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