1 files changed, 136 insertions, 68 deletions

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 6134832baaaf..15bb81f8dac2 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -126,6 +126,19 @@ static unsigned char *__struct_ptr(struct f2fs_sb_info *sbi, int struct_type)
         return NULL;
 }
 
+static ssize_t lifetime_write_kbytes_show(struct f2fs_attr *a,
+                struct f2fs_sb_info *sbi, char *buf)
+{
+        struct super_block *sb = sbi->sb;
+
+        if (!sb->s_bdev->bd_part)
+                return snprintf(buf, PAGE_SIZE, "0\n");
+
+        return snprintf(buf, PAGE_SIZE, "%llu\n",
+                (unsigned long long)(sbi->kbytes_written +
+                        BD_PART_WRITTEN(sbi)));
+}
+
 static ssize_t f2fs_sbi_show(struct f2fs_attr *a,
                         struct f2fs_sb_info *sbi, char *buf)
 {
@@ -204,6 +217,9 @@ static struct f2fs_attr f2fs_attr_##_name = {			\
                 f2fs_sbi_show, f2fs_sbi_store,                  \
                 offsetof(struct struct_name, elname))
 
+#define F2FS_GENERAL_RO_ATTR(name) \
+static struct f2fs_attr f2fs_attr_##name = __ATTR(name, 0444, name##_show, NULL)
+
 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_min_sleep_time, min_sleep_time);
 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_max_sleep_time, max_sleep_time);
 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_no_gc_sleep_time, no_gc_sleep_time);
@@ -216,10 +232,12 @@ F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ipu_util, min_ipu_util);
 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_fsync_blocks, min_fsync_blocks);
 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ram_thresh, ram_thresh);
 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ra_nid_pages, ra_nid_pages);
+F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, dirty_nats_ratio, dirty_nats_ratio);
 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_victim_search, max_victim_search);
 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, dir_level, dir_level);
 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, cp_interval, interval_time[CP_TIME]);
 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, idle_interval, interval_time[REQ_TIME]);
+F2FS_GENERAL_RO_ATTR(lifetime_write_kbytes);
 
 #define ATTR_LIST(name) (&f2fs_attr_##name.attr)
 static struct attribute *f2fs_attrs[] = {
@@ -237,8 +255,10 @@ static struct attribute *f2fs_attrs[] = {
         ATTR_LIST(dir_level),
         ATTR_LIST(ram_thresh),
         ATTR_LIST(ra_nid_pages),
+        ATTR_LIST(dirty_nats_ratio),
         ATTR_LIST(cp_interval),
         ATTR_LIST(idle_interval),
+        ATTR_LIST(lifetime_write_kbytes),
         NULL,
 };
 
@@ -450,10 +470,6 @@ static struct inode *f2fs_alloc_inode(struct super_block *sb)
 
         /* Will be used by directory only */
         fi->i_dir_level = F2FS_SB(sb)->dir_level;
-
-#ifdef CONFIG_F2FS_FS_ENCRYPTION
-        fi->i_crypt_info = NULL;
-#endif
         return &fi->vfs_inode;
 }
 
@@ -474,7 +490,7 @@ static int f2fs_drop_inode(struct inode *inode)
 
                         /* some remained atomic pages should discarded */
                         if (f2fs_is_atomic_file(inode))
-                                commit_inmem_pages(inode, true);
+                                drop_inmem_pages(inode);
 
                         /* should remain fi->extent_tree for writepage */
                         f2fs_destroy_extent_node(inode);
@@ -487,11 +503,7 @@ static int f2fs_drop_inode(struct inode *inode)
 
                         sb_end_intwrite(inode->i_sb);
 
-#ifdef CONFIG_F2FS_FS_ENCRYPTION
-                        if (F2FS_I(inode)->i_crypt_info)
-                                f2fs_free_encryption_info(inode,
-                                        F2FS_I(inode)->i_crypt_info);
-#endif
+                        fscrypt_put_encryption_info(inode, NULL);
                         spin_lock(&inode->i_lock);
                         atomic_dec(&inode->i_count);
                 }
