dm-thin-metadata.c 45 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020
  1. /*
  2. * Copyright (C) 2011-2012 Red Hat, Inc.
  3. *
  4. * This file is released under the GPL.
  5. */
  6. #include "dm-thin-metadata.h"
  7. #include "persistent-data/dm-btree.h"
  8. #include "persistent-data/dm-space-map.h"
  9. #include "persistent-data/dm-space-map-disk.h"
  10. #include "persistent-data/dm-transaction-manager.h"
  11. #include <linux/list.h>
  12. #include <linux/device-mapper.h>
  13. #include <linux/workqueue.h>
  14. /*--------------------------------------------------------------------------
  15. * As far as the metadata goes, there is:
  16. *
  17. * - A superblock in block zero, taking up fewer than 512 bytes for
  18. * atomic writes.
  19. *
  20. * - A space map managing the metadata blocks.
  21. *
  22. * - A space map managing the data blocks.
  23. *
  24. * - A btree mapping our internal thin dev ids onto struct disk_device_details.
  25. *
  26. * - A hierarchical btree, with 2 levels which effectively maps (thin
  27. * dev id, virtual block) -> block_time. Block time is a 64-bit
  28. * field holding the time in the low 24 bits, and block in the top 48
  29. * bits.
  30. *
  31. * BTrees consist solely of btree_nodes, that fill a block. Some are
  32. * internal nodes, as such their values are a __le64 pointing to other
  33. * nodes. Leaf nodes can store data of any reasonable size (ie. much
  34. * smaller than the block size). The nodes consist of the header,
  35. * followed by an array of keys, followed by an array of values. We have
  36. * to binary search on the keys so they're all held together to help the
  37. * cpu cache.
  38. *
  39. * Space maps have 2 btrees:
  40. *
  41. * - One maps a uint64_t onto a struct index_entry. Which points to a
  42. * bitmap block, and has some details about how many free entries there
  43. * are etc.
  44. *
  45. * - The bitmap blocks have a header (for the checksum). Then the rest
  46. * of the block is pairs of bits. With the meaning being:
  47. *
  48. * 0 - ref count is 0
  49. * 1 - ref count is 1
  50. * 2 - ref count is 2
  51. * 3 - ref count is higher than 2
  52. *
  53. * - If the count is higher than 2 then the ref count is entered in a
  54. * second btree that directly maps the block_address to a uint32_t ref
  55. * count.
  56. *
  57. * The space map metadata variant doesn't have a bitmaps btree. Instead
  58. * it has one single blocks worth of index_entries. This avoids
  59. * recursive issues with the bitmap btree needing to allocate space in
  60. * order to insert. With a small data block size such as 64k the
  61. * metadata support data devices that are hundreds of terrabytes.
  62. *
  63. * The space maps allocate space linearly from front to back. Space that
  64. * is freed in a transaction is never recycled within that transaction.
  65. * To try and avoid fragmenting _free_ space the allocator always goes
  66. * back and fills in gaps.
  67. *
  68. * All metadata io is in THIN_METADATA_BLOCK_SIZE sized/aligned chunks
  69. * from the block manager.
  70. *--------------------------------------------------------------------------*/
  71. #define DM_MSG_PREFIX "thin metadata"
  72. #define THIN_SUPERBLOCK_MAGIC 27022010
  73. #define THIN_SUPERBLOCK_LOCATION 0
  74. #define THIN_VERSION 2
  75. #define SECTOR_TO_BLOCK_SHIFT 3
  76. /*
  77. * For btree insert:
  78. * 3 for btree insert +
  79. * 2 for btree lookup used within space map
  80. * For btree remove:
  81. * 2 for shadow spine +
  82. * 4 for rebalance 3 child node
  83. */
  84. #define THIN_MAX_CONCURRENT_LOCKS 6
  85. /* This should be plenty */
  86. #define SPACE_MAP_ROOT_SIZE 128
  87. /*
  88. * Little endian on-disk superblock and device details.
  89. */
  90. struct thin_disk_superblock {
  91. __le32 csum; /* Checksum of superblock except for this field. */
  92. __le32 flags;
  93. __le64 blocknr; /* This block number, dm_block_t. */
  94. __u8 uuid[16];
  95. __le64 magic;
  96. __le32 version;
  97. __le32 time;
  98. __le64 trans_id;
  99. /*
  100. * Root held by userspace transactions.
  101. */
  102. __le64 held_root;
  103. __u8 data_space_map_root[SPACE_MAP_ROOT_SIZE];
  104. __u8 metadata_space_map_root[SPACE_MAP_ROOT_SIZE];
  105. /*
  106. * 2-level btree mapping (dev_id, (dev block, time)) -> data block
  107. */
  108. __le64 data_mapping_root;
  109. /*
  110. * Device detail root mapping dev_id -> device_details
  111. */
  112. __le64 device_details_root;
  113. __le32 data_block_size; /* In 512-byte sectors. */
  114. __le32 metadata_block_size; /* In 512-byte sectors. */
  115. __le64 metadata_nr_blocks;
  116. __le32 compat_flags;
  117. __le32 compat_ro_flags;
  118. __le32 incompat_flags;
  119. } __packed;
  120. struct disk_device_details {
  121. __le64 mapped_blocks;
  122. __le64 transaction_id; /* When created. */
  123. __le32 creation_time;
  124. __le32 snapshotted_time;
  125. } __packed;
  126. struct dm_pool_metadata {
  127. struct hlist_node hash;
  128. struct block_device *bdev;
  129. struct dm_block_manager *bm;
  130. struct dm_space_map *metadata_sm;
  131. struct dm_space_map *data_sm;
  132. struct dm_transaction_manager *tm;
  133. struct dm_transaction_manager *nb_tm;
  134. /*
  135. * Two-level btree.
  136. * First level holds thin_dev_t.
  137. * Second level holds mappings.
  138. */
  139. struct dm_btree_info info;
  140. /*
  141. * Non-blocking version of the above.
  142. */
  143. struct dm_btree_info nb_info;
  144. /*
  145. * Just the top level for deleting whole devices.
  146. */
  147. struct dm_btree_info tl_info;
  148. /*
  149. * Just the bottom level for creating new devices.
  150. */
  151. struct dm_btree_info bl_info;
  152. /*
  153. * Describes the device details btree.
  154. */
  155. struct dm_btree_info details_info;
  156. struct rw_semaphore root_lock;
  157. uint32_t time;
  158. dm_block_t root;
  159. dm_block_t details_root;
  160. struct list_head thin_devices;
  161. uint64_t trans_id;
  162. unsigned long flags;
  163. sector_t data_block_size;
  164. /*
  165. * Set if a transaction has to be aborted but the attempt to roll back
  166. * to the previous (good) transaction failed. The only pool metadata
  167. * operation possible in this state is the closing of the device.
  168. */
  169. bool fail_io:1;
  170. /*
  171. * Reading the space map roots can fail, so we read it into these
  172. * buffers before the superblock is locked and updated.
  173. */
  174. __u8 data_space_map_root[SPACE_MAP_ROOT_SIZE];
  175. __u8 metadata_space_map_root[SPACE_MAP_ROOT_SIZE];
  176. };
  177. struct dm_thin_device {
  178. struct list_head list;
  179. struct dm_pool_metadata *pmd;
  180. dm_thin_id id;
  181. int open_count;
  182. bool changed:1;
  183. bool aborted_with_changes:1;
  184. uint64_t mapped_blocks;
  185. uint64_t transaction_id;
  186. uint32_t creation_time;
  187. uint32_t snapshotted_time;
  188. };
  189. /*----------------------------------------------------------------
  190. * superblock validator
  191. *--------------------------------------------------------------*/
  192. #define SUPERBLOCK_CSUM_XOR 160774
  193. static void sb_prepare_for_write(struct dm_block_validator *v,
  194. struct dm_block *b,
  195. size_t block_size)
  196. {
  197. struct thin_disk_superblock *disk_super = dm_block_data(b);
  198. disk_super->blocknr = cpu_to_le64(dm_block_location(b));
  199. disk_super->csum = cpu_to_le32(dm_bm_checksum(&disk_super->flags,
  200. block_size - sizeof(__le32),
  201. SUPERBLOCK_CSUM_XOR));
  202. }
  203. static int sb_check(struct dm_block_validator *v,
  204. struct dm_block *b,
  205. size_t block_size)
  206. {
  207. struct thin_disk_superblock *disk_super = dm_block_data(b);
  208. __le32 csum_le;
  209. if (dm_block_location(b) != le64_to_cpu(disk_super->blocknr)) {
  210. DMERR("sb_check failed: blocknr %llu: "
  211. "wanted %llu", le64_to_cpu(disk_super->blocknr),
  212. (unsigned long long)dm_block_location(b));
  213. return -ENOTBLK;
  214. }
  215. if (le64_to_cpu(disk_super->magic) != THIN_SUPERBLOCK_MAGIC) {
  216. DMERR("sb_check failed: magic %llu: "
  217. "wanted %llu", le64_to_cpu(disk_super->magic),
  218. (unsigned long long)THIN_SUPERBLOCK_MAGIC);
  219. return -EILSEQ;
  220. }
  221. csum_le = cpu_to_le32(dm_bm_checksum(&disk_super->flags,
  222. block_size - sizeof(__le32),
  223. SUPERBLOCK_CSUM_XOR));
  224. if (csum_le != disk_super->csum) {
  225. DMERR("sb_check failed: csum %u: wanted %u",
  226. le32_to_cpu(csum_le), le32_to_cpu(disk_super->csum));
  227. return -EILSEQ;
  228. }
  229. return 0;
  230. }
  231. static struct dm_block_validator sb_validator = {
  232. .name = "superblock",
  233. .prepare_for_write = sb_prepare_for_write,
  234. .check = sb_check
  235. };
  236. /*----------------------------------------------------------------
  237. * Methods for the btree value types
  238. *--------------------------------------------------------------*/
  239. static uint64_t pack_block_time(dm_block_t b, uint32_t t)
  240. {
  241. return (b << 24) | t;
  242. }
  243. static void unpack_block_time(uint64_t v, dm_block_t *b, uint32_t *t)
  244. {
  245. *b = v >> 24;
  246. *t = v & ((1 << 24) - 1);
  247. }
  248. static void data_block_inc(void *context, const void *value_le)
  249. {
  250. struct dm_space_map *sm = context;
  251. __le64 v_le;
  252. uint64_t b;
  253. uint32_t t;
  254. memcpy(&v_le, value_le, sizeof(v_le));
  255. unpack_block_time(le64_to_cpu(v_le), &b, &t);
  256. dm_sm_inc_block(sm, b);
  257. }
  258. static void data_block_dec(void *context, const void *value_le)
  259. {
  260. struct dm_space_map *sm = context;
  261. __le64 v_le;
  262. uint64_t b;
  263. uint32_t t;
  264. memcpy(&v_le, value_le, sizeof(v_le));
  265. unpack_block_time(le64_to_cpu(v_le), &b, &t);
  266. dm_sm_dec_block(sm, b);
  267. }
  268. static int data_block_equal(void *context, const void *value1_le, const void *value2_le)
  269. {
  270. __le64 v1_le, v2_le;
  271. uint64_t b1, b2;
  272. uint32_t t;
  273. memcpy(&v1_le, value1_le, sizeof(v1_le));
  274. memcpy(&v2_le, value2_le, sizeof(v2_le));
  275. unpack_block_time(le64_to_cpu(v1_le), &b1, &t);
  276. unpack_block_time(le64_to_cpu(v2_le), &b2, &t);
  277. return b1 == b2;
  278. }
  279. static void subtree_inc(void *context, const void *value)
  280. {
  281. struct dm_btree_info *info = context;
  282. __le64 root_le;
  283. uint64_t root;
  284. memcpy(&root_le, value, sizeof(root_le));
  285. root = le64_to_cpu(root_le);
  286. dm_tm_inc(info->tm, root);
  287. }
  288. static void subtree_dec(void *context, const void *value)
  289. {
  290. struct dm_btree_info *info = context;
  291. __le64 root_le;
  292. uint64_t root;
  293. memcpy(&root_le, value, sizeof(root_le));
  294. root = le64_to_cpu(root_le);
  295. if (dm_btree_del(info, root))
  296. DMERR("btree delete failed");
  297. }
  298. static int subtree_equal(void *context, const void *value1_le, const void *value2_le)
  299. {
  300. __le64 v1_le, v2_le;
  301. memcpy(&v1_le, value1_le, sizeof(v1_le));
  302. memcpy(&v2_le, value2_le, sizeof(v2_le));
  303. return v1_le == v2_le;
  304. }
  305. /*----------------------------------------------------------------*/
  306. static int superblock_lock_zero(struct dm_pool_metadata *pmd,
  307. struct dm_block **sblock)
  308. {
  309. return dm_bm_write_lock_zero(pmd->bm, THIN_SUPERBLOCK_LOCATION,
  310. &sb_validator, sblock);
  311. }
  312. static int superblock_lock(struct dm_pool_metadata *pmd,
  313. struct dm_block **sblock)
  314. {
  315. return dm_bm_write_lock(pmd->bm, THIN_SUPERBLOCK_LOCATION,
  316. &sb_validator, sblock);
  317. }
  318. static int __superblock_all_zeroes(struct dm_block_manager *bm, int *result)
  319. {
  320. int r;
  321. unsigned i;
  322. struct dm_block *b;
  323. __le64 *data_le, zero = cpu_to_le64(0);
  324. unsigned block_size = dm_bm_block_size(bm) / sizeof(__le64);
  325. /*
  326. * We can't use a validator here - it may be all zeroes.
  327. */
  328. r = dm_bm_read_lock(bm, THIN_SUPERBLOCK_LOCATION, NULL, &b);
  329. if (r)
  330. return r;
  331. data_le = dm_block_data(b);
  332. *result = 1;
  333. for (i = 0; i < block_size; i++) {
  334. if (data_le[i] != zero) {
  335. *result = 0;
  336. break;
  337. }
  338. }
  339. dm_bm_unlock(b);
  340. return 0;
  341. }
  342. static void __setup_btree_details(struct dm_pool_metadata *pmd)
  343. {
  344. pmd->info.tm = pmd->tm;
  345. pmd->info.levels = 2;
  346. pmd->info.value_type.context = pmd->data_sm;
  347. pmd->info.value_type.size = sizeof(__le64);
  348. pmd->info.value_type.inc = data_block_inc;
  349. pmd->info.value_type.dec = data_block_dec;
  350. pmd->info.value_type.equal = data_block_equal;
  351. memcpy(&pmd->nb_info, &pmd->info, sizeof(pmd->nb_info));
  352. pmd->nb_info.tm = pmd->nb_tm;
  353. pmd->tl_info.tm = pmd->tm;
  354. pmd->tl_info.levels = 1;
  355. pmd->tl_info.value_type.context = &pmd->bl_info;
  356. pmd->tl_info.value_type.size = sizeof(__le64);
  357. pmd->tl_info.value_type.inc = subtree_inc;
  358. pmd->tl_info.value_type.dec = subtree_dec;
  359. pmd->tl_info.value_type.equal = subtree_equal;
  360. pmd->bl_info.tm = pmd->tm;
  361. pmd->bl_info.levels = 1;
  362. pmd->bl_info.value_type.context = pmd->data_sm;
  363. pmd->bl_info.value_type.size = sizeof(__le64);
  364. pmd->bl_info.value_type.inc = data_block_inc;
  365. pmd->bl_info.value_type.dec = data_block_dec;
  366. pmd->bl_info.value_type.equal = data_block_equal;
  367. pmd->details_info.tm = pmd->tm;
  368. pmd->details_info.levels = 1;
  369. pmd->details_info.value_type.context = NULL;
  370. pmd->details_info.value_type.size = sizeof(struct disk_device_details);
  371. pmd->details_info.value_type.inc = NULL;
  372. pmd->details_info.value_type.dec = NULL;
  373. pmd->details_info.value_type.equal = NULL;
  374. }
  375. static int save_sm_roots(struct dm_pool_metadata *pmd)
  376. {
  377. int r;
  378. size_t len;
  379. r = dm_sm_root_size(pmd->metadata_sm, &len);
  380. if (r < 0)
  381. return r;
  382. r = dm_sm_copy_root(pmd->metadata_sm, &pmd->metadata_space_map_root, len);
  383. if (r < 0)
  384. return r;
  385. r = dm_sm_root_size(pmd->data_sm, &len);
  386. if (r < 0)
  387. return r;
  388. return dm_sm_copy_root(pmd->data_sm, &pmd->data_space_map_root, len);
  389. }
  390. static void copy_sm_roots(struct dm_pool_metadata *pmd,
  391. struct thin_disk_superblock *disk)
  392. {
  393. memcpy(&disk->metadata_space_map_root,
  394. &pmd->metadata_space_map_root,
  395. sizeof(pmd->metadata_space_map_root));
  396. memcpy(&disk->data_space_map_root,
  397. &pmd->data_space_map_root,
  398. sizeof(pmd->data_space_map_root));
  399. }
  400. static int __write_initial_superblock(struct dm_pool_metadata *pmd)
  401. {
  402. int r;
  403. struct dm_block *sblock;
  404. struct thin_disk_superblock *disk_super;
  405. sector_t bdev_size = i_size_read(pmd->bdev->bd_inode) >> SECTOR_SHIFT;
  406. if (bdev_size > THIN_METADATA_MAX_SECTORS)
  407. bdev_size = THIN_METADATA_MAX_SECTORS;
  408. r = dm_sm_commit(pmd->data_sm);
  409. if (r < 0)
  410. return r;
  411. r = dm_tm_pre_commit(pmd->tm);
  412. if (r < 0)
  413. return r;
  414. r = save_sm_roots(pmd);
  415. if (r < 0)
  416. return r;
  417. r = superblock_lock_zero(pmd, &sblock);
  418. if (r)
  419. return r;
  420. disk_super = dm_block_data(sblock);
  421. disk_super->flags = 0;
  422. memset(disk_super->uuid, 0, sizeof(disk_super->uuid));
  423. disk_super->magic = cpu_to_le64(THIN_SUPERBLOCK_MAGIC);
  424. disk_super->version = cpu_to_le32(THIN_VERSION);
  425. disk_super->time = 0;
  426. disk_super->trans_id = 0;
  427. disk_super->held_root = 0;
  428. copy_sm_roots(pmd, disk_super);
  429. disk_super->data_mapping_root = cpu_to_le64(pmd->root);
  430. disk_super->device_details_root = cpu_to_le64(pmd->details_root);
  431. disk_super->metadata_block_size = cpu_to_le32(THIN_METADATA_BLOCK_SIZE);
  432. disk_super->metadata_nr_blocks = cpu_to_le64(bdev_size >> SECTOR_TO_BLOCK_SHIFT);
  433. disk_super->data_block_size = cpu_to_le32(pmd->data_block_size);
  434. return dm_tm_commit(pmd->tm, sblock);
  435. }
  436. static int __format_metadata(struct dm_pool_metadata *pmd)
  437. {
  438. int r;
  439. r = dm_tm_create_with_sm(pmd->bm, THIN_SUPERBLOCK_LOCATION,
  440. &pmd->tm, &pmd->metadata_sm);
  441. if (r < 0) {
  442. DMERR("tm_create_with_sm failed");
  443. return r;
  444. }
  445. pmd->data_sm = dm_sm_disk_create(pmd->tm, 0);
  446. if (IS_ERR(pmd->data_sm)) {
  447. DMERR("sm_disk_create failed");
  448. r = PTR_ERR(pmd->data_sm);
  449. goto bad_cleanup_tm;
  450. }
  451. pmd->nb_tm = dm_tm_create_non_blocking_clone(pmd->tm);
  452. if (!pmd->nb_tm) {
  453. DMERR("could not create non-blocking clone tm");
  454. r = -ENOMEM;
  455. goto bad_cleanup_data_sm;
  456. }
  457. __setup_btree_details(pmd);
  458. r = dm_btree_empty(&pmd->info, &pmd->root);
  459. if (r < 0)
  460. goto bad_cleanup_nb_tm;
  461. r = dm_btree_empty(&pmd->details_info, &pmd->details_root);
  462. if (r < 0) {
  463. DMERR("couldn't create devices root");
  464. goto bad_cleanup_nb_tm;
  465. }
  466. r = __write_initial_superblock(pmd);
  467. if (r)
  468. goto bad_cleanup_nb_tm;
  469. return 0;
  470. bad_cleanup_nb_tm:
  471. dm_tm_destroy(pmd->nb_tm);
  472. bad_cleanup_data_sm:
  473. dm_sm_destroy(pmd->data_sm);
  474. bad_cleanup_tm:
  475. dm_tm_destroy(pmd->tm);
  476. dm_sm_destroy(pmd->metadata_sm);
  477. return r;
  478. }
  479. static int __check_incompat_features(struct thin_disk_superblock *disk_super,
  480. struct dm_pool_metadata *pmd)
  481. {
  482. uint32_t features;
  483. features = le32_to_cpu(disk_super->incompat_flags) & ~THIN_FEATURE_INCOMPAT_SUPP;
  484. if (features) {
  485. DMERR("could not access metadata due to unsupported optional features (%lx).",
  486. (unsigned long)features);
  487. return -EINVAL;
  488. }
  489. /*
  490. * Check for read-only metadata to skip the following RDWR checks.
  491. */
  492. if (get_disk_ro(pmd->bdev->bd_disk))
  493. return 0;
  494. features = le32_to_cpu(disk_super->compat_ro_flags) & ~THIN_FEATURE_COMPAT_RO_SUPP;
  495. if (features) {
  496. DMERR("could not access metadata RDWR due to unsupported optional features (%lx).",
  497. (unsigned long)features);
  498. return -EINVAL;
  499. }
  500. return 0;
  501. }
  502. static int __open_metadata(struct dm_pool_metadata *pmd)
  503. {
  504. int r;
  505. struct dm_block *sblock;
  506. struct thin_disk_superblock *disk_super;
  507. r = dm_bm_read_lock(pmd->bm, THIN_SUPERBLOCK_LOCATION,
  508. &sb_validator, &sblock);
  509. if (r < 0) {
  510. DMERR("couldn't read superblock");
  511. return r;
  512. }
  513. disk_super = dm_block_data(sblock);
  514. /* Verify the data block size hasn't changed */
  515. if (le32_to_cpu(disk_super->data_block_size) != pmd->data_block_size) {
  516. DMERR("changing the data block size (from %u to %llu) is not supported",
  517. le32_to_cpu(disk_super->data_block_size),
  518. (unsigned long long)pmd->data_block_size);
  519. r = -EINVAL;
  520. goto bad_unlock_sblock;
  521. }
  522. r = __check_incompat_features(disk_super, pmd);
  523. if (r < 0)
  524. goto bad_unlock_sblock;
  525. r = dm_tm_open_with_sm(pmd->bm, THIN_SUPERBLOCK_LOCATION,
  526. disk_super->metadata_space_map_root,
  527. sizeof(disk_super->metadata_space_map_root),
  528. &pmd->tm, &pmd->metadata_sm);
  529. if (r < 0) {
  530. DMERR("tm_open_with_sm failed");
  531. goto bad_unlock_sblock;
  532. }
  533. pmd->data_sm = dm_sm_disk_open(pmd->tm, disk_super->data_space_map_root,
  534. sizeof(disk_super->data_space_map_root));
  535. if (IS_ERR(pmd->data_sm)) {
  536. DMERR("sm_disk_open failed");
  537. r = PTR_ERR(pmd->data_sm);
  538. goto bad_cleanup_tm;
  539. }
  540. pmd->nb_tm = dm_tm_create_non_blocking_clone(pmd->tm);
  541. if (!pmd->nb_tm) {
  542. DMERR("could not create non-blocking clone tm");
  543. r = -ENOMEM;
  544. goto bad_cleanup_data_sm;
  545. }
  546. __setup_btree_details(pmd);
  547. dm_bm_unlock(sblock);
  548. return 0;
  549. bad_cleanup_data_sm:
  550. dm_sm_destroy(pmd->data_sm);
  551. bad_cleanup_tm:
  552. dm_tm_destroy(pmd->tm);
  553. dm_sm_destroy(pmd->metadata_sm);
  554. bad_unlock_sblock:
  555. dm_bm_unlock(sblock);
  556. return r;
  557. }
  558. static int __open_or_format_metadata(struct dm_pool_metadata *pmd, bool format_device)
  559. {
  560. int r, unformatted;
  561. r = __superblock_all_zeroes(pmd->bm, &unformatted);
  562. if (r)
  563. return r;
  564. if (unformatted)
  565. return format_device ? __format_metadata(pmd) : -EPERM;
  566. return __open_metadata(pmd);
  567. }
  568. static int __create_persistent_data_objects(struct dm_pool_metadata *pmd, bool format_device)
  569. {
  570. int r;
  571. pmd->bm = dm_block_manager_create(pmd->bdev, THIN_METADATA_BLOCK_SIZE << SECTOR_SHIFT,
  572. THIN_MAX_CONCURRENT_LOCKS);
  573. if (IS_ERR(pmd->bm)) {
  574. DMERR("could not create block manager");
  575. return PTR_ERR(pmd->bm);
  576. }
  577. r = __open_or_format_metadata(pmd, format_device);
  578. if (r)
  579. dm_block_manager_destroy(pmd->bm);
  580. return r;
  581. }
  582. static void __destroy_persistent_data_objects(struct dm_pool_metadata *pmd)
  583. {
  584. dm_sm_destroy(pmd->data_sm);
  585. dm_sm_destroy(pmd->metadata_sm);
  586. dm_tm_destroy(pmd->nb_tm);
  587. dm_tm_destroy(pmd->tm);
  588. dm_block_manager_destroy(pmd->bm);
  589. }
  590. static int __begin_transaction(struct dm_pool_metadata *pmd)
  591. {
  592. int r;
  593. struct thin_disk_superblock *disk_super;
  594. struct dm_block *sblock;
  595. /*
  596. * We re-read the superblock every time. Shouldn't need to do this
  597. * really.
  598. */
  599. r = dm_bm_read_lock(pmd->bm, THIN_SUPERBLOCK_LOCATION,
  600. &sb_validator, &sblock);
  601. if (r)
  602. return r;
  603. disk_super = dm_block_data(sblock);
  604. pmd->time = le32_to_cpu(disk_super->time);
  605. pmd->root = le64_to_cpu(disk_super->data_mapping_root);
  606. pmd->details_root = le64_to_cpu(disk_super->device_details_root);
  607. pmd->trans_id = le64_to_cpu(disk_super->trans_id);
  608. pmd->flags = le32_to_cpu(disk_super->flags);
  609. pmd->data_block_size = le32_to_cpu(disk_super->data_block_size);
  610. dm_bm_unlock(sblock);
  611. return 0;
  612. }
  613. static int __write_changed_details(struct dm_pool_metadata *pmd)
  614. {
  615. int r;
  616. struct dm_thin_device *td, *tmp;
  617. struct disk_device_details details;
  618. uint64_t key;
  619. list_for_each_entry_safe(td, tmp, &pmd->thin_devices, list) {
  620. if (!td->changed)
  621. continue;
  622. key = td->id;
  623. details.mapped_blocks = cpu_to_le64(td->mapped_blocks);
  624. details.transaction_id = cpu_to_le64(td->transaction_id);
  625. details.creation_time = cpu_to_le32(td->creation_time);
  626. details.snapshotted_time = cpu_to_le32(td->snapshotted_time);
  627. __dm_bless_for_disk(&details);
  628. r = dm_btree_insert(&pmd->details_info, pmd->details_root,
  629. &key, &details, &pmd->details_root);
  630. if (r)
  631. return r;
  632. if (td->open_count)
  633. td->changed = 0;
  634. else {
  635. list_del(&td->list);
  636. kfree(td);
  637. }
  638. }
  639. return 0;
  640. }
  641. static int __commit_transaction(struct dm_pool_metadata *pmd)
  642. {
  643. int r;
  644. size_t metadata_len, data_len;
  645. struct thin_disk_superblock *disk_super;
  646. struct dm_block *sblock;
  647. /*
  648. * We need to know if the thin_disk_superblock exceeds a 512-byte sector.
  649. */
  650. BUILD_BUG_ON(sizeof(struct thin_disk_superblock) > 512);
  651. r = __write_changed_details(pmd);
  652. if (r < 0)
  653. return r;
  654. r = dm_sm_commit(pmd->data_sm);
  655. if (r < 0)
  656. return r;
  657. r = dm_tm_pre_commit(pmd->tm);
  658. if (r < 0)
  659. return r;
  660. r = dm_sm_root_size(pmd->metadata_sm, &metadata_len);
  661. if (r < 0)
  662. return r;
  663. r = dm_sm_root_size(pmd->data_sm, &data_len);
  664. if (r < 0)
  665. return r;
  666. r = save_sm_roots(pmd);
  667. if (r < 0)
  668. return r;
  669. r = superblock_lock(pmd, &sblock);
  670. if (r)
  671. return r;
  672. disk_super = dm_block_data(sblock);
  673. disk_super->time = cpu_to_le32(pmd->time);
  674. disk_super->data_mapping_root = cpu_to_le64(pmd->root);
  675. disk_super->device_details_root = cpu_to_le64(pmd->details_root);
  676. disk_super->trans_id = cpu_to_le64(pmd->trans_id);
  677. disk_super->flags = cpu_to_le32(pmd->flags);
  678. copy_sm_roots(pmd, disk_super);
  679. return dm_tm_commit(pmd->tm, sblock);
  680. }
  681. struct dm_pool_metadata *dm_pool_metadata_open(struct block_device *bdev,
  682. sector_t data_block_size,
  683. bool format_device)
  684. {
  685. int r;
  686. struct dm_pool_metadata *pmd;
  687. pmd = kmalloc(sizeof(*pmd), GFP_KERNEL);
  688. if (!pmd) {
  689. DMERR("could not allocate metadata struct");
  690. return ERR_PTR(-ENOMEM);
  691. }
  692. init_rwsem(&pmd->root_lock);
  693. pmd->time = 0;
  694. INIT_LIST_HEAD(&pmd->thin_devices);
  695. pmd->fail_io = false;
  696. pmd->bdev = bdev;
  697. pmd->data_block_size = data_block_size;
  698. r = __create_persistent_data_objects(pmd, format_device);
  699. if (r) {
  700. kfree(pmd);
  701. return ERR_PTR(r);
  702. }
  703. r = __begin_transaction(pmd);
  704. if (r < 0) {
  705. if (dm_pool_metadata_close(pmd) < 0)
  706. DMWARN("%s: dm_pool_metadata_close() failed.", __func__);
  707. return ERR_PTR(r);
  708. }
  709. return pmd;
  710. }
  711. int dm_pool_metadata_close(struct dm_pool_metadata *pmd)
  712. {
  713. int r;
  714. unsigned open_devices = 0;
  715. struct dm_thin_device *td, *tmp;
  716. down_read(&pmd->root_lock);
  717. list_for_each_entry_safe(td, tmp, &pmd->thin_devices, list) {
  718. if (td->open_count)
  719. open_devices++;
  720. else {
  721. list_del(&td->list);
  722. kfree(td);
  723. }
  724. }
  725. up_read(&pmd->root_lock);
  726. if (open_devices) {
  727. DMERR("attempt to close pmd when %u device(s) are still open",
  728. open_devices);
  729. return -EBUSY;
  730. }
  731. if (!dm_bm_is_read_only(pmd->bm) && !pmd->fail_io) {
  732. r = __commit_transaction(pmd);
  733. if (r < 0)
  734. DMWARN("%s: __commit_transaction() failed, error = %d",
  735. __func__, r);
  736. }
  737. if (!pmd->fail_io)
  738. __destroy_persistent_data_objects(pmd);
  739. kfree(pmd);
  740. return 0;
  741. }
  742. /*
  743. * __open_device: Returns @td corresponding to device with id @dev,
  744. * creating it if @create is set and incrementing @td->open_count.
  745. * On failure, @td is undefined.
  746. */
  747. static int __open_device(struct dm_pool_metadata *pmd,
  748. dm_thin_id dev, int create,
  749. struct dm_thin_device **td)
  750. {
  751. int r, changed = 0;
  752. struct dm_thin_device *td2;
  753. uint64_t key = dev;
  754. struct disk_device_details details_le;
  755. /*
  756. * If the device is already open, return it.
  757. */
  758. list_for_each_entry(td2, &pmd->thin_devices, list)
  759. if (td2->id == dev) {
  760. /*
  761. * May not create an already-open device.
  762. */
  763. if (create)
  764. return -EEXIST;
  765. td2->open_count++;
  766. *td = td2;
  767. return 0;
  768. }
  769. /*
  770. * Check the device exists.
  771. */
  772. r = dm_btree_lookup(&pmd->details_info, pmd->details_root,
  773. &key, &details_le);
  774. if (r) {
  775. if (r != -ENODATA || !create)
  776. return r;
  777. /*
  778. * Create new device.
  779. */
  780. changed = 1;
  781. details_le.mapped_blocks = 0;
  782. details_le.transaction_id = cpu_to_le64(pmd->trans_id);
  783. details_le.creation_time = cpu_to_le32(pmd->time);
  784. details_le.snapshotted_time = cpu_to_le32(pmd->time);
  785. }
  786. *td = kmalloc(sizeof(**td), GFP_NOIO);
  787. if (!*td)
  788. return -ENOMEM;
  789. (*td)->pmd = pmd;
  790. (*td)->id = dev;
  791. (*td)->open_count = 1;
  792. (*td)->changed = changed;
  793. (*td)->aborted_with_changes = false;
  794. (*td)->mapped_blocks = le64_to_cpu(details_le.mapped_blocks);
  795. (*td)->transaction_id = le64_to_cpu(details_le.transaction_id);
  796. (*td)->creation_time = le32_to_cpu(details_le.creation_time);
  797. (*td)->snapshotted_time = le32_to_cpu(details_le.snapshotted_time);
  798. list_add(&(*td)->list, &pmd->thin_devices);
  799. return 0;
  800. }
  801. static void __close_device(struct dm_thin_device *td)
  802. {
  803. --td->open_count;
  804. }
  805. static int __create_thin(struct dm_pool_metadata *pmd,
  806. dm_thin_id dev)
  807. {
  808. int r;
  809. dm_block_t dev_root;
  810. uint64_t key = dev;
  811. struct disk_device_details details_le;
  812. struct dm_thin_device *td;
  813. __le64 value;
  814. r = dm_btree_lookup(&pmd->details_info, pmd->details_root,
  815. &key, &details_le);
  816. if (!r)
  817. return -EEXIST;
  818. /*
  819. * Create an empty btree for the mappings.
  820. */
  821. r = dm_btree_empty(&pmd->bl_info, &dev_root);
  822. if (r)
  823. return r;
  824. /*
  825. * Insert it into the main mapping tree.
  826. */
  827. value = cpu_to_le64(dev_root);
  828. __dm_bless_for_disk(&value);
  829. r = dm_btree_insert(&pmd->tl_info, pmd->root, &key, &value, &pmd->root);
  830. if (r) {
  831. dm_btree_del(&pmd->bl_info, dev_root);
  832. return r;
  833. }
  834. r = __open_device(pmd, dev, 1, &td);
  835. if (r) {
  836. dm_btree_remove(&pmd->tl_info, pmd->root, &key, &pmd->root);
  837. dm_btree_del(&pmd->bl_info, dev_root);
  838. return r;
  839. }
  840. __close_device(td);
  841. return r;
  842. }
  843. int dm_pool_create_thin(struct dm_pool_metadata *pmd, dm_thin_id dev)
  844. {
  845. int r = -EINVAL;
  846. down_write(&pmd->root_lock);
  847. if (!pmd->fail_io)
  848. r = __create_thin(pmd, dev);
  849. up_write(&pmd->root_lock);
  850. return r;
  851. }
  852. static int __set_snapshot_details(struct dm_pool_metadata *pmd,
  853. struct dm_thin_device *snap,
  854. dm_thin_id origin, uint32_t time)
  855. {
  856. int r;
  857. struct dm_thin_device *td;
  858. r = __open_device(pmd, origin, 0, &td);
  859. if (r)
  860. return r;
  861. td->changed = 1;
  862. td->snapshotted_time = time;
  863. snap->mapped_blocks = td->mapped_blocks;
  864. snap->snapshotted_time = time;
  865. __close_device(td);
  866. return 0;
  867. }
  868. static int __create_snap(struct dm_pool_metadata *pmd,
  869. dm_thin_id dev, dm_thin_id origin)
  870. {
  871. int r;
  872. dm_block_t origin_root;
  873. uint64_t key = origin, dev_key = dev;
  874. struct dm_thin_device *td;
  875. struct disk_device_details details_le;
  876. __le64 value;
  877. /* check this device is unused */
  878. r = dm_btree_lookup(&pmd->details_info, pmd->details_root,
  879. &dev_key, &details_le);
  880. if (!r)
  881. return -EEXIST;
  882. /* find the mapping tree for the origin */
  883. r = dm_btree_lookup(&pmd->tl_info, pmd->root, &key, &value);
  884. if (r)
  885. return r;
  886. origin_root = le64_to_cpu(value);
  887. /* clone the origin, an inc will do */
  888. dm_tm_inc(pmd->tm, origin_root);
  889. /* insert into the main mapping tree */
  890. value = cpu_to_le64(origin_root);
  891. __dm_bless_for_disk(&value);
  892. key = dev;
  893. r = dm_btree_insert(&pmd->tl_info, pmd->root, &key, &value, &pmd->root);
  894. if (r) {
  895. dm_tm_dec(pmd->tm, origin_root);
  896. return r;
  897. }
  898. pmd->time++;
  899. r = __open_device(pmd, dev, 1, &td);
  900. if (r)
  901. goto bad;
  902. r = __set_snapshot_details(pmd, td, origin, pmd->time);
  903. __close_device(td);
  904. if (r)
  905. goto bad;
  906. return 0;
  907. bad:
  908. dm_btree_remove(&pmd->tl_info, pmd->root, &key, &pmd->root);
  909. dm_btree_remove(&pmd->details_info, pmd->details_root,
  910. &key, &pmd->details_root);
  911. return r;
  912. }
  913. int dm_pool_create_snap(struct dm_pool_metadata *pmd,
  914. dm_thin_id dev,
  915. dm_thin_id origin)
  916. {
  917. int r = -EINVAL;
  918. down_write(&pmd->root_lock);
  919. if (!pmd->fail_io)
  920. r = __create_snap(pmd, dev, origin);
  921. up_write(&pmd->root_lock);
  922. return r;
  923. }
  924. static int __delete_device(struct dm_pool_metadata *pmd, dm_thin_id dev)
  925. {
  926. int r;
  927. uint64_t key = dev;
  928. struct dm_thin_device *td;
  929. /* TODO: failure should mark the transaction invalid */
  930. r = __open_device(pmd, dev, 0, &td);
  931. if (r)
  932. return r;
  933. if (td->open_count > 1) {
  934. __close_device(td);
  935. return -EBUSY;
  936. }
  937. list_del(&td->list);
  938. kfree(td);
  939. r = dm_btree_remove(&pmd->details_info, pmd->details_root,
  940. &key, &pmd->details_root);
  941. if (r)
  942. return r;
  943. r = dm_btree_remove(&pmd->tl_info, pmd->root, &key, &pmd->root);
  944. if (r)
  945. return r;
  946. return 0;
  947. }
  948. int dm_pool_delete_thin_device(struct dm_pool_metadata *pmd,
  949. dm_thin_id dev)
  950. {
  951. int r = -EINVAL;
  952. down_write(&pmd->root_lock);
  953. if (!pmd->fail_io)
  954. r = __delete_device(pmd, dev);
  955. up_write(&pmd->root_lock);
  956. return r;
  957. }
  958. int dm_pool_set_metadata_transaction_id(struct dm_pool_metadata *pmd,
  959. uint64_t current_id,
  960. uint64_t new_id)
  961. {
  962. int r = -EINVAL;
  963. down_write(&pmd->root_lock);
  964. if (pmd->fail_io)
  965. goto out;
  966. if (pmd->trans_id != current_id) {
  967. DMERR("mismatched transaction id");
  968. goto out;
  969. }
  970. pmd->trans_id = new_id;
  971. r = 0;
  972. out:
  973. up_write(&pmd->root_lock);
  974. return r;
  975. }
  976. int dm_pool_get_metadata_transaction_id(struct dm_pool_metadata *pmd,
  977. uint64_t *result)
  978. {
  979. int r = -EINVAL;
  980. down_read(&pmd->root_lock);
  981. if (!pmd->fail_io) {
  982. *result = pmd->trans_id;
  983. r = 0;
  984. }
  985. up_read(&pmd->root_lock);
  986. return r;
  987. }
  988. static int __reserve_metadata_snap(struct dm_pool_metadata *pmd)
  989. {
  990. int r, inc;
  991. struct thin_disk_superblock *disk_super;
  992. struct dm_block *copy, *sblock;
  993. dm_block_t held_root;
  994. /*
  995. * We commit to ensure the btree roots which we increment in a
  996. * moment are up to date.
  997. */
  998. __commit_transaction(pmd);
  999. /*
  1000. * Copy the superblock.
  1001. */
  1002. dm_sm_inc_block(pmd->metadata_sm, THIN_SUPERBLOCK_LOCATION);
  1003. r = dm_tm_shadow_block(pmd->tm, THIN_SUPERBLOCK_LOCATION,
  1004. &sb_validator, &copy, &inc);
  1005. if (r)
  1006. return r;
  1007. BUG_ON(!inc);
  1008. held_root = dm_block_location(copy);
  1009. disk_super = dm_block_data(copy);
  1010. if (le64_to_cpu(disk_super->held_root)) {
  1011. DMWARN("Pool metadata snapshot already exists: release this before taking another.");
  1012. dm_tm_dec(pmd->tm, held_root);
  1013. dm_tm_unlock(pmd->tm, copy);
  1014. return -EBUSY;
  1015. }
  1016. /*
  1017. * Wipe the spacemap since we're not publishing this.
  1018. */
  1019. memset(&disk_super->data_space_map_root, 0,
  1020. sizeof(disk_super->data_space_map_root));
  1021. memset(&disk_super->metadata_space_map_root, 0,
  1022. sizeof(disk_super->metadata_space_map_root));
  1023. /*
  1024. * Increment the data structures that need to be preserved.
  1025. */
  1026. dm_tm_inc(pmd->tm, le64_to_cpu(disk_super->data_mapping_root));
  1027. dm_tm_inc(pmd->tm, le64_to_cpu(disk_super->device_details_root));
  1028. dm_tm_unlock(pmd->tm, copy);
  1029. /*
  1030. * Write the held root into the superblock.
  1031. */
  1032. r = superblock_lock(pmd, &sblock);
  1033. if (r) {
  1034. dm_tm_dec(pmd->tm, held_root);
  1035. return r;
  1036. }
  1037. disk_super = dm_block_data(sblock);
  1038. disk_super->held_root = cpu_to_le64(held_root);
  1039. dm_bm_unlock(sblock);
  1040. return 0;
  1041. }
  1042. int dm_pool_reserve_metadata_snap(struct dm_pool_metadata *pmd)
  1043. {
  1044. int r = -EINVAL;
  1045. down_write(&pmd->root_lock);
  1046. if (!pmd->fail_io)
  1047. r = __reserve_metadata_snap(pmd);
  1048. up_write(&pmd->root_lock);
  1049. return r;
  1050. }
  1051. static int __release_metadata_snap(struct dm_pool_metadata *pmd)
  1052. {
  1053. int r;
  1054. struct thin_disk_superblock *disk_super;
  1055. struct dm_block *sblock, *copy;
  1056. dm_block_t held_root;
  1057. r = superblock_lock(pmd, &sblock);
  1058. if (r)
  1059. return r;
  1060. disk_super = dm_block_data(sblock);
  1061. held_root = le64_to_cpu(disk_super->held_root);
  1062. disk_super->held_root = cpu_to_le64(0);
  1063. dm_bm_unlock(sblock);
  1064. if (!held_root) {
  1065. DMWARN("No pool metadata snapshot found: nothing to release.");
  1066. return -EINVAL;
  1067. }
  1068. r = dm_tm_read_lock(pmd->tm, held_root, &sb_validator, &copy);
  1069. if (r)
  1070. return r;
  1071. disk_super = dm_block_data(copy);
  1072. dm_btree_del(&pmd->info, le64_to_cpu(disk_super->data_mapping_root));
  1073. dm_btree_del(&pmd->details_info, le64_to_cpu(disk_super->device_details_root));
  1074. dm_sm_dec_block(pmd->metadata_sm, held_root);
  1075. dm_tm_unlock(pmd->tm, copy);
  1076. return 0;
  1077. }
  1078. int dm_pool_release_metadata_snap(struct dm_pool_metadata *pmd)
  1079. {
  1080. int r = -EINVAL;
  1081. down_write(&pmd->root_lock);
  1082. if (!pmd->fail_io)
  1083. r = __release_metadata_snap(pmd);
  1084. up_write(&pmd->root_lock);
  1085. return r;
  1086. }
  1087. static int __get_metadata_snap(struct dm_pool_metadata *pmd,
  1088. dm_block_t *result)
  1089. {
  1090. int r;
  1091. struct thin_disk_superblock *disk_super;
  1092. struct dm_block *sblock;
  1093. r = dm_bm_read_lock(pmd->bm, THIN_SUPERBLOCK_LOCATION,
  1094. &sb_validator, &sblock);
  1095. if (r)
  1096. return r;
  1097. disk_super = dm_block_data(sblock);
  1098. *result = le64_to_cpu(disk_super->held_root);
  1099. dm_bm_unlock(sblock);
  1100. return 0;
  1101. }
  1102. int dm_pool_get_metadata_snap(struct dm_pool_metadata *pmd,
  1103. dm_block_t *result)
  1104. {
  1105. int r = -EINVAL;
  1106. down_read(&pmd->root_lock);
  1107. if (!pmd->fail_io)
  1108. r = __get_metadata_snap(pmd, result);
  1109. up_read(&pmd->root_lock);
  1110. return r;
  1111. }
  1112. int dm_pool_open_thin_device(struct dm_pool_metadata *pmd, dm_thin_id dev,
  1113. struct dm_thin_device **td)
  1114. {
  1115. int r = -EINVAL;
  1116. down_write(&pmd->root_lock);
  1117. if (!pmd->fail_io)
  1118. r = __open_device(pmd, dev, 0, td);
  1119. up_write(&pmd->root_lock);
  1120. return r;
  1121. }
  1122. int dm_pool_close_thin_device(struct dm_thin_device *td)
  1123. {
  1124. down_write(&td->pmd->root_lock);
  1125. __close_device(td);
  1126. up_write(&td->pmd->root_lock);
  1127. return 0;
  1128. }
  1129. dm_thin_id dm_thin_dev_id(struct dm_thin_device *td)
  1130. {
  1131. return td->id;
  1132. }
  1133. /*
  1134. * Check whether @time (of block creation) is older than @td's last snapshot.
  1135. * If so then the associated block is shared with the last snapshot device.
  1136. * Any block on a device created *after* the device last got snapshotted is
  1137. * necessarily not shared.
  1138. */
  1139. static bool __snapshotted_since(struct dm_thin_device *td, uint32_t time)
  1140. {
  1141. return td->snapshotted_time > time;
  1142. }
  1143. static void unpack_lookup_result(struct dm_thin_device *td, __le64 value,
  1144. struct dm_thin_lookup_result *result)
  1145. {
  1146. uint64_t block_time = 0;
  1147. dm_block_t exception_block;
  1148. uint32_t exception_time;
  1149. block_time = le64_to_cpu(value);
  1150. unpack_block_time(block_time, &exception_block, &exception_time);
  1151. result->block = exception_block;
  1152. result->shared = __snapshotted_since(td, exception_time);
  1153. }
  1154. static int __find_block(struct dm_thin_device *td, dm_block_t block,
  1155. int can_issue_io, struct dm_thin_lookup_result *result)
  1156. {
  1157. int r;
  1158. __le64 value;
  1159. struct dm_pool_metadata *pmd = td->pmd;
  1160. dm_block_t keys[2] = { td->id, block };
  1161. struct dm_btree_info *info;
  1162. if (can_issue_io) {
  1163. info = &pmd->info;
  1164. } else
  1165. info = &pmd->nb_info;
  1166. r = dm_btree_lookup(info, pmd->root, keys, &value);
  1167. if (!r)
  1168. unpack_lookup_result(td, value, result);
  1169. return r;
  1170. }
  1171. int dm_thin_find_block(struct dm_thin_device *td, dm_block_t block,
  1172. int can_issue_io, struct dm_thin_lookup_result *result)
  1173. {
  1174. int r;
  1175. struct dm_pool_metadata *pmd = td->pmd;
  1176. down_read(&pmd->root_lock);
  1177. if (pmd->fail_io) {
  1178. up_read(&pmd->root_lock);
  1179. return -EINVAL;
  1180. }
  1181. r = __find_block(td, block, can_issue_io, result);
  1182. up_read(&pmd->root_lock);
  1183. return r;
  1184. }
  1185. static int __find_next_mapped_block(struct dm_thin_device *td, dm_block_t block,
  1186. dm_block_t *vblock,
  1187. struct dm_thin_lookup_result *result)
  1188. {
  1189. int r;
  1190. __le64 value;
  1191. struct dm_pool_metadata *pmd = td->pmd;
  1192. dm_block_t keys[2] = { td->id, block };
  1193. r = dm_btree_lookup_next(&pmd->info, pmd->root, keys, vblock, &value);
  1194. if (!r)
  1195. unpack_lookup_result(td, value, result);
  1196. return r;
  1197. }
  1198. static int __find_mapped_range(struct dm_thin_device *td,
  1199. dm_block_t begin, dm_block_t end,
  1200. dm_block_t *thin_begin, dm_block_t *thin_end,
  1201. dm_block_t *pool_begin, bool *maybe_shared)
  1202. {
  1203. int r;
  1204. dm_block_t pool_end;
  1205. struct dm_thin_lookup_result lookup;
  1206. if (end < begin)
  1207. return -ENODATA;
  1208. r = __find_next_mapped_block(td, begin, &begin, &lookup);
  1209. if (r)
  1210. return r;
  1211. if (begin >= end)
  1212. return -ENODATA;
  1213. *thin_begin = begin;
  1214. *pool_begin = lookup.block;
  1215. *maybe_shared = lookup.shared;
  1216. begin++;
  1217. pool_end = *pool_begin + 1;
  1218. while (begin != end) {
  1219. r = __find_block(td, begin, true, &lookup);
  1220. if (r) {
  1221. if (r == -ENODATA)
  1222. break;
  1223. else
  1224. return r;
  1225. }
  1226. if ((lookup.block != pool_end) ||
  1227. (lookup.shared != *maybe_shared))
  1228. break;
  1229. pool_end++;
  1230. begin++;
  1231. }
  1232. *thin_end = begin;
  1233. return 0;
  1234. }
  1235. int dm_thin_find_mapped_range(struct dm_thin_device *td,
  1236. dm_block_t begin, dm_block_t end,
  1237. dm_block_t *thin_begin, dm_block_t *thin_end,
  1238. dm_block_t *pool_begin, bool *maybe_shared)
  1239. {
  1240. int r = -EINVAL;
  1241. struct dm_pool_metadata *pmd = td->pmd;
  1242. down_read(&pmd->root_lock);
  1243. if (!pmd->fail_io) {
  1244. r = __find_mapped_range(td, begin, end, thin_begin, thin_end,
  1245. pool_begin, maybe_shared);
  1246. }
  1247. up_read(&pmd->root_lock);
  1248. return r;
  1249. }
  1250. static int __insert(struct dm_thin_device *td, dm_block_t block,
  1251. dm_block_t data_block)
  1252. {
  1253. int r, inserted;
  1254. __le64 value;
  1255. struct dm_pool_metadata *pmd = td->pmd;
  1256. dm_block_t keys[2] = { td->id, block };
  1257. value = cpu_to_le64(pack_block_time(data_block, pmd->time));
  1258. __dm_bless_for_disk(&value);
  1259. r = dm_btree_insert_notify(&pmd->info, pmd->root, keys, &value,
  1260. &pmd->root, &inserted);
  1261. if (r)
  1262. return r;
  1263. td->changed = 1;
  1264. if (inserted)
  1265. td->mapped_blocks++;
  1266. return 0;
  1267. }
  1268. int dm_thin_insert_block(struct dm_thin_device *td, dm_block_t block,
  1269. dm_block_t data_block)
  1270. {
  1271. int r = -EINVAL;
  1272. down_write(&td->pmd->root_lock);
  1273. if (!td->pmd->fail_io)
  1274. r = __insert(td, block, data_block);
  1275. up_write(&td->pmd->root_lock);
  1276. return r;
  1277. }
  1278. static int __remove(struct dm_thin_device *td, dm_block_t block)
  1279. {
  1280. int r;
  1281. struct dm_pool_metadata *pmd = td->pmd;
  1282. dm_block_t keys[2] = { td->id, block };
  1283. r = dm_btree_remove(&pmd->info, pmd->root, keys, &pmd->root);
  1284. if (r)
  1285. return r;
  1286. td->mapped_blocks--;
  1287. td->changed = 1;
  1288. return 0;
  1289. }
  1290. static int __remove_range(struct dm_thin_device *td, dm_block_t begin, dm_block_t end)
  1291. {
  1292. int r;
  1293. unsigned count, total_count = 0;
  1294. struct dm_pool_metadata *pmd = td->pmd;
  1295. dm_block_t keys[1] = { td->id };
  1296. __le64 value;
  1297. dm_block_t mapping_root;
  1298. /*
  1299. * Find the mapping tree
  1300. */
  1301. r = dm_btree_lookup(&pmd->tl_info, pmd->root, keys, &value);
  1302. if (r)
  1303. return r;
  1304. /*
  1305. * Remove from the mapping tree, taking care to inc the
  1306. * ref count so it doesn't get deleted.
  1307. */
  1308. mapping_root = le64_to_cpu(value);
  1309. dm_tm_inc(pmd->tm, mapping_root);
  1310. r = dm_btree_remove(&pmd->tl_info, pmd->root, keys, &pmd->root);
  1311. if (r)
  1312. return r;
  1313. /*
  1314. * Remove leaves stops at the first unmapped entry, so we have to
  1315. * loop round finding mapped ranges.
  1316. */
  1317. while (begin < end) {
  1318. r = dm_btree_lookup_next(&pmd->bl_info, mapping_root, &begin, &begin, &value);
  1319. if (r == -ENODATA)
  1320. break;
  1321. if (r)
  1322. return r;
  1323. if (begin >= end)
  1324. break;
  1325. r = dm_btree_remove_leaves(&pmd->bl_info, mapping_root, &begin, end, &mapping_root, &count);
  1326. if (r)
  1327. return r;
  1328. total_count += count;
  1329. }
  1330. td->mapped_blocks -= total_count;
  1331. td->changed = 1;
  1332. /*
  1333. * Reinsert the mapping tree.
  1334. */
  1335. value = cpu_to_le64(mapping_root);
  1336. __dm_bless_for_disk(&value);
  1337. return dm_btree_insert(&pmd->tl_info, pmd->root, keys, &value, &pmd->root);
  1338. }
  1339. int dm_thin_remove_block(struct dm_thin_device *td, dm_block_t block)
  1340. {
  1341. int r = -EINVAL;
  1342. down_write(&td->pmd->root_lock);
  1343. if (!td->pmd->fail_io)
  1344. r = __remove(td, block);
  1345. up_write(&td->pmd->root_lock);
  1346. return r;
  1347. }
  1348. int dm_thin_remove_range(struct dm_thin_device *td,
  1349. dm_block_t begin, dm_block_t end)
  1350. {
  1351. int r = -EINVAL;
  1352. down_write(&td->pmd->root_lock);
  1353. if (!td->pmd->fail_io)
  1354. r = __remove_range(td, begin, end);
  1355. up_write(&td->pmd->root_lock);
  1356. return r;
  1357. }
  1358. int dm_pool_block_is_used(struct dm_pool_metadata *pmd, dm_block_t b, bool *result)
  1359. {
  1360. int r;
  1361. uint32_t ref_count;
  1362. down_read(&pmd->root_lock);
  1363. r = dm_sm_get_count(pmd->data_sm, b, &ref_count);
  1364. if (!r)
  1365. *result = (ref_count != 0);
  1366. up_read(&pmd->root_lock);
  1367. return r;
  1368. }
  1369. int dm_pool_inc_data_range(struct dm_pool_metadata *pmd, dm_block_t b, dm_block_t e)
  1370. {
  1371. int r = 0;
  1372. down_write(&pmd->root_lock);
  1373. for (; b != e; b++) {
  1374. r = dm_sm_inc_block(pmd->data_sm, b);
  1375. if (r)
  1376. break;
  1377. }
  1378. up_write(&pmd->root_lock);
  1379. return r;
  1380. }
  1381. int dm_pool_dec_data_range(struct dm_pool_metadata *pmd, dm_block_t b, dm_block_t e)
  1382. {
  1383. int r = 0;
  1384. down_write(&pmd->root_lock);
  1385. for (; b != e; b++) {
  1386. r = dm_sm_dec_block(pmd->data_sm, b);
  1387. if (r)
  1388. break;
  1389. }
  1390. up_write(&pmd->root_lock);
  1391. return r;
  1392. }
  1393. bool dm_thin_changed_this_transaction(struct dm_thin_device *td)
  1394. {
  1395. int r;
  1396. down_read(&td->pmd->root_lock);
  1397. r = td->changed;
  1398. up_read(&td->pmd->root_lock);
  1399. return r;
  1400. }
  1401. bool dm_pool_changed_this_transaction(struct dm_pool_metadata *pmd)
  1402. {
  1403. bool r = false;
  1404. struct dm_thin_device *td, *tmp;
  1405. down_read(&pmd->root_lock);
  1406. list_for_each_entry_safe(td, tmp, &pmd->thin_devices, list) {
  1407. if (td->changed) {
  1408. r = td->changed;
  1409. break;
  1410. }
  1411. }
  1412. up_read(&pmd->root_lock);
  1413. return r;
  1414. }
  1415. bool dm_thin_aborted_changes(struct dm_thin_device *td)
  1416. {
  1417. bool r;
  1418. down_read(&td->pmd->root_lock);
  1419. r = td->aborted_with_changes;
  1420. up_read(&td->pmd->root_lock);
  1421. return r;
  1422. }
  1423. int dm_pool_alloc_data_block(struct dm_pool_metadata *pmd, dm_block_t *result)
  1424. {
  1425. int r = -EINVAL;
  1426. down_write(&pmd->root_lock);
  1427. if (!pmd->fail_io)
  1428. r = dm_sm_new_block(pmd->data_sm, result);
  1429. up_write(&pmd->root_lock);
  1430. return r;
  1431. }
  1432. int dm_pool_commit_metadata(struct dm_pool_metadata *pmd)
  1433. {
  1434. int r = -EINVAL;
  1435. down_write(&pmd->root_lock);
  1436. if (pmd->fail_io)
  1437. goto out;
  1438. r = __commit_transaction(pmd);
  1439. if (r <= 0)
  1440. goto out;
  1441. /*
  1442. * Open the next transaction.
  1443. */
  1444. r = __begin_transaction(pmd);
  1445. out:
  1446. up_write(&pmd->root_lock);
  1447. return r;
  1448. }
  1449. static void __set_abort_with_changes_flags(struct dm_pool_metadata *pmd)
  1450. {
  1451. struct dm_thin_device *td;
  1452. list_for_each_entry(td, &pmd->thin_devices, list)
  1453. td->aborted_with_changes = td->changed;
  1454. }
  1455. int dm_pool_abort_metadata(struct dm_pool_metadata *pmd)
  1456. {
  1457. int r = -EINVAL;
  1458. down_write(&pmd->root_lock);
  1459. if (pmd->fail_io)
  1460. goto out;
  1461. __set_abort_with_changes_flags(pmd);
  1462. __destroy_persistent_data_objects(pmd);
  1463. r = __create_persistent_data_objects(pmd, false);
  1464. if (r)
  1465. pmd->fail_io = true;
  1466. out:
  1467. up_write(&pmd->root_lock);
  1468. return r;
  1469. }
  1470. int dm_pool_get_free_block_count(struct dm_pool_metadata *pmd, dm_block_t *result)
  1471. {
  1472. int r = -EINVAL;
  1473. down_read(&pmd->root_lock);
  1474. if (!pmd->fail_io)
  1475. r = dm_sm_get_nr_free(pmd->data_sm, result);
  1476. up_read(&pmd->root_lock);
  1477. return r;
  1478. }
  1479. int dm_pool_get_free_metadata_block_count(struct dm_pool_metadata *pmd,
  1480. dm_block_t *result)
  1481. {
  1482. int r = -EINVAL;
  1483. down_read(&pmd->root_lock);
  1484. if (!pmd->fail_io)
  1485. r = dm_sm_get_nr_free(pmd->metadata_sm, result);
  1486. up_read(&pmd->root_lock);
  1487. return r;
  1488. }
  1489. int dm_pool_get_metadata_dev_size(struct dm_pool_metadata *pmd,
  1490. dm_block_t *result)
  1491. {
  1492. int r = -EINVAL;
  1493. down_read(&pmd->root_lock);
  1494. if (!pmd->fail_io)
  1495. r = dm_sm_get_nr_blocks(pmd->metadata_sm, result);
  1496. up_read(&pmd->root_lock);
  1497. return r;
  1498. }
  1499. int dm_pool_get_data_dev_size(struct dm_pool_metadata *pmd, dm_block_t *result)
  1500. {
  1501. int r = -EINVAL;
  1502. down_read(&pmd->root_lock);
  1503. if (!pmd->fail_io)
  1504. r = dm_sm_get_nr_blocks(pmd->data_sm, result);
  1505. up_read(&pmd->root_lock);
  1506. return r;
  1507. }
  1508. int dm_thin_get_mapped_count(struct dm_thin_device *td, dm_block_t *result)
  1509. {
  1510. int r = -EINVAL;
  1511. struct dm_pool_metadata *pmd = td->pmd;
  1512. down_read(&pmd->root_lock);
  1513. if (!pmd->fail_io) {
  1514. *result = td->mapped_blocks;
  1515. r = 0;
  1516. }
  1517. up_read(&pmd->root_lock);
  1518. return r;
  1519. }
  1520. static int __highest_block(struct dm_thin_device *td, dm_block_t *result)
  1521. {
  1522. int r;
  1523. __le64 value_le;
  1524. dm_block_t thin_root;
  1525. struct dm_pool_metadata *pmd = td->pmd;
  1526. r = dm_btree_lookup(&pmd->tl_info, pmd->root, &td->id, &value_le);
  1527. if (r)
  1528. return r;
  1529. thin_root = le64_to_cpu(value_le);
  1530. return dm_btree_find_highest_key(&pmd->bl_info, thin_root, result);
  1531. }
  1532. int dm_thin_get_highest_mapped_block(struct dm_thin_device *td,
  1533. dm_block_t *result)
  1534. {
  1535. int r = -EINVAL;
  1536. struct dm_pool_metadata *pmd = td->pmd;
  1537. down_read(&pmd->root_lock);
  1538. if (!pmd->fail_io)
  1539. r = __highest_block(td, result);
  1540. up_read(&pmd->root_lock);
  1541. return r;
  1542. }
  1543. static int __resize_space_map(struct dm_space_map *sm, dm_block_t new_count)
  1544. {
  1545. int r;
  1546. dm_block_t old_count;
  1547. r = dm_sm_get_nr_blocks(sm, &old_count);
  1548. if (r)
  1549. return r;
  1550. if (new_count == old_count)
  1551. return 0;
  1552. if (new_count < old_count) {
  1553. DMERR("cannot reduce size of space map");
  1554. return -EINVAL;
  1555. }
  1556. return dm_sm_extend(sm, new_count - old_count);
  1557. }
  1558. int dm_pool_resize_data_dev(struct dm_pool_metadata *pmd, dm_block_t new_count)
  1559. {
  1560. int r = -EINVAL;
  1561. down_write(&pmd->root_lock);
  1562. if (!pmd->fail_io)
  1563. r = __resize_space_map(pmd->data_sm, new_count);
  1564. up_write(&pmd->root_lock);
  1565. return r;
  1566. }
  1567. int dm_pool_resize_metadata_dev(struct dm_pool_metadata *pmd, dm_block_t new_count)
  1568. {
  1569. int r = -EINVAL;
  1570. down_write(&pmd->root_lock);
  1571. if (!pmd->fail_io)
  1572. r = __resize_space_map(pmd->metadata_sm, new_count);
  1573. up_write(&pmd->root_lock);
  1574. return r;
  1575. }
  1576. void dm_pool_metadata_read_only(struct dm_pool_metadata *pmd)
  1577. {
  1578. down_write(&pmd->root_lock);
  1579. dm_bm_set_read_only(pmd->bm);
  1580. up_write(&pmd->root_lock);
  1581. }
  1582. void dm_pool_metadata_read_write(struct dm_pool_metadata *pmd)
  1583. {
  1584. down_write(&pmd->root_lock);
  1585. dm_bm_set_read_write(pmd->bm);
  1586. up_write(&pmd->root_lock);
  1587. }
  1588. int dm_pool_register_metadata_threshold(struct dm_pool_metadata *pmd,
  1589. dm_block_t threshold,
  1590. dm_sm_threshold_fn fn,
  1591. void *context)
  1592. {
  1593. int r;
  1594. down_write(&pmd->root_lock);
  1595. r = dm_sm_register_threshold_callback(pmd->metadata_sm, threshold, fn, context);
  1596. up_write(&pmd->root_lock);
  1597. return r;
  1598. }
  1599. int dm_pool_metadata_set_needs_check(struct dm_pool_metadata *pmd)
  1600. {
  1601. int r;
  1602. struct dm_block *sblock;
  1603. struct thin_disk_superblock *disk_super;
  1604. down_write(&pmd->root_lock);
  1605. pmd->flags |= THIN_METADATA_NEEDS_CHECK_FLAG;
  1606. r = superblock_lock(pmd, &sblock);
  1607. if (r) {
  1608. DMERR("couldn't read superblock");
  1609. goto out;
  1610. }
  1611. disk_super = dm_block_data(sblock);
  1612. disk_super->flags = cpu_to_le32(pmd->flags);
  1613. dm_bm_unlock(sblock);
  1614. out:
  1615. up_write(&pmd->root_lock);
  1616. return r;
  1617. }
  1618. bool dm_pool_metadata_needs_check(struct dm_pool_metadata *pmd)
  1619. {
  1620. bool needs_check;
  1621. down_read(&pmd->root_lock);
  1622. needs_check = pmd->flags & THIN_METADATA_NEEDS_CHECK_FLAG;
  1623. up_read(&pmd->root_lock);
  1624. return needs_check;
  1625. }
  1626. void dm_pool_issue_prefetches(struct dm_pool_metadata *pmd)
  1627. {
  1628. down_read(&pmd->root_lock);
  1629. if (!pmd->fail_io)
  1630. dm_tm_issue_prefetches(pmd->tm);
  1631. up_read(&pmd->root_lock);
  1632. }