dm-log.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842
  1. /*
  2. * Copyright (C) 2003 Sistina Software
  3. * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
  4. *
  5. * This file is released under the LGPL.
  6. */
  7. #include <linux/init.h>
  8. #include <linux/slab.h>
  9. #include <linux/module.h>
  10. #include <linux/vmalloc.h>
  11. #include <linux/dm-io.h>
  12. #include <linux/dm-dirty-log.h>
  13. #include <linux/device-mapper.h>
  14. #define DM_MSG_PREFIX "dirty region log"
  15. static LIST_HEAD(_log_types);
  16. static DEFINE_SPINLOCK(_lock);
  17. static struct dm_dirty_log_type *__find_dirty_log_type(const char *name)
  18. {
  19. struct dm_dirty_log_type *log_type;
  20. list_for_each_entry(log_type, &_log_types, list)
  21. if (!strcmp(name, log_type->name))
  22. return log_type;
  23. return NULL;
  24. }
  25. static struct dm_dirty_log_type *_get_dirty_log_type(const char *name)
  26. {
  27. struct dm_dirty_log_type *log_type;
  28. spin_lock(&_lock);
  29. log_type = __find_dirty_log_type(name);
  30. if (log_type && !try_module_get(log_type->module))
  31. log_type = NULL;
  32. spin_unlock(&_lock);
  33. return log_type;
  34. }
  35. /*
  36. * get_type
  37. * @type_name
  38. *
  39. * Attempt to retrieve the dm_dirty_log_type by name. If not already
  40. * available, attempt to load the appropriate module.
  41. *
  42. * Log modules are named "dm-log-" followed by the 'type_name'.
  43. * Modules may contain multiple types.
  44. * This function will first try the module "dm-log-<type_name>",
  45. * then truncate 'type_name' on the last '-' and try again.
  46. *
  47. * For example, if type_name was "clustered-disk", it would search
  48. * 'dm-log-clustered-disk' then 'dm-log-clustered'.
  49. *
  50. * Returns: dirty_log_type* on success, NULL on failure
  51. */
  52. static struct dm_dirty_log_type *get_type(const char *type_name)
  53. {
  54. char *p, *type_name_dup;
  55. struct dm_dirty_log_type *log_type;
  56. if (!type_name)
  57. return NULL;
  58. log_type = _get_dirty_log_type(type_name);
  59. if (log_type)
  60. return log_type;
  61. type_name_dup = kstrdup(type_name, GFP_KERNEL);
  62. if (!type_name_dup) {
  63. DMWARN("No memory left to attempt log module load for \"%s\"",
  64. type_name);
  65. return NULL;
  66. }
  67. while (request_module("dm-log-%s", type_name_dup) ||
  68. !(log_type = _get_dirty_log_type(type_name))) {
  69. p = strrchr(type_name_dup, '-');
  70. if (!p)
  71. break;
  72. p[0] = '\0';
  73. }
  74. if (!log_type)
  75. DMWARN("Module for logging type \"%s\" not found.", type_name);
  76. kfree(type_name_dup);
  77. return log_type;
  78. }
  79. static void put_type(struct dm_dirty_log_type *type)
  80. {
  81. if (!type)
  82. return;
  83. spin_lock(&_lock);
  84. if (!__find_dirty_log_type(type->name))
  85. goto out;
  86. module_put(type->module);
  87. out:
  88. spin_unlock(&_lock);
  89. }
  90. int dm_dirty_log_type_register(struct dm_dirty_log_type *type)
  91. {
  92. int r = 0;
  93. spin_lock(&_lock);
  94. if (!__find_dirty_log_type(type->name))
  95. list_add(&type->list, &_log_types);
  96. else
  97. r = -EEXIST;
  98. spin_unlock(&_lock);
  99. return r;
  100. }
  101. EXPORT_SYMBOL(dm_dirty_log_type_register);
  102. int dm_dirty_log_type_unregister(struct dm_dirty_log_type *type)
  103. {
  104. spin_lock(&_lock);
  105. if (!__find_dirty_log_type(type->name)) {
  106. spin_unlock(&_lock);
  107. return -EINVAL;
  108. }
  109. list_del(&type->list);
  110. spin_unlock(&_lock);
  111. return 0;
  112. }
  113. EXPORT_SYMBOL(dm_dirty_log_type_unregister);
  114. struct dm_dirty_log *dm_dirty_log_create(const char *type_name,
  115. struct dm_target *ti,
  116. unsigned int argc, char **argv)
  117. {
  118. struct dm_dirty_log_type *type;
  119. struct dm_dirty_log *log;
  120. log = kmalloc(sizeof(*log), GFP_KERNEL);
  121. if (!log)
  122. return NULL;
  123. type = get_type(type_name);
  124. if (!type) {
  125. kfree(log);
  126. return NULL;
  127. }
  128. log->type = type;
  129. if (type->ctr(log, ti, argc, argv)) {
  130. kfree(log);
  131. put_type(type);
  132. return NULL;
  133. }
  134. return log;
  135. }
  136. EXPORT_SYMBOL(dm_dirty_log_create);
  137. void dm_dirty_log_destroy(struct dm_dirty_log *log)
  138. {
  139. log->type->dtr(log);
  140. put_type(log->type);
  141. kfree(log);
  142. }
  143. EXPORT_SYMBOL(dm_dirty_log_destroy);
  144. /*-----------------------------------------------------------------
  145. * Persistent and core logs share a lot of their implementation.
  146. * FIXME: need a reload method to be called from a resume
  147. *---------------------------------------------------------------*/
  148. /*
  149. * Magic for persistent mirrors: "MiRr"
  150. */
  151. #define MIRROR_MAGIC 0x4D695272
  152. /*
  153. * The on-disk version of the metadata.
  154. */
  155. #define MIRROR_DISK_VERSION 2
  156. #define LOG_OFFSET 2
  157. struct log_header {
  158. uint32_t magic;
  159. /*
  160. * Simple, incrementing version. no backward
  161. * compatibility.
  162. */
  163. uint32_t version;
  164. sector_t nr_regions;
  165. };
  166. struct log_c {
  167. struct dm_target *ti;
  168. int touched;
  169. uint32_t region_size;
  170. unsigned int region_count;
  171. region_t sync_count;
  172. unsigned bitset_uint32_count;
  173. uint32_t *clean_bits;
  174. uint32_t *sync_bits;
  175. uint32_t *recovering_bits; /* FIXME: this seems excessive */
  176. int sync_search;
  177. /* Resync flag */
  178. enum sync {
  179. DEFAULTSYNC, /* Synchronize if necessary */
  180. NOSYNC, /* Devices known to be already in sync */
  181. FORCESYNC, /* Force a sync to happen */
  182. } sync;
  183. struct dm_io_request io_req;
  184. /*
  185. * Disk log fields
  186. */
  187. int log_dev_failed;
  188. struct dm_dev *log_dev;
  189. struct log_header header;
  190. struct dm_io_region header_location;
  191. struct log_header *disk_header;
  192. };
  193. /*
  194. * The touched member needs to be updated every time we access
  195. * one of the bitsets.
  196. */
  197. static inline int log_test_bit(uint32_t *bs, unsigned bit)
  198. {
  199. return ext2_test_bit(bit, (unsigned long *) bs) ? 1 : 0;
  200. }
  201. static inline void log_set_bit(struct log_c *l,
  202. uint32_t *bs, unsigned bit)
  203. {
  204. ext2_set_bit(bit, (unsigned long *) bs);
  205. l->touched = 1;
  206. }
  207. static inline void log_clear_bit(struct log_c *l,
  208. uint32_t *bs, unsigned bit)
  209. {
  210. ext2_clear_bit(bit, (unsigned long *) bs);
  211. l->touched = 1;
  212. }
  213. /*----------------------------------------------------------------
  214. * Header IO
  215. *--------------------------------------------------------------*/
  216. static void header_to_disk(struct log_header *core, struct log_header *disk)
  217. {
  218. disk->magic = cpu_to_le32(core->magic);
  219. disk->version = cpu_to_le32(core->version);
  220. disk->nr_regions = cpu_to_le64(core->nr_regions);
  221. }
  222. static void header_from_disk(struct log_header *core, struct log_header *disk)
  223. {
  224. core->magic = le32_to_cpu(disk->magic);
  225. core->version = le32_to_cpu(disk->version);
  226. core->nr_regions = le64_to_cpu(disk->nr_regions);
  227. }
  228. static int rw_header(struct log_c *lc, int rw)
  229. {
  230. lc->io_req.bi_rw = rw;
  231. return dm_io(&lc->io_req, 1, &lc->header_location, NULL);
  232. }
  233. static int read_header(struct log_c *log)
  234. {
  235. int r;
  236. r = rw_header(log, READ);
  237. if (r)
  238. return r;
  239. header_from_disk(&log->header, log->disk_header);
  240. /* New log required? */
  241. if (log->sync != DEFAULTSYNC || log->header.magic != MIRROR_MAGIC) {
  242. log->header.magic = MIRROR_MAGIC;
  243. log->header.version = MIRROR_DISK_VERSION;
  244. log->header.nr_regions = 0;
  245. }
  246. #ifdef __LITTLE_ENDIAN
  247. if (log->header.version == 1)
  248. log->header.version = 2;
  249. #endif
  250. if (log->header.version != MIRROR_DISK_VERSION) {
  251. DMWARN("incompatible disk log version");
  252. return -EINVAL;
  253. }
  254. return 0;
  255. }
  256. static int _check_region_size(struct dm_target *ti, uint32_t region_size)
  257. {
  258. if (region_size < 2 || region_size > ti->len)
  259. return 0;
  260. if (!is_power_of_2(region_size))
  261. return 0;
  262. return 1;
  263. }
  264. /*----------------------------------------------------------------
  265. * core log constructor/destructor
  266. *
  267. * argv contains region_size followed optionally by [no]sync
  268. *--------------------------------------------------------------*/
  269. #define BYTE_SHIFT 3
  270. static int create_log_context(struct dm_dirty_log *log, struct dm_target *ti,
  271. unsigned int argc, char **argv,
  272. struct dm_dev *dev)
  273. {
  274. enum sync sync = DEFAULTSYNC;
  275. struct log_c *lc;
  276. uint32_t region_size;
  277. unsigned int region_count;
  278. size_t bitset_size, buf_size;
  279. int r;
  280. if (argc < 1 || argc > 2) {
  281. DMWARN("wrong number of arguments to dirty region log");
  282. return -EINVAL;
  283. }
  284. if (argc > 1) {
  285. if (!strcmp(argv[1], "sync"))
  286. sync = FORCESYNC;
  287. else if (!strcmp(argv[1], "nosync"))
  288. sync = NOSYNC;
  289. else {
  290. DMWARN("unrecognised sync argument to "
  291. "dirty region log: %s", argv[1]);
  292. return -EINVAL;
  293. }
  294. }
  295. if (sscanf(argv[0], "%u", &region_size) != 1 ||
  296. !_check_region_size(ti, region_size)) {
  297. DMWARN("invalid region size %s", argv[0]);
  298. return -EINVAL;
  299. }
  300. region_count = dm_sector_div_up(ti->len, region_size);
  301. lc = kmalloc(sizeof(*lc), GFP_KERNEL);
  302. if (!lc) {
  303. DMWARN("couldn't allocate core log");
  304. return -ENOMEM;
  305. }
  306. lc->ti = ti;
  307. lc->touched = 0;
  308. lc->region_size = region_size;
  309. lc->region_count = region_count;
  310. lc->sync = sync;
  311. /*
  312. * Work out how many "unsigned long"s we need to hold the bitset.
  313. */
  314. bitset_size = dm_round_up(region_count,
  315. sizeof(*lc->clean_bits) << BYTE_SHIFT);
  316. bitset_size >>= BYTE_SHIFT;
  317. lc->bitset_uint32_count = bitset_size / sizeof(*lc->clean_bits);
  318. /*
  319. * Disk log?
  320. */
  321. if (!dev) {
  322. lc->clean_bits = vmalloc(bitset_size);
  323. if (!lc->clean_bits) {
  324. DMWARN("couldn't allocate clean bitset");
  325. kfree(lc);
  326. return -ENOMEM;
  327. }
  328. lc->disk_header = NULL;
  329. } else {
  330. lc->log_dev = dev;
  331. lc->log_dev_failed = 0;
  332. lc->header_location.bdev = lc->log_dev->bdev;
  333. lc->header_location.sector = 0;
  334. /*
  335. * Buffer holds both header and bitset.
  336. */
  337. buf_size = dm_round_up((LOG_OFFSET << SECTOR_SHIFT) +
  338. bitset_size,
  339. ti->limits.logical_block_size);
  340. if (buf_size > dev->bdev->bd_inode->i_size) {
  341. DMWARN("log device %s too small: need %llu bytes",
  342. dev->name, (unsigned long long)buf_size);
  343. kfree(lc);
  344. return -EINVAL;
  345. }
  346. lc->header_location.count = buf_size >> SECTOR_SHIFT;
  347. lc->io_req.mem.type = DM_IO_VMA;
  348. lc->io_req.notify.fn = NULL;
  349. lc->io_req.client = dm_io_client_create(dm_div_up(buf_size,
  350. PAGE_SIZE));
  351. if (IS_ERR(lc->io_req.client)) {
  352. r = PTR_ERR(lc->io_req.client);
  353. DMWARN("couldn't allocate disk io client");
  354. kfree(lc);
  355. return -ENOMEM;
  356. }
  357. lc->disk_header = vmalloc(buf_size);
  358. if (!lc->disk_header) {
  359. DMWARN("couldn't allocate disk log buffer");
  360. dm_io_client_destroy(lc->io_req.client);
  361. kfree(lc);
  362. return -ENOMEM;
  363. }
  364. lc->io_req.mem.ptr.vma = lc->disk_header;
  365. lc->clean_bits = (void *)lc->disk_header +
  366. (LOG_OFFSET << SECTOR_SHIFT);
  367. }
  368. memset(lc->clean_bits, -1, bitset_size);
  369. lc->sync_bits = vmalloc(bitset_size);
  370. if (!lc->sync_bits) {
  371. DMWARN("couldn't allocate sync bitset");
  372. if (!dev)
  373. vfree(lc->clean_bits);
  374. else
  375. dm_io_client_destroy(lc->io_req.client);
  376. vfree(lc->disk_header);
  377. kfree(lc);
  378. return -ENOMEM;
  379. }
  380. memset(lc->sync_bits, (sync == NOSYNC) ? -1 : 0, bitset_size);
  381. lc->sync_count = (sync == NOSYNC) ? region_count : 0;
  382. lc->recovering_bits = vmalloc(bitset_size);
  383. if (!lc->recovering_bits) {
  384. DMWARN("couldn't allocate sync bitset");
  385. vfree(lc->sync_bits);
  386. if (!dev)
  387. vfree(lc->clean_bits);
  388. else
  389. dm_io_client_destroy(lc->io_req.client);
  390. vfree(lc->disk_header);
  391. kfree(lc);
  392. return -ENOMEM;
  393. }
  394. memset(lc->recovering_bits, 0, bitset_size);
  395. lc->sync_search = 0;
  396. log->context = lc;
  397. return 0;
  398. }
  399. static int core_ctr(struct dm_dirty_log *log, struct dm_target *ti,
  400. unsigned int argc, char **argv)
  401. {
  402. return create_log_context(log, ti, argc, argv, NULL);
  403. }
  404. static void destroy_log_context(struct log_c *lc)
  405. {
  406. vfree(lc->sync_bits);
  407. vfree(lc->recovering_bits);
  408. kfree(lc);
  409. }
  410. static void core_dtr(struct dm_dirty_log *log)
  411. {
  412. struct log_c *lc = (struct log_c *) log->context;
  413. vfree(lc->clean_bits);
  414. destroy_log_context(lc);
  415. }
  416. /*----------------------------------------------------------------
  417. * disk log constructor/destructor
  418. *
  419. * argv contains log_device region_size followed optionally by [no]sync
  420. *--------------------------------------------------------------*/
  421. static int disk_ctr(struct dm_dirty_log *log, struct dm_target *ti,
  422. unsigned int argc, char **argv)
  423. {
  424. int r;
  425. struct dm_dev *dev;
  426. if (argc < 2 || argc > 3) {
  427. DMWARN("wrong number of arguments to disk dirty region log");
  428. return -EINVAL;
  429. }
  430. r = dm_get_device(ti, argv[0], 0, 0 /* FIXME */,
  431. FMODE_READ | FMODE_WRITE, &dev);
  432. if (r)
  433. return r;
  434. r = create_log_context(log, ti, argc - 1, argv + 1, dev);
  435. if (r) {
  436. dm_put_device(ti, dev);
  437. return r;
  438. }
  439. return 0;
  440. }
  441. static void disk_dtr(struct dm_dirty_log *log)
  442. {
  443. struct log_c *lc = (struct log_c *) log->context;
  444. dm_put_device(lc->ti, lc->log_dev);
  445. vfree(lc->disk_header);
  446. dm_io_client_destroy(lc->io_req.client);
  447. destroy_log_context(lc);
  448. }
  449. static int count_bits32(uint32_t *addr, unsigned size)
  450. {
  451. int count = 0, i;
  452. for (i = 0; i < size; i++) {
  453. count += hweight32(*(addr+i));
  454. }
  455. return count;
  456. }
  457. static void fail_log_device(struct log_c *lc)
  458. {
  459. if (lc->log_dev_failed)
  460. return;
  461. lc->log_dev_failed = 1;
  462. dm_table_event(lc->ti->table);
  463. }
  464. static int disk_resume(struct dm_dirty_log *log)
  465. {
  466. int r;
  467. unsigned i;
  468. struct log_c *lc = (struct log_c *) log->context;
  469. size_t size = lc->bitset_uint32_count * sizeof(uint32_t);
  470. /* read the disk header */
  471. r = read_header(lc);
  472. if (r) {
  473. DMWARN("%s: Failed to read header on dirty region log device",
  474. lc->log_dev->name);
  475. fail_log_device(lc);
  476. /*
  477. * If the log device cannot be read, we must assume
  478. * all regions are out-of-sync. If we simply return
  479. * here, the state will be uninitialized and could
  480. * lead us to return 'in-sync' status for regions
  481. * that are actually 'out-of-sync'.
  482. */
  483. lc->header.nr_regions = 0;
  484. }
  485. /* set or clear any new bits -- device has grown */
  486. if (lc->sync == NOSYNC)
  487. for (i = lc->header.nr_regions; i < lc->region_count; i++)
  488. /* FIXME: amazingly inefficient */
  489. log_set_bit(lc, lc->clean_bits, i);
  490. else
  491. for (i = lc->header.nr_regions; i < lc->region_count; i++)
  492. /* FIXME: amazingly inefficient */
  493. log_clear_bit(lc, lc->clean_bits, i);
  494. /* clear any old bits -- device has shrunk */
  495. for (i = lc->region_count; i % (sizeof(*lc->clean_bits) << BYTE_SHIFT); i++)
  496. log_clear_bit(lc, lc->clean_bits, i);
  497. /* copy clean across to sync */
  498. memcpy(lc->sync_bits, lc->clean_bits, size);
  499. lc->sync_count = count_bits32(lc->clean_bits, lc->bitset_uint32_count);
  500. lc->sync_search = 0;
  501. /* set the correct number of regions in the header */
  502. lc->header.nr_regions = lc->region_count;
  503. header_to_disk(&lc->header, lc->disk_header);
  504. /* write the new header */
  505. r = rw_header(lc, WRITE);
  506. if (r) {
  507. DMWARN("%s: Failed to write header on dirty region log device",
  508. lc->log_dev->name);
  509. fail_log_device(lc);
  510. }
  511. return r;
  512. }
  513. static uint32_t core_get_region_size(struct dm_dirty_log *log)
  514. {
  515. struct log_c *lc = (struct log_c *) log->context;
  516. return lc->region_size;
  517. }
  518. static int core_resume(struct dm_dirty_log *log)
  519. {
  520. struct log_c *lc = (struct log_c *) log->context;
  521. lc->sync_search = 0;
  522. return 0;
  523. }
  524. static int core_is_clean(struct dm_dirty_log *log, region_t region)
  525. {
  526. struct log_c *lc = (struct log_c *) log->context;
  527. return log_test_bit(lc->clean_bits, region);
  528. }
  529. static int core_in_sync(struct dm_dirty_log *log, region_t region, int block)
  530. {
  531. struct log_c *lc = (struct log_c *) log->context;
  532. return log_test_bit(lc->sync_bits, region);
  533. }
  534. static int core_flush(struct dm_dirty_log *log)
  535. {
  536. /* no op */
  537. return 0;
  538. }
  539. static int disk_flush(struct dm_dirty_log *log)
  540. {
  541. int r;
  542. struct log_c *lc = (struct log_c *) log->context;
  543. /* only write if the log has changed */
  544. if (!lc->touched)
  545. return 0;
  546. r = rw_header(lc, WRITE);
  547. if (r)
  548. fail_log_device(lc);
  549. else
  550. lc->touched = 0;
  551. return r;
  552. }
  553. static void core_mark_region(struct dm_dirty_log *log, region_t region)
  554. {
  555. struct log_c *lc = (struct log_c *) log->context;
  556. log_clear_bit(lc, lc->clean_bits, region);
  557. }
  558. static void core_clear_region(struct dm_dirty_log *log, region_t region)
  559. {
  560. struct log_c *lc = (struct log_c *) log->context;
  561. log_set_bit(lc, lc->clean_bits, region);
  562. }
  563. static int core_get_resync_work(struct dm_dirty_log *log, region_t *region)
  564. {
  565. struct log_c *lc = (struct log_c *) log->context;
  566. if (lc->sync_search >= lc->region_count)
  567. return 0;
  568. do {
  569. *region = ext2_find_next_zero_bit(
  570. (unsigned long *) lc->sync_bits,
  571. lc->region_count,
  572. lc->sync_search);
  573. lc->sync_search = *region + 1;
  574. if (*region >= lc->region_count)
  575. return 0;
  576. } while (log_test_bit(lc->recovering_bits, *region));
  577. log_set_bit(lc, lc->recovering_bits, *region);
  578. return 1;
  579. }
  580. static void core_set_region_sync(struct dm_dirty_log *log, region_t region,
  581. int in_sync)
  582. {
  583. struct log_c *lc = (struct log_c *) log->context;
  584. log_clear_bit(lc, lc->recovering_bits, region);
  585. if (in_sync) {
  586. log_set_bit(lc, lc->sync_bits, region);
  587. lc->sync_count++;
  588. } else if (log_test_bit(lc->sync_bits, region)) {
  589. lc->sync_count--;
  590. log_clear_bit(lc, lc->sync_bits, region);
  591. }
  592. }
  593. static region_t core_get_sync_count(struct dm_dirty_log *log)
  594. {
  595. struct log_c *lc = (struct log_c *) log->context;
  596. return lc->sync_count;
  597. }
  598. #define DMEMIT_SYNC \
  599. if (lc->sync != DEFAULTSYNC) \
  600. DMEMIT("%ssync ", lc->sync == NOSYNC ? "no" : "")
  601. static int core_status(struct dm_dirty_log *log, status_type_t status,
  602. char *result, unsigned int maxlen)
  603. {
  604. int sz = 0;
  605. struct log_c *lc = log->context;
  606. switch(status) {
  607. case STATUSTYPE_INFO:
  608. DMEMIT("1 %s", log->type->name);
  609. break;
  610. case STATUSTYPE_TABLE:
  611. DMEMIT("%s %u %u ", log->type->name,
  612. lc->sync == DEFAULTSYNC ? 1 : 2, lc->region_size);
  613. DMEMIT_SYNC;
  614. }
  615. return sz;
  616. }
  617. static int disk_status(struct dm_dirty_log *log, status_type_t status,
  618. char *result, unsigned int maxlen)
  619. {
  620. int sz = 0;
  621. struct log_c *lc = log->context;
  622. switch(status) {
  623. case STATUSTYPE_INFO:
  624. DMEMIT("3 %s %s %c", log->type->name, lc->log_dev->name,
  625. lc->log_dev_failed ? 'D' : 'A');
  626. break;
  627. case STATUSTYPE_TABLE:
  628. DMEMIT("%s %u %s %u ", log->type->name,
  629. lc->sync == DEFAULTSYNC ? 2 : 3, lc->log_dev->name,
  630. lc->region_size);
  631. DMEMIT_SYNC;
  632. }
  633. return sz;
  634. }
  635. static struct dm_dirty_log_type _core_type = {
  636. .name = "core",
  637. .module = THIS_MODULE,
  638. .ctr = core_ctr,
  639. .dtr = core_dtr,
  640. .resume = core_resume,
  641. .get_region_size = core_get_region_size,
  642. .is_clean = core_is_clean,
  643. .in_sync = core_in_sync,
  644. .flush = core_flush,
  645. .mark_region = core_mark_region,
  646. .clear_region = core_clear_region,
  647. .get_resync_work = core_get_resync_work,
  648. .set_region_sync = core_set_region_sync,
  649. .get_sync_count = core_get_sync_count,
  650. .status = core_status,
  651. };
  652. static struct dm_dirty_log_type _disk_type = {
  653. .name = "disk",
  654. .module = THIS_MODULE,
  655. .ctr = disk_ctr,
  656. .dtr = disk_dtr,
  657. .postsuspend = disk_flush,
  658. .resume = disk_resume,
  659. .get_region_size = core_get_region_size,
  660. .is_clean = core_is_clean,
  661. .in_sync = core_in_sync,
  662. .flush = disk_flush,
  663. .mark_region = core_mark_region,
  664. .clear_region = core_clear_region,
  665. .get_resync_work = core_get_resync_work,
  666. .set_region_sync = core_set_region_sync,
  667. .get_sync_count = core_get_sync_count,
  668. .status = disk_status,
  669. };
  670. static int __init dm_dirty_log_init(void)
  671. {
  672. int r;
  673. r = dm_dirty_log_type_register(&_core_type);
  674. if (r)
  675. DMWARN("couldn't register core log");
  676. r = dm_dirty_log_type_register(&_disk_type);
  677. if (r) {
  678. DMWARN("couldn't register disk type");
  679. dm_dirty_log_type_unregister(&_core_type);
  680. }
  681. return r;
  682. }
  683. static void __exit dm_dirty_log_exit(void)
  684. {
  685. dm_dirty_log_type_unregister(&_disk_type);
  686. dm_dirty_log_type_unregister(&_core_type);
  687. }
  688. module_init(dm_dirty_log_init);
  689. module_exit(dm_dirty_log_exit);
  690. MODULE_DESCRIPTION(DM_NAME " dirty region log");
  691. MODULE_AUTHOR("Joe Thornber, Heinz Mauelshagen <dm-devel@redhat.com>");
  692. MODULE_LICENSE("GPL");