blob: 3b52bb72bd1f0cb8717798c121008a76784b9aa0 [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
Alasdair G Kergon283a8322011-08-02 12:32:01 +0100200struct log_header_disk {
201 __le32 magic;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202
203 /*
204 * Simple, incrementing version. no backward
205 * compatibility.
206 */
Alasdair G Kergon283a8322011-08-02 12:32:01 +0100207 __le32 version;
208 __le64 nr_regions;
209} __packed;
210
211struct log_header_core {
212 uint32_t magic;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 uint32_t version;
Alasdair G Kergon283a8322011-08-02 12:32:01 +0100214 uint64_t nr_regions;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215};
216
217struct log_c {
218 struct dm_target *ti;
Mikulas Patockab09acf12009-12-10 23:51:59 +0000219 int touched_dirtied;
220 int touched_cleaned;
Mikulas Patocka5adc78d2009-12-10 23:52:00 +0000221 int flush_failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 uint32_t region_size;
223 unsigned int region_count;
224 region_t sync_count;
225
226 unsigned bitset_uint32_count;
227 uint32_t *clean_bits;
228 uint32_t *sync_bits;
229 uint32_t *recovering_bits; /* FIXME: this seems excessive */
230
231 int sync_search;
232
233 /* Resync flag */
234 enum sync {
235 DEFAULTSYNC, /* Synchronize if necessary */
236 NOSYNC, /* Devices known to be already in sync */
237 FORCESYNC, /* Force a sync to happen */
238 } sync;
239
Heinz Mauelshagen5d234d12007-05-09 02:33:03 -0700240 struct dm_io_request io_req;
241
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 /*
243 * Disk log fields
244 */
Jonathan E Brassow01d03a62007-05-09 02:32:57 -0700245 int log_dev_failed;
Mikulas Patocka64b30c42009-12-10 23:52:02 +0000246 int log_dev_flush_failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 struct dm_dev *log_dev;
Alasdair G Kergon283a8322011-08-02 12:32:01 +0100248 struct log_header_core header;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249
Heinz Mauelshagen22a1ceb2008-04-24 21:43:17 +0100250 struct dm_io_region header_location;
Alasdair G Kergon283a8322011-08-02 12:32:01 +0100251 struct log_header_disk *disk_header;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252};
253
254/*
255 * The touched member needs to be updated every time we access
256 * one of the bitsets.
257 */
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100258static inline int log_test_bit(uint32_t *bs, unsigned bit)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259{
Akinobu Mitac8f543e2011-08-02 12:32:01 +0100260 return test_bit_le(bit, bs) ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261}
262
263static inline void log_set_bit(struct log_c *l,
264 uint32_t *bs, unsigned bit)
265{
Akinobu Mitac8f543e2011-08-02 12:32:01 +0100266 __set_bit_le(bit, bs);
Mikulas Patockab09acf12009-12-10 23:51:59 +0000267 l->touched_cleaned = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268}
269
270static inline void log_clear_bit(struct log_c *l,
271 uint32_t *bs, unsigned bit)
272{
Akinobu Mitac8f543e2011-08-02 12:32:01 +0100273 __clear_bit_le(bit, bs);
Mikulas Patockab09acf12009-12-10 23:51:59 +0000274 l->touched_dirtied = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275}
276
277/*----------------------------------------------------------------
278 * Header IO
279 *--------------------------------------------------------------*/
Alasdair G Kergon283a8322011-08-02 12:32:01 +0100280static void header_to_disk(struct log_header_core *core, struct log_header_disk *disk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281{
282 disk->magic = cpu_to_le32(core->magic);
283 disk->version = cpu_to_le32(core->version);
284 disk->nr_regions = cpu_to_le64(core->nr_regions);
285}
286
Alasdair G Kergon283a8322011-08-02 12:32:01 +0100287static void header_from_disk(struct log_header_core *core, struct log_header_disk *disk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288{
289 core->magic = le32_to_cpu(disk->magic);
290 core->version = le32_to_cpu(disk->version);
291 core->nr_regions = le64_to_cpu(disk->nr_regions);
292}
293
Heinz Mauelshagen5d234d12007-05-09 02:33:03 -0700294static int rw_header(struct log_c *lc, int rw)
295{
296 lc->io_req.bi_rw = rw;
Heinz Mauelshagen5d234d12007-05-09 02:33:03 -0700297
298 return dm_io(&lc->io_req, 1, &lc->header_location, NULL);
299}
300
Mikulas Patocka20a34a82009-12-10 23:52:00 +0000301static int flush_header(struct log_c *lc)
302{
303 struct dm_io_region null_location = {
304 .bdev = lc->header_location.bdev,
305 .sector = 0,
306 .count = 0,
307 };
308
Tejun Heod87f4c12010-09-03 11:56:19 +0200309 lc->io_req.bi_rw = WRITE_FLUSH;
Mikulas Patocka20a34a82009-12-10 23:52:00 +0000310
311 return dm_io(&lc->io_req, 1, &null_location, NULL);
312}
313
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314static int read_header(struct log_c *log)
315{
316 int r;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317
Heinz Mauelshagen5d234d12007-05-09 02:33:03 -0700318 r = rw_header(log, READ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 if (r)
320 return r;
321
322 header_from_disk(&log->header, log->disk_header);
323
324 /* New log required? */
325 if (log->sync != DEFAULTSYNC || log->header.magic != MIRROR_MAGIC) {
326 log->header.magic = MIRROR_MAGIC;
327 log->header.version = MIRROR_DISK_VERSION;
328 log->header.nr_regions = 0;
329 }
330
Patrick Caulfielda4fc4712006-02-01 03:04:51 -0800331#ifdef __LITTLE_ENDIAN
332 if (log->header.version == 1)
333 log->header.version = 2;
334#endif
335
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 if (log->header.version != MIRROR_DISK_VERSION) {
337 DMWARN("incompatible disk log version");
338 return -EINVAL;
339 }
340
341 return 0;
342}
343
Milan Broz2045e882009-01-06 03:05:01 +0000344static int _check_region_size(struct dm_target *ti, uint32_t region_size)
345{
346 if (region_size < 2 || region_size > ti->len)
347 return 0;
348
349 if (!is_power_of_2(region_size))
350 return 0;
351
352 return 1;
353}
354
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355/*----------------------------------------------------------------
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 * core log constructor/destructor
357 *
358 * argv contains region_size followed optionally by [no]sync
359 *--------------------------------------------------------------*/
360#define BYTE_SHIFT 3
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100361static int create_log_context(struct dm_dirty_log *log, struct dm_target *ti,
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700362 unsigned int argc, char **argv,
363 struct dm_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364{
365 enum sync sync = DEFAULTSYNC;
366
367 struct log_c *lc;
368 uint32_t region_size;
369 unsigned int region_count;
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700370 size_t bitset_size, buf_size;
Heinz Mauelshagen5d234d12007-05-09 02:33:03 -0700371 int r;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372
373 if (argc < 1 || argc > 2) {
Heinz Mauelshagenb7fd54a2008-04-24 21:43:06 +0100374 DMWARN("wrong number of arguments to dirty region log");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 return -EINVAL;
376 }
377
378 if (argc > 1) {
379 if (!strcmp(argv[1], "sync"))
380 sync = FORCESYNC;
381 else if (!strcmp(argv[1], "nosync"))
382 sync = NOSYNC;
383 else {
Heinz Mauelshagenb7fd54a2008-04-24 21:43:06 +0100384 DMWARN("unrecognised sync argument to "
385 "dirty region log: %s", argv[1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 return -EINVAL;
387 }
388 }
389
Milan Broz2045e882009-01-06 03:05:01 +0000390 if (sscanf(argv[0], "%u", &region_size) != 1 ||
391 !_check_region_size(ti, region_size)) {
392 DMWARN("invalid region size %s", argv[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 return -EINVAL;
394 }
395
396 region_count = dm_sector_div_up(ti->len, region_size);
397
398 lc = kmalloc(sizeof(*lc), GFP_KERNEL);
399 if (!lc) {
400 DMWARN("couldn't allocate core log");
401 return -ENOMEM;
402 }
403
404 lc->ti = ti;
Mikulas Patockab09acf12009-12-10 23:51:59 +0000405 lc->touched_dirtied = 0;
406 lc->touched_cleaned = 0;
Mikulas Patocka5adc78d2009-12-10 23:52:00 +0000407 lc->flush_failed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 lc->region_size = region_size;
409 lc->region_count = region_count;
410 lc->sync = sync;
411
412 /*
Alasdair G Kergon0e568222005-11-21 21:32:34 -0800413 * Work out how many "unsigned long"s we need to hold the bitset.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 */
415 bitset_size = dm_round_up(region_count,
Alasdair G Kergon29121bd2006-06-26 00:27:29 -0700416 sizeof(*lc->clean_bits) << BYTE_SHIFT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 bitset_size >>= BYTE_SHIFT;
418
Alasdair G Kergon29121bd2006-06-26 00:27:29 -0700419 lc->bitset_uint32_count = bitset_size / sizeof(*lc->clean_bits);
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700420
421 /*
422 * Disk log?
423 */
424 if (!dev) {
425 lc->clean_bits = vmalloc(bitset_size);
426 if (!lc->clean_bits) {
427 DMWARN("couldn't allocate clean bitset");
428 kfree(lc);
429 return -ENOMEM;
430 }
431 lc->disk_header = NULL;
432 } else {
433 lc->log_dev = dev;
Jonathan E Brassow01d03a62007-05-09 02:32:57 -0700434 lc->log_dev_failed = 0;
Mikulas Patocka64b30c42009-12-10 23:52:02 +0000435 lc->log_dev_flush_failed = 0;
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700436 lc->header_location.bdev = lc->log_dev->bdev;
437 lc->header_location.sector = 0;
438
439 /*
440 * Buffer holds both header and bitset.
441 */
Mike Snitzer18d85942009-06-22 10:12:33 +0100442 buf_size =
443 dm_round_up((LOG_OFFSET << SECTOR_SHIFT) + bitset_size,
444 bdev_logical_block_size(lc->header_location.
445 bdev));
Milan Brozac1f0ac2009-01-06 03:05:02 +0000446
Mikulas Patocka5657e8f2009-06-22 10:12:14 +0100447 if (buf_size > i_size_read(dev->bdev->bd_inode)) {
Milan Brozac1f0ac2009-01-06 03:05:02 +0000448 DMWARN("log device %s too small: need %llu bytes",
449 dev->name, (unsigned long long)buf_size);
450 kfree(lc);
451 return -EINVAL;
452 }
453
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700454 lc->header_location.count = buf_size >> SECTOR_SHIFT;
Takahiro Yasui6f3af012009-01-06 03:04:59 +0000455
Heinz Mauelshagen5d234d12007-05-09 02:33:03 -0700456 lc->io_req.mem.type = DM_IO_VMA;
Takahiro Yasui6f3af012009-01-06 03:04:59 +0000457 lc->io_req.notify.fn = NULL;
Mikulas Patockabda8efe2011-05-29 13:03:09 +0100458 lc->io_req.client = dm_io_client_create();
Heinz Mauelshagen5d234d12007-05-09 02:33:03 -0700459 if (IS_ERR(lc->io_req.client)) {
460 r = PTR_ERR(lc->io_req.client);
461 DMWARN("couldn't allocate disk io client");
462 kfree(lc);
Dan Carpenterdbc883f2011-01-13 20:00:00 +0000463 return r;
Heinz Mauelshagen5d234d12007-05-09 02:33:03 -0700464 }
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700465
466 lc->disk_header = vmalloc(buf_size);
467 if (!lc->disk_header) {
468 DMWARN("couldn't allocate disk log buffer");
Takahiro Yasuic7a2bd12009-01-06 03:04:56 +0000469 dm_io_client_destroy(lc->io_req.client);
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700470 kfree(lc);
471 return -ENOMEM;
472 }
473
Takahiro Yasui6f3af012009-01-06 03:04:59 +0000474 lc->io_req.mem.ptr.vma = lc->disk_header;
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700475 lc->clean_bits = (void *)lc->disk_header +
476 (LOG_OFFSET << SECTOR_SHIFT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 }
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700478
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 memset(lc->clean_bits, -1, bitset_size);
480
481 lc->sync_bits = vmalloc(bitset_size);
482 if (!lc->sync_bits) {
483 DMWARN("couldn't allocate sync bitset");
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700484 if (!dev)
485 vfree(lc->clean_bits);
Takahiro Yasuic7a2bd12009-01-06 03:04:56 +0000486 else
487 dm_io_client_destroy(lc->io_req.client);
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700488 vfree(lc->disk_header);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 kfree(lc);
490 return -ENOMEM;
491 }
492 memset(lc->sync_bits, (sync == NOSYNC) ? -1 : 0, bitset_size);
493 lc->sync_count = (sync == NOSYNC) ? region_count : 0;
494
Joe Perchese29e65a2011-08-02 12:32:02 +0100495 lc->recovering_bits = vzalloc(bitset_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 if (!lc->recovering_bits) {
497 DMWARN("couldn't allocate sync bitset");
498 vfree(lc->sync_bits);
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700499 if (!dev)
500 vfree(lc->clean_bits);
Takahiro Yasuic7a2bd12009-01-06 03:04:56 +0000501 else
502 dm_io_client_destroy(lc->io_req.client);
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700503 vfree(lc->disk_header);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 kfree(lc);
505 return -ENOMEM;
506 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 lc->sync_search = 0;
508 log->context = lc;
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700509
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 return 0;
511}
512
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100513static int core_ctr(struct dm_dirty_log *log, struct dm_target *ti,
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700514 unsigned int argc, char **argv)
515{
516 return create_log_context(log, ti, argc, argv, NULL);
517}
518
519static void destroy_log_context(struct log_c *lc)
520{
521 vfree(lc->sync_bits);
522 vfree(lc->recovering_bits);
523 kfree(lc);
524}
525
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100526static void core_dtr(struct dm_dirty_log *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527{
528 struct log_c *lc = (struct log_c *) log->context;
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700529
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 vfree(lc->clean_bits);
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700531 destroy_log_context(lc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532}
533
534/*----------------------------------------------------------------
535 * disk log constructor/destructor
536 *
537 * argv contains log_device region_size followed optionally by [no]sync
538 *--------------------------------------------------------------*/
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100539static int disk_ctr(struct dm_dirty_log *log, struct dm_target *ti,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 unsigned int argc, char **argv)
541{
542 int r;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 struct dm_dev *dev;
544
545 if (argc < 2 || argc > 3) {
Heinz Mauelshagenb7fd54a2008-04-24 21:43:06 +0100546 DMWARN("wrong number of arguments to disk dirty region log");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 return -EINVAL;
548 }
549
Milan Broz024d37e2011-03-24 13:52:14 +0000550 r = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 if (r)
552 return r;
553
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700554 r = create_log_context(log, ti, argc - 1, argv + 1, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 if (r) {
556 dm_put_device(ti, dev);
557 return r;
558 }
559
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561}
562
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100563static void disk_dtr(struct dm_dirty_log *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564{
565 struct log_c *lc = (struct log_c *) log->context;
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700566
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 dm_put_device(lc->ti, lc->log_dev);
568 vfree(lc->disk_header);
Heinz Mauelshagen5d234d12007-05-09 02:33:03 -0700569 dm_io_client_destroy(lc->io_req.client);
Alasdair G Kergonb7cca192006-06-26 00:27:29 -0700570 destroy_log_context(lc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571}
572
573static int count_bits32(uint32_t *addr, unsigned size)
574{
575 int count = 0, i;
576
577 for (i = 0; i < size; i++) {
578 count += hweight32(*(addr+i));
579 }
580 return count;
581}
582
Jonathan E Brassow01d03a62007-05-09 02:32:57 -0700583static void fail_log_device(struct log_c *lc)
584{
585 if (lc->log_dev_failed)
586 return;
587
588 lc->log_dev_failed = 1;
589 dm_table_event(lc->ti->table);
590}
591
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100592static int disk_resume(struct dm_dirty_log *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593{
594 int r;
595 unsigned i;
596 struct log_c *lc = (struct log_c *) log->context;
597 size_t size = lc->bitset_uint32_count * sizeof(uint32_t);
598
599 /* read the disk header */
600 r = read_header(lc);
Jonathan E Brassow01d03a62007-05-09 02:32:57 -0700601 if (r) {
Heinz Mauelshagenb7fd54a2008-04-24 21:43:06 +0100602 DMWARN("%s: Failed to read header on dirty region log device",
Jonathan E Brassow01d03a62007-05-09 02:32:57 -0700603 lc->log_dev->name);
604 fail_log_device(lc);
Jonathan Brassowba8b45c2007-05-09 02:33:08 -0700605 /*
606 * If the log device cannot be read, we must assume
607 * all regions are out-of-sync. If we simply return
608 * here, the state will be uninitialized and could
609 * lead us to return 'in-sync' status for regions
610 * that are actually 'out-of-sync'.
611 */
612 lc->header.nr_regions = 0;
Jonathan E Brassow01d03a62007-05-09 02:32:57 -0700613 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614
Alasdair G Kergon8a835f12006-06-26 00:27:30 -0700615 /* set or clear any new bits -- device has grown */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 if (lc->sync == NOSYNC)
617 for (i = lc->header.nr_regions; i < lc->region_count; i++)
618 /* FIXME: amazingly inefficient */
619 log_set_bit(lc, lc->clean_bits, i);
620 else
621 for (i = lc->header.nr_regions; i < lc->region_count; i++)
622 /* FIXME: amazingly inefficient */
623 log_clear_bit(lc, lc->clean_bits, i);
624
Alasdair G Kergon8a835f12006-06-26 00:27:30 -0700625 /* clear any old bits -- device has shrunk */
626 for (i = lc->region_count; i % (sizeof(*lc->clean_bits) << BYTE_SHIFT); i++)
627 log_clear_bit(lc, lc->clean_bits, i);
628
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 /* copy clean across to sync */
630 memcpy(lc->sync_bits, lc->clean_bits, size);
631 lc->sync_count = count_bits32(lc->clean_bits, lc->bitset_uint32_count);
Jonathan E Brassow88b20a12006-12-08 02:41:12 -0800632 lc->sync_search = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 /* set the correct number of regions in the header */
635 lc->header.nr_regions = lc->region_count;
636
Takahiro Yasui6f3af012009-01-06 03:04:59 +0000637 header_to_disk(&lc->header, lc->disk_header);
638
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 /* write the new header */
Takahiro Yasui6f3af012009-01-06 03:04:59 +0000640 r = rw_header(lc, WRITE);
Mikulas Patocka64b30c42009-12-10 23:52:02 +0000641 if (!r) {
Mikulas Patocka20a34a82009-12-10 23:52:00 +0000642 r = flush_header(lc);
Mikulas Patocka64b30c42009-12-10 23:52:02 +0000643 if (r)
644 lc->log_dev_flush_failed = 1;
645 }
Jonathan E Brassow01d03a62007-05-09 02:32:57 -0700646 if (r) {
Heinz Mauelshagenb7fd54a2008-04-24 21:43:06 +0100647 DMWARN("%s: Failed to write header on dirty region log device",
Jonathan E Brassow01d03a62007-05-09 02:32:57 -0700648 lc->log_dev->name);
649 fail_log_device(lc);
650 }
651
652 return r;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653}
654
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100655static uint32_t core_get_region_size(struct dm_dirty_log *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656{
657 struct log_c *lc = (struct log_c *) log->context;
658 return lc->region_size;
659}
660
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100661static int core_resume(struct dm_dirty_log *log)
Jonathan E Brassow88b20a12006-12-08 02:41:12 -0800662{
663 struct log_c *lc = (struct log_c *) log->context;
664 lc->sync_search = 0;
665 return 0;
666}
667
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100668static int core_is_clean(struct dm_dirty_log *log, region_t region)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669{
670 struct log_c *lc = (struct log_c *) log->context;
671 return log_test_bit(lc->clean_bits, region);
672}
673
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100674static int core_in_sync(struct dm_dirty_log *log, region_t region, int block)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675{
676 struct log_c *lc = (struct log_c *) log->context;
677 return log_test_bit(lc->sync_bits, region);
678}
679
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100680static int core_flush(struct dm_dirty_log *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681{
682 /* no op */
683 return 0;
684}
685
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100686static int disk_flush(struct dm_dirty_log *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687{
Mikulas Patocka076010e22009-12-10 23:52:01 +0000688 int r, i;
689 struct log_c *lc = log->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
691 /* only write if the log has changed */
Mikulas Patockab09acf12009-12-10 23:51:59 +0000692 if (!lc->touched_cleaned && !lc->touched_dirtied)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 return 0;
694
Mikulas Patocka076010e22009-12-10 23:52:01 +0000695 if (lc->touched_cleaned && log->flush_callback_fn &&
696 log->flush_callback_fn(lc->ti)) {
697 /*
698 * At this point it is impossible to determine which
699 * regions are clean and which are dirty (without
700 * re-reading the log off disk). So mark all of them
701 * dirty.
702 */
703 lc->flush_failed = 1;
704 for (i = 0; i < lc->region_count; i++)
705 log_clear_bit(lc, lc->clean_bits, i);
706 }
707
Takahiro Yasui6f3af012009-01-06 03:04:59 +0000708 r = rw_header(lc, WRITE);
Jonathan E Brassow01d03a62007-05-09 02:32:57 -0700709 if (r)
710 fail_log_device(lc);
Mikulas Patockab09acf12009-12-10 23:51:59 +0000711 else {
Mikulas Patocka20a34a82009-12-10 23:52:00 +0000712 if (lc->touched_dirtied) {
713 r = flush_header(lc);
Mikulas Patocka64b30c42009-12-10 23:52:02 +0000714 if (r) {
715 lc->log_dev_flush_failed = 1;
Mikulas Patocka20a34a82009-12-10 23:52:00 +0000716 fail_log_device(lc);
Mikulas Patocka64b30c42009-12-10 23:52:02 +0000717 } else
Mikulas Patocka20a34a82009-12-10 23:52:00 +0000718 lc->touched_dirtied = 0;
719 }
Mikulas Patockab09acf12009-12-10 23:51:59 +0000720 lc->touched_cleaned = 0;
721 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722
723 return r;
724}
725
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100726static void core_mark_region(struct dm_dirty_log *log, region_t region)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727{
728 struct log_c *lc = (struct log_c *) log->context;
729 log_clear_bit(lc, lc->clean_bits, region);
730}
731
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100732static void core_clear_region(struct dm_dirty_log *log, region_t region)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733{
734 struct log_c *lc = (struct log_c *) log->context;
Mikulas Patocka5adc78d2009-12-10 23:52:00 +0000735 if (likely(!lc->flush_failed))
736 log_set_bit(lc, lc->clean_bits, region);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737}
738
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100739static int core_get_resync_work(struct dm_dirty_log *log, region_t *region)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740{
741 struct log_c *lc = (struct log_c *) log->context;
742
743 if (lc->sync_search >= lc->region_count)
744 return 0;
745
746 do {
Akinobu Mitac8f543e2011-08-02 12:32:01 +0100747 *region = find_next_zero_bit_le(lc->sync_bits,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 lc->region_count,
749 lc->sync_search);
750 lc->sync_search = *region + 1;
751
Darrick J. Wongac81b2e2006-01-06 00:20:11 -0800752 if (*region >= lc->region_count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 return 0;
754
755 } while (log_test_bit(lc->recovering_bits, *region));
756
757 log_set_bit(lc, lc->recovering_bits, *region);
758 return 1;
759}
760
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100761static void core_set_region_sync(struct dm_dirty_log *log, region_t region,
Jonathan E Brassowf3ee6b22006-12-08 02:41:11 -0800762 int in_sync)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763{
764 struct log_c *lc = (struct log_c *) log->context;
765
766 log_clear_bit(lc, lc->recovering_bits, region);
Jonathan E Brassowf3ee6b22006-12-08 02:41:11 -0800767 if (in_sync) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 log_set_bit(lc, lc->sync_bits, region);
769 lc->sync_count++;
Jonathan E Brassowf3ee6b22006-12-08 02:41:11 -0800770 } else if (log_test_bit(lc->sync_bits, region)) {
771 lc->sync_count--;
772 log_clear_bit(lc, lc->sync_bits, region);
773 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774}
775
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100776static region_t core_get_sync_count(struct dm_dirty_log *log)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777{
778 struct log_c *lc = (struct log_c *) log->context;
779
780 return lc->sync_count;
781}
782
783#define DMEMIT_SYNC \
784 if (lc->sync != DEFAULTSYNC) \
785 DMEMIT("%ssync ", lc->sync == NOSYNC ? "no" : "")
786
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100787static int core_status(struct dm_dirty_log *log, status_type_t status,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 char *result, unsigned int maxlen)
789{
790 int sz = 0;
791 struct log_c *lc = log->context;
792
793 switch(status) {
794 case STATUSTYPE_INFO:
Jonathan E Brassow315dcc22007-05-09 02:32:58 -0700795 DMEMIT("1 %s", log->type->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 break;
797
798 case STATUSTYPE_TABLE:
799 DMEMIT("%s %u %u ", log->type->name,
800 lc->sync == DEFAULTSYNC ? 1 : 2, lc->region_size);
801 DMEMIT_SYNC;
802 }
803
804 return sz;
805}
806
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100807static int disk_status(struct dm_dirty_log *log, status_type_t status,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 char *result, unsigned int maxlen)
809{
810 int sz = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 struct log_c *lc = log->context;
812
813 switch(status) {
814 case STATUSTYPE_INFO:
Jonathan E Brassow315dcc22007-05-09 02:32:58 -0700815 DMEMIT("3 %s %s %c", log->type->name, lc->log_dev->name,
Mikulas Patocka64b30c42009-12-10 23:52:02 +0000816 lc->log_dev_flush_failed ? 'F' :
817 lc->log_dev_failed ? 'D' :
818 'A');
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 break;
820
821 case STATUSTYPE_TABLE:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 DMEMIT("%s %u %s %u ", log->type->name,
Jonathan E Brassow315dcc22007-05-09 02:32:58 -0700823 lc->sync == DEFAULTSYNC ? 2 : 3, lc->log_dev->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 lc->region_size);
825 DMEMIT_SYNC;
826 }
827
828 return sz;
829}
830
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100831static struct dm_dirty_log_type _core_type = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 .name = "core",
833 .module = THIS_MODULE,
834 .ctr = core_ctr,
835 .dtr = core_dtr,
Jonathan E Brassow88b20a12006-12-08 02:41:12 -0800836 .resume = core_resume,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 .get_region_size = core_get_region_size,
838 .is_clean = core_is_clean,
839 .in_sync = core_in_sync,
840 .flush = core_flush,
841 .mark_region = core_mark_region,
842 .clear_region = core_clear_region,
843 .get_resync_work = core_get_resync_work,
Jonathan E Brassowf3ee6b22006-12-08 02:41:11 -0800844 .set_region_sync = core_set_region_sync,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 .get_sync_count = core_get_sync_count,
846 .status = core_status,
847};
848
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100849static struct dm_dirty_log_type _disk_type = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 .name = "disk",
851 .module = THIS_MODULE,
852 .ctr = disk_ctr,
853 .dtr = disk_dtr,
Jonathan Brassow6b3df0d2007-10-19 22:47:57 +0100854 .postsuspend = disk_flush,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 .resume = disk_resume,
856 .get_region_size = core_get_region_size,
857 .is_clean = core_is_clean,
858 .in_sync = core_in_sync,
859 .flush = disk_flush,
860 .mark_region = core_mark_region,
861 .clear_region = core_clear_region,
862 .get_resync_work = core_get_resync_work,
Jonathan E Brassowf3ee6b22006-12-08 02:41:11 -0800863 .set_region_sync = core_set_region_sync,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 .get_sync_count = core_get_sync_count,
865 .status = disk_status,
866};
867
Adrian Bunkc8da2f82008-07-21 12:00:27 +0100868static int __init dm_dirty_log_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869{
870 int r;
871
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100872 r = dm_dirty_log_type_register(&_core_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 if (r)
874 DMWARN("couldn't register core log");
875
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100876 r = dm_dirty_log_type_register(&_disk_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 if (r) {
878 DMWARN("couldn't register disk type");
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100879 dm_dirty_log_type_unregister(&_core_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 }
881
882 return r;
883}
884
Adrian Bunkc8da2f82008-07-21 12:00:27 +0100885static void __exit dm_dirty_log_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886{
Heinz Mauelshagen416cd172008-04-24 21:43:35 +0100887 dm_dirty_log_type_unregister(&_disk_type);
888 dm_dirty_log_type_unregister(&_core_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889}
890
Heinz Mauelshagen769aef32008-04-24 21:43:09 +0100891module_init(dm_dirty_log_init);
892module_exit(dm_dirty_log_exit);
893
894MODULE_DESCRIPTION(DM_NAME " dirty region log");
895MODULE_AUTHOR("Joe Thornber, Heinz Mauelshagen <dm-devel@redhat.com>");
896MODULE_LICENSE("GPL");