125c6d98fSJan Kara /* 225c6d98fSJan Kara * Ext4 orphan inode handling 325c6d98fSJan Kara */ 425c6d98fSJan Kara #include <linux/fs.h> 525c6d98fSJan Kara #include <linux/quotaops.h> 625c6d98fSJan Kara #include <linux/buffer_head.h> 725c6d98fSJan Kara 825c6d98fSJan Kara #include "ext4.h" 925c6d98fSJan Kara #include "ext4_jbd2.h" 1025c6d98fSJan Kara 1102f310fcSJan Kara static int ext4_orphan_file_add(handle_t *handle, struct inode *inode) 1202f310fcSJan Kara { 134a79a98cSJan Kara int i, j, start; 1402f310fcSJan Kara struct ext4_orphan_info *oi = &EXT4_SB(inode->i_sb)->s_orphan_info; 1502f310fcSJan Kara int ret = 0; 164a79a98cSJan Kara bool found = false; 1702f310fcSJan Kara __le32 *bdata; 1802f310fcSJan Kara int inodes_per_ob = ext4_inodes_per_orphan_block(inode->i_sb); 194a79a98cSJan Kara int looped = 0; 2002f310fcSJan Kara 214a79a98cSJan Kara /* 224a79a98cSJan Kara * Find block with free orphan entry. Use CPU number for a naive hash 234a79a98cSJan Kara * for a search start in the orphan file 244a79a98cSJan Kara */ 254a79a98cSJan Kara start = raw_smp_processor_id()*13 % oi->of_blocks; 264a79a98cSJan Kara i = start; 274a79a98cSJan Kara do { 284a79a98cSJan Kara if (atomic_dec_if_positive(&oi->of_binfo[i].ob_free_entries) 294a79a98cSJan Kara >= 0) { 304a79a98cSJan Kara found = true; 314a79a98cSJan Kara break; 324a79a98cSJan Kara } 334a79a98cSJan Kara if (++i >= oi->of_blocks) 344a79a98cSJan Kara i = 0; 354a79a98cSJan Kara } while (i != start); 364a79a98cSJan Kara 374a79a98cSJan Kara if (!found) { 3802f310fcSJan Kara /* 3902f310fcSJan Kara * For now we don't grow or shrink orphan file. We just use 4002f310fcSJan Kara * whatever was allocated at mke2fs time. The additional 4102f310fcSJan Kara * credits we would have to reserve for each orphan inode 4202f310fcSJan Kara * operation just don't seem worth it. 4302f310fcSJan Kara */ 4402f310fcSJan Kara return -ENOSPC; 4502f310fcSJan Kara } 4602f310fcSJan Kara 4702f310fcSJan Kara ret = ext4_journal_get_write_access(handle, inode->i_sb, 4802f310fcSJan Kara oi->of_binfo[i].ob_bh, EXT4_JTR_ORPHAN_FILE); 494a79a98cSJan Kara if (ret) { 504a79a98cSJan Kara atomic_inc(&oi->of_binfo[i].ob_free_entries); 5102f310fcSJan Kara return ret; 524a79a98cSJan Kara } 5302f310fcSJan Kara 5402f310fcSJan Kara bdata = (__le32 *)(oi->of_binfo[i].ob_bh->b_data); 5502f310fcSJan Kara /* Find empty slot in a block */ 564a79a98cSJan Kara j = 0; 574a79a98cSJan Kara do { 584a79a98cSJan Kara if (looped) { 594a79a98cSJan Kara /* 604a79a98cSJan Kara * Did we walk through the block several times without 614a79a98cSJan Kara * finding free entry? It is theoretically possible 624a79a98cSJan Kara * if entries get constantly allocated and freed or 634a79a98cSJan Kara * if the block is corrupted. Avoid indefinite looping 644a79a98cSJan Kara * and bail. We'll use orphan list instead. 654a79a98cSJan Kara */ 664a79a98cSJan Kara if (looped > 3) { 674a79a98cSJan Kara atomic_inc(&oi->of_binfo[i].ob_free_entries); 684a79a98cSJan Kara return -ENOSPC; 694a79a98cSJan Kara } 704a79a98cSJan Kara cond_resched(); 714a79a98cSJan Kara } 724a79a98cSJan Kara while (bdata[j]) { 734a79a98cSJan Kara if (++j >= inodes_per_ob) { 744a79a98cSJan Kara j = 0; 754a79a98cSJan Kara looped++; 764a79a98cSJan Kara } 774a79a98cSJan Kara } 784a79a98cSJan Kara } while (cmpxchg(&bdata[j], (__le32)0, cpu_to_le32(inode->i_ino)) != 794a79a98cSJan Kara (__le32)0); 804a79a98cSJan Kara 8102f310fcSJan Kara EXT4_I(inode)->i_orphan_idx = i * inodes_per_ob + j; 8202f310fcSJan Kara ext4_set_inode_state(inode, EXT4_STATE_ORPHAN_FILE); 8302f310fcSJan Kara 8402f310fcSJan Kara return ext4_handle_dirty_metadata(handle, NULL, oi->of_binfo[i].ob_bh); 8502f310fcSJan Kara } 8602f310fcSJan Kara 8725c6d98fSJan Kara /* 8825c6d98fSJan Kara * ext4_orphan_add() links an unlinked or truncated inode into a list of 8925c6d98fSJan Kara * such inodes, starting at the superblock, in case we crash before the 9025c6d98fSJan Kara * file is closed/deleted, or in case the inode truncate spans multiple 9125c6d98fSJan Kara * transactions and the last transaction is not recovered after a crash. 9225c6d98fSJan Kara * 9325c6d98fSJan Kara * At filesystem recovery time, we walk this list deleting unlinked 9425c6d98fSJan Kara * inodes and truncating linked inodes in ext4_orphan_cleanup(). 9525c6d98fSJan Kara * 96f340b3d9Shongnanli * Orphan list manipulation functions must be called under i_rwsem unless 9725c6d98fSJan Kara * we are just creating the inode or deleting it. 9825c6d98fSJan Kara */ 9925c6d98fSJan Kara int ext4_orphan_add(handle_t *handle, struct inode *inode) 10025c6d98fSJan Kara { 10125c6d98fSJan Kara struct super_block *sb = inode->i_sb; 10225c6d98fSJan Kara struct ext4_sb_info *sbi = EXT4_SB(sb); 10325c6d98fSJan Kara struct ext4_iloc iloc; 10425c6d98fSJan Kara int err = 0, rc; 10525c6d98fSJan Kara bool dirty = false; 10625c6d98fSJan Kara 10725c6d98fSJan Kara if (!sbi->s_journal || is_bad_inode(inode)) 10825c6d98fSJan Kara return 0; 10925c6d98fSJan Kara 11025c6d98fSJan Kara WARN_ON_ONCE(!(inode->i_state & (I_NEW | I_FREEING)) && 11125c6d98fSJan Kara !inode_is_locked(inode)); 11225c6d98fSJan Kara /* 11302f310fcSJan Kara * Inode orphaned in orphan file or in orphan list? 11425c6d98fSJan Kara */ 11502f310fcSJan Kara if (ext4_test_inode_state(inode, EXT4_STATE_ORPHAN_FILE) || 11602f310fcSJan Kara !list_empty(&EXT4_I(inode)->i_orphan)) 11725c6d98fSJan Kara return 0; 11825c6d98fSJan Kara 11925c6d98fSJan Kara /* 12025c6d98fSJan Kara * Orphan handling is only valid for files with data blocks 12125c6d98fSJan Kara * being truncated, or files being unlinked. Note that we either 122f340b3d9Shongnanli * hold i_rwsem, or the inode can not be referenced from outside, 12325c6d98fSJan Kara * so i_nlink should not be bumped due to race 12425c6d98fSJan Kara */ 12525c6d98fSJan Kara ASSERT((S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || 12625c6d98fSJan Kara S_ISLNK(inode->i_mode)) || inode->i_nlink == 0); 12725c6d98fSJan Kara 12802f310fcSJan Kara if (sbi->s_orphan_info.of_blocks) { 12902f310fcSJan Kara err = ext4_orphan_file_add(handle, inode); 13002f310fcSJan Kara /* 13102f310fcSJan Kara * Fallback to normal orphan list of orphan file is 13202f310fcSJan Kara * out of space 13302f310fcSJan Kara */ 13402f310fcSJan Kara if (err != -ENOSPC) 13502f310fcSJan Kara return err; 13602f310fcSJan Kara } 13702f310fcSJan Kara 13825c6d98fSJan Kara BUFFER_TRACE(sbi->s_sbh, "get_write_access"); 13925c6d98fSJan Kara err = ext4_journal_get_write_access(handle, sb, sbi->s_sbh, 14025c6d98fSJan Kara EXT4_JTR_NONE); 14125c6d98fSJan Kara if (err) 14225c6d98fSJan Kara goto out; 14325c6d98fSJan Kara 14425c6d98fSJan Kara err = ext4_reserve_inode_write(handle, inode, &iloc); 14525c6d98fSJan Kara if (err) 14625c6d98fSJan Kara goto out; 14725c6d98fSJan Kara 14825c6d98fSJan Kara mutex_lock(&sbi->s_orphan_lock); 14925c6d98fSJan Kara /* 15025c6d98fSJan Kara * Due to previous errors inode may be already a part of on-disk 15125c6d98fSJan Kara * orphan list. If so skip on-disk list modification. 15225c6d98fSJan Kara */ 15325c6d98fSJan Kara if (!NEXT_ORPHAN(inode) || NEXT_ORPHAN(inode) > 15425c6d98fSJan Kara (le32_to_cpu(sbi->s_es->s_inodes_count))) { 15525c6d98fSJan Kara /* Insert this inode at the head of the on-disk orphan list */ 15625c6d98fSJan Kara NEXT_ORPHAN(inode) = le32_to_cpu(sbi->s_es->s_last_orphan); 15725c6d98fSJan Kara lock_buffer(sbi->s_sbh); 15825c6d98fSJan Kara sbi->s_es->s_last_orphan = cpu_to_le32(inode->i_ino); 15925c6d98fSJan Kara ext4_superblock_csum_set(sb); 16025c6d98fSJan Kara unlock_buffer(sbi->s_sbh); 16125c6d98fSJan Kara dirty = true; 16225c6d98fSJan Kara } 16325c6d98fSJan Kara list_add(&EXT4_I(inode)->i_orphan, &sbi->s_orphan); 16425c6d98fSJan Kara mutex_unlock(&sbi->s_orphan_lock); 16525c6d98fSJan Kara 16625c6d98fSJan Kara if (dirty) { 16725c6d98fSJan Kara err = ext4_handle_dirty_metadata(handle, NULL, sbi->s_sbh); 16825c6d98fSJan Kara rc = ext4_mark_iloc_dirty(handle, inode, &iloc); 16925c6d98fSJan Kara if (!err) 17025c6d98fSJan Kara err = rc; 17125c6d98fSJan Kara if (err) { 17225c6d98fSJan Kara /* 17325c6d98fSJan Kara * We have to remove inode from in-memory list if 17425c6d98fSJan Kara * addition to on disk orphan list failed. Stray orphan 17525c6d98fSJan Kara * list entries can cause panics at unmount time. 17625c6d98fSJan Kara */ 17725c6d98fSJan Kara mutex_lock(&sbi->s_orphan_lock); 17825c6d98fSJan Kara list_del_init(&EXT4_I(inode)->i_orphan); 17925c6d98fSJan Kara mutex_unlock(&sbi->s_orphan_lock); 18025c6d98fSJan Kara } 18125c6d98fSJan Kara } else 18225c6d98fSJan Kara brelse(iloc.bh); 18325c6d98fSJan Kara 184*4978c659SJan Kara ext4_debug("superblock will point to %lu\n", inode->i_ino); 185*4978c659SJan Kara ext4_debug("orphan inode %lu will point to %d\n", 18625c6d98fSJan Kara inode->i_ino, NEXT_ORPHAN(inode)); 18725c6d98fSJan Kara out: 18825c6d98fSJan Kara ext4_std_error(sb, err); 18925c6d98fSJan Kara return err; 19025c6d98fSJan Kara } 19125c6d98fSJan Kara 19202f310fcSJan Kara static int ext4_orphan_file_del(handle_t *handle, struct inode *inode) 19302f310fcSJan Kara { 19402f310fcSJan Kara struct ext4_orphan_info *oi = &EXT4_SB(inode->i_sb)->s_orphan_info; 19502f310fcSJan Kara __le32 *bdata; 19602f310fcSJan Kara int blk, off; 19702f310fcSJan Kara int inodes_per_ob = ext4_inodes_per_orphan_block(inode->i_sb); 19802f310fcSJan Kara int ret = 0; 19902f310fcSJan Kara 20002f310fcSJan Kara if (!handle) 20102f310fcSJan Kara goto out; 20202f310fcSJan Kara blk = EXT4_I(inode)->i_orphan_idx / inodes_per_ob; 20302f310fcSJan Kara off = EXT4_I(inode)->i_orphan_idx % inodes_per_ob; 20402f310fcSJan Kara if (WARN_ON_ONCE(blk >= oi->of_blocks)) 20502f310fcSJan Kara goto out; 20602f310fcSJan Kara 20702f310fcSJan Kara ret = ext4_journal_get_write_access(handle, inode->i_sb, 20802f310fcSJan Kara oi->of_binfo[blk].ob_bh, EXT4_JTR_ORPHAN_FILE); 20902f310fcSJan Kara if (ret) 21002f310fcSJan Kara goto out; 21102f310fcSJan Kara 21202f310fcSJan Kara bdata = (__le32 *)(oi->of_binfo[blk].ob_bh->b_data); 21302f310fcSJan Kara bdata[off] = 0; 2144a79a98cSJan Kara atomic_inc(&oi->of_binfo[blk].ob_free_entries); 21502f310fcSJan Kara ret = ext4_handle_dirty_metadata(handle, NULL, oi->of_binfo[blk].ob_bh); 21602f310fcSJan Kara out: 21702f310fcSJan Kara ext4_clear_inode_state(inode, EXT4_STATE_ORPHAN_FILE); 21802f310fcSJan Kara INIT_LIST_HEAD(&EXT4_I(inode)->i_orphan); 21902f310fcSJan Kara 22002f310fcSJan Kara return ret; 22102f310fcSJan Kara } 22202f310fcSJan Kara 22325c6d98fSJan Kara /* 22425c6d98fSJan Kara * ext4_orphan_del() removes an unlinked or truncated inode from the list 22525c6d98fSJan Kara * of such inodes stored on disk, because it is finally being cleaned up. 22625c6d98fSJan Kara */ 22725c6d98fSJan Kara int ext4_orphan_del(handle_t *handle, struct inode *inode) 22825c6d98fSJan Kara { 22925c6d98fSJan Kara struct list_head *prev; 23025c6d98fSJan Kara struct ext4_inode_info *ei = EXT4_I(inode); 23125c6d98fSJan Kara struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 23225c6d98fSJan Kara __u32 ino_next; 23325c6d98fSJan Kara struct ext4_iloc iloc; 23425c6d98fSJan Kara int err = 0; 23525c6d98fSJan Kara 23625c6d98fSJan Kara if (!sbi->s_journal && !(sbi->s_mount_state & EXT4_ORPHAN_FS)) 23725c6d98fSJan Kara return 0; 23825c6d98fSJan Kara 23925c6d98fSJan Kara WARN_ON_ONCE(!(inode->i_state & (I_NEW | I_FREEING)) && 24025c6d98fSJan Kara !inode_is_locked(inode)); 24102f310fcSJan Kara if (ext4_test_inode_state(inode, EXT4_STATE_ORPHAN_FILE)) 24202f310fcSJan Kara return ext4_orphan_file_del(handle, inode); 24302f310fcSJan Kara 24425c6d98fSJan Kara /* Do this quick check before taking global s_orphan_lock. */ 24525c6d98fSJan Kara if (list_empty(&ei->i_orphan)) 24625c6d98fSJan Kara return 0; 24725c6d98fSJan Kara 24825c6d98fSJan Kara if (handle) { 24925c6d98fSJan Kara /* Grab inode buffer early before taking global s_orphan_lock */ 25025c6d98fSJan Kara err = ext4_reserve_inode_write(handle, inode, &iloc); 25125c6d98fSJan Kara } 25225c6d98fSJan Kara 25325c6d98fSJan Kara mutex_lock(&sbi->s_orphan_lock); 254*4978c659SJan Kara ext4_debug("remove inode %lu from orphan list\n", inode->i_ino); 25525c6d98fSJan Kara 25625c6d98fSJan Kara prev = ei->i_orphan.prev; 25725c6d98fSJan Kara list_del_init(&ei->i_orphan); 25825c6d98fSJan Kara 25925c6d98fSJan Kara /* If we're on an error path, we may not have a valid 26025c6d98fSJan Kara * transaction handle with which to update the orphan list on 26125c6d98fSJan Kara * disk, but we still need to remove the inode from the linked 26225c6d98fSJan Kara * list in memory. */ 26325c6d98fSJan Kara if (!handle || err) { 26425c6d98fSJan Kara mutex_unlock(&sbi->s_orphan_lock); 26525c6d98fSJan Kara goto out_err; 26625c6d98fSJan Kara } 26725c6d98fSJan Kara 26825c6d98fSJan Kara ino_next = NEXT_ORPHAN(inode); 26925c6d98fSJan Kara if (prev == &sbi->s_orphan) { 270*4978c659SJan Kara ext4_debug("superblock will point to %u\n", ino_next); 27125c6d98fSJan Kara BUFFER_TRACE(sbi->s_sbh, "get_write_access"); 27225c6d98fSJan Kara err = ext4_journal_get_write_access(handle, inode->i_sb, 27325c6d98fSJan Kara sbi->s_sbh, EXT4_JTR_NONE); 27425c6d98fSJan Kara if (err) { 27525c6d98fSJan Kara mutex_unlock(&sbi->s_orphan_lock); 27625c6d98fSJan Kara goto out_brelse; 27725c6d98fSJan Kara } 27825c6d98fSJan Kara lock_buffer(sbi->s_sbh); 27925c6d98fSJan Kara sbi->s_es->s_last_orphan = cpu_to_le32(ino_next); 28025c6d98fSJan Kara ext4_superblock_csum_set(inode->i_sb); 28125c6d98fSJan Kara unlock_buffer(sbi->s_sbh); 28225c6d98fSJan Kara mutex_unlock(&sbi->s_orphan_lock); 28325c6d98fSJan Kara err = ext4_handle_dirty_metadata(handle, NULL, sbi->s_sbh); 28425c6d98fSJan Kara } else { 28525c6d98fSJan Kara struct ext4_iloc iloc2; 28625c6d98fSJan Kara struct inode *i_prev = 28725c6d98fSJan Kara &list_entry(prev, struct ext4_inode_info, i_orphan)->vfs_inode; 28825c6d98fSJan Kara 289*4978c659SJan Kara ext4_debug("orphan inode %lu will point to %u\n", 29025c6d98fSJan Kara i_prev->i_ino, ino_next); 29125c6d98fSJan Kara err = ext4_reserve_inode_write(handle, i_prev, &iloc2); 29225c6d98fSJan Kara if (err) { 29325c6d98fSJan Kara mutex_unlock(&sbi->s_orphan_lock); 29425c6d98fSJan Kara goto out_brelse; 29525c6d98fSJan Kara } 29625c6d98fSJan Kara NEXT_ORPHAN(i_prev) = ino_next; 29725c6d98fSJan Kara err = ext4_mark_iloc_dirty(handle, i_prev, &iloc2); 29825c6d98fSJan Kara mutex_unlock(&sbi->s_orphan_lock); 29925c6d98fSJan Kara } 30025c6d98fSJan Kara if (err) 30125c6d98fSJan Kara goto out_brelse; 30225c6d98fSJan Kara NEXT_ORPHAN(inode) = 0; 30325c6d98fSJan Kara err = ext4_mark_iloc_dirty(handle, inode, &iloc); 30425c6d98fSJan Kara out_err: 30525c6d98fSJan Kara ext4_std_error(inode->i_sb, err); 30625c6d98fSJan Kara return err; 30725c6d98fSJan Kara 30825c6d98fSJan Kara out_brelse: 30925c6d98fSJan Kara brelse(iloc.bh); 31025c6d98fSJan Kara goto out_err; 31125c6d98fSJan Kara } 31225c6d98fSJan Kara 31325c6d98fSJan Kara #ifdef CONFIG_QUOTA 31425c6d98fSJan Kara static int ext4_quota_on_mount(struct super_block *sb, int type) 31525c6d98fSJan Kara { 31625c6d98fSJan Kara return dquot_quota_on_mount(sb, 31725c6d98fSJan Kara rcu_dereference_protected(EXT4_SB(sb)->s_qf_names[type], 31825c6d98fSJan Kara lockdep_is_held(&sb->s_umount)), 31925c6d98fSJan Kara EXT4_SB(sb)->s_jquota_fmt, type); 32025c6d98fSJan Kara } 32125c6d98fSJan Kara #endif 32225c6d98fSJan Kara 32302f310fcSJan Kara static void ext4_process_orphan(struct inode *inode, 32402f310fcSJan Kara int *nr_truncates, int *nr_orphans) 32502f310fcSJan Kara { 32602f310fcSJan Kara struct super_block *sb = inode->i_sb; 32702f310fcSJan Kara int ret; 32802f310fcSJan Kara 32902f310fcSJan Kara dquot_initialize(inode); 33002f310fcSJan Kara if (inode->i_nlink) { 33102f310fcSJan Kara if (test_opt(sb, DEBUG)) 33202f310fcSJan Kara ext4_msg(sb, KERN_DEBUG, 33302f310fcSJan Kara "%s: truncating inode %lu to %lld bytes", 33402f310fcSJan Kara __func__, inode->i_ino, inode->i_size); 335*4978c659SJan Kara ext4_debug("truncating inode %lu to %lld bytes\n", 33602f310fcSJan Kara inode->i_ino, inode->i_size); 33702f310fcSJan Kara inode_lock(inode); 33802f310fcSJan Kara truncate_inode_pages(inode->i_mapping, inode->i_size); 33902f310fcSJan Kara ret = ext4_truncate(inode); 34002f310fcSJan Kara if (ret) { 34102f310fcSJan Kara /* 34202f310fcSJan Kara * We need to clean up the in-core orphan list 34302f310fcSJan Kara * manually if ext4_truncate() failed to get a 34402f310fcSJan Kara * transaction handle. 34502f310fcSJan Kara */ 34602f310fcSJan Kara ext4_orphan_del(NULL, inode); 34702f310fcSJan Kara ext4_std_error(inode->i_sb, ret); 34802f310fcSJan Kara } 34902f310fcSJan Kara inode_unlock(inode); 35002f310fcSJan Kara (*nr_truncates)++; 35102f310fcSJan Kara } else { 35202f310fcSJan Kara if (test_opt(sb, DEBUG)) 35302f310fcSJan Kara ext4_msg(sb, KERN_DEBUG, 35402f310fcSJan Kara "%s: deleting unreferenced inode %lu", 35502f310fcSJan Kara __func__, inode->i_ino); 356*4978c659SJan Kara ext4_debug("deleting unreferenced inode %lu\n", 35702f310fcSJan Kara inode->i_ino); 35802f310fcSJan Kara (*nr_orphans)++; 35902f310fcSJan Kara } 36002f310fcSJan Kara iput(inode); /* The delete magic happens here! */ 36102f310fcSJan Kara } 36202f310fcSJan Kara 36325c6d98fSJan Kara /* ext4_orphan_cleanup() walks a singly-linked list of inodes (starting at 36425c6d98fSJan Kara * the superblock) which were deleted from all directories, but held open by 36525c6d98fSJan Kara * a process at the time of a crash. We walk the list and try to delete these 36625c6d98fSJan Kara * inodes at recovery time (only with a read-write filesystem). 36725c6d98fSJan Kara * 36825c6d98fSJan Kara * In order to keep the orphan inode chain consistent during traversal (in 36925c6d98fSJan Kara * case of crash during recovery), we link each inode into the superblock 37025c6d98fSJan Kara * orphan list_head and handle it the same way as an inode deletion during 37125c6d98fSJan Kara * normal operation (which journals the operations for us). 37225c6d98fSJan Kara * 37325c6d98fSJan Kara * We only do an iget() and an iput() on each inode, which is very safe if we 37425c6d98fSJan Kara * accidentally point at an in-use or already deleted inode. The worst that 37525c6d98fSJan Kara * can happen in this case is that we get a "bit already cleared" message from 37625c6d98fSJan Kara * ext4_free_inode(). The only reason we would point at a wrong inode is if 37725c6d98fSJan Kara * e2fsck was run on this filesystem, and it must have already done the orphan 37825c6d98fSJan Kara * inode cleanup for us, so we can safely abort without any further action. 37925c6d98fSJan Kara */ 38025c6d98fSJan Kara void ext4_orphan_cleanup(struct super_block *sb, struct ext4_super_block *es) 38125c6d98fSJan Kara { 38225c6d98fSJan Kara unsigned int s_flags = sb->s_flags; 38302f310fcSJan Kara int nr_orphans = 0, nr_truncates = 0; 38402f310fcSJan Kara struct inode *inode; 38502f310fcSJan Kara int i, j; 38625c6d98fSJan Kara #ifdef CONFIG_QUOTA 38725c6d98fSJan Kara int quota_update = 0; 38825c6d98fSJan Kara #endif 38902f310fcSJan Kara __le32 *bdata; 39002f310fcSJan Kara struct ext4_orphan_info *oi = &EXT4_SB(sb)->s_orphan_info; 39102f310fcSJan Kara int inodes_per_ob = ext4_inodes_per_orphan_block(sb); 39202f310fcSJan Kara 39302f310fcSJan Kara if (!es->s_last_orphan && !oi->of_blocks) { 394*4978c659SJan Kara ext4_debug("no orphan inodes to clean up\n"); 39525c6d98fSJan Kara return; 39625c6d98fSJan Kara } 39725c6d98fSJan Kara 39825c6d98fSJan Kara if (bdev_read_only(sb->s_bdev)) { 39925c6d98fSJan Kara ext4_msg(sb, KERN_ERR, "write access " 40025c6d98fSJan Kara "unavailable, skipping orphan cleanup"); 40125c6d98fSJan Kara return; 40225c6d98fSJan Kara } 40325c6d98fSJan Kara 40425c6d98fSJan Kara /* Check if feature set would not allow a r/w mount */ 40525c6d98fSJan Kara if (!ext4_feature_set_ok(sb, 0)) { 40625c6d98fSJan Kara ext4_msg(sb, KERN_INFO, "Skipping orphan cleanup due to " 40725c6d98fSJan Kara "unknown ROCOMPAT features"); 40825c6d98fSJan Kara return; 40925c6d98fSJan Kara } 41025c6d98fSJan Kara 41125c6d98fSJan Kara if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) { 41225c6d98fSJan Kara /* don't clear list on RO mount w/ errors */ 41325c6d98fSJan Kara if (es->s_last_orphan && !(s_flags & SB_RDONLY)) { 41425c6d98fSJan Kara ext4_msg(sb, KERN_INFO, "Errors on filesystem, " 41525c6d98fSJan Kara "clearing orphan list.\n"); 41625c6d98fSJan Kara es->s_last_orphan = 0; 41725c6d98fSJan Kara } 418*4978c659SJan Kara ext4_debug("Skipping orphan recovery on fs with errors.\n"); 41925c6d98fSJan Kara return; 42025c6d98fSJan Kara } 42125c6d98fSJan Kara 42225c6d98fSJan Kara if (s_flags & SB_RDONLY) { 42325c6d98fSJan Kara ext4_msg(sb, KERN_INFO, "orphan cleanup on readonly fs"); 42425c6d98fSJan Kara sb->s_flags &= ~SB_RDONLY; 42525c6d98fSJan Kara } 42625c6d98fSJan Kara #ifdef CONFIG_QUOTA 42725c6d98fSJan Kara /* 42825c6d98fSJan Kara * Turn on quotas which were not enabled for read-only mounts if 42925c6d98fSJan Kara * filesystem has quota feature, so that they are updated correctly. 43025c6d98fSJan Kara */ 43125c6d98fSJan Kara if (ext4_has_feature_quota(sb) && (s_flags & SB_RDONLY)) { 43225c6d98fSJan Kara int ret = ext4_enable_quotas(sb); 43325c6d98fSJan Kara 43425c6d98fSJan Kara if (!ret) 43525c6d98fSJan Kara quota_update = 1; 43625c6d98fSJan Kara else 43725c6d98fSJan Kara ext4_msg(sb, KERN_ERR, 43825c6d98fSJan Kara "Cannot turn on quotas: error %d", ret); 43925c6d98fSJan Kara } 44025c6d98fSJan Kara 44125c6d98fSJan Kara /* Turn on journaled quotas used for old sytle */ 44225c6d98fSJan Kara for (i = 0; i < EXT4_MAXQUOTAS; i++) { 44325c6d98fSJan Kara if (EXT4_SB(sb)->s_qf_names[i]) { 44425c6d98fSJan Kara int ret = ext4_quota_on_mount(sb, i); 44525c6d98fSJan Kara 44625c6d98fSJan Kara if (!ret) 44725c6d98fSJan Kara quota_update = 1; 44825c6d98fSJan Kara else 44925c6d98fSJan Kara ext4_msg(sb, KERN_ERR, 45025c6d98fSJan Kara "Cannot turn on journaled " 45125c6d98fSJan Kara "quota: type %d: error %d", i, ret); 45225c6d98fSJan Kara } 45325c6d98fSJan Kara } 45425c6d98fSJan Kara #endif 45525c6d98fSJan Kara 45625c6d98fSJan Kara while (es->s_last_orphan) { 45725c6d98fSJan Kara /* 45825c6d98fSJan Kara * We may have encountered an error during cleanup; if 45925c6d98fSJan Kara * so, skip the rest. 46025c6d98fSJan Kara */ 46125c6d98fSJan Kara if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) { 462*4978c659SJan Kara ext4_debug("Skipping orphan recovery on fs with errors.\n"); 46325c6d98fSJan Kara es->s_last_orphan = 0; 46425c6d98fSJan Kara break; 46525c6d98fSJan Kara } 46625c6d98fSJan Kara 46725c6d98fSJan Kara inode = ext4_orphan_get(sb, le32_to_cpu(es->s_last_orphan)); 46825c6d98fSJan Kara if (IS_ERR(inode)) { 46925c6d98fSJan Kara es->s_last_orphan = 0; 47025c6d98fSJan Kara break; 47125c6d98fSJan Kara } 47225c6d98fSJan Kara 47325c6d98fSJan Kara list_add(&EXT4_I(inode)->i_orphan, &EXT4_SB(sb)->s_orphan); 47402f310fcSJan Kara ext4_process_orphan(inode, &nr_truncates, &nr_orphans); 47525c6d98fSJan Kara } 47602f310fcSJan Kara 47702f310fcSJan Kara for (i = 0; i < oi->of_blocks; i++) { 47802f310fcSJan Kara bdata = (__le32 *)(oi->of_binfo[i].ob_bh->b_data); 47902f310fcSJan Kara for (j = 0; j < inodes_per_ob; j++) { 48002f310fcSJan Kara if (!bdata[j]) 48102f310fcSJan Kara continue; 48202f310fcSJan Kara inode = ext4_orphan_get(sb, le32_to_cpu(bdata[j])); 48302f310fcSJan Kara if (IS_ERR(inode)) 48402f310fcSJan Kara continue; 48502f310fcSJan Kara ext4_set_inode_state(inode, EXT4_STATE_ORPHAN_FILE); 48602f310fcSJan Kara EXT4_I(inode)->i_orphan_idx = i * inodes_per_ob + j; 48702f310fcSJan Kara ext4_process_orphan(inode, &nr_truncates, &nr_orphans); 48825c6d98fSJan Kara } 48925c6d98fSJan Kara } 49025c6d98fSJan Kara 49125c6d98fSJan Kara #define PLURAL(x) (x), ((x) == 1) ? "" : "s" 49225c6d98fSJan Kara 49325c6d98fSJan Kara if (nr_orphans) 49425c6d98fSJan Kara ext4_msg(sb, KERN_INFO, "%d orphan inode%s deleted", 49525c6d98fSJan Kara PLURAL(nr_orphans)); 49625c6d98fSJan Kara if (nr_truncates) 49725c6d98fSJan Kara ext4_msg(sb, KERN_INFO, "%d truncate%s cleaned up", 49825c6d98fSJan Kara PLURAL(nr_truncates)); 49925c6d98fSJan Kara #ifdef CONFIG_QUOTA 50025c6d98fSJan Kara /* Turn off quotas if they were enabled for orphan cleanup */ 50125c6d98fSJan Kara if (quota_update) { 50225c6d98fSJan Kara for (i = 0; i < EXT4_MAXQUOTAS; i++) { 50325c6d98fSJan Kara if (sb_dqopt(sb)->files[i]) 50425c6d98fSJan Kara dquot_quota_off(sb, i); 50525c6d98fSJan Kara } 50625c6d98fSJan Kara } 50725c6d98fSJan Kara #endif 50825c6d98fSJan Kara sb->s_flags = s_flags; /* Restore SB_RDONLY status */ 50925c6d98fSJan Kara } 51002f310fcSJan Kara 51102f310fcSJan Kara void ext4_release_orphan_info(struct super_block *sb) 51202f310fcSJan Kara { 51302f310fcSJan Kara int i; 51402f310fcSJan Kara struct ext4_orphan_info *oi = &EXT4_SB(sb)->s_orphan_info; 51502f310fcSJan Kara 51602f310fcSJan Kara if (!oi->of_blocks) 51702f310fcSJan Kara return; 51802f310fcSJan Kara for (i = 0; i < oi->of_blocks; i++) 51902f310fcSJan Kara brelse(oi->of_binfo[i].ob_bh); 52002f310fcSJan Kara kfree(oi->of_binfo); 52102f310fcSJan Kara } 52202f310fcSJan Kara 52302f310fcSJan Kara static struct ext4_orphan_block_tail *ext4_orphan_block_tail( 52402f310fcSJan Kara struct super_block *sb, 52502f310fcSJan Kara struct buffer_head *bh) 52602f310fcSJan Kara { 52702f310fcSJan Kara return (struct ext4_orphan_block_tail *)(bh->b_data + sb->s_blocksize - 52802f310fcSJan Kara sizeof(struct ext4_orphan_block_tail)); 52902f310fcSJan Kara } 53002f310fcSJan Kara 53102f310fcSJan Kara static int ext4_orphan_file_block_csum_verify(struct super_block *sb, 53202f310fcSJan Kara struct buffer_head *bh) 53302f310fcSJan Kara { 53402f310fcSJan Kara __u32 calculated; 53502f310fcSJan Kara int inodes_per_ob = ext4_inodes_per_orphan_block(sb); 53602f310fcSJan Kara struct ext4_orphan_info *oi = &EXT4_SB(sb)->s_orphan_info; 53702f310fcSJan Kara struct ext4_orphan_block_tail *ot; 53802f310fcSJan Kara __le64 dsk_block_nr = cpu_to_le64(bh->b_blocknr); 53902f310fcSJan Kara 54002f310fcSJan Kara if (!ext4_has_metadata_csum(sb)) 54102f310fcSJan Kara return 1; 54202f310fcSJan Kara 54302f310fcSJan Kara ot = ext4_orphan_block_tail(sb, bh); 54402f310fcSJan Kara calculated = ext4_chksum(EXT4_SB(sb), oi->of_csum_seed, 54502f310fcSJan Kara (__u8 *)&dsk_block_nr, sizeof(dsk_block_nr)); 54602f310fcSJan Kara calculated = ext4_chksum(EXT4_SB(sb), calculated, (__u8 *)bh->b_data, 54702f310fcSJan Kara inodes_per_ob * sizeof(__u32)); 54802f310fcSJan Kara return le32_to_cpu(ot->ob_checksum) == calculated; 54902f310fcSJan Kara } 55002f310fcSJan Kara 55102f310fcSJan Kara /* This gets called only when checksumming is enabled */ 55202f310fcSJan Kara void ext4_orphan_file_block_trigger(struct jbd2_buffer_trigger_type *triggers, 55302f310fcSJan Kara struct buffer_head *bh, 55402f310fcSJan Kara void *data, size_t size) 55502f310fcSJan Kara { 55602f310fcSJan Kara struct super_block *sb = EXT4_TRIGGER(triggers)->sb; 55702f310fcSJan Kara __u32 csum; 55802f310fcSJan Kara int inodes_per_ob = ext4_inodes_per_orphan_block(sb); 55902f310fcSJan Kara struct ext4_orphan_info *oi = &EXT4_SB(sb)->s_orphan_info; 56002f310fcSJan Kara struct ext4_orphan_block_tail *ot; 56102f310fcSJan Kara __le64 dsk_block_nr = cpu_to_le64(bh->b_blocknr); 56202f310fcSJan Kara 56302f310fcSJan Kara csum = ext4_chksum(EXT4_SB(sb), oi->of_csum_seed, 56402f310fcSJan Kara (__u8 *)&dsk_block_nr, sizeof(dsk_block_nr)); 56502f310fcSJan Kara csum = ext4_chksum(EXT4_SB(sb), csum, (__u8 *)data, 56602f310fcSJan Kara inodes_per_ob * sizeof(__u32)); 56702f310fcSJan Kara ot = ext4_orphan_block_tail(sb, bh); 56802f310fcSJan Kara ot->ob_checksum = cpu_to_le32(csum); 56902f310fcSJan Kara } 57002f310fcSJan Kara 57102f310fcSJan Kara int ext4_init_orphan_info(struct super_block *sb) 57202f310fcSJan Kara { 57302f310fcSJan Kara struct ext4_orphan_info *oi = &EXT4_SB(sb)->s_orphan_info; 57402f310fcSJan Kara struct inode *inode; 57502f310fcSJan Kara int i, j; 57602f310fcSJan Kara int ret; 57702f310fcSJan Kara int free; 57802f310fcSJan Kara __le32 *bdata; 57902f310fcSJan Kara int inodes_per_ob = ext4_inodes_per_orphan_block(sb); 58002f310fcSJan Kara struct ext4_orphan_block_tail *ot; 58102f310fcSJan Kara ino_t orphan_ino = le32_to_cpu(EXT4_SB(sb)->s_es->s_orphan_file_inum); 58202f310fcSJan Kara 58302f310fcSJan Kara if (!ext4_has_feature_orphan_file(sb)) 58402f310fcSJan Kara return 0; 58502f310fcSJan Kara 58602f310fcSJan Kara inode = ext4_iget(sb, orphan_ino, EXT4_IGET_SPECIAL); 58702f310fcSJan Kara if (IS_ERR(inode)) { 58802f310fcSJan Kara ext4_msg(sb, KERN_ERR, "get orphan inode failed"); 58902f310fcSJan Kara return PTR_ERR(inode); 59002f310fcSJan Kara } 59102f310fcSJan Kara oi->of_blocks = inode->i_size >> sb->s_blocksize_bits; 59202f310fcSJan Kara oi->of_csum_seed = EXT4_I(inode)->i_csum_seed; 59302f310fcSJan Kara oi->of_binfo = kmalloc(oi->of_blocks*sizeof(struct ext4_orphan_block), 59402f310fcSJan Kara GFP_KERNEL); 59502f310fcSJan Kara if (!oi->of_binfo) { 59602f310fcSJan Kara ret = -ENOMEM; 59702f310fcSJan Kara goto out_put; 59802f310fcSJan Kara } 59902f310fcSJan Kara for (i = 0; i < oi->of_blocks; i++) { 60002f310fcSJan Kara oi->of_binfo[i].ob_bh = ext4_bread(NULL, inode, i, 0); 60102f310fcSJan Kara if (IS_ERR(oi->of_binfo[i].ob_bh)) { 60202f310fcSJan Kara ret = PTR_ERR(oi->of_binfo[i].ob_bh); 60302f310fcSJan Kara goto out_free; 60402f310fcSJan Kara } 60502f310fcSJan Kara if (!oi->of_binfo[i].ob_bh) { 60602f310fcSJan Kara ret = -EIO; 60702f310fcSJan Kara goto out_free; 60802f310fcSJan Kara } 60902f310fcSJan Kara ot = ext4_orphan_block_tail(sb, oi->of_binfo[i].ob_bh); 61002f310fcSJan Kara if (le32_to_cpu(ot->ob_magic) != EXT4_ORPHAN_BLOCK_MAGIC) { 61102f310fcSJan Kara ext4_error(sb, "orphan file block %d: bad magic", i); 61202f310fcSJan Kara ret = -EIO; 61302f310fcSJan Kara goto out_free; 61402f310fcSJan Kara } 61502f310fcSJan Kara if (!ext4_orphan_file_block_csum_verify(sb, 61602f310fcSJan Kara oi->of_binfo[i].ob_bh)) { 61702f310fcSJan Kara ext4_error(sb, "orphan file block %d: bad checksum", i); 61802f310fcSJan Kara ret = -EIO; 61902f310fcSJan Kara goto out_free; 62002f310fcSJan Kara } 62102f310fcSJan Kara bdata = (__le32 *)(oi->of_binfo[i].ob_bh->b_data); 62202f310fcSJan Kara free = 0; 62302f310fcSJan Kara for (j = 0; j < inodes_per_ob; j++) 62402f310fcSJan Kara if (bdata[j] == 0) 62502f310fcSJan Kara free++; 6264a79a98cSJan Kara atomic_set(&oi->of_binfo[i].ob_free_entries, free); 62702f310fcSJan Kara } 62802f310fcSJan Kara iput(inode); 62902f310fcSJan Kara return 0; 63002f310fcSJan Kara out_free: 63102f310fcSJan Kara for (i--; i >= 0; i--) 63202f310fcSJan Kara brelse(oi->of_binfo[i].ob_bh); 63302f310fcSJan Kara kfree(oi->of_binfo); 63402f310fcSJan Kara out_put: 63502f310fcSJan Kara iput(inode); 63602f310fcSJan Kara return ret; 63702f310fcSJan Kara } 63802f310fcSJan Kara 63902f310fcSJan Kara int ext4_orphan_file_empty(struct super_block *sb) 64002f310fcSJan Kara { 64102f310fcSJan Kara struct ext4_orphan_info *oi = &EXT4_SB(sb)->s_orphan_info; 64202f310fcSJan Kara int i; 64302f310fcSJan Kara int inodes_per_ob = ext4_inodes_per_orphan_block(sb); 64402f310fcSJan Kara 64502f310fcSJan Kara if (!ext4_has_feature_orphan_file(sb)) 64602f310fcSJan Kara return 1; 64702f310fcSJan Kara for (i = 0; i < oi->of_blocks; i++) 6484a79a98cSJan Kara if (atomic_read(&oi->of_binfo[i].ob_free_entries) != 6494a79a98cSJan Kara inodes_per_ob) 65002f310fcSJan Kara return 0; 65102f310fcSJan Kara return 1; 65202f310fcSJan Kara } 653