blob: 6951536ea29ceab63c8dca6facdb8253ac311dac [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Copyright (C) 2003 Sistina Software
Heinz Mauelshagenb7fd54a2008-04-24 21:43:06 +01003 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 * This file is released under the LGPL.
6 */
7
8#include <linux/init.h>
9#include <linux/slab.h>
10#include <linux/module.h>
11#include <linux/vmalloc.h>
Alasdair G Kergona765e202008-04-24 22:02:01 +010012#include <linux/dm-io.h>
13#include <linux/dm-dirty-log.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014
Mikulas Patocka586e80e2008-10-21 17:44:59 +010015#include <linux/device-mapper.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016
Heinz Mauelshagenb7fd54a2008-04-24 21:43:06 +010017#define DM_MSG_PREFIX "dirty region log"
Alasdair G Kergon72d94862006-06-26 00:27:35 -070018
Linus Torvalds1da177e2005-04-16 15:20:36 -070019static LIST_HEAD(_log_types);
20static DEFINE_SPINLOCK(_lock);
21
Mike Snitzerec44ab92009-04-02 19:55:30 +010022static struct dm_dirty_log_type *__find_dirty_log_type(const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -070023{
Mike Snitzerec44ab92009-04-02 19:55:30 +010024 struct dm_dirty_log_type *log_type;
Jonathan Brassow2a23aa12008-04-24 21:43:41 +010025
26 list_for_each_entry(log_type, &_log_types, list)
Mike Snitzerec44ab92009-04-02 19:55:30 +010027 if (!strcmp(name, log_type->name))
Jonathan Brassow2a23aa12008-04-24 21:43:41 +010028 return log_type;
29
30 return NULL;
31}
32
Mike Snitzerec44ab92009-04-02 19:55:30 +010033static struct dm_dirty_log_type *_get_dirty_log_type(const char *name)
Jonathan Brassow2a23aa12008-04-24 21:43:41 +010034{
Mike Snitzerec44ab92009-04-02 19:55:30 +010035 struct dm_dirty_log_type *log_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
37 spin_lock(&_lock);
Jonathan Brassow2a23aa12008-04-24 21:43:41 +010038
39 log_type = __find_dirty_log_type(name);
Mike Snitzerec44ab92009-04-02 19:55:30 +010040 if (log_type && !try_module_get(log_type->module))
Mike Snitzer84e67c92009-04-02 19:55:29 +010041 log_type = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
43 spin_unlock(&_lock);
Jonathan Brassow2a23aa12008-04-24 21:43:41 +010044
45 return log_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -070046}
47
Jonathan Brassowfb8b2842008-02-08 02:11:19 +000048/*
49 * get_type
50 * @type_name
51 *
Jonathan Brassow2a23aa12008-04-24 21:43:41 +010052 * Attempt to retrieve the dm_dirty_log_type by name. If not already
Jonathan Brassowfb8b2842008-02-08 02:11:19 +000053 * available, attempt to load the appropriate module.
54 *
55 * Log modules are named "dm-log-" followed by the 'type_name'.
56 * Modules may contain multiple types.
57 * This function will first try the module "dm-log-<type_name>",
58 * then truncate 'type_name' on the last '-' and try again.
59 *
60 * For example, if type_name was "clustered-disk", it would search
61 * 'dm-log-clustered-disk' then 'dm-log-clustered'.
62 *
63 * Returns: dirty_log_type* on success, NULL on failure
64 */
Heinz Mauelshagen416cd172008-04-24 21:43:35 +010065static struct dm_dirty_log_type *get_type(const char *type_name)
Jonathan Brassowfb8b2842008-02-08 02:11:19 +000066{
67 char *p, *type_name_dup;
Mike Snitzerec44ab92009-04-02 19:55:30 +010068 struct dm_dirty_log_type *log_type;
Jonathan Brassowfb8b2842008-02-08 02:11:19 +000069
Jonathan Brassow2a23aa12008-04-24 21:43:41 +010070 if (!type_name)
71 return NULL;
72
73 log_type = _get_dirty_log_type(type_name);
74 if (log_type)
Mike Snitzerec44ab92009-04-02 19:55:30 +010075 return log_type;
Jonathan Brassowfb8b2842008-02-08 02:11:19 +000076
77 type_name_dup = kstrdup(type_name, GFP_KERNEL);
78 if (!type_name_dup) {
79 DMWARN("No memory left to attempt log module load for \"%s\"",
80 type_name);
81 return NULL;
82 }
83
84 while (request_module("dm-log-%s", type_name_dup) ||
Jonathan Brassow2a23aa12008-04-24 21:43:41 +010085 !(log_type = _get_dirty_log_type(type_name))) {
Jonathan Brassowfb8b2842008-02-08 02:11:19 +000086 p = strrchr(type_name_dup, '-');
87 if (!p)
88 break;
89 p[0] = '\0';
90 }
91
Jonathan Brassow2a23aa12008-04-24 21:43:41 +010092 if (!log_type)
Jonathan Brassowfb8b2842008-02-08 02:11:19 +000093 DMWARN("Module for logging type \"%s\" not found.", type_name);
94
95 kfree(type_name_dup);
96
Mike Snitzerec44ab92009-04-02 19:55:30 +010097 return log_type;
Jonathan Brassowfb8b2842008-02-08 02:11:19 +000098}
99
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100100static void put_type(struct dm_dirty_log_type *type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101{
Jonathan Brassow2a23aa12008-04-24 21:43:41 +0100102 if (!type)
103 return;
104
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 spin_lock(&_lock);
Mike Snitzerec44ab92009-04-02 19:55:30 +0100106 if (!__find_dirty_log_type(type->name))
Jonathan Brassow2a23aa12008-04-24 21:43:41 +0100107 goto out;
108
Mike Snitzer84e67c92009-04-02 19:55:29 +0100109 module_put(type->module);
Jonathan Brassow2a23aa12008-04-24 21:43:41 +0100110
111out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 spin_unlock(&_lock);
113}
114
Alasdair G Kergonb8206bc2008-04-24 21:43:38 +0100115int dm_dirty_log_type_register(struct dm_dirty_log_type *type)
116{
Jonathan Brassow2a23aa12008-04-24 21:43:41 +0100117 int r = 0;
118
Alasdair G Kergonb8206bc2008-04-24 21:43:38 +0100119 spin_lock(&_lock);
Jonathan Brassow2a23aa12008-04-24 21:43:41 +0100120 if (!__find_dirty_log_type(type->name))
Mike Snitzerec44ab92009-04-02 19:55:30 +0100121 list_add(&type->list, &_log_types);
122 else
Jonathan Brassow2a23aa12008-04-24 21:43:41 +0100123 r = -EEXIST;
Alasdair G Kergonb8206bc2008-04-24 21:43:38 +0100124 spin_unlock(&_lock);
125
Jonathan Brassow2a23aa12008-04-24 21:43:41 +0100126 return r;
Alasdair G Kergonb8206bc2008-04-24 21:43:38 +0100127}
128EXPORT_SYMBOL(dm_dirty_log_type_register);
129
130int dm_dirty_log_type_unregister(struct dm_dirty_log_type *type)
131{
132 spin_lock(&_lock);
133
Mike Snitzerec44ab92009-04-02 19:55:30 +0100134 if (!__find_dirty_log_type(type->name)) {
Jonathan Brassow2a23aa12008-04-24 21:43:41 +0100135 spin_unlock(&_lock);
136 return -EINVAL;
137 }
138
Mike Snitzerec44ab92009-04-02 19:55:30 +0100139 list_del(&type->list);
Alasdair G Kergonb8206bc2008-04-24 21:43:38 +0100140
141 spin_unlock(&_lock);
142
143 return 0;
144}
145EXPORT_SYMBOL(dm_dirty_log_type_unregister);
146
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100147struct dm_dirty_log *dm_dirty_log_create(const char *type_name,
Mikulas Patocka87a8f242009-12-10 23:52:01 +0000148 struct dm_target *ti,
149 int (*flush_callback_fn)(struct dm_target *ti),
150 unsigned int argc, char **argv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151{
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100152 struct dm_dirty_log_type *type;
153 struct dm_dirty_log *log;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
155 log = kmalloc(sizeof(*log), GFP_KERNEL);
156 if (!log)
157 return NULL;
158
159 type = get_type(type_name);
160 if (!type) {
161 kfree(log);
162 return NULL;
163 }
164
Mikulas Patocka87a8f242009-12-10 23:52:01 +0000165 log->flush_callback_fn = flush_callback_fn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 log->type = type;
167 if (type->ctr(log, ti, argc, argv)) {
168 kfree(log);
169 put_type(type);
170 return NULL;
171 }
172
173 return log;
174}
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100175EXPORT_SYMBOL(dm_dirty_log_create);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100177void dm_dirty_log_destroy(struct dm_dirty_log *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178{
179 log->type->dtr(log);
180 put_type(log->type);
181 kfree(log);
182}
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100183EXPORT_SYMBOL(dm_dirty_log_destroy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184
185/*-----------------------------------------------------------------
186 * Persistent and core logs share a lot of their implementation.
187 * FIXME: need a reload method to be called from a resume
188 *---------------------------------------------------------------*/
189/*
190 * Magic for persistent mirrors: "MiRr"
191 */
192#define MIRROR_MAGIC 0x4D695272
193
194/*
195 * The on-disk version of the metadata.
196 */
Patrick Caulfielda4fc4712006-02-01 03:04:51 -0800197#define MIRROR_DISK_VERSION 2
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198#define LOG_OFFSET 2
199
200struct log_header {
201 uint32_t magic;
202
203 /*
204 * Simple, incrementing version. no backward
205 * compatibility.
206 */
207 uint32_t version;
208 sector_t nr_regions;
209};
210
211struct log_c {
212 struct dm_target *ti;
Mikulas Patockab09acf12009-12-10 23:51:59 +0000213 int touched_dirtied;
214 int touched_cleaned;
Mikulas Patocka5adc78d2009-12-10 23:52:00 +0000215 int flush_failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 uint32_t region_size;
217 unsigned int region_count;
218 region_t sync_count;
219
220 unsigned bitset_uint32_count;
221 uint32_t *clean_bits;
222 uint32_t *sync_bits;
223 uint32_t *recovering_bits; /* FIXME: this seems excessive */
224
225 int sync_search;
226
227 /* Resync flag */
228 enum sync {
229 DEFAULTSYNC, /* Synchronize if necessary */
230 NOSYNC, /* Devices known to be already in sync */
231 FORCESYNC, /* Force a sync to happen */
232 } sync;
233
Heinz Mauelshagen5d234d12007-05-09 02:33:03 -0700234 struct dm_io_request io_req;
235
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 /*
237 * Disk log fields
238 */
Jonathan E Brassow01d03a62007-05-09 02:32:57 -0700239 int log_dev_failed;
Mikulas Patocka64b30c42009-12-10 23:52:02 +0000240 int log_dev_flush_failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 struct dm_dev *log_dev;
242 struct log_header header;
243
Heinz Mauelshagen22a1ceb2008-04-24 21:43:17 +0100244 struct dm_io_region header_location;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 struct log_header *disk_header;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246};
247
248/*
249 * The touched member needs to be updated every time we access
250 * one of the bitsets.
251 */
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100252static inline int log_test_bit(uint32_t *bs, unsigned bit)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253{
Patrick Caulfielda4fc4712006-02-01 03:04:51 -0800254 return ext2_test_bit(bit, (unsigned long *) bs) ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255}
256
257static inline void log_set_bit(struct log_c *l,
258 uint32_t *bs, unsigned bit)
259{
Patrick Caulfielda4fc4712006-02-01 03:04:51 -0800260 ext2_set_bit(bit, (unsigned long *) bs);
Mikulas Patockab09acf12009-12-10 23:51:59 +0000261 l->touched_cleaned = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262}
263
264static inline void log_clear_bit(struct log_c *l,
265 uint32_t *bs, unsigned bit)
266{
Patrick Caulfielda4fc4712006-02-01 03:04:51 -0800267 ext2_clear_bit(bit, (unsigned long *) bs);
Mikulas Patockab09acf12009-12-10 23:51:59 +0000268 l->touched_dirtied = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269}
270
271/*----------------------------------------------------------------
272 * Header IO
273 *--------------------------------------------------------------*/
274static void header_to_disk(struct log_header *core, struct log_header *disk)
275{
276 disk->magic = cpu_to_le32(core->magic);
277 disk->version = cpu_to_le32(core->version);
278 disk->nr_regions = cpu_to_le64(core->nr_regions);
279}
280
281static void header_from_disk(struct log_header *core, struct log_header *disk)
282{
283 core->magic = le32_to_cpu(disk->magic);
284 core->version = le32_to_cpu(disk->version);
285 core->nr_regions = le64_to_cpu(disk->nr_regions);
286}
287
Heinz Mauelshagen5d234d12007-05-09 02:33:03 -0700288static int rw_header(struct log_c *lc, int rw)
289{
290 lc->io_req.bi_rw = rw;
Heinz Mauelshagen5d234d12007-05-09 02:33:03 -0700291
292 return dm_io(&lc->io_req, 1, &lc->header_location, NULL);
293}
294
Mikulas Patocka20a34a82009-12-10 23:52:00 +0000295static int flush_header(struct log_c *lc)
296{
297 struct dm_io_region null_location = {
298 .bdev = lc->header_location.bdev,
299 .sector = 0,
300 .count = 0,
301 };
302
Tejun Heod87f4c12010-09-03 11:56:19 +0200303 lc->io_req.bi_rw = WRITE_FLUSH;
Mikulas Patocka20a34a82009-12-10 23:52:00 +0000304
305 return dm_io(&lc->io_req, 1, &null_location, NULL);
306}
307
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308static int read_header(struct log_c *log)
309{
310 int r;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311
Heinz Mauelshagen5d234d12007-05-09 02:33:03 -0700312 r = rw_header(log, READ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 if (r)
314 return r;
315
316 header_from_disk(&log->header, log->disk_header);
317
318 /* New log required? */
319 if (log->sync != DEFAULTSYNC || log->header.magic != MIRROR_MAGIC) {
320 log->header.magic = MIRROR_MAGIC;
321 log->header.version = MIRROR_DISK_VERSION;
322 log->header.nr_regions = 0;
323 }
324
Patrick Caulfielda4fc4712006-02-01 03:04:51 -0800325#ifdef __LITTLE_ENDIAN
326 if (log->header.version == 1)
327 log->header.version = 2;
328#endif
329
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 if (log->header.version != MIRROR_DISK_VERSION) {
331 DMWARN("incompatible disk log version");
332 return -EINVAL;
333 }
334
335 return 0;
336}
337
Milan Broz2045e882009-01-06 03:05:01 +0000338static int _check_region_size(struct dm_target *ti, uint32_t region_size)
339{
340 if (region_size < 2 || region_size > ti->len)
341 return 0;
342
343 if (!is_power_of_2(region_size))
344 return 0;
345
346 return 1;
347}
348
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349/*----------------------------------------------------------------
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 * core log constructor/destructor
351 *
352 * argv contains region_size followed optionally by [no]sync
353 *--------------------------------------------------------------*/
354#define BYTE_SHIFT 3
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100355static int create_log_context(struct dm_dirty_log *log, struct dm_target *ti,
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700356 unsigned int argc, char **argv,
357 struct dm_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358{
359 enum sync sync = DEFAULTSYNC;
360
361 struct log_c *lc;
362 uint32_t region_size;
363 unsigned int region_count;
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700364 size_t bitset_size, buf_size;
Heinz Mauelshagen5d234d12007-05-09 02:33:03 -0700365 int r;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366
367 if (argc < 1 || argc > 2) {
Heinz Mauelshagenb7fd54a2008-04-24 21:43:06 +0100368 DMWARN("wrong number of arguments to dirty region log");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 return -EINVAL;
370 }
371
372 if (argc > 1) {
373 if (!strcmp(argv[1], "sync"))
374 sync = FORCESYNC;
375 else if (!strcmp(argv[1], "nosync"))
376 sync = NOSYNC;
377 else {
Heinz Mauelshagenb7fd54a2008-04-24 21:43:06 +0100378 DMWARN("unrecognised sync argument to "
379 "dirty region log: %s", argv[1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 return -EINVAL;
381 }
382 }
383
Milan Broz2045e882009-01-06 03:05:01 +0000384 if (sscanf(argv[0], "%u", &region_size) != 1 ||
385 !_check_region_size(ti, region_size)) {
386 DMWARN("invalid region size %s", argv[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 return -EINVAL;
388 }
389
390 region_count = dm_sector_div_up(ti->len, region_size);
391
392 lc = kmalloc(sizeof(*lc), GFP_KERNEL);
393 if (!lc) {
394 DMWARN("couldn't allocate core log");
395 return -ENOMEM;
396 }
397
398 lc->ti = ti;
Mikulas Patockab09acf12009-12-10 23:51:59 +0000399 lc->touched_dirtied = 0;
400 lc->touched_cleaned = 0;
Mikulas Patocka5adc78d2009-12-10 23:52:00 +0000401 lc->flush_failed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 lc->region_size = region_size;
403 lc->region_count = region_count;
404 lc->sync = sync;
405
406 /*
Alasdair G Kergon0e568222005-11-21 21:32:34 -0800407 * Work out how many "unsigned long"s we need to hold the bitset.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 */
409 bitset_size = dm_round_up(region_count,
Alasdair G Kergon29121bd2006-06-26 00:27:29 -0700410 sizeof(*lc->clean_bits) << BYTE_SHIFT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 bitset_size >>= BYTE_SHIFT;
412
Alasdair G Kergon29121bd2006-06-26 00:27:29 -0700413 lc->bitset_uint32_count = bitset_size / sizeof(*lc->clean_bits);
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700414
415 /*
416 * Disk log?
417 */
418 if (!dev) {
419 lc->clean_bits = vmalloc(bitset_size);
420 if (!lc->clean_bits) {
421 DMWARN("couldn't allocate clean bitset");
422 kfree(lc);
423 return -ENOMEM;
424 }
425 lc->disk_header = NULL;
426 } else {
427 lc->log_dev = dev;
Jonathan E Brassow01d03a62007-05-09 02:32:57 -0700428 lc->log_dev_failed = 0;
Mikulas Patocka64b30c42009-12-10 23:52:02 +0000429 lc->log_dev_flush_failed = 0;
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700430 lc->header_location.bdev = lc->log_dev->bdev;
431 lc->header_location.sector = 0;
432
433 /*
434 * Buffer holds both header and bitset.
435 */
Mike Snitzer18d85942009-06-22 10:12:33 +0100436 buf_size =
437 dm_round_up((LOG_OFFSET << SECTOR_SHIFT) + bitset_size,
438 bdev_logical_block_size(lc->header_location.
439 bdev));
Milan Brozac1f0ac2009-01-06 03:05:02 +0000440
Mikulas Patocka5657e8f2009-06-22 10:12:14 +0100441 if (buf_size > i_size_read(dev->bdev->bd_inode)) {
Milan Brozac1f0ac2009-01-06 03:05:02 +0000442 DMWARN("log device %s too small: need %llu bytes",
443 dev->name, (unsigned long long)buf_size);
444 kfree(lc);
445 return -EINVAL;
446 }
447
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700448 lc->header_location.count = buf_size >> SECTOR_SHIFT;
Takahiro Yasui6f3af012009-01-06 03:04:59 +0000449
Heinz Mauelshagen5d234d12007-05-09 02:33:03 -0700450 lc->io_req.mem.type = DM_IO_VMA;
Takahiro Yasui6f3af012009-01-06 03:04:59 +0000451 lc->io_req.notify.fn = NULL;
Heinz Mauelshagen5d234d12007-05-09 02:33:03 -0700452 lc->io_req.client = dm_io_client_create(dm_div_up(buf_size,
453 PAGE_SIZE));
454 if (IS_ERR(lc->io_req.client)) {
455 r = PTR_ERR(lc->io_req.client);
456 DMWARN("couldn't allocate disk io client");
457 kfree(lc);
Dan Carpenterdbc883f2011-01-13 20:00:00 +0000458 return r;
Heinz Mauelshagen5d234d12007-05-09 02:33:03 -0700459 }
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700460
461 lc->disk_header = vmalloc(buf_size);
462 if (!lc->disk_header) {
463 DMWARN("couldn't allocate disk log buffer");
Takahiro Yasuic7a2bd12009-01-06 03:04:56 +0000464 dm_io_client_destroy(lc->io_req.client);
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700465 kfree(lc);
466 return -ENOMEM;
467 }
468
Takahiro Yasui6f3af012009-01-06 03:04:59 +0000469 lc->io_req.mem.ptr.vma = lc->disk_header;
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700470 lc->clean_bits = (void *)lc->disk_header +
471 (LOG_OFFSET << SECTOR_SHIFT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 }
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700473
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 memset(lc->clean_bits, -1, bitset_size);
475
476 lc->sync_bits = vmalloc(bitset_size);
477 if (!lc->sync_bits) {
478 DMWARN("couldn't allocate sync bitset");
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700479 if (!dev)
480 vfree(lc->clean_bits);
Takahiro Yasuic7a2bd12009-01-06 03:04:56 +0000481 else
482 dm_io_client_destroy(lc->io_req.client);
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700483 vfree(lc->disk_header);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 kfree(lc);
485 return -ENOMEM;
486 }
487 memset(lc->sync_bits, (sync == NOSYNC) ? -1 : 0, bitset_size);
488 lc->sync_count = (sync == NOSYNC) ? region_count : 0;
489
490 lc->recovering_bits = vmalloc(bitset_size);
491 if (!lc->recovering_bits) {
492 DMWARN("couldn't allocate sync bitset");
493 vfree(lc->sync_bits);
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700494 if (!dev)
495 vfree(lc->clean_bits);
Takahiro Yasuic7a2bd12009-01-06 03:04:56 +0000496 else
497 dm_io_client_destroy(lc->io_req.client);
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700498 vfree(lc->disk_header);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 kfree(lc);
500 return -ENOMEM;
501 }
502 memset(lc->recovering_bits, 0, bitset_size);
503 lc->sync_search = 0;
504 log->context = lc;
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700505
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 return 0;
507}
508
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100509static int core_ctr(struct dm_dirty_log *log, struct dm_target *ti,
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700510 unsigned int argc, char **argv)
511{
512 return create_log_context(log, ti, argc, argv, NULL);
513}
514
515static void destroy_log_context(struct log_c *lc)
516{
517 vfree(lc->sync_bits);
518 vfree(lc->recovering_bits);
519 kfree(lc);
520}
521
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100522static void core_dtr(struct dm_dirty_log *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523{
524 struct log_c *lc = (struct log_c *) log->context;
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700525
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 vfree(lc->clean_bits);
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700527 destroy_log_context(lc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528}
529
530/*----------------------------------------------------------------
531 * disk log constructor/destructor
532 *
533 * argv contains log_device region_size followed optionally by [no]sync
534 *--------------------------------------------------------------*/
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100535static int disk_ctr(struct dm_dirty_log *log, struct dm_target *ti,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 unsigned int argc, char **argv)
537{
538 int r;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 struct dm_dev *dev;
540
541 if (argc < 2 || argc > 3) {
Heinz Mauelshagenb7fd54a2008-04-24 21:43:06 +0100542 DMWARN("wrong number of arguments to disk dirty region log");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 return -EINVAL;
544 }
545
Nikanth Karthikesan8215d6e2010-03-06 02:32:27 +0000546 r = dm_get_device(ti, argv[0], FMODE_READ | FMODE_WRITE, &dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 if (r)
548 return r;
549
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700550 r = create_log_context(log, ti, argc - 1, argv + 1, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 if (r) {
552 dm_put_device(ti, dev);
553 return r;
554 }
555
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557}
558
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100559static void disk_dtr(struct dm_dirty_log *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560{
561 struct log_c *lc = (struct log_c *) log->context;
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700562
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 dm_put_device(lc->ti, lc->log_dev);
564 vfree(lc->disk_header);
Heinz Mauelshagen5d234d12007-05-09 02:33:03 -0700565 dm_io_client_destroy(lc->io_req.client);
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700566 destroy_log_context(lc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567}
568
569static int count_bits32(uint32_t *addr, unsigned size)
570{
571 int count = 0, i;
572
573 for (i = 0; i < size; i++) {
574 count += hweight32(*(addr+i));
575 }
576 return count;
577}
578
Jonathan E Brassow01d03a62007-05-09 02:32:57 -0700579static void fail_log_device(struct log_c *lc)
580{
581 if (lc->log_dev_failed)
582 return;
583
584 lc->log_dev_failed = 1;
585 dm_table_event(lc->ti->table);
586}
587
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100588static int disk_resume(struct dm_dirty_log *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589{
590 int r;
591 unsigned i;
592 struct log_c *lc = (struct log_c *) log->context;
593 size_t size = lc->bitset_uint32_count * sizeof(uint32_t);
594
595 /* read the disk header */
596 r = read_header(lc);
Jonathan E Brassow01d03a62007-05-09 02:32:57 -0700597 if (r) {
Heinz Mauelshagenb7fd54a2008-04-24 21:43:06 +0100598 DMWARN("%s: Failed to read header on dirty region log device",
Jonathan E Brassow01d03a62007-05-09 02:32:57 -0700599 lc->log_dev->name);
600 fail_log_device(lc);
Jonathan Brassowba8b45c2007-05-09 02:33:08 -0700601 /*
602 * If the log device cannot be read, we must assume
603 * all regions are out-of-sync. If we simply return
604 * here, the state will be uninitialized and could
605 * lead us to return 'in-sync' status for regions
606 * that are actually 'out-of-sync'.
607 */
608 lc->header.nr_regions = 0;
Jonathan E Brassow01d03a62007-05-09 02:32:57 -0700609 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610
Alasdair G Kergon8a835f12006-06-26 00:27:30 -0700611 /* set or clear any new bits -- device has grown */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 if (lc->sync == NOSYNC)
613 for (i = lc->header.nr_regions; i < lc->region_count; i++)
614 /* FIXME: amazingly inefficient */
615 log_set_bit(lc, lc->clean_bits, i);
616 else
617 for (i = lc->header.nr_regions; i < lc->region_count; i++)
618 /* FIXME: amazingly inefficient */
619 log_clear_bit(lc, lc->clean_bits, i);
620
Alasdair G Kergon8a835f12006-06-26 00:27:30 -0700621 /* clear any old bits -- device has shrunk */
622 for (i = lc->region_count; i % (sizeof(*lc->clean_bits) << BYTE_SHIFT); i++)
623 log_clear_bit(lc, lc->clean_bits, i);
624
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 /* copy clean across to sync */
626 memcpy(lc->sync_bits, lc->clean_bits, size);
627 lc->sync_count = count_bits32(lc->clean_bits, lc->bitset_uint32_count);
Jonathan E Brassow88b20a12006-12-08 02:41:12 -0800628 lc->sync_search = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 /* set the correct number of regions in the header */
631 lc->header.nr_regions = lc->region_count;
632
Takahiro Yasui6f3af012009-01-06 03:04:59 +0000633 header_to_disk(&lc->header, lc->disk_header);
634
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 /* write the new header */
Takahiro Yasui6f3af012009-01-06 03:04:59 +0000636 r = rw_header(lc, WRITE);
Mikulas Patocka64b30c42009-12-10 23:52:02 +0000637 if (!r) {
Mikulas Patocka20a34a82009-12-10 23:52:00 +0000638 r = flush_header(lc);
Mikulas Patocka64b30c42009-12-10 23:52:02 +0000639 if (r)
640 lc->log_dev_flush_failed = 1;
641 }
Jonathan E Brassow01d03a62007-05-09 02:32:57 -0700642 if (r) {
Heinz Mauelshagenb7fd54a2008-04-24 21:43:06 +0100643 DMWARN("%s: Failed to write header on dirty region log device",
Jonathan E Brassow01d03a62007-05-09 02:32:57 -0700644 lc->log_dev->name);
645 fail_log_device(lc);
646 }
647
648 return r;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649}
650
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100651static uint32_t core_get_region_size(struct dm_dirty_log *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652{
653 struct log_c *lc = (struct log_c *) log->context;
654 return lc->region_size;
655}
656
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100657static int core_resume(struct dm_dirty_log *log)
Jonathan E Brassow88b20a12006-12-08 02:41:12 -0800658{
659 struct log_c *lc = (struct log_c *) log->context;
660 lc->sync_search = 0;
661 return 0;
662}
663
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100664static int core_is_clean(struct dm_dirty_log *log, region_t region)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665{
666 struct log_c *lc = (struct log_c *) log->context;
667 return log_test_bit(lc->clean_bits, region);
668}
669
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100670static int core_in_sync(struct dm_dirty_log *log, region_t region, int block)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671{
672 struct log_c *lc = (struct log_c *) log->context;
673 return log_test_bit(lc->sync_bits, region);
674}
675
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100676static int core_flush(struct dm_dirty_log *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677{
678 /* no op */
679 return 0;
680}
681
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100682static int disk_flush(struct dm_dirty_log *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683{
Mikulas Patocka076010e22009-12-10 23:52:01 +0000684 int r, i;
685 struct log_c *lc = log->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686
687 /* only write if the log has changed */
Mikulas Patockab09acf12009-12-10 23:51:59 +0000688 if (!lc->touched_cleaned && !lc->touched_dirtied)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 return 0;
690
Mikulas Patocka076010e22009-12-10 23:52:01 +0000691 if (lc->touched_cleaned && log->flush_callback_fn &&
692 log->flush_callback_fn(lc->ti)) {
693 /*
694 * At this point it is impossible to determine which
695 * regions are clean and which are dirty (without
696 * re-reading the log off disk). So mark all of them
697 * dirty.
698 */
699 lc->flush_failed = 1;
700 for (i = 0; i < lc->region_count; i++)
701 log_clear_bit(lc, lc->clean_bits, i);
702 }
703
Takahiro Yasui6f3af012009-01-06 03:04:59 +0000704 r = rw_header(lc, WRITE);
Jonathan E Brassow01d03a62007-05-09 02:32:57 -0700705 if (r)
706 fail_log_device(lc);
Mikulas Patockab09acf12009-12-10 23:51:59 +0000707 else {
Mikulas Patocka20a34a82009-12-10 23:52:00 +0000708 if (lc->touched_dirtied) {
709 r = flush_header(lc);
Mikulas Patocka64b30c42009-12-10 23:52:02 +0000710 if (r) {
711 lc->log_dev_flush_failed = 1;
Mikulas Patocka20a34a82009-12-10 23:52:00 +0000712 fail_log_device(lc);
Mikulas Patocka64b30c42009-12-10 23:52:02 +0000713 } else
Mikulas Patocka20a34a82009-12-10 23:52:00 +0000714 lc->touched_dirtied = 0;
715 }
Mikulas Patockab09acf12009-12-10 23:51:59 +0000716 lc->touched_cleaned = 0;
717 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718
719 return r;
720}
721
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100722static void core_mark_region(struct dm_dirty_log *log, region_t region)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723{
724 struct log_c *lc = (struct log_c *) log->context;
725 log_clear_bit(lc, lc->clean_bits, region);
726}
727
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100728static void core_clear_region(struct dm_dirty_log *log, region_t region)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729{
730 struct log_c *lc = (struct log_c *) log->context;
Mikulas Patocka5adc78d2009-12-10 23:52:00 +0000731 if (likely(!lc->flush_failed))
732 log_set_bit(lc, lc->clean_bits, region);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733}
734
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100735static int core_get_resync_work(struct dm_dirty_log *log, region_t *region)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736{
737 struct log_c *lc = (struct log_c *) log->context;
738
739 if (lc->sync_search >= lc->region_count)
740 return 0;
741
742 do {
Stefan Bader1113a7e2006-02-02 14:28:07 -0800743 *region = ext2_find_next_zero_bit(
744 (unsigned long *) lc->sync_bits,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 lc->region_count,
746 lc->sync_search);
747 lc->sync_search = *region + 1;
748
Darrick J. Wongac81b2e2006-01-06 00:20:11 -0800749 if (*region >= lc->region_count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 return 0;
751
752 } while (log_test_bit(lc->recovering_bits, *region));
753
754 log_set_bit(lc, lc->recovering_bits, *region);
755 return 1;
756}
757
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100758static void core_set_region_sync(struct dm_dirty_log *log, region_t region,
Jonathan E Brassowf3ee6b22006-12-08 02:41:11 -0800759 int in_sync)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760{
761 struct log_c *lc = (struct log_c *) log->context;
762
763 log_clear_bit(lc, lc->recovering_bits, region);
Jonathan E Brassowf3ee6b22006-12-08 02:41:11 -0800764 if (in_sync) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 log_set_bit(lc, lc->sync_bits, region);
766 lc->sync_count++;
Jonathan E Brassowf3ee6b22006-12-08 02:41:11 -0800767 } else if (log_test_bit(lc->sync_bits, region)) {
768 lc->sync_count--;
769 log_clear_bit(lc, lc->sync_bits, region);
770 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771}
772
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100773static region_t core_get_sync_count(struct dm_dirty_log *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774{
775 struct log_c *lc = (struct log_c *) log->context;
776
777 return lc->sync_count;
778}
779
780#define DMEMIT_SYNC \
781 if (lc->sync != DEFAULTSYNC) \
782 DMEMIT("%ssync ", lc->sync == NOSYNC ? "no" : "")
783
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100784static int core_status(struct dm_dirty_log *log, status_type_t status,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 char *result, unsigned int maxlen)
786{
787 int sz = 0;
788 struct log_c *lc = log->context;
789
790 switch(status) {
791 case STATUSTYPE_INFO:
Jonathan E Brassow315dcc22007-05-09 02:32:58 -0700792 DMEMIT("1 %s", log->type->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 break;
794
795 case STATUSTYPE_TABLE:
796 DMEMIT("%s %u %u ", log->type->name,
797 lc->sync == DEFAULTSYNC ? 1 : 2, lc->region_size);
798 DMEMIT_SYNC;
799 }
800
801 return sz;
802}
803
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100804static int disk_status(struct dm_dirty_log *log, status_type_t status,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 char *result, unsigned int maxlen)
806{
807 int sz = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 struct log_c *lc = log->context;
809
810 switch(status) {
811 case STATUSTYPE_INFO:
Jonathan E Brassow315dcc22007-05-09 02:32:58 -0700812 DMEMIT("3 %s %s %c", log->type->name, lc->log_dev->name,
Mikulas Patocka64b30c42009-12-10 23:52:02 +0000813 lc->log_dev_flush_failed ? 'F' :
814 lc->log_dev_failed ? 'D' :
815 'A');
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 break;
817
818 case STATUSTYPE_TABLE:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 DMEMIT("%s %u %s %u ", log->type->name,
Jonathan E Brassow315dcc22007-05-09 02:32:58 -0700820 lc->sync == DEFAULTSYNC ? 2 : 3, lc->log_dev->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 lc->region_size);
822 DMEMIT_SYNC;
823 }
824
825 return sz;
826}
827
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100828static struct dm_dirty_log_type _core_type = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 .name = "core",
830 .module = THIS_MODULE,
831 .ctr = core_ctr,
832 .dtr = core_dtr,
Jonathan E Brassow88b20a12006-12-08 02:41:12 -0800833 .resume = core_resume,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 .get_region_size = core_get_region_size,
835 .is_clean = core_is_clean,
836 .in_sync = core_in_sync,
837 .flush = core_flush,
838 .mark_region = core_mark_region,
839 .clear_region = core_clear_region,
840 .get_resync_work = core_get_resync_work,
Jonathan E Brassowf3ee6b22006-12-08 02:41:11 -0800841 .set_region_sync = core_set_region_sync,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 .get_sync_count = core_get_sync_count,
843 .status = core_status,
844};
845
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100846static struct dm_dirty_log_type _disk_type = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 .name = "disk",
848 .module = THIS_MODULE,
849 .ctr = disk_ctr,
850 .dtr = disk_dtr,
Jonathan Brassow6b3df0d2007-10-19 22:47:57 +0100851 .postsuspend = disk_flush,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 .resume = disk_resume,
853 .get_region_size = core_get_region_size,
854 .is_clean = core_is_clean,
855 .in_sync = core_in_sync,
856 .flush = disk_flush,
857 .mark_region = core_mark_region,
858 .clear_region = core_clear_region,
859 .get_resync_work = core_get_resync_work,
Jonathan E Brassowf3ee6b22006-12-08 02:41:11 -0800860 .set_region_sync = core_set_region_sync,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 .get_sync_count = core_get_sync_count,
862 .status = disk_status,
863};
864
Adrian Bunkc8da2f82008-07-21 12:00:27 +0100865static int __init dm_dirty_log_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866{
867 int r;
868
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100869 r = dm_dirty_log_type_register(&_core_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 if (r)
871 DMWARN("couldn't register core log");
872
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100873 r = dm_dirty_log_type_register(&_disk_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 if (r) {
875 DMWARN("couldn't register disk type");
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100876 dm_dirty_log_type_unregister(&_core_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 }
878
879 return r;
880}
881
Adrian Bunkc8da2f82008-07-21 12:00:27 +0100882static void __exit dm_dirty_log_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883{
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100884 dm_dirty_log_type_unregister(&_disk_type);
885 dm_dirty_log_type_unregister(&_core_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886}
887
Heinz Mauelshagen769aef32008-04-24 21:43:09 +0100888module_init(dm_dirty_log_init);
889module_exit(dm_dirty_log_exit);
890
891MODULE_DESCRIPTION(DM_NAME " dirty region log");
892MODULE_AUTHOR("Joe Thornber, Heinz Mauelshagen <dm-devel@redhat.com>");
893MODULE_LICENSE("GPL");