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