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
ext4_orphan_file_add(handle_t * handle,struct inode * inode)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 */
ext4_orphan_add(handle_t * handle,struct inode * inode)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
1844978c659SJan Kara ext4_debug("superblock will point to %lu\n", inode->i_ino);
1854978c659SJan 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
ext4_orphan_file_del(handle_t * handle,struct inode * inode)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 */
ext4_orphan_del(handle_t * handle,struct inode * inode)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);
2544978c659SJan 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) {
2704978c659SJan 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
2894978c659SJan 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
ext4_quota_on_mount(struct super_block * sb,int type)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
ext4_process_orphan(struct inode * inode,int * nr_truncates,int * nr_orphans)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);
3354978c659SJan 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);
3564978c659SJan 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 */
ext4_orphan_cleanup(struct super_block * sb,struct ext4_super_block * es)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) {
3944978c659SJan 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, "
415*78742d4dSLuís Henriques "clearing orphan list.");
41625c6d98fSJan Kara es->s_last_orphan = 0;
41725c6d98fSJan Kara }
4184978c659SJan 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) {
4624978c659SJan 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
ext4_release_orphan_info(struct super_block * sb)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
ext4_orphan_block_tail(struct super_block * sb,struct buffer_head * bh)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
ext4_orphan_file_block_csum_verify(struct super_block * sb,struct buffer_head * bh)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 */
ext4_orphan_file_block_trigger(struct jbd2_buffer_trigger_type * triggers,struct buffer_head * bh,void * data,size_t size)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
ext4_init_orphan_info(struct super_block * sb)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
ext4_orphan_file_empty(struct super_block * sb)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