libdm/ioctl/libdm-iface.c

   1 /*
   2  * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
   3  * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
   4  *
   5  * This file is part of the device-mapper userspace tools.
   6  *
   7  * This copyrighted material is made available to anyone wishing to use,
   8  * modify, copy, or redistribute it subject to the terms and conditions
   9  * of the GNU Lesser General Public License v.2.1.
  10  *
  11  * You should have received a copy of the GNU Lesser General Public License
  12  * along with this program; if not, write to the Free Software Foundation,
  13  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  14  */
  15
  16 #include "dmlib.h"
  17 #include "libdm-targets.h"
  18 #include "libdm-common.h"
  19
  20 #ifdef DM_COMPAT
  21 #  include "libdm-compat.h"
  22 #endif
  23
  24 #include <fcntl.h>
  25 #include <dirent.h>
  26 #include <sys/ioctl.h>
  27 #include <sys/utsname.h>
  28 #include <limits.h>
  29
  30 #ifdef linux
  31 #  include "kdev_t.h"
  32 #  include <linux/limits.h>
  33 #else
  34 #  define MAJOR(x) major((x))
  35 #  define MINOR(x) minor((x))
  36 #  define MKDEV(x,y) makedev((x),(y))
  37 #endif
  38
  39 #include "dm-ioctl.h"
  40
  41 /*
  42  * Ensure build compatibility.
  43  * The hard-coded versions here are the highest present
  44  * in the _cmd_data arrays.
  45  */
  46
  47 #if !((DM_VERSION_MAJOR == 1 && DM_VERSION_MINOR >= 0) || \
  48       (DM_VERSION_MAJOR == 4 && DM_VERSION_MINOR >= 0))
  49 #error The version of dm-ioctl.h included is incompatible.
  50 #endif
  51
  52 /* FIXME This should be exported in device-mapper.h */
  53 #define DM_NAME "device-mapper"
  54
  55 #define PROC_MISC "/proc/misc"
  56 #define PROC_DEVICES "/proc/devices"
  57 #define MISC_NAME "misc"
  58
  59 #define NUMBER_OF_MAJORS 4096
  60
  61 /*
  62  * Static minor number assigned since kernel version 2.6.36.
  63  * The original definition is in kernel's include/linux/miscdevice.h.
  64  * This number is also visible in modules.devname exported by depmod
  65  * utility (support included in module-init-tools version >= 3.12).
  66  */
  67 #define MAPPER_CTRL_MINOR 236
  68 #define MISC_MAJOR 10
  69
  70 /* dm major version no for running kernel */
  71 static unsigned _dm_version = DM_VERSION_MAJOR;
  72 static unsigned _dm_version_minor = 0;
  73 static unsigned _dm_version_patchlevel = 0;
  74 static int _log_suppress = 0;
  75
  76 static int _kernel_major;
  77 static int _kernel_minor;
  78 static int _kernel_release;
  79
  80 /*
  81  * If the kernel dm driver only supports one major number
  82  * we store it in _dm_device_major.  Otherwise we indicate
  83  * which major numbers have been claimed by device-mapper
  84  * in _dm_bitset.
  85  */
  86 static unsigned _dm_multiple_major_support = 1;
  87 static dm_bitset_t _dm_bitset = NULL;
  88 static uint32_t _dm_device_major = 0;
  89
  90 static int _control_fd = -1;
  91 static int _version_checked = 0;
  92 static int _version_ok = 1;
  93 static unsigned _ioctl_buffer_double_factor = 0;
  94
  95 /*
  96  * Support both old and new major numbers to ease the transition.
  97  * Clumsy, but only temporary.
  98  */
  99 #if DM_VERSION_MAJOR == 4 && defined(DM_COMPAT)
 100 const int _dm_compat = 1;
 101 #else
 102 const int _dm_compat = 0;
 103 #endif
 104
 105
 106 /* *INDENT-OFF* */
 107 static struct cmd_data _cmd_data_v4[] = {
 108         {"create",      DM_DEV_CREATE,          {4, 0, 0}},
 109         {"reload",      DM_TABLE_LOAD,          {4, 0, 0}},
 110         {"remove",      DM_DEV_REMOVE,          {4, 0, 0}},
 111         {"remove_all",  DM_REMOVE_ALL,          {4, 0, 0}},
 112         {"suspend",     DM_DEV_SUSPEND,         {4, 0, 0}},
 113         {"resume",      DM_DEV_SUSPEND,         {4, 0, 0}},
 114         {"info",        DM_DEV_STATUS,          {4, 0, 0}},
 115         {"deps",        DM_TABLE_DEPS,          {4, 0, 0}},
 116         {"rename",      DM_DEV_RENAME,          {4, 0, 0}},
 117         {"version",     DM_VERSION,             {4, 0, 0}},
 118         {"status",      DM_TABLE_STATUS,        {4, 0, 0}},
 119         {"table",       DM_TABLE_STATUS,        {4, 0, 0}},
 120         {"waitevent",   DM_DEV_WAIT,            {4, 0, 0}},
 121         {"names",       DM_LIST_DEVICES,        {4, 0, 0}},
 122         {"clear",       DM_TABLE_CLEAR,         {4, 0, 0}},
 123         {"mknodes",     DM_DEV_STATUS,          {4, 0, 0}},
 124 #ifdef DM_LIST_VERSIONS
 125         {"versions",    DM_LIST_VERSIONS,       {4, 1, 0}},
 126 #endif
 127 #ifdef DM_TARGET_MSG
 128         {"message",     DM_TARGET_MSG,          {4, 2, 0}},
 129 #endif
 130 #ifdef DM_DEV_SET_GEOMETRY
 131         {"setgeometry", DM_DEV_SET_GEOMETRY,    {4, 6, 0}},
 132 #endif
 133 };
 134 /* *INDENT-ON* */
 135
 136 #define ALIGNMENT_V1 sizeof(int)
 137 #define ALIGNMENT 8
 138
 139 /* FIXME Rejig library to record & use errno instead */
 140 #ifndef DM_EXISTS_FLAG
 141 #  define DM_EXISTS_FLAG 0x00000004
 142 #endif
 143
 144 static void *_align(void *ptr, unsigned int a)
 145 {
 146         register unsigned long agn = --a;
 147
 148         return (void *) (((unsigned long) ptr + agn) & ~agn);
 149 }
 150
 151 static int _uname(void)
 152 {
 153         static int _uts_set = 0;
 154         struct utsname _uts;
 155
 156         if (_uts_set)
 157                 return 1;
 158
 159         if (uname(&_uts)) {
 160                 log_error("uname failed: %s", strerror(errno));
 161                 return 0;
 162         }
 163         if (sscanf(_uts.release, "%d.%d.%d",
 164                         &_kernel_major,
 165                         &_kernel_minor,
 166                         &_kernel_release) != 3) {
 167                 log_error("Could not determine kernel version used.");
 168                 return 0;
 169         }
 170
 171         _uts_set = 1;
 172         return 1;
 173 }
 174
 175 #ifdef DM_IOCTLS
 176 /*
 177  * Set number to NULL to populate _dm_bitset - otherwise first
 178  * match is returned.
 179  */
 180 static int _get_proc_number(const char *file, const char *name,
 181                             uint32_t *number)
 182 {
 183         FILE *fl;
 184         char nm[256];
 185         int c;
 186         uint32_t num;
 187
 188         if (!(fl = fopen(file, "r"))) {
 189                 log_sys_error("fopen", file);
 190                 return 0;
 191         }
 192
 193         while (!feof(fl)) {
 194                 if (fscanf(fl, "%d %255s\n", &num, &nm[0]) == 2) {
 195                         if (!strcmp(name, nm)) {
 196                                 if (number) {
 197                                         *number = num;
 198                                         if (fclose(fl))
 199                                                 log_sys_error("fclose", file);
 200                                         return 1;
 201                                 }
 202                                 dm_bit_set(_dm_bitset, num);
 203                         }
 204                 } else do {
 205                         c = fgetc(fl);
 206                 } while (c != EOF && c != '\n');
 207         }
 208         if (fclose(fl))
 209                 log_sys_error("fclose", file);
 210
 211         if (number) {
 212                 log_error("%s: No entry for %s found", file, name);
 213                 return 0;
 214         }
 215
 216         return 1;
 217 }
 218
 219 static int _control_device_number(uint32_t *major, uint32_t *minor)
 220 {
 221         if (!_get_proc_number(PROC_DEVICES, MISC_NAME, major) ||
 222             !_get_proc_number(PROC_MISC, DM_NAME, minor)) {
 223                 *major = 0;
 224                 return 0;
 225         }
 226
 227         return 1;
 228 }
 229
 230 /*
 231  * Returns 1 if exists; 0 if it doesn't; -1 if it's wrong
 232  */
 233 static int _control_exists(const char *control, uint32_t major, uint32_t minor)
 234 {
 235         struct stat buf;
 236
 237         if (stat(control, &buf) < 0) {
 238                 if (errno != ENOENT)
 239                         log_sys_error("stat", control);
 240                 return 0;
 241         }
 242
 243         if (!S_ISCHR(buf.st_mode)) {
 244                 log_verbose("%s: Wrong inode type", control);
 245                 if (!unlink(control))
 246                         return 0;
 247                 log_sys_error("unlink", control);
 248                 return -1;
 249         }
 250
 251         if (major && buf.st_rdev != MKDEV(major, minor)) {
 252                 log_verbose("%s: Wrong device number: (%u, %u) instead of "
 253                             "(%u, %u)", control,
 254                             MAJOR(buf.st_mode), MINOR(buf.st_mode),
 255                             major, minor);
 256                 if (!unlink(control))
 257                         return 0;
 258                 log_sys_error("unlink", control);
 259                 return -1;
 260         }
 261
 262         return 1;
 263 }
 264
 265 static int _create_control(const char *control, uint32_t major, uint32_t minor)
 266 {
 267         int ret;
 268         mode_t old_umask;
 269
 270         if (!major)
 271                 return 0;
 272
 273         (void) dm_prepare_selinux_context(dm_dir(), S_IFDIR);
 274         old_umask = umask(DM_DEV_DIR_UMASK);
 275         ret = dm_create_dir(dm_dir());
 276         umask(old_umask);
 277         (void) dm_prepare_selinux_context(NULL, 0);
 278
 279         if (!ret)
 280                 return 0;
 281
 282         log_verbose("Creating device %s (%u, %u)", control, major, minor);
 283
 284         (void) dm_prepare_selinux_context(control, S_IFCHR);
 285         if (mknod(control, S_IFCHR | S_IRUSR | S_IWUSR,
 286                   MKDEV(major, minor)) < 0)  {
 287                 log_sys_error("mknod", control);
 288                 (void) dm_prepare_selinux_context(NULL, 0);
 289                 return 0;
 290         }
 291         (void) dm_prepare_selinux_context(NULL, 0);
 292
 293         return 1;
 294 }
 295 #endif
 296
 297 /*
 298  * FIXME Update bitset in long-running process if dm claims new major numbers.
 299  */
 300 static int _create_dm_bitset(void)
 301 {
 302 #ifdef DM_IOCTLS
 303         if (_dm_bitset || _dm_device_major)
 304                 return 1;
 305
 306         if (!_uname())
 307                 return 0;
 308
 309         /*
 310          * 2.6 kernels are limited to one major number.
 311          * Assume 2.4 kernels are patched not to.
 312          * FIXME Check _dm_version and _dm_version_minor if 2.6 changes this.
 313          */
 314         if (KERNEL_VERSION(_kernel_major, _kernel_minor, _kernel_release) >=
 315             KERNEL_VERSION(2, 6, 0))
 316                 _dm_multiple_major_support = 0;
 317
 318         if (!_dm_multiple_major_support) {
 319                 if (!_get_proc_number(PROC_DEVICES, DM_NAME, &_dm_device_major))
 320                         return 0;
 321                 return 1;
 322         }
 323
 324         /* Multiple major numbers supported */
 325         if (!(_dm_bitset = dm_bitset_create(NULL, NUMBER_OF_MAJORS)))
 326                 return 0;
 327
 328         if (!_get_proc_number(PROC_DEVICES, DM_NAME, NULL)) {
 329                 dm_bitset_destroy(_dm_bitset);
 330                 _dm_bitset = NULL;
 331                 return 0;
 332         }
 333
 334         return 1;
 335 #else
 336         return 0;
 337 #endif
 338 }
 339
 340 int dm_is_dm_major(uint32_t major)
 341 {
 342         if (!_create_dm_bitset())
 343                 return 0;
 344
 345         if (_dm_multiple_major_support)
 346                 return dm_bit(_dm_bitset, major) ? 1 : 0;
 347         else
 348                 return (major == _dm_device_major) ? 1 : 0;
 349 }
 350
 351 static void _close_control_fd(void)
 352 {
 353         if (_control_fd != -1) {
 354                 if (close(_control_fd) < 0)
 355                         log_sys_error("close", "_control_fd");
 356                 _control_fd = -1;
 357         }
 358 }
 359
 360 static int _open_and_assign_control_fd(const char *control,
 361                                        int ignore_nodev)
 362 {
 363         _close_control_fd();
 364
 365         if ((_control_fd = open(control, O_RDWR)) < 0) {
 366                 if (!(ignore_nodev && errno == ENODEV))
 367                         log_sys_error("open", control);
 368                 return 0;
 369         }
 370
 371         return 1;
 372 }
 373
 374 static int _open_control(void)
 375 {
 376 #ifdef DM_IOCTLS
 377         char control[PATH_MAX];
 378         uint32_t major = 0, minor;
 379         int dm_mod_autoload_support, needs_open;
 380
 381         if (_control_fd != -1)
 382                 return 1;
 383
 384         if (!_uname())
 385                 return 0;
 386
 387         snprintf(control, sizeof(control), "%s/%s", dm_dir(), DM_CONTROL_NODE);
 388
 389         /*
 390          * dm-mod autoloading is supported since kernel 2.6.36.
 391          * Udev daemon will try to read modules.devname file extracted
 392          * by depmod and create any static nodes needed.
 393          * The /dev/mapper/control node can be created and prepared this way.
 394          * First access to such node should load dm-mod module automatically.
 395          */
 396         dm_mod_autoload_support = KERNEL_VERSION(_kernel_major, _kernel_minor,
 397                                   _kernel_release) >= KERNEL_VERSION(2, 6, 36);
 398
 399         /*
 400          *  If dm-mod autoloading is supported and the control node exists
 401          *  already try to open it now. This should autoload dm-mod module.
 402          */
 403         if (dm_mod_autoload_support) {
 404                 if (!_get_proc_number(PROC_DEVICES, MISC_NAME, &major))
 405                         /* If major not found, just fallback to hardcoded value. */
 406                         major = MISC_MAJOR;
 407
 408                 /* Recreate the node with correct major and minor if needed. */
 409                 if (!_control_exists(control, major, MAPPER_CTRL_MINOR) &&
 410                     !_create_control(control, major, MAPPER_CTRL_MINOR))
 411                         goto error;
 412
 413                 _open_and_assign_control_fd(control, 1);
 414         }
 415
 416         /*
 417          * Get major and minor number assigned for the control node.
 418          * In case we make use of the module autoload support, this
 419          * information should be accessible now as well.
 420          */
 421         if (!_control_device_number(&major, &minor))
 422                 log_error("Is device-mapper driver missing from kernel?");
 423
 424         /*
 425          * Check the control node and its major and minor number.
 426          * If there's anything wrong, remove the old node and create
 427          * a correct one.
 428          */
 429         if ((needs_open = !_control_exists(control, major, minor)) &&
 430             !_create_control(control, major, minor)) {
 431                 _close_control_fd();
 432                 goto error;
 433         }
 434
 435         /*
 436          * For older kernels without dm-mod autoloading support, we always
 437          * need to open the control node here - we still haven't done that!
 438          * For newer kernels with dm-mod autoloading, we open it only if the
 439          * node was recreated and corrected in previous step.
 440          */
 441         if ((!dm_mod_autoload_support || needs_open) &&
 442              !_open_and_assign_control_fd(control, 0))
 443                 goto error;
 444
 445         if (!_create_dm_bitset()) {
 446                 log_error("Failed to set up list of device-mapper major numbers");
 447                 return 0;
 448         }
 449
 450         return 1;
 451
 452 error:
 453         log_error("Failure to communicate with kernel device-mapper driver.");
 454         return 0;
 455 #else
 456         return 1;
 457 #endif
 458 }
 459
 460 static void _dm_zfree_string(char *string)
 461 {
 462         if (string) {
 463                 memset(string, 0, strlen(string));
 464                 dm_free(string);
 465         }
 466 }
 467
 468 static void _dm_zfree_dmi(struct dm_ioctl *dmi)
 469 {
 470         if (dmi) {
 471                 memset(dmi, 0, dmi->data_size);
 472                 dm_free(dmi);
 473         }
 474 }
 475
 476 void dm_task_destroy(struct dm_task *dmt)
 477 {
 478         struct target *t, *n;
 479
 480         for (t = dmt->head; t; t = n) {
 481                 n = t->next;
 482                 _dm_zfree_string(t->params);
 483                 dm_free(t->type);
 484                 dm_free(t);
 485         }
 486
 487         if (dmt->dev_name)
 488                 dm_free(dmt->dev_name);
 489
 490         if (dmt->newname)
 491                 dm_free(dmt->newname);
 492
 493         if (dmt->message)
 494                 dm_free(dmt->message);
 495
 496         _dm_zfree_dmi(dmt->dmi.v4);
 497
 498         if (dmt->uuid)
 499                 dm_free(dmt->uuid);
 500
 501         dm_free(dmt);
 502 }
 503
 504 /*
 505  * Protocol Version 1 compatibility functions.
 506  */
 507
 508 #ifdef DM_COMPAT
 509
 510 static void _dm_zfree_dmi_v1(struct dm_ioctl_v1 *dmi)
 511 {
 512         if (dmi) {
 513                 memset(dmi, 0, dmi->data_size);
 514                 dm_free(dmi);
 515         }
 516 }
 517
 518 static int _dm_task_get_driver_version_v1(struct dm_task *dmt, char *version,
 519                                           size_t size)
 520 {
 521         unsigned int *v;
 522
 523         if (!dmt->dmi.v1) {
 524                 version[0] = '\0';
 525                 return 0;
 526         }
 527
 528         v = dmt->dmi.v1->version;
 529         snprintf(version, size, "%u.%u.%u", v[0], v[1], v[2]);
 530         return 1;
 531 }
 532
 533 /* Unmarshall the target info returned from a status call */
 534 static int _unmarshal_status_v1(struct dm_task *dmt, struct dm_ioctl_v1 *dmi)
 535 {
 536         char *outbuf = (char *) dmi + dmi->data_start;
 537         char *outptr = outbuf;
 538         int32_t i;
 539         struct dm_target_spec_v1 *spec;
 540
 541         for (i = 0; i < dmi->target_count; i++) {
 542                 spec = (struct dm_target_spec_v1 *) outptr;
 543
 544                 if (!dm_task_add_target(dmt, spec->sector_start,
 545                                         (uint64_t) spec->length,
 546                                         spec->target_type,
 547                                         outptr + sizeof(*spec))) {
 548                         return 0;
 549                 }
 550
 551                 outptr = outbuf + spec->next;
 552         }
 553
 554         return 1;
 555 }
 556
 557 static int _dm_format_dev_v1(char *buf, int bufsize, uint32_t dev_major,
 558                              uint32_t dev_minor)
 559 {
 560         int r;
 561
 562         if (bufsize < 8)
 563                 return 0;
 564
 565         r = snprintf(buf, bufsize, "%03x:%03x", dev_major, dev_minor);
 566         if (r < 0 || r > bufsize - 1)
 567                 return 0;
 568
 569         return 1;
 570 }
 571
 572 static int _dm_task_get_info_v1(struct dm_task *dmt, struct dm_info *info)
 573 {
 574         if (!dmt->dmi.v1)
 575                 return 0;
 576
 577         memset(info, 0, sizeof(*info));
 578
 579         info->exists = dmt->dmi.v1->flags & DM_EXISTS_FLAG ? 1 : 0;
 580         if (!info->exists)
 581                 return 1;
 582
 583         info->suspended = dmt->dmi.v1->flags & DM_SUSPEND_FLAG ? 1 : 0;
 584         info->read_only = dmt->dmi.v1->flags & DM_READONLY_FLAG ? 1 : 0;
 585         info->target_count = dmt->dmi.v1->target_count;
 586         info->open_count = dmt->dmi.v1->open_count;
 587         info->event_nr = 0;
 588         info->major = MAJOR(dmt->dmi.v1->dev);
 589         info->minor = MINOR(dmt->dmi.v1->dev);
 590         info->live_table = 1;
 591         info->inactive_table = 0;
 592
 593         return 1;
 594 }
 595
 596 static const char *_dm_task_get_name_v1(const struct dm_task *dmt)
 597 {
 598         return (dmt->dmi.v1->name);
 599 }
 600
 601 static const char *_dm_task_get_uuid_v1(const struct dm_task *dmt)
 602 {
 603         return (dmt->dmi.v1->uuid);
 604 }
 605
 606 static struct dm_deps *_dm_task_get_deps_v1(struct dm_task *dmt)
 607 {
 608         log_error("deps version 1 no longer supported by libdevmapper");
 609         return NULL;
 610 }
 611
 612 static struct dm_names *_dm_task_get_names_v1(struct dm_task *dmt)
 613 {
 614         return (struct dm_names *) (((void *) dmt->dmi.v1) +
 615                                     dmt->dmi.v1->data_start);
 616 }
 617
 618 static void *_add_target_v1(struct target *t, void *out, void *end)
 619 {
 620         void *out_sp = out;
 621         struct dm_target_spec_v1 sp;
 622         size_t sp_size = sizeof(struct dm_target_spec_v1);
 623         int len;
 624
 625         out += sp_size;
 626         if (out >= end)
 627                 return_NULL;
 628
 629         sp.status = 0;
 630         sp.sector_start = t->start;
 631         sp.length = t->length;
 632         strncpy(sp.target_type, t->type, sizeof(sp.target_type));
 633
 634         len = strlen(t->params);
 635
 636         if ((out + len + 1) >= end)
 637                 return_NULL;
 638
 639         strcpy((char *) out, t->params);
 640         out += len + 1;
 641
 642         /* align next block */
 643         out = _align(out, ALIGNMENT_V1);
 644
 645         sp.next = out - out_sp;
 646
 647         memcpy(out_sp, &sp, sp_size);
 648
 649         return out;
 650 }
 651
 652 static struct dm_ioctl_v1 *_flatten_v1(struct dm_task *dmt)
 653 {
 654         const size_t min_size = 16 * 1024;
 655         const int (*version)[3];
 656
 657         struct dm_ioctl_v1 *dmi;
 658         struct target *t;
 659         size_t len = sizeof(struct dm_ioctl_v1);
 660         void *b, *e;
 661         int count = 0;
 662
 663         for (t = dmt->head; t; t = t->next) {
 664                 len += sizeof(struct dm_target_spec_v1);
 665                 len += strlen(t->params) + 1 + ALIGNMENT_V1;
 666                 count++;
 667         }
 668
 669         if (count && dmt->newname) {
 670                 log_error("targets and newname are incompatible");
 671                 return NULL;
 672         }
 673
 674         if (dmt->newname)
 675                 len += strlen(dmt->newname) + 1;
 676
 677         /*
 678          * Give len a minimum size so that we have space to store
 679          * dependencies or status information.
 680          */
 681         if (len < min_size)
 682                 len = min_size;
 683
 684         if (!(dmi = dm_malloc(len)))
 685                 return NULL;
 686
 687         memset(dmi, 0, len);
 688
 689         version = &_cmd_data_v1[dmt->type].version;
 690
 691         dmi->version[0] = (*version)[0];
 692         dmi->version[1] = (*version)[1];
 693         dmi->version[2] = (*version)[2];
 694
 695         dmi->data_size = len;
 696         dmi->data_start = sizeof(struct dm_ioctl_v1);
 697
 698         if (dmt->dev_name)
 699                 strncpy(dmi->name, dmt->dev_name, sizeof(dmi->name));
 700
 701         if (dmt->type == DM_DEVICE_SUSPEND)
 702                 dmi->flags |= DM_SUSPEND_FLAG;
 703         if (dmt->read_only)
 704                 dmi->flags |= DM_READONLY_FLAG;
 705
 706         if (dmt->minor >= 0) {
 707                 if (dmt->major <= 0) {
 708                         log_error("Missing major number for persistent device");
 709                         return NULL;
 710                 }
 711                 dmi->flags |= DM_PERSISTENT_DEV_FLAG;
 712                 dmi->dev = MKDEV(dmt->major, dmt->minor);
 713         }
 714
 715         if (dmt->uuid)
 716                 strncpy(dmi->uuid, dmt->uuid, sizeof(dmi->uuid));
 717
 718         dmi->target_count = count;
 719
 720         b = (void *) (dmi + 1);
 721         e = (void *) ((char *) dmi + len);
 722
 723         for (t = dmt->head; t; t = t->next)
 724                 if (!(b = _add_target_v1(t, b, e))) {
 725                         log_error("Ran out of memory building ioctl parameter");
 726                         goto bad;
 727                 }
 728
 729         if (dmt->newname)
 730                 strcpy(b, dmt->newname);
 731
 732         return dmi;
 733
 734       bad:
 735         _dm_zfree_dmi_v1(dmi);
 736         return NULL;
 737 }
 738
 739 static int _dm_names_v1(struct dm_ioctl_v1 *dmi)
 740 {
 741         const char *dev_dir = dm_dir();
 742         int r = 1, len;
 743         const char *name;
 744         struct dirent *dirent;
 745         DIR *d;
 746         struct dm_names *names, *old_names = NULL;
 747         void *end = (void *) dmi + dmi->data_size;
 748         struct stat buf;
 749         char path[PATH_MAX];
 750
 751         log_warn("WARNING: Device list may be incomplete with interface "
 752                   "version 1.");
 753         log_warn("Please upgrade your kernel device-mapper driver.");
 754
 755         if (!(d = opendir(dev_dir))) {
 756                 log_sys_error("opendir", dev_dir);
 757                 return 0;
 758         }
 759
 760         names = (struct dm_names *) ((void *) dmi + dmi->data_start);
 761
 762         names->dev = 0;         /* Flags no data */
 763
 764         while ((dirent = readdir(d))) {
 765                 name = dirent->d_name;
 766
 767                 if (name[0] == '.' || !strcmp(name, "control"))
 768                         continue;
 769
 770                 if (old_names)
 771                         old_names->next = (uint32_t) ((void *) names -
 772                                                       (void *) old_names);
 773                 snprintf(path, sizeof(path), "%s/%s", dev_dir, name);
 774                 if (stat(path, &buf)) {
 775                         log_sys_error("stat", path);
 776                         continue;
 777                 }
 778                 if (!S_ISBLK(buf.st_mode))
 779                         continue;
 780                 names->dev = (uint64_t) buf.st_rdev;
 781                 names->next = 0;
 782                 len = strlen(name);
 783                 if (((void *) (names + 1) + len + 1) >= end) {
 784                         log_error("Insufficient buffer space for device list");
 785                         r = 0;
 786                         break;
 787                 }
 788
 789                 strcpy(names->name, name);
 790
 791                 old_names = names;
 792                 names = _align((void *) ++names + len + 1, ALIGNMENT);
 793         }
 794
 795         if (closedir(d))
 796                 log_sys_error("closedir", dev_dir);
 797
 798         return r;
 799 }
 800
 801 static int _dm_task_run_v1(struct dm_task *dmt)
 802 {
 803         struct dm_ioctl_v1 *dmi;
 804         unsigned int command;
 805
 806         dmi = _flatten_v1(dmt);
 807         if (!dmi) {
 808                 log_error("Couldn't create ioctl argument.");
 809                 return 0;
 810         }
 811
 812         if (!_open_control())
 813                 return 0;
 814
 815         if ((unsigned) dmt->type >=
 816             (sizeof(_cmd_data_v1) / sizeof(*_cmd_data_v1))) {
 817                 log_error(INTERNAL_ERROR "unknown device-mapper task %d",
 818                           dmt->type);
 819                 goto bad;
 820         }
 821
 822         command = _cmd_data_v1[dmt->type].cmd;
 823
 824         if (dmt->type == DM_DEVICE_TABLE)
 825                 dmi->flags |= DM_STATUS_TABLE_FLAG;
 826
 827         if (dmt->new_uuid) {
 828                 log_error("Changing UUID is not supported by kernel.");
 829                 goto bad;
 830         }
 831
 832         log_debug("dm %s %s %s%s%s [%u]", _cmd_data_v1[dmt->type].name,
 833                   dmi->name, dmi->uuid, dmt->newname ? " " : "",
 834                   dmt->newname ? dmt->newname : "",
 835                   dmi->data_size);
 836         if (dmt->type == DM_DEVICE_LIST) {
 837                 if (!_dm_names_v1(dmi))
 838                         goto bad;
 839         }
 840 #ifdef DM_IOCTLS
 841         else if (ioctl(_control_fd, command, dmi) < 0) {
 842                 if (_log_suppress)
 843                         log_verbose("device-mapper: %s ioctl failed: %s",
 844                                     _cmd_data_v1[dmt->type].name,
 845                                     strerror(errno));
 846                 else
 847                         log_error("device-mapper: %s ioctl failed: %s",
 848                                   _cmd_data_v1[dmt->type].name,
 849                                   strerror(errno));
 850                 goto bad;
 851         }
 852 #else /* Userspace alternative for testing */
 853 #endif
 854
 855         if (dmi->flags & DM_BUFFER_FULL_FLAG)
 856                 /* FIXME Increase buffer size and retry operation (if query) */
 857                 log_error("WARNING: libdevmapper buffer too small for data");
 858
 859         switch (dmt->type) {
 860         case DM_DEVICE_CREATE:
 861                 add_dev_node(dmt->dev_name, MAJOR(dmi->dev), MINOR(dmi->dev),
 862                              dmt->uid, dmt->gid, dmt->mode, 0);
 863                 break;
 864
 865         case DM_DEVICE_REMOVE:
 866                 rm_dev_node(dmt->dev_name, 0);
 867                 break;
 868
 869         case DM_DEVICE_RENAME:
 870                 rename_dev_node(dmt->dev_name, dmt->newname, 0);
 871                 break;
 872
 873         case DM_DEVICE_MKNODES:
 874                 if (dmi->flags & DM_EXISTS_FLAG)
 875                         add_dev_node(dmt->dev_name, MAJOR(dmi->dev),
 876                                      MINOR(dmi->dev), dmt->uid,
 877                                      dmt->gid, dmt->mode, 0);
 878                 else
 879                         rm_dev_node(dmt->dev_name, 0);
 880                 break;
 881
 882         case DM_DEVICE_STATUS:
 883         case DM_DEVICE_TABLE:
 884                 if (!_unmarshal_status_v1(dmt, dmi))
 885                         goto bad;
 886                 break;
 887
 888         case DM_DEVICE_SUSPEND:
 889         case DM_DEVICE_RESUME:
 890                 dmt->type = DM_DEVICE_INFO;
 891                 if (!dm_task_run(dmt))
 892                         goto bad;
 893                 _dm_zfree_dmi_v1(dmi);  /* We'll use what info returned */
 894                 return 1;
 895         }
 896
 897         dmt->dmi.v1 = dmi;
 898         return 1;
 899
 900       bad:
 901         _dm_zfree_dmi_v1(dmi);
 902         return 0;
 903 }
 904
 905 #endif
 906
 907 /*
 908  * Protocol Version 4 functions.
 909  */
 910
 911 int dm_task_get_driver_version(struct dm_task *dmt, char *version, size_t size)
 912 {
 913         unsigned *v;
 914
 915 #ifdef DM_COMPAT
 916         if (_dm_version == 1)
 917                 return _dm_task_get_driver_version_v1(dmt, version, size);
 918 #endif
 919
 920         if (!dmt->dmi.v4) {
 921                 version[0] = '\0';
 922                 return 0;
 923         }
 924
 925         v = dmt->dmi.v4->version;
 926         snprintf(version, size, "%u.%u.%u", v[0], v[1], v[2]);
 927         _dm_version_minor = v[1];
 928         _dm_version_patchlevel = v[2];
 929
 930         return 1;
 931 }
 932
 933 static int _check_version(char *version, size_t size, int log_suppress)
 934 {
 935         struct dm_task *task;
 936         int r;
 937
 938         if (!(task = dm_task_create(DM_DEVICE_VERSION))) {
 939                 log_error("Failed to get device-mapper version");
 940                 version[0] = '\0';
 941                 return 0;
 942         }
 943
 944         if (log_suppress)
 945                 _log_suppress = 1;
 946
 947         r = dm_task_run(task);
 948         dm_task_get_driver_version(task, version, size);
 949         dm_task_destroy(task);
 950         _log_suppress = 0;
 951
 952         return r;
 953 }
 954
 955 /*
 956  * Find out device-mapper's major version number the first time
 957  * this is called and whether or not we support it.
 958  */
 959 int dm_check_version(void)
 960 {
 961         char libversion[64], dmversion[64];
 962         const char *compat = "";
 963
 964         if (_version_checked)
 965                 return _version_ok;
 966
 967         _version_checked = 1;
 968
 969         if (_check_version(dmversion, sizeof(dmversion), _dm_compat))
 970                 return 1;
 971
 972         if (!_dm_compat)
 973                 goto bad;
 974
 975         log_verbose("device-mapper ioctl protocol version %u failed. "
 976                     "Trying protocol version 1.", _dm_version);
 977         _dm_version = 1;
 978         if (_check_version(dmversion, sizeof(dmversion), 0)) {
 979                 log_verbose("Using device-mapper ioctl protocol version 1");
 980                 return 1;
 981         }
 982
 983         compat = "(compat)";
 984
 985         dm_get_library_version(libversion, sizeof(libversion));
 986
 987         log_error("Incompatible libdevmapper %s%s and kernel driver %s",
 988                   libversion, compat, dmversion);
 989
 990       bad:
 991         _version_ok = 0;
 992         return 0;
 993 }
 994
 995 int dm_cookie_supported(void)
 996 {
 997         return (dm_check_version() &&
 998                 _dm_version >= 4 &&
 999                 _dm_version_minor >= 15);
1000 }
1001
1002 void *dm_get_next_target(struct dm_task *dmt, void *next,
1003                          uint64_t *start, uint64_t *length,
1004                          char **target_type, char **params)
1005 {
1006         struct target *t = (struct target *) next;
1007
1008         if (!t)
1009                 t = dmt->head;
1010
1011         if (!t)
1012                 return NULL;
1013
1014         *start = t->start;
1015         *length = t->length;
1016         *target_type = t->type;
1017         *params = t->params;
1018
1019         return t->next;
1020 }
1021
1022 /* Unmarshall the target info returned from a status call */
1023 static int _unmarshal_status(struct dm_task *dmt, struct dm_ioctl *dmi)
1024 {
1025         char *outbuf = (char *) dmi + dmi->data_start;
1026         char *outptr = outbuf;
1027         uint32_t i;
1028         struct dm_target_spec *spec;
1029
1030         for (i = 0; i < dmi->target_count; i++) {
1031                 spec = (struct dm_target_spec *) outptr;
1032                 if (!dm_task_add_target(dmt, spec->sector_start,
1033                                         spec->length,
1034                                         spec->target_type,
1035                                         outptr + sizeof(*spec))) {
1036                         return 0;
1037                 }
1038
1039                 outptr = outbuf + spec->next;
1040         }
1041
1042         return 1;
1043 }
1044
1045 int dm_format_dev(char *buf, int bufsize, uint32_t dev_major,
1046                   uint32_t dev_minor)
1047 {
1048         int r;
1049
1050 #ifdef DM_COMPAT
1051         if (_dm_version == 1)
1052                 return _dm_format_dev_v1(buf, bufsize, dev_major, dev_minor);
1053 #endif
1054
1055         if (bufsize < 8)
1056                 return 0;
1057
1058         r = snprintf(buf, (size_t) bufsize, "%u:%u", dev_major, dev_minor);
1059         if (r < 0 || r > bufsize - 1)
1060                 return 0;
1061
1062         return 1;
1063 }
1064
1065 int dm_task_get_info(struct dm_task *dmt, struct dm_info *info)
1066 {
1067 #ifdef DM_COMPAT
1068         if (_dm_version == 1)
1069                 return _dm_task_get_info_v1(dmt, info);
1070 #endif
1071
1072         if (!dmt->dmi.v4)
1073                 return 0;
1074
1075         memset(info, 0, sizeof(*info));
1076
1077         info->exists = dmt->dmi.v4->flags & DM_EXISTS_FLAG ? 1 : 0;
1078         if (!info->exists)
1079                 return 1;
1080
1081         info->suspended = dmt->dmi.v4->flags & DM_SUSPEND_FLAG ? 1 : 0;
1082         info->read_only = dmt->dmi.v4->flags & DM_READONLY_FLAG ? 1 : 0;
1083         info->live_table = dmt->dmi.v4->flags & DM_ACTIVE_PRESENT_FLAG ? 1 : 0;
1084         info->inactive_table = dmt->dmi.v4->flags & DM_INACTIVE_PRESENT_FLAG ?
1085             1 : 0;
1086         info->target_count = dmt->dmi.v4->target_count;
1087         info->open_count = dmt->dmi.v4->open_count;
1088         info->event_nr = dmt->dmi.v4->event_nr;
1089         info->major = MAJOR(dmt->dmi.v4->dev);
1090         info->minor = MINOR(dmt->dmi.v4->dev);
1091
1092         return 1;
1093 }
1094
1095 uint32_t dm_task_get_read_ahead(const struct dm_task *dmt, uint32_t *read_ahead)
1096 {
1097         const char *dev_name;
1098
1099         *read_ahead = 0;
1100
1101 #ifdef DM_COMPAT
1102         /* Not supporting this */
1103         if (_dm_version == 1)
1104                 return 1;
1105 #endif
1106
1107         if (!dmt->dmi.v4 || !(dmt->dmi.v4->flags & DM_EXISTS_FLAG))
1108                 return 0;
1109
1110         if (*dmt->dmi.v4->name)
1111                 dev_name = dmt->dmi.v4->name;
1112         else if (dmt->dev_name)
1113                 dev_name = dmt->dev_name;
1114         else {
1115                 log_error("Get read ahead request failed: device name unrecorded.");
1116                 return 0;
1117         }
1118
1119         return get_dev_node_read_ahead(dev_name, read_ahead);
1120 }
1121
1122 const char *dm_task_get_name(const struct dm_task *dmt)
1123 {
1124 #ifdef DM_COMPAT
1125         if (_dm_version == 1)
1126                 return _dm_task_get_name_v1(dmt);
1127 #endif
1128
1129         return (dmt->dmi.v4->name);
1130 }
1131
1132 const char *dm_task_get_uuid(const struct dm_task *dmt)
1133 {
1134 #ifdef DM_COMPAT
1135         if (_dm_version == 1)
1136                 return _dm_task_get_uuid_v1(dmt);
1137 #endif
1138
1139         return (dmt->dmi.v4->uuid);
1140 }
1141
1142 struct dm_deps *dm_task_get_deps(struct dm_task *dmt)
1143 {
1144 #ifdef DM_COMPAT
1145         if (_dm_version == 1)
1146                 return _dm_task_get_deps_v1(dmt);
1147 #endif
1148
1149         return (struct dm_deps *) (((char *) dmt->dmi.v4) +
1150                                    dmt->dmi.v4->data_start);
1151 }
1152
1153 struct dm_names *dm_task_get_names(struct dm_task *dmt)
1154 {
1155 #ifdef DM_COMPAT
1156         if (_dm_version == 1)
1157                 return _dm_task_get_names_v1(dmt);
1158 #endif
1159
1160         return (struct dm_names *) (((char *) dmt->dmi.v4) +
1161                                     dmt->dmi.v4->data_start);
1162 }
1163
1164 struct dm_versions *dm_task_get_versions(struct dm_task *dmt)
1165 {
1166         return (struct dm_versions *) (((char *) dmt->dmi.v4) +
1167                                        dmt->dmi.v4->data_start);
1168 }
1169
1170 int dm_task_set_ro(struct dm_task *dmt)
1171 {
1172         dmt->read_only = 1;
1173         return 1;
1174 }
1175
1176 int dm_task_set_read_ahead(struct dm_task *dmt, uint32_t read_ahead,
1177                            uint32_t read_ahead_flags)
1178 {
1179         dmt->read_ahead = read_ahead;
1180         dmt->read_ahead_flags = read_ahead_flags;
1181
1182         return 1;
1183 }
1184
1185 int dm_task_suppress_identical_reload(struct dm_task *dmt)
1186 {
1187         dmt->suppress_identical_reload = 1;
1188         return 1;
1189 }
1190
1191 int dm_task_set_newuuid(struct dm_task *dmt, const char *newuuid)
1192 {
1193         if (strlen(newuuid) >= DM_UUID_LEN) {
1194                 log_error("Uuid \"%s\" too long", newuuid);
1195                 return 0;
1196         }
1197
1198         if (!(dmt->newname = dm_strdup(newuuid))) {
1199                 log_error("dm_task_set_newuuid: strdup(%s) failed", newuuid);
1200                 return 0;
1201         }
1202         dmt->new_uuid = 1;
1203
1204         return 1;
1205 }
1206
1207 int dm_task_set_newname(struct dm_task *dmt, const char *newname)
1208 {
1209         if (strchr(newname, '/')) {
1210                 log_error("Name \"%s\" invalid. It contains \"/\".", newname);
1211                 return 0;
1212         }
1213
1214         if (strlen(newname) >= DM_NAME_LEN) {
1215                 log_error("Name \"%s\" too long", newname);
1216                 return 0;
1217         }
1218
1219         if (!(dmt->newname = dm_strdup(newname))) {
1220                 log_error("dm_task_set_newname: strdup(%s) failed", newname);
1221                 return 0;
1222         }
1223         dmt->new_uuid = 0;
1224
1225         return 1;
1226 }
1227
1228 int dm_task_set_message(struct dm_task *dmt, const char *message)
1229 {
1230         if (!(dmt->message = dm_strdup(message))) {
1231                 log_error("dm_task_set_message: strdup failed");
1232                 return 0;
1233         }
1234
1235         return 1;
1236 }
1237
1238 int dm_task_set_sector(struct dm_task *dmt, uint64_t sector)
1239 {
1240         dmt->sector = sector;
1241
1242         return 1;
1243 }
1244
1245 int dm_task_set_geometry(struct dm_task *dmt, const char *cylinders, const char *heads, const char *sectors, const char *start)
1246 {
1247         size_t len = strlen(cylinders) + 1 + strlen(heads) + 1 + strlen(sectors) + 1 + strlen(start) + 1;
1248
1249         if (!(dmt->geometry = dm_malloc(len))) {
1250                 log_error("dm_task_set_geometry: dm_malloc failed");
1251                 return 0;
1252         }
1253
1254         if (sprintf(dmt->geometry, "%s %s %s %s", cylinders, heads, sectors, start) < 0) {
1255                 log_error("dm_task_set_geometry: sprintf failed");
1256                 return 0;
1257         }
1258
1259         return 1;
1260 }
1261
1262 int dm_task_no_flush(struct dm_task *dmt)
1263 {
1264         dmt->no_flush = 1;
1265
1266         return 1;
1267 }
1268
1269 int dm_task_no_open_count(struct dm_task *dmt)
1270 {
1271         dmt->no_open_count = 1;
1272
1273         return 1;
1274 }
1275
1276 int dm_task_skip_lockfs(struct dm_task *dmt)
1277 {
1278         dmt->skip_lockfs = 1;
1279
1280         return 1;
1281 }
1282
1283 int dm_task_query_inactive_table(struct dm_task *dmt)
1284 {
1285         dmt->query_inactive_table = 1;
1286
1287         return 1;
1288 }
1289
1290 int dm_task_set_event_nr(struct dm_task *dmt, uint32_t event_nr)
1291 {
1292         dmt->event_nr = event_nr;
1293
1294         return 1;
1295 }
1296
1297 struct target *create_target(uint64_t start, uint64_t len, const char *type,
1298                              const char *params)
1299 {
1300         struct target *t = dm_malloc(sizeof(*t));
1301
1302         if (!t) {
1303                 log_error("create_target: malloc(%" PRIsize_t ") failed",
1304                           sizeof(*t));
1305                 return NULL;
1306         }
1307
1308         memset(t, 0, sizeof(*t));
1309
1310         if (!(t->params = dm_strdup(params))) {
1311                 log_error("create_target: strdup(params) failed");
1312                 goto bad;
1313         }
1314
1315         if (!(t->type = dm_strdup(type))) {
1316                 log_error("create_target: strdup(type) failed");
1317                 goto bad;
1318         }
1319
1320         t->start = start;
1321         t->length = len;
1322         return t;
1323
1324       bad:
1325         _dm_zfree_string(t->params);
1326         dm_free(t->type);
1327         dm_free(t);
1328         return NULL;
1329 }
1330
1331 static void *_add_target(struct target *t, void *out, void *end)
1332 {
1333         void *out_sp = out;
1334         struct dm_target_spec sp;
1335         size_t sp_size = sizeof(struct dm_target_spec);
1336         int len;
1337
1338         out += sp_size;
1339         if (out >= end)
1340                 return_NULL;
1341
1342         sp.status = 0;
1343         sp.sector_start = t->start;
1344         sp.length = t->length;
1345         strncpy(sp.target_type, t->type, sizeof(sp.target_type));
1346
1347         len = strlen(t->params);
1348
1349         if ((out + len + 1) >= end)
1350                 return_NULL;
1351
1352         strcpy((char *) out, t->params);
1353         out += len + 1;
1354
1355         /* align next block */
1356         out = _align(out, ALIGNMENT);
1357
1358         sp.next = out - out_sp;
1359         memcpy(out_sp, &sp, sp_size);
1360
1361         return out;
1362 }
1363
1364 static int _lookup_dev_name(uint64_t dev, char *buf, size_t len)
1365 {
1366         struct dm_names *names;
1367         unsigned next = 0;
1368         struct dm_task *dmt;
1369         int r = 0;
1370
1371         if (!(dmt = dm_task_create(DM_DEVICE_LIST)))
1372                 return 0;
1373
1374         if (!dm_task_run(dmt))
1375                 goto out;
1376
1377         if (!(names = dm_task_get_names(dmt)))
1378                 goto out;
1379
1380         if (!names->dev)
1381                 goto out;
1382
1383         do {
1384                 names = (void *) names + next;
1385                 if (names->dev == dev) {
1386                         strncpy(buf, names->name, len);
1387                         r = 1;
1388                         break;
1389                 }
1390                 next = names->next;
1391         } while (next);
1392
1393       out:
1394         dm_task_destroy(dmt);
1395         return r;
1396 }
1397
1398 static struct dm_ioctl *_flatten(struct dm_task *dmt, unsigned repeat_count)
1399 {
1400         const size_t min_size = 16 * 1024;
1401         const int (*version)[3];
1402
1403         struct dm_ioctl *dmi;
1404         struct target *t;
1405         struct dm_target_msg *tmsg;
1406         size_t len = sizeof(struct dm_ioctl);
1407         void *b, *e;
1408         int count = 0;
1409
1410         for (t = dmt->head; t; t = t->next) {
1411                 len += sizeof(struct dm_target_spec);
1412                 len += strlen(t->params) + 1 + ALIGNMENT;
1413                 count++;
1414         }
1415
1416         if (count && (dmt->sector || dmt->message)) {
1417                 log_error("targets and message are incompatible");
1418                 return NULL;
1419         }
1420
1421         if (count && dmt->newname) {
1422                 log_error("targets and rename are incompatible");
1423                 return NULL;
1424         }
1425
1426         if (count && dmt->geometry) {
1427                 log_error("targets and geometry are incompatible");
1428                 return NULL;
1429         }
1430
1431         if (dmt->newname && (dmt->sector || dmt->message)) {
1432                 log_error("message and rename are incompatible");
1433                 return NULL;
1434         }
1435
1436         if (dmt->newname && dmt->geometry) {
1437                 log_error("geometry and rename are incompatible");
1438                 return NULL;
1439         }
1440
1441         if (dmt->geometry && (dmt->sector || dmt->message)) {
1442                 log_error("geometry and message are incompatible");
1443                 return NULL;
1444         }
1445
1446         if (dmt->sector && !dmt->message) {
1447                 log_error("message is required with sector");
1448                 return NULL;
1449         }
1450
1451         if (dmt->newname)
1452                 len += strlen(dmt->newname) + 1;
1453
1454         if (dmt->message)
1455                 len += sizeof(struct dm_target_msg) + strlen(dmt->message) + 1;
1456
1457         if (dmt->geometry)
1458                 len += strlen(dmt->geometry) + 1;
1459
1460         /*
1461          * Give len a minimum size so that we have space to store
1462          * dependencies or status information.
1463          */
1464         if (len < min_size)
1465                 len = min_size;
1466
1467         /* Increase buffer size if repeating because buffer was too small */
1468         while (repeat_count--)
1469                 len *= 2;
1470
1471         if (!(dmi = dm_malloc(len)))
1472                 return NULL;
1473
1474         memset(dmi, 0, len);
1475
1476         version = &_cmd_data_v4[dmt->type].version;
1477
1478         dmi->version[0] = (*version)[0];
1479         dmi->version[1] = (*version)[1];
1480         dmi->version[2] = (*version)[2];
1481
1482         dmi->data_size = len;
1483         dmi->data_start = sizeof(struct dm_ioctl);
1484
1485         if (dmt->minor >= 0) {
1486                 if (dmt->major <= 0) {
1487                         log_error("Missing major number for persistent device.");
1488                         goto bad;
1489                 }
1490
1491                 if (!_dm_multiple_major_support && dmt->allow_default_major_fallback &&
1492                     dmt->major != _dm_device_major) {
1493                         log_verbose("Overriding major number of %" PRIu32
1494                                     " with %" PRIu32 " for persistent device.",
1495                                     dmt->major, _dm_device_major);
1496                         dmt->major = _dm_device_major;
1497                 }
1498
1499                 dmi->flags |= DM_PERSISTENT_DEV_FLAG;
1500                 dmi->dev = MKDEV(dmt->major, dmt->minor);
1501         }
1502
1503         /* Does driver support device number referencing? */
1504         if (_dm_version_minor < 3 && !dmt->dev_name && !dmt->uuid && dmi->dev) {
1505                 if (!_lookup_dev_name(dmi->dev, dmi->name, sizeof(dmi->name))) {
1506                         log_error("Unable to find name for device (%" PRIu32
1507                                   ":%" PRIu32 ")", dmt->major, dmt->minor);
1508                         goto bad;
1509                 }
1510                 log_verbose("device (%" PRIu32 ":%" PRIu32 ") is %s "
1511                             "for compatibility with old kernel",
1512                             dmt->major, dmt->minor, dmi->name);
1513         }
1514
1515         /* FIXME Until resume ioctl supplies name, use dev_name for readahead */
1516         if (dmt->dev_name && (dmt->type != DM_DEVICE_RESUME || dmt->minor < 0 ||
1517                               dmt->major < 0))
1518                 strncpy(dmi->name, dmt->dev_name, sizeof(dmi->name));
1519
1520         if (dmt->uuid)
1521                 strncpy(dmi->uuid, dmt->uuid, sizeof(dmi->uuid));
1522
1523         if (dmt->type == DM_DEVICE_SUSPEND)
1524                 dmi->flags |= DM_SUSPEND_FLAG;
1525         if (dmt->no_flush)
1526                 dmi->flags |= DM_NOFLUSH_FLAG;
1527         if (dmt->read_only)
1528                 dmi->flags |= DM_READONLY_FLAG;
1529         if (dmt->skip_lockfs)
1530                 dmi->flags |= DM_SKIP_LOCKFS_FLAG;
1531         if (dmt->query_inactive_table) {
1532                 if (_dm_version_minor < 16)
1533                         log_warn("WARNING: Inactive table query unsupported "
1534                                  "by kernel.  It will use live table.");
1535                 dmi->flags |= DM_QUERY_INACTIVE_TABLE_FLAG;
1536         }
1537         if (dmt->new_uuid) {
1538                 if (_dm_version_minor < 19) {
1539                         log_error("WARNING: Setting UUID unsupported by "
1540                                   "kernel.  Aborting operation.");
1541                         goto bad;
1542                 }
1543                 dmi->flags |= DM_UUID_FLAG;
1544         }
1545
1546         dmi->target_count = count;
1547         dmi->event_nr = dmt->event_nr;
1548
1549         b = (void *) (dmi + 1);
1550         e = (void *) ((char *) dmi + len);
1551
1552         for (t = dmt->head; t; t = t->next)
1553                 if (!(b = _add_target(t, b, e))) {
1554                         log_error("Ran out of memory building ioctl parameter");
1555                         goto bad;
1556                 }
1557
1558         if (dmt->newname)
1559                 strcpy(b, dmt->newname);
1560
1561         if (dmt->message) {
1562                 tmsg = (struct dm_target_msg *) b;
1563                 tmsg->sector = dmt->sector;
1564                 strcpy(tmsg->message, dmt->message);
1565         }
1566
1567         if (dmt->geometry)
1568                 strcpy(b, dmt->geometry);
1569
1570         return dmi;
1571
1572       bad:
1573         _dm_zfree_dmi(dmi);
1574         return NULL;
1575 }
1576
1577 static int _process_mapper_dir(struct dm_task *dmt)
1578 {
1579         struct dirent *dirent;
1580         DIR *d;
1581         const char *dir;
1582         int r = 1;
1583
1584         dir = dm_dir();
1585         if (!(d = opendir(dir))) {
1586                 log_sys_error("opendir", dir);
1587                 return 0;
1588         }
1589
1590         while ((dirent = readdir(d))) {
1591                 if (!strcmp(dirent->d_name, ".") ||
1592                     !strcmp(dirent->d_name, "..") ||
1593                     !strcmp(dirent->d_name, "control"))
1594                         continue;
1595                 if (!dm_task_set_name(dmt, dirent->d_name)) {
1596                         r = 0;
1597                         stack;
1598                         continue; /* try next name */
1599                 }
1600                 if (!dm_task_run(dmt)) {
1601                         r = 0;
1602                         stack;  /* keep going */
1603                 }
1604         }
1605
1606         if (closedir(d))
1607                 log_sys_error("closedir", dir);
1608
1609         return r;
1610 }
1611
1612 static int _process_all_v4(struct dm_task *dmt)
1613 {
1614         struct dm_task *task;
1615         struct dm_names *names;
1616         unsigned next = 0;
1617         int r = 1;
1618
1619         if (!(task = dm_task_create(DM_DEVICE_LIST)))
1620                 return 0;
1621
1622         if (!dm_task_run(task)) {
1623                 r = 0;
1624                 goto out;
1625         }
1626
1627         if (!(names = dm_task_get_names(task))) {
1628                 r = 0;
1629                 goto out;
1630         }
1631
1632         if (!names->dev)
1633                 goto out;
1634
1635         do {
1636                 names = (void *) names + next;
1637                 if (!dm_task_set_name(dmt, names->name)) {
1638                         r = 0;
1639                         goto out;
1640                 }
1641                 if (!dm_task_run(dmt))
1642                         r = 0;
1643                 next = names->next;
1644         } while (next);
1645
1646       out:
1647         dm_task_destroy(task);
1648         return r;
1649 }
1650
1651 static int _mknodes_v4(struct dm_task *dmt)
1652 {
1653         (void) _process_mapper_dir(dmt);
1654
1655         return _process_all_v4(dmt);
1656 }
1657
1658 /*
1659  * If an operation that uses a cookie fails, decrement the
1660  * semaphore instead of udev.
1661  */
1662 static int _udev_complete(struct dm_task *dmt)
1663 {
1664         uint16_t base;
1665
1666         if (dmt->cookie_set &&
1667             (base = dmt->event_nr & ~DM_UDEV_FLAGS_MASK))
1668                 /* strip flags from the cookie and use cookie magic instead */
1669                 return dm_udev_complete(base | (DM_COOKIE_MAGIC <<
1670                                                 DM_UDEV_FLAGS_SHIFT));
1671
1672         return 1;
1673 }
1674
1675 static int _check_uevent_generated(struct dm_ioctl *dmi)
1676 {
1677         if (!dm_check_version() ||
1678             _dm_version < 4 ||
1679             _dm_version_minor < 17)
1680                 /* can't check, assume uevent is generated */
1681                 return 1;
1682
1683         return dmi->flags & DM_UEVENT_GENERATED_FLAG;
1684 }
1685
1686 static int _create_and_load_v4(struct dm_task *dmt)
1687 {
1688         struct dm_task *task;
1689         int r;
1690         uint32_t cookie;
1691
1692         /* Use new task struct to create the device */
1693         if (!(task = dm_task_create(DM_DEVICE_CREATE))) {
1694                 log_error("Failed to create device-mapper task struct");
1695                 _udev_complete(dmt);
1696                 return 0;
1697         }
1698
1699         /* Copy across relevant fields */
1700         if (dmt->dev_name && !dm_task_set_name(task, dmt->dev_name)) {
1701                 dm_task_destroy(task);
1702                 _udev_complete(dmt);
1703                 return 0;
1704         }
1705
1706         if (dmt->uuid && !dm_task_set_uuid(task, dmt->uuid)) {
1707                 dm_task_destroy(task);
1708                 _udev_complete(dmt);
1709                 return 0;
1710         }
1711
1712         task->major = dmt->major;
1713         task->minor = dmt->minor;
1714         task->uid = dmt->uid;
1715         task->gid = dmt->gid;
1716         task->mode = dmt->mode;
1717         /* FIXME: Just for udev_check in dm_task_run. Can we avoid this? */
1718         task->event_nr = dmt->event_nr & DM_UDEV_FLAGS_MASK;
1719         task->cookie_set = dmt->cookie_set;
1720
1721         r = dm_task_run(task);
1722         dm_task_destroy(task);
1723         if (!r) {
1724                 _udev_complete(dmt);
1725                 return 0;
1726         }
1727
1728         /* Next load the table */
1729         if (!(task = dm_task_create(DM_DEVICE_RELOAD))) {
1730                 log_error("Failed to create device-mapper task struct");
1731                 _udev_complete(dmt);
1732                 r = 0;
1733                 goto revert;
1734         }
1735
1736         /* Copy across relevant fields */
1737         if (dmt->dev_name && !dm_task_set_name(task, dmt->dev_name)) {
1738                 dm_task_destroy(task);
1739                 _udev_complete(dmt);
1740                 r = 0;
1741                 goto revert;
1742         }
1743
1744         task->read_only = dmt->read_only;
1745         task->head = dmt->head;
1746         task->tail = dmt->tail;
1747
1748         r = dm_task_run(task);
1749
1750         task->head = NULL;
1751         task->tail = NULL;
1752         dm_task_destroy(task);
1753         if (!r) {
1754                 _udev_complete(dmt);
1755                 goto revert;
1756         }
1757
1758         /* Use the original structure last so the info will be correct */
1759         dmt->type = DM_DEVICE_RESUME;
1760         dm_free(dmt->uuid);
1761         dmt->uuid = NULL;
1762
1763         r = dm_task_run(dmt);
1764
1765         if (r)
1766                 return r;
1767
1768       revert:
1769         dmt->type = DM_DEVICE_REMOVE;
1770         dm_free(dmt->uuid);
1771         dmt->uuid = NULL;
1772
1773         /*
1774          * Also udev-synchronize "remove" dm task that is a part of this revert!
1775          * But only if the original dm task was supposed to be synchronized.
1776          */
1777         if (dmt->cookie_set) {
1778                 cookie = (dmt->event_nr & ~DM_UDEV_FLAGS_MASK) |
1779                          (DM_COOKIE_MAGIC << DM_UDEV_FLAGS_SHIFT);
1780                 if (!dm_task_set_cookie(dmt, &cookie,
1781                                         (dmt->event_nr & DM_UDEV_FLAGS_MASK) >>
1782                                         DM_UDEV_FLAGS_SHIFT))
1783                         stack; /* keep going */
1784         }
1785
1786         if (!dm_task_run(dmt))
1787                 log_error("Failed to revert device creation.");
1788
1789         return r;
1790 }
1791
1792 uint64_t dm_task_get_existing_table_size(struct dm_task *dmt)
1793 {
1794         return dmt->existing_table_size;
1795 }
1796
1797 static int _reload_with_suppression_v4(struct dm_task *dmt)
1798 {
1799         struct dm_task *task;
1800         struct target *t1, *t2;
1801         int r;
1802
1803         /* New task to get existing table information */
1804         if (!(task = dm_task_create(DM_DEVICE_TABLE))) {
1805                 log_error("Failed to create device-mapper task struct");
1806                 return 0;
1807         }
1808
1809         /* Copy across relevant fields */
1810         if (dmt->dev_name && !dm_task_set_name(task, dmt->dev_name)) {
1811                 dm_task_destroy(task);
1812                 return 0;
1813         }
1814
1815         if (dmt->uuid && !dm_task_set_uuid(task, dmt->uuid)) {
1816                 dm_task_destroy(task);
1817                 return 0;
1818         }
1819
1820         task->major = dmt->major;
1821         task->minor = dmt->minor;
1822
1823         r = dm_task_run(task);
1824
1825         if (!r) {
1826                 dm_task_destroy(task);
1827                 return r;
1828         }
1829
1830         /* Store existing table size */
1831         t2 = task->head;
1832         while (t2 && t2->next)
1833                 t2 = t2->next;
1834         dmt->existing_table_size = t2 ? t2->start + t2->length : 0;
1835
1836         if ((task->dmi.v4->flags & DM_READONLY_FLAG) ? 1 : 0 != dmt->read_only)
1837                 goto no_match;
1838
1839         t1 = dmt->head;
1840         t2 = task->head;
1841
1842         while (t1 && t2) {
1843                 while (t2->params[strlen(t2->params) - 1] == ' ')
1844                         t2->params[strlen(t2->params) - 1] = '\0';
1845                 if ((t1->start != t2->start) ||
1846                     (t1->length != t2->length) ||
1847                     (strcmp(t1->type, t2->type)) ||
1848                     (strcmp(t1->params, t2->params)))
1849                         goto no_match;
1850                 t1 = t1->next;
1851                 t2 = t2->next;
1852         }
1853
1854         if (!t1 && !t2) {
1855                 dmt->dmi.v4 = task->dmi.v4;
1856                 task->dmi.v4 = NULL;
1857                 dm_task_destroy(task);
1858                 return 1;
1859         }
1860
1861 no_match:
1862         dm_task_destroy(task);
1863
1864         /* Now do the original reload */
1865         dmt->suppress_identical_reload = 0;
1866         r = dm_task_run(dmt);
1867
1868         return r;
1869 }
1870
1871 static const char *_sanitise_message(char *message)
1872 {
1873         const char *sanitised_message = message ?: "";
1874
1875         /* FIXME: Check for whitespace variations. */
1876         /* This traps what cryptsetup sends us. */
1877         if (message && !strncasecmp(message, "key set", 7))
1878                 sanitised_message = "key set";
1879
1880         return sanitised_message;
1881 }
1882
1883 static struct dm_ioctl *_do_dm_ioctl(struct dm_task *dmt, unsigned command,
1884                                      unsigned repeat_count)
1885 {
1886         struct dm_ioctl *dmi;
1887         int ioctl_with_uevent;
1888
1889         dmi = _flatten(dmt, repeat_count);
1890         if (!dmi) {
1891                 log_error("Couldn't create ioctl argument.");
1892                 return NULL;
1893         }
1894
1895         if (dmt->type == DM_DEVICE_TABLE)
1896                 dmi->flags |= DM_STATUS_TABLE_FLAG;
1897
1898         dmi->flags |= DM_EXISTS_FLAG;   /* FIXME */
1899
1900         if (dmt->no_open_count)
1901                 dmi->flags |= DM_SKIP_BDGET_FLAG;
1902
1903         ioctl_with_uevent = dmt->type == DM_DEVICE_RESUME ||
1904                             dmt->type == DM_DEVICE_REMOVE ||
1905                             dmt->type == DM_DEVICE_RENAME;
1906
1907         if (ioctl_with_uevent && dm_cookie_supported()) {
1908                 /*
1909                  * Always mark events coming from libdevmapper as
1910                  * "primary sourced". This is needed to distinguish
1911                  * any spurious events so we can act appropriately.
1912                  * This needs to be applied even when udev_sync is
1913                  * not used because udev flags could be used alone.
1914                  */
1915                 dmi->event_nr |= DM_UDEV_PRIMARY_SOURCE_FLAG <<
1916                                  DM_UDEV_FLAGS_SHIFT;
1917
1918                 /*
1919                  * Prevent udev vs. libdevmapper race when processing nodes
1920                  * and symlinks. This can happen when the udev rules are
1921                  * installed and udev synchronisation code is enabled in
1922                  * libdevmapper but the software using libdevmapper does not
1923                  * make use of it (by not calling dm_task_set_cookie before).
1924                  * We need to instruct the udev rules not to be applied at
1925                  * all in this situation so we can gracefully fallback to
1926                  * libdevmapper's node and symlink creation code.
1927                  */
1928                 if (!dmt->cookie_set && dm_udev_get_sync_support()) {
1929                         log_debug("Cookie value is not set while trying to call %s "
1930                                   "ioctl. Please, consider using libdevmapper's udev "
1931                                   "synchronisation interface or disable it explicitly "
1932                                   "by calling dm_udev_set_sync_support(0).",
1933                                   dmt->type == DM_DEVICE_RESUME ? "DM_DEVICE_RESUME" :
1934                                   dmt->type == DM_DEVICE_REMOVE ? "DM_DEVICE_REMOVE" :
1935                                                                   "DM_DEVICE_RENAME");
1936                         log_debug("Switching off device-mapper and all subsystem related "
1937                                   "udev rules. Falling back to libdevmapper node creation.");
1938                         /*
1939                          * Disable general dm and subsystem rules but keep
1940                          * dm disk rules if not flagged out explicitly before.
1941                          * We need /dev/disk content for the software that expects it.
1942                         */
1943                         dmi->event_nr |= (DM_UDEV_DISABLE_DM_RULES_FLAG |
1944                                           DM_UDEV_DISABLE_SUBSYSTEM_RULES_FLAG) <<
1945                                          DM_UDEV_FLAGS_SHIFT;
1946                 }
1947         }
1948
1949         log_debug("dm %s %s%s %s%s%s %s%.0d%s%.0d%s"
1950                   "%s%c%c%s%s %.0" PRIu64 " %s [%u]",
1951                   _cmd_data_v4[dmt->type].name,
1952                   dmt->new_uuid ? "UUID " : "",
1953                   dmi->name, dmi->uuid, dmt->newname ? " " : "",
1954                   dmt->newname ? dmt->newname : "",
1955                   dmt->major > 0 ? "(" : "",
1956                   dmt->major > 0 ? dmt->major : 0,
1957                   dmt->major > 0 ? ":" : "",
1958                   dmt->minor > 0 ? dmt->minor : 0,
1959                   dmt->major > 0 && dmt->minor == 0 ? "0" : "",
1960                   dmt->major > 0 ? ") " : "",
1961                   dmt->no_open_count ? 'N' : 'O',
1962                   dmt->no_flush ? 'N' : 'F',
1963                   dmt->skip_lockfs ? "S " : "",
1964                   dmt->query_inactive_table ? "I " : "",
1965                   dmt->sector, _sanitise_message(dmt->message),
1966                   dmi->data_size);
1967 #ifdef DM_IOCTLS
1968         if (ioctl(_control_fd, command, dmi) < 0) {
1969                 if (errno == ENXIO && ((dmt->type == DM_DEVICE_INFO) ||
1970                                        (dmt->type == DM_DEVICE_MKNODES) ||
1971                                        (dmt->type == DM_DEVICE_STATUS)))
1972                         dmi->flags &= ~DM_EXISTS_FLAG;  /* FIXME */
1973                 else {
1974                         if (_log_suppress)
1975                                 log_verbose("device-mapper: %s ioctl "
1976                                             "failed: %s",
1977                                             _cmd_data_v4[dmt->type].name,
1978                                             strerror(errno));
1979                         else
1980                                 log_error("device-mapper: %s ioctl "
1981                                           "failed: %s",
1982                                            _cmd_data_v4[dmt->type].name,
1983                                           strerror(errno));
1984                         _dm_zfree_dmi(dmi);
1985                         return NULL;
1986                 }
1987         }
1988
1989         if (ioctl_with_uevent && !_check_uevent_generated(dmi))
1990                 _udev_complete(dmt);
1991
1992 #else /* Userspace alternative for testing */
1993 #endif
1994         return dmi;
1995 }
1996
1997 void dm_task_update_nodes(void)
1998 {
1999         update_devs();
2000 }
2001
2002 int dm_task_run(struct dm_task *dmt)
2003 {
2004         struct dm_ioctl *dmi;
2005         unsigned command;
2006         int check_udev;
2007         int udev_only;
2008
2009 #ifdef DM_COMPAT
2010         if (_dm_version == 1)
2011                 return _dm_task_run_v1(dmt);
2012 #endif
2013
2014         if ((unsigned) dmt->type >=
2015             (sizeof(_cmd_data_v4) / sizeof(*_cmd_data_v4))) {
2016                 log_error(INTERNAL_ERROR "unknown device-mapper task %d",
2017                           dmt->type);
2018                 return 0;
2019         }
2020
2021         command = _cmd_data_v4[dmt->type].cmd;
2022
2023         /* Old-style creation had a table supplied */
2024         if (dmt->type == DM_DEVICE_CREATE && dmt->head)
2025                 return _create_and_load_v4(dmt);
2026
2027         if (dmt->type == DM_DEVICE_MKNODES && !dmt->dev_name &&
2028             !dmt->uuid && dmt->major <= 0)
2029                 return _mknodes_v4(dmt);
2030
2031         if ((dmt->type == DM_DEVICE_RELOAD) && dmt->suppress_identical_reload)
2032                 return _reload_with_suppression_v4(dmt);
2033
2034         if (!_open_control()) {
2035                 _udev_complete(dmt);
2036                 return 0;
2037         }
2038
2039         /* FIXME Detect and warn if cookie set but should not be. */
2040 repeat_ioctl:
2041         if (!(dmi = _do_dm_ioctl(dmt, command, _ioctl_buffer_double_factor))) {
2042                 _udev_complete(dmt);
2043                 return 0;
2044         }
2045
2046         if (dmi->flags & DM_BUFFER_FULL_FLAG) {
2047                 switch (dmt->type) {
2048                 case DM_DEVICE_LIST_VERSIONS:
2049                 case DM_DEVICE_LIST:
2050                 case DM_DEVICE_DEPS:
2051                 case DM_DEVICE_STATUS:
2052                 case DM_DEVICE_TABLE:
2053                 case DM_DEVICE_WAITEVENT:
2054                         _ioctl_buffer_double_factor++;
2055                         _dm_zfree_dmi(dmi);
2056                         goto repeat_ioctl;
2057                 default:
2058                         log_error("WARNING: libdevmapper buffer too small for data");
2059                 }
2060         }
2061
2062         check_udev = dmt->cookie_set &&
2063                      !(dmt->event_nr >> DM_UDEV_FLAGS_SHIFT &
2064                        DM_UDEV_DISABLE_DM_RULES_FLAG);
2065
2066         udev_only = dmt->cookie_set ? (dmt->event_nr >> DM_UDEV_FLAGS_SHIFT &
2067                                         DM_UDEV_DISABLE_LIBRARY_FALLBACK) : 0;
2068
2069         switch (dmt->type) {
2070         case DM_DEVICE_CREATE:
2071                 if (dmt->dev_name && *dmt->dev_name && !udev_only)
2072                         add_dev_node(dmt->dev_name, MAJOR(dmi->dev),
2073                                      MINOR(dmi->dev), dmt->uid, dmt->gid,
2074                                      dmt->mode, check_udev);
2075                 break;
2076         case DM_DEVICE_REMOVE:
2077                 /* FIXME Kernel needs to fill in dmi->name */
2078                 if (dmt->dev_name && !udev_only)
2079                         rm_dev_node(dmt->dev_name, check_udev);
2080                 break;
2081
2082         case DM_DEVICE_RENAME:
2083                 /* FIXME Kernel needs to fill in dmi->name */
2084                 if (!dmt->new_uuid && dmt->dev_name && !udev_only)
2085                         rename_dev_node(dmt->dev_name, dmt->newname,
2086                                         check_udev);
2087                 break;
2088
2089         case DM_DEVICE_RESUME:
2090                 /* FIXME Kernel needs to fill in dmi->name */
2091                 set_dev_node_read_ahead(dmt->dev_name, dmt->read_ahead,
2092                                         dmt->read_ahead_flags);
2093                 break;
2094
2095         case DM_DEVICE_MKNODES:
2096                 if (dmi->flags & DM_EXISTS_FLAG)
2097                         add_dev_node(dmi->name, MAJOR(dmi->dev),
2098                                      MINOR(dmi->dev), dmt->uid,
2099                                      dmt->gid, dmt->mode, 0);
2100                 else if (dmt->dev_name)
2101                         rm_dev_node(dmt->dev_name, 0);
2102                 break;
2103
2104         case DM_DEVICE_STATUS:
2105         case DM_DEVICE_TABLE:
2106         case DM_DEVICE_WAITEVENT:
2107                 if (!_unmarshal_status(dmt, dmi))
2108                         goto bad;
2109                 break;
2110         }
2111
2112         /* Was structure reused? */
2113         _dm_zfree_dmi(dmt->dmi.v4);
2114         dmt->dmi.v4 = dmi;
2115         return 1;
2116
2117       bad:
2118         _dm_zfree_dmi(dmi);
2119         return 0;
2120 }
2121
2122 void dm_lib_release(void)
2123 {
2124         _close_control_fd();
2125         update_devs();
2126 }
2127
2128 void dm_pools_check_leaks(void);
2129
2130 void dm_lib_exit(void)
2131 {
2132         dm_lib_release();
2133         selinux_release();
2134         if (_dm_bitset)
2135                 dm_bitset_destroy(_dm_bitset);
2136         _dm_bitset = NULL;
2137         dm_pools_check_leaks();
2138         dm_dump_memory();
2139         _version_ok = 1;
2140         _version_checked = 0;
2141 }