segment.h 18 KB

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