contrib/lvm2/dist/libdm/libdm-common.c

   1 /*      $NetBSD: libdm-common.c,v 1.5 2009/12/05 11:42:24 haad Exp $    */
   2
   3 /*
   4  * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
   5  * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
   6  *
   7  * This file is part of the device-mapper userspace tools.
   8  *
   9  * This copyrighted material is made available to anyone wishing to use,
  10  * modify, copy, or redistribute it subject to the terms and conditions
  11  * of the GNU Lesser General Public License v.2.1.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public License
  14  * along with this program; if not, write to the Free Software Foundation,
  15  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  16  */
  17
  18 #include "dmlib.h"
  19 #include "libdm-targets.h"
  20 #include "libdm-common.h"
  21 #ifdef linux
  22 #include "kdev_t.h"
  23 #endif
  24 #include "dm-ioctl.h"
  25
  26 #include <stdarg.h>
  27 #include <sys/param.h>
  28 #include <sys/ioctl.h>
  29 #include <fcntl.h>
  30 #include <dirent.h>
  31
  32 #ifdef UDEV_SYNC_SUPPORT
  33 #  include <sys/types.h>
  34 #  include <sys/ipc.h>
  35 #  include <sys/sem.h>
  36 #ifdef HAVE_UDEV_QUEUE_GET_UDEV_IS_ACTIVE
  37 #  define LIBUDEV_I_KNOW_THE_API_IS_SUBJECT_TO_CHANGE
  38 #  include <libudev.h>
  39 #endif
  40 #endif
  41
  42 #ifdef linux
  43 #  include <linux/fs.h>
  44 #endif
  45
  46 #ifdef HAVE_SELINUX
  47 #  include <selinux/selinux.h>
  48 #endif
  49
  50 #if defined(__NetBSD__) || defined(__DragonFly__)
  51 #include "libdm-netbsd.h"
  52 #endif
  53
  54 #define DEV_DIR "/dev/"
  55
  56 static char _dm_dir[PATH_MAX] = DEV_DIR DM_DIR;
  57
  58 static int _verbose = 0;
  59
  60 #ifdef UDEV_SYNC_SUPPORT
  61 static int _udev_running = -1;
  62 static int _sync_with_udev = 1;
  63 #endif
  64
  65 /*
  66  * Library users can provide their own logging
  67  * function.
  68  */
  69
  70 static void _default_log_line(int level,
  71             const char *file __attribute((unused)),
  72             int line __attribute((unused)), int dm_errno,
  73             const char *f, va_list ap)
  74 {
  75         int use_stderr = level & _LOG_STDERR;
  76
  77         level &= ~_LOG_STDERR;
  78
  79         if (level > _LOG_WARN && !_verbose)
  80                 return;
  81
  82         if (level < _LOG_WARN)
  83                 vfprintf(stderr, f, ap);
  84         else
  85                 vfprintf(use_stderr ? stderr : stdout, f, ap);
  86
  87         if (level < _LOG_WARN)
  88                 fprintf(stderr, "\n");
  89         else
  90                 fprintf(use_stderr ? stderr : stdout, "\n");
  91 }
  92
  93 static void _default_log_with_errno(int level,
  94             const char *file __attribute((unused)),
  95             int line __attribute((unused)), int dm_errno,
  96             const char *f, ...)
  97 {
  98         va_list ap;
  99
 100         va_start(ap, f);
 101         _default_log_line(level, file, line, dm_errno, f, ap);
 102         va_end(ap);
 103 }
 104
 105 static void _default_log(int level, const char *file,
 106                          int line, const char *f, ...)
 107 {
 108         va_list ap;
 109
 110         va_start(ap, f);
 111         _default_log_line(level, file, line, 0, f, ap);
 112         va_end(ap);
 113 }
 114
 115 dm_log_fn dm_log = _default_log;
 116 dm_log_with_errno_fn dm_log_with_errno = _default_log_with_errno;
 117
 118 void dm_log_init(dm_log_fn fn)
 119 {
 120         if (fn)
 121                 dm_log = fn;
 122         else
 123                 dm_log = _default_log;
 124
 125         dm_log_with_errno = _default_log_with_errno;
 126 }
 127
 128 int dm_log_is_non_default(void)
 129 {
 130         return (dm_log == _default_log) ? 0 : 1;
 131 }
 132
 133 void dm_log_with_errno_init(dm_log_with_errno_fn fn)
 134 {
 135         if (fn)
 136                 dm_log_with_errno = fn;
 137         else
 138                 dm_log_with_errno = _default_log_with_errno;
 139
 140         dm_log = _default_log;
 141 }
 142
 143 void dm_log_init_verbose(int level)
 144 {
 145         _verbose = level;
 146 }
 147
 148 static void _build_dev_path(char *buffer, size_t len, const char *dev_name)
 149 {
 150         /* If there's a /, assume caller knows what they're doing */
 151         if (strchr(dev_name, '/'))
 152                 snprintf(buffer, len, "%s", dev_name);
 153         else
 154                 snprintf(buffer, len, "%s/%s", _dm_dir, dev_name);
 155 }
 156
 157 int dm_get_library_version(char *version, size_t size)
 158 {
 159         strncpy(version, DM_LIB_VERSION, size);
 160         return 1;
 161 }
 162
 163 struct dm_task *dm_task_create(int type)
 164 {
 165         struct dm_task *dmt = dm_malloc(sizeof(*dmt));
 166
 167         if (!dmt) {
 168                 log_error("dm_task_create: malloc(%" PRIsize_t ") failed",
 169                           sizeof(*dmt));
 170                 return NULL;
 171         }
 172
 173         if (!dm_check_version()) {
 174                 dm_free(dmt);
 175                 return NULL;
 176         }
 177
 178         memset(dmt, 0, sizeof(*dmt));
 179
 180         dmt->type = type;
 181         dmt->minor = -1;
 182         dmt->major = -1;
 183         dmt->allow_default_major_fallback = 1;
 184         dmt->uid = DM_DEVICE_UID;
 185         dmt->gid = DM_DEVICE_GID;
 186         dmt->mode = DM_DEVICE_MODE;
 187         dmt->no_open_count = 0;
 188         dmt->read_ahead = DM_READ_AHEAD_AUTO;
 189         dmt->read_ahead_flags = 0;
 190         dmt->event_nr = 0;
 191         dmt->cookie_set = 0;
 192         dmt->query_inactive_table = 0;
 193
 194         return dmt;
 195 }
 196
 197 /*
 198  * Find the name associated with a given device number by scanning _dm_dir.
 199  */
 200 static char *_find_dm_name_of_device(dev_t st_rdev)
 201 {
 202         const char *name;
 203         char path[PATH_MAX];
 204         struct dirent *dirent;
 205         DIR *d;
 206         struct stat buf;
 207         char *new_name = NULL;
 208
 209         if (!(d = opendir(_dm_dir))) {
 210                 log_sys_error("opendir", _dm_dir);
 211                 return NULL;
 212         }
 213
 214         while ((dirent = readdir(d))) {
 215                 name = dirent->d_name;
 216
 217                 if (!strcmp(name, ".") || !strcmp(name, ".."))
 218                         continue;
 219
 220                 if (dm_snprintf(path, sizeof(path), "%s/%s", _dm_dir,
 221                                 name) == -1) {
 222                         log_error("Couldn't create path for %s", name);
 223                         continue;
 224                 }
 225
 226                 if (stat(path, &buf))
 227                         continue;
 228
 229                 if (buf.st_rdev == st_rdev) {
 230                         if (!(new_name = dm_strdup(name)))
 231                                 log_error("dm_task_set_name: strdup(%s) failed",
 232                                           name);
 233                         break;
 234                 }
 235         }
 236
 237         if (closedir(d))
 238                 log_sys_error("closedir", _dm_dir);
 239
 240         return new_name;
 241 }
 242
 243 int dm_task_set_name(struct dm_task *dmt, const char *name)
 244 {
 245         char *pos;
 246         char *new_name = NULL;
 247         char path[PATH_MAX];
 248         struct stat st1, st2;
 249
 250         if (dmt->dev_name) {
 251                 dm_free(dmt->dev_name);
 252                 dmt->dev_name = NULL;
 253         }
 254
 255         /*
 256          * Path supplied for existing device?
 257          */
 258         if ((pos = strrchr(name, '/'))) {
 259                 if (dmt->type == DM_DEVICE_CREATE) {
 260                         log_error("Name \"%s\" invalid. It contains \"/\".", name);
 261                         return 0;
 262                 }
 263
 264                 if (stat(name, &st1)) {
 265                         log_error("Device %s not found", name);
 266                         return 0;
 267                 }
 268
 269                 /*
 270                  * If supplied path points to same device as last component
 271                  * under /dev/mapper, use that name directly.  Otherwise call
 272                  * _find_dm_name_of_device() to scan _dm_dir for a match.
 273                  */
 274                 if (dm_snprintf(path, sizeof(path), "%s/%s", _dm_dir,
 275                                 pos + 1) == -1) {
 276                         log_error("Couldn't create path for %s", pos + 1);
 277                         return 0;
 278                 }
 279
 280                 if (!stat(path, &st2) && (st1.st_rdev == st2.st_rdev))
 281                         name = pos + 1;
 282                 else if ((new_name = _find_dm_name_of_device(st1.st_rdev)))
 283                         name = new_name;
 284                 else {
 285                         log_error("Device %s not found", name);
 286                         return 0;
 287                 }
 288         }
 289
 290         if (strlen(name) >= DM_NAME_LEN) {
 291                 log_error("Name \"%s\" too long", name);
 292                 if (new_name)
 293                         dm_free(new_name);
 294                 return 0;
 295         }
 296
 297         if (new_name)
 298                 dmt->dev_name = new_name;
 299         else if (!(dmt->dev_name = dm_strdup(name))) {
 300                 log_error("dm_task_set_name: strdup(%s) failed", name);
 301                 return 0;
 302         }
 303
 304         return 1;
 305 }
 306
 307 int dm_task_set_uuid(struct dm_task *dmt, const char *uuid)
 308 {
 309         if (dmt->uuid) {
 310                 dm_free(dmt->uuid);
 311                 dmt->uuid = NULL;
 312         }
 313
 314         if (!(dmt->uuid = dm_strdup(uuid))) {
 315                 log_error("dm_task_set_uuid: strdup(%s) failed", uuid);
 316                 return 0;
 317         }
 318
 319         return 1;
 320 }
 321
 322 int dm_task_set_major(struct dm_task *dmt, int major)
 323 {
 324         dmt->major = major;
 325         dmt->allow_default_major_fallback = 0;
 326
 327         return 1;
 328 }
 329
 330 int dm_task_set_minor(struct dm_task *dmt, int minor)
 331 {
 332         dmt->minor = minor;
 333
 334         return 1;
 335 }
 336
 337 int dm_task_set_major_minor(struct dm_task *dmt, int major, int minor,
 338                             int allow_default_major_fallback)
 339 {
 340         dmt->major = major;
 341         dmt->minor = minor;
 342         dmt->allow_default_major_fallback = allow_default_major_fallback;
 343
 344         return 1;
 345 }
 346
 347 int dm_task_set_uid(struct dm_task *dmt, uid_t uid)
 348 {
 349         dmt->uid = uid;
 350
 351         return 1;
 352 }
 353
 354 int dm_task_set_gid(struct dm_task *dmt, gid_t gid)
 355 {
 356         dmt->gid = gid;
 357
 358         return 1;
 359 }
 360
 361 int dm_task_set_mode(struct dm_task *dmt, mode_t mode)
 362 {
 363         dmt->mode = mode;
 364
 365         return 1;
 366 }
 367
 368 int dm_task_add_target(struct dm_task *dmt, uint64_t start, uint64_t size,
 369                        const char *ttype, const char *params)
 370 {
 371         struct target *t = create_target(start, size, ttype, params);
 372
 373         if (!t)
 374                 return 0;
 375
 376         if (!dmt->head)
 377                 dmt->head = dmt->tail = t;
 378         else {
 379                 dmt->tail->next = t;
 380                 dmt->tail = t;
 381         }
 382
 383         return 1;
 384 }
 385
 386 int dm_set_selinux_context(const char *path, mode_t mode)
 387 {
 388 #ifdef HAVE_SELINUX
 389         security_context_t scontext;
 390
 391         if (is_selinux_enabled() <= 0)
 392                 return 1;
 393
 394         if (matchpathcon(path, mode, &scontext) < 0) {
 395                 log_error("%s: matchpathcon %07o failed: %s", path, mode,
 396                           strerror(errno));
 397                 return 0;
 398         }
 399
 400         log_debug("Setting SELinux context for %s to %s.", path, scontext);
 401
 402         if ((lsetfilecon(path, scontext) < 0) && (errno != ENOTSUP)) {
 403                 log_sys_error("lsetfilecon", path);
 404                 freecon(scontext);
 405                 return 0;
 406         }
 407
 408         freecon(scontext);
 409 #endif
 410         return 1;
 411 }
 412
 413 static int _add_dev_node(const char *dev_name, uint32_t major, uint32_t minor,
 414                          uid_t uid, gid_t gid, mode_t mode, int check_udev)
 415 {
 416         char path[PATH_MAX];
 417         struct stat info;
 418         dev_t dev = MKDEV(major, minor);
 419         mode_t old_mask;
 420
 421         #ifdef __NetBSD__
 422         char rpath[PATH_MAX];
 423         uint32_t raw_major;
 424         dev_t rdev;
 425         char raw_devname[DM_NAME_LEN+1]; /* r + other device name */
 426
 427         nbsd_get_dm_major(&raw_major,DM_CHAR_MAJOR);
 428         rdev = MKDEV(raw_major,minor);
 429
 430         snprintf(raw_devname,sizeof(raw_devname),"r%s",dev_name);
 431
 432         _build_dev_path(rpath, sizeof(rpath), raw_devname);
 433
 434         if (stat(rpath, &info) >= 0) {
 435                 if (!S_ISCHR(info.st_mode)) {
 436                         log_error("A non-raw device file at '%s' "
 437                             "is already present", rpath);
 438                         return 0;
 439                 }
 440
 441                 /* If right inode already exists we don't touch uid etc. */
 442                 if (info.st_rdev == rdev)
 443                         return 1;
 444
 445                 if (unlink(rpath) < 0) {
 446                         log_error("Unable to unlink device node for '%s'",
 447                             raw_devname);
 448                         return 0;
 449                 }
 450         }
 451
 452         old_mask = umask(0);
 453
 454         if (mknod(rpath, S_IFCHR | mode, rdev) < 0) {
 455                 log_error("Unable to make device node for '%s'", raw_devname);
 456                 return 0;
 457         }
 458 #elif defined(__DragonFly__)
 459         _build_dev_path(path, sizeof(path), dev_name);
 460         log_error("Skipping all sanity checks here");
 461         return 1;
 462 #endif
 463
 464         _build_dev_path(path, sizeof(path), dev_name);
 465
 466         if (stat(path, &info) >= 0) {
 467                 if (!S_ISBLK(info.st_mode)) {
 468                         log_error("A non-block device file at '%s' "
 469                                   "is already present", path);
 470                         return 0;
 471                 }
 472
 473                 /* If right inode already exists we don't touch uid etc. */
 474                 if (info.st_rdev == dev)
 475                         return 1;
 476
 477                 if (unlink(path) < 0) {
 478                         log_error("Unable to unlink device node for '%s'",
 479                                   dev_name);
 480                         return 0;
 481                 }
 482         } else if (dm_udev_get_sync_support() && check_udev)
 483                 log_warn("%s not set up by udev: Falling back to direct "
 484                          "node creation.", path);
 485
 486         old_mask = umask(0);
 487         if (mknod(path, S_IFBLK | mode, dev) < 0) {
 488                 umask(old_mask);
 489                 log_error("Unable to make device node for '%s'", dev_name);
 490                 return 0;
 491         }
 492         umask(old_mask);
 493
 494         if (chown(path, uid, gid) < 0) {
 495                 log_sys_error("chown", path);
 496                 return 0;
 497         }
 498
 499         log_debug("Created %s", path);
 500
 501         if (!dm_set_selinux_context(path, S_IFBLK))
 502                 return 0;
 503
 504         return 1;
 505 }
 506
 507 static int _rm_dev_node(const char *dev_name, int check_udev)
 508 {
 509         char path[PATH_MAX];
 510         struct stat info;
 511
 512         #ifdef __NetBSD__
 513         char rpath[PATH_MAX];
 514         char raw_devname[DM_NAME_LEN+1]; /* r + other device name */
 515
 516         snprintf(raw_devname,sizeof(raw_devname),"r%s",dev_name);
 517
 518         _build_dev_path(rpath, sizeof(rpath), raw_devname);
 519
 520         if (stat(rpath, &info) < 0)
 521                 return 1;
 522
 523         if (unlink(rpath) < 0) {
 524                 log_error("Unable to unlink device node for '%s'", raw_devname);
 525                 return 0;
 526         }
 527
 528         log_debug("Removed %s", rpath);
 529 #endif
 530
 531         _build_dev_path(path, sizeof(path), dev_name);
 532
 533         if (stat(path, &info) < 0)
 534                 return 1;
 535         else if (dm_udev_get_sync_support() && check_udev)
 536                 log_warn("Node %s was not removed by udev. "
 537                          "Falling back to direct node removal.", path);
 538
 539         if (unlink(path) < 0) {
 540                 log_error("Unable to unlink device node for '%s'", dev_name);
 541                 return 0;
 542         }
 543
 544         log_debug("Removed %s", path);
 545
 546         return 1;
 547 }
 548
 549 static int _rename_dev_node(const char *old_name, const char *new_name,
 550                             int check_udev)
 551 {
 552         char oldpath[PATH_MAX];
 553         char newpath[PATH_MAX];
 554         struct stat info;
 555
 556 #ifdef __NetBSD__
 557         char rpath[PATH_MAX];
 558         char nrpath[PATH_MAX];
 559         char raw_devname[DM_NAME_LEN+1]; /* r + other device name */
 560         char nraw_devname[DM_NAME_LEN+1]; /* r + other device name */
 561
 562         snprintf(nraw_devname,sizeof(raw_devname),"r%s",new_name);
 563         snprintf(raw_devname,sizeof(raw_devname),"r%s",old_name);
 564
 565         _build_dev_path(nrpath, sizeof(nrpath), nraw_devname);
 566         _build_dev_path(rpath, sizeof(rpath), raw_devname);
 567
 568         if (stat(nrpath, &info) == 0) {
 569                 if (S_ISBLK(info.st_mode)) {
 570                         log_error("A block device file at '%s' "
 571                             "is present where raw device should be.", newpath);
 572                         return 0;
 573                 }
 574
 575                 if (unlink(nrpath) < 0) {
 576                         log_error("Unable to unlink device node for '%s'",
 577                             nraw_devname);
 578                         return 0;
 579                 }
 580         }
 581
 582         if (rename(rpath, nrpath) < 0) {
 583                 log_error("Unable to rename device node from '%s' to '%s'",
 584                     raw_devname, nraw_devname);
 585                 return 0;
 586         }
 587
 588         log_debug("Renamed %s to %s", rpath, nrpath);
 589
 590 #endif
 591
 592         _build_dev_path(oldpath, sizeof(oldpath), old_name);
 593         _build_dev_path(newpath, sizeof(newpath), new_name);
 594
 595         if (stat(newpath, &info) == 0) {
 596                 if (!S_ISBLK(info.st_mode)) {
 597                         log_error("A non-block device file at '%s' "
 598                                   "is already present", newpath);
 599                         return 0;
 600                 }
 601                 else if (dm_udev_get_sync_support() && check_udev) {
 602                         if (stat(oldpath, &info) < 0 &&
 603                                  errno == ENOENT)
 604                                 /* assume udev already deleted this */
 605                                 return 1;
 606                         else {
 607                                 log_warn("The node %s should have been renamed to %s "
 608                                          "by udev but old node is still present. "
 609                                          "Falling back to direct old node removal.",
 610                                          oldpath, newpath);
 611                                 return _rm_dev_node(old_name, 0);
 612                         }
 613                 }
 614
 615                 if (unlink(newpath) < 0) {
 616                         if (errno == EPERM) {
 617                                 /* devfs, entry has already been renamed */
 618                                 return 1;
 619                         }
 620                         log_error("Unable to unlink device node for '%s'",
 621                                   new_name);
 622                         return 0;
 623                 }
 624         }
 625         else if (dm_udev_get_sync_support() && check_udev)
 626                 log_warn("The node %s should have been renamed to %s "
 627                          "by udev but new node is not present. "
 628                          "Falling back to direct node rename.",
 629                          oldpath, newpath);
 630
 631         if (rename(oldpath, newpath) < 0) {
 632                 log_error("Unable to rename device node from '%s' to '%s'",
 633                           old_name, new_name);
 634                 return 0;
 635         }
 636
 637         log_debug("Renamed %s to %s", oldpath, newpath);
 638
 639         return 1;
 640 }
 641
 642 #ifdef linux
 643 static int _open_dev_node(const char *dev_name)
 644 {
 645         int fd = -1;
 646         char path[PATH_MAX];
 647
 648         _build_dev_path(path, sizeof(path), dev_name);
 649
 650         if ((fd = open(path, O_RDONLY, 0)) < 0)
 651                 log_sys_error("open", path);
 652
 653         return fd;
 654 }
 655
 656 int get_dev_node_read_ahead(const char *dev_name, uint32_t *read_ahead)
 657 {
 658         int r = 1;
 659         int fd;
 660         long read_ahead_long;
 661
 662         if (!*dev_name) {
 663                 log_error("Empty device name passed to BLKRAGET");
 664                 return 0;
 665         }
 666
 667         if ((fd = _open_dev_node(dev_name)) < 0)
 668                 return_0;
 669
 670         if (ioctl(fd, BLKRAGET, &read_ahead_long)) {
 671                 log_sys_error("BLKRAGET", dev_name);
 672                 *read_ahead = 0;
 673                 r = 0;
 674         }  else {
 675                 *read_ahead = (uint32_t) read_ahead_long;
 676                 log_debug("%s: read ahead is %" PRIu32, dev_name, *read_ahead);
 677         }
 678
 679         if (close(fd))
 680                 stack;
 681
 682         return r;
 683 }
 684
 685 static int _set_read_ahead(const char *dev_name, uint32_t read_ahead)
 686 {
 687         int r = 1;
 688         int fd;
 689         long read_ahead_long = (long) read_ahead;
 690
 691         if (!*dev_name) {
 692                 log_error("Empty device name passed to BLKRAGET");
 693                 return 0;
 694         }
 695
 696         if ((fd = _open_dev_node(dev_name)) < 0)
 697                 return_0;
 698
 699         log_debug("%s: Setting read ahead to %" PRIu32, dev_name, read_ahead);
 700
 701         if (ioctl(fd, BLKRASET, read_ahead_long)) {
 702                 log_sys_error("BLKRASET", dev_name);
 703                 r = 0;
 704         }
 705
 706         if (close(fd))
 707                 stack;
 708
 709         return r;
 710 }
 711
 712 static int _set_dev_node_read_ahead(const char *dev_name, uint32_t read_ahead,
 713                                     uint32_t read_ahead_flags)
 714 {
 715         uint32_t current_read_ahead;
 716
 717         if (read_ahead == DM_READ_AHEAD_AUTO)
 718                 return 1;
 719
 720         if (read_ahead == DM_READ_AHEAD_NONE)
 721                 read_ahead = 0;
 722
 723         if (read_ahead_flags & DM_READ_AHEAD_MINIMUM_FLAG) {
 724                 if (!get_dev_node_read_ahead(dev_name, &current_read_ahead))
 725                         return_0;
 726
 727                 if (current_read_ahead > read_ahead) {
 728                         log_debug("%s: retaining kernel read ahead of %" PRIu32
 729                                   " (requested %" PRIu32 ")",
 730                                   dev_name, current_read_ahead, read_ahead);
 731                         return 1;
 732                 }
 733         }
 734
 735         return _set_read_ahead(dev_name, read_ahead);
 736 }
 737
 738 #else
 739
 740 int get_dev_node_read_ahead(const char *dev_name, uint32_t *read_ahead)
 741 {
 742         *read_ahead = 0;
 743
 744         return 1;
 745 }
 746
 747 static int _set_dev_node_read_ahead(const char *dev_name, uint32_t read_ahead,
 748                                     uint32_t read_ahead_flags)
 749 {
 750         return 1;
 751 }
 752 #endif
 753
 754 typedef enum {
 755         NODE_ADD,
 756         NODE_DEL,
 757         NODE_RENAME,
 758         NODE_READ_AHEAD
 759 } node_op_t;
 760
 761 static int _do_node_op(node_op_t type, const char *dev_name, uint32_t major,
 762                        uint32_t minor, uid_t uid, gid_t gid, mode_t mode,
 763                        const char *old_name, uint32_t read_ahead,
 764                        uint32_t read_ahead_flags, int check_udev)
 765 {
 766         switch (type) {
 767         case NODE_ADD:
 768                 return _add_dev_node(dev_name, major, minor, uid, gid,
 769                                      mode, check_udev);
 770         case NODE_DEL:
 771                 return _rm_dev_node(dev_name, check_udev);
 772         case NODE_RENAME:
 773                 return _rename_dev_node(old_name, dev_name, check_udev);
 774         case NODE_READ_AHEAD:
 775                 return _set_dev_node_read_ahead(dev_name, read_ahead,
 776                                                 read_ahead_flags);
 777         }
 778
 779         return 1;
 780 }
 781
 782 static DM_LIST_INIT(_node_ops);
 783
 784 struct node_op_parms {
 785         struct dm_list list;
 786         node_op_t type;
 787         char *dev_name;
 788         uint32_t major;
 789         uint32_t minor;
 790         uid_t uid;
 791         gid_t gid;
 792         mode_t mode;
 793         uint32_t read_ahead;
 794         uint32_t read_ahead_flags;
 795         char *old_name;
 796         int check_udev;
 797         char names[0];
 798 };
 799
 800 static void _store_str(char **pos, char **ptr, const char *str)
 801 {
 802         strcpy(*pos, str);
 803         *ptr = *pos;
 804         *pos += strlen(*ptr) + 1;
 805 }
 806
 807 static int _stack_node_op(node_op_t type, const char *dev_name, uint32_t major,
 808                           uint32_t minor, uid_t uid, gid_t gid, mode_t mode,
 809                           const char *old_name, uint32_t read_ahead,
 810                           uint32_t read_ahead_flags, int check_udev)
 811 {
 812         struct node_op_parms *nop;
 813         struct dm_list *noph, *nopht;
 814         size_t len = strlen(dev_name) + strlen(old_name) + 2;
 815         char *pos;
 816
 817         /*
 818          * Ignore any outstanding operations on the node if deleting it
 819          */
 820         if (type == NODE_DEL) {
 821                 dm_list_iterate_safe(noph, nopht, &_node_ops) {
 822                         nop = dm_list_item(noph, struct node_op_parms);
 823                         if (!strcmp(dev_name, nop->dev_name)) {
 824                                 dm_list_del(&nop->list);
 825                                 dm_free(nop);
 826                         }
 827                 }
 828         }
 829
 830         if (!(nop = dm_malloc(sizeof(*nop) + len))) {
 831                 log_error("Insufficient memory to stack mknod operation");
 832                 return 0;
 833         }
 834
 835         pos = nop->names;
 836         nop->type = type;
 837         nop->major = major;
 838         nop->minor = minor;
 839         nop->uid = uid;
 840         nop->gid = gid;
 841         nop->mode = mode;
 842         nop->read_ahead = read_ahead;
 843         nop->read_ahead_flags = read_ahead_flags;
 844         nop->check_udev = check_udev;
 845
 846         _store_str(&pos, &nop->dev_name, dev_name);
 847         _store_str(&pos, &nop->old_name, old_name);
 848
 849         dm_list_add(&_node_ops, &nop->list);
 850
 851         return 1;
 852 }
 853
 854 static void _pop_node_ops(void)
 855 {
 856         struct dm_list *noph, *nopht;
 857         struct node_op_parms *nop;
 858
 859         dm_list_iterate_safe(noph, nopht, &_node_ops) {
 860                 nop = dm_list_item(noph, struct node_op_parms);
 861                 _do_node_op(nop->type, nop->dev_name, nop->major, nop->minor,
 862                             nop->uid, nop->gid, nop->mode, nop->old_name,
 863                             nop->read_ahead, nop->read_ahead_flags,
 864                             nop->check_udev);
 865                 dm_list_del(&nop->list);
 866                 dm_free(nop);
 867         }
 868 }
 869
 870 int add_dev_node(const char *dev_name, uint32_t major, uint32_t minor,
 871                  uid_t uid, gid_t gid, mode_t mode, int check_udev)
 872 {
 873         log_debug("%s: Stacking NODE_ADD (%" PRIu32 ",%" PRIu32 ") %u:%u 0%o",
 874                   dev_name, major, minor, uid, gid, mode);
 875
 876         return _stack_node_op(NODE_ADD, dev_name, major, minor, uid,
 877                               gid, mode, "", 0, 0, check_udev);
 878 }
 879
 880 int rename_dev_node(const char *old_name, const char *new_name, int check_udev)
 881 {
 882         log_debug("%s: Stacking NODE_RENAME to %s", old_name, new_name);
 883
 884         return _stack_node_op(NODE_RENAME, new_name, 0, 0, 0,
 885                               0, 0, old_name, 0, 0, check_udev);
 886 }
 887
 888 int rm_dev_node(const char *dev_name, int check_udev)
 889 {
 890         log_debug("%s: Stacking NODE_DEL (replaces other stacked ops)", dev_name);
 891
 892         return _stack_node_op(NODE_DEL, dev_name, 0, 0, 0,
 893                               0, 0, "", 0, 0, check_udev);
 894 }
 895
 896 int set_dev_node_read_ahead(const char *dev_name, uint32_t read_ahead,
 897                             uint32_t read_ahead_flags)
 898 {
 899         if (read_ahead == DM_READ_AHEAD_AUTO)
 900                 return 1;
 901
 902         log_debug("%s: Stacking NODE_READ_AHEAD %" PRIu32 " (flags=%" PRIu32
 903                   ")", dev_name, read_ahead, read_ahead_flags);
 904
 905         return _stack_node_op(NODE_READ_AHEAD, dev_name, 0, 0, 0, 0,
 906                               0, "", read_ahead, read_ahead_flags, 0);
 907 }
 908
 909 void update_devs(void)
 910 {
 911         _pop_node_ops();
 912 }
 913
 914 int dm_set_dev_dir(const char *dev_dir)
 915 {
 916         size_t len;
 917         const char *slash;
 918         if (*dev_dir != '/') {
 919                 log_debug("Invalid dev_dir value, %s: "
 920                           "not an absolute name.", dev_dir);
 921                 return 0;
 922         }
 923
 924         len = strlen(dev_dir);
 925         slash = dev_dir[len-1] == '/' ? "" : "/";
 926
 927         if (snprintf(_dm_dir, sizeof _dm_dir, "%s%s%s", dev_dir, slash, DM_DIR)
 928             >= sizeof _dm_dir) {
 929                 log_debug("Invalid dev_dir value, %s: name too long.", dev_dir);
 930                 return 0;
 931         }
 932
 933         return 1;
 934 }
 935
 936 const char *dm_dir(void)
 937 {
 938         return _dm_dir;
 939 }
 940
 941 int dm_mknodes(const char *name)
 942 {
 943         struct dm_task *dmt;
 944         int r = 0;
 945
 946         if (!(dmt = dm_task_create(DM_DEVICE_MKNODES)))
 947                 return 0;
 948
 949         if (name && !dm_task_set_name(dmt, name))
 950                 goto out;
 951
 952         if (!dm_task_no_open_count(dmt))
 953                 goto out;
 954
 955         r = dm_task_run(dmt);
 956
 957 out:
 958         dm_task_destroy(dmt);
 959         return r;
 960 }
 961
 962 int dm_driver_version(char *version, size_t size)
 963 {
 964         struct dm_task *dmt;
 965         int r = 0;
 966
 967         if (!(dmt = dm_task_create(DM_DEVICE_VERSION)))
 968                 return 0;
 969
 970         if (!dm_task_run(dmt))
 971                 log_error("Failed to get driver version");
 972
 973         if (!dm_task_get_driver_version(dmt, version, size))
 974                 goto out;
 975
 976         r = 1;
 977
 978 out:
 979         dm_task_destroy(dmt);
 980         return r;
 981 }
 982
 983 #ifndef UDEV_SYNC_SUPPORT
 984 void dm_udev_set_sync_support(int sync_with_udev)
 985 {
 986 }
 987
 988 int dm_udev_get_sync_support(void)
 989 {
 990         return 0;
 991 }
 992
 993 int dm_task_set_cookie(struct dm_task *dmt, uint32_t *cookie, uint16_t flags)
 994 {
 995         if (dm_cookie_supported())
 996                 dmt->event_nr = flags << DM_UDEV_FLAGS_SHIFT;
 997         *cookie = 0;
 998
 999         return 1;
1000 }
1001
1002 int dm_udev_complete(uint32_t cookie)
1003 {
1004         return 1;
1005 }
1006
1007 int dm_udev_wait(uint32_t cookie)
1008 {
1009         return 1;
1010 }
1011
1012 #else           /* UDEV_SYNC_SUPPORT */
1013
1014
1015 static int _check_udev_is_running(void)
1016 {
1017
1018 #  ifndef HAVE_UDEV_QUEUE_GET_UDEV_IS_ACTIVE
1019
1020         log_debug("Could not get udev state because libudev library "
1021                   "was not found and it was not compiled in. "
1022                   "Assuming udev is not running.");
1023         return 0;
1024
1025 #  else /* HAVE_UDEV_QUEUE_GET_UDEV_IS_ACTIVE */
1026
1027         struct udev *udev;
1028         struct udev_queue *udev_queue;
1029         int r;
1030
1031         if (!(udev = udev_new()))
1032                 goto_bad;
1033
1034         if (!(udev_queue = udev_queue_new(udev))) {
1035                 udev_unref(udev);
1036                 goto_bad;
1037         }
1038
1039         if (!(r = udev_queue_get_udev_is_active(udev_queue)))
1040                 log_debug("Udev is not running. "
1041                           "Not using udev synchronisation code.");
1042
1043         udev_queue_unref(udev_queue);
1044         udev_unref(udev);
1045
1046         return r;
1047
1048 bad:
1049         log_error("Could not get udev state. Assuming udev is not running.");
1050         return 0;
1051
1052 #  endif        /* HAVE_UDEV_QUEUE_GET_UDEV_IS_ACTIVE */
1053
1054 }
1055
1056 void dm_udev_set_sync_support(int sync_with_udev)
1057 {
1058         if (_udev_running < 0)
1059                 _udev_running = _check_udev_is_running();
1060
1061         _sync_with_udev = sync_with_udev;
1062 }
1063
1064 int dm_udev_get_sync_support(void)
1065 {
1066         if (_udev_running < 0)
1067                 _udev_running = _check_udev_is_running();
1068
1069         return dm_cookie_supported() && _udev_running && _sync_with_udev;
1070 }
1071
1072 static int _get_cookie_sem(uint32_t cookie, int *semid)
1073 {
1074         if (cookie >> 16 != DM_COOKIE_MAGIC) {
1075                 log_error("Could not continue to access notification "
1076                           "semaphore identified by cookie value %"
1077                           PRIu32 " (0x%x). Incorrect cookie prefix.",
1078                           cookie, cookie);
1079                 return 0;
1080         }
1081
1082         if ((*semid = semget((key_t) cookie, 1, 0)) >= 0)
1083                 return 1;
1084
1085         switch (errno) {
1086                 case ENOENT:
1087                         log_error("Could not find notification "
1088                                   "semaphore identified by cookie "
1089                                   "value %" PRIu32 " (0x%x)",
1090                                   cookie, cookie);
1091                         break;
1092                 case EACCES:
1093                         log_error("No permission to access "
1094                                   "notificaton semaphore identified "
1095                                   "by cookie value %" PRIu32 " (0x%x)",
1096                                   cookie, cookie);
1097                         break;
1098                 default:
1099                         log_error("Failed to access notification "
1100                                    "semaphore identified by cookie "
1101                                    "value %" PRIu32 " (0x%x): %s",
1102                                   cookie, cookie, strerror(errno));
1103                         break;
1104         }
1105
1106         return 0;
1107 }
1108
1109 static int _udev_notify_sem_inc(uint32_t cookie, int semid)
1110 {
1111         struct sembuf sb = {0, 1, 0};
1112
1113         if (semop(semid, &sb, 1) < 0) {
1114                 log_error("semid %d: semop failed for cookie 0x%" PRIx32 ": %s",
1115                           semid, cookie, strerror(errno));
1116                 return 0;
1117         }
1118
1119         log_debug("Udev cookie 0x%" PRIx32 " (semid %d) incremented",
1120                   cookie, semid);
1121
1122         return 1;
1123 }
1124
1125 static int _udev_notify_sem_dec(uint32_t cookie, int semid)
1126 {
1127         struct sembuf sb = {0, -1, IPC_NOWAIT};
1128
1129         if (semop(semid, &sb, 1) < 0) {
1130                 switch (errno) {
1131                         case EAGAIN:
1132                                 log_error("semid %d: semop failed for cookie "
1133                                           "0x%" PRIx32 ": "
1134                                           "incorrect semaphore state",
1135                                           semid, cookie);
1136                                 break;
1137                         default:
1138                                 log_error("semid %d: semop failed for cookie "
1139                                           "0x%" PRIx32 ": %s",
1140                                           semid, cookie, strerror(errno));
1141                                 break;
1142                 }
1143                 return 0;
1144         }
1145
1146         log_debug("Udev cookie 0x%" PRIx32 " (semid %d) decremented",
1147                   cookie, semid);
1148
1149         return 1;
1150 }
1151
1152 static int _udev_notify_sem_destroy(uint32_t cookie, int semid)
1153 {
1154         if (semctl(semid, 0, IPC_RMID, 0) < 0) {
1155                 log_error("Could not cleanup notification semaphore "
1156                           "identified by cookie value %" PRIu32 " (0x%x): %s",
1157                           cookie, cookie, strerror(errno));
1158                 return 0;
1159         }
1160
1161         log_debug("Udev cookie 0x%" PRIx32 " (semid %d) destroyed", cookie,
1162                   semid);
1163
1164         return 1;
1165 }
1166
1167 static int _udev_notify_sem_create(uint32_t *cookie, int *semid)
1168 {
1169         int fd;
1170         int gen_semid;
1171         uint16_t base_cookie;
1172         uint32_t gen_cookie;
1173
1174         if ((fd = open("/dev/urandom", O_RDONLY)) < 0) {
1175                 log_error("Failed to open /dev/urandom "
1176                           "to create random cookie value");
1177                 *cookie = 0;
1178                 return 0;
1179         }
1180
1181         /* Generate random cookie value. Be sure it is unique and non-zero. */
1182         do {
1183                 /* FIXME Handle non-error returns from read(). Move _io() into libdm? */
1184                 if (read(fd, &base_cookie, sizeof(base_cookie)) != sizeof(base_cookie)) {
1185                         log_error("Failed to initialize notification cookie");
1186                         goto bad;
1187                 }
1188
1189                 gen_cookie = DM_COOKIE_MAGIC << 16 | base_cookie;
1190
1191                 if (base_cookie && (gen_semid = semget((key_t) gen_cookie,
1192                                     1, 0600 | IPC_CREAT | IPC_EXCL)) < 0) {
1193                         switch (errno) {
1194                                 case EEXIST:
1195                                         /* if the semaphore key exists, we
1196                                          * simply generate another random one */
1197                                         base_cookie = 0;
1198                                         break;
1199                                 case ENOMEM:
1200                                         log_error("Not enough memory to create "
1201                                                   "notification semaphore");
1202                                         goto bad;
1203                                 case ENOSPC:
1204                                         log_error("Limit for the maximum number "
1205                                                   "of semaphores reached. You can "
1206                                                   "check and set the limits in "
1207                                                   "/proc/sys/kernel/sem.");
1208                                         goto bad;
1209                                 default:
1210                                         log_error("Failed to create notification "
1211                                                   "semaphore: %s", strerror(errno));
1212                                         goto bad;
1213                         }
1214                 }
1215         } while (!base_cookie);
1216
1217         log_debug("Udev cookie 0x%" PRIx32 " (semid %d) created",
1218                   gen_cookie, gen_semid);
1219
1220         if (semctl(gen_semid, 0, SETVAL, 1) < 0) {
1221                 log_error("semid %d: semctl failed: %s", gen_semid, strerror(errno));
1222                 /* We have to destroy just created semaphore
1223                  * so it won't stay in the system. */
1224                 (void) _udev_notify_sem_destroy(gen_cookie, gen_semid);
1225                 goto bad;
1226         }
1227
1228         log_debug("Udev cookie 0x%" PRIx32 " (semid %d) incremented",
1229                   gen_cookie, gen_semid);
1230
1231         if (close(fd))
1232                 stack;
1233
1234         *semid = gen_semid;
1235         *cookie = gen_cookie;
1236
1237         return 1;
1238
1239 bad:
1240         if (close(fd))
1241                 stack;
1242
1243         *cookie = 0;
1244
1245         return 0;
1246 }
1247
1248 int dm_task_set_cookie(struct dm_task *dmt, uint32_t *cookie, uint16_t flags)
1249 {
1250         int semid;
1251
1252         if (dm_cookie_supported())
1253                 dmt->event_nr = flags << DM_UDEV_FLAGS_SHIFT;
1254
1255         if (!dm_udev_get_sync_support()) {
1256                 *cookie = 0;
1257                 return 1;
1258         }
1259
1260         if (*cookie) {
1261                 if (!_get_cookie_sem(*cookie, &semid))
1262                         goto_bad;
1263         } else if (!_udev_notify_sem_create(cookie, &semid))
1264                 goto_bad;
1265
1266         if (!_udev_notify_sem_inc(*cookie, semid)) {
1267                 log_error("Could not set notification semaphore "
1268                           "identified by cookie value %" PRIu32 " (0x%x)",
1269                           *cookie, *cookie);
1270                 goto bad;
1271         }
1272
1273         dmt->event_nr |= ~DM_UDEV_FLAGS_MASK & *cookie;
1274         dmt->cookie_set = 1;
1275
1276         log_debug("Udev cookie 0x%" PRIx32 " (semid %d) assigned to dm_task "
1277                   "with flags 0x%" PRIx16, *cookie, semid, flags);
1278
1279         return 1;
1280
1281 bad:
1282         dmt->event_nr = 0;
1283         return 0;
1284 }
1285
1286 int dm_udev_complete(uint32_t cookie)
1287 {
1288         int semid;
1289
1290         if (!cookie || !dm_udev_get_sync_support())
1291                 return 1;
1292
1293         if (!_get_cookie_sem(cookie, &semid))
1294                 return_0;
1295
1296         if (!_udev_notify_sem_dec(cookie, semid)) {
1297                 log_error("Could not signal waiting process using notification "
1298                           "semaphore identified by cookie value %" PRIu32 " (0x%x)",
1299                           cookie, cookie);
1300                 return 0;
1301         }
1302
1303         return 1;
1304 }
1305
1306 int dm_udev_wait(uint32_t cookie)
1307 {
1308         int semid;
1309         struct sembuf sb = {0, 0, 0};
1310
1311         if (!cookie || !dm_udev_get_sync_support())
1312                 return 1;
1313
1314         if (!_get_cookie_sem(cookie, &semid))
1315                 return_0;
1316
1317         if (!_udev_notify_sem_dec(cookie, semid)) {
1318                 log_error("Failed to set a proper state for notification "
1319                           "semaphore identified by cookie value %" PRIu32 " (0x%x) "
1320                           "to initialize waiting for incoming notifications.",
1321                           cookie, cookie);
1322                 (void) _udev_notify_sem_destroy(cookie, semid);
1323                 return 0;
1324         }
1325
1326         log_debug("Udev cookie 0x%" PRIx32 " (semid %d): Waiting for zero",
1327                   cookie, semid);
1328
1329 repeat_wait:
1330         if (semop(semid, &sb, 1) < 0) {
1331                 if (errno == EINTR)
1332                         goto repeat_wait;
1333                 else if (errno == EIDRM)
1334                         return 1;
1335
1336                 log_error("Could not set wait state for notification semaphore "
1337                           "identified by cookie value %" PRIu32 " (0x%x): %s",
1338                           cookie, cookie, strerror(errno));
1339                 (void) _udev_notify_sem_destroy(cookie, semid);
1340                 return 0;
1341         }
1342
1343         return _udev_notify_sem_destroy(cookie, semid);
1344 }
1345
1346 #endif          /* UDEV_SYNC_SUPPORT */