blob: 0c746420c00810f9c2e57ad346f3bd2589250821 [file] [log] [blame]
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +00001/*
2 * Copyright (C) 2001-2002 Sistina Software (UK) Limited.
3 * Copyright (C) 2006-2008 Red Hat GmbH
4 *
5 * This file is released under the GPL.
6 */
7
8#include "dm-exception-store.h"
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +00009
10#include <linux/mm.h>
11#include <linux/pagemap.h>
12#include <linux/vmalloc.h>
13#include <linux/slab.h>
14#include <linux/dm-io.h>
15
16#define DM_MSG_PREFIX "persistent snapshot"
17#define DM_CHUNK_SIZE_DEFAULT_SECTORS 32 /* 16KB */
18
19/*-----------------------------------------------------------------
20 * Persistent snapshots, by persistent we mean that the snapshot
21 * will survive a reboot.
22 *---------------------------------------------------------------*/
23
24/*
25 * We need to store a record of which parts of the origin have
26 * been copied to the snapshot device. The snapshot code
27 * requires that we copy exception chunks to chunk aligned areas
28 * of the COW store. It makes sense therefore, to store the
29 * metadata in chunk size blocks.
30 *
31 * There is no backward or forward compatibility implemented,
32 * snapshots with different disk versions than the kernel will
33 * not be usable. It is expected that "lvcreate" will blank out
34 * the start of a fresh COW device before calling the snapshot
35 * constructor.
36 *
37 * The first chunk of the COW device just contains the header.
38 * After this there is a chunk filled with exception metadata,
39 * followed by as many exception chunks as can fit in the
40 * metadata areas.
41 *
42 * All on disk structures are in little-endian format. The end
43 * of the exceptions info is indicated by an exception with a
44 * new_chunk of 0, which is invalid since it would point to the
45 * header chunk.
46 */
47
48/*
49 * Magic for persistent snapshots: "SnAp" - Feeble isn't it.
50 */
51#define SNAP_MAGIC 0x70416e53
52
53/*
54 * The on-disk version of the metadata.
55 */
56#define SNAPSHOT_DISK_VERSION 1
57
58struct disk_header {
59 uint32_t magic;
60
61 /*
62 * Is this snapshot valid. There is no way of recovering
63 * an invalid snapshot.
64 */
65 uint32_t valid;
66
67 /*
68 * Simple, incrementing version. no backward
69 * compatibility.
70 */
71 uint32_t version;
72
73 /* In sectors */
74 uint32_t chunk_size;
75};
76
77struct disk_exception {
78 uint64_t old_chunk;
79 uint64_t new_chunk;
80};
81
82struct commit_callback {
83 void (*callback)(void *, int success);
84 void *context;
85};
86
87/*
88 * The top level structure for a persistent exception store.
89 */
90struct pstore {
Jonathan Brassow71fab002009-04-02 19:55:33 +010091 struct dm_exception_store *store;
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +000092 int version;
93 int valid;
94 uint32_t exceptions_per_area;
95
96 /*
97 * Now that we have an asynchronous kcopyd there is no
98 * need for large chunk sizes, so it wont hurt to have a
99 * whole chunks worth of metadata in memory at once.
100 */
101 void *area;
102
103 /*
104 * An area of zeros used to clear the next area.
105 */
106 void *zero_area;
107
108 /*
Mikulas Patocka61578dc2009-09-04 20:40:39 +0100109 * An area used for header. The header can be written
110 * concurrently with metadata (when invalidating the snapshot),
111 * so it needs a separate buffer.
112 */
113 void *header_area;
114
115 /*
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000116 * Used to keep track of which metadata area the data in
117 * 'chunk' refers to.
118 */
119 chunk_t current_area;
120
121 /*
122 * The next free chunk for an exception.
123 */
124 chunk_t next_free;
125
126 /*
127 * The index of next free exception in the current
128 * metadata area.
129 */
130 uint32_t current_committed;
131
132 atomic_t pending_count;
133 uint32_t callback_count;
134 struct commit_callback *callbacks;
135 struct dm_io_client *io_client;
136
137 struct workqueue_struct *metadata_wq;
138};
139
140static unsigned sectors_to_pages(unsigned sectors)
141{
142 return DIV_ROUND_UP(sectors, PAGE_SIZE >> 9);
143}
144
145static int alloc_area(struct pstore *ps)
146{
147 int r = -ENOMEM;
148 size_t len;
149
Jonathan Brassow71fab002009-04-02 19:55:33 +0100150 len = ps->store->chunk_size << SECTOR_SHIFT;
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000151
152 /*
153 * Allocate the chunk_size block of memory that will hold
154 * a single metadata area.
155 */
156 ps->area = vmalloc(len);
157 if (!ps->area)
Mikulas Patocka61578dc2009-09-04 20:40:39 +0100158 goto err_area;
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000159
160 ps->zero_area = vmalloc(len);
Mikulas Patocka61578dc2009-09-04 20:40:39 +0100161 if (!ps->zero_area)
162 goto err_zero_area;
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000163 memset(ps->zero_area, 0, len);
164
Mikulas Patocka61578dc2009-09-04 20:40:39 +0100165 ps->header_area = vmalloc(len);
166 if (!ps->header_area)
167 goto err_header_area;
168
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000169 return 0;
Mikulas Patocka61578dc2009-09-04 20:40:39 +0100170
171err_header_area:
172 vfree(ps->zero_area);
173
174err_zero_area:
175 vfree(ps->area);
176
177err_area:
178 return r;
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000179}
180
181static void free_area(struct pstore *ps)
182{
Jonathan Brassowa32079c2009-04-02 19:55:35 +0100183 if (ps->area)
184 vfree(ps->area);
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000185 ps->area = NULL;
Jonathan Brassowa32079c2009-04-02 19:55:35 +0100186
187 if (ps->zero_area)
188 vfree(ps->zero_area);
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000189 ps->zero_area = NULL;
Mikulas Patocka61578dc2009-09-04 20:40:39 +0100190
191 if (ps->header_area)
192 vfree(ps->header_area);
193 ps->header_area = NULL;
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000194}
195
196struct mdata_req {
197 struct dm_io_region *where;
198 struct dm_io_request *io_req;
199 struct work_struct work;
200 int result;
201};
202
203static void do_metadata(struct work_struct *work)
204{
205 struct mdata_req *req = container_of(work, struct mdata_req, work);
206
207 req->result = dm_io(req->io_req, 1, req->where, NULL);
208}
209
210/*
211 * Read or write a chunk aligned and sized block of data from a device.
212 */
Mikulas Patocka02d2fd32009-09-04 20:40:37 +0100213static int chunk_io(struct pstore *ps, void *area, chunk_t chunk, int rw,
214 int metadata)
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000215{
216 struct dm_io_region where = {
Jonathan Brassow71fab002009-04-02 19:55:33 +0100217 .bdev = ps->store->cow->bdev,
218 .sector = ps->store->chunk_size * chunk,
219 .count = ps->store->chunk_size,
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000220 };
221 struct dm_io_request io_req = {
222 .bi_rw = rw,
223 .mem.type = DM_IO_VMA,
Mikulas Patocka02d2fd32009-09-04 20:40:37 +0100224 .mem.ptr.vma = area,
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000225 .client = ps->io_client,
226 .notify.fn = NULL,
227 };
228 struct mdata_req req;
229
230 if (!metadata)
231 return dm_io(&io_req, 1, &where, NULL);
232
233 req.where = &where;
234 req.io_req = &io_req;
235
236 /*
237 * Issue the synchronous I/O from a different thread
238 * to avoid generic_make_request recursion.
239 */
240 INIT_WORK(&req.work, do_metadata);
241 queue_work(ps->metadata_wq, &req.work);
242 flush_workqueue(ps->metadata_wq);
243
244 return req.result;
245}
246
247/*
248 * Convert a metadata area index to a chunk index.
249 */
250static chunk_t area_location(struct pstore *ps, chunk_t area)
251{
252 return 1 + ((ps->exceptions_per_area + 1) * area);
253}
254
255/*
256 * Read or write a metadata area. Remembering to skip the first
257 * chunk which holds the header.
258 */
259static int area_io(struct pstore *ps, int rw)
260{
261 int r;
262 chunk_t chunk;
263
264 chunk = area_location(ps, ps->current_area);
265
Mikulas Patocka02d2fd32009-09-04 20:40:37 +0100266 r = chunk_io(ps, ps->area, chunk, rw, 0);
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000267 if (r)
268 return r;
269
270 return 0;
271}
272
273static void zero_memory_area(struct pstore *ps)
274{
Jonathan Brassow71fab002009-04-02 19:55:33 +0100275 memset(ps->area, 0, ps->store->chunk_size << SECTOR_SHIFT);
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000276}
277
278static int zero_disk_area(struct pstore *ps, chunk_t area)
279{
Mikulas Patocka02d2fd32009-09-04 20:40:37 +0100280 return chunk_io(ps, ps->zero_area, area_location(ps, area), WRITE, 0);
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000281}
282
283static int read_header(struct pstore *ps, int *new_snapshot)
284{
285 int r;
286 struct disk_header *dh;
Mikulas Patockadf96eee2009-10-16 23:18:17 +0100287 unsigned chunk_size;
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000288 int chunk_size_supplied = 1;
Mikulas Patockaae0b7442009-09-04 20:40:43 +0100289 char *chunk_err;
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000290
291 /*
Mikulas Patockadf96eee2009-10-16 23:18:17 +0100292 * Use default chunk size (or logical_block_size, if larger)
293 * if none supplied
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000294 */
Jonathan Brassow71fab002009-04-02 19:55:33 +0100295 if (!ps->store->chunk_size) {
296 ps->store->chunk_size = max(DM_CHUNK_SIZE_DEFAULT_SECTORS,
Martin K. Petersene1defc42009-05-22 17:17:49 -0400297 bdev_logical_block_size(ps->store->cow->bdev) >> 9);
Jonathan Brassow71fab002009-04-02 19:55:33 +0100298 ps->store->chunk_mask = ps->store->chunk_size - 1;
299 ps->store->chunk_shift = ffs(ps->store->chunk_size) - 1;
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000300 chunk_size_supplied = 0;
301 }
302
Jonathan Brassow71fab002009-04-02 19:55:33 +0100303 ps->io_client = dm_io_client_create(sectors_to_pages(ps->store->
304 chunk_size));
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000305 if (IS_ERR(ps->io_client))
306 return PTR_ERR(ps->io_client);
307
308 r = alloc_area(ps);
309 if (r)
310 return r;
311
Mikulas Patocka61578dc2009-09-04 20:40:39 +0100312 r = chunk_io(ps, ps->header_area, 0, READ, 1);
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000313 if (r)
314 goto bad;
315
Mikulas Patocka61578dc2009-09-04 20:40:39 +0100316 dh = ps->header_area;
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000317
318 if (le32_to_cpu(dh->magic) == 0) {
319 *new_snapshot = 1;
320 return 0;
321 }
322
323 if (le32_to_cpu(dh->magic) != SNAP_MAGIC) {
324 DMWARN("Invalid or corrupt snapshot");
325 r = -ENXIO;
326 goto bad;
327 }
328
329 *new_snapshot = 0;
330 ps->valid = le32_to_cpu(dh->valid);
331 ps->version = le32_to_cpu(dh->version);
332 chunk_size = le32_to_cpu(dh->chunk_size);
333
Mikulas Patockaae0b7442009-09-04 20:40:43 +0100334 if (ps->store->chunk_size == chunk_size)
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000335 return 0;
336
Mikulas Patockaae0b7442009-09-04 20:40:43 +0100337 if (chunk_size_supplied)
Mikulas Patockadf96eee2009-10-16 23:18:17 +0100338 DMWARN("chunk size %u in device metadata overrides "
339 "table chunk size of %u.",
340 chunk_size, ps->store->chunk_size);
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000341
342 /* We had a bogus chunk_size. Fix stuff up. */
343 free_area(ps);
344
Mikulas Patockaae0b7442009-09-04 20:40:43 +0100345 r = dm_exception_store_set_chunk_size(ps->store, chunk_size,
346 &chunk_err);
347 if (r) {
Mikulas Patockadf96eee2009-10-16 23:18:17 +0100348 DMERR("invalid on-disk chunk size %u: %s.",
349 chunk_size, chunk_err);
Mikulas Patockaae0b7442009-09-04 20:40:43 +0100350 return r;
351 }
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000352
Jonathan Brassow71fab002009-04-02 19:55:33 +0100353 r = dm_io_client_resize(sectors_to_pages(ps->store->chunk_size),
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000354 ps->io_client);
355 if (r)
356 return r;
357
358 r = alloc_area(ps);
359 return r;
360
361bad:
362 free_area(ps);
363 return r;
364}
365
366static int write_header(struct pstore *ps)
367{
368 struct disk_header *dh;
369
Mikulas Patocka61578dc2009-09-04 20:40:39 +0100370 memset(ps->header_area, 0, ps->store->chunk_size << SECTOR_SHIFT);
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000371
Mikulas Patocka61578dc2009-09-04 20:40:39 +0100372 dh = ps->header_area;
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000373 dh->magic = cpu_to_le32(SNAP_MAGIC);
374 dh->valid = cpu_to_le32(ps->valid);
375 dh->version = cpu_to_le32(ps->version);
Jonathan Brassow71fab002009-04-02 19:55:33 +0100376 dh->chunk_size = cpu_to_le32(ps->store->chunk_size);
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000377
Mikulas Patocka61578dc2009-09-04 20:40:39 +0100378 return chunk_io(ps, ps->header_area, 0, WRITE, 1);
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000379}
380
381/*
382 * Access functions for the disk exceptions, these do the endian conversions.
383 */
384static struct disk_exception *get_exception(struct pstore *ps, uint32_t index)
385{
386 BUG_ON(index >= ps->exceptions_per_area);
387
388 return ((struct disk_exception *) ps->area) + index;
389}
390
391static void read_exception(struct pstore *ps,
392 uint32_t index, struct disk_exception *result)
393{
394 struct disk_exception *e = get_exception(ps, index);
395
396 /* copy it */
397 result->old_chunk = le64_to_cpu(e->old_chunk);
398 result->new_chunk = le64_to_cpu(e->new_chunk);
399}
400
401static void write_exception(struct pstore *ps,
402 uint32_t index, struct disk_exception *de)
403{
404 struct disk_exception *e = get_exception(ps, index);
405
406 /* copy it */
407 e->old_chunk = cpu_to_le64(de->old_chunk);
408 e->new_chunk = cpu_to_le64(de->new_chunk);
409}
410
411/*
412 * Registers the exceptions that are present in the current area.
413 * 'full' is filled in to indicate if the area has been
414 * filled.
415 */
Jonathan Brassowa159c1a2009-01-06 03:05:19 +0000416static int insert_exceptions(struct pstore *ps,
417 int (*callback)(void *callback_context,
418 chunk_t old, chunk_t new),
419 void *callback_context,
420 int *full)
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000421{
422 int r;
423 unsigned int i;
424 struct disk_exception de;
425
426 /* presume the area is full */
427 *full = 1;
428
429 for (i = 0; i < ps->exceptions_per_area; i++) {
430 read_exception(ps, i, &de);
431
432 /*
433 * If the new_chunk is pointing at the start of
434 * the COW device, where the first metadata area
435 * is we know that we've hit the end of the
436 * exceptions. Therefore the area is not full.
437 */
438 if (de.new_chunk == 0LL) {
439 ps->current_committed = i;
440 *full = 0;
441 break;
442 }
443
444 /*
445 * Keep track of the start of the free chunks.
446 */
447 if (ps->next_free <= de.new_chunk)
448 ps->next_free = de.new_chunk + 1;
449
450 /*
451 * Otherwise we add the exception to the snapshot.
452 */
Jonathan Brassowa159c1a2009-01-06 03:05:19 +0000453 r = callback(callback_context, de.old_chunk, de.new_chunk);
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000454 if (r)
455 return r;
456 }
457
458 return 0;
459}
460
Jonathan Brassowa159c1a2009-01-06 03:05:19 +0000461static int read_exceptions(struct pstore *ps,
462 int (*callback)(void *callback_context, chunk_t old,
463 chunk_t new),
464 void *callback_context)
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000465{
466 int r, full = 1;
467
468 /*
469 * Keeping reading chunks and inserting exceptions until
470 * we find a partially full area.
471 */
472 for (ps->current_area = 0; full; ps->current_area++) {
473 r = area_io(ps, READ);
474 if (r)
475 return r;
476
Jonathan Brassowa159c1a2009-01-06 03:05:19 +0000477 r = insert_exceptions(ps, callback, callback_context, &full);
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000478 if (r)
479 return r;
480 }
481
482 ps->current_area--;
483
484 return 0;
485}
486
487static struct pstore *get_info(struct dm_exception_store *store)
488{
489 return (struct pstore *) store->context;
490}
491
492static void persistent_fraction_full(struct dm_exception_store *store,
493 sector_t *numerator, sector_t *denominator)
494{
Jonathan Brassowd0216842009-04-02 19:55:32 +0100495 *numerator = get_info(store)->next_free * store->chunk_size;
Jonathan Brassow49beb2b2009-04-02 19:55:33 +0100496 *denominator = get_dev_size(store->cow->bdev);
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000497}
498
Jonathan Brassow493df712009-04-02 19:55:31 +0100499static void persistent_dtr(struct dm_exception_store *store)
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000500{
501 struct pstore *ps = get_info(store);
502
503 destroy_workqueue(ps->metadata_wq);
Jonathan Brassowa32079c2009-04-02 19:55:35 +0100504
505 /* Created in read_header */
506 if (ps->io_client)
507 dm_io_client_destroy(ps->io_client);
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000508 free_area(ps);
Jonathan Brassowa32079c2009-04-02 19:55:35 +0100509
510 /* Allocated in persistent_read_metadata */
511 if (ps->callbacks)
512 vfree(ps->callbacks);
513
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000514 kfree(ps);
515}
516
Jonathan Brassowa159c1a2009-01-06 03:05:19 +0000517static int persistent_read_metadata(struct dm_exception_store *store,
518 int (*callback)(void *callback_context,
519 chunk_t old, chunk_t new),
520 void *callback_context)
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000521{
522 int r, uninitialized_var(new_snapshot);
523 struct pstore *ps = get_info(store);
524
525 /*
526 * Read the snapshot header.
527 */
528 r = read_header(ps, &new_snapshot);
529 if (r)
530 return r;
531
532 /*
533 * Now we know correct chunk_size, complete the initialisation.
534 */
Jonathan Brassow71fab002009-04-02 19:55:33 +0100535 ps->exceptions_per_area = (ps->store->chunk_size << SECTOR_SHIFT) /
536 sizeof(struct disk_exception);
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000537 ps->callbacks = dm_vcalloc(ps->exceptions_per_area,
538 sizeof(*ps->callbacks));
539 if (!ps->callbacks)
540 return -ENOMEM;
541
542 /*
543 * Do we need to setup a new snapshot ?
544 */
545 if (new_snapshot) {
546 r = write_header(ps);
547 if (r) {
548 DMWARN("write_header failed");
549 return r;
550 }
551
552 ps->current_area = 0;
553 zero_memory_area(ps);
554 r = zero_disk_area(ps, 0);
555 if (r) {
556 DMWARN("zero_disk_area(0) failed");
557 return r;
558 }
559 } else {
560 /*
561 * Sanity checks.
562 */
563 if (ps->version != SNAPSHOT_DISK_VERSION) {
564 DMWARN("unable to handle snapshot disk version %d",
565 ps->version);
566 return -EINVAL;
567 }
568
569 /*
570 * Metadata are valid, but snapshot is invalidated
571 */
572 if (!ps->valid)
573 return 1;
574
575 /*
576 * Read the metadata.
577 */
Jonathan Brassowa159c1a2009-01-06 03:05:19 +0000578 r = read_exceptions(ps, callback, callback_context);
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000579 if (r)
580 return r;
581 }
582
583 return 0;
584}
585
Jonathan Brassowa159c1a2009-01-06 03:05:19 +0000586static int persistent_prepare_exception(struct dm_exception_store *store,
587 struct dm_snap_exception *e)
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000588{
589 struct pstore *ps = get_info(store);
590 uint32_t stride;
591 chunk_t next_free;
Jonathan Brassow49beb2b2009-04-02 19:55:33 +0100592 sector_t size = get_dev_size(store->cow->bdev);
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000593
594 /* Is there enough room ? */
Jonathan Brassowd0216842009-04-02 19:55:32 +0100595 if (size < ((ps->next_free + 1) * store->chunk_size))
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000596 return -ENOSPC;
597
598 e->new_chunk = ps->next_free;
599
600 /*
601 * Move onto the next free pending, making sure to take
602 * into account the location of the metadata chunks.
603 */
604 stride = (ps->exceptions_per_area + 1);
605 next_free = ++ps->next_free;
606 if (sector_div(next_free, stride) == 1)
607 ps->next_free++;
608
609 atomic_inc(&ps->pending_count);
610 return 0;
611}
612
Jonathan Brassowa159c1a2009-01-06 03:05:19 +0000613static void persistent_commit_exception(struct dm_exception_store *store,
614 struct dm_snap_exception *e,
615 void (*callback) (void *, int success),
616 void *callback_context)
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000617{
618 unsigned int i;
619 struct pstore *ps = get_info(store);
620 struct disk_exception de;
621 struct commit_callback *cb;
622
623 de.old_chunk = e->old_chunk;
624 de.new_chunk = e->new_chunk;
625 write_exception(ps, ps->current_committed++, &de);
626
627 /*
628 * Add the callback to the back of the array. This code
629 * is the only place where the callback array is
630 * manipulated, and we know that it will never be called
631 * multiple times concurrently.
632 */
633 cb = ps->callbacks + ps->callback_count++;
634 cb->callback = callback;
635 cb->context = callback_context;
636
637 /*
638 * If there are exceptions in flight and we have not yet
639 * filled this metadata area there's nothing more to do.
640 */
641 if (!atomic_dec_and_test(&ps->pending_count) &&
642 (ps->current_committed != ps->exceptions_per_area))
643 return;
644
645 /*
646 * If we completely filled the current area, then wipe the next one.
647 */
648 if ((ps->current_committed == ps->exceptions_per_area) &&
649 zero_disk_area(ps, ps->current_area + 1))
650 ps->valid = 0;
651
652 /*
653 * Commit exceptions to disk.
654 */
Mikulas Patocka2bd02342009-06-22 10:12:26 +0100655 if (ps->valid && area_io(ps, WRITE_BARRIER))
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000656 ps->valid = 0;
657
658 /*
659 * Advance to the next area if this one is full.
660 */
661 if (ps->current_committed == ps->exceptions_per_area) {
662 ps->current_committed = 0;
663 ps->current_area++;
664 zero_memory_area(ps);
665 }
666
667 for (i = 0; i < ps->callback_count; i++) {
668 cb = ps->callbacks + i;
669 cb->callback(cb->context, ps->valid);
670 }
671
672 ps->callback_count = 0;
673}
674
Jonathan Brassowa159c1a2009-01-06 03:05:19 +0000675static void persistent_drop_snapshot(struct dm_exception_store *store)
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000676{
677 struct pstore *ps = get_info(store);
678
679 ps->valid = 0;
680 if (write_header(ps))
681 DMWARN("write header failed");
682}
683
Jonathan Brassow493df712009-04-02 19:55:31 +0100684static int persistent_ctr(struct dm_exception_store *store,
685 unsigned argc, char **argv)
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000686{
687 struct pstore *ps;
688
689 /* allocate the pstore */
Jonathan Brassowa32079c2009-04-02 19:55:35 +0100690 ps = kzalloc(sizeof(*ps), GFP_KERNEL);
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000691 if (!ps)
692 return -ENOMEM;
693
Jonathan Brassow71fab002009-04-02 19:55:33 +0100694 ps->store = store;
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000695 ps->valid = 1;
696 ps->version = SNAPSHOT_DISK_VERSION;
697 ps->area = NULL;
Mikulas Patocka61578dc2009-09-04 20:40:39 +0100698 ps->zero_area = NULL;
699 ps->header_area = NULL;
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000700 ps->next_free = 2; /* skipping the header and first area */
701 ps->current_committed = 0;
702
703 ps->callback_count = 0;
704 atomic_set(&ps->pending_count, 0);
705 ps->callbacks = NULL;
706
707 ps->metadata_wq = create_singlethread_workqueue("ksnaphd");
708 if (!ps->metadata_wq) {
709 kfree(ps);
710 DMERR("couldn't start header metadata update thread");
711 return -ENOMEM;
712 }
713
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000714 store->context = ps;
715
716 return 0;
717}
718
Jonathan Brassow1e302a92009-04-02 19:55:35 +0100719static unsigned persistent_status(struct dm_exception_store *store,
720 status_type_t status, char *result,
721 unsigned maxlen)
Jonathan Brassow493df712009-04-02 19:55:31 +0100722{
Jonathan Brassow1e302a92009-04-02 19:55:35 +0100723 unsigned sz = 0;
724
725 switch (status) {
726 case STATUSTYPE_INFO:
727 break;
728 case STATUSTYPE_TABLE:
729 DMEMIT(" %s P %llu", store->cow->name,
730 (unsigned long long)store->chunk_size);
731 }
Jonathan Brassow493df712009-04-02 19:55:31 +0100732
733 return sz;
734}
735
736static struct dm_exception_store_type _persistent_type = {
737 .name = "persistent",
738 .module = THIS_MODULE,
739 .ctr = persistent_ctr,
740 .dtr = persistent_dtr,
741 .read_metadata = persistent_read_metadata,
742 .prepare_exception = persistent_prepare_exception,
743 .commit_exception = persistent_commit_exception,
744 .drop_snapshot = persistent_drop_snapshot,
745 .fraction_full = persistent_fraction_full,
746 .status = persistent_status,
747};
748
749static struct dm_exception_store_type _persistent_compat_type = {
750 .name = "P",
751 .module = THIS_MODULE,
752 .ctr = persistent_ctr,
753 .dtr = persistent_dtr,
754 .read_metadata = persistent_read_metadata,
755 .prepare_exception = persistent_prepare_exception,
756 .commit_exception = persistent_commit_exception,
757 .drop_snapshot = persistent_drop_snapshot,
758 .fraction_full = persistent_fraction_full,
759 .status = persistent_status,
760};
761
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000762int dm_persistent_snapshot_init(void)
763{
Jonathan Brassow493df712009-04-02 19:55:31 +0100764 int r;
765
766 r = dm_exception_store_type_register(&_persistent_type);
767 if (r) {
768 DMERR("Unable to register persistent exception store type");
769 return r;
770 }
771
772 r = dm_exception_store_type_register(&_persistent_compat_type);
773 if (r) {
774 DMERR("Unable to register old-style persistent exception "
775 "store type");
776 dm_exception_store_type_unregister(&_persistent_type);
777 return r;
778 }
779
780 return r;
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000781}
782
783void dm_persistent_snapshot_exit(void)
784{
Jonathan Brassow493df712009-04-02 19:55:31 +0100785 dm_exception_store_type_unregister(&_persistent_type);
786 dm_exception_store_type_unregister(&_persistent_compat_type);
Alasdair G Kergon4db6bfe2009-01-06 03:05:17 +0000787}