mmc: Move host and card drivers to subdirs
[linux-2.6] / drivers / md / dm-exception-store.c
1 /*
2  * dm-snapshot.c
3  *
4  * Copyright (C) 2001-2002 Sistina Software (UK) Limited.
5  *
6  * This file is released under the GPL.
7  */
8
9 #include "dm.h"
10 #include "dm-snap.h"
11 #include "dm-io.h"
12 #include "kcopyd.h"
13
14 #include <linux/mm.h>
15 #include <linux/pagemap.h>
16 #include <linux/vmalloc.h>
17 #include <linux/slab.h>
18
19 #define DM_MSG_PREFIX "snapshots"
20 #define DM_CHUNK_SIZE_DEFAULT_SECTORS 32        /* 16KB */
21
22 /*-----------------------------------------------------------------
23  * Persistent snapshots, by persistent we mean that the snapshot
24  * will survive a reboot.
25  *---------------------------------------------------------------*/
26
27 /*
28  * We need to store a record of which parts of the origin have
29  * been copied to the snapshot device.  The snapshot code
30  * requires that we copy exception chunks to chunk aligned areas
31  * of the COW store.  It makes sense therefore, to store the
32  * metadata in chunk size blocks.
33  *
34  * There is no backward or forward compatibility implemented,
35  * snapshots with different disk versions than the kernel will
36  * not be usable.  It is expected that "lvcreate" will blank out
37  * the start of a fresh COW device before calling the snapshot
38  * constructor.
39  *
40  * The first chunk of the COW device just contains the header.
41  * After this there is a chunk filled with exception metadata,
42  * followed by as many exception chunks as can fit in the
43  * metadata areas.
44  *
45  * All on disk structures are in little-endian format.  The end
46  * of the exceptions info is indicated by an exception with a
47  * new_chunk of 0, which is invalid since it would point to the
48  * header chunk.
49  */
50
51 /*
52  * Magic for persistent snapshots: "SnAp" - Feeble isn't it.
53  */
54 #define SNAP_MAGIC 0x70416e53
55
56 /*
57  * The on-disk version of the metadata.
58  */
59 #define SNAPSHOT_DISK_VERSION 1
60
61 struct disk_header {
62         uint32_t magic;
63
64         /*
65          * Is this snapshot valid.  There is no way of recovering
66          * an invalid snapshot.
67          */
68         uint32_t valid;
69
70         /*
71          * Simple, incrementing version. no backward
72          * compatibility.
73          */
74         uint32_t version;
75
76         /* In sectors */
77         uint32_t chunk_size;
78 };
79
80 struct disk_exception {
81         uint64_t old_chunk;
82         uint64_t new_chunk;
83 };
84
85 struct commit_callback {
86         void (*callback)(void *, int success);
87         void *context;
88 };
89
90 /*
91  * The top level structure for a persistent exception store.
92  */
93 struct pstore {
94         struct dm_snapshot *snap;       /* up pointer to my snapshot */
95         int version;
96         int valid;
97         uint32_t exceptions_per_area;
98
99         /*
100          * Now that we have an asynchronous kcopyd there is no
101          * need for large chunk sizes, so it wont hurt to have a
102          * whole chunks worth of metadata in memory at once.
103          */
104         void *area;
105
106         /*
107          * Used to keep track of which metadata area the data in
108          * 'chunk' refers to.
109          */
110         uint32_t current_area;
111
112         /*
113          * The next free chunk for an exception.
114          */
115         uint32_t next_free;
116
117         /*
118          * The index of next free exception in the current
119          * metadata area.
120          */
121         uint32_t current_committed;
122
123         atomic_t pending_count;
124         uint32_t callback_count;
125         struct commit_callback *callbacks;
126 };
127
128 static inline unsigned int sectors_to_pages(unsigned int sectors)
129 {
130         return sectors / (PAGE_SIZE >> 9);
131 }
132
133 static int alloc_area(struct pstore *ps)
134 {
135         int r = -ENOMEM;
136         size_t len;
137
138         len = ps->snap->chunk_size << SECTOR_SHIFT;
139
140         /*
141          * Allocate the chunk_size block of memory that will hold
142          * a single metadata area.
143          */
144         ps->area = vmalloc(len);
145         if (!ps->area)
146                 return r;
147
148         return 0;
149 }
150
151 static void free_area(struct pstore *ps)
152 {
153         vfree(ps->area);
154         ps->area = NULL;
155 }
156
157 /*
158  * Read or write a chunk aligned and sized block of data from a device.
159  */
160 static int chunk_io(struct pstore *ps, uint32_t chunk, int rw)
161 {
162         struct io_region where;
163         unsigned long bits;
164
165         where.bdev = ps->snap->cow->bdev;
166         where.sector = ps->snap->chunk_size * chunk;
167         where.count = ps->snap->chunk_size;
168
169         return dm_io_sync_vm(1, &where, rw, ps->area, &bits);
170 }
171
172 /*
173  * Read or write a metadata area.  Remembering to skip the first
174  * chunk which holds the header.
175  */
176 static int area_io(struct pstore *ps, uint32_t area, int rw)
177 {
178         int r;
179         uint32_t chunk;
180
181         /* convert a metadata area index to a chunk index */
182         chunk = 1 + ((ps->exceptions_per_area + 1) * area);
183
184         r = chunk_io(ps, chunk, rw);
185         if (r)
186                 return r;
187
188         ps->current_area = area;
189         return 0;
190 }
191
192 static int zero_area(struct pstore *ps, uint32_t area)
193 {
194         memset(ps->area, 0, ps->snap->chunk_size << SECTOR_SHIFT);
195         return area_io(ps, area, WRITE);
196 }
197
198 static int read_header(struct pstore *ps, int *new_snapshot)
199 {
200         int r;
201         struct disk_header *dh;
202         chunk_t chunk_size;
203         int chunk_size_supplied = 1;
204
205         /*
206          * Use default chunk size (or hardsect_size, if larger) if none supplied
207          */
208         if (!ps->snap->chunk_size) {
209                 ps->snap->chunk_size = max(DM_CHUNK_SIZE_DEFAULT_SECTORS,
210                     bdev_hardsect_size(ps->snap->cow->bdev) >> 9);
211                 ps->snap->chunk_mask = ps->snap->chunk_size - 1;
212                 ps->snap->chunk_shift = ffs(ps->snap->chunk_size) - 1;
213                 chunk_size_supplied = 0;
214         }
215
216         r = dm_io_get(sectors_to_pages(ps->snap->chunk_size));
217         if (r)
218                 return r;
219
220         r = alloc_area(ps);
221         if (r)
222                 goto bad1;
223
224         r = chunk_io(ps, 0, READ);
225         if (r)
226                 goto bad2;
227
228         dh = (struct disk_header *) ps->area;
229
230         if (le32_to_cpu(dh->magic) == 0) {
231                 *new_snapshot = 1;
232                 return 0;
233         }
234
235         if (le32_to_cpu(dh->magic) != SNAP_MAGIC) {
236                 DMWARN("Invalid or corrupt snapshot");
237                 r = -ENXIO;
238                 goto bad2;
239         }
240
241         *new_snapshot = 0;
242         ps->valid = le32_to_cpu(dh->valid);
243         ps->version = le32_to_cpu(dh->version);
244         chunk_size = le32_to_cpu(dh->chunk_size);
245
246         if (!chunk_size_supplied || ps->snap->chunk_size == chunk_size)
247                 return 0;
248
249         DMWARN("chunk size %llu in device metadata overrides "
250                "table chunk size of %llu.",
251                (unsigned long long)chunk_size,
252                (unsigned long long)ps->snap->chunk_size);
253
254         /* We had a bogus chunk_size. Fix stuff up. */
255         dm_io_put(sectors_to_pages(ps->snap->chunk_size));
256         free_area(ps);
257
258         ps->snap->chunk_size = chunk_size;
259         ps->snap->chunk_mask = chunk_size - 1;
260         ps->snap->chunk_shift = ffs(chunk_size) - 1;
261
262         r = dm_io_get(sectors_to_pages(chunk_size));
263         if (r)
264                 return r;
265
266         r = alloc_area(ps);
267         if (r)
268                 goto bad1;
269
270         return 0;
271
272 bad2:
273         free_area(ps);
274 bad1:
275         dm_io_put(sectors_to_pages(ps->snap->chunk_size));
276         return r;
277 }
278
279 static int write_header(struct pstore *ps)
280 {
281         struct disk_header *dh;
282
283         memset(ps->area, 0, ps->snap->chunk_size << SECTOR_SHIFT);
284
285         dh = (struct disk_header *) ps->area;
286         dh->magic = cpu_to_le32(SNAP_MAGIC);
287         dh->valid = cpu_to_le32(ps->valid);
288         dh->version = cpu_to_le32(ps->version);
289         dh->chunk_size = cpu_to_le32(ps->snap->chunk_size);
290
291         return chunk_io(ps, 0, WRITE);
292 }
293
294 /*
295  * Access functions for the disk exceptions, these do the endian conversions.
296  */
297 static struct disk_exception *get_exception(struct pstore *ps, uint32_t index)
298 {
299         BUG_ON(index >= ps->exceptions_per_area);
300
301         return ((struct disk_exception *) ps->area) + index;
302 }
303
304 static void read_exception(struct pstore *ps,
305                            uint32_t index, struct disk_exception *result)
306 {
307         struct disk_exception *e = get_exception(ps, index);
308
309         /* copy it */
310         result->old_chunk = le64_to_cpu(e->old_chunk);
311         result->new_chunk = le64_to_cpu(e->new_chunk);
312 }
313
314 static void write_exception(struct pstore *ps,
315                             uint32_t index, struct disk_exception *de)
316 {
317         struct disk_exception *e = get_exception(ps, index);
318
319         /* copy it */
320         e->old_chunk = cpu_to_le64(de->old_chunk);
321         e->new_chunk = cpu_to_le64(de->new_chunk);
322 }
323
324 /*
325  * Registers the exceptions that are present in the current area.
326  * 'full' is filled in to indicate if the area has been
327  * filled.
328  */
329 static int insert_exceptions(struct pstore *ps, int *full)
330 {
331         int r;
332         unsigned int i;
333         struct disk_exception de;
334
335         /* presume the area is full */
336         *full = 1;
337
338         for (i = 0; i < ps->exceptions_per_area; i++) {
339                 read_exception(ps, i, &de);
340
341                 /*
342                  * If the new_chunk is pointing at the start of
343                  * the COW device, where the first metadata area
344                  * is we know that we've hit the end of the
345                  * exceptions.  Therefore the area is not full.
346                  */
347                 if (de.new_chunk == 0LL) {
348                         ps->current_committed = i;
349                         *full = 0;
350                         break;
351                 }
352
353                 /*
354                  * Keep track of the start of the free chunks.
355                  */
356                 if (ps->next_free <= de.new_chunk)
357                         ps->next_free = de.new_chunk + 1;
358
359                 /*
360                  * Otherwise we add the exception to the snapshot.
361                  */
362                 r = dm_add_exception(ps->snap, de.old_chunk, de.new_chunk);
363                 if (r)
364                         return r;
365         }
366
367         return 0;
368 }
369
370 static int read_exceptions(struct pstore *ps)
371 {
372         uint32_t area;
373         int r, full = 1;
374
375         /*
376          * Keeping reading chunks and inserting exceptions until
377          * we find a partially full area.
378          */
379         for (area = 0; full; area++) {
380                 r = area_io(ps, area, READ);
381                 if (r)
382                         return r;
383
384                 r = insert_exceptions(ps, &full);
385                 if (r)
386                         return r;
387         }
388
389         return 0;
390 }
391
392 static inline struct pstore *get_info(struct exception_store *store)
393 {
394         return (struct pstore *) store->context;
395 }
396
397 static void persistent_fraction_full(struct exception_store *store,
398                                      sector_t *numerator, sector_t *denominator)
399 {
400         *numerator = get_info(store)->next_free * store->snap->chunk_size;
401         *denominator = get_dev_size(store->snap->cow->bdev);
402 }
403
404 static void persistent_destroy(struct exception_store *store)
405 {
406         struct pstore *ps = get_info(store);
407
408         dm_io_put(sectors_to_pages(ps->snap->chunk_size));
409         vfree(ps->callbacks);
410         free_area(ps);
411         kfree(ps);
412 }
413
414 static int persistent_read_metadata(struct exception_store *store)
415 {
416         int r, new_snapshot;
417         struct pstore *ps = get_info(store);
418
419         /*
420          * Read the snapshot header.
421          */
422         r = read_header(ps, &new_snapshot);
423         if (r)
424                 return r;
425
426         /*
427          * Now we know correct chunk_size, complete the initialisation.
428          */
429         ps->exceptions_per_area = (ps->snap->chunk_size << SECTOR_SHIFT) /
430                                   sizeof(struct disk_exception);
431         ps->callbacks = dm_vcalloc(ps->exceptions_per_area,
432                         sizeof(*ps->callbacks));
433         if (!ps->callbacks)
434                 return -ENOMEM;
435
436         /*
437          * Do we need to setup a new snapshot ?
438          */
439         if (new_snapshot) {
440                 r = write_header(ps);
441                 if (r) {
442                         DMWARN("write_header failed");
443                         return r;
444                 }
445
446                 r = zero_area(ps, 0);
447                 if (r) {
448                         DMWARN("zero_area(0) failed");
449                         return r;
450                 }
451
452         } else {
453                 /*
454                  * Sanity checks.
455                  */
456                 if (!ps->valid) {
457                         DMWARN("snapshot is marked invalid");
458                         return -EINVAL;
459                 }
460
461                 if (ps->version != SNAPSHOT_DISK_VERSION) {
462                         DMWARN("unable to handle snapshot disk version %d",
463                                ps->version);
464                         return -EINVAL;
465                 }
466
467                 /*
468                  * Read the metadata.
469                  */
470                 r = read_exceptions(ps);
471                 if (r)
472                         return r;
473         }
474
475         return 0;
476 }
477
478 static int persistent_prepare(struct exception_store *store,
479                               struct exception *e)
480 {
481         struct pstore *ps = get_info(store);
482         uint32_t stride;
483         sector_t size = get_dev_size(store->snap->cow->bdev);
484
485         /* Is there enough room ? */
486         if (size < ((ps->next_free + 1) * store->snap->chunk_size))
487                 return -ENOSPC;
488
489         e->new_chunk = ps->next_free;
490
491         /*
492          * Move onto the next free pending, making sure to take
493          * into account the location of the metadata chunks.
494          */
495         stride = (ps->exceptions_per_area + 1);
496         if ((++ps->next_free % stride) == 1)
497                 ps->next_free++;
498
499         atomic_inc(&ps->pending_count);
500         return 0;
501 }
502
503 static void persistent_commit(struct exception_store *store,
504                               struct exception *e,
505                               void (*callback) (void *, int success),
506                               void *callback_context)
507 {
508         int r;
509         unsigned int i;
510         struct pstore *ps = get_info(store);
511         struct disk_exception de;
512         struct commit_callback *cb;
513
514         de.old_chunk = e->old_chunk;
515         de.new_chunk = e->new_chunk;
516         write_exception(ps, ps->current_committed++, &de);
517
518         /*
519          * Add the callback to the back of the array.  This code
520          * is the only place where the callback array is
521          * manipulated, and we know that it will never be called
522          * multiple times concurrently.
523          */
524         cb = ps->callbacks + ps->callback_count++;
525         cb->callback = callback;
526         cb->context = callback_context;
527
528         /*
529          * If there are no more exceptions in flight, or we have
530          * filled this metadata area we commit the exceptions to
531          * disk.
532          */
533         if (atomic_dec_and_test(&ps->pending_count) ||
534             (ps->current_committed == ps->exceptions_per_area)) {
535                 r = area_io(ps, ps->current_area, WRITE);
536                 if (r)
537                         ps->valid = 0;
538
539                 /*
540                  * Have we completely filled the current area ?
541                  */
542                 if (ps->current_committed == ps->exceptions_per_area) {
543                         ps->current_committed = 0;
544                         r = zero_area(ps, ps->current_area + 1);
545                         if (r)
546                                 ps->valid = 0;
547                 }
548
549                 for (i = 0; i < ps->callback_count; i++) {
550                         cb = ps->callbacks + i;
551                         cb->callback(cb->context, r == 0 ? 1 : 0);
552                 }
553
554                 ps->callback_count = 0;
555         }
556 }
557
558 static void persistent_drop(struct exception_store *store)
559 {
560         struct pstore *ps = get_info(store);
561
562         ps->valid = 0;
563         if (write_header(ps))
564                 DMWARN("write header failed");
565 }
566
567 int dm_create_persistent(struct exception_store *store)
568 {
569         struct pstore *ps;
570
571         /* allocate the pstore */
572         ps = kmalloc(sizeof(*ps), GFP_KERNEL);
573         if (!ps)
574                 return -ENOMEM;
575
576         ps->snap = store->snap;
577         ps->valid = 1;
578         ps->version = SNAPSHOT_DISK_VERSION;
579         ps->area = NULL;
580         ps->next_free = 2;      /* skipping the header and first area */
581         ps->current_committed = 0;
582
583         ps->callback_count = 0;
584         atomic_set(&ps->pending_count, 0);
585         ps->callbacks = NULL;
586
587         store->destroy = persistent_destroy;
588         store->read_metadata = persistent_read_metadata;
589         store->prepare_exception = persistent_prepare;
590         store->commit_exception = persistent_commit;
591         store->drop_snapshot = persistent_drop;
592         store->fraction_full = persistent_fraction_full;
593         store->context = ps;
594
595         return 0;
596 }
597
598 /*-----------------------------------------------------------------
599  * Implementation of the store for non-persistent snapshots.
600  *---------------------------------------------------------------*/
601 struct transient_c {
602         sector_t next_free;
603 };
604
605 static void transient_destroy(struct exception_store *store)
606 {
607         kfree(store->context);
608 }
609
610 static int transient_read_metadata(struct exception_store *store)
611 {
612         return 0;
613 }
614
615 static int transient_prepare(struct exception_store *store, struct exception *e)
616 {
617         struct transient_c *tc = (struct transient_c *) store->context;
618         sector_t size = get_dev_size(store->snap->cow->bdev);
619
620         if (size < (tc->next_free + store->snap->chunk_size))
621                 return -1;
622
623         e->new_chunk = sector_to_chunk(store->snap, tc->next_free);
624         tc->next_free += store->snap->chunk_size;
625
626         return 0;
627 }
628
629 static void transient_commit(struct exception_store *store,
630                       struct exception *e,
631                       void (*callback) (void *, int success),
632                       void *callback_context)
633 {
634         /* Just succeed */
635         callback(callback_context, 1);
636 }
637
638 static void transient_fraction_full(struct exception_store *store,
639                                     sector_t *numerator, sector_t *denominator)
640 {
641         *numerator = ((struct transient_c *) store->context)->next_free;
642         *denominator = get_dev_size(store->snap->cow->bdev);
643 }
644
645 int dm_create_transient(struct exception_store *store)
646 {
647         struct transient_c *tc;
648
649         store->destroy = transient_destroy;
650         store->read_metadata = transient_read_metadata;
651         store->prepare_exception = transient_prepare;
652         store->commit_exception = transient_commit;
653         store->drop_snapshot = NULL;
654         store->fraction_full = transient_fraction_full;
655
656         tc = kmalloc(sizeof(struct transient_c), GFP_KERNEL);
657         if (!tc)
658                 return -ENOMEM;
659
660         tc->next_free = 0;
661         store->context = tc;
662
663         return 0;
664 }