2012-11-29 11:28:09 +07:00
|
|
|
/*
|
2012-11-02 15:07:47 +07:00
|
|
|
* fs/f2fs/super.c
|
|
|
|
*
|
|
|
|
* Copyright (c) 2012 Samsung Electronics Co., Ltd.
|
|
|
|
* http://www.samsung.com/
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/statfs.h>
|
|
|
|
#include <linux/buffer_head.h>
|
|
|
|
#include <linux/backing-dev.h>
|
|
|
|
#include <linux/kthread.h>
|
|
|
|
#include <linux/parser.h>
|
|
|
|
#include <linux/mount.h>
|
|
|
|
#include <linux/seq_file.h>
|
2013-06-28 10:47:01 +07:00
|
|
|
#include <linux/proc_fs.h>
|
2012-11-02 15:07:47 +07:00
|
|
|
#include <linux/random.h>
|
|
|
|
#include <linux/exportfs.h>
|
2013-03-17 15:26:14 +07:00
|
|
|
#include <linux/blkdev.h>
|
2012-11-02 15:07:47 +07:00
|
|
|
#include <linux/f2fs_fs.h>
|
2013-08-04 21:09:40 +07:00
|
|
|
#include <linux/sysfs.h>
|
2012-11-02 15:07:47 +07:00
|
|
|
|
|
|
|
#include "f2fs.h"
|
|
|
|
#include "node.h"
|
2013-03-31 11:26:03 +07:00
|
|
|
#include "segment.h"
|
2012-11-02 15:07:47 +07:00
|
|
|
#include "xattr.h"
|
2013-08-04 21:09:40 +07:00
|
|
|
#include "gc.h"
|
2012-11-02 15:07:47 +07:00
|
|
|
|
2013-04-19 23:28:40 +07:00
|
|
|
#define CREATE_TRACE_POINTS
|
|
|
|
#include <trace/events/f2fs.h>
|
|
|
|
|
2013-06-28 10:47:01 +07:00
|
|
|
static struct proc_dir_entry *f2fs_proc_root;
|
2012-11-02 15:07:47 +07:00
|
|
|
static struct kmem_cache *f2fs_inode_cachep;
|
2013-08-04 21:09:40 +07:00
|
|
|
static struct kset *f2fs_kset;
|
2012-11-02 15:07:47 +07:00
|
|
|
|
|
|
|
enum {
|
2013-06-16 07:48:48 +07:00
|
|
|
Opt_gc_background,
|
2012-11-02 15:07:47 +07:00
|
|
|
Opt_disable_roll_forward,
|
|
|
|
Opt_discard,
|
|
|
|
Opt_noheap,
|
2013-10-07 09:36:20 +07:00
|
|
|
Opt_user_xattr,
|
2012-11-02 15:07:47 +07:00
|
|
|
Opt_nouser_xattr,
|
2013-10-07 09:36:20 +07:00
|
|
|
Opt_acl,
|
2012-11-02 15:07:47 +07:00
|
|
|
Opt_noacl,
|
|
|
|
Opt_active_logs,
|
|
|
|
Opt_disable_ext_identify,
|
2013-08-08 13:16:22 +07:00
|
|
|
Opt_inline_xattr,
|
2013-11-10 22:13:17 +07:00
|
|
|
Opt_inline_data,
|
2012-11-02 15:07:47 +07:00
|
|
|
Opt_err,
|
|
|
|
};
|
|
|
|
|
|
|
|
static match_table_t f2fs_tokens = {
|
2013-06-16 07:48:48 +07:00
|
|
|
{Opt_gc_background, "background_gc=%s"},
|
2012-11-02 15:07:47 +07:00
|
|
|
{Opt_disable_roll_forward, "disable_roll_forward"},
|
|
|
|
{Opt_discard, "discard"},
|
|
|
|
{Opt_noheap, "no_heap"},
|
2013-10-07 09:36:20 +07:00
|
|
|
{Opt_user_xattr, "user_xattr"},
|
2012-11-02 15:07:47 +07:00
|
|
|
{Opt_nouser_xattr, "nouser_xattr"},
|
2013-10-07 09:36:20 +07:00
|
|
|
{Opt_acl, "acl"},
|
2012-11-02 15:07:47 +07:00
|
|
|
{Opt_noacl, "noacl"},
|
|
|
|
{Opt_active_logs, "active_logs=%u"},
|
|
|
|
{Opt_disable_ext_identify, "disable_ext_identify"},
|
2013-08-08 13:16:22 +07:00
|
|
|
{Opt_inline_xattr, "inline_xattr"},
|
2013-11-10 22:13:17 +07:00
|
|
|
{Opt_inline_data, "inline_data"},
|
2012-11-02 15:07:47 +07:00
|
|
|
{Opt_err, NULL},
|
|
|
|
};
|
|
|
|
|
2013-08-04 21:09:40 +07:00
|
|
|
/* Sysfs support for f2fs */
|
2013-10-24 13:49:07 +07:00
|
|
|
enum {
|
|
|
|
GC_THREAD, /* struct f2fs_gc_thread */
|
|
|
|
SM_INFO, /* struct f2fs_sm_info */
|
2014-01-08 11:45:08 +07:00
|
|
|
F2FS_SBI, /* struct f2fs_sb_info */
|
2013-10-24 13:49:07 +07:00
|
|
|
};
|
|
|
|
|
2013-08-04 21:09:40 +07:00
|
|
|
struct f2fs_attr {
|
|
|
|
struct attribute attr;
|
|
|
|
ssize_t (*show)(struct f2fs_attr *, struct f2fs_sb_info *, char *);
|
|
|
|
ssize_t (*store)(struct f2fs_attr *, struct f2fs_sb_info *,
|
|
|
|
const char *, size_t);
|
2013-10-24 13:49:07 +07:00
|
|
|
int struct_type;
|
2013-08-04 21:09:40 +07:00
|
|
|
int offset;
|
|
|
|
};
|
|
|
|
|
2013-10-24 13:49:07 +07:00
|
|
|
static unsigned char *__struct_ptr(struct f2fs_sb_info *sbi, int struct_type)
|
|
|
|
{
|
|
|
|
if (struct_type == GC_THREAD)
|
|
|
|
return (unsigned char *)sbi->gc_thread;
|
|
|
|
else if (struct_type == SM_INFO)
|
|
|
|
return (unsigned char *)SM_I(sbi);
|
2014-01-08 11:45:08 +07:00
|
|
|
else if (struct_type == F2FS_SBI)
|
|
|
|
return (unsigned char *)sbi;
|
2013-10-24 13:49:07 +07:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-08-04 21:09:40 +07:00
|
|
|
static ssize_t f2fs_sbi_show(struct f2fs_attr *a,
|
|
|
|
struct f2fs_sb_info *sbi, char *buf)
|
|
|
|
{
|
2013-10-24 13:49:07 +07:00
|
|
|
unsigned char *ptr = NULL;
|
2013-08-04 21:09:40 +07:00
|
|
|
unsigned int *ui;
|
|
|
|
|
2013-10-24 13:49:07 +07:00
|
|
|
ptr = __struct_ptr(sbi, a->struct_type);
|
|
|
|
if (!ptr)
|
2013-08-04 21:09:40 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2013-10-24 13:49:07 +07:00
|
|
|
ui = (unsigned int *)(ptr + a->offset);
|
2013-08-04 21:09:40 +07:00
|
|
|
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%u\n", *ui);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t f2fs_sbi_store(struct f2fs_attr *a,
|
|
|
|
struct f2fs_sb_info *sbi,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
2013-10-24 13:49:07 +07:00
|
|
|
unsigned char *ptr;
|
2013-08-04 21:09:40 +07:00
|
|
|
unsigned long t;
|
|
|
|
unsigned int *ui;
|
|
|
|
ssize_t ret;
|
|
|
|
|
2013-10-24 13:49:07 +07:00
|
|
|
ptr = __struct_ptr(sbi, a->struct_type);
|
|
|
|
if (!ptr)
|
2013-08-04 21:09:40 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2013-10-24 13:49:07 +07:00
|
|
|
ui = (unsigned int *)(ptr + a->offset);
|
2013-08-04 21:09:40 +07:00
|
|
|
|
|
|
|
ret = kstrtoul(skip_spaces(buf), 0, &t);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
*ui = t;
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t f2fs_attr_show(struct kobject *kobj,
|
|
|
|
struct attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
|
|
|
|
s_kobj);
|
|
|
|
struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr);
|
|
|
|
|
|
|
|
return a->show ? a->show(a, sbi, buf) : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t f2fs_attr_store(struct kobject *kobj, struct attribute *attr,
|
|
|
|
const char *buf, size_t len)
|
|
|
|
{
|
|
|
|
struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
|
|
|
|
s_kobj);
|
|
|
|
struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr);
|
|
|
|
|
|
|
|
return a->store ? a->store(a, sbi, buf, len) : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void f2fs_sb_release(struct kobject *kobj)
|
|
|
|
{
|
|
|
|
struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
|
|
|
|
s_kobj);
|
|
|
|
complete(&sbi->s_kobj_unregister);
|
|
|
|
}
|
|
|
|
|
2013-10-24 13:49:07 +07:00
|
|
|
#define F2FS_ATTR_OFFSET(_struct_type, _name, _mode, _show, _store, _offset) \
|
2013-08-04 21:09:40 +07:00
|
|
|
static struct f2fs_attr f2fs_attr_##_name = { \
|
|
|
|
.attr = {.name = __stringify(_name), .mode = _mode }, \
|
|
|
|
.show = _show, \
|
|
|
|
.store = _store, \
|
2013-10-24 13:49:07 +07:00
|
|
|
.struct_type = _struct_type, \
|
|
|
|
.offset = _offset \
|
2013-08-04 21:09:40 +07:00
|
|
|
}
|
|
|
|
|
2013-10-24 13:49:07 +07:00
|
|
|
#define F2FS_RW_ATTR(struct_type, struct_name, name, elname) \
|
|
|
|
F2FS_ATTR_OFFSET(struct_type, name, 0644, \
|
|
|
|
f2fs_sbi_show, f2fs_sbi_store, \
|
|
|
|
offsetof(struct struct_name, elname))
|
2013-08-04 21:09:40 +07:00
|
|
|
|
2013-10-24 13:49:07 +07:00
|
|
|
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);
|
|
|
|
F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_idle, gc_idle);
|
|
|
|
F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, reclaim_segments, rec_prefree_segments);
|
2013-11-12 13:00:38 +07:00
|
|
|
F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, max_small_discards, max_discards);
|
2013-11-07 11:13:42 +07:00
|
|
|
F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, ipu_policy, ipu_policy);
|
|
|
|
F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ipu_util, min_ipu_util);
|
2014-01-08 11:45:08 +07:00
|
|
|
F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_victim_search, max_victim_search);
|
2013-08-04 21:09:40 +07:00
|
|
|
|
|
|
|
#define ATTR_LIST(name) (&f2fs_attr_##name.attr)
|
|
|
|
static struct attribute *f2fs_attrs[] = {
|
|
|
|
ATTR_LIST(gc_min_sleep_time),
|
|
|
|
ATTR_LIST(gc_max_sleep_time),
|
|
|
|
ATTR_LIST(gc_no_gc_sleep_time),
|
2013-08-04 21:10:15 +07:00
|
|
|
ATTR_LIST(gc_idle),
|
2013-10-24 13:49:07 +07:00
|
|
|
ATTR_LIST(reclaim_segments),
|
2013-11-12 13:00:38 +07:00
|
|
|
ATTR_LIST(max_small_discards),
|
2013-11-07 11:13:42 +07:00
|
|
|
ATTR_LIST(ipu_policy),
|
|
|
|
ATTR_LIST(min_ipu_util),
|
2014-01-08 11:45:08 +07:00
|
|
|
ATTR_LIST(max_victim_search),
|
2013-08-04 21:09:40 +07:00
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct sysfs_ops f2fs_attr_ops = {
|
|
|
|
.show = f2fs_attr_show,
|
|
|
|
.store = f2fs_attr_store,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct kobj_type f2fs_ktype = {
|
|
|
|
.default_attrs = f2fs_attrs,
|
|
|
|
.sysfs_ops = &f2fs_attr_ops,
|
|
|
|
.release = f2fs_sb_release,
|
|
|
|
};
|
|
|
|
|
2012-12-30 12:52:05 +07:00
|
|
|
void f2fs_msg(struct super_block *sb, const char *level, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
struct va_format vaf;
|
|
|
|
va_list args;
|
|
|
|
|
|
|
|
va_start(args, fmt);
|
|
|
|
vaf.fmt = fmt;
|
|
|
|
vaf.va = &args;
|
|
|
|
printk("%sF2FS-fs (%s): %pV\n", level, sb->s_id, &vaf);
|
|
|
|
va_end(args);
|
|
|
|
}
|
|
|
|
|
2012-11-02 15:07:47 +07:00
|
|
|
static void init_once(void *foo)
|
|
|
|
{
|
|
|
|
struct f2fs_inode_info *fi = (struct f2fs_inode_info *) foo;
|
|
|
|
|
|
|
|
inode_init_once(&fi->vfs_inode);
|
|
|
|
}
|
|
|
|
|
2013-06-16 07:48:48 +07:00
|
|
|
static int parse_options(struct super_block *sb, char *options)
|
|
|
|
{
|
|
|
|
struct f2fs_sb_info *sbi = F2FS_SB(sb);
|
|
|
|
substring_t args[MAX_OPT_ARGS];
|
|
|
|
char *p, *name;
|
|
|
|
int arg = 0;
|
|
|
|
|
|
|
|
if (!options)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
while ((p = strsep(&options, ",")) != NULL) {
|
|
|
|
int token;
|
|
|
|
if (!*p)
|
|
|
|
continue;
|
|
|
|
/*
|
|
|
|
* Initialize args struct so we know whether arg was
|
|
|
|
* found; some options take optional arguments.
|
|
|
|
*/
|
|
|
|
args[0].to = args[0].from = NULL;
|
|
|
|
token = match_token(p, f2fs_tokens, args);
|
|
|
|
|
|
|
|
switch (token) {
|
|
|
|
case Opt_gc_background:
|
|
|
|
name = match_strdup(&args[0]);
|
|
|
|
|
|
|
|
if (!name)
|
|
|
|
return -ENOMEM;
|
|
|
|
if (!strncmp(name, "on", 2))
|
|
|
|
set_opt(sbi, BG_GC);
|
|
|
|
else if (!strncmp(name, "off", 3))
|
|
|
|
clear_opt(sbi, BG_GC);
|
|
|
|
else {
|
|
|
|
kfree(name);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
kfree(name);
|
|
|
|
break;
|
|
|
|
case Opt_disable_roll_forward:
|
|
|
|
set_opt(sbi, DISABLE_ROLL_FORWARD);
|
|
|
|
break;
|
|
|
|
case Opt_discard:
|
|
|
|
set_opt(sbi, DISCARD);
|
|
|
|
break;
|
|
|
|
case Opt_noheap:
|
|
|
|
set_opt(sbi, NOHEAP);
|
|
|
|
break;
|
|
|
|
#ifdef CONFIG_F2FS_FS_XATTR
|
2013-10-07 09:36:20 +07:00
|
|
|
case Opt_user_xattr:
|
|
|
|
set_opt(sbi, XATTR_USER);
|
|
|
|
break;
|
2013-06-16 07:48:48 +07:00
|
|
|
case Opt_nouser_xattr:
|
|
|
|
clear_opt(sbi, XATTR_USER);
|
|
|
|
break;
|
2013-08-08 13:16:22 +07:00
|
|
|
case Opt_inline_xattr:
|
|
|
|
set_opt(sbi, INLINE_XATTR);
|
|
|
|
break;
|
2013-06-16 07:48:48 +07:00
|
|
|
#else
|
2013-10-07 09:36:20 +07:00
|
|
|
case Opt_user_xattr:
|
|
|
|
f2fs_msg(sb, KERN_INFO,
|
|
|
|
"user_xattr options not supported");
|
|
|
|
break;
|
2013-06-16 07:48:48 +07:00
|
|
|
case Opt_nouser_xattr:
|
|
|
|
f2fs_msg(sb, KERN_INFO,
|
|
|
|
"nouser_xattr options not supported");
|
|
|
|
break;
|
2013-08-08 13:16:22 +07:00
|
|
|
case Opt_inline_xattr:
|
|
|
|
f2fs_msg(sb, KERN_INFO,
|
|
|
|
"inline_xattr options not supported");
|
|
|
|
break;
|
2013-06-16 07:48:48 +07:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_F2FS_FS_POSIX_ACL
|
2013-10-07 09:36:20 +07:00
|
|
|
case Opt_acl:
|
|
|
|
set_opt(sbi, POSIX_ACL);
|
|
|
|
break;
|
2013-06-16 07:48:48 +07:00
|
|
|
case Opt_noacl:
|
|
|
|
clear_opt(sbi, POSIX_ACL);
|
|
|
|
break;
|
|
|
|
#else
|
2013-10-07 09:36:20 +07:00
|
|
|
case Opt_acl:
|
|
|
|
f2fs_msg(sb, KERN_INFO, "acl options not supported");
|
|
|
|
break;
|
2013-06-16 07:48:48 +07:00
|
|
|
case Opt_noacl:
|
|
|
|
f2fs_msg(sb, KERN_INFO, "noacl options not supported");
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
case Opt_active_logs:
|
|
|
|
if (args->from && match_int(args, &arg))
|
|
|
|
return -EINVAL;
|
|
|
|
if (arg != 2 && arg != 4 && arg != NR_CURSEG_TYPE)
|
|
|
|
return -EINVAL;
|
|
|
|
sbi->active_logs = arg;
|
|
|
|
break;
|
|
|
|
case Opt_disable_ext_identify:
|
|
|
|
set_opt(sbi, DISABLE_EXT_IDENTIFY);
|
|
|
|
break;
|
2013-11-10 22:13:17 +07:00
|
|
|
case Opt_inline_data:
|
|
|
|
set_opt(sbi, INLINE_DATA);
|
|
|
|
break;
|
2013-06-16 07:48:48 +07:00
|
|
|
default:
|
|
|
|
f2fs_msg(sb, KERN_ERR,
|
|
|
|
"Unrecognized mount option \"%s\" or missing value",
|
|
|
|
p);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-11-02 15:07:47 +07:00
|
|
|
static struct inode *f2fs_alloc_inode(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct f2fs_inode_info *fi;
|
|
|
|
|
2013-12-05 08:54:00 +07:00
|
|
|
fi = kmem_cache_alloc(f2fs_inode_cachep, GFP_F2FS_ZERO);
|
2012-11-02 15:07:47 +07:00
|
|
|
if (!fi)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
init_once((void *) fi);
|
|
|
|
|
2013-03-19 06:03:35 +07:00
|
|
|
/* Initialize f2fs-specific inode info */
|
2012-11-02 15:07:47 +07:00
|
|
|
fi->vfs_inode.i_version = 1;
|
|
|
|
atomic_set(&fi->dirty_dents, 0);
|
|
|
|
fi->i_current_depth = 1;
|
|
|
|
fi->i_advise = 0;
|
|
|
|
rwlock_init(&fi->ext.ext_lock);
|
|
|
|
|
|
|
|
set_inode_flag(fi, FI_NEW_INODE);
|
|
|
|
|
2013-08-08 13:16:22 +07:00
|
|
|
if (test_opt(F2FS_SB(sb), INLINE_XATTR))
|
|
|
|
set_inode_flag(fi, FI_INLINE_XATTR);
|
|
|
|
|
2012-11-02 15:07:47 +07:00
|
|
|
return &fi->vfs_inode;
|
|
|
|
}
|
|
|
|
|
2013-04-30 09:33:27 +07:00
|
|
|
static int f2fs_drop_inode(struct inode *inode)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* This is to avoid a deadlock condition like below.
|
|
|
|
* writeback_single_inode(inode)
|
|
|
|
* - f2fs_write_data_page
|
|
|
|
* - f2fs_gc -> iput -> evict
|
|
|
|
* - inode_wait_for_writeback(inode)
|
|
|
|
*/
|
|
|
|
if (!inode_unhashed(inode) && inode->i_state & I_SYNC)
|
|
|
|
return 0;
|
|
|
|
return generic_drop_inode(inode);
|
|
|
|
}
|
|
|
|
|
2013-06-10 07:17:01 +07:00
|
|
|
/*
|
|
|
|
* f2fs_dirty_inode() is called from __mark_inode_dirty()
|
|
|
|
*
|
|
|
|
* We should call set_dirty_inode to write the dirty inode through write_inode.
|
|
|
|
*/
|
|
|
|
static void f2fs_dirty_inode(struct inode *inode, int flags)
|
|
|
|
{
|
|
|
|
set_inode_flag(F2FS_I(inode), FI_DIRTY_INODE);
|
|
|
|
}
|
|
|
|
|
2012-11-02 15:07:47 +07:00
|
|
|
static void f2fs_i_callback(struct rcu_head *head)
|
|
|
|
{
|
|
|
|
struct inode *inode = container_of(head, struct inode, i_rcu);
|
|
|
|
kmem_cache_free(f2fs_inode_cachep, F2FS_I(inode));
|
|
|
|
}
|
|
|
|
|
2012-11-28 14:12:41 +07:00
|
|
|
static void f2fs_destroy_inode(struct inode *inode)
|
2012-11-02 15:07:47 +07:00
|
|
|
{
|
|
|
|
call_rcu(&inode->i_rcu, f2fs_i_callback);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void f2fs_put_super(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct f2fs_sb_info *sbi = F2FS_SB(sb);
|
|
|
|
|
2013-06-28 10:47:01 +07:00
|
|
|
if (sbi->s_proc) {
|
|
|
|
remove_proc_entry("segment_info", sbi->s_proc);
|
|
|
|
remove_proc_entry(sb->s_id, f2fs_proc_root);
|
|
|
|
}
|
2013-08-04 21:09:40 +07:00
|
|
|
kobject_del(&sbi->s_kobj);
|
2013-06-28 10:47:01 +07:00
|
|
|
|
2012-11-02 15:07:47 +07:00
|
|
|
f2fs_destroy_stats(sbi);
|
|
|
|
stop_gc_thread(sbi);
|
|
|
|
|
2013-10-08 07:30:33 +07:00
|
|
|
/* We don't need to do checkpoint when it's clean */
|
|
|
|
if (sbi->s_dirty && get_pages(sbi, F2FS_DIRTY_NODES))
|
|
|
|
write_checkpoint(sbi, true);
|
2012-11-02 15:07:47 +07:00
|
|
|
|
|
|
|
iput(sbi->node_inode);
|
|
|
|
iput(sbi->meta_inode);
|
|
|
|
|
|
|
|
/* destroy f2fs internal modules */
|
|
|
|
destroy_node_manager(sbi);
|
|
|
|
destroy_segment_manager(sbi);
|
|
|
|
|
|
|
|
kfree(sbi->ckpt);
|
2013-08-04 21:09:40 +07:00
|
|
|
kobject_put(&sbi->s_kobj);
|
|
|
|
wait_for_completion(&sbi->s_kobj_unregister);
|
2012-11-02 15:07:47 +07:00
|
|
|
|
|
|
|
sb->s_fs_info = NULL;
|
|
|
|
brelse(sbi->raw_super_buf);
|
|
|
|
kfree(sbi);
|
|
|
|
}
|
|
|
|
|
|
|
|
int f2fs_sync_fs(struct super_block *sb, int sync)
|
|
|
|
{
|
|
|
|
struct f2fs_sb_info *sbi = F2FS_SB(sb);
|
|
|
|
|
2013-04-19 23:28:40 +07:00
|
|
|
trace_f2fs_sync_fs(sb, sync);
|
|
|
|
|
2012-11-02 15:07:47 +07:00
|
|
|
if (!sbi->s_dirty && !get_pages(sbi, F2FS_DIRTY_NODES))
|
|
|
|
return 0;
|
|
|
|
|
2013-04-01 06:32:21 +07:00
|
|
|
if (sync) {
|
|
|
|
mutex_lock(&sbi->gc_mutex);
|
2013-02-04 13:11:17 +07:00
|
|
|
write_checkpoint(sbi, false);
|
2013-04-01 06:32:21 +07:00
|
|
|
mutex_unlock(&sbi->gc_mutex);
|
|
|
|
} else {
|
2013-01-11 11:10:49 +07:00
|
|
|
f2fs_balance_fs(sbi);
|
2013-04-01 06:32:21 +07:00
|
|
|
}
|
2012-11-02 15:07:47 +07:00
|
|
|
|
2012-12-22 10:10:27 +07:00
|
|
|
return 0;
|
2012-11-02 15:07:47 +07:00
|
|
|
}
|
|
|
|
|
2013-01-29 16:30:07 +07:00
|
|
|
static int f2fs_freeze(struct super_block *sb)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2013-05-20 18:28:47 +07:00
|
|
|
if (f2fs_readonly(sb))
|
2013-01-29 16:30:07 +07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
err = f2fs_sync_fs(sb, 1);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int f2fs_unfreeze(struct super_block *sb)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-11-02 15:07:47 +07:00
|
|
|
static int f2fs_statfs(struct dentry *dentry, struct kstatfs *buf)
|
|
|
|
{
|
|
|
|
struct super_block *sb = dentry->d_sb;
|
|
|
|
struct f2fs_sb_info *sbi = F2FS_SB(sb);
|
|
|
|
u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
|
|
|
|
block_t total_count, user_block_count, start_count, ovp_count;
|
|
|
|
|
|
|
|
total_count = le64_to_cpu(sbi->raw_super->block_count);
|
|
|
|
user_block_count = sbi->user_block_count;
|
|
|
|
start_count = le32_to_cpu(sbi->raw_super->segment0_blkaddr);
|
|
|
|
ovp_count = SM_I(sbi)->ovp_segments << sbi->log_blocks_per_seg;
|
|
|
|
buf->f_type = F2FS_SUPER_MAGIC;
|
|
|
|
buf->f_bsize = sbi->blocksize;
|
|
|
|
|
|
|
|
buf->f_blocks = total_count - start_count;
|
|
|
|
buf->f_bfree = buf->f_blocks - valid_user_blocks(sbi) - ovp_count;
|
|
|
|
buf->f_bavail = user_block_count - valid_user_blocks(sbi);
|
|
|
|
|
2012-12-12 17:45:49 +07:00
|
|
|
buf->f_files = sbi->total_node_count;
|
|
|
|
buf->f_ffree = sbi->total_node_count - valid_inode_count(sbi);
|
2012-11-02 15:07:47 +07:00
|
|
|
|
2013-03-03 11:58:05 +07:00
|
|
|
buf->f_namelen = F2FS_NAME_LEN;
|
2012-11-02 15:07:47 +07:00
|
|
|
buf->f_fsid.val[0] = (u32)id;
|
|
|
|
buf->f_fsid.val[1] = (u32)(id >> 32);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int f2fs_show_options(struct seq_file *seq, struct dentry *root)
|
|
|
|
{
|
|
|
|
struct f2fs_sb_info *sbi = F2FS_SB(root->d_sb);
|
|
|
|
|
2013-06-16 07:48:48 +07:00
|
|
|
if (!(root->d_sb->s_flags & MS_RDONLY) && test_opt(sbi, BG_GC))
|
|
|
|
seq_printf(seq, ",background_gc=%s", "on");
|
2012-11-02 15:07:47 +07:00
|
|
|
else
|
2013-06-16 07:48:48 +07:00
|
|
|
seq_printf(seq, ",background_gc=%s", "off");
|
2012-11-02 15:07:47 +07:00
|
|
|
if (test_opt(sbi, DISABLE_ROLL_FORWARD))
|
|
|
|
seq_puts(seq, ",disable_roll_forward");
|
|
|
|
if (test_opt(sbi, DISCARD))
|
|
|
|
seq_puts(seq, ",discard");
|
|
|
|
if (test_opt(sbi, NOHEAP))
|
|
|
|
seq_puts(seq, ",no_heap_alloc");
|
|
|
|
#ifdef CONFIG_F2FS_FS_XATTR
|
|
|
|
if (test_opt(sbi, XATTR_USER))
|
|
|
|
seq_puts(seq, ",user_xattr");
|
|
|
|
else
|
|
|
|
seq_puts(seq, ",nouser_xattr");
|
2013-08-08 13:16:22 +07:00
|
|
|
if (test_opt(sbi, INLINE_XATTR))
|
|
|
|
seq_puts(seq, ",inline_xattr");
|
2012-11-02 15:07:47 +07:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_F2FS_FS_POSIX_ACL
|
|
|
|
if (test_opt(sbi, POSIX_ACL))
|
|
|
|
seq_puts(seq, ",acl");
|
|
|
|
else
|
|
|
|
seq_puts(seq, ",noacl");
|
|
|
|
#endif
|
|
|
|
if (test_opt(sbi, DISABLE_EXT_IDENTIFY))
|
2013-01-26 01:08:59 +07:00
|
|
|
seq_puts(seq, ",disable_ext_identify");
|
2013-11-10 22:13:17 +07:00
|
|
|
if (test_opt(sbi, INLINE_DATA))
|
|
|
|
seq_puts(seq, ",inline_data");
|
2012-11-02 15:07:47 +07:00
|
|
|
seq_printf(seq, ",active_logs=%u", sbi->active_logs);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-06-28 10:47:01 +07:00
|
|
|
static int segment_info_seq_show(struct seq_file *seq, void *offset)
|
|
|
|
{
|
|
|
|
struct super_block *sb = seq->private;
|
|
|
|
struct f2fs_sb_info *sbi = F2FS_SB(sb);
|
2014-01-18 03:44:39 +07:00
|
|
|
unsigned int total_segs =
|
|
|
|
le32_to_cpu(sbi->raw_super->segment_count_main);
|
2013-06-28 10:47:01 +07:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < total_segs; i++) {
|
|
|
|
seq_printf(seq, "%u", get_valid_blocks(sbi, i, 1));
|
|
|
|
if (i != 0 && (i % 10) == 0)
|
|
|
|
seq_puts(seq, "\n");
|
|
|
|
else
|
|
|
|
seq_puts(seq, " ");
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int segment_info_open_fs(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return single_open(file, segment_info_seq_show, PDE_DATA(inode));
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations f2fs_seq_segment_info_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = segment_info_open_fs,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
};
|
|
|
|
|
2013-06-16 07:48:48 +07:00
|
|
|
static int f2fs_remount(struct super_block *sb, int *flags, char *data)
|
|
|
|
{
|
|
|
|
struct f2fs_sb_info *sbi = F2FS_SB(sb);
|
|
|
|
struct f2fs_mount_info org_mount_opt;
|
|
|
|
int err, active_logs;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Save the old mount options in case we
|
|
|
|
* need to restore them.
|
|
|
|
*/
|
|
|
|
org_mount_opt = sbi->mount_opt;
|
|
|
|
active_logs = sbi->active_logs;
|
|
|
|
|
|
|
|
/* parse mount options */
|
|
|
|
err = parse_options(sb, data);
|
|
|
|
if (err)
|
|
|
|
goto restore_opts;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Previous and new state of filesystem is RO,
|
|
|
|
* so no point in checking GC conditions.
|
|
|
|
*/
|
|
|
|
if ((sb->s_flags & MS_RDONLY) && (*flags & MS_RDONLY))
|
|
|
|
goto skip;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We stop the GC thread if FS is mounted as RO
|
|
|
|
* or if background_gc = off is passed in mount
|
|
|
|
* option. Also sync the filesystem.
|
|
|
|
*/
|
|
|
|
if ((*flags & MS_RDONLY) || !test_opt(sbi, BG_GC)) {
|
|
|
|
if (sbi->gc_thread) {
|
|
|
|
stop_gc_thread(sbi);
|
|
|
|
f2fs_sync_fs(sb, 1);
|
|
|
|
}
|
|
|
|
} else if (test_opt(sbi, BG_GC) && !sbi->gc_thread) {
|
|
|
|
err = start_gc_thread(sbi);
|
|
|
|
if (err)
|
|
|
|
goto restore_opts;
|
|
|
|
}
|
|
|
|
skip:
|
|
|
|
/* Update the POSIXACL Flag */
|
|
|
|
sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
|
|
|
|
(test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
restore_opts:
|
|
|
|
sbi->mount_opt = org_mount_opt;
|
|
|
|
sbi->active_logs = active_logs;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-11-02 15:07:47 +07:00
|
|
|
static struct super_operations f2fs_sops = {
|
|
|
|
.alloc_inode = f2fs_alloc_inode,
|
2013-04-30 09:33:27 +07:00
|
|
|
.drop_inode = f2fs_drop_inode,
|
2012-11-02 15:07:47 +07:00
|
|
|
.destroy_inode = f2fs_destroy_inode,
|
|
|
|
.write_inode = f2fs_write_inode,
|
2013-06-10 07:17:01 +07:00
|
|
|
.dirty_inode = f2fs_dirty_inode,
|
2012-11-02 15:07:47 +07:00
|
|
|
.show_options = f2fs_show_options,
|
|
|
|
.evict_inode = f2fs_evict_inode,
|
|
|
|
.put_super = f2fs_put_super,
|
|
|
|
.sync_fs = f2fs_sync_fs,
|
2013-01-29 16:30:07 +07:00
|
|
|
.freeze_fs = f2fs_freeze,
|
|
|
|
.unfreeze_fs = f2fs_unfreeze,
|
2012-11-02 15:07:47 +07:00
|
|
|
.statfs = f2fs_statfs,
|
2013-06-16 07:48:48 +07:00
|
|
|
.remount_fs = f2fs_remount,
|
2012-11-02 15:07:47 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct inode *f2fs_nfs_get_inode(struct super_block *sb,
|
|
|
|
u64 ino, u32 generation)
|
|
|
|
{
|
|
|
|
struct f2fs_sb_info *sbi = F2FS_SB(sb);
|
|
|
|
struct inode *inode;
|
|
|
|
|
2013-12-06 13:00:58 +07:00
|
|
|
if (unlikely(ino < F2FS_ROOT_INO(sbi)))
|
2012-11-02 15:07:47 +07:00
|
|
|
return ERR_PTR(-ESTALE);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* f2fs_iget isn't quite right if the inode is currently unallocated!
|
|
|
|
* However f2fs_iget currently does appropriate checks to handle stale
|
|
|
|
* inodes so everything is OK.
|
|
|
|
*/
|
|
|
|
inode = f2fs_iget(sb, ino);
|
|
|
|
if (IS_ERR(inode))
|
|
|
|
return ERR_CAST(inode);
|
2013-12-06 13:00:58 +07:00
|
|
|
if (unlikely(generation && inode->i_generation != generation)) {
|
2012-11-02 15:07:47 +07:00
|
|
|
/* we didn't find the right inode.. */
|
|
|
|
iput(inode);
|
|
|
|
return ERR_PTR(-ESTALE);
|
|
|
|
}
|
|
|
|
return inode;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct dentry *f2fs_fh_to_dentry(struct super_block *sb, struct fid *fid,
|
|
|
|
int fh_len, int fh_type)
|
|
|
|
{
|
|
|
|
return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
|
|
|
|
f2fs_nfs_get_inode);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct dentry *f2fs_fh_to_parent(struct super_block *sb, struct fid *fid,
|
|
|
|
int fh_len, int fh_type)
|
|
|
|
{
|
|
|
|
return generic_fh_to_parent(sb, fid, fh_len, fh_type,
|
|
|
|
f2fs_nfs_get_inode);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct export_operations f2fs_export_ops = {
|
|
|
|
.fh_to_dentry = f2fs_fh_to_dentry,
|
|
|
|
.fh_to_parent = f2fs_fh_to_parent,
|
|
|
|
.get_parent = f2fs_get_parent,
|
|
|
|
};
|
|
|
|
|
|
|
|
static loff_t max_file_size(unsigned bits)
|
|
|
|
{
|
2013-08-12 19:08:03 +07:00
|
|
|
loff_t result = (DEF_ADDRS_PER_INODE - F2FS_INLINE_XATTR_ADDRS);
|
2012-11-02 15:07:47 +07:00
|
|
|
loff_t leaf_count = ADDRS_PER_BLOCK;
|
|
|
|
|
|
|
|
/* two direct node blocks */
|
|
|
|
result += (leaf_count * 2);
|
|
|
|
|
|
|
|
/* two indirect node blocks */
|
|
|
|
leaf_count *= NIDS_PER_BLOCK;
|
|
|
|
result += (leaf_count * 2);
|
|
|
|
|
|
|
|
/* one double indirect node block */
|
|
|
|
leaf_count *= NIDS_PER_BLOCK;
|
|
|
|
result += leaf_count;
|
|
|
|
|
|
|
|
result <<= bits;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2012-12-30 12:52:05 +07:00
|
|
|
static int sanity_check_raw_super(struct super_block *sb,
|
|
|
|
struct f2fs_super_block *raw_super)
|
2012-11-02 15:07:47 +07:00
|
|
|
{
|
|
|
|
unsigned int blocksize;
|
|
|
|
|
2012-12-30 12:52:05 +07:00
|
|
|
if (F2FS_SUPER_MAGIC != le32_to_cpu(raw_super->magic)) {
|
|
|
|
f2fs_msg(sb, KERN_INFO,
|
|
|
|
"Magic Mismatch, valid(0x%x) - read(0x%x)",
|
|
|
|
F2FS_SUPER_MAGIC, le32_to_cpu(raw_super->magic));
|
2012-11-02 15:07:47 +07:00
|
|
|
return 1;
|
2012-12-30 12:52:05 +07:00
|
|
|
}
|
2012-11-02 15:07:47 +07:00
|
|
|
|
2013-02-01 18:07:57 +07:00
|
|
|
/* Currently, support only 4KB page cache size */
|
|
|
|
if (F2FS_BLKSIZE != PAGE_CACHE_SIZE) {
|
|
|
|
f2fs_msg(sb, KERN_INFO,
|
2013-02-01 18:07:03 +07:00
|
|
|
"Invalid page_cache_size (%lu), supports only 4KB\n",
|
2013-02-01 18:07:57 +07:00
|
|
|
PAGE_CACHE_SIZE);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2012-11-02 15:07:47 +07:00
|
|
|
/* Currently, support only 4KB block size */
|
|
|
|
blocksize = 1 << le32_to_cpu(raw_super->log_blocksize);
|
2013-02-01 18:07:57 +07:00
|
|
|
if (blocksize != F2FS_BLKSIZE) {
|
2012-12-30 12:52:05 +07:00
|
|
|
f2fs_msg(sb, KERN_INFO,
|
|
|
|
"Invalid blocksize (%u), supports only 4KB\n",
|
|
|
|
blocksize);
|
2012-11-02 15:07:47 +07:00
|
|
|
return 1;
|
2012-12-30 12:52:05 +07:00
|
|
|
}
|
2013-02-01 18:07:57 +07:00
|
|
|
|
2012-11-02 15:07:47 +07:00
|
|
|
if (le32_to_cpu(raw_super->log_sectorsize) !=
|
2012-12-30 12:52:05 +07:00
|
|
|
F2FS_LOG_SECTOR_SIZE) {
|
|
|
|
f2fs_msg(sb, KERN_INFO, "Invalid log sectorsize");
|
2012-11-02 15:07:47 +07:00
|
|
|
return 1;
|
2012-12-30 12:52:05 +07:00
|
|
|
}
|
2012-11-02 15:07:47 +07:00
|
|
|
if (le32_to_cpu(raw_super->log_sectors_per_block) !=
|
2012-12-30 12:52:05 +07:00
|
|
|
F2FS_LOG_SECTORS_PER_BLOCK) {
|
|
|
|
f2fs_msg(sb, KERN_INFO, "Invalid log sectors per block");
|
2012-11-02 15:07:47 +07:00
|
|
|
return 1;
|
2012-12-30 12:52:05 +07:00
|
|
|
}
|
2012-11-02 15:07:47 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
f2fs: prevent checkpoint once any IO failure is detected
This patch enhances the checkpoint routine to cope with IO errors.
Basically f2fs detects IO errors from end_io_write, and the errors are able to
be occurred during one of data, node, and meta page writes.
In the previous code, when an IO error is occurred during writes, f2fs sets a
flag, CP_ERROR_FLAG, in the raw ckeckpoint buffer which will be written to disk.
Afterwards, write_checkpoint() will check the flag and remount f2fs as a
read-only (ro) mode.
However, even once f2fs is remounted as a ro mode, dirty checkpoint pages are
freely able to be written to disk by flusher or kswapd in background.
In such a case, after cold reboot, f2fs would restore the checkpoint data having
CP_ERROR_FLAG, resulting in disabling write_checkpoint and remounting f2fs as
a ro mode again.
Therefore, let's prevent any checkpoint page (meta) writes once an IO error is
occurred, and remount f2fs as a ro mode right away at that moment.
Reported-by: Oliver Winker <oliver@oli1170.net>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
Reviewed-by: Namjae Jeon <namjae.jeon@samsung.com>
2013-01-24 17:56:11 +07:00
|
|
|
static int sanity_check_ckpt(struct f2fs_sb_info *sbi)
|
2012-11-02 15:07:47 +07:00
|
|
|
{
|
|
|
|
unsigned int total, fsmeta;
|
f2fs: prevent checkpoint once any IO failure is detected
This patch enhances the checkpoint routine to cope with IO errors.
Basically f2fs detects IO errors from end_io_write, and the errors are able to
be occurred during one of data, node, and meta page writes.
In the previous code, when an IO error is occurred during writes, f2fs sets a
flag, CP_ERROR_FLAG, in the raw ckeckpoint buffer which will be written to disk.
Afterwards, write_checkpoint() will check the flag and remount f2fs as a
read-only (ro) mode.
However, even once f2fs is remounted as a ro mode, dirty checkpoint pages are
freely able to be written to disk by flusher or kswapd in background.
In such a case, after cold reboot, f2fs would restore the checkpoint data having
CP_ERROR_FLAG, resulting in disabling write_checkpoint and remounting f2fs as
a ro mode again.
Therefore, let's prevent any checkpoint page (meta) writes once an IO error is
occurred, and remount f2fs as a ro mode right away at that moment.
Reported-by: Oliver Winker <oliver@oli1170.net>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
Reviewed-by: Namjae Jeon <namjae.jeon@samsung.com>
2013-01-24 17:56:11 +07:00
|
|
|
struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
|
|
|
|
struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
|
2012-11-02 15:07:47 +07:00
|
|
|
|
|
|
|
total = le32_to_cpu(raw_super->segment_count);
|
|
|
|
fsmeta = le32_to_cpu(raw_super->segment_count_ckpt);
|
|
|
|
fsmeta += le32_to_cpu(raw_super->segment_count_sit);
|
|
|
|
fsmeta += le32_to_cpu(raw_super->segment_count_nat);
|
|
|
|
fsmeta += le32_to_cpu(ckpt->rsvd_segment_count);
|
|
|
|
fsmeta += le32_to_cpu(raw_super->segment_count_ssa);
|
|
|
|
|
2013-12-06 13:00:58 +07:00
|
|
|
if (unlikely(fsmeta >= total))
|
2012-11-02 15:07:47 +07:00
|
|
|
return 1;
|
f2fs: prevent checkpoint once any IO failure is detected
This patch enhances the checkpoint routine to cope with IO errors.
Basically f2fs detects IO errors from end_io_write, and the errors are able to
be occurred during one of data, node, and meta page writes.
In the previous code, when an IO error is occurred during writes, f2fs sets a
flag, CP_ERROR_FLAG, in the raw ckeckpoint buffer which will be written to disk.
Afterwards, write_checkpoint() will check the flag and remount f2fs as a
read-only (ro) mode.
However, even once f2fs is remounted as a ro mode, dirty checkpoint pages are
freely able to be written to disk by flusher or kswapd in background.
In such a case, after cold reboot, f2fs would restore the checkpoint data having
CP_ERROR_FLAG, resulting in disabling write_checkpoint and remounting f2fs as
a ro mode again.
Therefore, let's prevent any checkpoint page (meta) writes once an IO error is
occurred, and remount f2fs as a ro mode right away at that moment.
Reported-by: Oliver Winker <oliver@oli1170.net>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
Reviewed-by: Namjae Jeon <namjae.jeon@samsung.com>
2013-01-24 17:56:11 +07:00
|
|
|
|
2013-12-06 13:00:58 +07:00
|
|
|
if (unlikely(is_set_ckpt_flags(ckpt, CP_ERROR_FLAG))) {
|
f2fs: prevent checkpoint once any IO failure is detected
This patch enhances the checkpoint routine to cope with IO errors.
Basically f2fs detects IO errors from end_io_write, and the errors are able to
be occurred during one of data, node, and meta page writes.
In the previous code, when an IO error is occurred during writes, f2fs sets a
flag, CP_ERROR_FLAG, in the raw ckeckpoint buffer which will be written to disk.
Afterwards, write_checkpoint() will check the flag and remount f2fs as a
read-only (ro) mode.
However, even once f2fs is remounted as a ro mode, dirty checkpoint pages are
freely able to be written to disk by flusher or kswapd in background.
In such a case, after cold reboot, f2fs would restore the checkpoint data having
CP_ERROR_FLAG, resulting in disabling write_checkpoint and remounting f2fs as
a ro mode again.
Therefore, let's prevent any checkpoint page (meta) writes once an IO error is
occurred, and remount f2fs as a ro mode right away at that moment.
Reported-by: Oliver Winker <oliver@oli1170.net>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
Reviewed-by: Namjae Jeon <namjae.jeon@samsung.com>
2013-01-24 17:56:11 +07:00
|
|
|
f2fs_msg(sbi->sb, KERN_ERR, "A bug case: need to run fsck");
|
|
|
|
return 1;
|
|
|
|
}
|
2012-11-02 15:07:47 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void init_sb_info(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
struct f2fs_super_block *raw_super = sbi->raw_super;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
sbi->log_sectors_per_block =
|
|
|
|
le32_to_cpu(raw_super->log_sectors_per_block);
|
|
|
|
sbi->log_blocksize = le32_to_cpu(raw_super->log_blocksize);
|
|
|
|
sbi->blocksize = 1 << sbi->log_blocksize;
|
|
|
|
sbi->log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);
|
|
|
|
sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg;
|
|
|
|
sbi->segs_per_sec = le32_to_cpu(raw_super->segs_per_sec);
|
|
|
|
sbi->secs_per_zone = le32_to_cpu(raw_super->secs_per_zone);
|
|
|
|
sbi->total_sections = le32_to_cpu(raw_super->section_count);
|
|
|
|
sbi->total_node_count =
|
|
|
|
(le32_to_cpu(raw_super->segment_count_nat) / 2)
|
|
|
|
* sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK;
|
|
|
|
sbi->root_ino_num = le32_to_cpu(raw_super->root_ino);
|
|
|
|
sbi->node_ino_num = le32_to_cpu(raw_super->node_ino);
|
|
|
|
sbi->meta_ino_num = le32_to_cpu(raw_super->meta_ino);
|
2013-03-31 11:26:03 +07:00
|
|
|
sbi->cur_victim_sec = NULL_SECNO;
|
2014-01-08 11:45:08 +07:00
|
|
|
sbi->max_victim_search = DEF_MAX_VICTIM_SEARCH;
|
2012-11-02 15:07:47 +07:00
|
|
|
|
|
|
|
for (i = 0; i < NR_COUNT_TYPE; i++)
|
|
|
|
atomic_set(&sbi->nr_pages[i], 0);
|
|
|
|
}
|
|
|
|
|
2013-10-14 17:47:11 +07:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
static int read_raw_super_block(struct super_block *sb,
|
|
|
|
struct f2fs_super_block **raw_super,
|
|
|
|
struct buffer_head **raw_super_buf)
|
2013-02-01 18:07:03 +07:00
|
|
|
{
|
2013-10-14 17:47:11 +07:00
|
|
|
int block = 0;
|
2013-02-01 18:07:03 +07:00
|
|
|
|
2013-10-14 17:47:11 +07:00
|
|
|
retry:
|
2013-02-01 18:07:03 +07:00
|
|
|
*raw_super_buf = sb_bread(sb, block);
|
|
|
|
if (!*raw_super_buf) {
|
2013-10-14 17:47:11 +07:00
|
|
|
f2fs_msg(sb, KERN_ERR, "Unable to read %dth superblock",
|
|
|
|
block + 1);
|
|
|
|
if (block == 0) {
|
|
|
|
block++;
|
|
|
|
goto retry;
|
|
|
|
} else {
|
|
|
|
return -EIO;
|
|
|
|
}
|
2013-02-01 18:07:03 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
*raw_super = (struct f2fs_super_block *)
|
|
|
|
((char *)(*raw_super_buf)->b_data + F2FS_SUPER_OFFSET);
|
|
|
|
|
|
|
|
/* sanity checking of raw super */
|
2013-10-14 17:47:11 +07:00
|
|
|
if (sanity_check_raw_super(sb, *raw_super)) {
|
|
|
|
brelse(*raw_super_buf);
|
2014-01-18 03:44:39 +07:00
|
|
|
f2fs_msg(sb, KERN_ERR,
|
|
|
|
"Can't find valid F2FS filesystem in %dth superblock",
|
|
|
|
block + 1);
|
2013-12-06 13:00:58 +07:00
|
|
|
if (block == 0) {
|
2013-10-14 17:47:11 +07:00
|
|
|
block++;
|
|
|
|
goto retry;
|
|
|
|
} else {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
2013-02-01 18:07:03 +07:00
|
|
|
|
2013-10-14 17:47:11 +07:00
|
|
|
return 0;
|
2013-02-01 18:07:03 +07:00
|
|
|
}
|
|
|
|
|
2012-11-02 15:07:47 +07:00
|
|
|
static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
|
|
|
|
{
|
|
|
|
struct f2fs_sb_info *sbi;
|
|
|
|
struct f2fs_super_block *raw_super;
|
|
|
|
struct buffer_head *raw_super_buf;
|
|
|
|
struct inode *root;
|
|
|
|
long err = -EINVAL;
|
2013-11-18 15:16:17 +07:00
|
|
|
int i;
|
2012-11-02 15:07:47 +07:00
|
|
|
|
|
|
|
/* allocate memory for f2fs-specific super block info */
|
|
|
|
sbi = kzalloc(sizeof(struct f2fs_sb_info), GFP_KERNEL);
|
|
|
|
if (!sbi)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2013-01-12 12:41:13 +07:00
|
|
|
/* set a block size */
|
2013-12-06 13:00:58 +07:00
|
|
|
if (unlikely(!sb_set_blocksize(sb, F2FS_BLKSIZE))) {
|
2012-12-30 12:52:05 +07:00
|
|
|
f2fs_msg(sb, KERN_ERR, "unable to set blocksize");
|
2012-11-02 15:07:47 +07:00
|
|
|
goto free_sbi;
|
2012-12-30 12:52:05 +07:00
|
|
|
}
|
2012-11-02 15:07:47 +07:00
|
|
|
|
2013-10-14 17:47:11 +07:00
|
|
|
err = read_raw_super_block(sb, &raw_super, &raw_super_buf);
|
|
|
|
if (err)
|
|
|
|
goto free_sbi;
|
|
|
|
|
2013-06-07 13:16:53 +07:00
|
|
|
sb->s_fs_info = sbi;
|
2012-11-02 15:07:47 +07:00
|
|
|
/* init some FS parameters */
|
|
|
|
sbi->active_logs = NR_CURSEG_TYPE;
|
|
|
|
|
|
|
|
set_opt(sbi, BG_GC);
|
|
|
|
|
|
|
|
#ifdef CONFIG_F2FS_FS_XATTR
|
|
|
|
set_opt(sbi, XATTR_USER);
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_F2FS_FS_POSIX_ACL
|
|
|
|
set_opt(sbi, POSIX_ACL);
|
|
|
|
#endif
|
|
|
|
/* parse mount options */
|
2013-06-07 13:16:53 +07:00
|
|
|
err = parse_options(sb, (char *)data);
|
2013-04-12 09:23:18 +07:00
|
|
|
if (err)
|
2012-11-02 15:07:47 +07:00
|
|
|
goto free_sb_buf;
|
|
|
|
|
2012-11-28 14:12:41 +07:00
|
|
|
sb->s_maxbytes = max_file_size(le32_to_cpu(raw_super->log_blocksize));
|
2012-11-02 15:07:47 +07:00
|
|
|
sb->s_max_links = F2FS_LINK_MAX;
|
|
|
|
get_random_bytes(&sbi->s_next_generation, sizeof(u32));
|
|
|
|
|
|
|
|
sb->s_op = &f2fs_sops;
|
|
|
|
sb->s_xattr = f2fs_xattr_handlers;
|
|
|
|
sb->s_export_op = &f2fs_export_ops;
|
|
|
|
sb->s_magic = F2FS_SUPER_MAGIC;
|
|
|
|
sb->s_time_gran = 1;
|
|
|
|
sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
|
|
|
|
(test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0);
|
|
|
|
memcpy(sb->s_uuid, raw_super->uuid, sizeof(raw_super->uuid));
|
|
|
|
|
|
|
|
/* init f2fs-specific super block info */
|
|
|
|
sbi->sb = sb;
|
|
|
|
sbi->raw_super = raw_super;
|
|
|
|
sbi->raw_super_buf = raw_super_buf;
|
|
|
|
mutex_init(&sbi->gc_mutex);
|
|
|
|
mutex_init(&sbi->writepages);
|
|
|
|
mutex_init(&sbi->cp_mutex);
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 14:21:29 +07:00
|
|
|
mutex_init(&sbi->node_write);
|
2013-10-23 11:39:32 +07:00
|
|
|
sbi->por_doing = false;
|
2012-11-02 15:07:47 +07:00
|
|
|
spin_lock_init(&sbi->stat_lock);
|
2013-11-18 15:16:17 +07:00
|
|
|
|
2013-11-20 13:46:39 +07:00
|
|
|
mutex_init(&sbi->read_io.io_mutex);
|
2013-12-11 11:54:01 +07:00
|
|
|
sbi->read_io.sbi = sbi;
|
|
|
|
sbi->read_io.bio = NULL;
|
|
|
|
for (i = 0; i < NR_PAGE_TYPE; i++) {
|
2013-11-19 10:47:22 +07:00
|
|
|
mutex_init(&sbi->write_io[i].io_mutex);
|
2013-12-11 11:54:01 +07:00
|
|
|
sbi->write_io[i].sbi = sbi;
|
|
|
|
sbi->write_io[i].bio = NULL;
|
|
|
|
}
|
2013-11-18 15:16:17 +07:00
|
|
|
|
f2fs: use rw_sem instead of fs_lock(locks mutex)
The fs_locks is used to block other ops(ex, recovery) when doing checkpoint.
And each other operate routine(besides checkpoint) needs to acquire a fs_lock,
there is a terrible problem here, if these are too many concurrency threads acquiring
fs_lock, so that they will block each other and may lead to some performance problem,
but this is not the phenomenon we want to see.
Though there are some optimization patches introduced to enhance the usage of fs_lock,
but the thorough solution is using a *rw_sem* to replace the fs_lock.
Checkpoint routine takes write_sem, and other ops take read_sem, so that we can block
other ops(ex, recovery) when doing checkpoint, and other ops will not disturb each other,
this can avoid the problem described above completely.
Because of the weakness of rw_sem, the above change may introduce a potential problem
that the checkpoint thread might get starved if other threads are intensively locking
the read semaphore for I/O.(Pointed out by Xu Jin)
In order to avoid this, a wait_list is introduced, the appending read semaphore ops
will be dropped into the wait_list if checkpoint thread is waiting for write semaphore,
and will be waked up when checkpoint thread gives up write semaphore.
Thanks to Kim's previous review and test, and will be very glad to see other guys'
performance tests about this patch.
V2:
-fix the potential starvation problem.
-use more suitable func name suggested by Xu Jin.
Signed-off-by: Gu Zheng <guz.fnst@cn.fujitsu.com>
[Jaegeuk Kim: adjust minor coding standard]
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-09-27 17:08:30 +07:00
|
|
|
init_rwsem(&sbi->cp_rwsem);
|
2013-11-07 10:48:25 +07:00
|
|
|
init_waitqueue_head(&sbi->cp_wait);
|
2012-11-02 15:07:47 +07:00
|
|
|
init_sb_info(sbi);
|
|
|
|
|
|
|
|
/* get an inode for meta space */
|
|
|
|
sbi->meta_inode = f2fs_iget(sb, F2FS_META_INO(sbi));
|
|
|
|
if (IS_ERR(sbi->meta_inode)) {
|
2012-12-30 12:52:05 +07:00
|
|
|
f2fs_msg(sb, KERN_ERR, "Failed to read F2FS meta data inode");
|
2012-11-02 15:07:47 +07:00
|
|
|
err = PTR_ERR(sbi->meta_inode);
|
|
|
|
goto free_sb_buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = get_valid_checkpoint(sbi);
|
2012-12-30 12:52:05 +07:00
|
|
|
if (err) {
|
|
|
|
f2fs_msg(sb, KERN_ERR, "Failed to get valid F2FS checkpoint");
|
2012-11-02 15:07:47 +07:00
|
|
|
goto free_meta_inode;
|
2012-12-30 12:52:05 +07:00
|
|
|
}
|
2012-11-02 15:07:47 +07:00
|
|
|
|
|
|
|
/* sanity checking of checkpoint */
|
|
|
|
err = -EINVAL;
|
f2fs: prevent checkpoint once any IO failure is detected
This patch enhances the checkpoint routine to cope with IO errors.
Basically f2fs detects IO errors from end_io_write, and the errors are able to
be occurred during one of data, node, and meta page writes.
In the previous code, when an IO error is occurred during writes, f2fs sets a
flag, CP_ERROR_FLAG, in the raw ckeckpoint buffer which will be written to disk.
Afterwards, write_checkpoint() will check the flag and remount f2fs as a
read-only (ro) mode.
However, even once f2fs is remounted as a ro mode, dirty checkpoint pages are
freely able to be written to disk by flusher or kswapd in background.
In such a case, after cold reboot, f2fs would restore the checkpoint data having
CP_ERROR_FLAG, resulting in disabling write_checkpoint and remounting f2fs as
a ro mode again.
Therefore, let's prevent any checkpoint page (meta) writes once an IO error is
occurred, and remount f2fs as a ro mode right away at that moment.
Reported-by: Oliver Winker <oliver@oli1170.net>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
Reviewed-by: Namjae Jeon <namjae.jeon@samsung.com>
2013-01-24 17:56:11 +07:00
|
|
|
if (sanity_check_ckpt(sbi)) {
|
2012-12-30 12:52:05 +07:00
|
|
|
f2fs_msg(sb, KERN_ERR, "Invalid F2FS checkpoint");
|
2012-11-02 15:07:47 +07:00
|
|
|
goto free_cp;
|
2012-12-30 12:52:05 +07:00
|
|
|
}
|
2012-11-02 15:07:47 +07:00
|
|
|
|
|
|
|
sbi->total_valid_node_count =
|
|
|
|
le32_to_cpu(sbi->ckpt->valid_node_count);
|
|
|
|
sbi->total_valid_inode_count =
|
|
|
|
le32_to_cpu(sbi->ckpt->valid_inode_count);
|
|
|
|
sbi->user_block_count = le64_to_cpu(sbi->ckpt->user_block_count);
|
|
|
|
sbi->total_valid_block_count =
|
|
|
|
le64_to_cpu(sbi->ckpt->valid_block_count);
|
|
|
|
sbi->last_valid_block_count = sbi->total_valid_block_count;
|
|
|
|
sbi->alloc_valid_block_count = 0;
|
|
|
|
INIT_LIST_HEAD(&sbi->dir_inode_list);
|
|
|
|
spin_lock_init(&sbi->dir_inode_lock);
|
|
|
|
|
|
|
|
init_orphan_info(sbi);
|
|
|
|
|
|
|
|
/* setup f2fs internal modules */
|
|
|
|
err = build_segment_manager(sbi);
|
2012-12-30 12:52:05 +07:00
|
|
|
if (err) {
|
|
|
|
f2fs_msg(sb, KERN_ERR,
|
|
|
|
"Failed to initialize F2FS segment manager");
|
2012-11-02 15:07:47 +07:00
|
|
|
goto free_sm;
|
2012-12-30 12:52:05 +07:00
|
|
|
}
|
2012-11-02 15:07:47 +07:00
|
|
|
err = build_node_manager(sbi);
|
2012-12-30 12:52:05 +07:00
|
|
|
if (err) {
|
|
|
|
f2fs_msg(sb, KERN_ERR,
|
|
|
|
"Failed to initialize F2FS node manager");
|
2012-11-02 15:07:47 +07:00
|
|
|
goto free_nm;
|
2012-12-30 12:52:05 +07:00
|
|
|
}
|
2012-11-02 15:07:47 +07:00
|
|
|
|
|
|
|
build_gc_manager(sbi);
|
|
|
|
|
|
|
|
/* get an inode for node space */
|
|
|
|
sbi->node_inode = f2fs_iget(sb, F2FS_NODE_INO(sbi));
|
|
|
|
if (IS_ERR(sbi->node_inode)) {
|
2012-12-30 12:52:05 +07:00
|
|
|
f2fs_msg(sb, KERN_ERR, "Failed to read node inode");
|
2012-11-02 15:07:47 +07:00
|
|
|
err = PTR_ERR(sbi->node_inode);
|
|
|
|
goto free_nm;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if there are nt orphan nodes free them */
|
2013-11-28 14:43:43 +07:00
|
|
|
recover_orphan_inodes(sbi);
|
2012-11-02 15:07:47 +07:00
|
|
|
|
|
|
|
/* read root inode and dentry */
|
|
|
|
root = f2fs_iget(sb, F2FS_ROOT_INO(sbi));
|
|
|
|
if (IS_ERR(root)) {
|
2012-12-30 12:52:05 +07:00
|
|
|
f2fs_msg(sb, KERN_ERR, "Failed to read root inode");
|
2012-11-02 15:07:47 +07:00
|
|
|
err = PTR_ERR(root);
|
|
|
|
goto free_node_inode;
|
|
|
|
}
|
2013-11-28 14:43:43 +07:00
|
|
|
if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
|
|
|
|
err = -EINVAL;
|
2012-11-02 15:07:47 +07:00
|
|
|
goto free_root_inode;
|
2013-11-28 14:43:43 +07:00
|
|
|
}
|
2012-11-02 15:07:47 +07:00
|
|
|
|
|
|
|
sb->s_root = d_make_root(root); /* allocate root dentry */
|
|
|
|
if (!sb->s_root) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto free_root_inode;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* recover fsynced data */
|
2013-03-20 17:01:06 +07:00
|
|
|
if (!test_opt(sbi, DISABLE_ROLL_FORWARD)) {
|
|
|
|
err = recover_fsync_data(sbi);
|
2013-05-03 04:07:34 +07:00
|
|
|
if (err)
|
|
|
|
f2fs_msg(sb, KERN_ERR,
|
|
|
|
"Cannot recover all fsync data errno=%ld", err);
|
2013-03-20 17:01:06 +07:00
|
|
|
}
|
2012-11-02 15:07:47 +07:00
|
|
|
|
2013-06-16 07:48:48 +07:00
|
|
|
/*
|
|
|
|
* If filesystem is not mounted as read-only then
|
|
|
|
* do start the gc_thread.
|
|
|
|
*/
|
|
|
|
if (!(sb->s_flags & MS_RDONLY)) {
|
|
|
|
/* After POR, we can run background GC thread.*/
|
|
|
|
err = start_gc_thread(sbi);
|
|
|
|
if (err)
|
2013-11-07 09:14:51 +07:00
|
|
|
goto free_gc;
|
2013-06-16 07:48:48 +07:00
|
|
|
}
|
2012-11-02 15:07:47 +07:00
|
|
|
|
|
|
|
err = f2fs_build_stats(sbi);
|
|
|
|
if (err)
|
2013-11-07 09:14:51 +07:00
|
|
|
goto free_gc;
|
2012-11-02 15:07:47 +07:00
|
|
|
|
2013-06-28 10:47:01 +07:00
|
|
|
if (f2fs_proc_root)
|
|
|
|
sbi->s_proc = proc_mkdir(sb->s_id, f2fs_proc_root);
|
|
|
|
|
|
|
|
if (sbi->s_proc)
|
|
|
|
proc_create_data("segment_info", S_IRUGO, sbi->s_proc,
|
|
|
|
&f2fs_seq_segment_info_fops, sb);
|
|
|
|
|
2013-03-17 15:26:14 +07:00
|
|
|
if (test_opt(sbi, DISCARD)) {
|
|
|
|
struct request_queue *q = bdev_get_queue(sb->s_bdev);
|
|
|
|
if (!blk_queue_discard(q))
|
|
|
|
f2fs_msg(sb, KERN_WARNING,
|
|
|
|
"mounting with \"discard\" option, but "
|
|
|
|
"the device does not support discard");
|
|
|
|
}
|
|
|
|
|
2013-08-04 21:09:40 +07:00
|
|
|
sbi->s_kobj.kset = f2fs_kset;
|
|
|
|
init_completion(&sbi->s_kobj_unregister);
|
|
|
|
err = kobject_init_and_add(&sbi->s_kobj, &f2fs_ktype, NULL,
|
|
|
|
"%s", sb->s_id);
|
|
|
|
if (err)
|
|
|
|
goto fail;
|
|
|
|
|
2012-11-02 15:07:47 +07:00
|
|
|
return 0;
|
|
|
|
fail:
|
2013-11-07 09:14:51 +07:00
|
|
|
if (sbi->s_proc) {
|
|
|
|
remove_proc_entry("segment_info", sbi->s_proc);
|
|
|
|
remove_proc_entry(sb->s_id, f2fs_proc_root);
|
|
|
|
}
|
|
|
|
f2fs_destroy_stats(sbi);
|
|
|
|
free_gc:
|
2012-11-02 15:07:47 +07:00
|
|
|
stop_gc_thread(sbi);
|
|
|
|
free_root_inode:
|
|
|
|
dput(sb->s_root);
|
|
|
|
sb->s_root = NULL;
|
|
|
|
free_node_inode:
|
|
|
|
iput(sbi->node_inode);
|
|
|
|
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);
|
|
|
|
iput(sbi->meta_inode);
|
|
|
|
free_sb_buf:
|
|
|
|
brelse(raw_super_buf);
|
|
|
|
free_sbi:
|
|
|
|
kfree(sbi);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct dentry *f2fs_mount(struct file_system_type *fs_type, int flags,
|
|
|
|
const char *dev_name, void *data)
|
|
|
|
{
|
|
|
|
return mount_bdev(fs_type, flags, dev_name, data, f2fs_fill_super);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct file_system_type f2fs_fs_type = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.name = "f2fs",
|
|
|
|
.mount = f2fs_mount,
|
|
|
|
.kill_sb = kill_block_super,
|
|
|
|
.fs_flags = FS_REQUIRES_DEV,
|
|
|
|
};
|
2013-03-03 10:39:14 +07:00
|
|
|
MODULE_ALIAS_FS("f2fs");
|
2012-11-02 15:07:47 +07:00
|
|
|
|
2013-01-16 22:08:30 +07:00
|
|
|
static int __init init_inodecache(void)
|
2012-11-02 15:07:47 +07:00
|
|
|
{
|
|
|
|
f2fs_inode_cachep = f2fs_kmem_cache_create("f2fs_inode_cache",
|
|
|
|
sizeof(struct f2fs_inode_info), NULL);
|
2013-12-06 13:00:58 +07:00
|
|
|
if (!f2fs_inode_cachep)
|
2012-11-02 15:07:47 +07:00
|
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void destroy_inodecache(void)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Make sure all delayed rcu free inodes are flushed before we
|
|
|
|
* destroy cache.
|
|
|
|
*/
|
|
|
|
rcu_barrier();
|
|
|
|
kmem_cache_destroy(f2fs_inode_cachep);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init init_f2fs_fs(void)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = init_inodecache();
|
|
|
|
if (err)
|
|
|
|
goto fail;
|
|
|
|
err = create_node_manager_caches();
|
|
|
|
if (err)
|
2013-08-20 15:49:51 +07:00
|
|
|
goto free_inodecache;
|
2013-11-15 11:55:58 +07:00
|
|
|
err = create_segment_manager_caches();
|
2012-11-02 15:07:47 +07:00
|
|
|
if (err)
|
2013-08-20 15:49:51 +07:00
|
|
|
goto free_node_manager_caches;
|
2013-11-15 11:55:58 +07:00
|
|
|
err = create_gc_caches();
|
|
|
|
if (err)
|
|
|
|
goto free_segment_manager_caches;
|
2012-11-02 15:07:47 +07:00
|
|
|
err = create_checkpoint_caches();
|
|
|
|
if (err)
|
2013-08-20 15:49:51 +07:00
|
|
|
goto free_gc_caches;
|
2013-08-04 21:09:40 +07:00
|
|
|
f2fs_kset = kset_create_and_add("f2fs", NULL, fs_kobj);
|
2013-08-23 07:30:20 +07:00
|
|
|
if (!f2fs_kset) {
|
|
|
|
err = -ENOMEM;
|
2013-08-20 15:49:51 +07:00
|
|
|
goto free_checkpoint_caches;
|
2013-08-23 07:30:20 +07:00
|
|
|
}
|
2013-01-15 17:58:47 +07:00
|
|
|
err = register_filesystem(&f2fs_fs_type);
|
|
|
|
if (err)
|
2013-08-20 15:49:51 +07:00
|
|
|
goto free_kset;
|
2013-01-15 17:58:47 +07:00
|
|
|
f2fs_create_root_stats();
|
2013-06-28 10:47:01 +07:00
|
|
|
f2fs_proc_root = proc_mkdir("fs/f2fs", NULL);
|
2013-08-20 15:49:51 +07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
free_kset:
|
|
|
|
kset_unregister(f2fs_kset);
|
|
|
|
free_checkpoint_caches:
|
|
|
|
destroy_checkpoint_caches();
|
|
|
|
free_gc_caches:
|
|
|
|
destroy_gc_caches();
|
2013-11-15 11:55:58 +07:00
|
|
|
free_segment_manager_caches:
|
|
|
|
destroy_segment_manager_caches();
|
2013-08-20 15:49:51 +07:00
|
|
|
free_node_manager_caches:
|
|
|
|
destroy_node_manager_caches();
|
|
|
|
free_inodecache:
|
|
|
|
destroy_inodecache();
|
2012-11-02 15:07:47 +07:00
|
|
|
fail:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit exit_f2fs_fs(void)
|
|
|
|
{
|
2013-06-28 10:47:01 +07:00
|
|
|
remove_proc_entry("fs/f2fs", NULL);
|
2013-01-15 17:58:47 +07:00
|
|
|
f2fs_destroy_root_stats();
|
2012-11-02 15:07:47 +07:00
|
|
|
unregister_filesystem(&f2fs_fs_type);
|
|
|
|
destroy_checkpoint_caches();
|
|
|
|
destroy_gc_caches();
|
2013-12-11 12:32:13 +07:00
|
|
|
destroy_segment_manager_caches();
|
2012-11-02 15:07:47 +07:00
|
|
|
destroy_node_manager_caches();
|
|
|
|
destroy_inodecache();
|
2013-08-04 21:09:40 +07:00
|
|
|
kset_unregister(f2fs_kset);
|
2012-11-02 15:07:47 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(init_f2fs_fs)
|
|
|
|
module_exit(exit_f2fs_fs)
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Samsung Electronics's Praesto Team");
|
|
|
|
MODULE_DESCRIPTION("Flash Friendly File System");
|
|
|
|
MODULE_LICENSE("GPL");
|