dm - undo my pointless moving of dm.h
[dragonfly.git] / sys / dev / disk / dm / dm_ioctl.c
CommitLineData
ff56536e
AH
1/* $NetBSD: dm_ioctl.c,v 1.21 2010/02/25 20:48:58 jakllsch 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 * Locking is used to synchronise between ioctl calls and between dm_table's
34 * users.
35 *
36 * ioctl locking:
37 * Simple reference counting, to count users of device will be used routines
38 * dm_dev_busy/dm_dev_unbusy are used for that.
39 * dm_dev_lookup/dm_dev_rem call dm_dev_busy before return(caller is therefore
40 * holder of reference_counter last).
41 *
42 * ioctl routines which change/remove dm_dev parameters must wait on
43 * dm_dev::dev_cv and when last user will call dm_dev_unbusy they will wake
44 * up them.
45 *
46 * table_head locking:
47 * To access table entries dm_table_* routines must be used.
48 *
49 * dm_table_get_entry will increment table users reference
5b279a20 50 * counter. It will return active or inactive table depends
ff56536e
AH
51 * on uint8_t argument.
52 *
53 * dm_table_release must be called for every table_entry from
54 * dm_table_get_entry. Between these to calls tables can'tbe switched
55 * or destroyed.
56 *
57 * dm_table_head_init initialize talbe_entries SLISTS and io_cv.
58 *
59 * dm_table_head_destroy destroy cv.
60 *
61 * There are two types of users for dm_table_head first type will
62 * only read list and try to do anything with it e.g. dmstrategy,
63 * dm_table_size etc. There is another user for table_head which wants
64 * to change table lists e.g. dm_dev_resume_ioctl, dm_dev_remove_ioctl,
65 * dm_table_clear_ioctl.
66 *
67 * NOTE: It is not allowed to call dm_table_destroy, dm_table_switch_tables
68 * with hold table reference counter. Table reference counter is hold
69 * after calling dm_table_get_entry routine. After calling this
70 * function user must call dm_table_release before any writer table
71 * operation.
72 *
73 * Example: dm_table_get_entry
74 * dm_table_destroy/dm_table_switch_tables
75 * This exaple will lead to deadlock situation because after dm_table_get_entry
76 * table reference counter is != 0 and dm_table_destroy have to wait on cv until
77 * reference counter is 0.
78 *
79 */
80
81#include <sys/types.h>
82#include <sys/param.h>
83
84#include <sys/device.h>
3b48c3c1 85#include <sys/devicestat.h>
db596036 86#include <sys/devfs.h>
ff56536e
AH
87#include <sys/disk.h>
88#include <sys/disklabel.h>
5b279a20 89#include <sys/malloc.h>
637936eb 90#include <sys/udev.h>
ff56536e 91#include <sys/vnode.h>
a84e173e 92#include <dev/disk/dm/dm.h>
ff56536e 93
ff56536e 94#include "netbsd-dm.h"
ff56536e 95
5b279a20 96extern struct dev_ops dm_ops;
db596036 97extern struct devfs_bitmap dm_minor_bitmap;
ff56536e
AH
98uint64_t dm_dev_counter;
99
ff56536e
AH
100#define DM_REMOVE_FLAG(flag, name) do { \
101 prop_dictionary_get_uint32(dm_dict,DM_IOCTL_FLAGS,&flag); \
102 flag &= ~name; \
103 prop_dictionary_set_uint32(dm_dict,DM_IOCTL_FLAGS,flag); \
104} while (/*CONSTCOND*/0)
105
106#define DM_ADD_FLAG(flag, name) do { \
107 prop_dictionary_get_uint32(dm_dict,DM_IOCTL_FLAGS,&flag); \
108 flag |= name; \
109 prop_dictionary_set_uint32(dm_dict,DM_IOCTL_FLAGS,flag); \
110} while (/*CONSTCOND*/0)
111
112static int dm_dbg_print_flags(int);
113
114/*
115 * Print flags sent to the kernel from libevmapper.
116 */
117static int
118dm_dbg_print_flags(int flags)
119{
120 aprint_debug("dbg_print --- %d\n", flags);
121
122 if (flags & DM_READONLY_FLAG)
123 aprint_debug("dbg_flags: DM_READONLY_FLAG set In/Out\n");
124
125 if (flags & DM_SUSPEND_FLAG)
126 aprint_debug("dbg_flags: DM_SUSPEND_FLAG set In/Out \n");
127
128 if (flags & DM_PERSISTENT_DEV_FLAG)
129 aprint_debug("db_flags: DM_PERSISTENT_DEV_FLAG set In\n");
130
131 if (flags & DM_STATUS_TABLE_FLAG)
132 aprint_debug("dbg_flags: DM_STATUS_TABLE_FLAG set In\n");
133
134 if (flags & DM_ACTIVE_PRESENT_FLAG)
135 aprint_debug("dbg_flags: DM_ACTIVE_PRESENT_FLAG set Out\n");
136
137 if (flags & DM_INACTIVE_PRESENT_FLAG)
138 aprint_debug("dbg_flags: DM_INACTIVE_PRESENT_FLAG set Out\n");
139
140 if (flags & DM_BUFFER_FULL_FLAG)
141 aprint_debug("dbg_flags: DM_BUFFER_FULL_FLAG set Out\n");
142
143 if (flags & DM_SKIP_BDGET_FLAG)
144 aprint_debug("dbg_flags: DM_SKIP_BDGET_FLAG set In\n");
145
146 if (flags & DM_SKIP_LOCKFS_FLAG)
147 aprint_debug("dbg_flags: DM_SKIP_LOCKFS_FLAG set In\n");
148
149 if (flags & DM_NOFLUSH_FLAG)
150 aprint_debug("dbg_flags: DM_NOFLUSH_FLAG set In\n");
151
152 return 0;
153}
154/*
155 * Get version ioctl call I do it as default therefore this
156 * function is unused now.
157 */
158int
159dm_get_version_ioctl(prop_dictionary_t dm_dict)
160{
ff56536e
AH
161 return 0;
162}
163/*
164 * Get list of all available targets from global
165 * target list and sent them back to libdevmapper.
166 */
167int
168dm_list_versions_ioctl(prop_dictionary_t dm_dict)
169{
170 prop_array_t target_list;
171 uint32_t flags;
172
173 flags = 0;
174
175 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
176
177 dm_dbg_print_flags(flags);
178 target_list = dm_target_prop_list();
179
180 prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, target_list);
181 prop_object_release(target_list);
182
183 return 0;
184}
185/*
186 * Create in-kernel entry for device. Device attributes such as name, uuid are
187 * taken from proplib dictionary.
188 *
189 */
190int
191dm_dev_create_ioctl(prop_dictionary_t dm_dict)
192{
193 dm_dev_t *dmv;
194 const char *name, *uuid;
08cba728 195 char name_buf[MAXPATHLEN];
db596036 196 int r, flags, dm_minor;
ff56536e
AH
197
198 r = 0;
199 flags = 0;
200 name = NULL;
201 uuid = NULL;
202
203 /* Get needed values from dictionary. */
204 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
205 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
206 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
207
208 dm_dbg_print_flags(flags);
209
210 /* Lookup name and uuid if device already exist quit. */
211 if ((dmv = dm_dev_lookup(name, uuid, -1)) != NULL) {
212 DM_ADD_FLAG(flags, DM_EXISTS_FLAG); /* Device already exists */
213 dm_dev_unbusy(dmv);
214 return EEXIST;
215 }
b878986e 216
ff56536e
AH
217 if ((dmv = dm_dev_alloc()) == NULL)
218 return ENOMEM;
219
220 if (uuid)
221 strncpy(dmv->uuid, uuid, DM_UUID_LEN);
222 else
223 dmv->uuid[0] = '\0';
224
225 if (name)
226 strlcpy(dmv->name, name, DM_NAME_LEN);
227
db596036 228 dm_minor = devfs_clone_bitmap_get(&dm_minor_bitmap, 0);
ff56536e
AH
229 dmv->flags = 0; /* device flags are set when needed */
230 dmv->ref_cnt = 0;
231 dmv->event_nr = 0;
232 dmv->dev_type = 0;
956c8d71 233 dmv->is_open = 0;
ff56536e
AH
234
235 dm_table_head_init(&dmv->table_head);
236
5b279a20
AH
237 lockinit(&dmv->dev_mtx, "dmdev", 0, LK_CANRECURSE);
238 lockinit(&dmv->diskp_mtx, "dmdisk", 0, LK_CANRECURSE);
ff56536e
AH
239 cv_init(&dmv->dev_cv, "dm_dev");
240
241 if (flags & DM_READONLY_FLAG)
242 dmv->flags |= DM_READONLY_FLAG;
243
5b279a20 244 aprint_debug("Creating device dm/%s\n", name);
08cba728 245 ksnprintf(name_buf, sizeof(name_buf), "mapper/%s", dmv->name);
3b48c3c1
AH
246
247 devstat_add_entry(&dmv->stats, name, 0, DEV_BSIZE,
248 DEVSTAT_NO_ORDERED_TAGS,
249 DEVSTAT_TYPE_DIRECT | DEVSTAT_TYPE_IF_OTHER,
250 DEVSTAT_PRIORITY_DISK);
251
db596036 252 dmv->devt = disk_create_named(name_buf, dm_minor, dmv->diskp, &dm_ops);
956c8d71
AH
253 reference_dev(dmv->devt);
254
db596036
AH
255 dmv->minor = minor(dmv->devt);
256 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
f5d8307c 257 udev_dict_set_cstr(dmv->devt, "subsystem", "disk");
ff56536e
AH
258
259 if ((r = dm_dev_insert(dmv)) != 0)
260 dm_dev_free(dmv);
261
262 DM_ADD_FLAG(flags, DM_EXISTS_FLAG);
263 DM_REMOVE_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
264
265 /* Increment device counter After creating device */
5b279a20 266 ++dm_dev_counter; /* XXX: was atomic 64 */
ff56536e
AH
267
268 return r;
269}
270/*
271 * Get list of created device-mapper devices fromglobal list and
272 * send it to kernel.
273 *
274 * Output dictionary:
275 *
276 * <key>cmd_data</key>
277 * <array>
278 * <dict>
279 * <key>name<key>
280 * <string>...</string>
281 *
282 * <key>dev</key>
283 * <integer>...</integer>
284 * </dict>
285 * </array>
286 *
287 */
288int
289dm_dev_list_ioctl(prop_dictionary_t dm_dict)
290{
291 prop_array_t dev_list;
292
293 uint32_t flags;
294
295 flags = 0;
296
297 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
298
299 dm_dbg_print_flags(flags);
300
301 dev_list = dm_dev_prop_list();
302
303 prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, dev_list);
304 prop_object_release(dev_list);
305
306 return 0;
307}
308/*
309 * Rename selected devices old name is in struct dm_ioctl.
310 * newname is taken from dictionary
311 *
312 * <key>cmd_data</key>
313 * <array>
314 * <string>...</string>
315 * </array>
316 */
317int
318dm_dev_rename_ioctl(prop_dictionary_t dm_dict)
319{
320 prop_array_t cmd_array;
321 dm_dev_t *dmv;
322
323 const char *name, *uuid, *n_name;
324 uint32_t flags, minor;
325
326 name = NULL;
327 uuid = NULL;
328 minor = 0;
329
330 /* Get needed values from dictionary. */
331 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
332 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
333 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
334 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
335
336 dm_dbg_print_flags(flags);
337
338 cmd_array = prop_dictionary_get(dm_dict, DM_IOCTL_CMD_DATA);
339
340 prop_array_get_cstring_nocopy(cmd_array, 0, &n_name);
341
342 if (strlen(n_name) + 1 > DM_NAME_LEN)
343 return EINVAL;
344
e8f83946 345 if ((dmv = dm_dev_rem(NULL, name, uuid, minor)) == NULL) {
ff56536e
AH
346 DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
347 return ENOENT;
348 }
349 /* change device name */
350 /*
351 * XXX How to deal with this change, name only used in
352 * dm_dev_routines, should I add dm_dev_change_name which will run
353 * under the dm_dev_list mutex ?
354 */
355 strlcpy(dmv->name, n_name, DM_NAME_LEN);
356
357 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt);
358 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
359 prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid);
360
361 dm_dev_insert(dmv);
362
363 return 0;
364}
365/*
366 * Remove device from global list I have to remove active
367 * and inactive tables first.
368 */
369int
370dm_dev_remove_ioctl(prop_dictionary_t dm_dict)
371{
372 dm_dev_t *dmv;
373 const char *name, *uuid;
374 uint32_t flags, minor;
ff56536e
AH
375
376 flags = 0;
377 name = NULL;
378 uuid = NULL;
379
380 /* Get needed values from dictionary. */
381 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
382 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
383 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
384 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
385
386 dm_dbg_print_flags(flags);
387
388 /*
389 * This seems as hack to me, probably use routine dm_dev_get_devt to
390 * atomicaly get devt from device.
391 */
392 if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
393 DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
394 return ENOENT;
395 }
ff56536e
AH
396
397 dm_dev_unbusy(dmv);
398
956c8d71
AH
399 if (dmv->is_open)
400 return EBUSY;
401
ff56536e
AH
402 /*
403 * This will call dm_detach routine which will actually removes
404 * device.
405 */
5b279a20 406 return dm_detach(dmv);
ff56536e
AH
407}
408/*
409 * Return actual state of device to libdevmapper.
410 */
411int
412dm_dev_status_ioctl(prop_dictionary_t dm_dict)
413{
414 dm_dev_t *dmv;
415 const char *name, *uuid;
416 uint32_t flags, j, minor;
417
418 name = NULL;
419 uuid = NULL;
420 flags = 0;
421 j = 0;
422
423 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
424 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
425 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
426 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
427
428 if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
429 DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
430 return ENOENT;
431 }
432 dm_dbg_print_flags(dmv->flags);
433
434 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt);
435 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
436 prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid);
437
438 if (dmv->flags & DM_SUSPEND_FLAG)
439 DM_ADD_FLAG(flags, DM_SUSPEND_FLAG);
440
441 /*
442 * Add status flags for tables I have to check both active and
443 * inactive tables.
444 */
445 if ((j = dm_table_get_target_count(&dmv->table_head, DM_TABLE_ACTIVE))) {
446 DM_ADD_FLAG(flags, DM_ACTIVE_PRESENT_FLAG);
447 } else
448 DM_REMOVE_FLAG(flags, DM_ACTIVE_PRESENT_FLAG);
449
450 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_TARGET_COUNT, j);
451
452 if (dm_table_get_target_count(&dmv->table_head, DM_TABLE_INACTIVE))
453 DM_ADD_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
454 else
455 DM_REMOVE_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
456
457 dm_dev_unbusy(dmv);
458
459 return 0;
460}
461/*
462 * Set only flag to suggest that device is suspended. This call is
463 * not supported in NetBSD.
464 *
465 */
466int
467dm_dev_suspend_ioctl(prop_dictionary_t dm_dict)
468{
469 dm_dev_t *dmv;
470 const char *name, *uuid;
471 uint32_t flags, minor;
472
473 name = NULL;
474 uuid = NULL;
475 flags = 0;
476
477 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
478 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
479 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
480 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
481
482 if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
483 DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
484 return ENOENT;
485 }
5b279a20 486 atomic_set_int(&dmv->flags, DM_SUSPEND_FLAG);
ff56536e
AH
487
488 dm_dbg_print_flags(dmv->flags);
489
490 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt);
491 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_FLAGS, dmv->flags);
492 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
493
494 dm_dev_unbusy(dmv);
495
496 /* Add flags to dictionary flag after dmv -> dict copy */
497 DM_ADD_FLAG(flags, DM_EXISTS_FLAG);
498
499 return 0;
500}
501/*
502 * Simulate Linux behaviour better and switch tables here and not in
503 * dm_table_load_ioctl.
504 */
505int
506dm_dev_resume_ioctl(prop_dictionary_t dm_dict)
507{
508 dm_dev_t *dmv;
509 const char *name, *uuid;
510 uint32_t flags, minor;
511
512 name = NULL;
513 uuid = NULL;
514 flags = 0;
515
516 /*
517 * char *xml; xml = prop_dictionary_externalize(dm_dict);
518 * printf("%s\n",xml);
519 */
520
521 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
522 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
523 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
524 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
525
526 /* Remove device from global device list */
527 if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
528 DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
529 return ENOENT;
530 }
5b279a20
AH
531 atomic_clear_int(&dmv->flags, (DM_SUSPEND_FLAG | DM_INACTIVE_PRESENT_FLAG));
532 atomic_set_int(&dmv->flags, DM_ACTIVE_PRESENT_FLAG);
ff56536e
AH
533
534 dm_table_switch_tables(&dmv->table_head);
535
536 DM_ADD_FLAG(flags, DM_EXISTS_FLAG);
537
5b279a20 538 dmsetdiskinfo(dmv->diskp, &dmv->table_head);
ff56536e
AH
539
540 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt);
541 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_FLAGS, flags);
542 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
543
544 dm_dev_unbusy(dmv);
545
546 /* Destroy inactive table after resume. */
547 dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
548
549 return 0;
550}
551/*
552 * Table management routines
553 * lvm2tools doens't send name/uuid to kernel with table
554 * for lookup I have to use minor number.
555 */
556
557/*
558 * Remove inactive table from device. Routines which work's with inactive tables
559 * doesn't need to synchronise with dmstrategy. They can synchronise themselves with mutex?.
560 *
561 */
562int
563dm_table_clear_ioctl(prop_dictionary_t dm_dict)
564{
565 dm_dev_t *dmv;
566 const char *name, *uuid;
567 uint32_t flags, minor;
568
569 dmv = NULL;
570 name = NULL;
571 uuid = NULL;
572 flags = 0;
573 minor = 0;
574
575 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
576 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
577 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
578 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
579
580 aprint_debug("Clearing inactive table from device: %s--%s\n",
581 name, uuid);
582
583 if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
584 DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
585 return ENOENT;
586 }
587 /* Select unused table */
588 dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
589
5b279a20 590 atomic_clear_int(&dmv->flags, DM_INACTIVE_PRESENT_FLAG);
ff56536e
AH
591
592 dm_dev_unbusy(dmv);
593
594 return 0;
595}
596/*
597 * Get list of physical devices for active table.
598 * Get dev_t from pdev vnode and insert it into cmd_array.
599 *
600 * XXX. This function is called from lvm2tools to get information
601 * about physical devices, too e.g. during vgcreate.
602 */
603int
604dm_table_deps_ioctl(prop_dictionary_t dm_dict)
605{
606 dm_dev_t *dmv;
607 dm_table_t *tbl;
608 dm_table_entry_t *table_en;
609
610 prop_array_t cmd_array;
611 const char *name, *uuid;
612 uint32_t flags, minor;
613
614 int table_type;
615 size_t i;
616
617 name = NULL;
618 uuid = NULL;
619 dmv = NULL;
620 flags = 0;
621
622 i = 0;
623
624 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
625 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
626 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
627 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
628
629 /* create array for dev_t's */
630 cmd_array = prop_array_create();
631
632 if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
633 DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
634 return ENOENT;
635 }
636 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
637 prop_dictionary_set_cstring(dm_dict, DM_IOCTL_NAME, dmv->name);
638 prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid);
639
640 aprint_debug("Getting table deps for device: %s\n", dmv->name);
641
642 /*
643 * if DM_QUERY_INACTIVE_TABLE_FLAG is passed we need to query
644 * INACTIVE TABLE
645 */
646 if (flags & DM_QUERY_INACTIVE_TABLE_FLAG)
647 table_type = DM_TABLE_INACTIVE;
648 else
649 table_type = DM_TABLE_ACTIVE;
650
651 tbl = dm_table_get_entry(&dmv->table_head, table_type);
652
653 SLIST_FOREACH(table_en, tbl, next)
654 table_en->target->deps(table_en, cmd_array);
655
656 dm_table_release(&dmv->table_head, table_type);
657 dm_dev_unbusy(dmv);
658
659 prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, cmd_array);
660 prop_object_release(cmd_array);
661
662 return 0;
663}
664/*
665 * Load new table/tables to device.
666 * Call apropriate target init routine open all physical pdev's and
667 * link them to device. For other targets mirror, strip, snapshot
668 * etc. also add dependency devices to upcalls list.
669 *
670 * Load table to inactive slot table are switched in dm_device_resume_ioctl.
671 * This simulates Linux behaviour better there should not be any difference.
672 *
673 */
674int
675dm_table_load_ioctl(prop_dictionary_t dm_dict)
676{
677 dm_dev_t *dmv;
678 dm_table_entry_t *table_en, *last_table;
679 dm_table_t *tbl;
680 dm_target_t *target;
681
682 prop_object_iterator_t iter;
683 prop_array_t cmd_array;
684 prop_dictionary_t target_dict;
685
686 const char *name, *uuid, *type;
687
688 uint32_t flags, ret, minor;
689
690 char *str;
691
692 ret = 0;
693 flags = 0;
694 name = NULL;
695 uuid = NULL;
696 dmv = NULL;
697 last_table = NULL;
698 str = NULL;
699
700 /*
701 * char *xml; xml = prop_dictionary_externalize(dm_dict);
702 * printf("%s\n",xml);
703 */
704
705 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
706 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
707 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
708 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
709
710 cmd_array = prop_dictionary_get(dm_dict, DM_IOCTL_CMD_DATA);
711 iter = prop_array_iterator(cmd_array);
712 dm_dbg_print_flags(flags);
713
714 if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
715 DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
716 return ENOENT;
717 }
718 aprint_debug("Loading table to device: %s--%d\n", name,
719 dmv->table_head.cur_active_table);
720
721 /*
722 * I have to check if this table slot is not used by another table list.
723 * if it is used I should free them.
724 */
725 if (dmv->flags & DM_INACTIVE_PRESENT_FLAG)
726 dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
727
728 dm_dbg_print_flags(dmv->flags);
729 tbl = dm_table_get_entry(&dmv->table_head, DM_TABLE_INACTIVE);
730
731 aprint_debug("dmv->name = %s\n", dmv->name);
732
733 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
734
735 while ((target_dict = prop_object_iterator_next(iter)) != NULL) {
ff56536e
AH
736 prop_dictionary_get_cstring_nocopy(target_dict,
737 DM_TABLE_TYPE, &type);
738 /*
739 * If we want to deny table with 2 or more different
740 * target we should do it here
741 */
7115a22b
AH
742 if (((target = dm_target_lookup(type)) == NULL) &&
743 ((target = dm_target_autoload(type)) == NULL)) {
ff56536e
AH
744 dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE);
745 dm_dev_unbusy(dmv);
746 return ENOENT;
747 }
5b279a20
AH
748 if ((table_en = kmalloc(sizeof(dm_table_entry_t),
749 M_DM, M_WAITOK)) == NULL) {
ff56536e
AH
750 dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE);
751 dm_dev_unbusy(dmv);
12a49c9b 752 dm_target_unbusy(target);
ff56536e
AH
753 return ENOMEM;
754 }
755 prop_dictionary_get_uint64(target_dict, DM_TABLE_START,
756 &table_en->start);
757 prop_dictionary_get_uint64(target_dict, DM_TABLE_LENGTH,
758 &table_en->length);
759
e8e2bcda
AH
760 aprint_debug("dm_ioctl.c... table_en->start = %ju, "
761 "table_en->length = %ju\n",
762 (uintmax_t)table_en->start,
763 (uintmax_t)table_en->length);
5b279a20 764
ff56536e
AH
765 table_en->target = target;
766 table_en->dm_dev = dmv;
767 table_en->target_config = NULL;
768
769 /*
770 * There is a parameter string after dm_target_spec
771 * structure which points to /dev/wd0a 284 part of
772 * table. String str points to this text. This can be
773 * null and therefore it should be checked before we try to
774 * use it.
775 */
776 prop_dictionary_get_cstring(target_dict,
777 DM_TABLE_PARAMS, (char **) &str);
778
779 if (SLIST_EMPTY(tbl))
780 /* insert this table to head */
781 SLIST_INSERT_HEAD(tbl, table_en, next);
782 else
783 SLIST_INSERT_AFTER(last_table, table_en, next);
784
785 /*
786 * Params string is different for every target,
787 * therfore I have to pass it to target init
788 * routine and parse parameters there.
789 */
aadb5a11 790 aprint_debug("DM: str passed in is: %s", str);
ff56536e
AH
791 if ((ret = target->init(dmv, &table_en->target_config,
792 str)) != 0) {
793
794 dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE);
795 dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
5b279a20 796 kfree(str, M_TEMP);
ff56536e
AH
797
798 dm_dev_unbusy(dmv);
12a49c9b 799 dm_target_unbusy(target);
ff56536e
AH
800 return ret;
801 }
802 last_table = table_en;
5b279a20 803 kfree(str, M_TEMP);
ff56536e
AH
804 }
805 prop_object_iterator_release(iter);
806
807 DM_ADD_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
5b279a20 808 atomic_set_int(&dmv->flags, DM_INACTIVE_PRESENT_FLAG);
ff56536e
AH
809
810 dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE);
3b48c3c1 811
ff56536e 812 dm_dev_unbusy(dmv);
3b48c3c1
AH
813#if 0
814 dmsetdiskinfo(dmv->diskp, &dmv->table_head);
815#endif
ff56536e
AH
816 return 0;
817}
818/*
819 * Get description of all tables loaded to device from kernel
820 * and send it to libdevmapper.
821 *
822 * Output dictionary for every table:
823 *
824 * <key>cmd_data</key>
825 * <array>
826 * <dict>
827 * <key>type<key>
828 * <string>...</string>
829 *
830 * <key>start</key>
831 * <integer>...</integer>
832 *
833 * <key>length</key>
834 * <integer>...</integer>
835 *
836 * <key>params</key>
837 * <string>...</string>
838 * </dict>
839 * </array>
840 *
841 */
842int
843dm_table_status_ioctl(prop_dictionary_t dm_dict)
844{
845 dm_dev_t *dmv;
846 dm_table_t *tbl;
847 dm_table_entry_t *table_en;
848
849 prop_array_t cmd_array;
850 prop_dictionary_t target_dict;
851
852 uint32_t rec_size, minor;
853
854 const char *name, *uuid;
855 char *params;
856 int flags;
857 int table_type;
858
859 dmv = NULL;
860 uuid = NULL;
861 name = NULL;
862 params = NULL;
863 flags = 0;
864 rec_size = 0;
865
866 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
867 prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
868 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
869 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
870
871 cmd_array = prop_array_create();
872
873 if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
874 DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
875 return ENOENT;
876 }
877 /*
878 * if DM_QUERY_INACTIVE_TABLE_FLAG is passed we need to query
879 * INACTIVE TABLE
880 */
881 if (flags & DM_QUERY_INACTIVE_TABLE_FLAG)
882 table_type = DM_TABLE_INACTIVE;
883 else
884 table_type = DM_TABLE_ACTIVE;
885
886 if (dm_table_get_target_count(&dmv->table_head, DM_TABLE_ACTIVE))
887 DM_ADD_FLAG(flags, DM_ACTIVE_PRESENT_FLAG);
888 else {
889 DM_REMOVE_FLAG(flags, DM_ACTIVE_PRESENT_FLAG);
890
891 if (dm_table_get_target_count(&dmv->table_head, DM_TABLE_INACTIVE))
892 DM_ADD_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
893 else {
894 DM_REMOVE_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
895 }
896 }
897
898 if (dmv->flags & DM_SUSPEND_FLAG)
899 DM_ADD_FLAG(flags, DM_SUSPEND_FLAG);
900
901 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
902
903 aprint_debug("Status of device tables: %s--%d\n",
904 name, dmv->table_head.cur_active_table);
905
906 tbl = dm_table_get_entry(&dmv->table_head, table_type);
907
908 SLIST_FOREACH(table_en, tbl, next) {
909 target_dict = prop_dictionary_create();
910 aprint_debug("%016" PRIu64 ", length %016" PRIu64
911 ", target %s\n", table_en->start, table_en->length,
912 table_en->target->name);
913
914 prop_dictionary_set_uint64(target_dict, DM_TABLE_START,
915 table_en->start);
916 prop_dictionary_set_uint64(target_dict, DM_TABLE_LENGTH,
917 table_en->length);
918
919 prop_dictionary_set_cstring(target_dict, DM_TABLE_TYPE,
920 table_en->target->name);
921
922 /* dm_table_get_cur_actv.table ?? */
923 prop_dictionary_set_int32(target_dict, DM_TABLE_STAT,
924 dmv->table_head.cur_active_table);
925
926 if (flags |= DM_STATUS_TABLE_FLAG) {
927 params = table_en->target->status
928 (table_en->target_config);
929
930 if (params != NULL) {
931 prop_dictionary_set_cstring(target_dict,
932 DM_TABLE_PARAMS, params);
933
5b279a20 934 kfree(params, M_DM);
ff56536e
AH
935 }
936 }
937 prop_array_add(cmd_array, target_dict);
938 prop_object_release(target_dict);
939 }
940
941 dm_table_release(&dmv->table_head, table_type);
942 dm_dev_unbusy(dmv);
943
944 prop_dictionary_set_uint32(dm_dict, DM_IOCTL_FLAGS, flags);
945 prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, cmd_array);
946 prop_object_release(cmd_array);
947
948 return 0;
949}
950
951
952/*
953 * For every call I have to set kernel driver version.
954 * Because I can have commands supported only in other
955 * newer/later version. This routine is called for every
956 * ioctl command.
957 */
958int
959dm_check_version(prop_dictionary_t dm_dict)
960{
961 size_t i;
962 int dm_version[3];
963 prop_array_t ver;
964
965 ver = prop_dictionary_get(dm_dict, DM_IOCTL_VERSION);
966
967 for (i = 0; i < 3; i++)
968 prop_array_get_uint32(ver, i, &dm_version[i]);
969
970 if (DM_VERSION_MAJOR != dm_version[0] || DM_VERSION_MINOR < dm_version[1]) {
971 aprint_debug("libdevmapper/kernel version mismatch "
972 "kernel: %d.%d.%d libdevmapper: %d.%d.%d\n",
973 DM_VERSION_MAJOR, DM_VERSION_MINOR, DM_VERSION_PATCHLEVEL,
974 dm_version[0], dm_version[1], dm_version[2]);
975
976 return EIO;
977 }
978 prop_array_set_uint32(ver, 0, DM_VERSION_MAJOR);
979 prop_array_set_uint32(ver, 1, DM_VERSION_MINOR);
980 prop_array_set_uint32(ver, 2, DM_VERSION_PATCHLEVEL);
981
982 prop_dictionary_set(dm_dict, DM_IOCTL_VERSION, ver);
983
984 return 0;
985}