@@ -562,6 +574,10 @@ static void f2fs_put_super(struct super_block *sb)
         f2fs_leave_shrinker(sbi);
         mutex_unlock(&sbi->umount_mutex);
 
+        /* our cp_error case, we can wait for any writeback page */
+        if (get_pages(sbi, F2FS_WRITEBACK))
+                f2fs_flush_merged_bios(sbi);
+
         iput(sbi->node_inode);
         iput(sbi->meta_inode);
 
@@ -574,6 +590,8 @@ static void f2fs_put_super(struct super_block *sb)
         wait_for_completion(&sbi->s_kobj_unregister);
 
         sb->s_fs_info = NULL;
+        if (sbi->s_chksum_driver)
+                crypto_free_shash(sbi->s_chksum_driver);
         kfree(sbi->raw_super);
         kfree(sbi);
 }
@@ -766,8 +784,6 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
         bool need_stop_gc = false;
         bool no_extent_cache = !test_opt(sbi, EXTENT_CACHE);
 
-        sync_filesystem(sb);
-
         /*
          * Save the old mount options in case we
          * need to restore them.
@@ -775,6 +791,13 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
         org_mount_opt = sbi->mount_opt;
         active_logs = sbi->active_logs;
 
+        if (*flags & MS_RDONLY) {
+                set_opt(sbi, FASTBOOT);
+                set_sbi_flag(sbi, SBI_IS_DIRTY);
+        }
+
+        sync_filesystem(sb);
+
         sbi->mount_opt.opt = 0;
         default_options(sbi);
 
@@ -862,6 +885,41 @@ static struct super_operations f2fs_sops = {
         .remount_fs     = f2fs_remount,
 };
 
+#ifdef CONFIG_F2FS_FS_ENCRYPTION
+static int f2fs_get_context(struct inode *inode, void *ctx, size_t len)
+{
+        return f2fs_getxattr(inode, F2FS_XATTR_INDEX_ENCRYPTION,
+                                F2FS_XATTR_NAME_ENCRYPTION_CONTEXT,
+                                ctx, len, NULL);
+}
+
+static int f2fs_set_context(struct inode *inode, const void *ctx, size_t len,
+                                                        void *fs_data)
+{
+        return f2fs_setxattr(inode, F2FS_XATTR_INDEX_ENCRYPTION,
+                                F2FS_XATTR_NAME_ENCRYPTION_CONTEXT,
+                                ctx, len, fs_data, XATTR_CREATE);
+}
+
+static unsigned f2fs_max_namelen(struct inode *inode)
+{
+        return S_ISLNK(inode->i_mode) ?
+                        inode->i_sb->s_blocksize : F2FS_NAME_LEN;
+}
+
+static struct fscrypt_operations f2fs_cryptops = {
+        .get_context    = f2fs_get_context,
+        .set_context    = f2fs_set_context,
+        .is_encrypted   = f2fs_encrypted_inode,
+        .empty_dir      = f2fs_empty_dir,
+        .max_namelen    = f2fs_max_namelen,
+};
+#else
+static struct fscrypt_operations f2fs_cryptops = {
+        .is_encrypted   = f2fs_encrypted_inode,
+};
+#endif
+
 static struct inode *f2fs_nfs_get_inode(struct super_block *sb,
                 u64 ino, u32 generation)
 {
@@ -1074,7 +1132,7 @@ static int sanity_check_raw_super(struct super_block *sb,
         return 0;
 }
 
-static int sanity_check_ckpt(struct f2fs_sb_info *sbi)
+int sanity_check_ckpt(struct f2fs_sb_info *sbi)
 {
         unsigned int total, fsmeta;
         struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
@@ -1134,14 +1192,15 @@ static void init_sb_info(struct f2fs_sb_info *sbi)
 
 /*
  * Read f2fs raw super block.
- * Because we have two copies of super block, so read the first one at first,
- * if the first one is invalid, move to read the second one.
+ * Because we have two copies of super block, so read both of them
+ * to get the first valid one. If any one of them is broken, we pass
+ * them recovery flag back to the caller.
  */
 static int read_raw_super_block(struct super_block *sb,
                         struct f2fs_super_block **raw_super,
                         int *valid_super_block, int *recovery)
 {
-        int block = 0;
+        int block;
         struct buffer_head *bh;
         struct f2fs_super_block *super, *buf;
         int err = 0;
@@ -1149,50 +1208,48 @@ static int read_raw_super_block(struct super_block *sb,
         super = kzalloc(sizeof(struct f2fs_super_block), GFP_KERNEL);
         if (!super)
                 return -ENOMEM;
-retry:
-        bh = sb_bread(sb, block);
-        if (!bh) {
-                *recovery = 1;
-                f2fs_msg(sb, KERN_ERR, "Unable to read %dth superblock",
+
+        for (block = 0; block < 2; block++) {
+                bh = sb_bread(sb, block);
+                if (!bh) {
+                        f2fs_msg(sb, KERN_ERR, "Unable to read %dth superblock",
                                 block + 1);
-                err = -EIO;
-                goto next;
-        }
+                        err = -EIO;
+                        continue;
+                }
 
-        buf = (struct f2fs_super_block *)(bh->b_data + F2FS_SUPER_OFFSET);
+                buf = (struct f2fs_super_block *)
+                                (bh->b_data + F2FS_SUPER_OFFSET);
 
-        /* sanity checking of raw super */
-        if (sanity_check_raw_super(sb, buf)) {
-                brelse(bh);
-                *recovery = 1;
-                f2fs_msg(sb, KERN_ERR,
-                        "Can't find valid F2FS filesystem in %dth superblock",
-                                                                block + 1);
-                err = -EINVAL;
-                goto next;
-        }
+                /* sanity checking of raw super */
+                if (sanity_check_raw_super(sb, buf)) {
+                        f2fs_msg(sb, KERN_ERR,
+                                "Can't find valid F2FS filesystem in %dth superblock",
+                                block + 1);
+                        err = -EINVAL;
+                        brelse(bh);
+                        continue;
+                }
 
-        if (!*raw_super) {
-                memcpy(super, buf, sizeof(*super));
-                *valid_super_block = block;
-                *raw_super = super;
+                if (!*raw_super) {
+                        memcpy(super, buf, sizeof(*super));
+                        *valid_super_block = block;
+                        *raw_super = super;
+                }
+                brelse(bh);
         }
-        brelse(bh);
 
-next:
-        /* check the validity of the second superblock */
-        if (block == 0) {
-                block++;
-                goto retry;
-        }
+        /* Fail to read any one of the superblocks*/
+        if (err < 0)
+                *recovery = 1;
 
         /* No valid superblock */
-        if (!*raw_super) {
+        if (!*raw_super)
                 kfree(super);
-                return err;
-        }
+        else
+                err = 0;
 
-        return 0;
+        return err;
 }
 
 static int __f2fs_commit_super(struct f2fs_sb_info *sbi, int block)
@@ -1242,6 +1299,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
         bool retry = true, need_fsck = false;
         char *options = NULL;
         int recovery, i, valid_super_block;
+        struct curseg_info *seg_i;
 
 try_onemore:
         err = -EINVAL;
@@ -1254,6 +1312,15 @@ try_onemore:
         if (!sbi)
                 return -ENOMEM;
 
+        /* Load the checksum driver */
+        sbi->s_chksum_driver = crypto_alloc_shash("crc32", 0, 0);
+        if (IS_ERR(sbi->s_chksum_driver)) {
+                f2fs_msg(sb, KERN_ERR, "Cannot load crc32 driver.");
+                err = PTR_ERR(sbi->s_chksum_driver);
+                sbi->s_chksum_driver = NULL;
+                goto free_sbi;
+        }
+
         /* set a block size */
         if (unlikely(!sb_set_blocksize(sb, F2FS_BLKSIZE))) {
                 f2fs_msg(sb, KERN_ERR, "unable to set blocksize");
@@ -1285,6 +1352,7 @@ try_onemore:
         get_random_bytes(&sbi->s_next_generation, sizeof(u32));
 
         sb->s_op = &f2fs_sops;
+        sb->s_cop = &f2fs_cryptops;
         sb->s_xattr = f2fs_xattr_handlers;
         sb->s_export_op = &f2fs_export_ops;
         sb->s_magic = F2FS_SUPER_MAGIC;
@@ -1333,13 +1401,6 @@ try_onemore:
                 goto free_meta_inode;
         }
 
-        /* sanity checking of checkpoint */
-        err = -EINVAL;
-        if (sanity_check_ckpt(sbi)) {
-                f2fs_msg(sb, KERN_ERR, "Invalid F2FS checkpoint");
-                goto free_cp;
-        }
-
         sbi->total_valid_node_count =
                                 le32_to_cpu(sbi->ckpt->valid_node_count);
         sbi->total_valid_inode_count =
@@ -1372,6 +1433,17 @@ try_onemore:
                 goto free_nm;
         }
 
+        /* For write statistics */
+        if (sb->s_bdev->bd_part)
+                sbi->sectors_written_start =
+                        (u64)part_stat_read(sb->s_bdev->bd_part, sectors[1]);
+
+        /* Read accumulated write IO statistics if exists */
+        seg_i = CURSEG_I(sbi, CURSEG_HOT_NODE);
+        if (__exist_node_summaries(sbi))
+                sbi->kbytes_written =
+                        le64_to_cpu(seg_i->sum_blk->journal.info.kbytes_written);
+
         build_gc_manager(sbi);
 
         /* get an inode for node space */
@@ -1466,8 +1538,10 @@ try_onemore:
 
         /* recover broken superblock */
         if (recovery && !f2fs_readonly(sb) && !bdev_read_only(sb->s_bdev)) {
-                f2fs_msg(sb, KERN_INFO, "Recover invalid superblock");
-                f2fs_commit_super(sbi, true);
+                err = f2fs_commit_super(sbi, true);
+                f2fs_msg(sb, KERN_INFO,
+                        "Try to recover %dth superblock, ret: %ld",
+                        sbi->valid_super_block ? 1 : 2, err);
         }
 
         f2fs_update_time(sbi, CP_TIME);
@@ -1496,7 +1570,6 @@ free_nm:
         destroy_node_manager(sbi);
 free_sm:
         destroy_segment_manager(sbi);
-free_cp:
         kfree(sbi->ckpt);
 free_meta_inode:
         make_bad_inode(sbi->meta_inode);
@@ -1506,6 +1579,8 @@ free_options:
 free_sb_buf:
         kfree(raw_super);
 free_sbi:
+        if (sbi->s_chksum_driver)
+                crypto_free_shash(sbi->s_chksum_driver);
         kfree(sbi);
 
         /* give only one another chance */
@@ -1585,13 +1660,9 @@ static int __init init_f2fs_fs(void)
                 err = -ENOMEM;
                 goto free_extent_cache;
         }
-        err = f2fs_init_crypto();
-        if (err)
-                goto free_kset;
-
         err = register_shrinker(&f2fs_shrinker_info);
         if (err)
-                goto free_crypto;
+                goto free_kset;
 
         err = register_filesystem(&f2fs_fs_type);
         if (err)
@@ -1606,8 +1677,6 @@ free_filesystem:
         unregister_filesystem(&f2fs_fs_type);
 free_shrinker:
         unregister_shrinker(&f2fs_shrinker_info);
-free_crypto:
-        f2fs_exit_crypto();
 free_kset:
         kset_unregister(f2fs_kset);
 free_extent_cache:
@@ -1630,7 +1699,6 @@ static void __exit exit_f2fs_fs(void)
         f2fs_destroy_root_stats();
         unregister_shrinker(&f2fs_shrinker_info);
         unregister_filesystem(&f2fs_fs_type);
-        f2fs_exit_crypto();
         destroy_extent_cache();
         destroy_checkpoint_caches();
         destroy_segment_manager_caches();