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