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 /* 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 struct f2fs_sb_info { 523 struct super_block *sb; /* pointer to VFS super block */ 524 struct proc_dir_entry *s_proc; /* proc entry */ 525 struct buffer_head *raw_super_buf; /* buffer head of raw sb */ 526 struct f2fs_super_block *raw_super; /* raw super block pointer */ 527 int s_dirty; /* dirty flag for checkpoint */ 528 bool need_fsck; /* need fsck.f2fs to fix */ 529 bool s_closing; /* specify unmounting */ 530 531 /* for node-related operations */ 532 struct f2fs_nm_info *nm_info; /* node manager */ 533 struct inode *node_inode; /* cache node blocks */ 534 535 /* for segment-related operations */ 536 struct f2fs_sm_info *sm_info; /* segment manager */ 537 538 /* for bio operations */ 539 struct f2fs_bio_info read_io; /* for read bios */ 540 struct f2fs_bio_info write_io[NR_PAGE_TYPE]; /* for write bios */ 541 542 /* for checkpoint */ 543 struct f2fs_checkpoint *ckpt; /* raw checkpoint pointer */ 544 struct inode *meta_inode; /* cache meta blocks */ 545 struct mutex cp_mutex; /* checkpoint procedure lock */ 546 struct rw_semaphore cp_rwsem; /* blocking FS operations */ 547 struct rw_semaphore node_write; /* locking node writes */ 548 struct mutex writepages; /* mutex for writepages() */ 549 bool por_doing; /* recovery is doing or not */ 550 wait_queue_head_t cp_wait; 551 552 struct inode_management im[MAX_INO_ENTRY]; /* manage inode cache */ 553 554 /* for orphan inode, use 0'th array */ 555 unsigned int max_orphans; /* max orphan inodes */ 556 557 /* for directory inode management */ 558 struct list_head dir_inode_list; /* dir inode list */ 559 spinlock_t dir_inode_lock; /* for dir inode list lock */ 560 561 /* basic filesystem units */ 562 unsigned int log_sectors_per_block; /* log2 sectors per block */ 563 unsigned int log_blocksize; /* log2 block size */ 564 unsigned int blocksize; /* block size */ 565 unsigned int root_ino_num; /* root inode number*/ 566 unsigned int node_ino_num; /* node inode number*/ 567 unsigned int meta_ino_num; /* meta inode number*/ 568 unsigned int log_blocks_per_seg; /* log2 blocks per segment */ 569 unsigned int blocks_per_seg; /* blocks per segment */ 570 unsigned int segs_per_sec; /* segments per section */ 571 unsigned int secs_per_zone; /* sections per zone */ 572 unsigned int total_sections; /* total section count */ 573 unsigned int total_node_count; /* total node block count */ 574 unsigned int total_valid_node_count; /* valid node block count */ 575 unsigned int total_valid_inode_count; /* valid inode count */ 576 int active_logs; /* # of active logs */ 577 int dir_level; /* directory level */ 578 579 block_t user_block_count; /* # of user blocks */ 580 block_t total_valid_block_count; /* # of valid blocks */ 581 block_t alloc_valid_block_count; /* # of allocated blocks */ 582 block_t last_valid_block_count; /* for recovery */ 583 u32 s_next_generation; /* for NFS support */ 584 atomic_t nr_pages[NR_COUNT_TYPE]; /* # of pages, see count_type */ 585 586 struct f2fs_mount_info mount_opt; /* mount options */ 587 588 /* for cleaning operations */ 589 struct mutex gc_mutex; /* mutex for GC */ 590 struct f2fs_gc_kthread *gc_thread; /* GC thread */ 591 unsigned int cur_victim_sec; /* current victim section num */ 592 593 /* maximum # of trials to find a victim segment for SSR and GC */ 594 unsigned int max_victim_search; 595 596 /* 597 * for stat information. 598 * one is for the LFS mode, and the other is for the SSR mode. 599 */ 600 #ifdef CONFIG_F2FS_STAT_FS 601 struct f2fs_stat_info *stat_info; /* FS status information */ 602 unsigned int segment_count[2]; /* # of allocated segments */ 603 unsigned int block_count[2]; /* # of allocated blocks */ 604 atomic_t inplace_count; /* # of inplace update */ 605 int total_hit_ext, read_hit_ext; /* extent cache hit ratio */ 606 atomic_t inline_inode; /* # of inline_data inodes */ 607 atomic_t inline_dir; /* # of inline_dentry inodes */ 608 int bg_gc; /* background gc calls */ 609 unsigned int n_dirty_dirs; /* # of dir inodes */ 610 #endif 611 unsigned int last_victim[2]; /* last victim segment # */ 612 spinlock_t stat_lock; /* lock for stat operations */ 613 614 /* For sysfs suppport */ 615 struct kobject s_kobj; 616 struct completion s_kobj_unregister; 617 }; 618 619 /* 620 * Inline functions 621 */ 622 static inline struct f2fs_inode_info *F2FS_I(struct inode *inode) 623 { 624 return container_of(inode, struct f2fs_inode_info, vfs_inode); 625 } 626 627 static inline struct f2fs_sb_info *F2FS_SB(struct super_block *sb) 628 { 629 return sb->s_fs_info; 630 } 631 632 static inline struct f2fs_sb_info *F2FS_I_SB(struct inode *inode) 633 { 634 return F2FS_SB(inode->i_sb); 635 } 636 637 static inline struct f2fs_sb_info *F2FS_M_SB(struct address_space *mapping) 638 { 639 return F2FS_I_SB(mapping->host); 640 } 641 642 static inline struct f2fs_sb_info *F2FS_P_SB(struct page *page) 643 { 644 return F2FS_M_SB(page->mapping); 645 } 646 647 static inline struct f2fs_super_block *F2FS_RAW_SUPER(struct f2fs_sb_info *sbi) 648 { 649 return (struct f2fs_super_block *)(sbi->raw_super); 650 } 651 652 static inline struct f2fs_checkpoint *F2FS_CKPT(struct f2fs_sb_info *sbi) 653 { 654 return (struct f2fs_checkpoint *)(sbi->ckpt); 655 } 656 657 static inline struct f2fs_node *F2FS_NODE(struct page *page) 658 { 659 return (struct f2fs_node *)page_address(page); 660 } 661 662 static inline struct f2fs_inode *F2FS_INODE(struct page *page) 663 { 664 return &((struct f2fs_node *)page_address(page))->i; 665 } 666 667 static inline struct f2fs_nm_info *NM_I(struct f2fs_sb_info *sbi) 668 { 669 return (struct f2fs_nm_info *)(sbi->nm_info); 670 } 671 672 static inline struct f2fs_sm_info *SM_I(struct f2fs_sb_info *sbi) 673 { 674 return (struct f2fs_sm_info *)(sbi->sm_info); 675 } 676 677 static inline struct sit_info *SIT_I(struct f2fs_sb_info *sbi) 678 { 679 return (struct sit_info *)(SM_I(sbi)->sit_info); 680 } 681 682 static inline struct free_segmap_info *FREE_I(struct f2fs_sb_info *sbi) 683 { 684 return (struct free_segmap_info *)(SM_I(sbi)->free_info); 685 } 686 687 static inline struct dirty_seglist_info *DIRTY_I(struct f2fs_sb_info *sbi) 688 { 689 return (struct dirty_seglist_info *)(SM_I(sbi)->dirty_info); 690 } 691 692 static inline struct address_space *META_MAPPING(struct f2fs_sb_info *sbi) 693 { 694 return sbi->meta_inode->i_mapping; 695 } 696 697 static inline struct address_space *NODE_MAPPING(struct f2fs_sb_info *sbi) 698 { 699 return sbi->node_inode->i_mapping; 700 } 701 702 static inline void F2FS_SET_SB_DIRT(struct f2fs_sb_info *sbi) 703 { 704 sbi->s_dirty = 1; 705 } 706 707 static inline void F2FS_RESET_SB_DIRT(struct f2fs_sb_info *sbi) 708 { 709 sbi->s_dirty = 0; 710 } 711 712 static inline unsigned long long cur_cp_version(struct f2fs_checkpoint *cp) 713 { 714 return le64_to_cpu(cp->checkpoint_ver); 715 } 716 717 static inline bool is_set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f) 718 { 719 unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags); 720 return ckpt_flags & f; 721 } 722 723 static inline void set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f) 724 { 725 unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags); 726 ckpt_flags |= f; 727 cp->ckpt_flags = cpu_to_le32(ckpt_flags); 728 } 729 730 static inline void clear_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f) 731 { 732 unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags); 733 ckpt_flags &= (~f); 734 cp->ckpt_flags = cpu_to_le32(ckpt_flags); 735 } 736 737 static inline void f2fs_lock_op(struct f2fs_sb_info *sbi) 738 { 739 down_read(&sbi->cp_rwsem); 740 } 741 742 static inline void f2fs_unlock_op(struct f2fs_sb_info *sbi) 743 { 744 up_read(&sbi->cp_rwsem); 745 } 746 747 static inline void f2fs_lock_all(struct f2fs_sb_info *sbi) 748 { 749 f2fs_down_write(&sbi->cp_rwsem, &sbi->cp_mutex); 750 } 751 752 static inline void f2fs_unlock_all(struct f2fs_sb_info *sbi) 753 { 754 up_write(&sbi->cp_rwsem); 755 } 756 757 /* 758 * Check whether the given nid is within node id range. 759 */ 760 static inline int check_nid_range(struct f2fs_sb_info *sbi, nid_t nid) 761 { 762 if (unlikely(nid < F2FS_ROOT_INO(sbi))) 763 return -EINVAL; 764 if (unlikely(nid >= NM_I(sbi)->max_nid)) 765 return -EINVAL; 766 return 0; 767 } 768 769 #define F2FS_DEFAULT_ALLOCATED_BLOCKS 1 770 771 /* 772 * Check whether the inode has blocks or not 773 */ 774 static inline int F2FS_HAS_BLOCKS(struct inode *inode) 775 { 776 if (F2FS_I(inode)->i_xattr_nid) 777 return inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS + 1; 778 else 779 return inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS; 780 } 781 782 static inline bool f2fs_has_xattr_block(unsigned int ofs) 783 { 784 return ofs == XATTR_NODE_OFFSET; 785 } 786 787 static inline bool inc_valid_block_count(struct f2fs_sb_info *sbi, 788 struct inode *inode, blkcnt_t count) 789 { 790 block_t valid_block_count; 791 792 spin_lock(&sbi->stat_lock); 793 valid_block_count = 794 sbi->total_valid_block_count + (block_t)count; 795 if (unlikely(valid_block_count > sbi->user_block_count)) { 796 spin_unlock(&sbi->stat_lock); 797 return false; 798 } 799 inode->i_blocks += count; 800 sbi->total_valid_block_count = valid_block_count; 801 sbi->alloc_valid_block_count += (block_t)count; 802 spin_unlock(&sbi->stat_lock); 803 return true; 804 } 805 806 static inline void dec_valid_block_count(struct f2fs_sb_info *sbi, 807 struct inode *inode, 808 blkcnt_t count) 809 { 810 spin_lock(&sbi->stat_lock); 811 f2fs_bug_on(sbi, sbi->total_valid_block_count < (block_t) count); 812 f2fs_bug_on(sbi, inode->i_blocks < count); 813 inode->i_blocks -= count; 814 sbi->total_valid_block_count -= (block_t)count; 815 spin_unlock(&sbi->stat_lock); 816 } 817 818 static inline void inc_page_count(struct f2fs_sb_info *sbi, int count_type) 819 { 820 atomic_inc(&sbi->nr_pages[count_type]); 821 F2FS_SET_SB_DIRT(sbi); 822 } 823 824 static inline void inode_inc_dirty_pages(struct inode *inode) 825 { 826 atomic_inc(&F2FS_I(inode)->dirty_pages); 827 if (S_ISDIR(inode->i_mode)) 828 inc_page_count(F2FS_I_SB(inode), F2FS_DIRTY_DENTS); 829 } 830 831 static inline void dec_page_count(struct f2fs_sb_info *sbi, int count_type) 832 { 833 atomic_dec(&sbi->nr_pages[count_type]); 834 } 835 836 static inline void inode_dec_dirty_pages(struct inode *inode) 837 { 838 if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode)) 839 return; 840 841 atomic_dec(&F2FS_I(inode)->dirty_pages); 842 843 if (S_ISDIR(inode->i_mode)) 844 dec_page_count(F2FS_I_SB(inode), F2FS_DIRTY_DENTS); 845 } 846 847 static inline int get_pages(struct f2fs_sb_info *sbi, int count_type) 848 { 849 return atomic_read(&sbi->nr_pages[count_type]); 850 } 851 852 static inline int get_dirty_pages(struct inode *inode) 853 { 854 return atomic_read(&F2FS_I(inode)->dirty_pages); 855 } 856 857 static inline int get_blocktype_secs(struct f2fs_sb_info *sbi, int block_type) 858 { 859 unsigned int pages_per_sec = sbi->segs_per_sec * 860 (1 << sbi->log_blocks_per_seg); 861 return ((get_pages(sbi, block_type) + pages_per_sec - 1) 862 >> sbi->log_blocks_per_seg) / sbi->segs_per_sec; 863 } 864 865 static inline block_t valid_user_blocks(struct f2fs_sb_info *sbi) 866 { 867 return sbi->total_valid_block_count; 868 } 869 870 static inline unsigned long __bitmap_size(struct f2fs_sb_info *sbi, int flag) 871 { 872 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi); 873 874 /* return NAT or SIT bitmap */ 875 if (flag == NAT_BITMAP) 876 return le32_to_cpu(ckpt->nat_ver_bitmap_bytesize); 877 else if (flag == SIT_BITMAP) 878 return le32_to_cpu(ckpt->sit_ver_bitmap_bytesize); 879 880 return 0; 881 } 882 883 static inline void *__bitmap_ptr(struct f2fs_sb_info *sbi, int flag) 884 { 885 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi); 886 int offset; 887 888 if (le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload) > 0) { 889 if (flag == NAT_BITMAP) 890 return &ckpt->sit_nat_version_bitmap; 891 else 892 return (unsigned char *)ckpt + F2FS_BLKSIZE; 893 } else { 894 offset = (flag == NAT_BITMAP) ? 895 le32_to_cpu(ckpt->sit_ver_bitmap_bytesize) : 0; 896 return &ckpt->sit_nat_version_bitmap + offset; 897 } 898 } 899 900 static inline block_t __start_cp_addr(struct f2fs_sb_info *sbi) 901 { 902 block_t start_addr; 903 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi); 904 unsigned long long ckpt_version = cur_cp_version(ckpt); 905 906 start_addr = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_blkaddr); 907 908 /* 909 * odd numbered checkpoint should at cp segment 0 910 * and even segment must be at cp segment 1 911 */ 912 if (!(ckpt_version & 1)) 913 start_addr += sbi->blocks_per_seg; 914 915 return start_addr; 916 } 917 918 static inline block_t __start_sum_addr(struct f2fs_sb_info *sbi) 919 { 920 return le32_to_cpu(F2FS_CKPT(sbi)->cp_pack_start_sum); 921 } 922 923 static inline bool inc_valid_node_count(struct f2fs_sb_info *sbi, 924 struct inode *inode) 925 { 926 block_t valid_block_count; 927 unsigned int valid_node_count; 928 929 spin_lock(&sbi->stat_lock); 930 931 valid_block_count = sbi->total_valid_block_count + 1; 932 if (unlikely(valid_block_count > sbi->user_block_count)) { 933 spin_unlock(&sbi->stat_lock); 934 return false; 935 } 936 937 valid_node_count = sbi->total_valid_node_count + 1; 938 if (unlikely(valid_node_count > sbi->total_node_count)) { 939 spin_unlock(&sbi->stat_lock); 940 return false; 941 } 942 943 if (inode) 944 inode->i_blocks++; 945 946 sbi->alloc_valid_block_count++; 947 sbi->total_valid_node_count++; 948 sbi->total_valid_block_count++; 949 spin_unlock(&sbi->stat_lock); 950 951 return true; 952 } 953 954 static inline void dec_valid_node_count(struct f2fs_sb_info *sbi, 955 struct inode *inode) 956 { 957 spin_lock(&sbi->stat_lock); 958 959 f2fs_bug_on(sbi, !sbi->total_valid_block_count); 960 f2fs_bug_on(sbi, !sbi->total_valid_node_count); 961 f2fs_bug_on(sbi, !inode->i_blocks); 962 963 inode->i_blocks--; 964 sbi->total_valid_node_count--; 965 sbi->total_valid_block_count--; 966 967 spin_unlock(&sbi->stat_lock); 968 } 969 970 static inline unsigned int valid_node_count(struct f2fs_sb_info *sbi) 971 { 972 return sbi->total_valid_node_count; 973 } 974 975 static inline void inc_valid_inode_count(struct f2fs_sb_info *sbi) 976 { 977 spin_lock(&sbi->stat_lock); 978 f2fs_bug_on(sbi, sbi->total_valid_inode_count == sbi->total_node_count); 979 sbi->total_valid_inode_count++; 980 spin_unlock(&sbi->stat_lock); 981 } 982 983 static inline void dec_valid_inode_count(struct f2fs_sb_info *sbi) 984 { 985 spin_lock(&sbi->stat_lock); 986 f2fs_bug_on(sbi, !sbi->total_valid_inode_count); 987 sbi->total_valid_inode_count--; 988 spin_unlock(&sbi->stat_lock); 989 } 990 991 static inline unsigned int valid_inode_count(struct f2fs_sb_info *sbi) 992 { 993 return sbi->total_valid_inode_count; 994 } 995 996 static inline void f2fs_put_page(struct page *page, int unlock) 997 { 998 if (!page) 999 return; 1000 1001 if (unlock) { 1002 f2fs_bug_on(F2FS_P_SB(page), !PageLocked(page)); 1003 unlock_page(page); 1004 } 1005 page_cache_release(page); 1006 } 1007 1008 static inline void f2fs_put_dnode(struct dnode_of_data *dn) 1009 { 1010 if (dn->node_page) 1011 f2fs_put_page(dn->node_page, 1); 1012 if (dn->inode_page && dn->node_page != dn->inode_page) 1013 f2fs_put_page(dn->inode_page, 0); 1014 dn->node_page = NULL; 1015 dn->inode_page = NULL; 1016 } 1017 1018 static inline struct kmem_cache *f2fs_kmem_cache_create(const char *name, 1019 size_t size) 1020 { 1021 return kmem_cache_create(name, size, 0, SLAB_RECLAIM_ACCOUNT, NULL); 1022 } 1023 1024 static inline void *f2fs_kmem_cache_alloc(struct kmem_cache *cachep, 1025 gfp_t flags) 1026 { 1027 void *entry; 1028 retry: 1029 entry = kmem_cache_alloc(cachep, flags); 1030 if (!entry) { 1031 cond_resched(); 1032 goto retry; 1033 } 1034 1035 return entry; 1036 } 1037 1038 static inline void f2fs_radix_tree_insert(struct radix_tree_root *root, 1039 unsigned long index, void *item) 1040 { 1041 while (radix_tree_insert(root, index, item)) 1042 cond_resched(); 1043 } 1044 1045 #define RAW_IS_INODE(p) ((p)->footer.nid == (p)->footer.ino) 1046 1047 static inline bool IS_INODE(struct page *page) 1048 { 1049 struct f2fs_node *p = F2FS_NODE(page); 1050 return RAW_IS_INODE(p); 1051 } 1052 1053 static inline __le32 *blkaddr_in_node(struct f2fs_node *node) 1054 { 1055 return RAW_IS_INODE(node) ? node->i.i_addr : node->dn.addr; 1056 } 1057 1058 static inline block_t datablock_addr(struct page *node_page, 1059 unsigned int offset) 1060 { 1061 struct f2fs_node *raw_node; 1062 __le32 *addr_array; 1063 raw_node = F2FS_NODE(node_page); 1064 addr_array = blkaddr_in_node(raw_node); 1065 return le32_to_cpu(addr_array[offset]); 1066 } 1067 1068 static inline int f2fs_test_bit(unsigned int nr, char *addr) 1069 { 1070 int mask; 1071 1072 addr += (nr >> 3); 1073 mask = 1 << (7 - (nr & 0x07)); 1074 return mask & *addr; 1075 } 1076 1077 static inline int f2fs_test_and_set_bit(unsigned int nr, char *addr) 1078 { 1079 int mask; 1080 int ret; 1081 1082 addr += (nr >> 3); 1083 mask = 1 << (7 - (nr & 0x07)); 1084 ret = mask & *addr; 1085 *addr |= mask; 1086 return ret; 1087 } 1088 1089 static inline int f2fs_test_and_clear_bit(unsigned int nr, char *addr) 1090 { 1091 int mask; 1092 int ret; 1093 1094 addr += (nr >> 3); 1095 mask = 1 << (7 - (nr & 0x07)); 1096 ret = mask & *addr; 1097 *addr &= ~mask; 1098 return ret; 1099 } 1100 1101 static inline void f2fs_change_bit(unsigned int nr, char *addr) 1102 { 1103 int mask; 1104 1105 addr += (nr >> 3); 1106 mask = 1 << (7 - (nr & 0x07)); 1107 *addr ^= mask; 1108 } 1109 1110 /* used for f2fs_inode_info->flags */ 1111 enum { 1112 FI_NEW_INODE, /* indicate newly allocated inode */ 1113 FI_DIRTY_INODE, /* indicate inode is dirty or not */ 1114 FI_DIRTY_DIR, /* indicate directory has dirty pages */ 1115 FI_INC_LINK, /* need to increment i_nlink */ 1116 FI_ACL_MODE, /* indicate acl mode */ 1117 FI_NO_ALLOC, /* should not allocate any blocks */ 1118 FI_UPDATE_DIR, /* should update inode block for consistency */ 1119 FI_DELAY_IPUT, /* used for the recovery */ 1120 FI_NO_EXTENT, /* not to use the extent cache */ 1121 FI_INLINE_XATTR, /* used for inline xattr */ 1122 FI_INLINE_DATA, /* used for inline data*/ 1123 FI_INLINE_DENTRY, /* used for inline dentry */ 1124 FI_APPEND_WRITE, /* inode has appended data */ 1125 FI_UPDATE_WRITE, /* inode has in-place-update data */ 1126 FI_NEED_IPU, /* used for ipu per file */ 1127 FI_ATOMIC_FILE, /* indicate atomic file */ 1128 FI_VOLATILE_FILE, /* indicate volatile file */ 1129 FI_DROP_CACHE, /* drop dirty page cache */ 1130 FI_DATA_EXIST, /* indicate data exists */ 1131 }; 1132 1133 static inline void set_inode_flag(struct f2fs_inode_info *fi, int flag) 1134 { 1135 if (!test_bit(flag, &fi->flags)) 1136 set_bit(flag, &fi->flags); 1137 } 1138 1139 static inline int is_inode_flag_set(struct f2fs_inode_info *fi, int flag) 1140 { 1141 return test_bit(flag, &fi->flags); 1142 } 1143 1144 static inline void clear_inode_flag(struct f2fs_inode_info *fi, int flag) 1145 { 1146 if (test_bit(flag, &fi->flags)) 1147 clear_bit(flag, &fi->flags); 1148 } 1149 1150 static inline void set_acl_inode(struct f2fs_inode_info *fi, umode_t mode) 1151 { 1152 fi->i_acl_mode = mode; 1153 set_inode_flag(fi, FI_ACL_MODE); 1154 } 1155 1156 static inline void get_inline_info(struct f2fs_inode_info *fi, 1157 struct f2fs_inode *ri) 1158 { 1159 if (ri->i_inline & F2FS_INLINE_XATTR) 1160 set_inode_flag(fi, FI_INLINE_XATTR); 1161 if (ri->i_inline & F2FS_INLINE_DATA) 1162 set_inode_flag(fi, FI_INLINE_DATA); 1163 if (ri->i_inline & F2FS_INLINE_DENTRY) 1164 set_inode_flag(fi, FI_INLINE_DENTRY); 1165 if (ri->i_inline & F2FS_DATA_EXIST) 1166 set_inode_flag(fi, FI_DATA_EXIST); 1167 } 1168 1169 static inline void set_raw_inline(struct f2fs_inode_info *fi, 1170 struct f2fs_inode *ri) 1171 { 1172 ri->i_inline = 0; 1173 1174 if (is_inode_flag_set(fi, FI_INLINE_XATTR)) 1175 ri->i_inline |= F2FS_INLINE_XATTR; 1176 if (is_inode_flag_set(fi, FI_INLINE_DATA)) 1177 ri->i_inline |= F2FS_INLINE_DATA; 1178 if (is_inode_flag_set(fi, FI_INLINE_DENTRY)) 1179 ri->i_inline |= F2FS_INLINE_DENTRY; 1180 if (is_inode_flag_set(fi, FI_DATA_EXIST)) 1181 ri->i_inline |= F2FS_DATA_EXIST; 1182 } 1183 1184 static inline int f2fs_has_inline_xattr(struct inode *inode) 1185 { 1186 return is_inode_flag_set(F2FS_I(inode), FI_INLINE_XATTR); 1187 } 1188 1189 static inline unsigned int addrs_per_inode(struct f2fs_inode_info *fi) 1190 { 1191 if (f2fs_has_inline_xattr(&fi->vfs_inode)) 1192 return DEF_ADDRS_PER_INODE - F2FS_INLINE_XATTR_ADDRS; 1193 return DEF_ADDRS_PER_INODE; 1194 } 1195 1196 static inline void *inline_xattr_addr(struct page *page) 1197 { 1198 struct f2fs_inode *ri = F2FS_INODE(page); 1199 return (void *)&(ri->i_addr[DEF_ADDRS_PER_INODE - 1200 F2FS_INLINE_XATTR_ADDRS]); 1201 } 1202 1203 static inline int inline_xattr_size(struct inode *inode) 1204 { 1205 if (f2fs_has_inline_xattr(inode)) 1206 return F2FS_INLINE_XATTR_ADDRS << 2; 1207 else 1208 return 0; 1209 } 1210 1211 static inline int f2fs_has_inline_data(struct inode *inode) 1212 { 1213 return is_inode_flag_set(F2FS_I(inode), FI_INLINE_DATA); 1214 } 1215 1216 static inline void f2fs_clear_inline_inode(struct inode *inode) 1217 { 1218 clear_inode_flag(F2FS_I(inode), FI_INLINE_DATA); 1219 clear_inode_flag(F2FS_I(inode), FI_DATA_EXIST); 1220 } 1221 1222 static inline int f2fs_exist_data(struct inode *inode) 1223 { 1224 return is_inode_flag_set(F2FS_I(inode), FI_DATA_EXIST); 1225 } 1226 1227 static inline bool f2fs_is_atomic_file(struct inode *inode) 1228 { 1229 return is_inode_flag_set(F2FS_I(inode), FI_ATOMIC_FILE); 1230 } 1231 1232 static inline bool f2fs_is_volatile_file(struct inode *inode) 1233 { 1234 return is_inode_flag_set(F2FS_I(inode), FI_VOLATILE_FILE); 1235 } 1236 1237 static inline bool f2fs_is_drop_cache(struct inode *inode) 1238 { 1239 return is_inode_flag_set(F2FS_I(inode), FI_DROP_CACHE); 1240 } 1241 1242 static inline void *inline_data_addr(struct page *page) 1243 { 1244 struct f2fs_inode *ri = F2FS_INODE(page); 1245 return (void *)&(ri->i_addr[1]); 1246 } 1247 1248 static inline int f2fs_has_inline_dentry(struct inode *inode) 1249 { 1250 return is_inode_flag_set(F2FS_I(inode), FI_INLINE_DENTRY); 1251 } 1252 1253 static inline void *inline_dentry_addr(struct page *page) 1254 { 1255 struct f2fs_inode *ri = F2FS_INODE(page); 1256 return (void *)&(ri->i_addr[1]); 1257 } 1258 1259 static inline void f2fs_dentry_kunmap(struct inode *dir, struct page *page) 1260 { 1261 if (!f2fs_has_inline_dentry(dir)) 1262 kunmap(page); 1263 } 1264 1265 static inline int f2fs_readonly(struct super_block *sb) 1266 { 1267 return sb->s_flags & MS_RDONLY; 1268 } 1269 1270 static inline bool f2fs_cp_error(struct f2fs_sb_info *sbi) 1271 { 1272 return is_set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG); 1273 } 1274 1275 static inline void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi) 1276 { 1277 set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG); 1278 sbi->sb->s_flags |= MS_RDONLY; 1279 } 1280 1281 #define get_inode_mode(i) \ 1282 ((is_inode_flag_set(F2FS_I(i), FI_ACL_MODE)) ? \ 1283 (F2FS_I(i)->i_acl_mode) : ((i)->i_mode)) 1284 1285 /* get offset of first page in next direct node */ 1286 #define PGOFS_OF_NEXT_DNODE(pgofs, fi) \ 1287 ((pgofs < ADDRS_PER_INODE(fi)) ? ADDRS_PER_INODE(fi) : \ 1288 (pgofs - ADDRS_PER_INODE(fi) + ADDRS_PER_BLOCK) / \ 1289 ADDRS_PER_BLOCK * ADDRS_PER_BLOCK + ADDRS_PER_INODE(fi)) 1290 1291 /* 1292 * file.c 1293 */ 1294 int f2fs_sync_file(struct file *, loff_t, loff_t, int); 1295 void truncate_data_blocks(struct dnode_of_data *); 1296 int truncate_blocks(struct inode *, u64, bool); 1297 void f2fs_truncate(struct inode *); 1298 int f2fs_getattr(struct vfsmount *, struct dentry *, struct kstat *); 1299 int f2fs_setattr(struct dentry *, struct iattr *); 1300 int truncate_hole(struct inode *, pgoff_t, pgoff_t); 1301 int truncate_data_blocks_range(struct dnode_of_data *, int); 1302 long f2fs_ioctl(struct file *, unsigned int, unsigned long); 1303 long f2fs_compat_ioctl(struct file *, unsigned int, unsigned long); 1304 1305 /* 1306 * inode.c 1307 */ 1308 void f2fs_set_inode_flags(struct inode *); 1309 struct inode *f2fs_iget(struct super_block *, unsigned long); 1310 int try_to_free_nats(struct f2fs_sb_info *, int); 1311 void update_inode(struct inode *, struct page *); 1312 void update_inode_page(struct inode *); 1313 int f2fs_write_inode(struct inode *, struct writeback_control *); 1314 void f2fs_evict_inode(struct inode *); 1315 void handle_failed_inode(struct inode *); 1316 1317 /* 1318 * namei.c 1319 */ 1320 struct dentry *f2fs_get_parent(struct dentry *child); 1321 1322 /* 1323 * dir.c 1324 */ 1325 extern unsigned char f2fs_filetype_table[F2FS_FT_MAX]; 1326 void set_de_type(struct f2fs_dir_entry *, struct inode *); 1327 struct f2fs_dir_entry *find_target_dentry(struct qstr *, int *, 1328 struct f2fs_dentry_ptr *); 1329 bool f2fs_fill_dentries(struct dir_context *, struct f2fs_dentry_ptr *, 1330 unsigned int); 1331 void do_make_empty_dir(struct inode *, struct inode *, 1332 struct f2fs_dentry_ptr *); 1333 struct page *init_inode_metadata(struct inode *, struct inode *, 1334 const struct qstr *, struct page *); 1335 void update_parent_metadata(struct inode *, struct inode *, unsigned int); 1336 int room_for_filename(const void *, int, int); 1337 void f2fs_drop_nlink(struct inode *, struct inode *, struct page *); 1338 struct f2fs_dir_entry *f2fs_find_entry(struct inode *, struct qstr *, 1339 struct page **); 1340 struct f2fs_dir_entry *f2fs_parent_dir(struct inode *, struct page **); 1341 ino_t f2fs_inode_by_name(struct inode *, struct qstr *); 1342 void f2fs_set_link(struct inode *, struct f2fs_dir_entry *, 1343 struct page *, struct inode *); 1344 int update_dent_inode(struct inode *, const struct qstr *); 1345 int __f2fs_add_link(struct inode *, const struct qstr *, struct inode *); 1346 void f2fs_delete_entry(struct f2fs_dir_entry *, struct page *, struct inode *, 1347 struct inode *); 1348 int f2fs_do_tmpfile(struct inode *, struct inode *); 1349 int f2fs_make_empty(struct inode *, struct inode *); 1350 bool f2fs_empty_dir(struct inode *); 1351 1352 static inline int f2fs_add_link(struct dentry *dentry, struct inode *inode) 1353 { 1354 return __f2fs_add_link(dentry->d_parent->d_inode, &dentry->d_name, 1355 inode); 1356 } 1357 1358 /* 1359 * super.c 1360 */ 1361 int f2fs_sync_fs(struct super_block *, int); 1362 extern __printf(3, 4) 1363 void f2fs_msg(struct super_block *, const char *, const char *, ...); 1364 1365 /* 1366 * hash.c 1367 */ 1368 f2fs_hash_t f2fs_dentry_hash(const struct qstr *); 1369 1370 /* 1371 * node.c 1372 */ 1373 struct dnode_of_data; 1374 struct node_info; 1375 1376 bool available_free_memory(struct f2fs_sb_info *, int); 1377 bool is_checkpointed_node(struct f2fs_sb_info *, nid_t); 1378 bool has_fsynced_inode(struct f2fs_sb_info *, nid_t); 1379 bool need_inode_block_update(struct f2fs_sb_info *, nid_t); 1380 void get_node_info(struct f2fs_sb_info *, nid_t, struct node_info *); 1381 int get_dnode_of_data(struct dnode_of_data *, pgoff_t, int); 1382 int truncate_inode_blocks(struct inode *, pgoff_t); 1383 int truncate_xattr_node(struct inode *, struct page *); 1384 int wait_on_node_pages_writeback(struct f2fs_sb_info *, nid_t); 1385 void remove_inode_page(struct inode *); 1386 struct page *new_inode_page(struct inode *); 1387 struct page *new_node_page(struct dnode_of_data *, unsigned int, struct page *); 1388 void ra_node_page(struct f2fs_sb_info *, nid_t); 1389 struct page *get_node_page(struct f2fs_sb_info *, pgoff_t); 1390 struct page *get_node_page_ra(struct page *, int); 1391 void sync_inode_page(struct dnode_of_data *); 1392 int sync_node_pages(struct f2fs_sb_info *, nid_t, struct writeback_control *); 1393 bool alloc_nid(struct f2fs_sb_info *, nid_t *); 1394 void alloc_nid_done(struct f2fs_sb_info *, nid_t); 1395 void alloc_nid_failed(struct f2fs_sb_info *, nid_t); 1396 void recover_inline_xattr(struct inode *, struct page *); 1397 void recover_xattr_data(struct inode *, struct page *, block_t); 1398 int recover_inode_page(struct f2fs_sb_info *, struct page *); 1399 int restore_node_summary(struct f2fs_sb_info *, unsigned int, 1400 struct f2fs_summary_block *); 1401 void flush_nat_entries(struct f2fs_sb_info *); 1402 int build_node_manager(struct f2fs_sb_info *); 1403 void destroy_node_manager(struct f2fs_sb_info *); 1404 int __init create_node_manager_caches(void); 1405 void destroy_node_manager_caches(void); 1406 1407 /* 1408 * segment.c 1409 */ 1410 void register_inmem_page(struct inode *, struct page *); 1411 void commit_inmem_pages(struct inode *, bool); 1412 void f2fs_balance_fs(struct f2fs_sb_info *); 1413 void f2fs_balance_fs_bg(struct f2fs_sb_info *); 1414 int f2fs_issue_flush(struct f2fs_sb_info *); 1415 int create_flush_cmd_control(struct f2fs_sb_info *); 1416 void destroy_flush_cmd_control(struct f2fs_sb_info *); 1417 void invalidate_blocks(struct f2fs_sb_info *, block_t); 1418 void refresh_sit_entry(struct f2fs_sb_info *, block_t, block_t); 1419 void clear_prefree_segments(struct f2fs_sb_info *); 1420 void release_discard_addrs(struct f2fs_sb_info *); 1421 void discard_next_dnode(struct f2fs_sb_info *, block_t); 1422 int npages_for_summary_flush(struct f2fs_sb_info *, bool); 1423 void allocate_new_segments(struct f2fs_sb_info *); 1424 int f2fs_trim_fs(struct f2fs_sb_info *, struct fstrim_range *); 1425 struct page *get_sum_page(struct f2fs_sb_info *, unsigned int); 1426 void write_meta_page(struct f2fs_sb_info *, struct page *); 1427 void write_node_page(struct f2fs_sb_info *, struct page *, 1428 unsigned int, struct f2fs_io_info *); 1429 void write_data_page(struct page *, struct dnode_of_data *, 1430 struct f2fs_io_info *); 1431 void rewrite_data_page(struct page *, struct f2fs_io_info *); 1432 void recover_data_page(struct f2fs_sb_info *, struct page *, 1433 struct f2fs_summary *, block_t, block_t); 1434 void allocate_data_block(struct f2fs_sb_info *, struct page *, 1435 block_t, block_t *, struct f2fs_summary *, int); 1436 void f2fs_wait_on_page_writeback(struct page *, enum page_type); 1437 void write_data_summaries(struct f2fs_sb_info *, block_t); 1438 void write_node_summaries(struct f2fs_sb_info *, block_t); 1439 int lookup_journal_in_cursum(struct f2fs_summary_block *, 1440 int, unsigned int, int); 1441 void flush_sit_entries(struct f2fs_sb_info *, struct cp_control *); 1442 int build_segment_manager(struct f2fs_sb_info *); 1443 void destroy_segment_manager(struct f2fs_sb_info *); 1444 int __init create_segment_manager_caches(void); 1445 void destroy_segment_manager_caches(void); 1446 1447 /* 1448 * checkpoint.c 1449 */ 1450 struct page *grab_meta_page(struct f2fs_sb_info *, pgoff_t); 1451 struct page *get_meta_page(struct f2fs_sb_info *, pgoff_t); 1452 int ra_meta_pages(struct f2fs_sb_info *, block_t, int, int); 1453 void ra_meta_pages_cond(struct f2fs_sb_info *, pgoff_t); 1454 long sync_meta_pages(struct f2fs_sb_info *, enum page_type, long); 1455 void add_dirty_inode(struct f2fs_sb_info *, nid_t, int type); 1456 void remove_dirty_inode(struct f2fs_sb_info *, nid_t, int type); 1457 void release_dirty_inode(struct f2fs_sb_info *); 1458 bool exist_written_data(struct f2fs_sb_info *, nid_t, int); 1459 int acquire_orphan_inode(struct f2fs_sb_info *); 1460 void release_orphan_inode(struct f2fs_sb_info *); 1461 void add_orphan_inode(struct f2fs_sb_info *, nid_t); 1462 void remove_orphan_inode(struct f2fs_sb_info *, nid_t); 1463 void recover_orphan_inodes(struct f2fs_sb_info *); 1464 int get_valid_checkpoint(struct f2fs_sb_info *); 1465 void update_dirty_page(struct inode *, struct page *); 1466 void add_dirty_dir_inode(struct inode *); 1467 void remove_dirty_dir_inode(struct inode *); 1468 void sync_dirty_dir_inodes(struct f2fs_sb_info *); 1469 void write_checkpoint(struct f2fs_sb_info *, struct cp_control *); 1470 void init_ino_entry_info(struct f2fs_sb_info *); 1471 int __init create_checkpoint_caches(void); 1472 void destroy_checkpoint_caches(void); 1473 1474 /* 1475 * data.c 1476 */ 1477 void f2fs_submit_merged_bio(struct f2fs_sb_info *, enum page_type, int); 1478 int f2fs_submit_page_bio(struct f2fs_sb_info *, struct page *, 1479 struct f2fs_io_info *); 1480 void f2fs_submit_page_mbio(struct f2fs_sb_info *, struct page *, 1481 struct f2fs_io_info *); 1482 int reserve_new_block(struct dnode_of_data *); 1483 int f2fs_reserve_block(struct dnode_of_data *, pgoff_t); 1484 void update_extent_cache(struct dnode_of_data *); 1485 struct page *find_data_page(struct inode *, pgoff_t, bool); 1486 struct page *get_lock_data_page(struct inode *, pgoff_t); 1487 struct page *get_new_data_page(struct inode *, struct page *, pgoff_t, bool); 1488 int do_write_data_page(struct page *, struct f2fs_io_info *); 1489 int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *, u64, u64); 1490 1491 /* 1492 * gc.c 1493 */ 1494 int start_gc_thread(struct f2fs_sb_info *); 1495 void stop_gc_thread(struct f2fs_sb_info *); 1496 block_t start_bidx_of_node(unsigned int, struct f2fs_inode_info *); 1497 int f2fs_gc(struct f2fs_sb_info *); 1498 void build_gc_manager(struct f2fs_sb_info *); 1499 1500 /* 1501 * recovery.c 1502 */ 1503 int recover_fsync_data(struct f2fs_sb_info *); 1504 bool space_for_roll_forward(struct f2fs_sb_info *); 1505 1506 /* 1507 * debug.c 1508 */ 1509 #ifdef CONFIG_F2FS_STAT_FS 1510 struct f2fs_stat_info { 1511 struct list_head stat_list; 1512 struct f2fs_sb_info *sbi; 1513 int all_area_segs, sit_area_segs, nat_area_segs, ssa_area_segs; 1514 int main_area_segs, main_area_sections, main_area_zones; 1515 int hit_ext, total_ext; 1516 int ndirty_node, ndirty_dent, ndirty_dirs, ndirty_meta; 1517 int nats, dirty_nats, sits, dirty_sits, fnids; 1518 int total_count, utilization; 1519 int bg_gc, inline_inode, inline_dir, inmem_pages; 1520 unsigned int valid_count, valid_node_count, valid_inode_count; 1521 unsigned int bimodal, avg_vblocks; 1522 int util_free, util_valid, util_invalid; 1523 int rsvd_segs, overp_segs; 1524 int dirty_count, node_pages, meta_pages; 1525 int prefree_count, call_count, cp_count; 1526 int tot_segs, node_segs, data_segs, free_segs, free_secs; 1527 int tot_blks, data_blks, node_blks; 1528 int curseg[NR_CURSEG_TYPE]; 1529 int cursec[NR_CURSEG_TYPE]; 1530 int curzone[NR_CURSEG_TYPE]; 1531 1532 unsigned int segment_count[2]; 1533 unsigned int block_count[2]; 1534 unsigned int inplace_count; 1535 unsigned base_mem, cache_mem, page_mem; 1536 }; 1537 1538 static inline struct f2fs_stat_info *F2FS_STAT(struct f2fs_sb_info *sbi) 1539 { 1540 return (struct f2fs_stat_info *)sbi->stat_info; 1541 } 1542 1543 #define stat_inc_cp_count(si) ((si)->cp_count++) 1544 #define stat_inc_call_count(si) ((si)->call_count++) 1545 #define stat_inc_bggc_count(sbi) ((sbi)->bg_gc++) 1546 #define stat_inc_dirty_dir(sbi) ((sbi)->n_dirty_dirs++) 1547 #define stat_dec_dirty_dir(sbi) ((sbi)->n_dirty_dirs--) 1548 #define stat_inc_total_hit(sb) ((F2FS_SB(sb))->total_hit_ext++) 1549 #define stat_inc_read_hit(sb) ((F2FS_SB(sb))->read_hit_ext++) 1550 #define stat_inc_inline_inode(inode) \ 1551 do { \ 1552 if (f2fs_has_inline_data(inode)) \ 1553 (atomic_inc(&F2FS_I_SB(inode)->inline_inode)); \ 1554 } while (0) 1555 #define stat_dec_inline_inode(inode) \ 1556 do { \ 1557 if (f2fs_has_inline_data(inode)) \ 1558 (atomic_dec(&F2FS_I_SB(inode)->inline_inode)); \ 1559 } while (0) 1560 #define stat_inc_inline_dir(inode) \ 1561 do { \ 1562 if (f2fs_has_inline_dentry(inode)) \ 1563 (atomic_inc(&F2FS_I_SB(inode)->inline_dir)); \ 1564 } while (0) 1565 #define stat_dec_inline_dir(inode) \ 1566 do { \ 1567 if (f2fs_has_inline_dentry(inode)) \ 1568 (atomic_dec(&F2FS_I_SB(inode)->inline_dir)); \ 1569 } while (0) 1570 #define stat_inc_seg_type(sbi, curseg) \ 1571 ((sbi)->segment_count[(curseg)->alloc_type]++) 1572 #define stat_inc_block_count(sbi, curseg) \ 1573 ((sbi)->block_count[(curseg)->alloc_type]++) 1574 #define stat_inc_inplace_blocks(sbi) \ 1575 (atomic_inc(&(sbi)->inplace_count)) 1576 #define stat_inc_seg_count(sbi, type) \ 1577 do { \ 1578 struct f2fs_stat_info *si = F2FS_STAT(sbi); \ 1579 (si)->tot_segs++; \ 1580 if (type == SUM_TYPE_DATA) \ 1581 si->data_segs++; \ 1582 else \ 1583 si->node_segs++; \ 1584 } while (0) 1585 1586 #define stat_inc_tot_blk_count(si, blks) \ 1587 (si->tot_blks += (blks)) 1588 1589 #define stat_inc_data_blk_count(sbi, blks) \ 1590 do { \ 1591 struct f2fs_stat_info *si = F2FS_STAT(sbi); \ 1592 stat_inc_tot_blk_count(si, blks); \ 1593 si->data_blks += (blks); \ 1594 } while (0) 1595 1596 #define stat_inc_node_blk_count(sbi, blks) \ 1597 do { \ 1598 struct f2fs_stat_info *si = F2FS_STAT(sbi); \ 1599 stat_inc_tot_blk_count(si, blks); \ 1600 si->node_blks += (blks); \ 1601 } while (0) 1602 1603 int f2fs_build_stats(struct f2fs_sb_info *); 1604 void f2fs_destroy_stats(struct f2fs_sb_info *); 1605 void __init f2fs_create_root_stats(void); 1606 void f2fs_destroy_root_stats(void); 1607 #else 1608 #define stat_inc_cp_count(si) 1609 #define stat_inc_call_count(si) 1610 #define stat_inc_bggc_count(si) 1611 #define stat_inc_dirty_dir(sbi) 1612 #define stat_dec_dirty_dir(sbi) 1613 #define stat_inc_total_hit(sb) 1614 #define stat_inc_read_hit(sb) 1615 #define stat_inc_inline_inode(inode) 1616 #define stat_dec_inline_inode(inode) 1617 #define stat_inc_inline_dir(inode) 1618 #define stat_dec_inline_dir(inode) 1619 #define stat_inc_seg_type(sbi, curseg) 1620 #define stat_inc_block_count(sbi, curseg) 1621 #define stat_inc_inplace_blocks(sbi) 1622 #define stat_inc_seg_count(si, type) 1623 #define stat_inc_tot_blk_count(si, blks) 1624 #define stat_inc_data_blk_count(si, blks) 1625 #define stat_inc_node_blk_count(sbi, blks) 1626 1627 static inline int f2fs_build_stats(struct f2fs_sb_info *sbi) { return 0; } 1628 static inline void f2fs_destroy_stats(struct f2fs_sb_info *sbi) { } 1629 static inline void __init f2fs_create_root_stats(void) { } 1630 static inline void f2fs_destroy_root_stats(void) { } 1631 #endif 1632 1633 extern const struct file_operations f2fs_dir_operations; 1634 extern const struct file_operations f2fs_file_operations; 1635 extern const struct inode_operations f2fs_file_inode_operations; 1636 extern const struct address_space_operations f2fs_dblock_aops; 1637 extern const struct address_space_operations f2fs_node_aops; 1638 extern const struct address_space_operations f2fs_meta_aops; 1639 extern const struct inode_operations f2fs_dir_inode_operations; 1640 extern const struct inode_operations f2fs_symlink_inode_operations; 1641 extern const struct inode_operations f2fs_special_inode_operations; 1642 1643 /* 1644 * inline.c 1645 */ 1646 bool f2fs_may_inline(struct inode *); 1647 void read_inline_data(struct page *, struct page *); 1648 int f2fs_read_inline_data(struct inode *, struct page *); 1649 int f2fs_convert_inline_page(struct dnode_of_data *, struct page *); 1650 int f2fs_convert_inline_inode(struct inode *); 1651 int f2fs_write_inline_data(struct inode *, struct page *); 1652 bool recover_inline_data(struct inode *, struct page *); 1653 struct f2fs_dir_entry *find_in_inline_dir(struct inode *, struct qstr *, 1654 struct page **); 1655 struct f2fs_dir_entry *f2fs_parent_inline_dir(struct inode *, struct page **); 1656 int make_empty_inline_dir(struct inode *inode, struct inode *, struct page *); 1657 int f2fs_add_inline_entry(struct inode *, const struct qstr *, struct inode *); 1658 void f2fs_delete_inline_entry(struct f2fs_dir_entry *, struct page *, 1659 struct inode *, struct inode *); 1660 bool f2fs_empty_inline_dir(struct inode *); 1661 int f2fs_read_inline_dir(struct file *, struct dir_context *); 1662 #endif 1663