1 /* 2 * fs/f2fs/segment.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 #include <linux/blkdev.h> 12 13 /* constant macro */ 14 #define NULL_SEGNO ((unsigned int)(~0)) 15 #define NULL_SECNO ((unsigned int)(~0)) 16 17 /* L: Logical segment # in volume, R: Relative segment # in main area */ 18 #define GET_L2R_SEGNO(free_i, segno) (segno - free_i->start_segno) 19 #define GET_R2L_SEGNO(free_i, segno) (segno + free_i->start_segno) 20 21 #define IS_DATASEG(t) \ 22 ((t == CURSEG_HOT_DATA) || (t == CURSEG_COLD_DATA) || \ 23 (t == CURSEG_WARM_DATA)) 24 25 #define IS_NODESEG(t) \ 26 ((t == CURSEG_HOT_NODE) || (t == CURSEG_COLD_NODE) || \ 27 (t == CURSEG_WARM_NODE)) 28 29 #define IS_CURSEG(sbi, seg) \ 30 ((seg == CURSEG_I(sbi, CURSEG_HOT_DATA)->segno) || \ 31 (seg == CURSEG_I(sbi, CURSEG_WARM_DATA)->segno) || \ 32 (seg == CURSEG_I(sbi, CURSEG_COLD_DATA)->segno) || \ 33 (seg == CURSEG_I(sbi, CURSEG_HOT_NODE)->segno) || \ 34 (seg == CURSEG_I(sbi, CURSEG_WARM_NODE)->segno) || \ 35 (seg == CURSEG_I(sbi, CURSEG_COLD_NODE)->segno)) 36 37 #define IS_CURSEC(sbi, secno) \ 38 ((secno == CURSEG_I(sbi, CURSEG_HOT_DATA)->segno / \ 39 sbi->segs_per_sec) || \ 40 (secno == CURSEG_I(sbi, CURSEG_WARM_DATA)->segno / \ 41 sbi->segs_per_sec) || \ 42 (secno == CURSEG_I(sbi, CURSEG_COLD_DATA)->segno / \ 43 sbi->segs_per_sec) || \ 44 (secno == CURSEG_I(sbi, CURSEG_HOT_NODE)->segno / \ 45 sbi->segs_per_sec) || \ 46 (secno == CURSEG_I(sbi, CURSEG_WARM_NODE)->segno / \ 47 sbi->segs_per_sec) || \ 48 (secno == CURSEG_I(sbi, CURSEG_COLD_NODE)->segno / \ 49 sbi->segs_per_sec)) \ 50 51 #define START_BLOCK(sbi, segno) \ 52 (SM_I(sbi)->seg0_blkaddr + \ 53 (GET_R2L_SEGNO(FREE_I(sbi), segno) << sbi->log_blocks_per_seg)) 54 #define NEXT_FREE_BLKADDR(sbi, curseg) \ 55 (START_BLOCK(sbi, curseg->segno) + curseg->next_blkoff) 56 57 #define MAIN_BASE_BLOCK(sbi) (SM_I(sbi)->main_blkaddr) 58 59 #define GET_SEGOFF_FROM_SEG0(sbi, blk_addr) \ 60 ((blk_addr) - SM_I(sbi)->seg0_blkaddr) 61 #define GET_SEGNO_FROM_SEG0(sbi, blk_addr) \ 62 (GET_SEGOFF_FROM_SEG0(sbi, blk_addr) >> sbi->log_blocks_per_seg) 63 #define GET_SEGNO(sbi, blk_addr) \ 64 (((blk_addr == NULL_ADDR) || (blk_addr == NEW_ADDR)) ? \ 65 NULL_SEGNO : GET_L2R_SEGNO(FREE_I(sbi), \ 66 GET_SEGNO_FROM_SEG0(sbi, blk_addr))) 67 #define GET_SECNO(sbi, segno) \ 68 ((segno) / sbi->segs_per_sec) 69 #define GET_ZONENO_FROM_SEGNO(sbi, segno) \ 70 ((segno / sbi->segs_per_sec) / sbi->secs_per_zone) 71 72 #define GET_SUM_BLOCK(sbi, segno) \ 73 ((sbi->sm_info->ssa_blkaddr) + segno) 74 75 #define GET_SUM_TYPE(footer) ((footer)->entry_type) 76 #define SET_SUM_TYPE(footer, type) ((footer)->entry_type = type) 77 78 #define SIT_ENTRY_OFFSET(sit_i, segno) \ 79 (segno % sit_i->sents_per_block) 80 #define SIT_BLOCK_OFFSET(sit_i, segno) \ 81 (segno / SIT_ENTRY_PER_BLOCK) 82 #define START_SEGNO(sit_i, segno) \ 83 (SIT_BLOCK_OFFSET(sit_i, segno) * SIT_ENTRY_PER_BLOCK) 84 #define f2fs_bitmap_size(nr) \ 85 (BITS_TO_LONGS(nr) * sizeof(unsigned long)) 86 #define TOTAL_SEGS(sbi) (SM_I(sbi)->main_segments) 87 #define TOTAL_SECS(sbi) (sbi->total_sections) 88 89 #define SECTOR_FROM_BLOCK(sbi, blk_addr) \ 90 (blk_addr << ((sbi)->log_blocksize - F2FS_LOG_SECTOR_SIZE)) 91 #define SECTOR_TO_BLOCK(sbi, sectors) \ 92 (sectors >> ((sbi)->log_blocksize - F2FS_LOG_SECTOR_SIZE)) 93 94 /* during checkpoint, bio_private is used to synchronize the last bio */ 95 struct bio_private { 96 struct f2fs_sb_info *sbi; 97 bool is_sync; 98 void *wait; 99 }; 100 101 /* 102 * indicate a block allocation direction: RIGHT and LEFT. 103 * RIGHT means allocating new sections towards the end of volume. 104 * LEFT means the opposite direction. 105 */ 106 enum { 107 ALLOC_RIGHT = 0, 108 ALLOC_LEFT 109 }; 110 111 /* 112 * In the victim_sel_policy->alloc_mode, there are two block allocation modes. 113 * LFS writes data sequentially with cleaning operations. 114 * SSR (Slack Space Recycle) reuses obsolete space without cleaning operations. 115 */ 116 enum { 117 LFS = 0, 118 SSR 119 }; 120 121 /* 122 * In the victim_sel_policy->gc_mode, there are two gc, aka cleaning, modes. 123 * GC_CB is based on cost-benefit algorithm. 124 * GC_GREEDY is based on greedy algorithm. 125 */ 126 enum { 127 GC_CB = 0, 128 GC_GREEDY 129 }; 130 131 /* 132 * BG_GC means the background cleaning job. 133 * FG_GC means the on-demand cleaning job. 134 */ 135 enum { 136 BG_GC = 0, 137 FG_GC 138 }; 139 140 /* for a function parameter to select a victim segment */ 141 struct victim_sel_policy { 142 int alloc_mode; /* LFS or SSR */ 143 int gc_mode; /* GC_CB or GC_GREEDY */ 144 unsigned long *dirty_segmap; /* dirty segment bitmap */ 145 unsigned int offset; /* last scanned bitmap offset */ 146 unsigned int ofs_unit; /* bitmap search unit */ 147 unsigned int min_cost; /* minimum cost */ 148 unsigned int min_segno; /* segment # having min. cost */ 149 }; 150 151 struct seg_entry { 152 unsigned short valid_blocks; /* # of valid blocks */ 153 unsigned char *cur_valid_map; /* validity bitmap of blocks */ 154 /* 155 * # of valid blocks and the validity bitmap stored in the the last 156 * checkpoint pack. This information is used by the SSR mode. 157 */ 158 unsigned short ckpt_valid_blocks; 159 unsigned char *ckpt_valid_map; 160 unsigned char type; /* segment type like CURSEG_XXX_TYPE */ 161 unsigned long long mtime; /* modification time of the segment */ 162 }; 163 164 struct sec_entry { 165 unsigned int valid_blocks; /* # of valid blocks in a section */ 166 }; 167 168 struct segment_allocation { 169 void (*allocate_segment)(struct f2fs_sb_info *, int, bool); 170 }; 171 172 struct sit_info { 173 const struct segment_allocation *s_ops; 174 175 block_t sit_base_addr; /* start block address of SIT area */ 176 block_t sit_blocks; /* # of blocks used by SIT area */ 177 block_t written_valid_blocks; /* # of valid blocks in main area */ 178 char *sit_bitmap; /* SIT bitmap pointer */ 179 unsigned int bitmap_size; /* SIT bitmap size */ 180 181 unsigned long *dirty_sentries_bitmap; /* bitmap for dirty sentries */ 182 unsigned int dirty_sentries; /* # of dirty sentries */ 183 unsigned int sents_per_block; /* # of SIT entries per block */ 184 struct mutex sentry_lock; /* to protect SIT cache */ 185 struct seg_entry *sentries; /* SIT segment-level cache */ 186 struct sec_entry *sec_entries; /* SIT section-level cache */ 187 188 /* for cost-benefit algorithm in cleaning procedure */ 189 unsigned long long elapsed_time; /* elapsed time after mount */ 190 unsigned long long mounted_time; /* mount time */ 191 unsigned long long min_mtime; /* min. modification time */ 192 unsigned long long max_mtime; /* max. modification time */ 193 }; 194 195 struct free_segmap_info { 196 unsigned int start_segno; /* start segment number logically */ 197 unsigned int free_segments; /* # of free segments */ 198 unsigned int free_sections; /* # of free sections */ 199 rwlock_t segmap_lock; /* free segmap lock */ 200 unsigned long *free_segmap; /* free segment bitmap */ 201 unsigned long *free_secmap; /* free section bitmap */ 202 }; 203 204 /* Notice: The order of dirty type is same with CURSEG_XXX in f2fs.h */ 205 enum dirty_type { 206 DIRTY_HOT_DATA, /* dirty segments assigned as hot data logs */ 207 DIRTY_WARM_DATA, /* dirty segments assigned as warm data logs */ 208 DIRTY_COLD_DATA, /* dirty segments assigned as cold data logs */ 209 DIRTY_HOT_NODE, /* dirty segments assigned as hot node logs */ 210 DIRTY_WARM_NODE, /* dirty segments assigned as warm node logs */ 211 DIRTY_COLD_NODE, /* dirty segments assigned as cold node logs */ 212 DIRTY, /* to count # of dirty segments */ 213 PRE, /* to count # of entirely obsolete segments */ 214 NR_DIRTY_TYPE 215 }; 216 217 struct dirty_seglist_info { 218 const struct victim_selection *v_ops; /* victim selction operation */ 219 unsigned long *dirty_segmap[NR_DIRTY_TYPE]; 220 struct mutex seglist_lock; /* lock for segment bitmaps */ 221 int nr_dirty[NR_DIRTY_TYPE]; /* # of dirty segments */ 222 unsigned long *victim_secmap; /* background GC victims */ 223 }; 224 225 /* victim selection function for cleaning and SSR */ 226 struct victim_selection { 227 int (*get_victim)(struct f2fs_sb_info *, unsigned int *, 228 int, int, char); 229 }; 230 231 /* for active log information */ 232 struct curseg_info { 233 struct mutex curseg_mutex; /* lock for consistency */ 234 struct f2fs_summary_block *sum_blk; /* cached summary block */ 235 unsigned char alloc_type; /* current allocation type */ 236 unsigned int segno; /* current segment number */ 237 unsigned short next_blkoff; /* next block offset to write */ 238 unsigned int zone; /* current zone number */ 239 unsigned int next_segno; /* preallocated segment */ 240 }; 241 242 /* 243 * inline functions 244 */ 245 static inline struct curseg_info *CURSEG_I(struct f2fs_sb_info *sbi, int type) 246 { 247 return (struct curseg_info *)(SM_I(sbi)->curseg_array + type); 248 } 249 250 static inline struct seg_entry *get_seg_entry(struct f2fs_sb_info *sbi, 251 unsigned int segno) 252 { 253 struct sit_info *sit_i = SIT_I(sbi); 254 return &sit_i->sentries[segno]; 255 } 256 257 static inline struct sec_entry *get_sec_entry(struct f2fs_sb_info *sbi, 258 unsigned int segno) 259 { 260 struct sit_info *sit_i = SIT_I(sbi); 261 return &sit_i->sec_entries[GET_SECNO(sbi, segno)]; 262 } 263 264 static inline unsigned int get_valid_blocks(struct f2fs_sb_info *sbi, 265 unsigned int segno, int section) 266 { 267 /* 268 * In order to get # of valid blocks in a section instantly from many 269 * segments, f2fs manages two counting structures separately. 270 */ 271 if (section > 1) 272 return get_sec_entry(sbi, segno)->valid_blocks; 273 else 274 return get_seg_entry(sbi, segno)->valid_blocks; 275 } 276 277 static inline void seg_info_from_raw_sit(struct seg_entry *se, 278 struct f2fs_sit_entry *rs) 279 { 280 se->valid_blocks = GET_SIT_VBLOCKS(rs); 281 se->ckpt_valid_blocks = GET_SIT_VBLOCKS(rs); 282 memcpy(se->cur_valid_map, rs->valid_map, SIT_VBLOCK_MAP_SIZE); 283 memcpy(se->ckpt_valid_map, rs->valid_map, SIT_VBLOCK_MAP_SIZE); 284 se->type = GET_SIT_TYPE(rs); 285 se->mtime = le64_to_cpu(rs->mtime); 286 } 287 288 static inline void seg_info_to_raw_sit(struct seg_entry *se, 289 struct f2fs_sit_entry *rs) 290 { 291 unsigned short raw_vblocks = (se->type << SIT_VBLOCKS_SHIFT) | 292 se->valid_blocks; 293 rs->vblocks = cpu_to_le16(raw_vblocks); 294 memcpy(rs->valid_map, se->cur_valid_map, SIT_VBLOCK_MAP_SIZE); 295 memcpy(se->ckpt_valid_map, rs->valid_map, SIT_VBLOCK_MAP_SIZE); 296 se->ckpt_valid_blocks = se->valid_blocks; 297 rs->mtime = cpu_to_le64(se->mtime); 298 } 299 300 static inline unsigned int find_next_inuse(struct free_segmap_info *free_i, 301 unsigned int max, unsigned int segno) 302 { 303 unsigned int ret; 304 read_lock(&free_i->segmap_lock); 305 ret = find_next_bit(free_i->free_segmap, max, segno); 306 read_unlock(&free_i->segmap_lock); 307 return ret; 308 } 309 310 static inline void __set_free(struct f2fs_sb_info *sbi, unsigned int segno) 311 { 312 struct free_segmap_info *free_i = FREE_I(sbi); 313 unsigned int secno = segno / sbi->segs_per_sec; 314 unsigned int start_segno = secno * sbi->segs_per_sec; 315 unsigned int next; 316 317 write_lock(&free_i->segmap_lock); 318 clear_bit(segno, free_i->free_segmap); 319 free_i->free_segments++; 320 321 next = find_next_bit(free_i->free_segmap, TOTAL_SEGS(sbi), start_segno); 322 if (next >= start_segno + sbi->segs_per_sec) { 323 clear_bit(secno, free_i->free_secmap); 324 free_i->free_sections++; 325 } 326 write_unlock(&free_i->segmap_lock); 327 } 328 329 static inline void __set_inuse(struct f2fs_sb_info *sbi, 330 unsigned int segno) 331 { 332 struct free_segmap_info *free_i = FREE_I(sbi); 333 unsigned int secno = segno / sbi->segs_per_sec; 334 set_bit(segno, free_i->free_segmap); 335 free_i->free_segments--; 336 if (!test_and_set_bit(secno, free_i->free_secmap)) 337 free_i->free_sections--; 338 } 339 340 static inline void __set_test_and_free(struct f2fs_sb_info *sbi, 341 unsigned int segno) 342 { 343 struct free_segmap_info *free_i = FREE_I(sbi); 344 unsigned int secno = segno / sbi->segs_per_sec; 345 unsigned int start_segno = secno * sbi->segs_per_sec; 346 unsigned int next; 347 348 write_lock(&free_i->segmap_lock); 349 if (test_and_clear_bit(segno, free_i->free_segmap)) { 350 free_i->free_segments++; 351 352 next = find_next_bit(free_i->free_segmap, TOTAL_SEGS(sbi), 353 start_segno); 354 if (next >= start_segno + sbi->segs_per_sec) { 355 if (test_and_clear_bit(secno, free_i->free_secmap)) 356 free_i->free_sections++; 357 } 358 } 359 write_unlock(&free_i->segmap_lock); 360 } 361 362 static inline void __set_test_and_inuse(struct f2fs_sb_info *sbi, 363 unsigned int segno) 364 { 365 struct free_segmap_info *free_i = FREE_I(sbi); 366 unsigned int secno = segno / sbi->segs_per_sec; 367 write_lock(&free_i->segmap_lock); 368 if (!test_and_set_bit(segno, free_i->free_segmap)) { 369 free_i->free_segments--; 370 if (!test_and_set_bit(secno, free_i->free_secmap)) 371 free_i->free_sections--; 372 } 373 write_unlock(&free_i->segmap_lock); 374 } 375 376 static inline void get_sit_bitmap(struct f2fs_sb_info *sbi, 377 void *dst_addr) 378 { 379 struct sit_info *sit_i = SIT_I(sbi); 380 memcpy(dst_addr, sit_i->sit_bitmap, sit_i->bitmap_size); 381 } 382 383 static inline block_t written_block_count(struct f2fs_sb_info *sbi) 384 { 385 struct sit_info *sit_i = SIT_I(sbi); 386 block_t vblocks; 387 388 mutex_lock(&sit_i->sentry_lock); 389 vblocks = sit_i->written_valid_blocks; 390 mutex_unlock(&sit_i->sentry_lock); 391 392 return vblocks; 393 } 394 395 static inline unsigned int free_segments(struct f2fs_sb_info *sbi) 396 { 397 struct free_segmap_info *free_i = FREE_I(sbi); 398 unsigned int free_segs; 399 400 read_lock(&free_i->segmap_lock); 401 free_segs = free_i->free_segments; 402 read_unlock(&free_i->segmap_lock); 403 404 return free_segs; 405 } 406 407 static inline int reserved_segments(struct f2fs_sb_info *sbi) 408 { 409 return SM_I(sbi)->reserved_segments; 410 } 411 412 static inline unsigned int free_sections(struct f2fs_sb_info *sbi) 413 { 414 struct free_segmap_info *free_i = FREE_I(sbi); 415 unsigned int free_secs; 416 417 read_lock(&free_i->segmap_lock); 418 free_secs = free_i->free_sections; 419 read_unlock(&free_i->segmap_lock); 420 421 return free_secs; 422 } 423 424 static inline unsigned int prefree_segments(struct f2fs_sb_info *sbi) 425 { 426 return DIRTY_I(sbi)->nr_dirty[PRE]; 427 } 428 429 static inline unsigned int dirty_segments(struct f2fs_sb_info *sbi) 430 { 431 return DIRTY_I(sbi)->nr_dirty[DIRTY_HOT_DATA] + 432 DIRTY_I(sbi)->nr_dirty[DIRTY_WARM_DATA] + 433 DIRTY_I(sbi)->nr_dirty[DIRTY_COLD_DATA] + 434 DIRTY_I(sbi)->nr_dirty[DIRTY_HOT_NODE] + 435 DIRTY_I(sbi)->nr_dirty[DIRTY_WARM_NODE] + 436 DIRTY_I(sbi)->nr_dirty[DIRTY_COLD_NODE]; 437 } 438 439 static inline int overprovision_segments(struct f2fs_sb_info *sbi) 440 { 441 return SM_I(sbi)->ovp_segments; 442 } 443 444 static inline int overprovision_sections(struct f2fs_sb_info *sbi) 445 { 446 return ((unsigned int) overprovision_segments(sbi)) / sbi->segs_per_sec; 447 } 448 449 static inline int reserved_sections(struct f2fs_sb_info *sbi) 450 { 451 return ((unsigned int) reserved_segments(sbi)) / sbi->segs_per_sec; 452 } 453 454 static inline bool need_SSR(struct f2fs_sb_info *sbi) 455 { 456 return (free_sections(sbi) < overprovision_sections(sbi)); 457 } 458 459 static inline bool has_not_enough_free_secs(struct f2fs_sb_info *sbi, int freed) 460 { 461 int node_secs = get_blocktype_secs(sbi, F2FS_DIRTY_NODES); 462 int dent_secs = get_blocktype_secs(sbi, F2FS_DIRTY_DENTS); 463 464 if (sbi->por_doing) 465 return false; 466 467 return ((free_sections(sbi) + freed) <= (node_secs + 2 * dent_secs + 468 reserved_sections(sbi))); 469 } 470 471 static inline int utilization(struct f2fs_sb_info *sbi) 472 { 473 return div_u64(valid_user_blocks(sbi) * 100, sbi->user_block_count); 474 } 475 476 /* 477 * Sometimes f2fs may be better to drop out-of-place update policy. 478 * So, if fs utilization is over MIN_IPU_UTIL, then f2fs tries to write 479 * data in the original place likewise other traditional file systems. 480 * But, currently set 100 in percentage, which means it is disabled. 481 * See below need_inplace_update(). 482 */ 483 #define MIN_IPU_UTIL 100 484 static inline bool need_inplace_update(struct inode *inode) 485 { 486 struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb); 487 if (S_ISDIR(inode->i_mode)) 488 return false; 489 if (need_SSR(sbi) && utilization(sbi) > MIN_IPU_UTIL) 490 return true; 491 return false; 492 } 493 494 static inline unsigned int curseg_segno(struct f2fs_sb_info *sbi, 495 int type) 496 { 497 struct curseg_info *curseg = CURSEG_I(sbi, type); 498 return curseg->segno; 499 } 500 501 static inline unsigned char curseg_alloc_type(struct f2fs_sb_info *sbi, 502 int type) 503 { 504 struct curseg_info *curseg = CURSEG_I(sbi, type); 505 return curseg->alloc_type; 506 } 507 508 static inline unsigned short curseg_blkoff(struct f2fs_sb_info *sbi, int type) 509 { 510 struct curseg_info *curseg = CURSEG_I(sbi, type); 511 return curseg->next_blkoff; 512 } 513 514 static inline void check_seg_range(struct f2fs_sb_info *sbi, unsigned int segno) 515 { 516 unsigned int end_segno = SM_I(sbi)->segment_count - 1; 517 BUG_ON(segno > end_segno); 518 } 519 520 /* 521 * This function is used for only debugging. 522 * NOTE: In future, we have to remove this function. 523 */ 524 static inline void verify_block_addr(struct f2fs_sb_info *sbi, block_t blk_addr) 525 { 526 struct f2fs_sm_info *sm_info = SM_I(sbi); 527 block_t total_blks = sm_info->segment_count << sbi->log_blocks_per_seg; 528 block_t start_addr = sm_info->seg0_blkaddr; 529 block_t end_addr = start_addr + total_blks - 1; 530 BUG_ON(blk_addr < start_addr); 531 BUG_ON(blk_addr > end_addr); 532 } 533 534 /* 535 * Summary block is always treated as invalid block 536 */ 537 static inline void check_block_count(struct f2fs_sb_info *sbi, 538 int segno, struct f2fs_sit_entry *raw_sit) 539 { 540 struct f2fs_sm_info *sm_info = SM_I(sbi); 541 unsigned int end_segno = sm_info->segment_count - 1; 542 int valid_blocks = 0; 543 int i; 544 545 /* check segment usage */ 546 BUG_ON(GET_SIT_VBLOCKS(raw_sit) > sbi->blocks_per_seg); 547 548 /* check boundary of a given segment number */ 549 BUG_ON(segno > end_segno); 550 551 /* check bitmap with valid block count */ 552 for (i = 0; i < sbi->blocks_per_seg; i++) 553 if (f2fs_test_bit(i, raw_sit->valid_map)) 554 valid_blocks++; 555 BUG_ON(GET_SIT_VBLOCKS(raw_sit) != valid_blocks); 556 } 557 558 static inline pgoff_t current_sit_addr(struct f2fs_sb_info *sbi, 559 unsigned int start) 560 { 561 struct sit_info *sit_i = SIT_I(sbi); 562 unsigned int offset = SIT_BLOCK_OFFSET(sit_i, start); 563 block_t blk_addr = sit_i->sit_base_addr + offset; 564 565 check_seg_range(sbi, start); 566 567 /* calculate sit block address */ 568 if (f2fs_test_bit(offset, sit_i->sit_bitmap)) 569 blk_addr += sit_i->sit_blocks; 570 571 return blk_addr; 572 } 573 574 static inline pgoff_t next_sit_addr(struct f2fs_sb_info *sbi, 575 pgoff_t block_addr) 576 { 577 struct sit_info *sit_i = SIT_I(sbi); 578 block_addr -= sit_i->sit_base_addr; 579 if (block_addr < sit_i->sit_blocks) 580 block_addr += sit_i->sit_blocks; 581 else 582 block_addr -= sit_i->sit_blocks; 583 584 return block_addr + sit_i->sit_base_addr; 585 } 586 587 static inline void set_to_next_sit(struct sit_info *sit_i, unsigned int start) 588 { 589 unsigned int block_off = SIT_BLOCK_OFFSET(sit_i, start); 590 591 if (f2fs_test_bit(block_off, sit_i->sit_bitmap)) 592 f2fs_clear_bit(block_off, sit_i->sit_bitmap); 593 else 594 f2fs_set_bit(block_off, sit_i->sit_bitmap); 595 } 596 597 static inline unsigned long long get_mtime(struct f2fs_sb_info *sbi) 598 { 599 struct sit_info *sit_i = SIT_I(sbi); 600 return sit_i->elapsed_time + CURRENT_TIME_SEC.tv_sec - 601 sit_i->mounted_time; 602 } 603 604 static inline void set_summary(struct f2fs_summary *sum, nid_t nid, 605 unsigned int ofs_in_node, unsigned char version) 606 { 607 sum->nid = cpu_to_le32(nid); 608 sum->ofs_in_node = cpu_to_le16(ofs_in_node); 609 sum->version = version; 610 } 611 612 static inline block_t start_sum_block(struct f2fs_sb_info *sbi) 613 { 614 return __start_cp_addr(sbi) + 615 le32_to_cpu(F2FS_CKPT(sbi)->cp_pack_start_sum); 616 } 617 618 static inline block_t sum_blk_addr(struct f2fs_sb_info *sbi, int base, int type) 619 { 620 return __start_cp_addr(sbi) + 621 le32_to_cpu(F2FS_CKPT(sbi)->cp_pack_total_block_count) 622 - (base + 1) + type; 623 } 624 625 static inline bool sec_usage_check(struct f2fs_sb_info *sbi, unsigned int secno) 626 { 627 if (IS_CURSEC(sbi, secno) || (sbi->cur_victim_sec == secno)) 628 return true; 629 return false; 630 } 631 632 static inline unsigned int max_hw_blocks(struct f2fs_sb_info *sbi) 633 { 634 struct block_device *bdev = sbi->sb->s_bdev; 635 struct request_queue *q = bdev_get_queue(bdev); 636 return SECTOR_TO_BLOCK(sbi, queue_max_sectors(q)); 637 } 638