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 34 #define CREATE_TRACE_POINTS 35 #include <trace/events/f2fs.h> 36 37 static struct proc_dir_entry *f2fs_proc_root; 38 static struct kmem_cache *f2fs_inode_cachep; 39 static struct kset *f2fs_kset; 40 41 enum { 42 Opt_gc_background, 43 Opt_disable_roll_forward, 44 Opt_discard, 45 Opt_noheap, 46 Opt_user_xattr, 47 Opt_nouser_xattr, 48 Opt_acl, 49 Opt_noacl, 50 Opt_active_logs, 51 Opt_disable_ext_identify, 52 Opt_inline_xattr, 53 Opt_inline_data, 54 Opt_flush_merge, 55 Opt_nobarrier, 56 Opt_err, 57 }; 58 59 static match_table_t f2fs_tokens = { 60 {Opt_gc_background, "background_gc=%s"}, 61 {Opt_disable_roll_forward, "disable_roll_forward"}, 62 {Opt_discard, "discard"}, 63 {Opt_noheap, "no_heap"}, 64 {Opt_user_xattr, "user_xattr"}, 65 {Opt_nouser_xattr, "nouser_xattr"}, 66 {Opt_acl, "acl"}, 67 {Opt_noacl, "noacl"}, 68 {Opt_active_logs, "active_logs=%u"}, 69 {Opt_disable_ext_identify, "disable_ext_identify"}, 70 {Opt_inline_xattr, "inline_xattr"}, 71 {Opt_inline_data, "inline_data"}, 72 {Opt_flush_merge, "flush_merge"}, 73 {Opt_nobarrier, "nobarrier"}, 74 {Opt_err, NULL}, 75 }; 76 77 /* Sysfs support for f2fs */ 78 enum { 79 GC_THREAD, /* struct f2fs_gc_thread */ 80 SM_INFO, /* struct f2fs_sm_info */ 81 NM_INFO, /* struct f2fs_nm_info */ 82 F2FS_SBI, /* struct f2fs_sb_info */ 83 }; 84 85 struct f2fs_attr { 86 struct attribute attr; 87 ssize_t (*show)(struct f2fs_attr *, struct f2fs_sb_info *, char *); 88 ssize_t (*store)(struct f2fs_attr *, struct f2fs_sb_info *, 89 const char *, size_t); 90 int struct_type; 91 int offset; 92 }; 93 94 static unsigned char *__struct_ptr(struct f2fs_sb_info *sbi, int struct_type) 95 { 96 if (struct_type == GC_THREAD) 97 return (unsigned char *)sbi->gc_thread; 98 else if (struct_type == SM_INFO) 99 return (unsigned char *)SM_I(sbi); 100 else if (struct_type == NM_INFO) 101 return (unsigned char *)NM_I(sbi); 102 else if (struct_type == F2FS_SBI) 103 return (unsigned char *)sbi; 104 return NULL; 105 } 106 107 static ssize_t f2fs_sbi_show(struct f2fs_attr *a, 108 struct f2fs_sb_info *sbi, char *buf) 109 { 110 unsigned char *ptr = NULL; 111 unsigned int *ui; 112 113 ptr = __struct_ptr(sbi, a->struct_type); 114 if (!ptr) 115 return -EINVAL; 116 117 ui = (unsigned int *)(ptr + a->offset); 118 119 return snprintf(buf, PAGE_SIZE, "%u\n", *ui); 120 } 121 122 static ssize_t f2fs_sbi_store(struct f2fs_attr *a, 123 struct f2fs_sb_info *sbi, 124 const char *buf, size_t count) 125 { 126 unsigned char *ptr; 127 unsigned long t; 128 unsigned int *ui; 129 ssize_t ret; 130 131 ptr = __struct_ptr(sbi, a->struct_type); 132 if (!ptr) 133 return -EINVAL; 134 135 ui = (unsigned int *)(ptr + a->offset); 136 137 ret = kstrtoul(skip_spaces(buf), 0, &t); 138 if (ret < 0) 139 return ret; 140 *ui = t; 141 return count; 142 } 143 144 static ssize_t f2fs_attr_show(struct kobject *kobj, 145 struct attribute *attr, char *buf) 146 { 147 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, 148 s_kobj); 149 struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr); 150 151 return a->show ? a->show(a, sbi, buf) : 0; 152 } 153 154 static ssize_t f2fs_attr_store(struct kobject *kobj, struct attribute *attr, 155 const char *buf, size_t len) 156 { 157 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, 158 s_kobj); 159 struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr); 160 161 return a->store ? a->store(a, sbi, buf, len) : 0; 162 } 163 164 static void f2fs_sb_release(struct kobject *kobj) 165 { 166 struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info, 167 s_kobj); 168 complete(&sbi->s_kobj_unregister); 169 } 170 171 #define F2FS_ATTR_OFFSET(_struct_type, _name, _mode, _show, _store, _offset) \ 172 static struct f2fs_attr f2fs_attr_##_name = { \ 173 .attr = {.name = __stringify(_name), .mode = _mode }, \ 174 .show = _show, \ 175 .store = _store, \ 176 .struct_type = _struct_type, \ 177 .offset = _offset \ 178 } 179 180 #define F2FS_RW_ATTR(struct_type, struct_name, name, elname) \ 181 F2FS_ATTR_OFFSET(struct_type, name, 0644, \ 182 f2fs_sbi_show, f2fs_sbi_store, \ 183 offsetof(struct struct_name, elname)) 184 185 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_min_sleep_time, min_sleep_time); 186 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_max_sleep_time, max_sleep_time); 187 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_no_gc_sleep_time, no_gc_sleep_time); 188 F2FS_RW_ATTR(GC_THREAD, f2fs_gc_kthread, gc_idle, gc_idle); 189 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, reclaim_segments, rec_prefree_segments); 190 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, max_small_discards, max_discards); 191 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, ipu_policy, ipu_policy); 192 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_ipu_util, min_ipu_util); 193 F2FS_RW_ATTR(SM_INFO, f2fs_sm_info, min_fsync_blocks, min_fsync_blocks); 194 F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ram_thresh, ram_thresh); 195 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_victim_search, max_victim_search); 196 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, dir_level, dir_level); 197 198 #define ATTR_LIST(name) (&f2fs_attr_##name.attr) 199 static struct attribute *f2fs_attrs[] = { 200 ATTR_LIST(gc_min_sleep_time), 201 ATTR_LIST(gc_max_sleep_time), 202 ATTR_LIST(gc_no_gc_sleep_time), 203 ATTR_LIST(gc_idle), 204 ATTR_LIST(reclaim_segments), 205 ATTR_LIST(max_small_discards), 206 ATTR_LIST(ipu_policy), 207 ATTR_LIST(min_ipu_util), 208 ATTR_LIST(min_fsync_blocks), 209 ATTR_LIST(max_victim_search), 210 ATTR_LIST(dir_level), 211 ATTR_LIST(ram_thresh), 212 NULL, 213 }; 214 215 static const struct sysfs_ops f2fs_attr_ops = { 216 .show = f2fs_attr_show, 217 .store = f2fs_attr_store, 218 }; 219 220 static struct kobj_type f2fs_ktype = { 221 .default_attrs = f2fs_attrs, 222 .sysfs_ops = &f2fs_attr_ops, 223 .release = f2fs_sb_release, 224 }; 225 226 void f2fs_msg(struct super_block *sb, const char *level, const char *fmt, ...) 227 { 228 struct va_format vaf; 229 va_list args; 230 231 va_start(args, fmt); 232 vaf.fmt = fmt; 233 vaf.va = &args; 234 printk("%sF2FS-fs (%s): %pV\n", level, sb->s_id, &vaf); 235 va_end(args); 236 } 237 238 static void init_once(void *foo) 239 { 240 struct f2fs_inode_info *fi = (struct f2fs_inode_info *) foo; 241 242 inode_init_once(&fi->vfs_inode); 243 } 244 245 static int parse_options(struct super_block *sb, char *options) 246 { 247 struct f2fs_sb_info *sbi = F2FS_SB(sb); 248 substring_t args[MAX_OPT_ARGS]; 249 char *p, *name; 250 int arg = 0; 251 252 if (!options) 253 return 0; 254 255 while ((p = strsep(&options, ",")) != NULL) { 256 int token; 257 if (!*p) 258 continue; 259 /* 260 * Initialize args struct so we know whether arg was 261 * found; some options take optional arguments. 262 */ 263 args[0].to = args[0].from = NULL; 264 token = match_token(p, f2fs_tokens, args); 265 266 switch (token) { 267 case Opt_gc_background: 268 name = match_strdup(&args[0]); 269 270 if (!name) 271 return -ENOMEM; 272 if (strlen(name) == 2 && !strncmp(name, "on", 2)) 273 set_opt(sbi, BG_GC); 274 else if (strlen(name) == 3 && !strncmp(name, "off", 3)) 275 clear_opt(sbi, BG_GC); 276 else { 277 kfree(name); 278 return -EINVAL; 279 } 280 kfree(name); 281 break; 282 case Opt_disable_roll_forward: 283 set_opt(sbi, DISABLE_ROLL_FORWARD); 284 break; 285 case Opt_discard: 286 set_opt(sbi, DISCARD); 287 break; 288 case Opt_noheap: 289 set_opt(sbi, NOHEAP); 290 break; 291 #ifdef CONFIG_F2FS_FS_XATTR 292 case Opt_user_xattr: 293 set_opt(sbi, XATTR_USER); 294 break; 295 case Opt_nouser_xattr: 296 clear_opt(sbi, XATTR_USER); 297 break; 298 case Opt_inline_xattr: 299 set_opt(sbi, INLINE_XATTR); 300 break; 301 #else 302 case Opt_user_xattr: 303 f2fs_msg(sb, KERN_INFO, 304 "user_xattr options not supported"); 305 break; 306 case Opt_nouser_xattr: 307 f2fs_msg(sb, KERN_INFO, 308 "nouser_xattr options not supported"); 309 break; 310 case Opt_inline_xattr: 311 f2fs_msg(sb, KERN_INFO, 312 "inline_xattr options not supported"); 313 break; 314 #endif 315 #ifdef CONFIG_F2FS_FS_POSIX_ACL 316 case Opt_acl: 317 set_opt(sbi, POSIX_ACL); 318 break; 319 case Opt_noacl: 320 clear_opt(sbi, POSIX_ACL); 321 break; 322 #else 323 case Opt_acl: 324 f2fs_msg(sb, KERN_INFO, "acl options not supported"); 325 break; 326 case Opt_noacl: 327 f2fs_msg(sb, KERN_INFO, "noacl options not supported"); 328 break; 329 #endif 330 case Opt_active_logs: 331 if (args->from && match_int(args, &arg)) 332 return -EINVAL; 333 if (arg != 2 && arg != 4 && arg != NR_CURSEG_TYPE) 334 return -EINVAL; 335 sbi->active_logs = arg; 336 break; 337 case Opt_disable_ext_identify: 338 set_opt(sbi, DISABLE_EXT_IDENTIFY); 339 break; 340 case Opt_inline_data: 341 set_opt(sbi, INLINE_DATA); 342 break; 343 case Opt_flush_merge: 344 set_opt(sbi, FLUSH_MERGE); 345 break; 346 case Opt_nobarrier: 347 set_opt(sbi, NOBARRIER); 348 break; 349 default: 350 f2fs_msg(sb, KERN_ERR, 351 "Unrecognized mount option \"%s\" or missing value", 352 p); 353 return -EINVAL; 354 } 355 } 356 return 0; 357 } 358 359 static struct inode *f2fs_alloc_inode(struct super_block *sb) 360 { 361 struct f2fs_inode_info *fi; 362 363 fi = kmem_cache_alloc(f2fs_inode_cachep, GFP_F2FS_ZERO); 364 if (!fi) 365 return NULL; 366 367 init_once((void *) fi); 368 369 /* Initialize f2fs-specific inode info */ 370 fi->vfs_inode.i_version = 1; 371 atomic_set(&fi->dirty_pages, 0); 372 fi->i_current_depth = 1; 373 fi->i_advise = 0; 374 rwlock_init(&fi->ext.ext_lock); 375 init_rwsem(&fi->i_sem); 376 INIT_LIST_HEAD(&fi->inmem_pages); 377 mutex_init(&fi->inmem_lock); 378 379 set_inode_flag(fi, FI_NEW_INODE); 380 381 if (test_opt(F2FS_SB(sb), INLINE_XATTR)) 382 set_inode_flag(fi, FI_INLINE_XATTR); 383 384 /* Will be used by directory only */ 385 fi->i_dir_level = F2FS_SB(sb)->dir_level; 386 387 return &fi->vfs_inode; 388 } 389 390 static int f2fs_drop_inode(struct inode *inode) 391 { 392 /* 393 * This is to avoid a deadlock condition like below. 394 * writeback_single_inode(inode) 395 * - f2fs_write_data_page 396 * - f2fs_gc -> iput -> evict 397 * - inode_wait_for_writeback(inode) 398 */ 399 if (!inode_unhashed(inode) && inode->i_state & I_SYNC) 400 return 0; 401 return generic_drop_inode(inode); 402 } 403 404 /* 405 * f2fs_dirty_inode() is called from __mark_inode_dirty() 406 * 407 * We should call set_dirty_inode to write the dirty inode through write_inode. 408 */ 409 static void f2fs_dirty_inode(struct inode *inode, int flags) 410 { 411 set_inode_flag(F2FS_I(inode), FI_DIRTY_INODE); 412 } 413 414 static void f2fs_i_callback(struct rcu_head *head) 415 { 416 struct inode *inode = container_of(head, struct inode, i_rcu); 417 kmem_cache_free(f2fs_inode_cachep, F2FS_I(inode)); 418 } 419 420 static void f2fs_destroy_inode(struct inode *inode) 421 { 422 call_rcu(&inode->i_rcu, f2fs_i_callback); 423 } 424 425 static void f2fs_put_super(struct super_block *sb) 426 { 427 struct f2fs_sb_info *sbi = F2FS_SB(sb); 428 429 if (sbi->s_proc) { 430 remove_proc_entry("segment_info", sbi->s_proc); 431 remove_proc_entry(sb->s_id, f2fs_proc_root); 432 } 433 kobject_del(&sbi->s_kobj); 434 435 f2fs_destroy_stats(sbi); 436 stop_gc_thread(sbi); 437 438 /* We don't need to do checkpoint when it's clean */ 439 if (sbi->s_dirty) { 440 struct cp_control cpc = { 441 .reason = CP_UMOUNT, 442 }; 443 write_checkpoint(sbi, &cpc); 444 } 445 446 /* 447 * normally superblock is clean, so we need to release this. 448 * In addition, EIO will skip do checkpoint, we need this as well. 449 */ 450 release_dirty_inode(sbi); 451 release_discard_addrs(sbi); 452 453 iput(sbi->node_inode); 454 iput(sbi->meta_inode); 455 456 /* destroy f2fs internal modules */ 457 destroy_node_manager(sbi); 458 destroy_segment_manager(sbi); 459 460 kfree(sbi->ckpt); 461 kobject_put(&sbi->s_kobj); 462 wait_for_completion(&sbi->s_kobj_unregister); 463 464 sb->s_fs_info = NULL; 465 brelse(sbi->raw_super_buf); 466 kfree(sbi); 467 } 468 469 int f2fs_sync_fs(struct super_block *sb, int sync) 470 { 471 struct f2fs_sb_info *sbi = F2FS_SB(sb); 472 473 trace_f2fs_sync_fs(sb, sync); 474 475 if (sync) { 476 struct cp_control cpc = { 477 .reason = CP_SYNC, 478 }; 479 mutex_lock(&sbi->gc_mutex); 480 write_checkpoint(sbi, &cpc); 481 mutex_unlock(&sbi->gc_mutex); 482 } else { 483 f2fs_balance_fs(sbi); 484 } 485 486 return 0; 487 } 488 489 static int f2fs_freeze(struct super_block *sb) 490 { 491 int err; 492 493 if (f2fs_readonly(sb)) 494 return 0; 495 496 err = f2fs_sync_fs(sb, 1); 497 return err; 498 } 499 500 static int f2fs_unfreeze(struct super_block *sb) 501 { 502 return 0; 503 } 504 505 static int f2fs_statfs(struct dentry *dentry, struct kstatfs *buf) 506 { 507 struct super_block *sb = dentry->d_sb; 508 struct f2fs_sb_info *sbi = F2FS_SB(sb); 509 u64 id = huge_encode_dev(sb->s_bdev->bd_dev); 510 block_t total_count, user_block_count, start_count, ovp_count; 511 512 total_count = le64_to_cpu(sbi->raw_super->block_count); 513 user_block_count = sbi->user_block_count; 514 start_count = le32_to_cpu(sbi->raw_super->segment0_blkaddr); 515 ovp_count = SM_I(sbi)->ovp_segments << sbi->log_blocks_per_seg; 516 buf->f_type = F2FS_SUPER_MAGIC; 517 buf->f_bsize = sbi->blocksize; 518 519 buf->f_blocks = total_count - start_count; 520 buf->f_bfree = buf->f_blocks - valid_user_blocks(sbi) - ovp_count; 521 buf->f_bavail = user_block_count - valid_user_blocks(sbi); 522 523 buf->f_files = sbi->total_node_count - F2FS_RESERVED_NODE_NUM; 524 buf->f_ffree = buf->f_files - valid_inode_count(sbi); 525 526 buf->f_namelen = F2FS_NAME_LEN; 527 buf->f_fsid.val[0] = (u32)id; 528 buf->f_fsid.val[1] = (u32)(id >> 32); 529 530 return 0; 531 } 532 533 static int f2fs_show_options(struct seq_file *seq, struct dentry *root) 534 { 535 struct f2fs_sb_info *sbi = F2FS_SB(root->d_sb); 536 537 if (!f2fs_readonly(sbi->sb) && test_opt(sbi, BG_GC)) 538 seq_printf(seq, ",background_gc=%s", "on"); 539 else 540 seq_printf(seq, ",background_gc=%s", "off"); 541 if (test_opt(sbi, DISABLE_ROLL_FORWARD)) 542 seq_puts(seq, ",disable_roll_forward"); 543 if (test_opt(sbi, DISCARD)) 544 seq_puts(seq, ",discard"); 545 if (test_opt(sbi, NOHEAP)) 546 seq_puts(seq, ",no_heap_alloc"); 547 #ifdef CONFIG_F2FS_FS_XATTR 548 if (test_opt(sbi, XATTR_USER)) 549 seq_puts(seq, ",user_xattr"); 550 else 551 seq_puts(seq, ",nouser_xattr"); 552 if (test_opt(sbi, INLINE_XATTR)) 553 seq_puts(seq, ",inline_xattr"); 554 #endif 555 #ifdef CONFIG_F2FS_FS_POSIX_ACL 556 if (test_opt(sbi, POSIX_ACL)) 557 seq_puts(seq, ",acl"); 558 else 559 seq_puts(seq, ",noacl"); 560 #endif 561 if (test_opt(sbi, DISABLE_EXT_IDENTIFY)) 562 seq_puts(seq, ",disable_ext_identify"); 563 if (test_opt(sbi, INLINE_DATA)) 564 seq_puts(seq, ",inline_data"); 565 if (!f2fs_readonly(sbi->sb) && test_opt(sbi, FLUSH_MERGE)) 566 seq_puts(seq, ",flush_merge"); 567 if (test_opt(sbi, NOBARRIER)) 568 seq_puts(seq, ",nobarrier"); 569 seq_printf(seq, ",active_logs=%u", sbi->active_logs); 570 571 return 0; 572 } 573 574 static int segment_info_seq_show(struct seq_file *seq, void *offset) 575 { 576 struct super_block *sb = seq->private; 577 struct f2fs_sb_info *sbi = F2FS_SB(sb); 578 unsigned int total_segs = 579 le32_to_cpu(sbi->raw_super->segment_count_main); 580 int i; 581 582 seq_puts(seq, "format: segment_type|valid_blocks\n" 583 "segment_type(0:HD, 1:WD, 2:CD, 3:HN, 4:WN, 5:CN)\n"); 584 585 for (i = 0; i < total_segs; i++) { 586 struct seg_entry *se = get_seg_entry(sbi, i); 587 588 if ((i % 10) == 0) 589 seq_printf(seq, "%-5d", i); 590 seq_printf(seq, "%d|%-3u", se->type, 591 get_valid_blocks(sbi, i, 1)); 592 if ((i % 10) == 9 || i == (total_segs - 1)) 593 seq_putc(seq, '\n'); 594 else 595 seq_putc(seq, ' '); 596 } 597 598 return 0; 599 } 600 601 static int segment_info_open_fs(struct inode *inode, struct file *file) 602 { 603 return single_open(file, segment_info_seq_show, PDE_DATA(inode)); 604 } 605 606 static const struct file_operations f2fs_seq_segment_info_fops = { 607 .owner = THIS_MODULE, 608 .open = segment_info_open_fs, 609 .read = seq_read, 610 .llseek = seq_lseek, 611 .release = single_release, 612 }; 613 614 static int f2fs_remount(struct super_block *sb, int *flags, char *data) 615 { 616 struct f2fs_sb_info *sbi = F2FS_SB(sb); 617 struct f2fs_mount_info org_mount_opt; 618 int err, active_logs; 619 bool need_restart_gc = false; 620 bool need_stop_gc = false; 621 622 sync_filesystem(sb); 623 624 /* 625 * Save the old mount options in case we 626 * need to restore them. 627 */ 628 org_mount_opt = sbi->mount_opt; 629 active_logs = sbi->active_logs; 630 631 sbi->mount_opt.opt = 0; 632 sbi->active_logs = NR_CURSEG_TYPE; 633 634 /* parse mount options */ 635 err = parse_options(sb, data); 636 if (err) 637 goto restore_opts; 638 639 /* 640 * Previous and new state of filesystem is RO, 641 * so skip checking GC and FLUSH_MERGE conditions. 642 */ 643 if (f2fs_readonly(sb) && (*flags & MS_RDONLY)) 644 goto skip; 645 646 /* 647 * We stop the GC thread if FS is mounted as RO 648 * or if background_gc = off is passed in mount 649 * option. Also sync the filesystem. 650 */ 651 if ((*flags & MS_RDONLY) || !test_opt(sbi, BG_GC)) { 652 if (sbi->gc_thread) { 653 stop_gc_thread(sbi); 654 f2fs_sync_fs(sb, 1); 655 need_restart_gc = true; 656 } 657 } else if (test_opt(sbi, BG_GC) && !sbi->gc_thread) { 658 err = start_gc_thread(sbi); 659 if (err) 660 goto restore_opts; 661 need_stop_gc = true; 662 } 663 664 /* 665 * We stop issue flush thread if FS is mounted as RO 666 * or if flush_merge is not passed in mount option. 667 */ 668 if ((*flags & MS_RDONLY) || !test_opt(sbi, FLUSH_MERGE)) { 669 destroy_flush_cmd_control(sbi); 670 } else if (test_opt(sbi, FLUSH_MERGE) && !SM_I(sbi)->cmd_control_info) { 671 err = create_flush_cmd_control(sbi); 672 if (err) 673 goto restore_gc; 674 } 675 skip: 676 /* Update the POSIXACL Flag */ 677 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) | 678 (test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0); 679 return 0; 680 restore_gc: 681 if (need_restart_gc) { 682 if (start_gc_thread(sbi)) 683 f2fs_msg(sbi->sb, KERN_WARNING, 684 "background gc thread has stopped"); 685 } else if (need_stop_gc) { 686 stop_gc_thread(sbi); 687 } 688 restore_opts: 689 sbi->mount_opt = org_mount_opt; 690 sbi->active_logs = active_logs; 691 return err; 692 } 693 694 static struct super_operations f2fs_sops = { 695 .alloc_inode = f2fs_alloc_inode, 696 .drop_inode = f2fs_drop_inode, 697 .destroy_inode = f2fs_destroy_inode, 698 .write_inode = f2fs_write_inode, 699 .dirty_inode = f2fs_dirty_inode, 700 .show_options = f2fs_show_options, 701 .evict_inode = f2fs_evict_inode, 702 .put_super = f2fs_put_super, 703 .sync_fs = f2fs_sync_fs, 704 .freeze_fs = f2fs_freeze, 705 .unfreeze_fs = f2fs_unfreeze, 706 .statfs = f2fs_statfs, 707 .remount_fs = f2fs_remount, 708 }; 709 710 static struct inode *f2fs_nfs_get_inode(struct super_block *sb, 711 u64 ino, u32 generation) 712 { 713 struct f2fs_sb_info *sbi = F2FS_SB(sb); 714 struct inode *inode; 715 716 if (check_nid_range(sbi, ino)) 717 return ERR_PTR(-ESTALE); 718 719 /* 720 * f2fs_iget isn't quite right if the inode is currently unallocated! 721 * However f2fs_iget currently does appropriate checks to handle stale 722 * inodes so everything is OK. 723 */ 724 inode = f2fs_iget(sb, ino); 725 if (IS_ERR(inode)) 726 return ERR_CAST(inode); 727 if (unlikely(generation && inode->i_generation != generation)) { 728 /* we didn't find the right inode.. */ 729 iput(inode); 730 return ERR_PTR(-ESTALE); 731 } 732 return inode; 733 } 734 735 static struct dentry *f2fs_fh_to_dentry(struct super_block *sb, struct fid *fid, 736 int fh_len, int fh_type) 737 { 738 return generic_fh_to_dentry(sb, fid, fh_len, fh_type, 739 f2fs_nfs_get_inode); 740 } 741 742 static struct dentry *f2fs_fh_to_parent(struct super_block *sb, struct fid *fid, 743 int fh_len, int fh_type) 744 { 745 return generic_fh_to_parent(sb, fid, fh_len, fh_type, 746 f2fs_nfs_get_inode); 747 } 748 749 static const struct export_operations f2fs_export_ops = { 750 .fh_to_dentry = f2fs_fh_to_dentry, 751 .fh_to_parent = f2fs_fh_to_parent, 752 .get_parent = f2fs_get_parent, 753 }; 754 755 static loff_t max_file_size(unsigned bits) 756 { 757 loff_t result = (DEF_ADDRS_PER_INODE - F2FS_INLINE_XATTR_ADDRS); 758 loff_t leaf_count = ADDRS_PER_BLOCK; 759 760 /* two direct node blocks */ 761 result += (leaf_count * 2); 762 763 /* two indirect node blocks */ 764 leaf_count *= NIDS_PER_BLOCK; 765 result += (leaf_count * 2); 766 767 /* one double indirect node block */ 768 leaf_count *= NIDS_PER_BLOCK; 769 result += leaf_count; 770 771 result <<= bits; 772 return result; 773 } 774 775 static int sanity_check_raw_super(struct super_block *sb, 776 struct f2fs_super_block *raw_super) 777 { 778 unsigned int blocksize; 779 780 if (F2FS_SUPER_MAGIC != le32_to_cpu(raw_super->magic)) { 781 f2fs_msg(sb, KERN_INFO, 782 "Magic Mismatch, valid(0x%x) - read(0x%x)", 783 F2FS_SUPER_MAGIC, le32_to_cpu(raw_super->magic)); 784 return 1; 785 } 786 787 /* Currently, support only 4KB page cache size */ 788 if (F2FS_BLKSIZE != PAGE_CACHE_SIZE) { 789 f2fs_msg(sb, KERN_INFO, 790 "Invalid page_cache_size (%lu), supports only 4KB\n", 791 PAGE_CACHE_SIZE); 792 return 1; 793 } 794 795 /* Currently, support only 4KB block size */ 796 blocksize = 1 << le32_to_cpu(raw_super->log_blocksize); 797 if (blocksize != F2FS_BLKSIZE) { 798 f2fs_msg(sb, KERN_INFO, 799 "Invalid blocksize (%u), supports only 4KB\n", 800 blocksize); 801 return 1; 802 } 803 804 /* Currently, support 512/1024/2048/4096 bytes sector size */ 805 if (le32_to_cpu(raw_super->log_sectorsize) > 806 F2FS_MAX_LOG_SECTOR_SIZE || 807 le32_to_cpu(raw_super->log_sectorsize) < 808 F2FS_MIN_LOG_SECTOR_SIZE) { 809 f2fs_msg(sb, KERN_INFO, "Invalid log sectorsize (%u)", 810 le32_to_cpu(raw_super->log_sectorsize)); 811 return 1; 812 } 813 if (le32_to_cpu(raw_super->log_sectors_per_block) + 814 le32_to_cpu(raw_super->log_sectorsize) != 815 F2FS_MAX_LOG_SECTOR_SIZE) { 816 f2fs_msg(sb, KERN_INFO, 817 "Invalid log sectors per block(%u) log sectorsize(%u)", 818 le32_to_cpu(raw_super->log_sectors_per_block), 819 le32_to_cpu(raw_super->log_sectorsize)); 820 return 1; 821 } 822 return 0; 823 } 824 825 static int sanity_check_ckpt(struct f2fs_sb_info *sbi) 826 { 827 unsigned int total, fsmeta; 828 struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi); 829 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi); 830 831 total = le32_to_cpu(raw_super->segment_count); 832 fsmeta = le32_to_cpu(raw_super->segment_count_ckpt); 833 fsmeta += le32_to_cpu(raw_super->segment_count_sit); 834 fsmeta += le32_to_cpu(raw_super->segment_count_nat); 835 fsmeta += le32_to_cpu(ckpt->rsvd_segment_count); 836 fsmeta += le32_to_cpu(raw_super->segment_count_ssa); 837 838 if (unlikely(fsmeta >= total)) 839 return 1; 840 841 if (unlikely(f2fs_cp_error(sbi))) { 842 f2fs_msg(sbi->sb, KERN_ERR, "A bug case: need to run fsck"); 843 return 1; 844 } 845 return 0; 846 } 847 848 static void init_sb_info(struct f2fs_sb_info *sbi) 849 { 850 struct f2fs_super_block *raw_super = sbi->raw_super; 851 int i; 852 853 sbi->log_sectors_per_block = 854 le32_to_cpu(raw_super->log_sectors_per_block); 855 sbi->log_blocksize = le32_to_cpu(raw_super->log_blocksize); 856 sbi->blocksize = 1 << sbi->log_blocksize; 857 sbi->log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg); 858 sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg; 859 sbi->segs_per_sec = le32_to_cpu(raw_super->segs_per_sec); 860 sbi->secs_per_zone = le32_to_cpu(raw_super->secs_per_zone); 861 sbi->total_sections = le32_to_cpu(raw_super->section_count); 862 sbi->total_node_count = 863 (le32_to_cpu(raw_super->segment_count_nat) / 2) 864 * sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK; 865 sbi->root_ino_num = le32_to_cpu(raw_super->root_ino); 866 sbi->node_ino_num = le32_to_cpu(raw_super->node_ino); 867 sbi->meta_ino_num = le32_to_cpu(raw_super->meta_ino); 868 sbi->cur_victim_sec = NULL_SECNO; 869 sbi->max_victim_search = DEF_MAX_VICTIM_SEARCH; 870 871 for (i = 0; i < NR_COUNT_TYPE; i++) 872 atomic_set(&sbi->nr_pages[i], 0); 873 874 sbi->dir_level = DEF_DIR_LEVEL; 875 sbi->need_fsck = false; 876 } 877 878 /* 879 * Read f2fs raw super block. 880 * Because we have two copies of super block, so read the first one at first, 881 * if the first one is invalid, move to read the second one. 882 */ 883 static int read_raw_super_block(struct super_block *sb, 884 struct f2fs_super_block **raw_super, 885 struct buffer_head **raw_super_buf) 886 { 887 int block = 0; 888 889 retry: 890 *raw_super_buf = sb_bread(sb, block); 891 if (!*raw_super_buf) { 892 f2fs_msg(sb, KERN_ERR, "Unable to read %dth superblock", 893 block + 1); 894 if (block == 0) { 895 block++; 896 goto retry; 897 } else { 898 return -EIO; 899 } 900 } 901 902 *raw_super = (struct f2fs_super_block *) 903 ((char *)(*raw_super_buf)->b_data + F2FS_SUPER_OFFSET); 904 905 /* sanity checking of raw super */ 906 if (sanity_check_raw_super(sb, *raw_super)) { 907 brelse(*raw_super_buf); 908 f2fs_msg(sb, KERN_ERR, 909 "Can't find valid F2FS filesystem in %dth superblock", 910 block + 1); 911 if (block == 0) { 912 block++; 913 goto retry; 914 } else { 915 return -EINVAL; 916 } 917 } 918 919 return 0; 920 } 921 922 static int f2fs_fill_super(struct super_block *sb, void *data, int silent) 923 { 924 struct f2fs_sb_info *sbi; 925 struct f2fs_super_block *raw_super; 926 struct buffer_head *raw_super_buf; 927 struct inode *root; 928 long err = -EINVAL; 929 bool retry = true; 930 int i; 931 932 try_onemore: 933 /* allocate memory for f2fs-specific super block info */ 934 sbi = kzalloc(sizeof(struct f2fs_sb_info), GFP_KERNEL); 935 if (!sbi) 936 return -ENOMEM; 937 938 /* set a block size */ 939 if (unlikely(!sb_set_blocksize(sb, F2FS_BLKSIZE))) { 940 f2fs_msg(sb, KERN_ERR, "unable to set blocksize"); 941 goto free_sbi; 942 } 943 944 err = read_raw_super_block(sb, &raw_super, &raw_super_buf); 945 if (err) 946 goto free_sbi; 947 948 sb->s_fs_info = sbi; 949 /* init some FS parameters */ 950 sbi->active_logs = NR_CURSEG_TYPE; 951 952 set_opt(sbi, BG_GC); 953 954 #ifdef CONFIG_F2FS_FS_XATTR 955 set_opt(sbi, XATTR_USER); 956 #endif 957 #ifdef CONFIG_F2FS_FS_POSIX_ACL 958 set_opt(sbi, POSIX_ACL); 959 #endif 960 /* parse mount options */ 961 err = parse_options(sb, (char *)data); 962 if (err) 963 goto free_sb_buf; 964 965 sb->s_maxbytes = max_file_size(le32_to_cpu(raw_super->log_blocksize)); 966 sb->s_max_links = F2FS_LINK_MAX; 967 get_random_bytes(&sbi->s_next_generation, sizeof(u32)); 968 969 sb->s_op = &f2fs_sops; 970 sb->s_xattr = f2fs_xattr_handlers; 971 sb->s_export_op = &f2fs_export_ops; 972 sb->s_magic = F2FS_SUPER_MAGIC; 973 sb->s_time_gran = 1; 974 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) | 975 (test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0); 976 memcpy(sb->s_uuid, raw_super->uuid, sizeof(raw_super->uuid)); 977 978 /* init f2fs-specific super block info */ 979 sbi->sb = sb; 980 sbi->raw_super = raw_super; 981 sbi->raw_super_buf = raw_super_buf; 982 mutex_init(&sbi->gc_mutex); 983 mutex_init(&sbi->writepages); 984 mutex_init(&sbi->cp_mutex); 985 init_rwsem(&sbi->node_write); 986 sbi->por_doing = false; 987 spin_lock_init(&sbi->stat_lock); 988 989 init_rwsem(&sbi->read_io.io_rwsem); 990 sbi->read_io.sbi = sbi; 991 sbi->read_io.bio = NULL; 992 for (i = 0; i < NR_PAGE_TYPE; i++) { 993 init_rwsem(&sbi->write_io[i].io_rwsem); 994 sbi->write_io[i].sbi = sbi; 995 sbi->write_io[i].bio = NULL; 996 } 997 998 init_rwsem(&sbi->cp_rwsem); 999 init_waitqueue_head(&sbi->cp_wait); 1000 init_sb_info(sbi); 1001 1002 /* get an inode for meta space */ 1003 sbi->meta_inode = f2fs_iget(sb, F2FS_META_INO(sbi)); 1004 if (IS_ERR(sbi->meta_inode)) { 1005 f2fs_msg(sb, KERN_ERR, "Failed to read F2FS meta data inode"); 1006 err = PTR_ERR(sbi->meta_inode); 1007 goto free_sb_buf; 1008 } 1009 1010 err = get_valid_checkpoint(sbi); 1011 if (err) { 1012 f2fs_msg(sb, KERN_ERR, "Failed to get valid F2FS checkpoint"); 1013 goto free_meta_inode; 1014 } 1015 1016 /* sanity checking of checkpoint */ 1017 err = -EINVAL; 1018 if (sanity_check_ckpt(sbi)) { 1019 f2fs_msg(sb, KERN_ERR, "Invalid F2FS checkpoint"); 1020 goto free_cp; 1021 } 1022 1023 sbi->total_valid_node_count = 1024 le32_to_cpu(sbi->ckpt->valid_node_count); 1025 sbi->total_valid_inode_count = 1026 le32_to_cpu(sbi->ckpt->valid_inode_count); 1027 sbi->user_block_count = le64_to_cpu(sbi->ckpt->user_block_count); 1028 sbi->total_valid_block_count = 1029 le64_to_cpu(sbi->ckpt->valid_block_count); 1030 sbi->last_valid_block_count = sbi->total_valid_block_count; 1031 sbi->alloc_valid_block_count = 0; 1032 INIT_LIST_HEAD(&sbi->dir_inode_list); 1033 spin_lock_init(&sbi->dir_inode_lock); 1034 1035 init_ino_entry_info(sbi); 1036 1037 /* setup f2fs internal modules */ 1038 err = build_segment_manager(sbi); 1039 if (err) { 1040 f2fs_msg(sb, KERN_ERR, 1041 "Failed to initialize F2FS segment manager"); 1042 goto free_sm; 1043 } 1044 err = build_node_manager(sbi); 1045 if (err) { 1046 f2fs_msg(sb, KERN_ERR, 1047 "Failed to initialize F2FS node manager"); 1048 goto free_nm; 1049 } 1050 1051 build_gc_manager(sbi); 1052 1053 /* get an inode for node space */ 1054 sbi->node_inode = f2fs_iget(sb, F2FS_NODE_INO(sbi)); 1055 if (IS_ERR(sbi->node_inode)) { 1056 f2fs_msg(sb, KERN_ERR, "Failed to read node inode"); 1057 err = PTR_ERR(sbi->node_inode); 1058 goto free_nm; 1059 } 1060 1061 /* if there are nt orphan nodes free them */ 1062 recover_orphan_inodes(sbi); 1063 1064 /* read root inode and dentry */ 1065 root = f2fs_iget(sb, F2FS_ROOT_INO(sbi)); 1066 if (IS_ERR(root)) { 1067 f2fs_msg(sb, KERN_ERR, "Failed to read root inode"); 1068 err = PTR_ERR(root); 1069 goto free_node_inode; 1070 } 1071 if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) { 1072 iput(root); 1073 err = -EINVAL; 1074 goto free_node_inode; 1075 } 1076 1077 sb->s_root = d_make_root(root); /* allocate root dentry */ 1078 if (!sb->s_root) { 1079 err = -ENOMEM; 1080 goto free_root_inode; 1081 } 1082 1083 err = f2fs_build_stats(sbi); 1084 if (err) 1085 goto free_root_inode; 1086 1087 if (f2fs_proc_root) 1088 sbi->s_proc = proc_mkdir(sb->s_id, f2fs_proc_root); 1089 1090 if (sbi->s_proc) 1091 proc_create_data("segment_info", S_IRUGO, sbi->s_proc, 1092 &f2fs_seq_segment_info_fops, sb); 1093 1094 if (test_opt(sbi, DISCARD)) { 1095 struct request_queue *q = bdev_get_queue(sb->s_bdev); 1096 if (!blk_queue_discard(q)) 1097 f2fs_msg(sb, KERN_WARNING, 1098 "mounting with \"discard\" option, but " 1099 "the device does not support discard"); 1100 } 1101 1102 sbi->s_kobj.kset = f2fs_kset; 1103 init_completion(&sbi->s_kobj_unregister); 1104 err = kobject_init_and_add(&sbi->s_kobj, &f2fs_ktype, NULL, 1105 "%s", sb->s_id); 1106 if (err) 1107 goto free_proc; 1108 1109 if (!retry) 1110 sbi->need_fsck = true; 1111 1112 /* recover fsynced data */ 1113 if (!test_opt(sbi, DISABLE_ROLL_FORWARD)) { 1114 err = recover_fsync_data(sbi); 1115 if (err) { 1116 f2fs_msg(sb, KERN_ERR, 1117 "Cannot recover all fsync data errno=%ld", err); 1118 goto free_kobj; 1119 } 1120 } 1121 1122 /* 1123 * If filesystem is not mounted as read-only then 1124 * do start the gc_thread. 1125 */ 1126 if (!f2fs_readonly(sb)) { 1127 /* After POR, we can run background GC thread.*/ 1128 err = start_gc_thread(sbi); 1129 if (err) 1130 goto free_kobj; 1131 } 1132 return 0; 1133 1134 free_kobj: 1135 kobject_del(&sbi->s_kobj); 1136 free_proc: 1137 if (sbi->s_proc) { 1138 remove_proc_entry("segment_info", sbi->s_proc); 1139 remove_proc_entry(sb->s_id, f2fs_proc_root); 1140 } 1141 f2fs_destroy_stats(sbi); 1142 free_root_inode: 1143 dput(sb->s_root); 1144 sb->s_root = NULL; 1145 free_node_inode: 1146 iput(sbi->node_inode); 1147 free_nm: 1148 destroy_node_manager(sbi); 1149 free_sm: 1150 destroy_segment_manager(sbi); 1151 free_cp: 1152 kfree(sbi->ckpt); 1153 free_meta_inode: 1154 make_bad_inode(sbi->meta_inode); 1155 iput(sbi->meta_inode); 1156 free_sb_buf: 1157 brelse(raw_super_buf); 1158 free_sbi: 1159 kfree(sbi); 1160 1161 /* give only one another chance */ 1162 if (retry) { 1163 retry = 0; 1164 shrink_dcache_sb(sb); 1165 goto try_onemore; 1166 } 1167 return err; 1168 } 1169 1170 static struct dentry *f2fs_mount(struct file_system_type *fs_type, int flags, 1171 const char *dev_name, void *data) 1172 { 1173 return mount_bdev(fs_type, flags, dev_name, data, f2fs_fill_super); 1174 } 1175 1176 static struct file_system_type f2fs_fs_type = { 1177 .owner = THIS_MODULE, 1178 .name = "f2fs", 1179 .mount = f2fs_mount, 1180 .kill_sb = kill_block_super, 1181 .fs_flags = FS_REQUIRES_DEV, 1182 }; 1183 MODULE_ALIAS_FS("f2fs"); 1184 1185 static int __init init_inodecache(void) 1186 { 1187 f2fs_inode_cachep = f2fs_kmem_cache_create("f2fs_inode_cache", 1188 sizeof(struct f2fs_inode_info)); 1189 if (!f2fs_inode_cachep) 1190 return -ENOMEM; 1191 return 0; 1192 } 1193 1194 static void destroy_inodecache(void) 1195 { 1196 /* 1197 * Make sure all delayed rcu free inodes are flushed before we 1198 * destroy cache. 1199 */ 1200 rcu_barrier(); 1201 kmem_cache_destroy(f2fs_inode_cachep); 1202 } 1203 1204 static int __init init_f2fs_fs(void) 1205 { 1206 int err; 1207 1208 err = init_inodecache(); 1209 if (err) 1210 goto fail; 1211 err = create_node_manager_caches(); 1212 if (err) 1213 goto free_inodecache; 1214 err = create_segment_manager_caches(); 1215 if (err) 1216 goto free_node_manager_caches; 1217 err = create_gc_caches(); 1218 if (err) 1219 goto free_segment_manager_caches; 1220 err = create_checkpoint_caches(); 1221 if (err) 1222 goto free_gc_caches; 1223 f2fs_kset = kset_create_and_add("f2fs", NULL, fs_kobj); 1224 if (!f2fs_kset) { 1225 err = -ENOMEM; 1226 goto free_checkpoint_caches; 1227 } 1228 err = register_filesystem(&f2fs_fs_type); 1229 if (err) 1230 goto free_kset; 1231 f2fs_create_root_stats(); 1232 f2fs_proc_root = proc_mkdir("fs/f2fs", NULL); 1233 return 0; 1234 1235 free_kset: 1236 kset_unregister(f2fs_kset); 1237 free_checkpoint_caches: 1238 destroy_checkpoint_caches(); 1239 free_gc_caches: 1240 destroy_gc_caches(); 1241 free_segment_manager_caches: 1242 destroy_segment_manager_caches(); 1243 free_node_manager_caches: 1244 destroy_node_manager_caches(); 1245 free_inodecache: 1246 destroy_inodecache(); 1247 fail: 1248 return err; 1249 } 1250 1251 static void __exit exit_f2fs_fs(void) 1252 { 1253 remove_proc_entry("fs/f2fs", NULL); 1254 f2fs_destroy_root_stats(); 1255 unregister_filesystem(&f2fs_fs_type); 1256 destroy_checkpoint_caches(); 1257 destroy_gc_caches(); 1258 destroy_segment_manager_caches(); 1259 destroy_node_manager_caches(); 1260 destroy_inodecache(); 1261 kset_unregister(f2fs_kset); 1262 } 1263 1264 module_init(init_f2fs_fs) 1265 module_exit(exit_f2fs_fs) 1266 1267 MODULE_AUTHOR("Samsung Electronics's Praesto Team"); 1268 MODULE_DESCRIPTION("Flash Friendly File System"); 1269 MODULE_LICENSE("GPL"); 1270