sys/dev/disk/dm/dm_ioctl.c

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