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