fsmap.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) 2017 Oracle. All Rights Reserved.
  4. *
  5. * Author: Darrick J. Wong <darrick.wong@oracle.com>
  6. */
  7. #include "ext4.h"
  8. #include <linux/fsmap.h>
  9. #include "fsmap.h"
  10. #include "mballoc.h"
  11. #include <linux/sort.h>
  12. #include <linux/list_sort.h>
  13. #include <trace/events/ext4.h>
  14. /* Convert an ext4_fsmap to an fsmap. */
  15. void ext4_fsmap_from_internal(struct super_block *sb, struct fsmap *dest,
  16. struct ext4_fsmap *src)
  17. {
  18. dest->fmr_device = src->fmr_device;
  19. dest->fmr_flags = src->fmr_flags;
  20. dest->fmr_physical = src->fmr_physical << sb->s_blocksize_bits;
  21. dest->fmr_owner = src->fmr_owner;
  22. dest->fmr_offset = 0;
  23. dest->fmr_length = src->fmr_length << sb->s_blocksize_bits;
  24. dest->fmr_reserved[0] = 0;
  25. dest->fmr_reserved[1] = 0;
  26. dest->fmr_reserved[2] = 0;
  27. }
  28. /* Convert an fsmap to an ext4_fsmap. */
  29. void ext4_fsmap_to_internal(struct super_block *sb, struct ext4_fsmap *dest,
  30. struct fsmap *src)
  31. {
  32. dest->fmr_device = src->fmr_device;
  33. dest->fmr_flags = src->fmr_flags;
  34. dest->fmr_physical = src->fmr_physical >> sb->s_blocksize_bits;
  35. dest->fmr_owner = src->fmr_owner;
  36. dest->fmr_length = src->fmr_length >> sb->s_blocksize_bits;
  37. }
  38. /* getfsmap query state */
  39. struct ext4_getfsmap_info {
  40. struct ext4_fsmap_head *gfi_head;
  41. ext4_fsmap_format_t gfi_formatter; /* formatting fn */
  42. void *gfi_format_arg;/* format buffer */
  43. ext4_fsblk_t gfi_next_fsblk; /* next fsblock we expect */
  44. u32 gfi_dev; /* device id */
  45. ext4_group_t gfi_agno; /* bg number, if applicable */
  46. struct ext4_fsmap gfi_low; /* low rmap key */
  47. struct ext4_fsmap gfi_high; /* high rmap key */
  48. struct ext4_fsmap gfi_lastfree; /* free ext at end of last bg */
  49. struct list_head gfi_meta_list; /* fixed metadata list */
  50. bool gfi_last; /* last extent? */
  51. };
  52. /* Associate a device with a getfsmap handler. */
  53. struct ext4_getfsmap_dev {
  54. int (*gfd_fn)(struct super_block *sb,
  55. struct ext4_fsmap *keys,
  56. struct ext4_getfsmap_info *info);
  57. u32 gfd_dev;
  58. };
  59. /* Compare two getfsmap device handlers. */
  60. static int ext4_getfsmap_dev_compare(const void *p1, const void *p2)
  61. {
  62. const struct ext4_getfsmap_dev *d1 = p1;
  63. const struct ext4_getfsmap_dev *d2 = p2;
  64. return d1->gfd_dev - d2->gfd_dev;
  65. }
  66. /* Compare a record against our starting point */
  67. static bool ext4_getfsmap_rec_before_low_key(struct ext4_getfsmap_info *info,
  68. struct ext4_fsmap *rec)
  69. {
  70. return rec->fmr_physical < info->gfi_low.fmr_physical;
  71. }
  72. /*
  73. * Format a reverse mapping for getfsmap, having translated rm_startblock
  74. * into the appropriate daddr units.
  75. */
  76. static int ext4_getfsmap_helper(struct super_block *sb,
  77. struct ext4_getfsmap_info *info,
  78. struct ext4_fsmap *rec)
  79. {
  80. struct ext4_fsmap fmr;
  81. struct ext4_sb_info *sbi = EXT4_SB(sb);
  82. ext4_fsblk_t rec_fsblk = rec->fmr_physical;
  83. ext4_group_t agno;
  84. ext4_grpblk_t cno;
  85. int error;
  86. if (fatal_signal_pending(current))
  87. return -EINTR;
  88. /*
  89. * Filter out records that start before our startpoint, if the
  90. * caller requested that.
  91. */
  92. if (ext4_getfsmap_rec_before_low_key(info, rec)) {
  93. rec_fsblk += rec->fmr_length;
  94. if (info->gfi_next_fsblk < rec_fsblk)
  95. info->gfi_next_fsblk = rec_fsblk;
  96. return EXT4_QUERY_RANGE_CONTINUE;
  97. }
  98. /* Are we just counting mappings? */
  99. if (info->gfi_head->fmh_count == 0) {
  100. if (info->gfi_head->fmh_entries == UINT_MAX)
  101. return EXT4_QUERY_RANGE_ABORT;
  102. if (rec_fsblk > info->gfi_next_fsblk)
  103. info->gfi_head->fmh_entries++;
  104. if (info->gfi_last)
  105. return EXT4_QUERY_RANGE_CONTINUE;
  106. info->gfi_head->fmh_entries++;
  107. rec_fsblk += rec->fmr_length;
  108. if (info->gfi_next_fsblk < rec_fsblk)
  109. info->gfi_next_fsblk = rec_fsblk;
  110. return EXT4_QUERY_RANGE_CONTINUE;
  111. }
  112. /*
  113. * If the record starts past the last physical block we saw,
  114. * then we've found a gap. Report the gap as being owned by
  115. * whatever the caller specified is the missing owner.
  116. */
  117. if (rec_fsblk > info->gfi_next_fsblk) {
  118. if (info->gfi_head->fmh_entries >= info->gfi_head->fmh_count)
  119. return EXT4_QUERY_RANGE_ABORT;
  120. ext4_get_group_no_and_offset(sb, info->gfi_next_fsblk,
  121. &agno, &cno);
  122. trace_ext4_fsmap_mapping(sb, info->gfi_dev, agno,
  123. EXT4_C2B(sbi, cno),
  124. rec_fsblk - info->gfi_next_fsblk,
  125. EXT4_FMR_OWN_UNKNOWN);
  126. fmr.fmr_device = info->gfi_dev;
  127. fmr.fmr_physical = info->gfi_next_fsblk;
  128. fmr.fmr_owner = EXT4_FMR_OWN_UNKNOWN;
  129. fmr.fmr_length = rec_fsblk - info->gfi_next_fsblk;
  130. fmr.fmr_flags = FMR_OF_SPECIAL_OWNER;
  131. error = info->gfi_formatter(&fmr, info->gfi_format_arg);
  132. if (error)
  133. return error;
  134. info->gfi_head->fmh_entries++;
  135. }
  136. if (info->gfi_last)
  137. goto out;
  138. /* Fill out the extent we found */
  139. if (info->gfi_head->fmh_entries >= info->gfi_head->fmh_count)
  140. return EXT4_QUERY_RANGE_ABORT;
  141. ext4_get_group_no_and_offset(sb, rec_fsblk, &agno, &cno);
  142. trace_ext4_fsmap_mapping(sb, info->gfi_dev, agno, EXT4_C2B(sbi, cno),
  143. rec->fmr_length, rec->fmr_owner);
  144. fmr.fmr_device = info->gfi_dev;
  145. fmr.fmr_physical = rec_fsblk;
  146. fmr.fmr_owner = rec->fmr_owner;
  147. fmr.fmr_flags = FMR_OF_SPECIAL_OWNER;
  148. fmr.fmr_length = rec->fmr_length;
  149. error = info->gfi_formatter(&fmr, info->gfi_format_arg);
  150. if (error)
  151. return error;
  152. info->gfi_head->fmh_entries++;
  153. out:
  154. rec_fsblk += rec->fmr_length;
  155. if (info->gfi_next_fsblk < rec_fsblk)
  156. info->gfi_next_fsblk = rec_fsblk;
  157. return EXT4_QUERY_RANGE_CONTINUE;
  158. }
  159. static inline ext4_fsblk_t ext4_fsmap_next_pblk(struct ext4_fsmap *fmr)
  160. {
  161. return fmr->fmr_physical + fmr->fmr_length;
  162. }
  163. /* Transform a blockgroup's free record into a fsmap */
  164. static int ext4_getfsmap_datadev_helper(struct super_block *sb,
  165. ext4_group_t agno, ext4_grpblk_t start,
  166. ext4_grpblk_t len, void *priv)
  167. {
  168. struct ext4_fsmap irec;
  169. struct ext4_getfsmap_info *info = priv;
  170. struct ext4_fsmap *p;
  171. struct ext4_fsmap *tmp;
  172. struct ext4_sb_info *sbi = EXT4_SB(sb);
  173. ext4_fsblk_t fsb;
  174. ext4_fsblk_t fslen;
  175. int error;
  176. fsb = (EXT4_C2B(sbi, start) + ext4_group_first_block_no(sb, agno));
  177. fslen = EXT4_C2B(sbi, len);
  178. /* If the retained free extent record is set... */
  179. if (info->gfi_lastfree.fmr_owner) {
  180. /* ...and abuts this one, lengthen it and return. */
  181. if (ext4_fsmap_next_pblk(&info->gfi_lastfree) == fsb) {
  182. info->gfi_lastfree.fmr_length += fslen;
  183. return 0;
  184. }
  185. /*
  186. * There's a gap between the two free extents; emit the
  187. * retained extent prior to merging the meta_list.
  188. */
  189. error = ext4_getfsmap_helper(sb, info, &info->gfi_lastfree);
  190. if (error)
  191. return error;
  192. info->gfi_lastfree.fmr_owner = 0;
  193. }
  194. /* Merge in any relevant extents from the meta_list */
  195. list_for_each_entry_safe(p, tmp, &info->gfi_meta_list, fmr_list) {
  196. if (p->fmr_physical + p->fmr_length <= info->gfi_next_fsblk) {
  197. list_del(&p->fmr_list);
  198. kfree(p);
  199. } else if (p->fmr_physical < fsb) {
  200. error = ext4_getfsmap_helper(sb, info, p);
  201. if (error)
  202. return error;
  203. list_del(&p->fmr_list);
  204. kfree(p);
  205. }
  206. }
  207. irec.fmr_device = 0;
  208. irec.fmr_physical = fsb;
  209. irec.fmr_length = fslen;
  210. irec.fmr_owner = EXT4_FMR_OWN_FREE;
  211. irec.fmr_flags = 0;
  212. /* If this is a free extent at the end of a bg, buffer it. */
  213. if (ext4_fsmap_next_pblk(&irec) ==
  214. ext4_group_first_block_no(sb, agno + 1)) {
  215. info->gfi_lastfree = irec;
  216. return 0;
  217. }
  218. /* Otherwise, emit it */
  219. return ext4_getfsmap_helper(sb, info, &irec);
  220. }
  221. /* Execute a getfsmap query against the log device. */
  222. static int ext4_getfsmap_logdev(struct super_block *sb, struct ext4_fsmap *keys,
  223. struct ext4_getfsmap_info *info)
  224. {
  225. journal_t *journal = EXT4_SB(sb)->s_journal;
  226. struct ext4_fsmap irec;
  227. /* Set up search keys */
  228. info->gfi_low = keys[0];
  229. info->gfi_low.fmr_length = 0;
  230. memset(&info->gfi_high, 0xFF, sizeof(info->gfi_high));
  231. trace_ext4_fsmap_low_key(sb, info->gfi_dev, 0,
  232. info->gfi_low.fmr_physical,
  233. info->gfi_low.fmr_length,
  234. info->gfi_low.fmr_owner);
  235. trace_ext4_fsmap_high_key(sb, info->gfi_dev, 0,
  236. info->gfi_high.fmr_physical,
  237. info->gfi_high.fmr_length,
  238. info->gfi_high.fmr_owner);
  239. if (keys[0].fmr_physical > 0)
  240. return 0;
  241. /* Fabricate an rmap entry for the external log device. */
  242. irec.fmr_physical = journal->j_blk_offset;
  243. irec.fmr_length = journal->j_total_len;
  244. irec.fmr_owner = EXT4_FMR_OWN_LOG;
  245. irec.fmr_flags = 0;
  246. return ext4_getfsmap_helper(sb, info, &irec);
  247. }
  248. /* Helper to fill out an ext4_fsmap. */
  249. static inline int ext4_getfsmap_fill(struct list_head *meta_list,
  250. ext4_fsblk_t fsb, ext4_fsblk_t len,
  251. uint64_t owner)
  252. {
  253. struct ext4_fsmap *fsm;
  254. fsm = kmalloc(sizeof(*fsm), GFP_NOFS);
  255. if (!fsm)
  256. return -ENOMEM;
  257. fsm->fmr_device = 0;
  258. fsm->fmr_flags = 0;
  259. fsm->fmr_physical = fsb;
  260. fsm->fmr_owner = owner;
  261. fsm->fmr_length = len;
  262. list_add_tail(&fsm->fmr_list, meta_list);
  263. return 0;
  264. }
  265. /*
  266. * This function returns the number of file system metadata blocks at
  267. * the beginning of a block group, including the reserved gdt blocks.
  268. */
  269. static unsigned int ext4_getfsmap_find_sb(struct super_block *sb,
  270. ext4_group_t agno,
  271. struct list_head *meta_list)
  272. {
  273. struct ext4_sb_info *sbi = EXT4_SB(sb);
  274. ext4_fsblk_t fsb = ext4_group_first_block_no(sb, agno);
  275. ext4_fsblk_t len;
  276. unsigned long first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
  277. unsigned long metagroup = agno / EXT4_DESC_PER_BLOCK(sb);
  278. int error;
  279. /* Record the superblock. */
  280. if (ext4_bg_has_super(sb, agno)) {
  281. error = ext4_getfsmap_fill(meta_list, fsb, 1, EXT4_FMR_OWN_FS);
  282. if (error)
  283. return error;
  284. fsb++;
  285. }
  286. /* Record the group descriptors. */
  287. len = ext4_bg_num_gdb(sb, agno);
  288. if (!len)
  289. return 0;
  290. error = ext4_getfsmap_fill(meta_list, fsb, len,
  291. EXT4_FMR_OWN_GDT);
  292. if (error)
  293. return error;
  294. fsb += len;
  295. /* Reserved GDT blocks */
  296. if (!ext4_has_feature_meta_bg(sb) || metagroup < first_meta_bg) {
  297. len = le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks);
  298. error = ext4_getfsmap_fill(meta_list, fsb, len,
  299. EXT4_FMR_OWN_RESV_GDT);
  300. if (error)
  301. return error;
  302. }
  303. return 0;
  304. }
  305. /* Compare two fsmap items. */
  306. static int ext4_getfsmap_compare(void *priv,
  307. struct list_head *a,
  308. struct list_head *b)
  309. {
  310. struct ext4_fsmap *fa;
  311. struct ext4_fsmap *fb;
  312. fa = container_of(a, struct ext4_fsmap, fmr_list);
  313. fb = container_of(b, struct ext4_fsmap, fmr_list);
  314. if (fa->fmr_physical < fb->fmr_physical)
  315. return -1;
  316. else if (fa->fmr_physical > fb->fmr_physical)
  317. return 1;
  318. return 0;
  319. }
  320. /* Merge adjacent extents of fixed metadata. */
  321. static void ext4_getfsmap_merge_fixed_metadata(struct list_head *meta_list)
  322. {
  323. struct ext4_fsmap *p;
  324. struct ext4_fsmap *prev = NULL;
  325. struct ext4_fsmap *tmp;
  326. list_for_each_entry_safe(p, tmp, meta_list, fmr_list) {
  327. if (!prev) {
  328. prev = p;
  329. continue;
  330. }
  331. if (prev->fmr_owner == p->fmr_owner &&
  332. prev->fmr_physical + prev->fmr_length == p->fmr_physical) {
  333. prev->fmr_length += p->fmr_length;
  334. list_del(&p->fmr_list);
  335. kfree(p);
  336. } else
  337. prev = p;
  338. }
  339. }
  340. /* Free a list of fixed metadata. */
  341. static void ext4_getfsmap_free_fixed_metadata(struct list_head *meta_list)
  342. {
  343. struct ext4_fsmap *p;
  344. struct ext4_fsmap *tmp;
  345. list_for_each_entry_safe(p, tmp, meta_list, fmr_list) {
  346. list_del(&p->fmr_list);
  347. kfree(p);
  348. }
  349. }
  350. /* Find all the fixed metadata in the filesystem. */
  351. static int ext4_getfsmap_find_fixed_metadata(struct super_block *sb,
  352. struct list_head *meta_list)
  353. {
  354. struct ext4_group_desc *gdp;
  355. ext4_group_t agno;
  356. int error;
  357. INIT_LIST_HEAD(meta_list);
  358. /* Collect everything. */
  359. for (agno = 0; agno < EXT4_SB(sb)->s_groups_count; agno++) {
  360. gdp = ext4_get_group_desc(sb, agno, NULL);
  361. if (!gdp) {
  362. error = -EFSCORRUPTED;
  363. goto err;
  364. }
  365. /* Superblock & GDT */
  366. error = ext4_getfsmap_find_sb(sb, agno, meta_list);
  367. if (error)
  368. goto err;
  369. /* Block bitmap */
  370. error = ext4_getfsmap_fill(meta_list,
  371. ext4_block_bitmap(sb, gdp), 1,
  372. EXT4_FMR_OWN_BLKBM);
  373. if (error)
  374. goto err;
  375. /* Inode bitmap */
  376. error = ext4_getfsmap_fill(meta_list,
  377. ext4_inode_bitmap(sb, gdp), 1,
  378. EXT4_FMR_OWN_INOBM);
  379. if (error)
  380. goto err;
  381. /* Inodes */
  382. error = ext4_getfsmap_fill(meta_list,
  383. ext4_inode_table(sb, gdp),
  384. EXT4_SB(sb)->s_itb_per_group,
  385. EXT4_FMR_OWN_INODES);
  386. if (error)
  387. goto err;
  388. }
  389. /* Sort the list */
  390. list_sort(NULL, meta_list, ext4_getfsmap_compare);
  391. /* Merge adjacent extents */
  392. ext4_getfsmap_merge_fixed_metadata(meta_list);
  393. return 0;
  394. err:
  395. ext4_getfsmap_free_fixed_metadata(meta_list);
  396. return error;
  397. }
  398. /* Execute a getfsmap query against the buddy bitmaps */
  399. static int ext4_getfsmap_datadev(struct super_block *sb,
  400. struct ext4_fsmap *keys,
  401. struct ext4_getfsmap_info *info)
  402. {
  403. struct ext4_sb_info *sbi = EXT4_SB(sb);
  404. ext4_fsblk_t start_fsb;
  405. ext4_fsblk_t end_fsb;
  406. ext4_fsblk_t bofs;
  407. ext4_fsblk_t eofs;
  408. ext4_group_t start_ag;
  409. ext4_group_t end_ag;
  410. ext4_grpblk_t first_cluster;
  411. ext4_grpblk_t last_cluster;
  412. int error = 0;
  413. bofs = le32_to_cpu(sbi->s_es->s_first_data_block);
  414. eofs = ext4_blocks_count(sbi->s_es);
  415. if (keys[0].fmr_physical >= eofs)
  416. return 0;
  417. else if (keys[0].fmr_physical < bofs)
  418. keys[0].fmr_physical = bofs;
  419. if (keys[1].fmr_physical >= eofs)
  420. keys[1].fmr_physical = eofs - 1;
  421. start_fsb = keys[0].fmr_physical;
  422. end_fsb = keys[1].fmr_physical;
  423. /* Determine first and last group to examine based on start and end */
  424. ext4_get_group_no_and_offset(sb, start_fsb, &start_ag, &first_cluster);
  425. ext4_get_group_no_and_offset(sb, end_fsb, &end_ag, &last_cluster);
  426. /*
  427. * Convert the fsmap low/high keys to bg based keys. Initialize
  428. * low to the fsmap low key and max out the high key to the end
  429. * of the bg.
  430. */
  431. info->gfi_low = keys[0];
  432. info->gfi_low.fmr_physical = EXT4_C2B(sbi, first_cluster);
  433. info->gfi_low.fmr_length = 0;
  434. memset(&info->gfi_high, 0xFF, sizeof(info->gfi_high));
  435. /* Assemble a list of all the fixed-location metadata. */
  436. error = ext4_getfsmap_find_fixed_metadata(sb, &info->gfi_meta_list);
  437. if (error)
  438. goto err;
  439. /* Query each bg */
  440. for (info->gfi_agno = start_ag;
  441. info->gfi_agno <= end_ag;
  442. info->gfi_agno++) {
  443. /*
  444. * Set the bg high key from the fsmap high key if this
  445. * is the last bg that we're querying.
  446. */
  447. if (info->gfi_agno == end_ag) {
  448. info->gfi_high = keys[1];
  449. info->gfi_high.fmr_physical = EXT4_C2B(sbi,
  450. last_cluster);
  451. info->gfi_high.fmr_length = 0;
  452. }
  453. trace_ext4_fsmap_low_key(sb, info->gfi_dev, info->gfi_agno,
  454. info->gfi_low.fmr_physical,
  455. info->gfi_low.fmr_length,
  456. info->gfi_low.fmr_owner);
  457. trace_ext4_fsmap_high_key(sb, info->gfi_dev, info->gfi_agno,
  458. info->gfi_high.fmr_physical,
  459. info->gfi_high.fmr_length,
  460. info->gfi_high.fmr_owner);
  461. error = ext4_mballoc_query_range(sb, info->gfi_agno,
  462. EXT4_B2C(sbi, info->gfi_low.fmr_physical),
  463. EXT4_B2C(sbi, info->gfi_high.fmr_physical),
  464. ext4_getfsmap_datadev_helper, info);
  465. if (error)
  466. goto err;
  467. /*
  468. * Set the bg low key to the start of the bg prior to
  469. * moving on to the next bg.
  470. */
  471. if (info->gfi_agno == start_ag)
  472. memset(&info->gfi_low, 0, sizeof(info->gfi_low));
  473. }
  474. /* Do we have a retained free extent? */
  475. if (info->gfi_lastfree.fmr_owner) {
  476. error = ext4_getfsmap_helper(sb, info, &info->gfi_lastfree);
  477. if (error)
  478. goto err;
  479. }
  480. /* Report any gaps at the end of the bg */
  481. info->gfi_last = true;
  482. error = ext4_getfsmap_datadev_helper(sb, end_ag, last_cluster, 0, info);
  483. if (error)
  484. goto err;
  485. err:
  486. ext4_getfsmap_free_fixed_metadata(&info->gfi_meta_list);
  487. return error;
  488. }
  489. /* Do we recognize the device? */
  490. static bool ext4_getfsmap_is_valid_device(struct super_block *sb,
  491. struct ext4_fsmap *fm)
  492. {
  493. if (fm->fmr_device == 0 || fm->fmr_device == UINT_MAX ||
  494. fm->fmr_device == new_encode_dev(sb->s_bdev->bd_dev))
  495. return true;
  496. if (EXT4_SB(sb)->s_journal_bdev &&
  497. fm->fmr_device == new_encode_dev(EXT4_SB(sb)->s_journal_bdev->bd_dev))
  498. return true;
  499. return false;
  500. }
  501. /* Ensure that the low key is less than the high key. */
  502. static bool ext4_getfsmap_check_keys(struct ext4_fsmap *low_key,
  503. struct ext4_fsmap *high_key)
  504. {
  505. if (low_key->fmr_device > high_key->fmr_device)
  506. return false;
  507. if (low_key->fmr_device < high_key->fmr_device)
  508. return true;
  509. if (low_key->fmr_physical > high_key->fmr_physical)
  510. return false;
  511. if (low_key->fmr_physical < high_key->fmr_physical)
  512. return true;
  513. if (low_key->fmr_owner > high_key->fmr_owner)
  514. return false;
  515. if (low_key->fmr_owner < high_key->fmr_owner)
  516. return true;
  517. return false;
  518. }
  519. #define EXT4_GETFSMAP_DEVS 2
  520. /*
  521. * Get filesystem's extents as described in head, and format for
  522. * output. Calls formatter to fill the user's buffer until all
  523. * extents are mapped, until the passed-in head->fmh_count slots have
  524. * been filled, or until the formatter short-circuits the loop, if it
  525. * is tracking filled-in extents on its own.
  526. *
  527. * Key to Confusion
  528. * ----------------
  529. * There are multiple levels of keys and counters at work here:
  530. * _fsmap_head.fmh_keys -- low and high fsmap keys passed in;
  531. * these reflect fs-wide block addrs.
  532. * dkeys -- fmh_keys used to query each device;
  533. * these are fmh_keys but w/ the low key
  534. * bumped up by fmr_length.
  535. * _getfsmap_info.gfi_next_fsblk-- next fs block we expect to see; this
  536. * is how we detect gaps in the fsmap
  537. * records and report them.
  538. * _getfsmap_info.gfi_low/high -- per-bg low/high keys computed from
  539. * dkeys; used to query the free space.
  540. */
  541. int ext4_getfsmap(struct super_block *sb, struct ext4_fsmap_head *head,
  542. ext4_fsmap_format_t formatter, void *arg)
  543. {
  544. struct ext4_fsmap dkeys[2]; /* per-dev keys */
  545. struct ext4_getfsmap_dev handlers[EXT4_GETFSMAP_DEVS];
  546. struct ext4_getfsmap_info info = { NULL };
  547. int i;
  548. int error = 0;
  549. if (head->fmh_iflags & ~FMH_IF_VALID)
  550. return -EINVAL;
  551. if (!ext4_getfsmap_is_valid_device(sb, &head->fmh_keys[0]) ||
  552. !ext4_getfsmap_is_valid_device(sb, &head->fmh_keys[1]))
  553. return -EINVAL;
  554. head->fmh_entries = 0;
  555. /* Set up our device handlers. */
  556. memset(handlers, 0, sizeof(handlers));
  557. handlers[0].gfd_dev = new_encode_dev(sb->s_bdev->bd_dev);
  558. handlers[0].gfd_fn = ext4_getfsmap_datadev;
  559. if (EXT4_SB(sb)->s_journal_bdev) {
  560. handlers[1].gfd_dev = new_encode_dev(
  561. EXT4_SB(sb)->s_journal_bdev->bd_dev);
  562. handlers[1].gfd_fn = ext4_getfsmap_logdev;
  563. }
  564. sort(handlers, EXT4_GETFSMAP_DEVS, sizeof(struct ext4_getfsmap_dev),
  565. ext4_getfsmap_dev_compare, NULL);
  566. /*
  567. * To continue where we left off, we allow userspace to use the
  568. * last mapping from a previous call as the low key of the next.
  569. * This is identified by a non-zero length in the low key. We
  570. * have to increment the low key in this scenario to ensure we
  571. * don't return the same mapping again, and instead return the
  572. * very next mapping.
  573. *
  574. * Bump the physical offset as there can be no other mapping for
  575. * the same physical block range.
  576. */
  577. dkeys[0] = head->fmh_keys[0];
  578. dkeys[0].fmr_physical += dkeys[0].fmr_length;
  579. dkeys[0].fmr_owner = 0;
  580. dkeys[0].fmr_length = 0;
  581. memset(&dkeys[1], 0xFF, sizeof(struct ext4_fsmap));
  582. if (!ext4_getfsmap_check_keys(dkeys, &head->fmh_keys[1]))
  583. return -EINVAL;
  584. info.gfi_next_fsblk = head->fmh_keys[0].fmr_physical +
  585. head->fmh_keys[0].fmr_length;
  586. info.gfi_formatter = formatter;
  587. info.gfi_format_arg = arg;
  588. info.gfi_head = head;
  589. /* For each device we support... */
  590. for (i = 0; i < EXT4_GETFSMAP_DEVS; i++) {
  591. /* Is this device within the range the user asked for? */
  592. if (!handlers[i].gfd_fn)
  593. continue;
  594. if (head->fmh_keys[0].fmr_device > handlers[i].gfd_dev)
  595. continue;
  596. if (head->fmh_keys[1].fmr_device < handlers[i].gfd_dev)
  597. break;
  598. /*
  599. * If this device number matches the high key, we have
  600. * to pass the high key to the handler to limit the
  601. * query results. If the device number exceeds the
  602. * low key, zero out the low key so that we get
  603. * everything from the beginning.
  604. */
  605. if (handlers[i].gfd_dev == head->fmh_keys[1].fmr_device)
  606. dkeys[1] = head->fmh_keys[1];
  607. if (handlers[i].gfd_dev > head->fmh_keys[0].fmr_device)
  608. memset(&dkeys[0], 0, sizeof(struct ext4_fsmap));
  609. info.gfi_dev = handlers[i].gfd_dev;
  610. info.gfi_last = false;
  611. info.gfi_agno = -1;
  612. error = handlers[i].gfd_fn(sb, dkeys, &info);
  613. if (error)
  614. break;
  615. info.gfi_next_fsblk = 0;
  616. }
  617. head->fmh_oflags = FMH_OF_DEV_T;
  618. return error;
  619. }