dm - Import verbatim from NetBSD
[dragonfly.git] / sys / dev / disk / dm / dm_target_snapshot.c
1 /*        $NetBSD: dm_target_snapshot.c,v 1.12 2010/01/04 00:12:22 haad Exp $      */
2
3 /*
4  * Copyright (c) 2008 The NetBSD Foundation, Inc.
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to The NetBSD Foundation
8  * by Adam Hamsik.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29  * POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 /*
33  * 1. Suspend my_data to temporarily stop any I/O while the snapshot is being
34  * activated.
35  * dmsetup suspend my_data
36  *
37  * 2. Create the snapshot-origin device with no table.
38  * dmsetup create my_data_org
39  *
40  * 3. Read the table from my_data and load it into my_data_org.
41  * dmsetup table my_data | dmsetup load my_data_org
42  *
43  * 4. Resume this new table.
44  * dmsetup resume my_data_org
45  *
46  * 5. Create the snapshot device with no table.
47  * dmsetup create my_data_snap
48  *
49  * 6. Load the table into my_data_snap. This uses /dev/hdd1 as the COW device and
50  * uses a 32kB chunk-size.
51  * echo "0 `blockdev --getsize /dev/mapper/my_data` snapshot \
52  *  /dev/mapper/my_data_org /dev/hdd1 p 64" | dmsetup load my_data_snap
53  *
54  * 7. Reload my_data as a snapshot-origin device that points to my_data_org.
55  * echo "0 `blockdev --getsize /dev/mapper/my_data` snapshot-origin \
56  *  /dev/mapper/my_data_org" | dmsetup load my_data
57  *
58  * 8. Resume the snapshot and origin devices.
59  * dmsetup resume my_data_snap
60  * dmsetup resume my_data
61  *
62  * Before snapshot creation
63  *  dev_name; dev table
64  * | my_data; 0 1024 linear /dev/sd1a 384|
65  *
66  * After snapshot creation
67  *                               |my_data_org;0 1024 linear /dev/sd1a 384|
68  *                              /
69  * |my_data; 0 1024 snapshot-origin /dev/vg00/my_data_org|
70  *                           /
71  * |my_data_snap; 0 1024 snapshot /dev/vg00/my_data /dev/mapper/my_data_cow P 8
72  *                           \
73  *                            |my_data_cow; 0 256 linear /dev/sd1a 1408|
74  */
75
76 /*
77  * This file implements initial version of device-mapper snapshot target.
78  */
79 #include <sys/types.h>
80 #include <sys/param.h>
81
82 #include <sys/buf.h>
83 #include <sys/kmem.h>
84 #include <sys/vnode.h>
85
86 #include "dm.h"
87
88 #ifdef DM_TARGET_MODULE
89 /*
90  * Every target can be compiled directly to dm driver or as a
91  * separate module this part of target is used for loading targets
92  * to dm driver.
93  * Target can be unloaded from kernel only if there are no users of
94  * it e.g. there are no devices which uses that target.
95  */
96 #include <sys/kernel.h>
97 #include <sys/module.h>
98
99 MODULE(MODULE_CLASS_MISC, dm_target_snapshot, "dm");
100
101 static int
102 dm_target_snapshot_modcmd(modcmd_t cmd, void *arg)
103 {
104         dm_target_t *dmt, *dmt1;
105         int r;
106
107         dmt = NULL;
108         dmt1 = NULL;
109
110         switch (cmd) {
111         case MODULE_CMD_INIT:
112                 if (((dmt = dm_target_lookup("snapshot")) != NULL)) {
113                         dm_target_unbusy(dmt);
114                         return EEXIST;
115                 }
116                 if (((dmt = dm_target_lookup("snapshot-origin")) != NULL)) {
117                         dm_target_unbusy(dmt);
118                         return EEXIST;
119                 }
120                 dmt = dm_target_alloc("snapshot");
121                 dmt1 = dm_target_alloc("snapshot-origin");
122
123                 dmt->version[0] = 1;
124                 dmt->version[1] = 0;
125                 dmt->version[2] = 5;
126                 strlcpy(dmt->name, "snapshot", DM_MAX_TYPE_NAME);
127                 dmt->init = &dm_target_snapshot_init;
128                 dmt->status = &dm_target_snapshot_status;
129                 dmt->strategy = &dm_target_snapshot_strategy;
130                 dmt->deps = &dm_target_snapshot_deps;
131                 dmt->destroy = &dm_target_snapshot_destroy;
132                 dmt->upcall = &dm_target_snapshot_upcall;
133
134                 r = dm_target_insert(dmt);
135
136                 dmt1->version[0] = 1;
137                 dmt1->version[1] = 0;
138                 dmt1->version[2] = 5;
139                 strlcpy(dmt1->name, "snapshot-origin", DM_MAX_TYPE_NAME);
140                 dmt1->init = &dm_target_snapshot_orig_init;
141                 dmt1->status = &dm_target_snapshot_orig_status;
142                 dmt1->strategy = &dm_target_snapshot_orig_strategy;
143                 dmt1->deps = &dm_target_snapshot_orig_deps;
144                 dmt1->destroy = &dm_target_snapshot_orig_destroy;
145                 dmt1->upcall = &dm_target_snapshot_orig_upcall;
146
147                 r = dm_target_insert(dmt1);
148                 break;
149
150         case MODULE_CMD_FINI:
151                 /*
152                  * Try to remove snapshot target if it works remove snap-origin
153                  * it is not possible to remove snapshot and do not remove
154                  * snap-origin because they are used together.
155                  */
156                 if ((r = dm_target_rem("snapshot")) == 0)
157                         r = dm_target_rem("snapshot-origin");
158
159                 break;
160
161         case MODULE_CMD_STAT:
162                 return ENOTTY;
163
164         default:
165                 return ENOTTY;
166         }
167
168         return r;
169 }
170 #endif
171
172 /*
173  * Init function called from dm_table_load_ioctl.
174  * argv:  /dev/mapper/my_data_org /dev/mapper/tsc_cow_dev p 64
175  *        snapshot_origin device, cow device, persistent flag, chunk size
176  */
177 int
178 dm_target_snapshot_init(dm_dev_t * dmv, void **target_config, char *params)
179 {
180         dm_target_snapshot_config_t *tsc;
181         dm_pdev_t *dmp_snap, *dmp_cow;
182         char **ap, *argv[5];
183
184         dmp_cow = NULL;
185
186         if (params == NULL)
187                 return EINVAL;
188         /*
189          * Parse a string, containing tokens delimited by white space,
190          * into an argument vector
191          */
192         for (ap = argv; ap < &argv[4] &&
193             (*ap = strsep(&params, " \t")) != NULL;) {
194                 if (**ap != '\0')
195                         ap++;
196         }
197
198         printf("Snapshot target init function called!!\n");
199         printf("Snapshotted device: %s, cow device %s,\n\t persistent flag: %s, "
200             "chunk size: %s\n", argv[0], argv[1], argv[2], argv[3]);
201
202         /* Insert snap device to global pdev list */
203         if ((dmp_snap = dm_pdev_insert(argv[0])) == NULL)
204                 return ENOENT;
205
206         if ((tsc = kmem_alloc(sizeof(dm_target_snapshot_config_t), KM_NOSLEEP))
207             == NULL)
208                 return 1;
209
210         tsc->tsc_persistent_dev = 0;
211
212         /* There is now cow device for nonpersistent snapshot devices */
213         if (strcmp(argv[2], "p") == 0) {
214                 tsc->tsc_persistent_dev = 1;
215
216                 /* Insert cow device to global pdev list */
217                 if ((dmp_cow = dm_pdev_insert(argv[1])) == NULL)
218                         return ENOENT;
219         }
220         tsc->tsc_chunk_size = atoi(argv[3]);
221
222         tsc->tsc_snap_dev = dmp_snap;
223         tsc->tsc_cow_dev = dmp_cow;
224
225         *target_config = tsc;
226
227         dmv->dev_type = DM_SNAPSHOT_DEV;
228
229         return 0;
230 }
231 /*
232  * Status routine is called to get params string, which is target
233  * specific. When dm_table_status_ioctl is called with flag
234  * DM_STATUS_TABLE_FLAG I have to sent params string back.
235  */
236 char *
237 dm_target_snapshot_status(void *target_config)
238 {
239         dm_target_snapshot_config_t *tsc;
240
241         uint32_t i;
242         uint32_t count;
243         size_t prm_len, cow_len;
244         char *params, *cow_name;
245
246         tsc = target_config;
247
248         prm_len = 0;
249         cow_len = 0;
250         count = 0;
251         cow_name = NULL;
252
253         printf("Snapshot target status function called\n");
254
255         /* count number of chars in offset */
256         for (i = tsc->tsc_chunk_size; i != 0; i /= 10)
257                 count++;
258
259         if (tsc->tsc_persistent_dev)
260                 cow_len = strlen(tsc->tsc_cow_dev->name);
261
262         /* length of names + count of chars + spaces and null char */
263         prm_len = strlen(tsc->tsc_snap_dev->name) + cow_len + count + 5;
264
265         if ((params = kmem_alloc(prm_len, KM_NOSLEEP)) == NULL)
266                 return NULL;
267
268         printf("%s %s %s %" PRIu64 "\n", tsc->tsc_snap_dev->name,
269             tsc->tsc_cow_dev->name, tsc->tsc_persistent_dev ? "p" : "n",
270             tsc->tsc_chunk_size);
271
272         snprintf(params, prm_len, "%s %s %s %" PRIu64, tsc->tsc_snap_dev->name,
273             tsc->tsc_persistent_dev ? tsc->tsc_cow_dev->name : "",
274             tsc->tsc_persistent_dev ? "p" : "n",
275             tsc->tsc_chunk_size);
276
277         return params;
278 }
279 /* Strategy routine called from dm_strategy. */
280 int
281 dm_target_snapshot_strategy(dm_table_entry_t * table_en, struct buf * bp)
282 {
283
284         printf("Snapshot target read function called!!\n");
285
286         bp->b_error = EIO;
287         bp->b_resid = 0;
288
289         biodone(bp);
290
291         return 0;
292 }
293 /* Doesn't do anything here. */
294 int
295 dm_target_snapshot_destroy(dm_table_entry_t * table_en)
296 {
297         dm_target_snapshot_config_t *tsc;
298
299         /*
300          * Destroy function is called for every target even if it
301          * doesn't have target_config.
302          */
303
304         if (table_en->target_config == NULL)
305                 return 0;
306
307         printf("Snapshot target destroy function called\n");
308
309         tsc = table_en->target_config;
310
311         /* Decrement pdev ref counter if 0 remove it */
312         dm_pdev_decr(tsc->tsc_snap_dev);
313
314         if (tsc->tsc_persistent_dev)
315                 dm_pdev_decr(tsc->tsc_cow_dev);
316
317         /* Unbusy target so we can unload it */
318         dm_target_unbusy(table_en->target);
319
320         kmem_free(table_en->target_config, sizeof(dm_target_snapshot_config_t));
321
322         table_en->target_config = NULL;
323
324         return 0;
325 }
326 /* Add this target dependiences to prop_array_t */
327 int
328 dm_target_snapshot_deps(dm_table_entry_t * table_en,
329     prop_array_t prop_array)
330 {
331         dm_target_snapshot_config_t *tsc;
332         struct vattr va;
333
334         int error;
335
336         if (table_en->target_config == NULL)
337                 return 0;
338
339         tsc = table_en->target_config;
340
341         if ((error = VOP_GETATTR(tsc->tsc_snap_dev->pdev_vnode, &va, curlwp->l_cred)) != 0)
342                 return error;
343
344         prop_array_add_uint64(prop_array, (uint64_t) va.va_rdev);
345
346         if (tsc->tsc_persistent_dev) {
347
348                 if ((error = VOP_GETATTR(tsc->tsc_cow_dev->pdev_vnode, &va,
349                             curlwp->l_cred)) != 0)
350                         return error;
351
352                 prop_array_add_uint64(prop_array, (uint64_t) va.va_rdev);
353
354         }
355         return 0;
356 }
357 /* Upcall is used to inform other depended devices about IO. */
358 int
359 dm_target_snapshot_upcall(dm_table_entry_t * table_en, struct buf * bp)
360 {
361         printf("dm_target_snapshot_upcall called\n");
362
363         printf("upcall buf flags %s %s\n",
364             (bp->b_flags & B_WRITE) ? "B_WRITE" : "",
365             (bp->b_flags & B_READ) ? "B_READ" : "");
366
367         return 0;
368 }
369 /*
370  * dm target snapshot origin routines.
371  *
372  * Keep for compatibility with linux lvm2tools. They use two targets
373  * to implement snapshots. Snapshot target will implement exception
374  * store and snapshot origin will implement device which calls every
375  * snapshot device when write is done on master device.
376  */
377
378 /*
379  * Init function called from dm_table_load_ioctl.
380  *
381  * argv: /dev/mapper/my_data_real
382  */
383 int
384 dm_target_snapshot_orig_init(dm_dev_t * dmv, void **target_config,
385     prop_dictionary_t dict)
386 {
387         dm_target_snapshot_origin_config_t *tsoc;
388         dm_pdev_t *dmp_real;
389
390         if (params == NULL)
391                 return EINVAL;
392
393         printf("Snapshot origin target init function called!!\n");
394         printf("Parent device: %s\n", params);
395
396         /* Insert snap device to global pdev list */
397         if ((dmp_real = dm_pdev_insert(params)) == NULL)
398                 return ENOENT;
399
400         if ((tsoc = kmem_alloc(sizeof(dm_target_snapshot_origin_config_t), KM_NOSLEEP))
401             == NULL)
402                 return 1;
403
404         tsoc->tsoc_real_dev = dmp_real;
405
406         dmv->dev_type = DM_SNAPSHOT_ORIG_DEV;
407
408         *target_config = tsoc;
409
410         return 0;
411 }
412 /*
413  * Status routine is called to get params string, which is target
414  * specific. When dm_table_status_ioctl is called with flag
415  * DM_STATUS_TABLE_FLAG I have to sent params string back.
416  */
417 char *
418 dm_target_snapshot_orig_status(void *target_config)
419 {
420         dm_target_snapshot_origin_config_t *tsoc;
421
422         size_t prm_len;
423         char *params;
424
425         tsoc = target_config;
426
427         prm_len = 0;
428
429         printf("Snapshot origin target status function called\n");
430
431         /* length of names + count of chars + spaces and null char */
432         prm_len = strlen(tsoc->tsoc_real_dev->name) + 1;
433
434         printf("real_dev name %s\n", tsoc->tsoc_real_dev->name);
435
436         if ((params = kmem_alloc(prm_len, KM_NOSLEEP)) == NULL)
437                 return NULL;
438
439         printf("%s\n", tsoc->tsoc_real_dev->name);
440
441         snprintf(params, prm_len, "%s", tsoc->tsoc_real_dev->name);
442
443         return params;
444 }
445 /* Strategy routine called from dm_strategy. */
446 int
447 dm_target_snapshot_orig_strategy(dm_table_entry_t * table_en, struct buf * bp)
448 {
449
450         printf("Snapshot_Orig target read function called!!\n");
451
452         bp->b_error = EIO;
453         bp->b_resid = 0;
454
455         biodone(bp);
456
457         return 0;
458 }
459 /* Decrement pdev and free allocated space. */
460 int
461 dm_target_snapshot_orig_destroy(dm_table_entry_t * table_en)
462 {
463         dm_target_snapshot_origin_config_t *tsoc;
464
465         /*
466          * Destroy function is called for every target even if it
467          * doesn't have target_config.
468          */
469
470         if (table_en->target_config == NULL)
471                 return 0;
472
473         tsoc = table_en->target_config;
474
475         /* Decrement pdev ref counter if 0 remove it */
476         dm_pdev_decr(tsoc->tsoc_real_dev);
477
478         /* Unbusy target so we can unload it */
479         dm_target_unbusy(table_en->target);
480
481         kmem_free(table_en->target_config, sizeof(dm_target_snapshot_origin_config_t));
482
483         table_en->target_config = NULL;
484
485         return 0;
486 }
487 /*
488  * Get target deps and add them to prop_array_t.
489  */
490 int
491 dm_target_snapshot_orig_deps(dm_table_entry_t * table_en,
492     prop_array_t prop_array)
493 {
494         dm_target_snapshot_origin_config_t *tsoc;
495         struct vattr va;
496
497         int error;
498
499         if (table_en->target_config == NULL)
500                 return 0;
501
502         tsoc = table_en->target_config;
503
504         if ((error = VOP_GETATTR(tsoc->tsoc_real_dev->pdev_vnode, &va,
505                     curlwp->l_cred)) != 0)
506                 return error;
507
508         prop_array_add_uint64(prop_array, (uint64_t) va.va_rdev);
509
510         return 0;
511 }
512 /* Unsupported for this target. */
513 int
514 dm_target_snapshot_orig_upcall(dm_table_entry_t * table_en, struct buf * bp)
515 {
516         return 0;
517 }