1 /* 2 * fs/f2fs/f2fs.h 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 #ifndef _LINUX_F2FS_H 12 #define _LINUX_F2FS_H 13 14 #include <linux/types.h> 15 #include <linux/page-flags.h> 16 #include <linux/buffer_head.h> 17 #include <linux/slab.h> 18 #include <linux/crc32.h> 19 #include <linux/magic.h> 20 #include <linux/kobject.h> 21 #include <linux/sched.h> 22 23 #ifdef CONFIG_F2FS_CHECK_FS 24 #define f2fs_bug_on(sbi, condition) BUG_ON(condition) 25 #define f2fs_down_write(x, y) down_write_nest_lock(x, y) 26 #else 27 #define f2fs_bug_on(sbi, condition) \ 28 do { \ 29 if (unlikely(condition)) { \ 30 WARN_ON(1); \ 31 sbi->need_fsck = true; \ 32 } \ 33 } while (0) 34 #define f2fs_down_write(x, y) down_write(x) 35 #endif 36 37 /* 38 * For mount options 39 */ 40 #define F2FS_MOUNT_BG_GC 0x00000001 41 #define F2FS_MOUNT_DISABLE_ROLL_FORWARD 0x00000002 42 #define F2FS_MOUNT_DISCARD 0x00000004 43 #define F2FS_MOUNT_NOHEAP 0x00000008 44 #define F2FS_MOUNT_XATTR_USER 0x00000010 45 #define F2FS_MOUNT_POSIX_ACL 0x00000020 46 #define F2FS_MOUNT_DISABLE_EXT_IDENTIFY 0x00000040 47 #define F2FS_MOUNT_INLINE_XATTR 0x00000080 48 #define F2FS_MOUNT_INLINE_DATA 0x00000100 49 #define F2FS_MOUNT_INLINE_DENTRY 0x00000200 50 #define F2FS_MOUNT_FLUSH_MERGE 0x00000400 51 #define F2FS_MOUNT_NOBARRIER 0x00000800 52 #define F2FS_MOUNT_FASTBOOT 0x00001000 53 54 #define clear_opt(sbi, option) (sbi->mount_opt.opt &= ~F2FS_MOUNT_##option) 55 #define set_opt(sbi, option) (sbi->mount_opt.opt |= F2FS_MOUNT_##option) 56 #define test_opt(sbi, option) (sbi->mount_opt.opt & F2FS_MOUNT_##option) 57 58 #define ver_after(a, b) (typecheck(unsigned long long, a) && \ 59 typecheck(unsigned long long, b) && \ 60 ((long long)((a) - (b)) > 0)) 61 62 typedef u32 block_t; /* 63 * should not change u32, since it is the on-disk block 64 * address format, __le32. 65 */ 66 typedef u32 nid_t; 67 68 struct f2fs_mount_info { 69 unsigned int opt; 70 }; 71 72 #define CRCPOLY_LE 0xedb88320 73 74 static inline __u32 f2fs_crc32(void *buf, size_t len) 75 { 76 unsigned char *p = (unsigned char *)buf; 77 __u32 crc = F2FS_SUPER_MAGIC; 78 int i; 79 80 while (len--) { 81 crc ^= *p++; 82 for (i = 0; i < 8; i++) 83 crc = (crc >> 1) ^ ((crc & 1) ? CRCPOLY_LE : 0); 84 } 85 return crc; 86 } 87 88 static inline bool f2fs_crc_valid(__u32 blk_crc, void *buf, size_t buf_size) 89 { 90 return f2fs_crc32(buf, buf_size) == blk_crc; 91 } 92 93 /* 94 * For checkpoint manager 95 */ 96 enum { 97 NAT_BITMAP, 98 SIT_BITMAP 99 }; 100 101 enum { 102 CP_UMOUNT, 103 CP_SYNC, 104 CP_DISCARD, 105 }; 106 107 struct cp_control { 108 int reason; 109 __u64 trim_start; 110 __u64 trim_end; 111 __u64 trim_minlen; 112 __u64 trimmed; 113 }; 114 115 /* 116 * For CP/NAT/SIT/SSA readahead 117 */ 118 enum { 119 META_CP, 120 META_NAT, 121 META_SIT, 122 META_SSA, 123 META_POR, 124 }; 125 126 /* for the list of ino */ 127 enum { 128 ORPHAN_INO, /* for orphan ino list */ 129 APPEND_INO, /* for append ino list */ 130 UPDATE_INO, /* for update ino list */ 131 MAX_INO_ENTRY, /* max. list */ 132 }; 133 134 struct ino_entry { 135 struct list_head list; /* list head */ 136 nid_t ino; /* inode number */ 137 }; 138 139 /* for the list of directory inodes */ 140 struct dir_inode_entry { 141 struct list_head list; /* list head */ 142 struct inode *inode; /* vfs inode pointer */ 143 }; 144 145 /* for the list of blockaddresses to be discarded */ 146 struct discard_entry { 147 struct list_head list; /* list head */ 148 block_t blkaddr; /* block address to be discarded */ 149 int len; /* # of consecutive blocks of the discard */ 150 }; 151 152 /* for the list of fsync inodes, used only during recovery */ 153 struct fsync_inode_entry { 154 struct list_head list; /* list head */ 155 struct inode *inode; /* vfs inode pointer */ 156 block_t blkaddr; /* block address locating the last fsync */ 157 block_t last_dentry; /* block address locating the last dentry */ 158 block_t last_inode; /* block address locating the last inode */ 159 }; 160 161 #define nats_in_cursum(sum) (le16_to_cpu(sum->n_nats)) 162 #define sits_in_cursum(sum) (le16_to_cpu(sum->n_sits)) 163 164 #define nat_in_journal(sum, i) (sum->nat_j.entries[i].ne) 165 #define nid_in_journal(sum, i) (sum->nat_j.entries[i].nid) 166 #define sit_in_journal(sum, i) (sum->sit_j.entries[i].se) 167 #define segno_in_journal(sum, i) (sum->sit_j.entries[i].segno) 168 169 #define MAX_NAT_JENTRIES(sum) (NAT_JOURNAL_ENTRIES - nats_in_cursum(sum)) 170 #define MAX_SIT_JENTRIES(sum) (SIT_JOURNAL_ENTRIES - sits_in_cursum(sum)) 171 172 static inline int update_nats_in_cursum(struct f2fs_summary_block *rs, int i) 173 { 174 int before = nats_in_cursum(rs); 175 rs->n_nats = cpu_to_le16(before + i); 176 return before; 177 } 178 179 static inline int update_sits_in_cursum(struct f2fs_summary_block *rs, int i) 180 { 181 int before = sits_in_cursum(rs); 182 rs->n_sits = cpu_to_le16(before + i); 183 return before; 184 } 185 186 static inline bool __has_cursum_space(struct f2fs_summary_block *sum, int size, 187 int type) 188 { 189 if (type == NAT_JOURNAL) 190 return size <= MAX_NAT_JENTRIES(sum); 191 return size <= MAX_SIT_JENTRIES(sum); 192 } 193 194 /* 195 * ioctl commands 196 */ 197 #define F2FS_IOC_GETFLAGS FS_IOC_GETFLAGS 198 #define F2FS_IOC_SETFLAGS FS_IOC_SETFLAGS 199 200 #define F2FS_IOCTL_MAGIC 0xf5 201 #define F2FS_IOC_START_ATOMIC_WRITE _IO(F2FS_IOCTL_MAGIC, 1) 202 #define F2FS_IOC_COMMIT_ATOMIC_WRITE _IO(F2FS_IOCTL_MAGIC, 2) 203 #define F2FS_IOC_START_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 3) 204 205 #if defined(__KERNEL__) && defined(CONFIG_COMPAT) 206 /* 207 * ioctl commands in 32 bit emulation 208 */ 209 #define F2FS_IOC32_GETFLAGS FS_IOC32_GETFLAGS 210 #define F2FS_IOC32_SETFLAGS FS_IOC32_SETFLAGS 211 #endif 212 213 /* 214 * For INODE and NODE manager 215 */ 216 /* for directory operations */ 217 struct f2fs_dentry_ptr { 218 const void *bitmap; 219 struct f2fs_dir_entry *dentry; 220 __u8 (*filename)[F2FS_SLOT_LEN]; 221 int max; 222 }; 223 224 static inline void make_dentry_ptr(struct f2fs_dentry_ptr *d, 225 void *src, int type) 226 { 227 if (type == 1) { 228 struct f2fs_dentry_block *t = (struct f2fs_dentry_block *)src; 229 d->max = NR_DENTRY_IN_BLOCK; 230 d->bitmap = &t->dentry_bitmap; 231 d->dentry = t->dentry; 232 d->filename = t->filename; 233 } else { 234 struct f2fs_inline_dentry *t = (struct f2fs_inline_dentry *)src; 235 d->max = NR_INLINE_DENTRY; 236 d->bitmap = &t->dentry_bitmap; 237 d->dentry = t->dentry; 238 d->filename = t->filename; 239 } 240 } 241 242 /* 243 * XATTR_NODE_OFFSET stores xattrs to one node block per file keeping -1 244 * as its node offset to distinguish from index node blocks. 245 * But some bits are used to mark the node block. 246 */ 247 #define XATTR_NODE_OFFSET ((((unsigned int)-1) << OFFSET_BIT_SHIFT) \ 248 >> OFFSET_BIT_SHIFT) 249 enum { 250 ALLOC_NODE, /* allocate a new node page if needed */ 251 LOOKUP_NODE, /* look up a node without readahead */ 252 LOOKUP_NODE_RA, /* 253 * look up a node with readahead called 254 * by get_data_block. 255 */ 256 }; 257 258 #define F2FS_LINK_MAX 32000 /* maximum link count per file */ 259 260 #define MAX_DIR_RA_PAGES 4 /* maximum ra pages of dir */ 261 262 /* for in-memory extent cache entry */ 263 #define F2FS_MIN_EXTENT_LEN 16 /* minimum extent length */ 264 265 struct extent_info { 266 rwlock_t ext_lock; /* rwlock for consistency */ 267 unsigned int fofs; /* start offset in a file */ 268 u32 blk_addr; /* start block address of the extent */ 269 unsigned int len; /* length of the extent */ 270 }; 271 272 /* 273 * i_advise uses FADVISE_XXX_BIT. We can add additional hints later. 274 */ 275 #define FADVISE_COLD_BIT 0x01 276 #define FADVISE_LOST_PINO_BIT 0x02 277 278 #define DEF_DIR_LEVEL 0 279 280 struct f2fs_inode_info { 281 struct inode vfs_inode; /* serve a vfs inode */ 282 unsigned long i_flags; /* keep an inode flags for ioctl */ 283 unsigned char i_advise; /* use to give file attribute hints */ 284 unsigned char i_dir_level; /* use for dentry level for large dir */ 285 unsigned int i_current_depth; /* use only in directory structure */ 286 unsigned int i_pino; /* parent inode number */ 287 umode_t i_acl_mode; /* keep file acl mode temporarily */ 288 289 /* Use below internally in f2fs*/ 290 unsigned long flags; /* use to pass per-file flags */ 291 struct rw_semaphore i_sem; /* protect fi info */ 292 atomic_t dirty_pages; /* # of dirty pages */ 293 f2fs_hash_t chash; /* hash value of given file name */ 294 unsigned int clevel; /* maximum level of given file name */ 295 nid_t i_xattr_nid; /* node id that contains xattrs */ 296 unsigned long long xattr_ver; /* cp version of xattr modification */ 297 struct extent_info ext; /* in-memory extent cache entry */ 298 struct dir_inode_entry *dirty_dir; /* the pointer of dirty dir */ 299 300 struct radix_tree_root inmem_root; /* radix tree for inmem pages */ 301 struct list_head inmem_pages; /* inmemory pages managed by f2fs */ 302 struct mutex inmem_lock; /* lock for inmemory pages */ 303 }; 304 305 static inline void get_extent_info(struct extent_info *ext, 306 struct f2fs_extent i_ext) 307 { 308 write_lock(&ext->ext_lock); 309 ext->fofs = le32_to_cpu(i_ext.fofs); 310 ext->blk_addr = le32_to_cpu(i_ext.blk_addr); 311 ext->len = le32_to_cpu(i_ext.len); 312 write_unlock(&ext->ext_lock); 313 } 314 315 static inline void set_raw_extent(struct extent_info *ext, 316 struct f2fs_extent *i_ext) 317 { 318 read_lock(&ext->ext_lock); 319 i_ext->fofs = cpu_to_le32(ext->fofs); 320 i_ext->blk_addr = cpu_to_le32(ext->blk_addr); 321 i_ext->len = cpu_to_le32(ext->len); 322 read_unlock(&ext->ext_lock); 323 } 324 325 struct f2fs_nm_info { 326 block_t nat_blkaddr; /* base disk address of NAT */ 327 nid_t max_nid; /* maximum possible node ids */ 328 nid_t available_nids; /* maximum available node ids */ 329 nid_t next_scan_nid; /* the next nid to be scanned */ 330 unsigned int ram_thresh; /* control the memory footprint */ 331 332 /* NAT cache management */ 333 struct radix_tree_root nat_root;/* root of the nat entry cache */ 334 struct radix_tree_root nat_set_root;/* root of the nat set cache */ 335 struct rw_semaphore nat_tree_lock; /* protect nat_tree_lock */ 336 struct list_head nat_entries; /* cached nat entry list (clean) */ 337 unsigned int nat_cnt; /* the # of cached nat entries */ 338 unsigned int dirty_nat_cnt; /* total num of nat entries in set */ 339 340 /* free node ids management */ 341 struct radix_tree_root free_nid_root;/* root of the free_nid cache */ 342 struct list_head free_nid_list; /* a list for free nids */ 343 spinlock_t free_nid_list_lock; /* protect free nid list */ 344 unsigned int fcnt; /* the number of free node id */ 345 struct mutex build_lock; /* lock for build free nids */ 346 347 /* for checkpoint */ 348 char *nat_bitmap; /* NAT bitmap pointer */ 349 int bitmap_size; /* bitmap size */ 350 }; 351 352 /* 353 * this structure is used as one of function parameters. 354 * all the information are dedicated to a given direct node block determined 355 * by the data offset in a file. 356 */ 357 struct dnode_of_data { 358 struct inode *inode; /* vfs inode pointer */ 359 struct page *inode_page; /* its inode page, NULL is possible */ 360 struct page *node_page; /* cached direct node page */ 361 nid_t nid; /* node id of the direct node block */ 362 unsigned int ofs_in_node; /* data offset in the node page */ 363 bool inode_page_locked; /* inode page is locked or not */ 364 block_t data_blkaddr; /* block address of the node block */ 365 }; 366 367 static inline void set_new_dnode(struct dnode_of_data *dn, struct inode *inode, 368 struct page *ipage, struct page *npage, nid_t nid) 369 { 370 memset(dn, 0, sizeof(*dn)); 371 dn->inode = inode; 372 dn->inode_page = ipage; 373 dn->node_page = npage; 374 dn->nid = nid; 375 } 376 377 /* 378 * For SIT manager 379 * 380 * By default, there are 6 active log areas across the whole main area. 381 * When considering hot and cold data separation to reduce cleaning overhead, 382 * we split 3 for data logs and 3 for node logs as hot, warm, and cold types, 383 * respectively. 384 * In the current design, you should not change the numbers intentionally. 385 * Instead, as a mount option such as active_logs=x, you can use 2, 4, and 6 386 * logs individually according to the underlying devices. (default: 6) 387 * Just in case, on-disk layout covers maximum 16 logs that consist of 8 for 388 * data and 8 for node logs. 389 */ 390 #define NR_CURSEG_DATA_TYPE (3) 391 #define NR_CURSEG_NODE_TYPE (3) 392 #define NR_CURSEG_TYPE (NR_CURSEG_DATA_TYPE + NR_CURSEG_NODE_TYPE) 393 394 enum { 395 CURSEG_HOT_DATA = 0, /* directory entry blocks */ 396 CURSEG_WARM_DATA, /* data blocks */ 397 CURSEG_COLD_DATA, /* multimedia or GCed data blocks */ 398 CURSEG_HOT_NODE, /* direct node blocks of directory files */ 399 CURSEG_WARM_NODE, /* direct node blocks of normal files */ 400 CURSEG_COLD_NODE, /* indirect node blocks */ 401 NO_CHECK_TYPE 402 }; 403 404 struct flush_cmd { 405 struct completion wait; 406 struct llist_node llnode; 407 int ret; 408 }; 409 410 struct flush_cmd_control { 411 struct task_struct *f2fs_issue_flush; /* flush thread */ 412 wait_queue_head_t flush_wait_queue; /* waiting queue for wake-up */ 413 struct llist_head issue_list; /* list for command issue */ 414 struct llist_node *dispatch_list; /* list for command dispatch */ 415 }; 416 417 struct f2fs_sm_info { 418 struct sit_info *sit_info; /* whole segment information */ 419 struct free_segmap_info *free_info; /* free segment information */ 420 struct dirty_seglist_info *dirty_info; /* dirty segment information */ 421 struct curseg_info *curseg_array; /* active segment information */ 422 423 block_t seg0_blkaddr; /* block address of 0'th segment */ 424 block_t main_blkaddr; /* start block address of main area */ 425 block_t ssa_blkaddr; /* start block address of SSA area */ 426 427 unsigned int segment_count; /* total # of segments */ 428 unsigned int main_segments; /* # of segments in main area */ 429 unsigned int reserved_segments; /* # of reserved segments */ 430 unsigned int ovp_segments; /* # of overprovision segments */ 431 432 /* a threshold to reclaim prefree segments */ 433 unsigned int rec_prefree_segments; 434 435 /* for small discard management */ 436 struct list_head discard_list; /* 4KB discard list */ 437 int nr_discards; /* # of discards in the list */ 438 int max_discards; /* max. discards to be issued */ 439 440 struct list_head sit_entry_set; /* sit entry set list */ 441 442 unsigned int ipu_policy; /* in-place-update policy */ 443 unsigned int min_ipu_util; /* in-place-update threshold */ 444 unsigned int min_fsync_blocks; /* threshold for fsync */ 445 446 /* for flush command control */ 447 struct flush_cmd_control *cmd_control_info; 448 449 }; 450 451 /* 452 * For superblock 453 */ 454 /* 455 * COUNT_TYPE for monitoring 456 * 457 * f2fs monitors the number of several block types such as on-writeback, 458 * dirty dentry blocks, dirty node blocks, and dirty meta blocks. 459 */ 460 enum count_type { 461 F2FS_WRITEBACK, 462 F2FS_DIRTY_DENTS, 463 F2FS_DIRTY_NODES, 464 F2FS_DIRTY_META, 465 F2FS_INMEM_PAGES, 466 NR_COUNT_TYPE, 467 }; 468 469 /* 470 * The below are the page types of bios used in submit_bio(). 471 * The available types are: 472 * DATA User data pages. It operates as async mode. 473 * NODE Node pages. It operates as async mode. 474 * META FS metadata pages such as SIT, NAT, CP. 475 * NR_PAGE_TYPE The number of page types. 476 * META_FLUSH Make sure the previous pages are written 477 * with waiting the bio's completion 478 * ... Only can be used with META. 479 */ 480 #define PAGE_TYPE_OF_BIO(type) ((type) > META ? META : (type)) 481 enum page_type { 482 DATA, 483 NODE, 484 META, 485 NR_PAGE_TYPE, 486 META_FLUSH, 487 }; 488 489 struct f2fs_io_info { 490 enum page_type type; /* contains DATA/NODE/META/META_FLUSH */ 491 int rw; /* contains R/RS/W/WS with REQ_META/REQ_PRIO */ 492 }; 493 494 #define is_read_io(rw) (((rw) & 1) == READ) 495 struct f2fs_bio_info { 496 struct f2fs_sb_info *sbi; /* f2fs superblock */ 497 struct bio *bio; /* bios to merge */ 498 sector_t last_block_in_bio; /* last block number */ 499 struct f2fs_io_info fio; /* store buffered io info. */ 500 struct rw_semaphore io_rwsem; /* blocking op for bio */ 501 }; 502 503 /* for inner inode cache management */ 504 struct inode_management { 505 struct radix_tree_root ino_root; /* ino entry array */ 506 spinlock_t ino_lock; /* for ino entry lock */ 507 struct list_head ino_list; /* inode list head */ 508 unsigned long ino_num; /* number of entries */ 509 }; 510 511 struct f2fs_sb_info { 512 struct super_block *sb; /* pointer to VFS super block */ 513 struct proc_dir_entry *s_proc; /* proc entry */ 514 struct buffer_head *raw_super_buf; /* buffer head of raw sb */ 515 struct f2fs_super_block *raw_super; /* raw super block pointer */ 516 int s_dirty; /* dirty flag for checkpoint */ 517 bool need_fsck; /* need fsck.f2fs to fix */ 518 519 /* for node-related operations */ 520 struct f2fs_nm_info *nm_info; /* node manager */ 521 struct inode *node_inode; /* cache node blocks */ 522 523 /* for segment-related operations */ 524 struct f2fs_sm_info *sm_info; /* segment manager */ 525 526 /* for bio operations */ 527 struct f2fs_bio_info read_io; /* for read bios */ 528 struct f2fs_bio_info write_io[NR_PAGE_TYPE]; /* for write bios */ 529 530 /* for checkpoint */ 531 struct f2fs_checkpoint *ckpt; /* raw checkpoint pointer */ 532 struct inode *meta_inode; /* cache meta blocks */ 533 struct mutex cp_mutex; /* checkpoint procedure lock */ 534 struct rw_semaphore cp_rwsem; /* blocking FS operations */ 535 struct rw_semaphore node_write; /* locking node writes */ 536 struct mutex writepages; /* mutex for writepages() */ 537 bool por_doing; /* recovery is doing or not */ 538 wait_queue_head_t cp_wait; 539 540 struct inode_management im[MAX_INO_ENTRY]; /* manage inode cache */ 541 542 /* for orphan inode, use 0'th array */ 543 unsigned int max_orphans; /* max orphan inodes */ 544 545 /* for directory inode management */ 546 struct list_head dir_inode_list; /* dir inode list */ 547 spinlock_t dir_inode_lock; /* for dir inode list lock */ 548 549 /* basic filesystem units */ 550 unsigned int log_sectors_per_block; /* log2 sectors per block */ 551 unsigned int log_blocksize; /* log2 block size */ 552 unsigned int blocksize; /* block size */ 553 unsigned int root_ino_num; /* root inode number*/ 554 unsigned int node_ino_num; /* node inode number*/ 555 unsigned int meta_ino_num; /* meta inode number*/ 556 unsigned int log_blocks_per_seg; /* log2 blocks per segment */ 557 unsigned int blocks_per_seg; /* blocks per segment */ 558 unsigned int segs_per_sec; /* segments per section */ 559 unsigned int secs_per_zone; /* sections per zone */ 560 unsigned int total_sections; /* total section count */ 561 unsigned int total_node_count; /* total node block count */ 562 unsigned int total_valid_node_count; /* valid node block count */ 563 unsigned int total_valid_inode_count; /* valid inode count */ 564 int active_logs; /* # of active logs */ 565 int dir_level; /* directory level */ 566 567 block_t user_block_count; /* # of user blocks */ 568 block_t total_valid_block_count; /* # of valid blocks */ 569 block_t alloc_valid_block_count; /* # of allocated blocks */ 570 block_t last_valid_block_count; /* for recovery */ 571 u32 s_next_generation; /* for NFS support */ 572 atomic_t nr_pages[NR_COUNT_TYPE]; /* # of pages, see count_type */ 573 574 struct f2fs_mount_info mount_opt; /* mount options */ 575 576 /* for cleaning operations */ 577 struct mutex gc_mutex; /* mutex for GC */ 578 struct f2fs_gc_kthread *gc_thread; /* GC thread */ 579 unsigned int cur_victim_sec; /* current victim section num */ 580 581 /* maximum # of trials to find a victim segment for SSR and GC */ 582 unsigned int max_victim_search; 583 584 /* 585 * for stat information. 586 * one is for the LFS mode, and the other is for the SSR mode. 587 */ 588 #ifdef CONFIG_F2FS_STAT_FS 589 struct f2fs_stat_info *stat_info; /* FS status information */ 590 unsigned int segment_count[2]; /* # of allocated segments */ 591 unsigned int block_count[2]; /* # of allocated blocks */ 592 int total_hit_ext, read_hit_ext; /* extent cache hit ratio */ 593 atomic_t inline_inode; /* # of inline_data inodes */ 594 atomic_t inline_dir; /* # of inline_dentry inodes */ 595 int bg_gc; /* background gc calls */ 596 unsigned int n_dirty_dirs; /* # of dir inodes */ 597 #endif 598 unsigned int last_victim[2]; /* last victim segment # */ 599 spinlock_t stat_lock; /* lock for stat operations */ 600 601 /* For sysfs suppport */ 602 struct kobject s_kobj; 603 struct completion s_kobj_unregister; 604 }; 605 606 /* 607 * Inline functions 608 */ 609 static inline struct f2fs_inode_info *F2FS_I(struct inode *inode) 610 { 611 return container_of(inode, struct f2fs_inode_info, vfs_inode); 612 } 613 614 static inline struct f2fs_sb_info *F2FS_SB(struct super_block *sb) 615 { 616 return sb->s_fs_info; 617 } 618 619 static inline struct f2fs_sb_info *F2FS_I_SB(struct inode *inode) 620 { 621 return F2FS_SB(inode->i_sb); 622 } 623 624 static inline struct f2fs_sb_info *F2FS_M_SB(struct address_space *mapping) 625 { 626 return F2FS_I_SB(mapping->host); 627 } 628 629 static inline struct f2fs_sb_info *F2FS_P_SB(struct page *page) 630 { 631 return F2FS_M_SB(page->mapping); 632 } 633 634 static inline struct f2fs_super_block *F2FS_RAW_SUPER(struct f2fs_sb_info *sbi) 635 { 636 return (struct f2fs_super_block *)(sbi->raw_super); 637 } 638 639 static inline struct f2fs_checkpoint *F2FS_CKPT(struct f2fs_sb_info *sbi) 640 { 641 return (struct f2fs_checkpoint *)(sbi->ckpt); 642 } 643 644 static inline struct f2fs_node *F2FS_NODE(struct page *page) 645 { 646 return (struct f2fs_node *)page_address(page); 647 } 648 649 static inline struct f2fs_inode *F2FS_INODE(struct page *page) 650 { 651 return &((struct f2fs_node *)page_address(page))->i; 652 } 653 654 static inline struct f2fs_nm_info *NM_I(struct f2fs_sb_info *sbi) 655 { 656 return (struct f2fs_nm_info *)(sbi->nm_info); 657 } 658 659 static inline struct f2fs_sm_info *SM_I(struct f2fs_sb_info *sbi) 660 { 661 return (struct f2fs_sm_info *)(sbi->sm_info); 662 } 663 664 static inline struct sit_info *SIT_I(struct f2fs_sb_info *sbi) 665 { 666 return (struct sit_info *)(SM_I(sbi)->sit_info); 667 } 668 669 static inline struct free_segmap_info *FREE_I(struct f2fs_sb_info *sbi) 670 { 671 return (struct free_segmap_info *)(SM_I(sbi)->free_info); 672 } 673 674 static inline struct dirty_seglist_info *DIRTY_I(struct f2fs_sb_info *sbi) 675 { 676 return (struct dirty_seglist_info *)(SM_I(sbi)->dirty_info); 677 } 678 679 static inline struct address_space *META_MAPPING(struct f2fs_sb_info *sbi) 680 { 681 return sbi->meta_inode->i_mapping; 682 } 683 684 static inline struct address_space *NODE_MAPPING(struct f2fs_sb_info *sbi) 685 { 686 return sbi->node_inode->i_mapping; 687 } 688 689 static inline void F2FS_SET_SB_DIRT(struct f2fs_sb_info *sbi) 690 { 691 sbi->s_dirty = 1; 692 } 693 694 static inline void F2FS_RESET_SB_DIRT(struct f2fs_sb_info *sbi) 695 { 696 sbi->s_dirty = 0; 697 } 698 699 static inline unsigned long long cur_cp_version(struct f2fs_checkpoint *cp) 700 { 701 return le64_to_cpu(cp->checkpoint_ver); 702 } 703 704 static inline bool is_set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f) 705 { 706 unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags); 707 return ckpt_flags & f; 708 } 709 710 static inline void set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f) 711 { 712 unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags); 713 ckpt_flags |= f; 714 cp->ckpt_flags = cpu_to_le32(ckpt_flags); 715 } 716 717 static inline void clear_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f) 718 { 719 unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags); 720 ckpt_flags &= (~f); 721 cp->ckpt_flags = cpu_to_le32(ckpt_flags); 722 } 723 724 static inline void f2fs_lock_op(struct f2fs_sb_info *sbi) 725 { 726 down_read(&sbi->cp_rwsem); 727 } 728 729 static inline void f2fs_unlock_op(struct f2fs_sb_info *sbi) 730 { 731 up_read(&sbi->cp_rwsem); 732 } 733 734 static inline void f2fs_lock_all(struct f2fs_sb_info *sbi) 735 { 736 f2fs_down_write(&sbi->cp_rwsem, &sbi->cp_mutex); 737 } 738 739 static inline void f2fs_unlock_all(struct f2fs_sb_info *sbi) 740 { 741 up_write(&sbi->cp_rwsem); 742 } 743 744 /* 745 * Check whether the given nid is within node id range. 746 */ 747 static inline int check_nid_range(struct f2fs_sb_info *sbi, nid_t nid) 748 { 749 if (unlikely(nid < F2FS_ROOT_INO(sbi))) 750 return -EINVAL; 751 if (unlikely(nid >= NM_I(sbi)->max_nid)) 752 return -EINVAL; 753 return 0; 754 } 755 756 #define F2FS_DEFAULT_ALLOCATED_BLOCKS 1 757 758 /* 759 * Check whether the inode has blocks or not 760 */ 761 static inline int F2FS_HAS_BLOCKS(struct inode *inode) 762 { 763 if (F2FS_I(inode)->i_xattr_nid) 764 return inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS + 1; 765 else 766 return inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS; 767 } 768 769 static inline bool f2fs_has_xattr_block(unsigned int ofs) 770 { 771 return ofs == XATTR_NODE_OFFSET; 772 } 773 774 static inline bool inc_valid_block_count(struct f2fs_sb_info *sbi, 775 struct inode *inode, blkcnt_t count) 776 { 777 block_t valid_block_count; 778 779 spin_lock(&sbi->stat_lock); 780 valid_block_count = 781 sbi->total_valid_block_count + (block_t)count; 782 if (unlikely(valid_block_count > sbi->user_block_count)) { 783 spin_unlock(&sbi->stat_lock); 784 return false; 785 } 786 inode->i_blocks += count; 787 sbi->total_valid_block_count = valid_block_count; 788 sbi->alloc_valid_block_count += (block_t)count; 789 spin_unlock(&sbi->stat_lock); 790 return true; 791 } 792 793 static inline void dec_valid_block_count(struct f2fs_sb_info *sbi, 794 struct inode *inode, 795 blkcnt_t count) 796 { 797 spin_lock(&sbi->stat_lock); 798 f2fs_bug_on(sbi, sbi->total_valid_block_count < (block_t) count); 799 f2fs_bug_on(sbi, inode->i_blocks < count); 800 inode->i_blocks -= count; 801 sbi->total_valid_block_count -= (block_t)count; 802 spin_unlock(&sbi->stat_lock); 803 } 804 805 static inline void inc_page_count(struct f2fs_sb_info *sbi, int count_type) 806 { 807 atomic_inc(&sbi->nr_pages[count_type]); 808 F2FS_SET_SB_DIRT(sbi); 809 } 810 811 static inline void inode_inc_dirty_pages(struct inode *inode) 812 { 813 atomic_inc(&F2FS_I(inode)->dirty_pages); 814 if (S_ISDIR(inode->i_mode)) 815 inc_page_count(F2FS_I_SB(inode), F2FS_DIRTY_DENTS); 816 } 817 818 static inline void dec_page_count(struct f2fs_sb_info *sbi, int count_type) 819 { 820 atomic_dec(&sbi->nr_pages[count_type]); 821 } 822 823 static inline void inode_dec_dirty_pages(struct inode *inode) 824 { 825 if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode)) 826 return; 827 828 atomic_dec(&F2FS_I(inode)->dirty_pages); 829 830 if (S_ISDIR(inode->i_mode)) 831 dec_page_count(F2FS_I_SB(inode), F2FS_DIRTY_DENTS); 832 } 833 834 static inline int get_pages(struct f2fs_sb_info *sbi, int count_type) 835 { 836 return atomic_read(&sbi->nr_pages[count_type]); 837 } 838 839 static inline int get_dirty_pages(struct inode *inode) 840 { 841 return atomic_read(&F2FS_I(inode)->dirty_pages); 842 } 843 844 static inline int get_blocktype_secs(struct f2fs_sb_info *sbi, int block_type) 845 { 846 unsigned int pages_per_sec = sbi->segs_per_sec * 847 (1 << sbi->log_blocks_per_seg); 848 return ((get_pages(sbi, block_type) + pages_per_sec - 1) 849 >> sbi->log_blocks_per_seg) / sbi->segs_per_sec; 850 } 851 852 static inline block_t valid_user_blocks(struct f2fs_sb_info *sbi) 853 { 854 return sbi->total_valid_block_count; 855 } 856 857 static inline unsigned long __bitmap_size(struct f2fs_sb_info *sbi, int flag) 858 { 859 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi); 860 861 /* return NAT or SIT bitmap */ 862 if (flag == NAT_BITMAP) 863 return le32_to_cpu(ckpt->nat_ver_bitmap_bytesize); 864 else if (flag == SIT_BITMAP) 865 return le32_to_cpu(ckpt->sit_ver_bitmap_bytesize); 866 867 return 0; 868 } 869 870 static inline void *__bitmap_ptr(struct f2fs_sb_info *sbi, int flag) 871 { 872 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi); 873 int offset; 874 875 if (le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload) > 0) { 876 if (flag == NAT_BITMAP) 877 return &ckpt->sit_nat_version_bitmap; 878 else 879 return (unsigned char *)ckpt + F2FS_BLKSIZE; 880 } else { 881 offset = (flag == NAT_BITMAP) ? 882 le32_to_cpu(ckpt->sit_ver_bitmap_bytesize) : 0; 883 return &ckpt->sit_nat_version_bitmap + offset; 884 } 885 } 886 887 static inline block_t __start_cp_addr(struct f2fs_sb_info *sbi) 888 { 889 block_t start_addr; 890 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi); 891 unsigned long long ckpt_version = cur_cp_version(ckpt); 892 893 start_addr = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_blkaddr); 894 895 /* 896 * odd numbered checkpoint should at cp segment 0 897 * and even segment must be at cp segment 1 898 */ 899 if (!(ckpt_version & 1)) 900 start_addr += sbi->blocks_per_seg; 901 902 return start_addr; 903 } 904 905 static inline block_t __start_sum_addr(struct f2fs_sb_info *sbi) 906 { 907 return le32_to_cpu(F2FS_CKPT(sbi)->cp_pack_start_sum); 908 } 909 910 static inline bool inc_valid_node_count(struct f2fs_sb_info *sbi, 911 struct inode *inode) 912 { 913 block_t valid_block_count; 914 unsigned int valid_node_count; 915 916 spin_lock(&sbi->stat_lock); 917 918 valid_block_count = sbi->total_valid_block_count + 1; 919 if (unlikely(valid_block_count > sbi->user_block_count)) { 920 spin_unlock(&sbi->stat_lock); 921 return false; 922 } 923 924 valid_node_count = sbi->total_valid_node_count + 1; 925 if (unlikely(valid_node_count > sbi->total_node_count)) { 926 spin_unlock(&sbi->stat_lock); 927 return false; 928 } 929 930 if (inode) 931 inode->i_blocks++; 932 933 sbi->alloc_valid_block_count++; 934 sbi->total_valid_node_count++; 935 sbi->total_valid_block_count++; 936 spin_unlock(&sbi->stat_lock); 937 938 return true; 939 } 940 941 static inline void dec_valid_node_count(struct f2fs_sb_info *sbi, 942 struct inode *inode) 943 { 944 spin_lock(&sbi->stat_lock); 945 946 f2fs_bug_on(sbi, !sbi->total_valid_block_count); 947 f2fs_bug_on(sbi, !sbi->total_valid_node_count); 948 f2fs_bug_on(sbi, !inode->i_blocks); 949 950 inode->i_blocks--; 951 sbi->total_valid_node_count--; 952 sbi->total_valid_block_count--; 953 954 spin_unlock(&sbi->stat_lock); 955 } 956 957 static inline unsigned int valid_node_count(struct f2fs_sb_info *sbi) 958 { 959 return sbi->total_valid_node_count; 960 } 961 962 static inline void inc_valid_inode_count(struct f2fs_sb_info *sbi) 963 { 964 spin_lock(&sbi->stat_lock); 965 f2fs_bug_on(sbi, sbi->total_valid_inode_count == sbi->total_node_count); 966 sbi->total_valid_inode_count++; 967 spin_unlock(&sbi->stat_lock); 968 } 969 970 static inline void dec_valid_inode_count(struct f2fs_sb_info *sbi) 971 { 972 spin_lock(&sbi->stat_lock); 973 f2fs_bug_on(sbi, !sbi->total_valid_inode_count); 974 sbi->total_valid_inode_count--; 975 spin_unlock(&sbi->stat_lock); 976 } 977 978 static inline unsigned int valid_inode_count(struct f2fs_sb_info *sbi) 979 { 980 return sbi->total_valid_inode_count; 981 } 982 983 static inline void f2fs_put_page(struct page *page, int unlock) 984 { 985 if (!page) 986 return; 987 988 if (unlock) { 989 f2fs_bug_on(F2FS_P_SB(page), !PageLocked(page)); 990 unlock_page(page); 991 } 992 page_cache_release(page); 993 } 994 995 static inline void f2fs_put_dnode(struct dnode_of_data *dn) 996 { 997 if (dn->node_page) 998 f2fs_put_page(dn->node_page, 1); 999 if (dn->inode_page && dn->node_page != dn->inode_page) 1000 f2fs_put_page(dn->inode_page, 0); 1001 dn->node_page = NULL; 1002 dn->inode_page = NULL; 1003 } 1004 1005 static inline struct kmem_cache *f2fs_kmem_cache_create(const char *name, 1006 size_t size) 1007 { 1008 return kmem_cache_create(name, size, 0, SLAB_RECLAIM_ACCOUNT, NULL); 1009 } 1010 1011 static inline void *f2fs_kmem_cache_alloc(struct kmem_cache *cachep, 1012 gfp_t flags) 1013 { 1014 void *entry; 1015 retry: 1016 entry = kmem_cache_alloc(cachep, flags); 1017 if (!entry) { 1018 cond_resched(); 1019 goto retry; 1020 } 1021 1022 return entry; 1023 } 1024 1025 static inline void f2fs_radix_tree_insert(struct radix_tree_root *root, 1026 unsigned long index, void *item) 1027 { 1028 while (radix_tree_insert(root, index, item)) 1029 cond_resched(); 1030 } 1031 1032 #define RAW_IS_INODE(p) ((p)->footer.nid == (p)->footer.ino) 1033 1034 static inline bool IS_INODE(struct page *page) 1035 { 1036 struct f2fs_node *p = F2FS_NODE(page); 1037 return RAW_IS_INODE(p); 1038 } 1039 1040 static inline __le32 *blkaddr_in_node(struct f2fs_node *node) 1041 { 1042 return RAW_IS_INODE(node) ? node->i.i_addr : node->dn.addr; 1043 } 1044 1045 static inline block_t datablock_addr(struct page *node_page, 1046 unsigned int offset) 1047 { 1048 struct f2fs_node *raw_node; 1049 __le32 *addr_array; 1050 raw_node = F2FS_NODE(node_page); 1051 addr_array = blkaddr_in_node(raw_node); 1052 return le32_to_cpu(addr_array[offset]); 1053 } 1054 1055 static inline int f2fs_test_bit(unsigned int nr, char *addr) 1056 { 1057 int mask; 1058 1059 addr += (nr >> 3); 1060 mask = 1 << (7 - (nr & 0x07)); 1061 return mask & *addr; 1062 } 1063 1064 static inline int f2fs_test_and_set_bit(unsigned int nr, char *addr) 1065 { 1066 int mask; 1067 int ret; 1068 1069 addr += (nr >> 3); 1070 mask = 1 << (7 - (nr & 0x07)); 1071 ret = mask & *addr; 1072 *addr |= mask; 1073 return ret; 1074 } 1075 1076 static inline int f2fs_test_and_clear_bit(unsigned int nr, char *addr) 1077 { 1078 int mask; 1079 int ret; 1080 1081 addr += (nr >> 3); 1082 mask = 1 << (7 - (nr & 0x07)); 1083 ret = mask & *addr; 1084 *addr &= ~mask; 1085 return ret; 1086 } 1087 1088 static inline void f2fs_change_bit(unsigned int nr, char *addr) 1089 { 1090 int mask; 1091 1092 addr += (nr >> 3); 1093 mask = 1 << (7 - (nr & 0x07)); 1094 *addr ^= mask; 1095 } 1096 1097 /* used for f2fs_inode_info->flags */ 1098 enum { 1099 FI_NEW_INODE, /* indicate newly allocated inode */ 1100 FI_DIRTY_INODE, /* indicate inode is dirty or not */ 1101 FI_DIRTY_DIR, /* indicate directory has dirty pages */ 1102 FI_INC_LINK, /* need to increment i_nlink */ 1103 FI_ACL_MODE, /* indicate acl mode */ 1104 FI_NO_ALLOC, /* should not allocate any blocks */ 1105 FI_UPDATE_DIR, /* should update inode block for consistency */ 1106 FI_DELAY_IPUT, /* used for the recovery */ 1107 FI_NO_EXTENT, /* not to use the extent cache */ 1108 FI_INLINE_XATTR, /* used for inline xattr */ 1109 FI_INLINE_DATA, /* used for inline data*/ 1110 FI_INLINE_DENTRY, /* used for inline dentry */ 1111 FI_APPEND_WRITE, /* inode has appended data */ 1112 FI_UPDATE_WRITE, /* inode has in-place-update data */ 1113 FI_NEED_IPU, /* used for ipu per file */ 1114 FI_ATOMIC_FILE, /* indicate atomic file */ 1115 FI_VOLATILE_FILE, /* indicate volatile file */ 1116 FI_DATA_EXIST, /* indicate data exists */ 1117 }; 1118 1119 static inline void set_inode_flag(struct f2fs_inode_info *fi, int flag) 1120 { 1121 if (!test_bit(flag, &fi->flags)) 1122 set_bit(flag, &fi->flags); 1123 } 1124 1125 static inline int is_inode_flag_set(struct f2fs_inode_info *fi, int flag) 1126 { 1127 return test_bit(flag, &fi->flags); 1128 } 1129 1130 static inline void clear_inode_flag(struct f2fs_inode_info *fi, int flag) 1131 { 1132 if (test_bit(flag, &fi->flags)) 1133 clear_bit(flag, &fi->flags); 1134 } 1135 1136 static inline void set_acl_inode(struct f2fs_inode_info *fi, umode_t mode) 1137 { 1138 fi->i_acl_mode = mode; 1139 set_inode_flag(fi, FI_ACL_MODE); 1140 } 1141 1142 static inline void get_inline_info(struct f2fs_inode_info *fi, 1143 struct f2fs_inode *ri) 1144 { 1145 if (ri->i_inline & F2FS_INLINE_XATTR) 1146 set_inode_flag(fi, FI_INLINE_XATTR); 1147 if (ri->i_inline & F2FS_INLINE_DATA) 1148 set_inode_flag(fi, FI_INLINE_DATA); 1149 if (ri->i_inline & F2FS_INLINE_DENTRY) 1150 set_inode_flag(fi, FI_INLINE_DENTRY); 1151 if (ri->i_inline & F2FS_DATA_EXIST) 1152 set_inode_flag(fi, FI_DATA_EXIST); 1153 } 1154 1155 static inline void set_raw_inline(struct f2fs_inode_info *fi, 1156 struct f2fs_inode *ri) 1157 { 1158 ri->i_inline = 0; 1159 1160 if (is_inode_flag_set(fi, FI_INLINE_XATTR)) 1161 ri->i_inline |= F2FS_INLINE_XATTR; 1162 if (is_inode_flag_set(fi, FI_INLINE_DATA)) 1163 ri->i_inline |= F2FS_INLINE_DATA; 1164 if (is_inode_flag_set(fi, FI_INLINE_DENTRY)) 1165 ri->i_inline |= F2FS_INLINE_DENTRY; 1166 if (is_inode_flag_set(fi, FI_DATA_EXIST)) 1167 ri->i_inline |= F2FS_DATA_EXIST; 1168 } 1169 1170 static inline int f2fs_has_inline_xattr(struct inode *inode) 1171 { 1172 return is_inode_flag_set(F2FS_I(inode), FI_INLINE_XATTR); 1173 } 1174 1175 static inline unsigned int addrs_per_inode(struct f2fs_inode_info *fi) 1176 { 1177 if (f2fs_has_inline_xattr(&fi->vfs_inode)) 1178 return DEF_ADDRS_PER_INODE - F2FS_INLINE_XATTR_ADDRS; 1179 return DEF_ADDRS_PER_INODE; 1180 } 1181 1182 static inline void *inline_xattr_addr(struct page *page) 1183 { 1184 struct f2fs_inode *ri = F2FS_INODE(page); 1185 return (void *)&(ri->i_addr[DEF_ADDRS_PER_INODE - 1186 F2FS_INLINE_XATTR_ADDRS]); 1187 } 1188 1189 static inline int inline_xattr_size(struct inode *inode) 1190 { 1191 if (f2fs_has_inline_xattr(inode)) 1192 return F2FS_INLINE_XATTR_ADDRS << 2; 1193 else 1194 return 0; 1195 } 1196 1197 static inline int f2fs_has_inline_data(struct inode *inode) 1198 { 1199 return is_inode_flag_set(F2FS_I(inode), FI_INLINE_DATA); 1200 } 1201 1202 static inline void f2fs_clear_inline_inode(struct inode *inode) 1203 { 1204 clear_inode_flag(F2FS_I(inode), FI_INLINE_DATA); 1205 clear_inode_flag(F2FS_I(inode), FI_DATA_EXIST); 1206 } 1207 1208 static inline int f2fs_exist_data(struct inode *inode) 1209 { 1210 return is_inode_flag_set(F2FS_I(inode), FI_DATA_EXIST); 1211 } 1212 1213 static inline bool f2fs_is_atomic_file(struct inode *inode) 1214 { 1215 return is_inode_flag_set(F2FS_I(inode), FI_ATOMIC_FILE); 1216 } 1217 1218 static inline bool f2fs_is_volatile_file(struct inode *inode) 1219 { 1220 return is_inode_flag_set(F2FS_I(inode), FI_VOLATILE_FILE); 1221 } 1222 1223 static inline void *inline_data_addr(struct page *page) 1224 { 1225 struct f2fs_inode *ri = F2FS_INODE(page); 1226 return (void *)&(ri->i_addr[1]); 1227 } 1228 1229 static inline int f2fs_has_inline_dentry(struct inode *inode) 1230 { 1231 return is_inode_flag_set(F2FS_I(inode), FI_INLINE_DENTRY); 1232 } 1233 1234 static inline void *inline_dentry_addr(struct page *page) 1235 { 1236 struct f2fs_inode *ri = F2FS_INODE(page); 1237 return (void *)&(ri->i_addr[1]); 1238 } 1239 1240 static inline void f2fs_dentry_kunmap(struct inode *dir, struct page *page) 1241 { 1242 if (!f2fs_has_inline_dentry(dir)) 1243 kunmap(page); 1244 } 1245 1246 static inline int f2fs_readonly(struct super_block *sb) 1247 { 1248 return sb->s_flags & MS_RDONLY; 1249 } 1250 1251 static inline bool f2fs_cp_error(struct f2fs_sb_info *sbi) 1252 { 1253 return is_set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG); 1254 } 1255 1256 static inline void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi) 1257 { 1258 set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG); 1259 sbi->sb->s_flags |= MS_RDONLY; 1260 } 1261 1262 #define get_inode_mode(i) \ 1263 ((is_inode_flag_set(F2FS_I(i), FI_ACL_MODE)) ? \ 1264 (F2FS_I(i)->i_acl_mode) : ((i)->i_mode)) 1265 1266 /* get offset of first page in next direct node */ 1267 #define PGOFS_OF_NEXT_DNODE(pgofs, fi) \ 1268 ((pgofs < ADDRS_PER_INODE(fi)) ? ADDRS_PER_INODE(fi) : \ 1269 (pgofs - ADDRS_PER_INODE(fi) + ADDRS_PER_BLOCK) / \ 1270 ADDRS_PER_BLOCK * ADDRS_PER_BLOCK + ADDRS_PER_INODE(fi)) 1271 1272 /* 1273 * file.c 1274 */ 1275 int f2fs_sync_file(struct file *, loff_t, loff_t, int); 1276 void truncate_data_blocks(struct dnode_of_data *); 1277 int truncate_blocks(struct inode *, u64, bool); 1278 void f2fs_truncate(struct inode *); 1279 int f2fs_getattr(struct vfsmount *, struct dentry *, struct kstat *); 1280 int f2fs_setattr(struct dentry *, struct iattr *); 1281 int truncate_hole(struct inode *, pgoff_t, pgoff_t); 1282 int truncate_data_blocks_range(struct dnode_of_data *, int); 1283 long f2fs_ioctl(struct file *, unsigned int, unsigned long); 1284 long f2fs_compat_ioctl(struct file *, unsigned int, unsigned long); 1285 1286 /* 1287 * inode.c 1288 */ 1289 void f2fs_set_inode_flags(struct inode *); 1290 struct inode *f2fs_iget(struct super_block *, unsigned long); 1291 int try_to_free_nats(struct f2fs_sb_info *, int); 1292 void update_inode(struct inode *, struct page *); 1293 void update_inode_page(struct inode *); 1294 int f2fs_write_inode(struct inode *, struct writeback_control *); 1295 void f2fs_evict_inode(struct inode *); 1296 void handle_failed_inode(struct inode *); 1297 1298 /* 1299 * namei.c 1300 */ 1301 struct dentry *f2fs_get_parent(struct dentry *child); 1302 1303 /* 1304 * dir.c 1305 */ 1306 extern unsigned char f2fs_filetype_table[F2FS_FT_MAX]; 1307 void set_de_type(struct f2fs_dir_entry *, struct inode *); 1308 struct f2fs_dir_entry *find_target_dentry(struct qstr *, int *, 1309 struct f2fs_dentry_ptr *); 1310 bool f2fs_fill_dentries(struct dir_context *, struct f2fs_dentry_ptr *, 1311 unsigned int); 1312 void do_make_empty_dir(struct inode *, struct inode *, 1313 struct f2fs_dentry_ptr *); 1314 struct page *init_inode_metadata(struct inode *, struct inode *, 1315 const struct qstr *, struct page *); 1316 void update_parent_metadata(struct inode *, struct inode *, unsigned int); 1317 int room_for_filename(const void *, int, int); 1318 void f2fs_drop_nlink(struct inode *, struct inode *, struct page *); 1319 struct f2fs_dir_entry *f2fs_find_entry(struct inode *, struct qstr *, 1320 struct page **); 1321 struct f2fs_dir_entry *f2fs_parent_dir(struct inode *, struct page **); 1322 ino_t f2fs_inode_by_name(struct inode *, struct qstr *); 1323 void f2fs_set_link(struct inode *, struct f2fs_dir_entry *, 1324 struct page *, struct inode *); 1325 int update_dent_inode(struct inode *, const struct qstr *); 1326 int __f2fs_add_link(struct inode *, const struct qstr *, struct inode *); 1327 void f2fs_delete_entry(struct f2fs_dir_entry *, struct page *, struct inode *, 1328 struct inode *); 1329 int f2fs_do_tmpfile(struct inode *, struct inode *); 1330 int f2fs_make_empty(struct inode *, struct inode *); 1331 bool f2fs_empty_dir(struct inode *); 1332 1333 static inline int f2fs_add_link(struct dentry *dentry, struct inode *inode) 1334 { 1335 return __f2fs_add_link(dentry->d_parent->d_inode, &dentry->d_name, 1336 inode); 1337 } 1338 1339 /* 1340 * super.c 1341 */ 1342 int f2fs_sync_fs(struct super_block *, int); 1343 extern __printf(3, 4) 1344 void f2fs_msg(struct super_block *, const char *, const char *, ...); 1345 1346 /* 1347 * hash.c 1348 */ 1349 f2fs_hash_t f2fs_dentry_hash(const struct qstr *); 1350 1351 /* 1352 * node.c 1353 */ 1354 struct dnode_of_data; 1355 struct node_info; 1356 1357 bool available_free_memory(struct f2fs_sb_info *, int); 1358 bool is_checkpointed_node(struct f2fs_sb_info *, nid_t); 1359 bool has_fsynced_inode(struct f2fs_sb_info *, nid_t); 1360 bool need_inode_block_update(struct f2fs_sb_info *, nid_t); 1361 void get_node_info(struct f2fs_sb_info *, nid_t, struct node_info *); 1362 int get_dnode_of_data(struct dnode_of_data *, pgoff_t, int); 1363 int truncate_inode_blocks(struct inode *, pgoff_t); 1364 int truncate_xattr_node(struct inode *, struct page *); 1365 int wait_on_node_pages_writeback(struct f2fs_sb_info *, nid_t); 1366 void remove_inode_page(struct inode *); 1367 struct page *new_inode_page(struct inode *); 1368 struct page *new_node_page(struct dnode_of_data *, unsigned int, struct page *); 1369 void ra_node_page(struct f2fs_sb_info *, nid_t); 1370 struct page *get_node_page(struct f2fs_sb_info *, pgoff_t); 1371 struct page *get_node_page_ra(struct page *, int); 1372 void sync_inode_page(struct dnode_of_data *); 1373 int sync_node_pages(struct f2fs_sb_info *, nid_t, struct writeback_control *); 1374 bool alloc_nid(struct f2fs_sb_info *, nid_t *); 1375 void alloc_nid_done(struct f2fs_sb_info *, nid_t); 1376 void alloc_nid_failed(struct f2fs_sb_info *, nid_t); 1377 void recover_inline_xattr(struct inode *, struct page *); 1378 void recover_xattr_data(struct inode *, struct page *, block_t); 1379 int recover_inode_page(struct f2fs_sb_info *, struct page *); 1380 int restore_node_summary(struct f2fs_sb_info *, unsigned int, 1381 struct f2fs_summary_block *); 1382 void flush_nat_entries(struct f2fs_sb_info *); 1383 int build_node_manager(struct f2fs_sb_info *); 1384 void destroy_node_manager(struct f2fs_sb_info *); 1385 int __init create_node_manager_caches(void); 1386 void destroy_node_manager_caches(void); 1387 1388 /* 1389 * segment.c 1390 */ 1391 void register_inmem_page(struct inode *, struct page *); 1392 void invalidate_inmem_page(struct inode *, struct page *); 1393 void commit_inmem_pages(struct inode *, bool); 1394 void f2fs_balance_fs(struct f2fs_sb_info *); 1395 void f2fs_balance_fs_bg(struct f2fs_sb_info *); 1396 int f2fs_issue_flush(struct f2fs_sb_info *); 1397 int create_flush_cmd_control(struct f2fs_sb_info *); 1398 void destroy_flush_cmd_control(struct f2fs_sb_info *); 1399 void invalidate_blocks(struct f2fs_sb_info *, block_t); 1400 void refresh_sit_entry(struct f2fs_sb_info *, block_t, block_t); 1401 void clear_prefree_segments(struct f2fs_sb_info *); 1402 void release_discard_addrs(struct f2fs_sb_info *); 1403 void discard_next_dnode(struct f2fs_sb_info *, block_t); 1404 int npages_for_summary_flush(struct f2fs_sb_info *); 1405 void allocate_new_segments(struct f2fs_sb_info *); 1406 int f2fs_trim_fs(struct f2fs_sb_info *, struct fstrim_range *); 1407 struct page *get_sum_page(struct f2fs_sb_info *, unsigned int); 1408 void write_meta_page(struct f2fs_sb_info *, struct page *); 1409 void write_node_page(struct f2fs_sb_info *, struct page *, 1410 struct f2fs_io_info *, unsigned int, block_t, block_t *); 1411 void write_data_page(struct page *, struct dnode_of_data *, block_t *, 1412 struct f2fs_io_info *); 1413 void rewrite_data_page(struct page *, block_t, struct f2fs_io_info *); 1414 void recover_data_page(struct f2fs_sb_info *, struct page *, 1415 struct f2fs_summary *, block_t, block_t); 1416 void allocate_data_block(struct f2fs_sb_info *, struct page *, 1417 block_t, block_t *, struct f2fs_summary *, int); 1418 void f2fs_wait_on_page_writeback(struct page *, enum page_type); 1419 void write_data_summaries(struct f2fs_sb_info *, block_t); 1420 void write_node_summaries(struct f2fs_sb_info *, block_t); 1421 int lookup_journal_in_cursum(struct f2fs_summary_block *, 1422 int, unsigned int, int); 1423 void flush_sit_entries(struct f2fs_sb_info *, struct cp_control *); 1424 int build_segment_manager(struct f2fs_sb_info *); 1425 void destroy_segment_manager(struct f2fs_sb_info *); 1426 int __init create_segment_manager_caches(void); 1427 void destroy_segment_manager_caches(void); 1428 1429 /* 1430 * checkpoint.c 1431 */ 1432 struct page *grab_meta_page(struct f2fs_sb_info *, pgoff_t); 1433 struct page *get_meta_page(struct f2fs_sb_info *, pgoff_t); 1434 int ra_meta_pages(struct f2fs_sb_info *, block_t, int, int); 1435 void ra_meta_pages_cond(struct f2fs_sb_info *, pgoff_t); 1436 long sync_meta_pages(struct f2fs_sb_info *, enum page_type, long); 1437 void add_dirty_inode(struct f2fs_sb_info *, nid_t, int type); 1438 void remove_dirty_inode(struct f2fs_sb_info *, nid_t, int type); 1439 void release_dirty_inode(struct f2fs_sb_info *); 1440 bool exist_written_data(struct f2fs_sb_info *, nid_t, int); 1441 int acquire_orphan_inode(struct f2fs_sb_info *); 1442 void release_orphan_inode(struct f2fs_sb_info *); 1443 void add_orphan_inode(struct f2fs_sb_info *, nid_t); 1444 void remove_orphan_inode(struct f2fs_sb_info *, nid_t); 1445 void recover_orphan_inodes(struct f2fs_sb_info *); 1446 int get_valid_checkpoint(struct f2fs_sb_info *); 1447 void update_dirty_page(struct inode *, struct page *); 1448 void add_dirty_dir_inode(struct inode *); 1449 void remove_dirty_dir_inode(struct inode *); 1450 void sync_dirty_dir_inodes(struct f2fs_sb_info *); 1451 void write_checkpoint(struct f2fs_sb_info *, struct cp_control *); 1452 void init_ino_entry_info(struct f2fs_sb_info *); 1453 int __init create_checkpoint_caches(void); 1454 void destroy_checkpoint_caches(void); 1455 1456 /* 1457 * data.c 1458 */ 1459 void f2fs_submit_merged_bio(struct f2fs_sb_info *, enum page_type, int); 1460 int f2fs_submit_page_bio(struct f2fs_sb_info *, struct page *, block_t, int); 1461 void f2fs_submit_page_mbio(struct f2fs_sb_info *, struct page *, block_t, 1462 struct f2fs_io_info *); 1463 int reserve_new_block(struct dnode_of_data *); 1464 int f2fs_reserve_block(struct dnode_of_data *, pgoff_t); 1465 void update_extent_cache(block_t, struct dnode_of_data *); 1466 struct page *find_data_page(struct inode *, pgoff_t, bool); 1467 struct page *get_lock_data_page(struct inode *, pgoff_t); 1468 struct page *get_new_data_page(struct inode *, struct page *, pgoff_t, bool); 1469 int do_write_data_page(struct page *, struct f2fs_io_info *); 1470 int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *, u64, u64); 1471 1472 /* 1473 * gc.c 1474 */ 1475 int start_gc_thread(struct f2fs_sb_info *); 1476 void stop_gc_thread(struct f2fs_sb_info *); 1477 block_t start_bidx_of_node(unsigned int, struct f2fs_inode_info *); 1478 int f2fs_gc(struct f2fs_sb_info *); 1479 void build_gc_manager(struct f2fs_sb_info *); 1480 int __init create_gc_caches(void); 1481 void destroy_gc_caches(void); 1482 1483 /* 1484 * recovery.c 1485 */ 1486 int recover_fsync_data(struct f2fs_sb_info *); 1487 bool space_for_roll_forward(struct f2fs_sb_info *); 1488 1489 /* 1490 * debug.c 1491 */ 1492 #ifdef CONFIG_F2FS_STAT_FS 1493 struct f2fs_stat_info { 1494 struct list_head stat_list; 1495 struct f2fs_sb_info *sbi; 1496 int all_area_segs, sit_area_segs, nat_area_segs, ssa_area_segs; 1497 int main_area_segs, main_area_sections, main_area_zones; 1498 int hit_ext, total_ext; 1499 int ndirty_node, ndirty_dent, ndirty_dirs, ndirty_meta; 1500 int nats, sits, fnids; 1501 int total_count, utilization; 1502 int bg_gc, inline_inode, inline_dir, inmem_pages; 1503 unsigned int valid_count, valid_node_count, valid_inode_count; 1504 unsigned int bimodal, avg_vblocks; 1505 int util_free, util_valid, util_invalid; 1506 int rsvd_segs, overp_segs; 1507 int dirty_count, node_pages, meta_pages; 1508 int prefree_count, call_count, cp_count; 1509 int tot_segs, node_segs, data_segs, free_segs, free_secs; 1510 int tot_blks, data_blks, node_blks; 1511 int curseg[NR_CURSEG_TYPE]; 1512 int cursec[NR_CURSEG_TYPE]; 1513 int curzone[NR_CURSEG_TYPE]; 1514 1515 unsigned int segment_count[2]; 1516 unsigned int block_count[2]; 1517 unsigned base_mem, cache_mem; 1518 }; 1519 1520 static inline struct f2fs_stat_info *F2FS_STAT(struct f2fs_sb_info *sbi) 1521 { 1522 return (struct f2fs_stat_info *)sbi->stat_info; 1523 } 1524 1525 #define stat_inc_cp_count(si) ((si)->cp_count++) 1526 #define stat_inc_call_count(si) ((si)->call_count++) 1527 #define stat_inc_bggc_count(sbi) ((sbi)->bg_gc++) 1528 #define stat_inc_dirty_dir(sbi) ((sbi)->n_dirty_dirs++) 1529 #define stat_dec_dirty_dir(sbi) ((sbi)->n_dirty_dirs--) 1530 #define stat_inc_total_hit(sb) ((F2FS_SB(sb))->total_hit_ext++) 1531 #define stat_inc_read_hit(sb) ((F2FS_SB(sb))->read_hit_ext++) 1532 #define stat_inc_inline_inode(inode) \ 1533 do { \ 1534 if (f2fs_has_inline_data(inode)) \ 1535 (atomic_inc(&F2FS_I_SB(inode)->inline_inode)); \ 1536 } while (0) 1537 #define stat_dec_inline_inode(inode) \ 1538 do { \ 1539 if (f2fs_has_inline_data(inode)) \ 1540 (atomic_dec(&F2FS_I_SB(inode)->inline_inode)); \ 1541 } while (0) 1542 #define stat_inc_inline_dir(inode) \ 1543 do { \ 1544 if (f2fs_has_inline_dentry(inode)) \ 1545 (atomic_inc(&F2FS_I_SB(inode)->inline_dir)); \ 1546 } while (0) 1547 #define stat_dec_inline_dir(inode) \ 1548 do { \ 1549 if (f2fs_has_inline_dentry(inode)) \ 1550 (atomic_dec(&F2FS_I_SB(inode)->inline_dir)); \ 1551 } while (0) 1552 #define stat_inc_seg_type(sbi, curseg) \ 1553 ((sbi)->segment_count[(curseg)->alloc_type]++) 1554 #define stat_inc_block_count(sbi, curseg) \ 1555 ((sbi)->block_count[(curseg)->alloc_type]++) 1556 1557 #define stat_inc_seg_count(sbi, type) \ 1558 do { \ 1559 struct f2fs_stat_info *si = F2FS_STAT(sbi); \ 1560 (si)->tot_segs++; \ 1561 if (type == SUM_TYPE_DATA) \ 1562 si->data_segs++; \ 1563 else \ 1564 si->node_segs++; \ 1565 } while (0) 1566 1567 #define stat_inc_tot_blk_count(si, blks) \ 1568 (si->tot_blks += (blks)) 1569 1570 #define stat_inc_data_blk_count(sbi, blks) \ 1571 do { \ 1572 struct f2fs_stat_info *si = F2FS_STAT(sbi); \ 1573 stat_inc_tot_blk_count(si, blks); \ 1574 si->data_blks += (blks); \ 1575 } while (0) 1576 1577 #define stat_inc_node_blk_count(sbi, blks) \ 1578 do { \ 1579 struct f2fs_stat_info *si = F2FS_STAT(sbi); \ 1580 stat_inc_tot_blk_count(si, blks); \ 1581 si->node_blks += (blks); \ 1582 } while (0) 1583 1584 int f2fs_build_stats(struct f2fs_sb_info *); 1585 void f2fs_destroy_stats(struct f2fs_sb_info *); 1586 void __init f2fs_create_root_stats(void); 1587 void f2fs_destroy_root_stats(void); 1588 #else 1589 #define stat_inc_cp_count(si) 1590 #define stat_inc_call_count(si) 1591 #define stat_inc_bggc_count(si) 1592 #define stat_inc_dirty_dir(sbi) 1593 #define stat_dec_dirty_dir(sbi) 1594 #define stat_inc_total_hit(sb) 1595 #define stat_inc_read_hit(sb) 1596 #define stat_inc_inline_inode(inode) 1597 #define stat_dec_inline_inode(inode) 1598 #define stat_inc_inline_dir(inode) 1599 #define stat_dec_inline_dir(inode) 1600 #define stat_inc_seg_type(sbi, curseg) 1601 #define stat_inc_block_count(sbi, curseg) 1602 #define stat_inc_seg_count(si, type) 1603 #define stat_inc_tot_blk_count(si, blks) 1604 #define stat_inc_data_blk_count(si, blks) 1605 #define stat_inc_node_blk_count(sbi, blks) 1606 1607 static inline int f2fs_build_stats(struct f2fs_sb_info *sbi) { return 0; } 1608 static inline void f2fs_destroy_stats(struct f2fs_sb_info *sbi) { } 1609 static inline void __init f2fs_create_root_stats(void) { } 1610 static inline void f2fs_destroy_root_stats(void) { } 1611 #endif 1612 1613 extern const struct file_operations f2fs_dir_operations; 1614 extern const struct file_operations f2fs_file_operations; 1615 extern const struct inode_operations f2fs_file_inode_operations; 1616 extern const struct address_space_operations f2fs_dblock_aops; 1617 extern const struct address_space_operations f2fs_node_aops; 1618 extern const struct address_space_operations f2fs_meta_aops; 1619 extern const struct inode_operations f2fs_dir_inode_operations; 1620 extern const struct inode_operations f2fs_symlink_inode_operations; 1621 extern const struct inode_operations f2fs_special_inode_operations; 1622 1623 /* 1624 * inline.c 1625 */ 1626 bool f2fs_may_inline(struct inode *); 1627 void read_inline_data(struct page *, struct page *); 1628 int f2fs_read_inline_data(struct inode *, struct page *); 1629 int f2fs_convert_inline_page(struct dnode_of_data *, struct page *); 1630 int f2fs_convert_inline_inode(struct inode *); 1631 int f2fs_write_inline_data(struct inode *, struct page *); 1632 void truncate_inline_data(struct page *, u64); 1633 bool recover_inline_data(struct inode *, struct page *); 1634 struct f2fs_dir_entry *find_in_inline_dir(struct inode *, struct qstr *, 1635 struct page **); 1636 struct f2fs_dir_entry *f2fs_parent_inline_dir(struct inode *, struct page **); 1637 int make_empty_inline_dir(struct inode *inode, struct inode *, struct page *); 1638 int f2fs_add_inline_entry(struct inode *, const struct qstr *, struct inode *); 1639 void f2fs_delete_inline_entry(struct f2fs_dir_entry *, struct page *, 1640 struct inode *, struct inode *); 1641 bool f2fs_empty_inline_dir(struct inode *); 1642 int f2fs_read_inline_dir(struct file *, struct dir_context *); 1643 #endif 1644