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