external/gpl2/lvm2/dist/daemons/clvmd/lvm-functions.c

   1 /*      $NetBSD$        */
   2
   3 /*
   4  * Copyright (C) 2002-2004 Sistina Software, Inc. All rights reserved.
   5  * Copyright (C) 2004-2009 Red Hat, Inc. All rights reserved.
   6  *
   7  * This file is part of LVM2.
   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 General Public License v.2.
  12  *
  13  * You should have received a copy of the GNU 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 #define _GNU_SOURCE
  19 #define _FILE_OFFSET_BITS 64
  20
  21 #include <configure.h>
  22 #include <pthread.h>
  23 #include <sys/types.h>
  24 #include <sys/utsname.h>
  25 #include <sys/ioctl.h>
  26 #include <sys/socket.h>
  27 #include <sys/stat.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <stdint.h>
  31 #include <fcntl.h>
  32 #include <string.h>
  33 #include <stddef.h>
  34 #include <stdint.h>
  35 #include <unistd.h>
  36 #include <errno.h>
  37 #include <syslog.h>
  38 #include <assert.h>
  39 #include <libdevmapper.h>
  40 #include <libdlm.h>
  41
  42 #include "lvm-types.h"
  43 #include "clvm.h"
  44 #include "clvmd-comms.h"
  45 #include "clvmd.h"
  46 #include "lvm-functions.h"
  47
  48 /* LVM2 headers */
  49 #include "toolcontext.h"
  50 #include "lvmcache.h"
  51 #include "lvm-logging.h"
  52 #include "lvm-globals.h"
  53 #include "activate.h"
  54 #include "locking.h"
  55 #include "archiver.h"
  56 #include "defaults.h"
  57
  58 static struct cmd_context *cmd = NULL;
  59 static struct dm_hash_table *lv_hash = NULL;
  60 static pthread_mutex_t lv_hash_lock;
  61 static pthread_mutex_t lvm_lock;
  62 static char last_error[1024];
  63 static int suspended = 0;
  64
  65 struct lv_info {
  66         int lock_id;
  67         int lock_mode;
  68 };
  69
  70 static const char *decode_locking_cmd(unsigned char cmdl)
  71 {
  72         static char buf[128];
  73         const char *type;
  74         const char *scope;
  75         const char *command;
  76
  77         switch (cmdl & LCK_TYPE_MASK) {
  78         case LCK_NULL:
  79                 type = "NULL";
  80                 break;
  81         case LCK_READ:
  82                 type = "READ";
  83                 break;
  84         case LCK_PREAD:
  85                 type = "PREAD";
  86                 break;
  87         case LCK_WRITE:
  88                 type = "WRITE";
  89                 break;
  90         case LCK_EXCL:
  91                 type = "EXCL";
  92                 break;
  93         case LCK_UNLOCK:
  94                 type = "UNLOCK";
  95                 break;
  96         default:
  97                 type = "unknown";
  98                 break;
  99         }
 100
 101         switch (cmdl & LCK_SCOPE_MASK) {
 102         case LCK_VG:
 103                 scope = "VG";
 104                 break;
 105         case LCK_LV:
 106                 scope = "LV";
 107                 break;
 108         default:
 109                 scope = "unknown";
 110                 break;
 111         }
 112
 113         switch (cmdl & LCK_MASK) {
 114         case LCK_LV_EXCLUSIVE & LCK_MASK:
 115                 command = "LCK_LV_EXCLUSIVE";
 116                 break;
 117         case LCK_LV_SUSPEND & LCK_MASK:
 118                 command = "LCK_LV_SUSPEND";
 119                 break;
 120         case LCK_LV_RESUME & LCK_MASK:
 121                 command = "LCK_LV_RESUME";
 122                 break;
 123         case LCK_LV_ACTIVATE & LCK_MASK:
 124                 command = "LCK_LV_ACTIVATE";
 125                 break;
 126         case LCK_LV_DEACTIVATE & LCK_MASK:
 127                 command = "LCK_LV_DEACTIVATE";
 128                 break;
 129         default:
 130                 command = "unknown";
 131                 break;
 132         }
 133
 134         sprintf(buf, "0x%x %s (%s|%s%s%s%s%s%s)", cmdl, command, type, scope,
 135                 cmdl & LCK_NONBLOCK   ? "|NONBLOCK" : "",
 136                 cmdl & LCK_HOLD       ? "|HOLD" : "",
 137                 cmdl & LCK_LOCAL      ? "|LOCAL" : "",
 138                 cmdl & LCK_CLUSTER_VG ? "|CLUSTER_VG" : "",
 139                 cmdl & LCK_CACHE      ? "|CACHE" : "");
 140
 141         return buf;
 142 }
 143
 144 static const char *decode_flags(unsigned char flags)
 145 {
 146         static char buf[128];
 147
 148         sprintf(buf, "0x%x (%s%s%s%s)", flags,
 149                 flags & LCK_PARTIAL_MODE          ? "PARTIAL_MODE " : "",
 150                 flags & LCK_MIRROR_NOSYNC_MODE    ? "MIRROR_NOSYNC " : "",
 151                 flags & LCK_DMEVENTD_MONITOR_MODE ? "DMEVENTD_MONITOR " : "",
 152                 flags & LCK_CONVERT ? "CONVERT " : "");
 153
 154         return buf;
 155 }
 156
 157 char *get_last_lvm_error()
 158 {
 159         return last_error;
 160 }
 161
 162 /*
 163  * Hash lock info helpers
 164  */
 165 static struct lv_info *lookup_info(const char *resource)
 166 {
 167         struct lv_info *lvi;
 168
 169         pthread_mutex_lock(&lv_hash_lock);
 170         lvi = dm_hash_lookup(lv_hash, resource);
 171         pthread_mutex_unlock(&lv_hash_lock);
 172
 173         return lvi;
 174 }
 175
 176 static void insert_info(const char *resource, struct lv_info *lvi)
 177 {
 178         pthread_mutex_lock(&lv_hash_lock);
 179         dm_hash_insert(lv_hash, resource, lvi);
 180         pthread_mutex_unlock(&lv_hash_lock);
 181 }
 182
 183 static void remove_info(const char *resource)
 184 {
 185         pthread_mutex_lock(&lv_hash_lock);
 186         dm_hash_remove(lv_hash, resource);
 187         pthread_mutex_unlock(&lv_hash_lock);
 188 }
 189
 190 /*
 191  * Return the mode a lock is currently held at (or -1 if not held)
 192  */
 193 static int get_current_lock(char *resource)
 194 {
 195         struct lv_info *lvi;
 196
 197         if ((lvi = lookup_info(resource)))
 198                 return lvi->lock_mode;
 199
 200         return -1;
 201 }
 202
 203
 204 void init_lvhash()
 205 {
 206         /* Create hash table for keeping LV locks & status */
 207         lv_hash = dm_hash_create(100);
 208         pthread_mutex_init(&lv_hash_lock, NULL);
 209         pthread_mutex_init(&lvm_lock, NULL);
 210 }
 211
 212 /* Called at shutdown to tidy the lockspace */
 213 void destroy_lvhash()
 214 {
 215         struct dm_hash_node *v;
 216         struct lv_info *lvi;
 217         char *resource;
 218         int status;
 219
 220         pthread_mutex_lock(&lv_hash_lock);
 221
 222         dm_hash_iterate(v, lv_hash) {
 223                 lvi = dm_hash_get_data(lv_hash, v);
 224                 resource = dm_hash_get_key(lv_hash, v);
 225
 226                 if ((status = sync_unlock(resource, lvi->lock_id)))
 227                         DEBUGLOG("unlock_all. unlock failed(%d): %s\n",
 228                                  status,  strerror(errno));
 229                 free(lvi);
 230         }
 231
 232         dm_hash_destroy(lv_hash);
 233         lv_hash = NULL;
 234
 235         pthread_mutex_unlock(&lv_hash_lock);
 236 }
 237
 238 /* Gets a real lock and keeps the info in the hash table */
 239 int hold_lock(char *resource, int mode, int flags)
 240 {
 241         int status;
 242         int saved_errno;
 243         struct lv_info *lvi;
 244
 245         /* Mask off invalid options */
 246         flags &= LKF_NOQUEUE | LKF_CONVERT;
 247
 248         lvi = lookup_info(resource);
 249
 250         /* Only allow explicit conversions */
 251         if (lvi && !(flags & LKF_CONVERT)) {
 252                 errno = EBUSY;
 253                 return -1;
 254         }
 255         if (lvi) {
 256                 /* Already exists - convert it */
 257                 status =
 258                     sync_lock(resource, mode, flags, &lvi->lock_id);
 259                 saved_errno = errno;
 260                 if (!status)
 261                         lvi->lock_mode = mode;
 262
 263                 if (status) {
 264                         DEBUGLOG("hold_lock. convert to %d failed: %s\n", mode,
 265                                  strerror(errno));
 266                 }
 267                 errno = saved_errno;
 268         } else {
 269                 lvi = malloc(sizeof(struct lv_info));
 270                 if (!lvi)
 271                         return -1;
 272
 273                 lvi->lock_mode = mode;
 274                 status = sync_lock(resource, mode, flags, &lvi->lock_id);
 275                 saved_errno = errno;
 276                 if (status) {
 277                         free(lvi);
 278                         DEBUGLOG("hold_lock. lock at %d failed: %s\n", mode,
 279                                  strerror(errno));
 280                 } else
 281                         insert_info(resource, lvi);
 282
 283                 errno = saved_errno;
 284         }
 285         return status;
 286 }
 287
 288 /* Unlock and remove it from the hash table */
 289 int hold_unlock(char *resource)
 290 {
 291         struct lv_info *lvi;
 292         int status;
 293         int saved_errno;
 294
 295         if (!(lvi = lookup_info(resource))) {
 296                 DEBUGLOG("hold_unlock, lock not already held\n");
 297                 return 0;
 298         }
 299
 300         status = sync_unlock(resource, lvi->lock_id);
 301         saved_errno = errno;
 302         if (!status) {
 303                 remove_info(resource);
 304                 free(lvi);
 305         } else {
 306                 DEBUGLOG("hold_unlock. unlock failed(%d): %s\n", status,
 307                          strerror(errno));
 308         }
 309
 310         errno = saved_errno;
 311         return status;
 312 }
 313
 314 /* Watch the return codes here.
 315    liblvm API functions return 1(true) for success, 0(false) for failure and don't set errno.
 316    libdlm API functions return 0 for success, -1 for failure and do set errno.
 317    These functions here return 0 for success or >0 for failure (where the retcode is errno)
 318 */
 319
 320 /* Activate LV exclusive or non-exclusive */
 321 static int do_activate_lv(char *resource, unsigned char lock_flags, int mode)
 322 {
 323         int oldmode;
 324         int status;
 325         int activate_lv;
 326         int exclusive = 0;
 327         struct lvinfo lvi;
 328
 329         /* Is it already open ? */
 330         oldmode = get_current_lock(resource);
 331         if (oldmode == mode) {
 332                 return 0;       /* Nothing to do */
 333         }
 334
 335         /* Does the config file want us to activate this LV ? */
 336         if (!lv_activation_filter(cmd, resource, &activate_lv))
 337                 return EIO;
 338
 339         if (!activate_lv)
 340                 return 0;       /* Success, we did nothing! */
 341
 342         /* Do we need to activate exclusively? */
 343         if ((activate_lv == 2) || (mode == LKM_EXMODE)) {
 344                 exclusive = 1;
 345                 mode = LKM_EXMODE;
 346         }
 347
 348         /* Try to get the lock if it's a clustered volume group */
 349         if (lock_flags & LCK_CLUSTER_VG) {
 350                 status = hold_lock(resource, mode, LKF_NOQUEUE | (lock_flags & LCK_CONVERT?LKF_CONVERT:0));
 351                 if (status) {
 352                         /* Return an LVM-sensible error for this.
 353                          * Forcing EIO makes the upper level return this text
 354                          * rather than the strerror text for EAGAIN.
 355                          */
 356                         if (errno == EAGAIN) {
 357                                 sprintf(last_error, "Volume is busy on another node");
 358                                 errno = EIO;
 359                         }
 360                         return errno;
 361                 }
 362         }
 363
 364         /* If it's suspended then resume it */
 365         if (!lv_info_by_lvid(cmd, resource, &lvi, 0, 0))
 366                 return EIO;
 367
 368         if (lvi.suspended)
 369                 if (!lv_resume(cmd, resource))
 370                         return EIO;
 371
 372         /* Now activate it */
 373         if (!lv_activate(cmd, resource, exclusive))
 374                 return EIO;
 375
 376         return 0;
 377 }
 378
 379 /* Resume the LV if it was active */
 380 static int do_resume_lv(char *resource)
 381 {
 382         int oldmode;
 383
 384         /* Is it open ? */
 385         oldmode = get_current_lock(resource);
 386         if (oldmode == -1) {
 387                 DEBUGLOG("do_resume_lv, lock not already held\n");
 388                 return 0;       /* We don't need to do anything */
 389         }
 390
 391         if (!lv_resume_if_active(cmd, resource))
 392                 return EIO;
 393
 394         return 0;
 395 }
 396
 397 /* Suspend the device if active */
 398 static int do_suspend_lv(char *resource)
 399 {
 400         int oldmode;
 401         struct lvinfo lvi;
 402
 403         /* Is it open ? */
 404         oldmode = get_current_lock(resource);
 405         if (oldmode == -1) {
 406                 DEBUGLOG("do_suspend_lv, lock held at %d\n", oldmode);
 407                 return 0; /* Not active, so it's OK */
 408         }
 409
 410         /* Only suspend it if it exists */
 411         if (!lv_info_by_lvid(cmd, resource, &lvi, 0, 0))
 412                 return EIO;
 413
 414         if (lvi.exists) {
 415                 if (!lv_suspend_if_active(cmd, resource)) {
 416                         return EIO;
 417                 }
 418         }
 419         return 0;
 420 }
 421
 422 static int do_deactivate_lv(char *resource, unsigned char lock_flags)
 423 {
 424         int oldmode;
 425         int status;
 426
 427         /* Is it open ? */
 428         oldmode = get_current_lock(resource);
 429         if (oldmode == -1 && (lock_flags & LCK_CLUSTER_VG)) {
 430                 DEBUGLOG("do_deactivate_lock, lock not already held\n");
 431                 return 0;       /* We don't need to do anything */
 432         }
 433
 434         if (!lv_deactivate(cmd, resource))
 435                 return EIO;
 436
 437         if (lock_flags & LCK_CLUSTER_VG) {
 438                 status = hold_unlock(resource);
 439                 if (status)
 440                         return errno;
 441         }
 442
 443         return 0;
 444 }
 445
 446 const char *do_lock_query(char *resource)
 447 {
 448         int mode;
 449         const char *type = NULL;
 450
 451         mode = get_current_lock(resource);
 452         switch (mode) {
 453                 case LKM_NLMODE: type = "NL"; break;
 454                 case LKM_CRMODE: type = "CR"; break;
 455                 case LKM_CWMODE: type = "CW"; break;
 456                 case LKM_PRMODE: type = "PR"; break;
 457                 case LKM_PWMODE: type = "PW"; break;
 458                 case LKM_EXMODE: type = "EX"; break;
 459         }
 460
 461         DEBUGLOG("do_lock_query: resource '%s', mode %i (%s)\n", resource, mode, type ?: "?");
 462
 463         return type;
 464 }
 465
 466 /* This is the LOCK_LV part that happens on all nodes in the cluster -
 467    it is responsible for the interaction with device-mapper and LVM */
 468 int do_lock_lv(unsigned char command, unsigned char lock_flags, char *resource)
 469 {
 470         int status = 0;
 471
 472         DEBUGLOG("do_lock_lv: resource '%s', cmd = %s, flags = %s\n",
 473                  resource, decode_locking_cmd(command), decode_flags(lock_flags));
 474
 475         if (!cmd->config_valid || config_files_changed(cmd)) {
 476                 /* Reinitialise various settings inc. logging, filters */
 477                 if (do_refresh_cache()) {
 478                         log_error("Updated config file invalid. Aborting.");
 479                         return EINVAL;
 480                 }
 481         }
 482
 483         pthread_mutex_lock(&lvm_lock);
 484         if (lock_flags & LCK_MIRROR_NOSYNC_MODE)
 485                 init_mirror_in_sync(1);
 486
 487         if (!(lock_flags & LCK_DMEVENTD_MONITOR_MODE))
 488                 init_dmeventd_monitor(0);
 489
 490         cmd->partial_activation = (lock_flags & LCK_PARTIAL_MODE) ? 1 : 0;
 491
 492         switch (command & LCK_MASK) {
 493         case LCK_LV_EXCLUSIVE:
 494                 status = do_activate_lv(resource, lock_flags, LKM_EXMODE);
 495                 break;
 496
 497         case LCK_LV_SUSPEND:
 498                 status = do_suspend_lv(resource);
 499                 if (!status)
 500                         suspended++;
 501                 break;
 502
 503         case LCK_UNLOCK:
 504         case LCK_LV_RESUME:     /* if active */
 505                 status = do_resume_lv(resource);
 506                 if (!status)
 507                         suspended--;
 508                 break;
 509
 510         case LCK_LV_ACTIVATE:
 511                 status = do_activate_lv(resource, lock_flags, LKM_CRMODE);
 512                 break;
 513
 514         case LCK_LV_DEACTIVATE:
 515                 status = do_deactivate_lv(resource, lock_flags);
 516                 break;
 517
 518         default:
 519                 DEBUGLOG("Invalid LV command 0x%x\n", command);
 520                 status = EINVAL;
 521                 break;
 522         }
 523
 524         if (lock_flags & LCK_MIRROR_NOSYNC_MODE)
 525                 init_mirror_in_sync(0);
 526
 527         if (!(lock_flags & LCK_DMEVENTD_MONITOR_MODE))
 528                 init_dmeventd_monitor(DEFAULT_DMEVENTD_MONITOR);
 529
 530         cmd->partial_activation = 0;
 531
 532         /* clean the pool for another command */
 533         dm_pool_empty(cmd->mem);
 534         pthread_mutex_unlock(&lvm_lock);
 535
 536         DEBUGLOG("Command return is %d\n", status);
 537         return status;
 538 }
 539
 540 /* Functions to do on the local node only BEFORE the cluster-wide stuff above happens */
 541 int pre_lock_lv(unsigned char command, unsigned char lock_flags, char *resource)
 542 {
 543         /* Nearly all the stuff happens cluster-wide. Apart from SUSPEND. Here we get the
 544            lock out on this node (because we are the node modifying the metadata)
 545            before suspending cluster-wide.
 546          */
 547         if (command == LCK_LV_SUSPEND) {
 548                 DEBUGLOG("pre_lock_lv: resource '%s', cmd = %s, flags = %s\n",
 549                          resource, decode_locking_cmd(command), decode_flags(lock_flags));
 550
 551                 if (hold_lock(resource, LKM_PWMODE, LKF_NOQUEUE| (lock_flags & LCK_CONVERT?LKF_CONVERT:0)))
 552                         return errno;
 553         }
 554         return 0;
 555 }
 556
 557 /* Functions to do on the local node only AFTER the cluster-wide stuff above happens */
 558 int post_lock_lv(unsigned char command, unsigned char lock_flags,
 559                  char *resource)
 560 {
 561         int status;
 562
 563         /* Opposite of above, done on resume after a metadata update */
 564         if (command == LCK_LV_RESUME) {
 565                 int oldmode;
 566
 567                 DEBUGLOG
 568                     ("post_lock_lv: resource '%s', cmd = %s, flags = %s\n",
 569                      resource, decode_locking_cmd(command), decode_flags(lock_flags));
 570
 571                 /* If the lock state is PW then restore it to what it was */
 572                 oldmode = get_current_lock(resource);
 573                 if (oldmode == LKM_PWMODE) {
 574                         struct lvinfo lvi;
 575
 576                         pthread_mutex_lock(&lvm_lock);
 577                         status = lv_info_by_lvid(cmd, resource, &lvi, 0, 0);
 578                         pthread_mutex_unlock(&lvm_lock);
 579                         if (!status)
 580                                 return EIO;
 581
 582                         if (lvi.exists) {
 583                                 if (hold_lock(resource, LKM_CRMODE, lock_flags & LCK_CONVERT?LKF_CONVERT:0))
 584                                         return errno;
 585                         } else {
 586                                 if (hold_unlock(resource))
 587                                         return errno;
 588                         }
 589                 }
 590         }
 591         return 0;
 592 }
 593
 594 /* Check if a VG is in use by LVM1 so we don't stomp on it */
 595 int do_check_lvm1(const char *vgname)
 596 {
 597         int status;
 598
 599         status = check_lvm1_vg_inactive(cmd, vgname);
 600
 601         return status == 1 ? 0 : EBUSY;
 602 }
 603
 604 int do_refresh_cache()
 605 {
 606         DEBUGLOG("Refreshing context\n");
 607         log_notice("Refreshing context");
 608
 609         pthread_mutex_lock(&lvm_lock);
 610
 611         if (!refresh_toolcontext(cmd)) {
 612                 pthread_mutex_unlock(&lvm_lock);
 613                 return -1;
 614         }
 615
 616         init_full_scan_done(0);
 617         lvmcache_label_scan(cmd, 2);
 618         dm_pool_empty(cmd->mem);
 619
 620         pthread_mutex_unlock(&lvm_lock);
 621
 622         return 0;
 623 }
 624
 625
 626 /* Only called at gulm startup. Drop any leftover VG or P_orphan locks
 627    that might be hanging around if we died for any reason
 628 */
 629 static void drop_vg_locks()
 630 {
 631         char vg[128];
 632         char line[255];
 633         FILE *vgs =
 634             popen
 635             ("lvm pvs  --config 'log{command_names=0 prefix=\"\"}' --nolocking --noheadings -o vg_name", "r");
 636
 637         sync_unlock("P_" VG_ORPHANS, LCK_EXCL);
 638         sync_unlock("P_" VG_GLOBAL, LCK_EXCL);
 639
 640         if (!vgs)
 641                 return;
 642
 643         while (fgets(line, sizeof(line), vgs)) {
 644                 char *vgend;
 645                 char *vgstart;
 646
 647                 if (line[strlen(line)-1] == '\n')
 648                         line[strlen(line)-1] = '\0';
 649
 650                 vgstart = line + strspn(line, " ");
 651                 vgend = vgstart + strcspn(vgstart, " ");
 652                 *vgend = '\0';
 653
 654                 if (strncmp(vgstart, "WARNING:", 8) == 0)
 655                         continue;
 656
 657                 sprintf(vg, "V_%s", vgstart);
 658                 sync_unlock(vg, LCK_EXCL);
 659
 660         }
 661         if (fclose(vgs))
 662                 DEBUGLOG("vgs fclose failed: %s\n", strerror(errno));
 663 }
 664
 665 /*
 666  * Drop lvmcache metadata
 667  */
 668 void drop_metadata(const char *vgname)
 669 {
 670         DEBUGLOG("Dropping metadata for VG %s\n", vgname);
 671         pthread_mutex_lock(&lvm_lock);
 672         lvmcache_drop_metadata(vgname);
 673         pthread_mutex_unlock(&lvm_lock);
 674 }
 675
 676 /*
 677  * Ideally, clvmd should be started before any LVs are active
 678  * but this may not be the case...
 679  * I suppose this also comes in handy if clvmd crashes, not that it would!
 680  */
 681 static void *get_initial_state()
 682 {
 683         char lv[64], vg[64], flags[25], vg_flags[25];
 684         char uuid[65];
 685         char line[255];
 686         FILE *lvs =
 687             popen
 688             ("lvm lvs  --config 'log{command_names=0 prefix=\"\"}' --nolocking --noheadings -o vg_uuid,lv_uuid,lv_attr,vg_attr",
 689              "r");
 690
 691         if (!lvs)
 692                 return NULL;
 693
 694         while (fgets(line, sizeof(line), lvs)) {
 695                 if (sscanf(line, "%s %s %s %s\n", vg, lv, flags, vg_flags) == 4) {
 696
 697                         /* States: s:suspended a:active S:dropped snapshot I:invalid snapshot */
 698                         if (strlen(vg) == 38 &&                         /* is is a valid UUID ? */
 699                             (flags[4] == 'a' || flags[4] == 's') &&     /* is it active or suspended? */
 700                             vg_flags[5] == 'c') {                       /* is it clustered ? */
 701                                 /* Convert hyphen-separated UUIDs into one */
 702                                 memcpy(&uuid[0], &vg[0], 6);
 703                                 memcpy(&uuid[6], &vg[7], 4);
 704                                 memcpy(&uuid[10], &vg[12], 4);
 705                                 memcpy(&uuid[14], &vg[17], 4);
 706                                 memcpy(&uuid[18], &vg[22], 4);
 707                                 memcpy(&uuid[22], &vg[27], 4);
 708                                 memcpy(&uuid[26], &vg[32], 6);
 709                                 memcpy(&uuid[32], &lv[0], 6);
 710                                 memcpy(&uuid[38], &lv[7], 4);
 711                                 memcpy(&uuid[42], &lv[12], 4);
 712                                 memcpy(&uuid[46], &lv[17], 4);
 713                                 memcpy(&uuid[50], &lv[22], 4);
 714                                 memcpy(&uuid[54], &lv[27], 4);
 715                                 memcpy(&uuid[58], &lv[32], 6);
 716                                 uuid[64] = '\0';
 717
 718                                 DEBUGLOG("getting initial lock for %s\n", uuid);
 719                                 hold_lock(uuid, LKM_CRMODE, LKF_NOQUEUE);
 720                         }
 721                 }
 722         }
 723         if (fclose(lvs))
 724                 DEBUGLOG("lvs fclose failed: %s\n", strerror(errno));
 725         return NULL;
 726 }
 727
 728 static void lvm2_log_fn(int level, const char *file, int line, int dm_errno,
 729                         const char *message)
 730 {
 731
 732         /* Send messages to the normal LVM2 logging system too,
 733            so we get debug output when it's asked for.
 734            We need to NULL the function ptr otherwise it will just call
 735            back into here! */
 736         init_log_fn(NULL);
 737         print_log(level, file, line, dm_errno, "%s", message);
 738         init_log_fn(lvm2_log_fn);
 739
 740         /*
 741          * Ignore non-error messages, but store the latest one for returning
 742          * to the user.
 743          */
 744         if (level != _LOG_ERR && level != _LOG_FATAL)
 745                 return;
 746
 747         strncpy(last_error, message, sizeof(last_error));
 748         last_error[sizeof(last_error)-1] = '\0';
 749 }
 750
 751 /* This checks some basic cluster-LVM configuration stuff */
 752 static void check_config()
 753 {
 754         int locking_type;
 755
 756         locking_type = find_config_tree_int(cmd, "global/locking_type", 1);
 757
 758         if (locking_type == 3) /* compiled-in cluster support */
 759                 return;
 760
 761         if (locking_type == 2) { /* External library, check name */
 762                 const char *libname;
 763
 764                 libname = find_config_tree_str(cmd, "global/locking_library",
 765                                           "");
 766                 if (strstr(libname, "liblvm2clusterlock.so"))
 767                         return;
 768
 769                 log_error("Incorrect LVM locking library specified in lvm.conf, cluster operations may not work.");
 770                 return;
 771         }
 772         log_error("locking_type not set correctly in lvm.conf, cluster operations will not work.");
 773 }
 774
 775 /* Backups up the LVM metadata if it's changed */
 776 void lvm_do_backup(const char *vgname)
 777 {
 778         struct volume_group * vg;
 779         int consistent = 0;
 780
 781         DEBUGLOG("Triggering backup of VG metadata for %s. suspended=%d\n", vgname, suspended);
 782
 783         pthread_mutex_lock(&lvm_lock);
 784
 785         vg = vg_read_internal(cmd, vgname, NULL /*vgid*/, &consistent);
 786
 787         if (vg && consistent)
 788                 check_current_backup(vg);
 789         else
 790                 log_error("Error backing up metadata, can't find VG for group %s", vgname);
 791
 792         vg_release(vg);
 793         dm_pool_empty(cmd->mem);
 794
 795         pthread_mutex_unlock(&lvm_lock);
 796 }
 797
 798 /* Called to initialise the LVM context of the daemon */
 799 int init_lvm(int using_gulm)
 800 {
 801         if (!(cmd = create_toolcontext(1, NULL))) {
 802                 log_error("Failed to allocate command context");
 803                 return 0;
 804         }
 805
 806         if (stored_errno()) {
 807                 destroy_toolcontext(cmd);
 808                 return 0;
 809         }
 810
 811         /* Use LOG_DAEMON for syslog messages instead of LOG_USER */
 812         init_syslog(LOG_DAEMON);
 813         openlog("clvmd", LOG_PID, LOG_DAEMON);
 814         cmd->cmd_line = "clvmd";
 815
 816         /* Check lvm.conf is setup for cluster-LVM */
 817         check_config();
 818
 819         /* Remove any non-LV locks that may have been left around */
 820         if (using_gulm)
 821                 drop_vg_locks();
 822
 823         get_initial_state();
 824
 825         /* Trap log messages so we can pass them back to the user */
 826         init_log_fn(lvm2_log_fn);
 827
 828         return 1;
 829 }
 830
 831 void destroy_lvm(void)
 832 {
 833         if (cmd)
 834                 destroy_toolcontext(cmd);
 835         cmd = NULL;
 836 }