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