dm-space-map-disk.c 6.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318
  1. /*
  2. * Copyright (C) 2011 Red Hat, Inc.
  3. *
  4. * This file is released under the GPL.
  5. */
  6. #include "dm-space-map-common.h"
  7. #include "dm-space-map-disk.h"
  8. #include "dm-space-map.h"
  9. #include "dm-transaction-manager.h"
  10. #include <linux/list.h>
  11. #include <linux/slab.h>
  12. #include <linux/export.h>
  13. #include <linux/device-mapper.h>
  14. #define DM_MSG_PREFIX "space map disk"
  15. /*----------------------------------------------------------------*/
  16. /*
  17. * Space map interface.
  18. */
  19. struct sm_disk {
  20. struct dm_space_map sm;
  21. struct ll_disk ll;
  22. struct ll_disk old_ll;
  23. dm_block_t begin;
  24. dm_block_t nr_allocated_this_transaction;
  25. };
  26. static void sm_disk_destroy(struct dm_space_map *sm)
  27. {
  28. struct sm_disk *smd = container_of(sm, struct sm_disk, sm);
  29. kfree(smd);
  30. }
  31. static int sm_disk_extend(struct dm_space_map *sm, dm_block_t extra_blocks)
  32. {
  33. struct sm_disk *smd = container_of(sm, struct sm_disk, sm);
  34. return sm_ll_extend(&smd->ll, extra_blocks);
  35. }
  36. static int sm_disk_get_nr_blocks(struct dm_space_map *sm, dm_block_t *count)
  37. {
  38. struct sm_disk *smd = container_of(sm, struct sm_disk, sm);
  39. *count = smd->old_ll.nr_blocks;
  40. return 0;
  41. }
  42. static int sm_disk_get_nr_free(struct dm_space_map *sm, dm_block_t *count)
  43. {
  44. struct sm_disk *smd = container_of(sm, struct sm_disk, sm);
  45. *count = (smd->old_ll.nr_blocks - smd->old_ll.nr_allocated) - smd->nr_allocated_this_transaction;
  46. return 0;
  47. }
  48. static int sm_disk_get_count(struct dm_space_map *sm, dm_block_t b,
  49. uint32_t *result)
  50. {
  51. struct sm_disk *smd = container_of(sm, struct sm_disk, sm);
  52. return sm_ll_lookup(&smd->ll, b, result);
  53. }
  54. static int sm_disk_count_is_more_than_one(struct dm_space_map *sm, dm_block_t b,
  55. int *result)
  56. {
  57. int r;
  58. uint32_t count;
  59. r = sm_disk_get_count(sm, b, &count);
  60. if (r)
  61. return r;
  62. *result = count > 1;
  63. return 0;
  64. }
  65. static int sm_disk_set_count(struct dm_space_map *sm, dm_block_t b,
  66. uint32_t count)
  67. {
  68. int r;
  69. uint32_t old_count;
  70. enum allocation_event ev;
  71. struct sm_disk *smd = container_of(sm, struct sm_disk, sm);
  72. r = sm_ll_insert(&smd->ll, b, count, &ev);
  73. if (!r) {
  74. switch (ev) {
  75. case SM_NONE:
  76. break;
  77. case SM_ALLOC:
  78. /*
  79. * This _must_ be free in the prior transaction
  80. * otherwise we've lost atomicity.
  81. */
  82. smd->nr_allocated_this_transaction++;
  83. break;
  84. case SM_FREE:
  85. /*
  86. * It's only free if it's also free in the last
  87. * transaction.
  88. */
  89. r = sm_ll_lookup(&smd->old_ll, b, &old_count);
  90. if (r)
  91. return r;
  92. if (!old_count)
  93. smd->nr_allocated_this_transaction--;
  94. break;
  95. }
  96. }
  97. return r;
  98. }
  99. static int sm_disk_inc_block(struct dm_space_map *sm, dm_block_t b)
  100. {
  101. int r;
  102. enum allocation_event ev;
  103. struct sm_disk *smd = container_of(sm, struct sm_disk, sm);
  104. r = sm_ll_inc(&smd->ll, b, &ev);
  105. if (!r && (ev == SM_ALLOC))
  106. /*
  107. * This _must_ be free in the prior transaction
  108. * otherwise we've lost atomicity.
  109. */
  110. smd->nr_allocated_this_transaction++;
  111. return r;
  112. }
  113. static int sm_disk_dec_block(struct dm_space_map *sm, dm_block_t b)
  114. {
  115. int r;
  116. uint32_t old_count;
  117. enum allocation_event ev;
  118. struct sm_disk *smd = container_of(sm, struct sm_disk, sm);
  119. r = sm_ll_dec(&smd->ll, b, &ev);
  120. if (!r && (ev == SM_FREE)) {
  121. /*
  122. * It's only free if it's also free in the last
  123. * transaction.
  124. */
  125. r = sm_ll_lookup(&smd->old_ll, b, &old_count);
  126. if (!r && !old_count)
  127. smd->nr_allocated_this_transaction--;
  128. }
  129. return r;
  130. }
  131. static int sm_disk_new_block(struct dm_space_map *sm, dm_block_t *b)
  132. {
  133. int r;
  134. enum allocation_event ev;
  135. struct sm_disk *smd = container_of(sm, struct sm_disk, sm);
  136. /* FIXME: we should loop round a couple of times */
  137. r = sm_ll_find_free_block(&smd->old_ll, smd->begin, smd->old_ll.nr_blocks, b);
  138. if (r)
  139. return r;
  140. smd->begin = *b + 1;
  141. r = sm_ll_inc(&smd->ll, *b, &ev);
  142. if (!r) {
  143. BUG_ON(ev != SM_ALLOC);
  144. smd->nr_allocated_this_transaction++;
  145. }
  146. return r;
  147. }
  148. static int sm_disk_commit(struct dm_space_map *sm)
  149. {
  150. int r;
  151. dm_block_t nr_free;
  152. struct sm_disk *smd = container_of(sm, struct sm_disk, sm);
  153. r = sm_disk_get_nr_free(sm, &nr_free);
  154. if (r)
  155. return r;
  156. r = sm_ll_commit(&smd->ll);
  157. if (r)
  158. return r;
  159. memcpy(&smd->old_ll, &smd->ll, sizeof(smd->old_ll));
  160. smd->begin = 0;
  161. smd->nr_allocated_this_transaction = 0;
  162. r = sm_disk_get_nr_free(sm, &nr_free);
  163. if (r)
  164. return r;
  165. return 0;
  166. }
  167. static int sm_disk_root_size(struct dm_space_map *sm, size_t *result)
  168. {
  169. *result = sizeof(struct disk_sm_root);
  170. return 0;
  171. }
  172. static int sm_disk_copy_root(struct dm_space_map *sm, void *where_le, size_t max)
  173. {
  174. struct sm_disk *smd = container_of(sm, struct sm_disk, sm);
  175. struct disk_sm_root root_le;
  176. root_le.nr_blocks = cpu_to_le64(smd->ll.nr_blocks);
  177. root_le.nr_allocated = cpu_to_le64(smd->ll.nr_allocated);
  178. root_le.bitmap_root = cpu_to_le64(smd->ll.bitmap_root);
  179. root_le.ref_count_root = cpu_to_le64(smd->ll.ref_count_root);
  180. if (max < sizeof(root_le))
  181. return -ENOSPC;
  182. memcpy(where_le, &root_le, sizeof(root_le));
  183. return 0;
  184. }
  185. /*----------------------------------------------------------------*/
  186. static struct dm_space_map ops = {
  187. .destroy = sm_disk_destroy,
  188. .extend = sm_disk_extend,
  189. .get_nr_blocks = sm_disk_get_nr_blocks,
  190. .get_nr_free = sm_disk_get_nr_free,
  191. .get_count = sm_disk_get_count,
  192. .count_is_more_than_one = sm_disk_count_is_more_than_one,
  193. .set_count = sm_disk_set_count,
  194. .inc_block = sm_disk_inc_block,
  195. .dec_block = sm_disk_dec_block,
  196. .new_block = sm_disk_new_block,
  197. .commit = sm_disk_commit,
  198. .root_size = sm_disk_root_size,
  199. .copy_root = sm_disk_copy_root,
  200. .register_threshold_callback = NULL
  201. };
  202. struct dm_space_map *dm_sm_disk_create(struct dm_transaction_manager *tm,
  203. dm_block_t nr_blocks)
  204. {
  205. int r;
  206. struct sm_disk *smd;
  207. smd = kmalloc(sizeof(*smd), GFP_KERNEL);
  208. if (!smd)
  209. return ERR_PTR(-ENOMEM);
  210. smd->begin = 0;
  211. smd->nr_allocated_this_transaction = 0;
  212. memcpy(&smd->sm, &ops, sizeof(smd->sm));
  213. r = sm_ll_new_disk(&smd->ll, tm);
  214. if (r)
  215. goto bad;
  216. r = sm_ll_extend(&smd->ll, nr_blocks);
  217. if (r)
  218. goto bad;
  219. r = sm_disk_commit(&smd->sm);
  220. if (r)
  221. goto bad;
  222. return &smd->sm;
  223. bad:
  224. kfree(smd);
  225. return ERR_PTR(r);
  226. }
  227. EXPORT_SYMBOL_GPL(dm_sm_disk_create);
  228. struct dm_space_map *dm_sm_disk_open(struct dm_transaction_manager *tm,
  229. void *root_le, size_t len)
  230. {
  231. int r;
  232. struct sm_disk *smd;
  233. smd = kmalloc(sizeof(*smd), GFP_KERNEL);
  234. if (!smd)
  235. return ERR_PTR(-ENOMEM);
  236. smd->begin = 0;
  237. smd->nr_allocated_this_transaction = 0;
  238. memcpy(&smd->sm, &ops, sizeof(smd->sm));
  239. r = sm_ll_open_disk(&smd->ll, tm, root_le, len);
  240. if (r)
  241. goto bad;
  242. r = sm_disk_commit(&smd->sm);
  243. if (r)
  244. goto bad;
  245. return &smd->sm;
  246. bad:
  247. kfree(smd);
  248. return ERR_PTR(r);
  249. }
  250. EXPORT_SYMBOL_GPL(dm_sm_disk_open);
  251. /*----------------------------------------------------------------*/