~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/f2fs/super.c

Version: ~ [ linux-5.2-rc1 ] ~ [ linux-5.1.2 ] ~ [ linux-5.0.16 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.43 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.119 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.176 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.179 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.139 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.67 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * fs/f2fs/super.c
  3  *
  4  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
  5  *             http://www.samsung.com/
  6  *
  7  * This program is free software; you can redistribute it and/or modify
  8  * it under the terms of the GNU General Public License version 2 as
  9  * published by the Free Software Foundation.
 10  */
 11 #include <linux/module.h>
 12 #include <linux/init.h>
 13 #include <linux/fs.h>
 14 #include <linux/statfs.h>
 15 #include <linux/buffer_head.h>
 16 #include <linux/backing-dev.h>
 17 #include <linux/kthread.h>
 18 #include <linux/parser.h>
 19 #include <linux/mount.h>
 20 #include <linux/seq_file.h>
 21 #include <linux/proc_fs.h>
 22 #include <linux/random.h>
 23 #include <linux/exportfs.h>
 24 #include <linux/blkdev.h>
 25 #include <linux/f2fs_fs.h>
 26 #include <linux/sysfs.h>
 27 
 28 #include "f2fs.h"
 29 #include "node.h"
 30 #include "segment.h"
 31 #include "xattr.h"
 32 #include "gc.h"
 33 #include "trace.h"
 34 
 35 #define CREATE_TRACE_POINTS
 36 #include <trace/events/f2fs.h>
 37 
 38 static struct proc_dir_entry *f2fs_proc_root;
 39 static struct kmem_cache *f2fs_inode_cachep;
 40 static struct kset *f2fs_kset;
 41 
 42 /* f2fs-wide shrinker description */
 43 static struct shrinker f2fs_shrinker_info = {
 44         .scan_objects = f2fs_shrink_scan,
 45         .count_objects = f2fs_shrink_count,
 46         .seeks = DEFAULT_SEEKS,
 47 };
 48 
 49 enum {
 50         Opt_gc_background,
 51         Opt_disable_roll_forward,
 52         Opt_norecovery,
 53         Opt_discard,
 54         Opt_noheap,
 55         Opt_user_xattr,
 56         Opt_nouser_xattr,
 57         Opt_acl,
 58         Opt_noacl,
 59         Opt_active_logs,
 60         Opt_disable_ext_identify,
 61         Opt_inline_xattr,
 62         Opt_inline_data,
 63         Opt_inline_dentry,
 64         Opt_flush_merge,
 65         Opt_nobarrier,
 66         Opt_fastboot,
 67         Opt_extent_cache,
 68         Opt_noextent_cache,
 69         Opt_noinline_data,
 70         Opt_data_flush,
 71         Opt_err,
 72 };
 73 
 74 static match_table_t f2fs_tokens = {
 75         {Opt_gc_background, "background_gc=%s"},
 76         {Opt_disable_roll_forward, "disable_roll_forward"},
 77         {Opt_norecovery, "norecovery"},
 78         {Opt_discard, "discard"},
 79         {Opt_noheap, "no_heap"},
 80         {Opt_user_xattr, "user_xattr"},
 81         {Opt_nouser_xattr, "nouser_xattr"},
 82         {Opt_acl, "acl"},
 83         {Opt_noacl, "noacl"},
 84         {Opt_active_logs, "active_logs=%u"},
 85         {Opt_disable_ext_identify, "disable_ext_identify"},
 86         {Opt_inline_xattr, "inline_xattr"},
 87         {Opt_inline_data, "inline_data"},
 88         {Opt_inline_dentry, "inline_dentry"},
 89         {Opt_flush_merge, "flush_merge"},
 90         {Opt_nobarrier, "nobarrier"},
 91         {Opt_fastboot, "fastboot"},
 92         {Opt_extent_cache, "extent_cache"},
 93         {Opt_noextent_cache, "noextent_cache"},
 94         {Opt_noinline_data, "noinline_data"},
 95         {Opt_data_flush, "data_flush"},
 96         {Opt_err, NULL},
 97 };
 98 
 99 /* Sysfs support for f2fs */
100 enum {
101         GC_THREAD,      /* struct f2fs_gc_thread */
102         SM_INFO,        /* struct f2fs_sm_info */
103         NM_INFO,        /* struct f2fs_nm_info */
104         F2FS_SBI,       /* struct f2fs_sb_info */
105 };
106 
107 struct f2fs_attr {
108         struct attribute attr;
109         ssize_t (*show)(struct f2fs_attr *, struct f2fs_sb_info *, char *);
110         ssize_t (*store)(struct f2fs_attr *, struct f2fs_sb_info *,
111                          const char *, size_t);
112         int struct_type;
113         int offset;
114 };
115 
116 static unsigned char *__struct_ptr(struct f2fs_sb_info *sbi, int struct_type)
117 {
118         if (struct_type == GC_THREAD)
119                 return (unsigned char *)sbi->gc_thread;
120         else if (struct_type == SM_INFO)
121                 return (unsigned char *)SM_I(sbi);
122         else if (struct_type == NM_INFO)
123                 return (unsigned char *)NM_I(sbi);
124         else if (struct_type == F2FS_SBI)
125                 return (unsigned char *)sbi;
126         return NULL;
127 }
128 
129 static ssize_t lifetime_write_kbytes_show(struct f2fs_attr *a,
130                 struct f2fs_sb_info *sbi, char *buf)
131 {
132         struct super_block *sb = sbi->sb;
133 
134         if (!sb->s_bdev->bd_part)
135                 return snprintf(buf, PAGE_SIZE, "\n");
136 
137         return snprintf(buf, PAGE_SIZE, "%llu\n",
138                 (unsigned long long)(sbi->kbytes_written +
139                         BD_PART_WRITTEN(sbi)));
140 }
141 
142 static ssize_t f2fs_sbi_show(struct f2fs_attr *a,
143                         struct f2fs_sb_info *sbi, char *buf)
144 {
145         unsigned char *ptr = NULL;
146         unsigned int *ui;
147 
148         ptr = __struct_ptr(sbi, a->struct_type);
149         if (!ptr)
150                 return -EINVAL;
151 
152         ui = (unsigned int *)(ptr + a->offset);
153 
154         return snprintf(buf, PAGE_SIZE, "%u\n", *ui);
155 }
156 
157 static ssize_t f2fs_sbi_store(struct f2fs_attr *a,
158                         struct f2fs_sb_info *sbi,
159                         const char *buf, size_t count)
160 {
161         unsigned char *ptr;
162         unsigned long t;
163         unsigned int *ui;
164         ssize_t ret;
165 
166         ptr = __struct_ptr(sbi, a->struct_type);
167         if (!ptr)
168                 return -EINVAL;
169 
170         ui = (unsigned int *)(ptr + a->offset);
171 
172         ret = kstrtoul(skip_spaces(buf), 0, &t);
173         if (ret < 0)
174                 return ret;
175         *ui = t;
176         return count;
177 }
178 
179 static ssize_t f2fs_attr_show(struct kobject *kobj,
180                                 struct attribute *attr, char *buf)
181 {
182         struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
183                                                                 s_kobj);
184         struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr);
185 
186         return a->show ? a->show(a, sbi, buf) : 0;
187 }
188 
189 static ssize_t f2fs_attr_store(struct kobject *kobj, struct attribute *attr,
190                                                 const char *buf, size_t len)
191 {
192         struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
193                                                                         s_kobj);
194         struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr);
195 
196         return a->store ? a->store(a, sbi, buf, len) : 0;
197 }
198 
199 static void f2fs_sb_release(struct kobject *kobj)
200 {
201         struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
202                                                                 s_kobj);
203         complete(&sbi->s_kobj_unregister);
204 }
205 
206 #define F2FS_ATTR_OFFSET(_struct_type, _name, _mode, _show, _store, _offset) \
207 static struct f2fs_attr f2fs_attr_##_name = {                   \
208         .attr = {.name = __stringify(_name), .mode = _mode },   \
209         .show   = _show,                                        \
210         .store  = _store,                                       \
211         .struct_type = _struct_type,                            \
212         .offset = _offset                                       \
213 }
214 
215 #define F2FS_RW_ATTR(struct_type, struct_name, name, elname)    \
216         F2FS_ATTR_OFFSET(struct_type, name, 0644,               \
217                 f2fs_sbi_show, f2fs_sbi_store,                  \
218                 offsetof(struct struct_name, elname))
219 
220 #define F2FS_GENERAL_RO_ATTR(name) \
221 static struct f2fs_attr f2fs_attr_##name = __ATTR(name, 0444, name##_show, NULL)
222 
223 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_min_sleep_time, min_sleep_time);
224 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_max_sleep_time, max_sleep_time);
225 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_no_gc_sleep_time, no_gc_sleep_time);
226 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_idle, gc_idle);
227 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, reclaim_segments, rec_prefree_segments);
228 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, max_small_discards, max_discards);
229 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, batched_trim_sections, trim_sections);
230 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, ipu_policy, ipu_policy);
231 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ipu_util, min_ipu_util);
232 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_fsync_blocks, min_fsync_blocks);
233 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ram_thresh, ram_thresh);
234 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ra_nid_pages, ra_nid_pages);
235 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, dirty_nats_ratio, dirty_nats_ratio);
236 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_victim_search, max_victim_search);
237 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, dir_level, dir_level);
238 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, cp_interval, interval_time[CP_TIME]);
239 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, idle_interval, interval_time[REQ_TIME]);
240 F2FS_GENERAL_RO_ATTR(lifetime_write_kbytes);
241 
242 #define ATTR_LIST(name) (&f2fs_attr_##name.attr)
243 static struct attribute *f2fs_attrs[] = {
244         ATTR_LIST(gc_min_sleep_time),
245         ATTR_LIST(gc_max_sleep_time),
246         ATTR_LIST(gc_no_gc_sleep_time),
247         ATTR_LIST(gc_idle),
248         ATTR_LIST(reclaim_segments),
249         ATTR_LIST(max_small_discards),
250         ATTR_LIST(batched_trim_sections),
251         ATTR_LIST(ipu_policy),
252         ATTR_LIST(min_ipu_util),
253         ATTR_LIST(min_fsync_blocks),
254         ATTR_LIST(max_victim_search),
255         ATTR_LIST(dir_level),
256         ATTR_LIST(ram_thresh),
257         ATTR_LIST(ra_nid_pages),
258         ATTR_LIST(dirty_nats_ratio),
259         ATTR_LIST(cp_interval),
260         ATTR_LIST(idle_interval),
261         ATTR_LIST(lifetime_write_kbytes),
262         NULL,
263 };
264 
265 static const struct sysfs_ops f2fs_attr_ops = {
266         .show   = f2fs_attr_show,
267         .store  = f2fs_attr_store,
268 };
269 
270 static struct kobj_type f2fs_ktype = {
271         .default_attrs  = f2fs_attrs,
272         .sysfs_ops      = &f2fs_attr_ops,
273         .release        = f2fs_sb_release,
274 };
275 
276 void f2fs_msg(struct super_block *sb, const char *level, const char *fmt, ...)
277 {
278         struct va_format vaf;
279         va_list args;
280 
281         va_start(args, fmt);
282         vaf.fmt = fmt;
283         vaf.va = &args;
284         printk("%sF2FS-fs (%s): %pV\n", level, sb->s_id, &vaf);
285         va_end(args);
286 }
287 
288 static void init_once(void *foo)
289 {
290         struct f2fs_inode_info *fi = (struct f2fs_inode_info *) foo;
291 
292         inode_init_once(&fi->vfs_inode);
293 }
294 
295 static int parse_options(struct super_block *sb, char *options)
296 {
297         struct f2fs_sb_info *sbi = F2FS_SB(sb);
298         struct request_queue *q;
299         substring_t args[MAX_OPT_ARGS];
300         char *p, *name;
301         int arg = 0;
302 
303         if (!options)
304                 return 0;
305 
306         while ((p = strsep(&options, ",")) != NULL) {
307                 int token;
308                 if (!*p)
309                         continue;
310                 /*
311                  * Initialize args struct so we know whether arg was
312                  * found; some options take optional arguments.
313                  */
314                 args[0].to = args[0].from = NULL;
315                 token = match_token(p, f2fs_tokens, args);
316 
317                 switch (token) {
318                 case Opt_gc_background:
319                         name = match_strdup(&args[0]);
320 
321                         if (!name)
322                                 return -ENOMEM;
323                         if (strlen(name) == 2 && !strncmp(name, "on", 2)) {
324                                 set_opt(sbi, BG_GC);
325                                 clear_opt(sbi, FORCE_FG_GC);
326                         } else if (strlen(name) == 3 && !strncmp(name, "off", 3)) {
327                                 clear_opt(sbi, BG_GC);
328                                 clear_opt(sbi, FORCE_FG_GC);
329                         } else if (strlen(name) == 4 && !strncmp(name, "sync", 4)) {
330                                 set_opt(sbi, BG_GC);
331                                 set_opt(sbi, FORCE_FG_GC);
332                         } else {
333                                 kfree(name);
334                                 return -EINVAL;
335                         }
336                         kfree(name);
337                         break;
338                 case Opt_disable_roll_forward:
339                         set_opt(sbi, DISABLE_ROLL_FORWARD);
340                         break;
341                 case Opt_norecovery:
342                         /* this option mounts f2fs with ro */
343                         set_opt(sbi, DISABLE_ROLL_FORWARD);
344                         if (!f2fs_readonly(sb))
345                                 return -EINVAL;
346                         break;
347                 case Opt_discard:
348                         q = bdev_get_queue(sb->s_bdev);
349                         if (blk_queue_discard(q)) {
350                                 set_opt(sbi, DISCARD);
351                         } else {
352                                 f2fs_msg(sb, KERN_WARNING,
353                                         "mounting with \"discard\" option, but "
354                                         "the device does not support discard");
355                         }
356                         break;
357                 case Opt_noheap:
358                         set_opt(sbi, NOHEAP);
359                         break;
360 #ifdef CONFIG_F2FS_FS_XATTR
361                 case Opt_user_xattr:
362                         set_opt(sbi, XATTR_USER);
363                         break;
364                 case Opt_nouser_xattr:
365                         clear_opt(sbi, XATTR_USER);
366                         break;
367                 case Opt_inline_xattr:
368                         set_opt(sbi, INLINE_XATTR);
369                         break;
370 #else
371                 case Opt_user_xattr:
372                         f2fs_msg(sb, KERN_INFO,
373                                 "user_xattr options not supported");
374                         break;
375                 case Opt_nouser_xattr:
376                         f2fs_msg(sb, KERN_INFO,
377                                 "nouser_xattr options not supported");
378                         break;
379                 case Opt_inline_xattr:
380                         f2fs_msg(sb, KERN_INFO,
381                                 "inline_xattr options not supported");
382                         break;
383 #endif
384 #ifdef CONFIG_F2FS_FS_POSIX_ACL
385                 case Opt_acl:
386                         set_opt(sbi, POSIX_ACL);
387                         break;
388                 case Opt_noacl:
389                         clear_opt(sbi, POSIX_ACL);
390                         break;
391 #else
392                 case Opt_acl:
393                         f2fs_msg(sb, KERN_INFO, "acl options not supported");
394                         break;
395                 case Opt_noacl:
396                         f2fs_msg(sb, KERN_INFO, "noacl options not supported");
397                         break;
398 #endif
399                 case Opt_active_logs:
400                         if (args->from && match_int(args, &arg))
401                                 return -EINVAL;
402                         if (arg != 2 && arg != 4 && arg != NR_CURSEG_TYPE)
403                                 return -EINVAL;
404                         sbi->active_logs = arg;
405                         break;
406                 case Opt_disable_ext_identify:
407                         set_opt(sbi, DISABLE_EXT_IDENTIFY);
408                         break;
409                 case Opt_inline_data:
410                         set_opt(sbi, INLINE_DATA);
411                         break;
412                 case Opt_inline_dentry:
413                         set_opt(sbi, INLINE_DENTRY);
414                         break;
415                 case Opt_flush_merge:
416                         set_opt(sbi, FLUSH_MERGE);
417                         break;
418                 case Opt_nobarrier:
419                         set_opt(sbi, NOBARRIER);
420                         break;
421                 case Opt_fastboot:
422                         set_opt(sbi, FASTBOOT);
423                         break;
424                 case Opt_extent_cache:
425                         set_opt(sbi, EXTENT_CACHE);
426                         break;
427                 case Opt_noextent_cache:
428                         clear_opt(sbi, EXTENT_CACHE);
429                         break;
430                 case Opt_noinline_data:
431                         clear_opt(sbi, INLINE_DATA);
432                         break;
433                 case Opt_data_flush:
434                         set_opt(sbi, DATA_FLUSH);
435                         break;
436                 default:
437                         f2fs_msg(sb, KERN_ERR,
438                                 "Unrecognized mount option \"%s\" or missing value",
439                                 p);
440                         return -EINVAL;
441                 }
442         }
443         return 0;
444 }
445 
446 static struct inode *f2fs_alloc_inode(struct super_block *sb)
447 {
448         struct f2fs_inode_info *fi;
449 
450         fi = kmem_cache_alloc(f2fs_inode_cachep, GFP_F2FS_ZERO);
451         if (!fi)
452                 return NULL;
453 
454         init_once((void *) fi);
455 
456         /* Initialize f2fs-specific inode info */
457         fi->vfs_inode.i_version = 1;
458         atomic_set(&fi->dirty_pages, 0);
459         fi->i_current_depth = 1;
460         fi->i_advise = 0;
461         init_rwsem(&fi->i_sem);
462         INIT_LIST_HEAD(&fi->dirty_list);
463         INIT_LIST_HEAD(&fi->inmem_pages);
464         mutex_init(&fi->inmem_lock);
465 
466         set_inode_flag(fi, FI_NEW_INODE);
467 
468         if (test_opt(F2FS_SB(sb), INLINE_XATTR))
469                 set_inode_flag(fi, FI_INLINE_XATTR);
470 
471         /* Will be used by directory only */
472         fi->i_dir_level = F2FS_SB(sb)->dir_level;
473         return &fi->vfs_inode;
474 }
475 
476 static int f2fs_drop_inode(struct inode *inode)
477 {
478         /*
479          * This is to avoid a deadlock condition like below.
480          * writeback_single_inode(inode)
481          *  - f2fs_write_data_page
482          *    - f2fs_gc -> iput -> evict
483          *       - inode_wait_for_writeback(inode)
484          */
485         if (!inode_unhashed(inode) && inode->i_state & I_SYNC) {
486                 if (!inode->i_nlink && !is_bad_inode(inode)) {
487                         /* to avoid evict_inode call simultaneously */
488                         atomic_inc(&inode->i_count);
489                         spin_unlock(&inode->i_lock);
490 
491                         /* some remained atomic pages should discarded */
492                         if (f2fs_is_atomic_file(inode))
493                                 drop_inmem_pages(inode);
494 
495                         /* should remain fi->extent_tree for writepage */
496                         f2fs_destroy_extent_node(inode);
497 
498                         sb_start_intwrite(inode->i_sb);
499                         i_size_write(inode, 0);
500 
501                         if (F2FS_HAS_BLOCKS(inode))
502                                 f2fs_truncate(inode, true);
503 
504                         sb_end_intwrite(inode->i_sb);
505 
506                         fscrypt_put_encryption_info(inode, NULL);
507                         spin_lock(&inode->i_lock);
508                         atomic_dec(&inode->i_count);
509                 }
510                 return 0;
511         }
512         return generic_drop_inode(inode);
513 }
514 
515 /*
516  * f2fs_dirty_inode() is called from __mark_inode_dirty()
517  *
518  * We should call set_dirty_inode to write the dirty inode through write_inode.
519  */
520 static void f2fs_dirty_inode(struct inode *inode, int flags)
521 {
522         set_inode_flag(F2FS_I(inode), FI_DIRTY_INODE);
523 }
524 
525 static void f2fs_i_callback(struct rcu_head *head)
526 {
527         struct inode *inode = container_of(head, struct inode, i_rcu);
528         kmem_cache_free(f2fs_inode_cachep, F2FS_I(inode));
529 }
530 
531 static void f2fs_destroy_inode(struct inode *inode)
532 {
533         call_rcu(&inode->i_rcu, f2fs_i_callback);
534 }
535 
536 static void f2fs_put_super(struct super_block *sb)
537 {
538         struct f2fs_sb_info *sbi = F2FS_SB(sb);
539 
540         if (sbi->s_proc) {
541                 remove_proc_entry("segment_info", sbi->s_proc);
542                 remove_proc_entry(sb->s_id, f2fs_proc_root);
543         }
544         kobject_del(&sbi->s_kobj);
545 
546         stop_gc_thread(sbi);
547 
548         /* prevent remaining shrinker jobs */
549         mutex_lock(&sbi->umount_mutex);
550 
551         /*
552          * We don't need to do checkpoint when superblock is clean.
553          * But, the previous checkpoint was not done by umount, it needs to do
554          * clean checkpoint again.
555          */
556         if (is_sbi_flag_set(sbi, SBI_IS_DIRTY) ||
557                         !is_set_ckpt_flags(F2FS_CKPT(sbi), CP_UMOUNT_FLAG)) {
558                 struct cp_control cpc = {
559                         .reason = CP_UMOUNT,
560                 };
561                 write_checkpoint(sbi, &cpc);
562         }
563 
564         /* write_checkpoint can update stat informaion */
565         f2fs_destroy_stats(sbi);
566 
567         /*
568          * normally superblock is clean, so we need to release this.
569          * In addition, EIO will skip do checkpoint, we need this as well.
570          */
571         release_ino_entry(sbi);
572         release_discard_addrs(sbi);
573 
574         f2fs_leave_shrinker(sbi);
575         mutex_unlock(&sbi->umount_mutex);
576 
577         /* our cp_error case, we can wait for any writeback page */
578         if (get_pages(sbi, F2FS_WRITEBACK))
579                 f2fs_flush_merged_bios(sbi);
580 
581         iput(sbi->node_inode);
582         iput(sbi->meta_inode);
583 
584         /* destroy f2fs internal modules */
585         destroy_node_manager(sbi);
586         destroy_segment_manager(sbi);
587 
588         kfree(sbi->ckpt);
589         kobject_put(&sbi->s_kobj);
590         wait_for_completion(&sbi->s_kobj_unregister);
591 
592         sb->s_fs_info = NULL;
593         if (sbi->s_chksum_driver)
594                 crypto_free_shash(sbi->s_chksum_driver);
595         kfree(sbi->raw_super);
596         kfree(sbi);
597 }
598 
599 int f2fs_sync_fs(struct super_block *sb, int sync)
600 {
601         struct f2fs_sb_info *sbi = F2FS_SB(sb);
602         int err = 0;
603 
604         trace_f2fs_sync_fs(sb, sync);
605 
606         if (sync) {
607                 struct cp_control cpc;
608 
609                 cpc.reason = __get_cp_reason(sbi);
610 
611                 mutex_lock(&sbi->gc_mutex);
612                 err = write_checkpoint(sbi, &cpc);
613                 mutex_unlock(&sbi->gc_mutex);
614         }
615         f2fs_trace_ios(NULL, 1);
616 
617         return err;
618 }
619 
620 static int f2fs_freeze(struct super_block *sb)
621 {
622         int err;
623 
624         if (f2fs_readonly(sb))
625                 return 0;
626 
627         err = f2fs_sync_fs(sb, 1);
628         return err;
629 }
630 
631 static int f2fs_unfreeze(struct super_block *sb)
632 {
633         return 0;
634 }
635 
636 static int f2fs_statfs(struct dentry *dentry, struct kstatfs *buf)
637 {
638         struct super_block *sb = dentry->d_sb;
639         struct f2fs_sb_info *sbi = F2FS_SB(sb);
640         u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
641         block_t total_count, user_block_count, start_count, ovp_count;
642 
643         total_count = le64_to_cpu(sbi->raw_super->block_count);
644         user_block_count = sbi->user_block_count;
645         start_count = le32_to_cpu(sbi->raw_super->segment0_blkaddr);
646         ovp_count = SM_I(sbi)->ovp_segments << sbi->log_blocks_per_seg;
647         buf->f_type = F2FS_SUPER_MAGIC;
648         buf->f_bsize = sbi->blocksize;
649 
650         buf->f_blocks = total_count - start_count;
651         buf->f_bfree = buf->f_blocks - valid_user_blocks(sbi) - ovp_count;
652         buf->f_bavail = user_block_count - valid_user_blocks(sbi);
653 
654         buf->f_files = sbi->total_node_count - F2FS_RESERVED_NODE_NUM;
655         buf->f_ffree = buf->f_files - valid_inode_count(sbi);
656 
657         buf->f_namelen = F2FS_NAME_LEN;
658         buf->f_fsid.val[0] = (u32)id;
659         buf->f_fsid.val[1] = (u32)(id >> 32);
660 
661         return 0;
662 }
663 
664 static int f2fs_show_options(struct seq_file *seq, struct dentry *root)
665 {
666         struct f2fs_sb_info *sbi = F2FS_SB(root->d_sb);
667 
668         if (!f2fs_readonly(sbi->sb) && test_opt(sbi, BG_GC)) {
669                 if (test_opt(sbi, FORCE_FG_GC))
670                         seq_printf(seq, ",background_gc=%s", "sync");
671                 else
672                         seq_printf(seq, ",background_gc=%s", "on");
673         } else {
674                 seq_printf(seq, ",background_gc=%s", "off");
675         }
676         if (test_opt(sbi, DISABLE_ROLL_FORWARD))
677                 seq_puts(seq, ",disable_roll_forward");
678         if (test_opt(sbi, DISCARD))
679                 seq_puts(seq, ",discard");
680         if (test_opt(sbi, NOHEAP))
681                 seq_puts(seq, ",no_heap_alloc");
682 #ifdef CONFIG_F2FS_FS_XATTR
683         if (test_opt(sbi, XATTR_USER))
684                 seq_puts(seq, ",user_xattr");
685         else
686                 seq_puts(seq, ",nouser_xattr");
687         if (test_opt(sbi, INLINE_XATTR))
688                 seq_puts(seq, ",inline_xattr");
689 #endif
690 #ifdef CONFIG_F2FS_FS_POSIX_ACL
691         if (test_opt(sbi, POSIX_ACL))
692                 seq_puts(seq, ",acl");
693         else
694                 seq_puts(seq, ",noacl");
695 #endif
696         if (test_opt(sbi, DISABLE_EXT_IDENTIFY))
697                 seq_puts(seq, ",disable_ext_identify");
698         if (test_opt(sbi, INLINE_DATA))
699                 seq_puts(seq, ",inline_data");
700         else
701                 seq_puts(seq, ",noinline_data");
702         if (test_opt(sbi, INLINE_DENTRY))
703                 seq_puts(seq, ",inline_dentry");
704         if (!f2fs_readonly(sbi->sb) && test_opt(sbi, FLUSH_MERGE))
705                 seq_puts(seq, ",flush_merge");
706         if (test_opt(sbi, NOBARRIER))
707                 seq_puts(seq, ",nobarrier");
708         if (test_opt(sbi, FASTBOOT))
709                 seq_puts(seq, ",fastboot");
710         if (test_opt(sbi, EXTENT_CACHE))
711                 seq_puts(seq, ",extent_cache");
712         else
713                 seq_puts(seq, ",noextent_cache");
714         if (test_opt(sbi, DATA_FLUSH))
715                 seq_puts(seq, ",data_flush");
716         seq_printf(seq, ",active_logs=%u", sbi->active_logs);
717 
718         return 0;
719 }
720 
721 static int segment_info_seq_show(struct seq_file *seq, void *offset)
722 {
723         struct super_block *sb = seq->private;
724         struct f2fs_sb_info *sbi = F2FS_SB(sb);
725         unsigned int total_segs =
726                         le32_to_cpu(sbi->raw_super->segment_count_main);
727         int i;
728 
729         seq_puts(seq, "format: segment_type|valid_blocks\n"
730                 "segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n");
731 
732         for (i = 0; i < total_segs; i++) {
733                 struct seg_entry *se = get_seg_entry(sbi, i);
734 
735                 if ((i % 10) == 0)
736                         seq_printf(seq, "%-10d", i);
737                 seq_printf(seq, "%d|%-3u", se->type,
738                                         get_valid_blocks(sbi, i, 1));
739                 if ((i % 10) == 9 || i == (total_segs - 1))
740                         seq_putc(seq, '\n');
741                 else
742                         seq_putc(seq, ' ');
743         }
744 
745         return 0;
746 }
747 
748 static int segment_info_open_fs(struct inode *inode, struct file *file)
749 {
750         return single_open(file, segment_info_seq_show, PDE_DATA(inode));
751 }
752 
753 static const struct file_operations f2fs_seq_segment_info_fops = {
754         .owner = THIS_MODULE,
755         .open = segment_info_open_fs,
756         .read = seq_read,
757         .llseek = seq_lseek,
758         .release = single_release,
759 };
760 
761 static void default_options(struct f2fs_sb_info *sbi)
762 {
763         /* init some FS parameters */
764         sbi->active_logs = NR_CURSEG_TYPE;
765 
766         set_opt(sbi, BG_GC);
767         set_opt(sbi, INLINE_DATA);
768         set_opt(sbi, EXTENT_CACHE);
769 
770 #ifdef CONFIG_F2FS_FS_XATTR
771         set_opt(sbi, XATTR_USER);
772 #endif
773 #ifdef CONFIG_F2FS_FS_POSIX_ACL
774         set_opt(sbi, POSIX_ACL);
775 #endif
776 }
777 
778 static int f2fs_remount(struct super_block *sb, int *flags, char *data)
779 {
780         struct f2fs_sb_info *sbi = F2FS_SB(sb);
781         struct f2fs_mount_info org_mount_opt;
782         int err, active_logs;
783         bool need_restart_gc = false;
784         bool need_stop_gc = false;
785         bool no_extent_cache = !test_opt(sbi, EXTENT_CACHE);
786 
787         /*
788          * Save the old mount options in case we
789          * need to restore them.
790          */
791         org_mount_opt = sbi->mount_opt;
792         active_logs = sbi->active_logs;
793 
794         if (*flags & MS_RDONLY) {
795                 set_opt(sbi, FASTBOOT);
796                 set_sbi_flag(sbi, SBI_IS_DIRTY);
797         }
798 
799         sync_filesystem(sb);
800 
801         sbi->mount_opt.opt = 0;
802         default_options(sbi);
803 
804         /* parse mount options */
805         err = parse_options(sb, data);
806         if (err)
807                 goto restore_opts;
808 
809         /*
810          * Previous and new state of filesystem is RO,
811          * so skip checking GC and FLUSH_MERGE conditions.
812          */
813         if (f2fs_readonly(sb) && (*flags & MS_RDONLY))
814                 goto skip;
815 
816         /* disallow enable/disable extent_cache dynamically */
817         if (no_extent_cache == !!test_opt(sbi, EXTENT_CACHE)) {
818                 err = -EINVAL;
819                 f2fs_msg(sbi->sb, KERN_WARNING,
820                                 "switch extent_cache option is not allowed");
821                 goto restore_opts;
822         }
823 
824         /*
825          * We stop the GC thread if FS is mounted as RO
826          * or if background_gc = off is passed in mount
827          * option. Also sync the filesystem.
828          */
829         if ((*flags & MS_RDONLY) || !test_opt(sbi, BG_GC)) {
830                 if (sbi->gc_thread) {
831                         stop_gc_thread(sbi);
832                         f2fs_sync_fs(sb, 1);
833                         need_restart_gc = true;
834                 }
835         } else if (!sbi->gc_thread) {
836                 err = start_gc_thread(sbi);
837                 if (err)
838                         goto restore_opts;
839                 need_stop_gc = true;
840         }
841 
842         /*
843          * We stop issue flush thread if FS is mounted as RO
844          * or if flush_merge is not passed in mount option.
845          */
846         if ((*flags & MS_RDONLY) || !test_opt(sbi, FLUSH_MERGE)) {
847                 destroy_flush_cmd_control(sbi);
848         } else if (!SM_I(sbi)->cmd_control_info) {
849                 err = create_flush_cmd_control(sbi);
850                 if (err)
851                         goto restore_gc;
852         }
853 skip:
854         /* Update the POSIXACL Flag */
855          sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
856                 (test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0);
857         return 0;
858 restore_gc:
859         if (need_restart_gc) {
860                 if (start_gc_thread(sbi))
861                         f2fs_msg(sbi->sb, KERN_WARNING,
862                                 "background gc thread has stopped");
863         } else if (need_stop_gc) {
864                 stop_gc_thread(sbi);
865         }
866 restore_opts:
867         sbi->mount_opt = org_mount_opt;
868         sbi->active_logs = active_logs;
869         return err;
870 }
871 
872 static struct super_operations f2fs_sops = {
873         .alloc_inode    = f2fs_alloc_inode,
874         .drop_inode     = f2fs_drop_inode,
875         .destroy_inode  = f2fs_destroy_inode,
876         .write_inode    = f2fs_write_inode,
877         .dirty_inode    = f2fs_dirty_inode,
878         .show_options   = f2fs_show_options,
879         .evict_inode    = f2fs_evict_inode,
880         .put_super      = f2fs_put_super,
881         .sync_fs        = f2fs_sync_fs,
882         .freeze_fs      = f2fs_freeze,
883         .unfreeze_fs    = f2fs_unfreeze,
884         .statfs         = f2fs_statfs,
885         .remount_fs     = f2fs_remount,
886 };
887 
888 #ifdef CONFIG_F2FS_FS_ENCRYPTION
889 static int f2fs_get_context(struct inode *inode, void *ctx, size_t len)
890 {
891         return f2fs_getxattr(inode, F2FS_XATTR_INDEX_ENCRYPTION,
892                                 F2FS_XATTR_NAME_ENCRYPTION_CONTEXT,
893                                 ctx, len, NULL);
894 }
895 
896 static int f2fs_key_prefix(struct inode *inode, u8 **key)
897 {
898         *key = F2FS_I_SB(inode)->key_prefix;
899         return F2FS_I_SB(inode)->key_prefix_size;
900 }
901 
902 static int f2fs_set_context(struct inode *inode, const void *ctx, size_t len,
903                                                         void *fs_data)
904 {
905         return f2fs_setxattr(inode, F2FS_XATTR_INDEX_ENCRYPTION,
906                                 F2FS_XATTR_NAME_ENCRYPTION_CONTEXT,
907                                 ctx, len, fs_data, XATTR_CREATE);
908 }
909 
910 static unsigned f2fs_max_namelen(struct inode *inode)
911 {
912         return S_ISLNK(inode->i_mode) ?
913                         inode->i_sb->s_blocksize : F2FS_NAME_LEN;
914 }
915 
916 static struct fscrypt_operations f2fs_cryptops = {
917         .get_context    = f2fs_get_context,
918         .key_prefix     = f2fs_key_prefix,
919         .set_context    = f2fs_set_context,
920         .is_encrypted   = f2fs_encrypted_inode,
921         .empty_dir      = f2fs_empty_dir,
922         .max_namelen    = f2fs_max_namelen,
923 };
924 #else
925 static struct fscrypt_operations f2fs_cryptops = {
926         .is_encrypted   = f2fs_encrypted_inode,
927 };
928 #endif
929 
930 static struct inode *f2fs_nfs_get_inode(struct super_block *sb,
931                 u64 ino, u32 generation)
932 {
933         struct f2fs_sb_info *sbi = F2FS_SB(sb);
934         struct inode *inode;
935 
936         if (check_nid_range(sbi, ino))
937                 return ERR_PTR(-ESTALE);
938 
939         /*
940          * f2fs_iget isn't quite right if the inode is currently unallocated!
941          * However f2fs_iget currently does appropriate checks to handle stale
942          * inodes so everything is OK.
943          */
944         inode = f2fs_iget(sb, ino);
945         if (IS_ERR(inode))
946                 return ERR_CAST(inode);
947         if (unlikely(generation && inode->i_generation != generation)) {
948                 /* we didn't find the right inode.. */
949                 iput(inode);
950                 return ERR_PTR(-ESTALE);
951         }
952         return inode;
953 }
954 
955 static struct dentry *f2fs_fh_to_dentry(struct super_block *sb, struct fid *fid,
956                 int fh_len, int fh_type)
957 {
958         return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
959                                     f2fs_nfs_get_inode);
960 }
961 
962 static struct dentry *f2fs_fh_to_parent(struct super_block *sb, struct fid *fid,
963                 int fh_len, int fh_type)
964 {
965         return generic_fh_to_parent(sb, fid, fh_len, fh_type,
966                                     f2fs_nfs_get_inode);
967 }
968 
969 static const struct export_operations f2fs_export_ops = {
970         .fh_to_dentry = f2fs_fh_to_dentry,
971         .fh_to_parent = f2fs_fh_to_parent,
972         .get_parent = f2fs_get_parent,
973 };
974 
975 static loff_t max_file_blocks(void)
976 {
977         loff_t result = (DEF_ADDRS_PER_INODE - F2FS_INLINE_XATTR_ADDRS);
978         loff_t leaf_count = ADDRS_PER_BLOCK;
979 
980         /* two direct node blocks */
981         result += (leaf_count * 2);
982 
983         /* two indirect node blocks */
984         leaf_count *= NIDS_PER_BLOCK;
985         result += (leaf_count * 2);
986 
987         /* one double indirect node block */
988         leaf_count *= NIDS_PER_BLOCK;
989         result += leaf_count;
990 
991         return result;
992 }
993 
994 static int __f2fs_commit_super(struct buffer_head *bh,
995                         struct f2fs_super_block *super)
996 {
997         lock_buffer(bh);
998         if (super)
999                 memcpy(bh->b_data + F2FS_SUPER_OFFSET, super, sizeof(*super));
1000         set_buffer_uptodate(bh);
1001         set_buffer_dirty(bh);
1002         unlock_buffer(bh);
1003 
1004         /* it's rare case, we can do fua all the time */
1005         return __sync_dirty_buffer(bh, WRITE_FLUSH_FUA);
1006 }
1007 
1008 static inline bool sanity_check_area_boundary(struct super_block *sb,
1009                                         struct buffer_head *bh)
1010 {
1011         struct f2fs_super_block *raw_super = (struct f2fs_super_block *)
1012                                         (bh->b_data + F2FS_SUPER_OFFSET);
1013         u32 segment0_blkaddr = le32_to_cpu(raw_super->segment0_blkaddr);
1014         u32 cp_blkaddr = le32_to_cpu(raw_super->cp_blkaddr);
1015         u32 sit_blkaddr = le32_to_cpu(raw_super->sit_blkaddr);
1016         u32 nat_blkaddr = le32_to_cpu(raw_super->nat_blkaddr);
1017         u32 ssa_blkaddr = le32_to_cpu(raw_super->ssa_blkaddr);
1018         u32 main_blkaddr = le32_to_cpu(raw_super->main_blkaddr);
1019         u32 segment_count_ckpt = le32_to_cpu(raw_super->segment_count_ckpt);
1020         u32 segment_count_sit = le32_to_cpu(raw_super->segment_count_sit);
1021         u32 segment_count_nat = le32_to_cpu(raw_super->segment_count_nat);
1022         u32 segment_count_ssa = le32_to_cpu(raw_super->segment_count_ssa);
1023         u32 segment_count_main = le32_to_cpu(raw_super->segment_count_main);
1024         u32 segment_count = le32_to_cpu(raw_super->segment_count);
1025         u32 log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);
1026         u64 main_end_blkaddr = main_blkaddr +
1027                                 (segment_count_main << log_blocks_per_seg);
1028         u64 seg_end_blkaddr = segment0_blkaddr +
1029                                 (segment_count << log_blocks_per_seg);
1030 
1031         if (segment0_blkaddr != cp_blkaddr) {
1032                 f2fs_msg(sb, KERN_INFO,
1033                         "Mismatch start address, segment0(%u) cp_blkaddr(%u)",
1034                         segment0_blkaddr, cp_blkaddr);
1035                 return true;
1036         }
1037 
1038         if (cp_blkaddr + (segment_count_ckpt << log_blocks_per_seg) !=
1039                                                         sit_blkaddr) {
1040                 f2fs_msg(sb, KERN_INFO,
1041                         "Wrong CP boundary, start(%u) end(%u) blocks(%u)",
1042                         cp_blkaddr, sit_blkaddr,
1043                         segment_count_ckpt << log_blocks_per_seg);
1044                 return true;
1045         }
1046 
1047         if (sit_blkaddr + (segment_count_sit << log_blocks_per_seg) !=
1048                                                         nat_blkaddr) {
1049                 f2fs_msg(sb, KERN_INFO,
1050                         "Wrong SIT boundary, start(%u) end(%u) blocks(%u)",
1051                         sit_blkaddr, nat_blkaddr,
1052                         segment_count_sit << log_blocks_per_seg);
1053                 return true;
1054         }
1055 
1056         if (nat_blkaddr + (segment_count_nat << log_blocks_per_seg) !=
1057                                                         ssa_blkaddr) {
1058                 f2fs_msg(sb, KERN_INFO,
1059                         "Wrong NAT boundary, start(%u) end(%u) blocks(%u)",
1060                         nat_blkaddr, ssa_blkaddr,
1061                         segment_count_nat << log_blocks_per_seg);
1062                 return true;
1063         }
1064 
1065         if (ssa_blkaddr + (segment_count_ssa << log_blocks_per_seg) !=
1066                                                         main_blkaddr) {
1067                 f2fs_msg(sb, KERN_INFO,
1068                         "Wrong SSA boundary, start(%u) end(%u) blocks(%u)",
1069                         ssa_blkaddr, main_blkaddr,
1070                         segment_count_ssa << log_blocks_per_seg);
1071                 return true;
1072         }
1073 
1074         if (main_end_blkaddr > seg_end_blkaddr) {
1075                 f2fs_msg(sb, KERN_INFO,
1076                         "Wrong MAIN_AREA boundary, start(%u) end(%u) block(%u)",
1077                         main_blkaddr,
1078                         segment0_blkaddr +
1079                                 (segment_count << log_blocks_per_seg),
1080                         segment_count_main << log_blocks_per_seg);
1081                 return true;
1082         } else if (main_end_blkaddr < seg_end_blkaddr) {
1083                 int err = 0;
1084                 char *res;
1085 
1086                 /* fix in-memory information all the time */
1087                 raw_super->segment_count = cpu_to_le32((main_end_blkaddr -
1088                                 segment0_blkaddr) >> log_blocks_per_seg);
1089 
1090                 if (f2fs_readonly(sb) || bdev_read_only(sb->s_bdev)) {
1091                         res = "internally";
1092                 } else {
1093                         err = __f2fs_commit_super(bh, NULL);
1094                         res = err ? "failed" : "done";
1095                 }
1096                 f2fs_msg(sb, KERN_INFO,
1097                         "Fix alignment : %s, start(%u) end(%u) block(%u)",
1098                         res, main_blkaddr,
1099                         segment0_blkaddr +
1100                                 (segment_count << log_blocks_per_seg),
1101                         segment_count_main << log_blocks_per_seg);
1102                 if (err)
1103                         return true;
1104         }
1105         return false;
1106 }
1107 
1108 static int sanity_check_raw_super(struct super_block *sb,
1109                                 struct buffer_head *bh)
1110 {
1111         struct f2fs_super_block *raw_super = (struct f2fs_super_block *)
1112                                         (bh->b_data + F2FS_SUPER_OFFSET);
1113         unsigned int blocksize;
1114 
1115         if (F2FS_SUPER_MAGIC != le32_to_cpu(raw_super->magic)) {
1116                 f2fs_msg(sb, KERN_INFO,
1117                         "Magic Mismatch, valid(0x%x) - read(0x%x)",
1118                         F2FS_SUPER_MAGIC, le32_to_cpu(raw_super->magic));
1119                 return 1;
1120         }
1121 
1122         /* Currently, support only 4KB page cache size */
1123         if (F2FS_BLKSIZE != PAGE_SIZE) {
1124                 f2fs_msg(sb, KERN_INFO,
1125                         "Invalid page_cache_size (%lu), supports only 4KB\n",
1126                         PAGE_SIZE);
1127                 return 1;
1128         }
1129 
1130         /* Currently, support only 4KB block size */
1131         blocksize = 1 << le32_to_cpu(raw_super->log_blocksize);
1132         if (blocksize != F2FS_BLKSIZE) {
1133                 f2fs_msg(sb, KERN_INFO,
1134                         "Invalid blocksize (%u), supports only 4KB\n",
1135                         blocksize);
1136                 return 1;
1137         }
1138 
1139         /* check log blocks per segment */
1140         if (le32_to_cpu(raw_super->log_blocks_per_seg) != 9) {
1141                 f2fs_msg(sb, KERN_INFO,
1142                         "Invalid log blocks per segment (%u)\n",
1143                         le32_to_cpu(raw_super->log_blocks_per_seg));
1144                 return 1;
1145         }
1146 
1147         /* Currently, support 512/1024/2048/4096 bytes sector size */
1148         if (le32_to_cpu(raw_super->log_sectorsize) >
1149                                 F2FS_MAX_LOG_SECTOR_SIZE ||
1150                 le32_to_cpu(raw_super->log_sectorsize) <
1151                                 F2FS_MIN_LOG_SECTOR_SIZE) {
1152                 f2fs_msg(sb, KERN_INFO, "Invalid log sectorsize (%u)",
1153                         le32_to_cpu(raw_super->log_sectorsize));
1154                 return 1;
1155         }
1156         if (le32_to_cpu(raw_super->log_sectors_per_block) +
1157                 le32_to_cpu(raw_super->log_sectorsize) !=
1158                         F2FS_MAX_LOG_SECTOR_SIZE) {
1159                 f2fs_msg(sb, KERN_INFO,
1160                         "Invalid log sectors per block(%u) log sectorsize(%u)",
1161                         le32_to_cpu(raw_super->log_sectors_per_block),
1162                         le32_to_cpu(raw_super->log_sectorsize));
1163                 return 1;
1164         }
1165 
1166         /* check reserved ino info */
1167         if (le32_to_cpu(raw_super->node_ino) != 1 ||
1168                 le32_to_cpu(raw_super->meta_ino) != 2 ||
1169                 le32_to_cpu(raw_super->root_ino) != 3) {
1170                 f2fs_msg(sb, KERN_INFO,
1171                         "Invalid Fs Meta Ino: node(%u) meta(%u) root(%u)",
1172                         le32_to_cpu(raw_super->node_ino),
1173                         le32_to_cpu(raw_super->meta_ino),
1174                         le32_to_cpu(raw_super->root_ino));
1175                 return 1;
1176         }
1177 
1178         /* check CP/SIT/NAT/SSA/MAIN_AREA area boundary */
1179         if (sanity_check_area_boundary(sb, bh))
1180                 return 1;
1181 
1182         return 0;
1183 }
1184 
1185 int sanity_check_ckpt(struct f2fs_sb_info *sbi)
1186 {
1187         unsigned int total, fsmeta;
1188         struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
1189         struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
1190 
1191         total = le32_to_cpu(raw_super->segment_count);
1192         fsmeta = le32_to_cpu(raw_super->segment_count_ckpt);
1193         fsmeta += le32_to_cpu(raw_super->segment_count_sit);
1194         fsmeta += le32_to_cpu(raw_super->segment_count_nat);
1195         fsmeta += le32_to_cpu(ckpt->rsvd_segment_count);
1196         fsmeta += le32_to_cpu(raw_super->segment_count_ssa);
1197 
1198         if (unlikely(fsmeta >= total))
1199                 return 1;
1200 
1201         if (unlikely(f2fs_cp_error(sbi))) {
1202                 f2fs_msg(sbi->sb, KERN_ERR, "A bug case: need to run fsck");
1203                 return 1;
1204         }
1205         return 0;
1206 }
1207 
1208 static void init_sb_info(struct f2fs_sb_info *sbi)
1209 {
1210         struct f2fs_super_block *raw_super = sbi->raw_super;
1211         int i;
1212 
1213         sbi->log_sectors_per_block =
1214                 le32_to_cpu(raw_super->log_sectors_per_block);
1215         sbi->log_blocksize = le32_to_cpu(raw_super->log_blocksize);
1216         sbi->blocksize = 1 << sbi->log_blocksize;
1217         sbi->log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);
1218         sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg;
1219         sbi->segs_per_sec = le32_to_cpu(raw_super->segs_per_sec);
1220         sbi->secs_per_zone = le32_to_cpu(raw_super->secs_per_zone);
1221         sbi->total_sections = le32_to_cpu(raw_super->section_count);
1222         sbi->total_node_count =
1223                 (le32_to_cpu(raw_super->segment_count_nat) / 2)
1224                         * sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK;
1225         sbi->root_ino_num = le32_to_cpu(raw_super->root_ino);
1226         sbi->node_ino_num = le32_to_cpu(raw_super->node_ino);
1227         sbi->meta_ino_num = le32_to_cpu(raw_super->meta_ino);
1228         sbi->cur_victim_sec = NULL_SECNO;
1229         sbi->max_victim_search = DEF_MAX_VICTIM_SEARCH;
1230 
1231         for (i = 0; i < NR_COUNT_TYPE; i++)
1232                 atomic_set(&sbi->nr_pages[i], 0);
1233 
1234         sbi->dir_level = DEF_DIR_LEVEL;
1235         sbi->interval_time[CP_TIME] = DEF_CP_INTERVAL;
1236         sbi->interval_time[REQ_TIME] = DEF_IDLE_INTERVAL;
1237         clear_sbi_flag(sbi, SBI_NEED_FSCK);
1238 
1239         INIT_LIST_HEAD(&sbi->s_list);
1240         mutex_init(&sbi->umount_mutex);
1241 
1242 #ifdef CONFIG_F2FS_FS_ENCRYPTION
1243         memcpy(sbi->key_prefix, F2FS_KEY_DESC_PREFIX,
1244                                 F2FS_KEY_DESC_PREFIX_SIZE);
1245         sbi->key_prefix_size = F2FS_KEY_DESC_PREFIX_SIZE;
1246 #endif
1247 }
1248 
1249 /*
1250  * Read f2fs raw super block.
1251  * Because we have two copies of super block, so read both of them
1252  * to get the first valid one. If any one of them is broken, we pass
1253  * them recovery flag back to the caller.
1254  */
1255 static int read_raw_super_block(struct super_block *sb,
1256                         struct f2fs_super_block **raw_super,
1257                         int *valid_super_block, int *recovery)
1258 {
1259         int block;
1260         struct buffer_head *bh;
1261         struct f2fs_super_block *super;
1262         int err = 0;
1263 
1264         super = kzalloc(sizeof(struct f2fs_super_block), GFP_KERNEL);
1265         if (!super)
1266                 return -ENOMEM;
1267 
1268         for (block = 0; block < 2; block++) {
1269                 bh = sb_bread(sb, block);
1270                 if (!bh) {
1271                         f2fs_msg(sb, KERN_ERR, "Unable to read %dth superblock",
1272                                 block + 1);
1273                         err = -EIO;
1274                         continue;
1275                 }
1276 
1277                 /* sanity checking of raw super */
1278                 if (sanity_check_raw_super(sb, bh)) {
1279                         f2fs_msg(sb, KERN_ERR,
1280                                 "Can't find valid F2FS filesystem in %dth superblock",
1281                                 block + 1);
1282                         err = -EINVAL;
1283                         brelse(bh);
1284                         continue;
1285                 }
1286 
1287                 if (!*raw_super) {
1288                         memcpy(super, bh->b_data + F2FS_SUPER_OFFSET,
1289                                                         sizeof(*super));
1290                         *valid_super_block = block;
1291                         *raw_super = super;
1292                 }
1293                 brelse(bh);
1294         }
1295 
1296         /* Fail to read any one of the superblocks*/
1297         if (err < 0)
1298                 *recovery = 1;
1299 
1300         /* No valid superblock */
1301         if (!*raw_super)
1302                 kfree(super);
1303         else
1304                 err = 0;
1305 
1306         return err;
1307 }
1308 
1309 int f2fs_commit_super(struct f2fs_sb_info *sbi, bool recover)
1310 {
1311         struct buffer_head *bh;
1312         int err;
1313 
1314         /* write back-up superblock first */
1315         bh = sb_getblk(sbi->sb, sbi->valid_super_block ? 0: 1);
1316         if (!bh)
1317                 return -EIO;
1318         err = __f2fs_commit_super(bh, F2FS_RAW_SUPER(sbi));
1319         brelse(bh);
1320 
1321         /* if we are in recovery path, skip writing valid superblock */
1322         if (recover || err)
1323                 return err;
1324 
1325         /* write current valid superblock */
1326         bh = sb_getblk(sbi->sb, sbi->valid_super_block);
1327         if (!bh)
1328                 return -EIO;
1329         err = __f2fs_commit_super(bh, F2FS_RAW_SUPER(sbi));
1330         brelse(bh);
1331         return err;
1332 }
1333 
1334 static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
1335 {
1336         struct f2fs_sb_info *sbi;
1337         struct f2fs_super_block *raw_super;
1338         struct inode *root;
1339         long err;
1340         bool retry = true, need_fsck = false;
1341         char *options = NULL;
1342         int recovery, i, valid_super_block;
1343         struct curseg_info *seg_i;
1344 
1345 try_onemore:
1346         err = -EINVAL;
1347         raw_super = NULL;
1348         valid_super_block = -1;
1349         recovery = 0;
1350 
1351         /* allocate memory for f2fs-specific super block info */
1352         sbi = kzalloc(sizeof(struct f2fs_sb_info), GFP_KERNEL);
1353         if (!sbi)
1354                 return -ENOMEM;
1355 
1356         /* Load the checksum driver */
1357         sbi->s_chksum_driver = crypto_alloc_shash("crc32", 0, 0);
1358         if (IS_ERR(sbi->s_chksum_driver)) {
1359                 f2fs_msg(sb, KERN_ERR, "Cannot load crc32 driver.");
1360                 err = PTR_ERR(sbi->s_chksum_driver);
1361                 sbi->s_chksum_driver = NULL;
1362                 goto free_sbi;
1363         }
1364 
1365         /* set a block size */
1366         if (unlikely(!sb_set_blocksize(sb, F2FS_BLKSIZE))) {
1367                 f2fs_msg(sb, KERN_ERR, "unable to set blocksize");
1368                 goto free_sbi;
1369         }
1370 
1371         err = read_raw_super_block(sb, &raw_super, &valid_super_block,
1372                                                                 &recovery);
1373         if (err)
1374                 goto free_sbi;
1375 
1376         sb->s_fs_info = sbi;
1377         default_options(sbi);
1378         /* parse mount options */
1379         options = kstrdup((const char *)data, GFP_KERNEL);
1380         if (data && !options) {
1381                 err = -ENOMEM;
1382                 goto free_sb_buf;
1383         }
1384 
1385         err = parse_options(sb, options);
1386         if (err)
1387                 goto free_options;
1388 
1389         sbi->max_file_blocks = max_file_blocks();
1390         sb->s_maxbytes = sbi->max_file_blocks <<
1391                                 le32_to_cpu(raw_super->log_blocksize);
1392         sb->s_max_links = F2FS_LINK_MAX;
1393         get_random_bytes(&sbi->s_next_generation, sizeof(u32));
1394 
1395         sb->s_op = &f2fs_sops;
1396         sb->s_cop = &f2fs_cryptops;
1397         sb->s_xattr = f2fs_xattr_handlers;
1398         sb->s_export_op = &f2fs_export_ops;
1399         sb->s_magic = F2FS_SUPER_MAGIC;
1400         sb->s_time_gran = 1;
1401         sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
1402                 (test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0);
1403         memcpy(sb->s_uuid, raw_super->uuid, sizeof(raw_super->uuid));
1404 
1405         /* init f2fs-specific super block info */
1406         sbi->sb = sb;
1407         sbi->raw_super = raw_super;
1408         sbi->valid_super_block = valid_super_block;
1409         mutex_init(&sbi->gc_mutex);
1410         mutex_init(&sbi->writepages);
1411         mutex_init(&sbi->cp_mutex);
1412         init_rwsem(&sbi->node_write);
1413 
1414         /* disallow all the data/node/meta page writes */
1415         set_sbi_flag(sbi, SBI_POR_DOING);
1416         spin_lock_init(&sbi->stat_lock);
1417 
1418         init_rwsem(&sbi->read_io.io_rwsem);
1419         sbi->read_io.sbi = sbi;
1420         sbi->read_io.bio = NULL;
1421         for (i = 0; i < NR_PAGE_TYPE; i++) {
1422                 init_rwsem(&sbi->write_io[i].io_rwsem);
1423                 sbi->write_io[i].sbi = sbi;
1424                 sbi->write_io[i].bio = NULL;
1425         }
1426 
1427         init_rwsem(&sbi->cp_rwsem);
1428         init_waitqueue_head(&sbi->cp_wait);
1429         init_sb_info(sbi);
1430 
1431         /* get an inode for meta space */
1432         sbi->meta_inode = f2fs_iget(sb, F2FS_META_INO(sbi));
1433         if (IS_ERR(sbi->meta_inode)) {
1434                 f2fs_msg(sb, KERN_ERR, "Failed to read F2FS meta data inode");
1435                 err = PTR_ERR(sbi->meta_inode);
1436                 goto free_options;
1437         }
1438 
1439         err = get_valid_checkpoint(sbi);
1440         if (err) {
1441                 f2fs_msg(sb, KERN_ERR, "Failed to get valid F2FS checkpoint");
1442                 goto free_meta_inode;
1443         }
1444 
1445         sbi->total_valid_node_count =
1446                                 le32_to_cpu(sbi->ckpt->valid_node_count);
1447         sbi->total_valid_inode_count =
1448                                 le32_to_cpu(sbi->ckpt->valid_inode_count);
1449         sbi->user_block_count = le64_to_cpu(sbi->ckpt->user_block_count);
1450         sbi->total_valid_block_count =
1451                                 le64_to_cpu(sbi->ckpt->valid_block_count);
1452         sbi->last_valid_block_count = sbi->total_valid_block_count;
1453         sbi->alloc_valid_block_count = 0;
1454         for (i = 0; i < NR_INODE_TYPE; i++) {
1455                 INIT_LIST_HEAD(&sbi->inode_list[i]);
1456                 spin_lock_init(&sbi->inode_lock[i]);
1457         }
1458 
1459         init_extent_cache_info(sbi);
1460 
1461         init_ino_entry_info(sbi);
1462 
1463         /* setup f2fs internal modules */
1464         err = build_segment_manager(sbi);
1465         if (err) {
1466                 f2fs_msg(sb, KERN_ERR,
1467                         "Failed to initialize F2FS segment manager");
1468                 goto free_sm;
1469         }
1470         err = build_node_manager(sbi);
1471         if (err) {
1472                 f2fs_msg(sb, KERN_ERR,
1473                         "Failed to initialize F2FS node manager");
1474                 goto free_nm;
1475         }
1476 
1477         /* For write statistics */
1478         if (sb->s_bdev->bd_part)
1479                 sbi->sectors_written_start =
1480                         (u64)part_stat_read(sb->s_bdev->bd_part, sectors[1]);
1481 
1482         /* Read accumulated write IO statistics if exists */
1483         seg_i = CURSEG_I(sbi, CURSEG_HOT_NODE);
1484         if (__exist_node_summaries(sbi))
1485                 sbi->kbytes_written =
1486                         le64_to_cpu(seg_i->journal->info.kbytes_written);
1487 
1488         build_gc_manager(sbi);
1489 
1490         /* get an inode for node space */
1491         sbi->node_inode = f2fs_iget(sb, F2FS_NODE_INO(sbi));
1492         if (IS_ERR(sbi->node_inode)) {
1493                 f2fs_msg(sb, KERN_ERR, "Failed to read node inode");
1494                 err = PTR_ERR(sbi->node_inode);
1495                 goto free_nm;
1496         }
1497 
1498         f2fs_join_shrinker(sbi);
1499 
1500         /* if there are nt orphan nodes free them */
1501         err = recover_orphan_inodes(sbi);
1502         if (err)
1503                 goto free_node_inode;
1504 
1505         /* read root inode and dentry */
1506         root = f2fs_iget(sb, F2FS_ROOT_INO(sbi));
1507         if (IS_ERR(root)) {
1508                 f2fs_msg(sb, KERN_ERR, "Failed to read root inode");
1509                 err = PTR_ERR(root);
1510                 goto free_node_inode;
1511         }
1512         if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
1513                 iput(root);
1514                 err = -EINVAL;
1515                 goto free_node_inode;
1516         }
1517 
1518         sb->s_root = d_make_root(root); /* allocate root dentry */
1519         if (!sb->s_root) {
1520                 err = -ENOMEM;
1521                 goto free_root_inode;
1522         }
1523 
1524         err = f2fs_build_stats(sbi);
1525         if (err)
1526                 goto free_root_inode;
1527 
1528         if (f2fs_proc_root)
1529                 sbi->s_proc = proc_mkdir(sb->s_id, f2fs_proc_root);
1530 
1531         if (sbi->s_proc)
1532                 proc_create_data("segment_info", S_IRUGO, sbi->s_proc,
1533                                  &f2fs_seq_segment_info_fops, sb);
1534 
1535         sbi->s_kobj.kset = f2fs_kset;
1536         init_completion(&sbi->s_kobj_unregister);
1537         err = kobject_init_and_add(&sbi->s_kobj, &f2fs_ktype, NULL,
1538                                                         "%s", sb->s_id);
1539         if (err)
1540                 goto free_proc;
1541 
1542         /* recover fsynced data */
1543         if (!test_opt(sbi, DISABLE_ROLL_FORWARD)) {
1544                 /*
1545                  * mount should be failed, when device has readonly mode, and
1546                  * previous checkpoint was not done by clean system shutdown.
1547                  */
1548                 if (bdev_read_only(sb->s_bdev) &&
1549                                 !is_set_ckpt_flags(sbi->ckpt, CP_UMOUNT_FLAG)) {
1550                         err = -EROFS;
1551                         goto free_kobj;
1552                 }
1553 
1554                 if (need_fsck)
1555                         set_sbi_flag(sbi, SBI_NEED_FSCK);
1556 
1557                 err = recover_fsync_data(sbi);
1558                 if (err) {
1559                         need_fsck = true;
1560                         f2fs_msg(sb, KERN_ERR,
1561                                 "Cannot recover all fsync data errno=%ld", err);
1562                         goto free_kobj;
1563                 }
1564         }
1565         /* recover_fsync_data() cleared this already */
1566         clear_sbi_flag(sbi, SBI_POR_DOING);
1567 
1568         /*
1569          * If filesystem is not mounted as read-only then
1570          * do start the gc_thread.
1571          */
1572         if (test_opt(sbi, BG_GC) && !f2fs_readonly(sb)) {
1573                 /* After POR, we can run background GC thread.*/
1574                 err = start_gc_thread(sbi);
1575                 if (err)
1576                         goto free_kobj;
1577         }
1578         kfree(options);
1579 
1580         /* recover broken superblock */
1581         if (recovery && !f2fs_readonly(sb) && !bdev_read_only(sb->s_bdev)) {
1582                 err = f2fs_commit_super(sbi, true);
1583                 f2fs_msg(sb, KERN_INFO,
1584                         "Try to recover %dth superblock, ret: %ld",
1585                         sbi->valid_super_block ? 1 : 2, err);
1586         }
1587 
1588         f2fs_update_time(sbi, CP_TIME);
1589         f2fs_update_time(sbi, REQ_TIME);
1590         return 0;
1591 
1592 free_kobj:
1593         kobject_del(&sbi->s_kobj);
1594         kobject_put(&sbi->s_kobj);
1595         wait_for_completion(&sbi->s_kobj_unregister);
1596 free_proc:
1597         if (sbi->s_proc) {
1598                 remove_proc_entry("segment_info", sbi->s_proc);
1599                 remove_proc_entry(sb->s_id, f2fs_proc_root);
1600         }
1601         f2fs_destroy_stats(sbi);
1602 free_root_inode:
1603         dput(sb->s_root);
1604         sb->s_root = NULL;
1605 free_node_inode:
1606         mutex_lock(&sbi->umount_mutex);
1607         f2fs_leave_shrinker(sbi);
1608         iput(sbi->node_inode);
1609         mutex_unlock(&sbi->umount_mutex);
1610 free_nm:
1611         destroy_node_manager(sbi);
1612 free_sm:
1613         destroy_segment_manager(sbi);
1614         kfree(sbi->ckpt);
1615 free_meta_inode:
1616         make_bad_inode(sbi->meta_inode);
1617         iput(sbi->meta_inode);
1618 free_options:
1619         kfree(options);
1620 free_sb_buf:
1621         kfree(raw_super);
1622 free_sbi:
1623         if (sbi->s_chksum_driver)
1624                 crypto_free_shash(sbi->s_chksum_driver);
1625         kfree(sbi);
1626 
1627         /* give only one another chance */
1628         if (retry) {
1629                 retry = false;
1630                 shrink_dcache_sb(sb);
1631                 goto try_onemore;
1632         }
1633         return err;
1634 }
1635 
1636 static struct dentry *f2fs_mount(struct file_system_type *fs_type, int flags,
1637                         const char *dev_name, void *data)
1638 {
1639         return mount_bdev(fs_type, flags, dev_name, data, f2fs_fill_super);
1640 }
1641 
1642 static void kill_f2fs_super(struct super_block *sb)
1643 {
1644         if (sb->s_root)
1645                 set_sbi_flag(F2FS_SB(sb), SBI_IS_CLOSE);
1646         kill_block_super(sb);
1647 }
1648 
1649 static struct file_system_type f2fs_fs_type = {
1650         .owner          = THIS_MODULE,
1651         .name           = "f2fs",
1652         .mount          = f2fs_mount,
1653         .kill_sb        = kill_f2fs_super,
1654         .fs_flags       = FS_REQUIRES_DEV,
1655 };
1656 MODULE_ALIAS_FS("f2fs");
1657 
1658 static int __init init_inodecache(void)
1659 {
1660         f2fs_inode_cachep = kmem_cache_create("f2fs_inode_cache",
1661                         sizeof(struct f2fs_inode_info), 0,
1662                         SLAB_RECLAIM_ACCOUNT|SLAB_ACCOUNT, NULL);
1663         if (!f2fs_inode_cachep)
1664                 return -ENOMEM;
1665         return 0;
1666 }
1667 
1668 static void destroy_inodecache(void)
1669 {
1670         /*
1671          * Make sure all delayed rcu free inodes are flushed before we
1672          * destroy cache.
1673          */
1674         rcu_barrier();
1675         kmem_cache_destroy(f2fs_inode_cachep);
1676 }
1677 
1678 static int __init init_f2fs_fs(void)
1679 {
1680         int err;
1681 
1682         f2fs_build_trace_ios();
1683 
1684         err = init_inodecache();
1685         if (err)
1686                 goto fail;
1687         err = create_node_manager_caches();
1688         if (err)
1689                 goto free_inodecache;
1690         err = create_segment_manager_caches();
1691         if (err)
1692                 goto free_node_manager_caches;
1693         err = create_checkpoint_caches();
1694         if (err)
1695                 goto free_segment_manager_caches;
1696         err = create_extent_cache();
1697         if (err)
1698                 goto free_checkpoint_caches;
1699         f2fs_kset = kset_create_and_add("f2fs", NULL, fs_kobj);
1700         if (!f2fs_kset) {
1701                 err = -ENOMEM;
1702                 goto free_extent_cache;
1703         }
1704         err = register_shrinker(&f2fs_shrinker_info);
1705         if (err)
1706                 goto free_kset;
1707 
1708         err = register_filesystem(&f2fs_fs_type);
1709         if (err)
1710                 goto free_shrinker;
1711         err = f2fs_create_root_stats();
1712         if (err)
1713                 goto free_filesystem;
1714         f2fs_proc_root = proc_mkdir("fs/f2fs", NULL);
1715         return 0;
1716 
1717 free_filesystem:
1718         unregister_filesystem(&f2fs_fs_type);
1719 free_shrinker:
1720         unregister_shrinker(&f2fs_shrinker_info);
1721 free_kset:
1722         kset_unregister(f2fs_kset);
1723 free_extent_cache:
1724         destroy_extent_cache();
1725 free_checkpoint_caches:
1726         destroy_checkpoint_caches();
1727 free_segment_manager_caches:
1728         destroy_segment_manager_caches();
1729 free_node_manager_caches:
1730         destroy_node_manager_caches();
1731 free_inodecache:
1732         destroy_inodecache();
1733 fail:
1734         return err;
1735 }
1736 
1737 static void __exit exit_f2fs_fs(void)
1738 {
1739         remove_proc_entry("fs/f2fs", NULL);
1740         f2fs_destroy_root_stats();
1741         unregister_shrinker(&f2fs_shrinker_info);
1742         unregister_filesystem(&f2fs_fs_type);
1743         destroy_extent_cache();
1744         destroy_checkpoint_caches();
1745         destroy_segment_manager_caches();
1746         destroy_node_manager_caches();
1747         destroy_inodecache();
1748         kset_unregister(f2fs_kset);
1749         f2fs_destroy_trace_ios();
1750 }
1751 
1752 module_init(init_f2fs_fs)
1753 module_exit(exit_f2fs_fs)
1754 
1755 MODULE_AUTHOR("Samsung Electronics's Praesto Team");
1756 MODULE_DESCRIPTION("Flash Friendly File System");
1757 MODULE_LICENSE("GPL");
1758 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp