util.c

   1 /*
   2  * mdadm - manage Linux "md" devices aka RAID arrays.
   3  *
   4  * Copyright (C) 2001-2013 Neil Brown <neilb@suse.de>
   5  *
   6  *
   7  *    This program is free software; you can redistribute it and/or modify
   8  *    it under the terms of the GNU General Public License as published by
   9  *    the Free Software Foundation; either version 2 of the License, or
  10  *    (at your option) any later version.
  11  *
  12  *    This program is distributed in the hope that it will be useful,
  13  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *    GNU General Public License for more details.
  16  *
  17  *    You should have received a copy of the GNU General Public License
  18  *    along with this program; if not, write to the Free Software
  19  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  *    Author: Neil Brown
  22  *    Email: <neilb@suse.de>
  23  */
  24
  25 #include        "mdadm.h"
  26 #include        "md_p.h"
  27 #include        <sys/socket.h>
  28 #include        <sys/utsname.h>
  29 #include        <sys/wait.h>
  30 #include        <sys/un.h>
  31 #include        <sys/resource.h>
  32 #include        <sys/vfs.h>
  33 #include        <linux/magic.h>
  34 #include        <poll.h>
  35 #include        <ctype.h>
  36 #include        <dirent.h>
  37 #include        <signal.h>
  38 #include        <dlfcn.h>
  39
  40
  41 /*
  42  * following taken from linux/blkpg.h because they aren't
  43  * anywhere else and it isn't safe to #include linux/ * stuff.
  44  */
  45
  46 #define BLKPG      _IO(0x12,105)
  47
  48 /* The argument structure */
  49 struct blkpg_ioctl_arg {
  50         int op;
  51         int flags;
  52         int datalen;
  53         void *data;
  54 };
  55
  56 /* The subfunctions (for the op field) */
  57 #define BLKPG_ADD_PARTITION     1
  58 #define BLKPG_DEL_PARTITION     2
  59
  60 /* Sizes of name fields. Unused at present. */
  61 #define BLKPG_DEVNAMELTH        64
  62 #define BLKPG_VOLNAMELTH        64
  63
  64 /* The data structure for ADD_PARTITION and DEL_PARTITION */
  65 struct blkpg_partition {
  66         long long start;                /* starting offset in bytes */
  67         long long length;               /* length in bytes */
  68         int pno;                        /* partition number */
  69         char devname[BLKPG_DEVNAMELTH]; /* partition name, like sda5 or c0d1p2,
  70                                            to be used in kernel messages */
  71         char volname[BLKPG_VOLNAMELTH]; /* volume label */
  72 };
  73
  74 #include "part.h"
  75
  76 /* Force a compilation error if condition is true */
  77 #define BUILD_BUG_ON(condition) ((void)BUILD_BUG_ON_ZERO(condition))
  78
  79 /* Force a compilation error if condition is true, but also produce a
  80    result (of value 0 and type size_t), so the expression can be used
  81    e.g. in a structure initializer (or where-ever else comma expressions
  82    aren't permitted). */
  83 #define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:-!!(e); }))
  84
  85 static int is_dlm_hooks_ready = 0;
  86
  87 int dlm_funs_ready(void)
  88 {
  89         return is_dlm_hooks_ready ? 1 : 0;
  90 }
  91
  92 #ifndef MDASSEMBLE
  93 static struct dlm_hooks *dlm_hooks = NULL;
  94 struct dlm_lock_resource *dlm_lock_res = NULL;
  95 static int ast_called = 0;
  96
  97 struct dlm_lock_resource {
  98         dlm_lshandle_t *ls;
  99         struct dlm_lksb lksb;
 100 };
 101
 102 /* Using poll(2) to wait for and dispatch ASTs */
 103 static int poll_for_ast(dlm_lshandle_t ls)
 104 {
 105         struct pollfd pfd;
 106
 107         pfd.fd = dlm_hooks->ls_get_fd(ls);
 108         pfd.events = POLLIN;
 109
 110         while (!ast_called)
 111         {
 112                 if (poll(&pfd, 1, 0) < 0)
 113                 {
 114                         perror("poll");
 115                         return -1;
 116                 }
 117                 dlm_hooks->dispatch(dlm_hooks->ls_get_fd(ls));
 118         }
 119         ast_called = 0;
 120
 121         return 0;
 122 }
 123
 124 static void dlm_ast(void *arg)
 125 {
 126         ast_called = 1;
 127 }
 128
 129 static char *cluster_name = NULL;
 130 /* Create the lockspace, take bitmapXXX locks on all the bitmaps. */
 131 int cluster_get_dlmlock(int *lockid)
 132 {
 133         int ret = -1;
 134         char str[64];
 135         int flags = LKF_NOQUEUE;
 136
 137         ret = get_cluster_name(&cluster_name);
 138         if (ret) {
 139                 pr_err("The md can't get cluster name\n");
 140                 return -1;
 141         }
 142
 143         dlm_lock_res = xmalloc(sizeof(struct dlm_lock_resource));
 144         dlm_lock_res->ls = dlm_hooks->create_lockspace(cluster_name, O_RDWR);
 145         if (!dlm_lock_res->ls) {
 146                 pr_err("%s failed to create lockspace\n", cluster_name);
 147                 return -ENOMEM;
 148         }
 149
 150         snprintf(str, 64, "bitmap%s", cluster_name);
 151         ret = dlm_hooks->ls_lock(dlm_lock_res->ls, LKM_PWMODE, &dlm_lock_res->lksb,
 152                           flags, str, strlen(str), 0, dlm_ast,
 153                           dlm_lock_res, NULL, NULL);
 154         if (ret) {
 155                 pr_err("error %d when get PW mode on lock %s\n", errno, str);
 156                 dlm_hooks->release_lockspace(cluster_name, dlm_lock_res->ls, 1);
 157                 return ret;
 158         }
 159
 160         /* Wait for it to complete */
 161         poll_for_ast(dlm_lock_res->ls);
 162         *lockid = dlm_lock_res->lksb.sb_lkid;
 163
 164         return dlm_lock_res->lksb.sb_status;
 165 }
 166
 167 int cluster_release_dlmlock(int lockid)
 168 {
 169         int ret = -1;
 170
 171         if (!cluster_name)
 172                 return -1;
 173
 174         ret = dlm_hooks->ls_unlock(dlm_lock_res->ls, lockid, 0,
 175                                      &dlm_lock_res->lksb, dlm_lock_res);
 176         if (ret) {
 177                 pr_err("error %d happened when unlock\n", errno);
 178                 /* XXX make sure the lock is unlocked eventually */
 179                 goto out;
 180         }
 181
 182         /* Wait for it to complete */
 183         poll_for_ast(dlm_lock_res->ls);
 184
 185         errno = dlm_lock_res->lksb.sb_status;
 186         if (errno != EUNLOCK) {
 187                 pr_err("error %d happened in ast when unlock lockspace\n", errno);
 188                 /* XXX make sure the lockspace is unlocked eventually */
 189                 goto out;
 190         }
 191
 192         ret = dlm_hooks->release_lockspace(cluster_name, dlm_lock_res->ls, 1);
 193         if (ret) {
 194                 pr_err("error %d happened when release lockspace\n", errno);
 195                 /* XXX make sure the lockspace is released eventually */
 196                 goto out;
 197         }
 198         free(dlm_lock_res);
 199
 200 out:
 201         return ret;
 202 }
 203 #else
 204 int cluster_get_dlmlock(int *lockid)
 205 {
 206         return -1;
 207 }
 208 int cluster_release_dlmlock(int lockid)
 209 {
 210         return -1;
 211 }
 212 #endif
 213
 214 /*
 215  * Parse a 128 bit uuid in 4 integers
 216  * format is 32 hexx nibbles with options :.<space> separator
 217  * If not exactly 32 hex digits are found, return 0
 218  * else return 1
 219  */
 220 int parse_uuid(char *str, int uuid[4])
 221 {
 222         int hit = 0; /* number of Hex digIT */
 223         int i;
 224         char c;
 225         for (i = 0; i < 4; i++)
 226                 uuid[i] = 0;
 227
 228         while ((c = *str++) != 0) {
 229                 int n;
 230                 if (c >= '0' && c <= '9')
 231                         n = c-'0';
 232                 else if (c >= 'a' && c <= 'f')
 233                         n = 10 + c - 'a';
 234                 else if (c >= 'A' && c <= 'F')
 235                         n = 10 + c - 'A';
 236                 else if (strchr(":. -", c))
 237                         continue;
 238                 else return 0;
 239
 240                 if (hit<32) {
 241                         uuid[hit/8] <<= 4;
 242                         uuid[hit/8] += n;
 243                 }
 244                 hit++;
 245         }
 246         if (hit == 32)
 247                 return 1;
 248         return 0;
 249 }
 250
 251 /*
 252  * Get the md version number.
 253  * We use the RAID_VERSION ioctl if it is supported
 254  * If not, but we have a block device with major '9', we assume
 255  * 0.36.0
 256  *
 257  * Return version number as 24 but number - assume version parts
 258  * always < 255
 259  */
 260
 261 int md_get_version(int fd)
 262 {
 263         struct stat stb;
 264         mdu_version_t vers;
 265
 266         if (fstat(fd, &stb)<0)
 267                 return -1;
 268         if ((S_IFMT&stb.st_mode) != S_IFBLK)
 269                 return -1;
 270
 271         if (ioctl(fd, RAID_VERSION, &vers) == 0)
 272                 return  (vers.major*10000) + (vers.minor*100) + vers.patchlevel;
 273         if (errno == EACCES)
 274                 return -1;
 275         if (major(stb.st_rdev) == MD_MAJOR)
 276                 return (3600);
 277         return -1;
 278 }
 279
 280 int get_linux_version()
 281 {
 282         struct utsname name;
 283         char *cp;
 284         int a = 0, b = 0,c = 0;
 285         if (uname(&name) <0)
 286                 return -1;
 287
 288         cp = name.release;
 289         a = strtoul(cp, &cp, 10);
 290         if (*cp == '.')
 291                 b = strtoul(cp+1, &cp, 10);
 292         if (*cp == '.')
 293                 c = strtoul(cp+1, &cp, 10);
 294
 295         return (a*1000000)+(b*1000)+c;
 296 }
 297
 298 #ifndef MDASSEMBLE
 299 int mdadm_version(char *version)
 300 {
 301         int a, b, c;
 302         char *cp;
 303
 304         if (!version)
 305                 version = Version;
 306
 307         cp = strchr(version, '-');
 308         if (!cp || *(cp+1) != ' ' || *(cp+2) != 'v')
 309                 return -1;
 310         cp += 3;
 311         a = strtoul(cp, &cp, 10);
 312         if (*cp != '.')
 313                 return -1;
 314         b = strtoul(cp+1, &cp, 10);
 315         if (*cp == '.')
 316                 c = strtoul(cp+1, &cp, 10);
 317         else
 318                 c = 0;
 319         if (*cp != ' ' && *cp != '-')
 320                 return -1;
 321         return (a*1000000)+(b*1000)+c;
 322 }
 323
 324 unsigned long long parse_size(char *size)
 325 {
 326         /* parse 'size' which should be a number optionally
 327          * followed by 'K', 'M', or 'G'.
 328          * Without a suffix, K is assumed.
 329          * Number returned is in sectors (half-K)
 330          * INVALID_SECTORS returned on error.
 331          */
 332         char *c;
 333         long long s = strtoll(size, &c, 10);
 334         if (s > 0) {
 335                 switch (*c) {
 336                 case 'K':
 337                         c++;
 338                 default:
 339                         s *= 2;
 340                         break;
 341                 case 'M':
 342                         c++;
 343                         s *= 1024 * 2;
 344                         break;
 345                 case 'G':
 346                         c++;
 347                         s *= 1024 * 1024 * 2;
 348                         break;
 349                 case 's': /* sectors */
 350                         c++;
 351                         break;
 352                 }
 353         } else
 354                 s = INVALID_SECTORS;
 355         if (*c)
 356                 s = INVALID_SECTORS;
 357         return s;
 358 }
 359
 360 int parse_layout_10(char *layout)
 361 {
 362         int copies, rv;
 363         char *cp;
 364         /* Parse the layout string for raid10 */
 365         /* 'f', 'o' or 'n' followed by a number <= raid_disks */
 366         if ((layout[0] !=  'n' && layout[0] != 'f' && layout[0] != 'o') ||
 367             (copies = strtoul(layout+1, &cp, 10)) < 1 ||
 368             copies > 200 ||
 369             *cp)
 370                 return -1;
 371         if (layout[0] == 'n')
 372                 rv = 256 + copies;
 373         else if (layout[0] == 'o')
 374                 rv = 0x10000 + (copies<<8) + 1;
 375         else
 376                 rv = 1 + (copies<<8);
 377         return rv;
 378 }
 379
 380 int parse_layout_faulty(char *layout)
 381 {
 382         /* Parse the layout string for 'faulty' */
 383         int ln = strcspn(layout, "0123456789");
 384         char *m = xstrdup(layout);
 385         int mode;
 386         m[ln] = 0;
 387         mode = map_name(faultylayout, m);
 388         if (mode == UnSet)
 389                 return -1;
 390
 391         return mode | (atoi(layout+ln)<< ModeShift);
 392 }
 393
 394 long parse_num(char *num)
 395 {
 396         /* Either return a valid number, or -1 */
 397         char *c;
 398         long rv = strtol(num, &c, 10);
 399         if (rv < 0 || *c || !num[0])
 400                 return -1;
 401         else
 402                 return rv;
 403 }
 404 #endif
 405
 406 int parse_cluster_confirm_arg(char *input, char **devname, int *slot)
 407 {
 408         char *dev;
 409         *slot = strtoul(input, &dev, 10);
 410         if (dev == input || dev[0] != ':')
 411                 return -1;
 412         *devname = dev+1;
 413         return 0;
 414 }
 415
 416 void remove_partitions(int fd)
 417 {
 418         /* remove partitions from this block devices.
 419          * This is used for components added to an array
 420          */
 421 #ifdef BLKPG_DEL_PARTITION
 422         struct blkpg_ioctl_arg a;
 423         struct blkpg_partition p;
 424
 425         a.op = BLKPG_DEL_PARTITION;
 426         a.data = (void*)&p;
 427         a.datalen = sizeof(p);
 428         a.flags = 0;
 429         memset(a.data, 0, a.datalen);
 430         for (p.pno = 0; p.pno < 16; p.pno++)
 431                 ioctl(fd, BLKPG, &a);
 432 #endif
 433 }
 434
 435 int test_partition(int fd)
 436 {
 437         /* Check if fd is a whole-disk or a partition.
 438          * BLKPG will return EINVAL on a partition, and BLKPG_DEL_PARTITION
 439          * will return ENXIO on an invalid partition number.
 440          */
 441         struct blkpg_ioctl_arg a;
 442         struct blkpg_partition p;
 443         a.op = BLKPG_DEL_PARTITION;
 444         a.data = (void*)&p;
 445         a.datalen = sizeof(p);
 446         a.flags = 0;
 447         memset(a.data, 0, a.datalen);
 448         p.pno = 1<<30;
 449         if (ioctl(fd, BLKPG, &a) == 0)
 450                 /* Very unlikely, but not a partition */
 451                 return 0;
 452         if (errno == ENXIO || errno == ENOTTY)
 453                 /* not a partition */
 454                 return 0;
 455
 456         return 1;
 457 }
 458
 459 int test_partition_from_id(dev_t id)
 460 {
 461         char buf[20];
 462         int fd, rv;
 463
 464         sprintf(buf, "%d:%d", major(id), minor(id));
 465         fd = dev_open(buf, O_RDONLY);
 466         if (fd < 0)
 467                 return -1;
 468         rv = test_partition(fd);
 469         close(fd);
 470         return rv;
 471 }
 472
 473 int enough(int level, int raid_disks, int layout, int clean, char *avail)
 474 {
 475         int copies, first;
 476         int i;
 477         int avail_disks = 0;
 478
 479         for (i = 0; i < raid_disks; i++)
 480                 avail_disks += !!avail[i];
 481
 482         switch (level) {
 483         case 10:
 484                 /* This is the tricky one - we need to check
 485                  * which actual disks are present.
 486                  */
 487                 copies = (layout&255)* ((layout>>8) & 255);
 488                 first = 0;
 489                 do {
 490                         /* there must be one of the 'copies' form 'first' */
 491                         int n = copies;
 492                         int cnt = 0;
 493                         int this = first;
 494                         while (n--) {
 495                                 if (avail[this])
 496                                         cnt++;
 497                                 this = (this+1) % raid_disks;
 498                         }
 499                         if (cnt == 0)
 500                                 return 0;
 501                         first = (first+(layout&255)) % raid_disks;
 502                 } while (first != 0);
 503                 return 1;
 504
 505         case LEVEL_MULTIPATH:
 506                 return avail_disks>= 1;
 507         case LEVEL_LINEAR:
 508         case 0:
 509                 return avail_disks == raid_disks;
 510         case 1:
 511                 return avail_disks >= 1;
 512         case 4:
 513                 if (avail_disks == raid_disks - 1 &&
 514                     !avail[raid_disks - 1])
 515                         /* If just the parity device is missing, then we
 516                          * have enough, even if not clean
 517                          */
 518                         return 1;
 519                 /* FALL THROUGH */
 520         case 5:
 521                 if (clean)
 522                         return avail_disks >= raid_disks-1;
 523                 else
 524                         return avail_disks >= raid_disks;
 525         case 6:
 526                 if (clean)
 527                         return avail_disks >= raid_disks-2;
 528                 else
 529                         return avail_disks >= raid_disks;
 530         default:
 531                 return 0;
 532         }
 533 }
 534
 535 int enough_fd(int fd)
 536 {
 537         struct mdu_array_info_s array;
 538         struct mdu_disk_info_s disk;
 539         int i, rv;
 540         char *avail;
 541
 542         if (ioctl(fd, GET_ARRAY_INFO, &array) != 0 ||
 543             array.raid_disks <= 0)
 544                 return 0;
 545         avail = xcalloc(array.raid_disks, 1);
 546         for (i = 0; i < MAX_DISKS && array.nr_disks > 0; i++) {
 547                 disk.number = i;
 548                 if (ioctl(fd, GET_DISK_INFO, &disk) != 0)
 549                         continue;
 550                 if (disk.major == 0 && disk.minor == 0)
 551                         continue;
 552                 array.nr_disks--;
 553
 554                 if (! (disk.state & (1<<MD_DISK_SYNC)))
 555                         continue;
 556                 if (disk.raid_disk < 0 || disk.raid_disk >= array.raid_disks)
 557                         continue;
 558                 avail[disk.raid_disk] = 1;
 559         }
 560         /* This is used on an active array, so assume it is clean */
 561         rv = enough(array.level, array.raid_disks, array.layout,
 562                     1, avail);
 563         free(avail);
 564         return rv;
 565 }
 566
 567 const int uuid_zero[4] = { 0, 0, 0, 0 };
 568
 569 int same_uuid(int a[4], int b[4], int swapuuid)
 570 {
 571         if (swapuuid) {
 572                 /* parse uuids are hostendian.
 573                  * uuid's from some superblocks are big-ending
 574                  * if there is a difference, we need to swap..
 575                  */
 576                 unsigned char *ac = (unsigned char *)a;
 577                 unsigned char *bc = (unsigned char *)b;
 578                 int i;
 579                 for (i = 0; i < 16; i += 4) {
 580                         if (ac[i+0] != bc[i+3] ||
 581                             ac[i+1] != bc[i+2] ||
 582                             ac[i+2] != bc[i+1] ||
 583                             ac[i+3] != bc[i+0])
 584                                 return 0;
 585                 }
 586                 return 1;
 587         } else {
 588                 if (a[0]==b[0] &&
 589                     a[1]==b[1] &&
 590                     a[2]==b[2] &&
 591                     a[3]==b[3])
 592                         return 1;
 593                 return 0;
 594         }
 595 }
 596
 597 void copy_uuid(void *a, int b[4], int swapuuid)
 598 {
 599         if (swapuuid) {
 600                 /* parse uuids are hostendian.
 601                  * uuid's from some superblocks are big-ending
 602                  * if there is a difference, we need to swap..
 603                  */
 604                 unsigned char *ac = (unsigned char *)a;
 605                 unsigned char *bc = (unsigned char *)b;
 606                 int i;
 607                 for (i = 0; i < 16; i += 4) {
 608                         ac[i+0] = bc[i+3];
 609                         ac[i+1] = bc[i+2];
 610                         ac[i+2] = bc[i+1];
 611                         ac[i+3] = bc[i+0];
 612                 }
 613         } else
 614                 memcpy(a, b, 16);
 615 }
 616
 617 char *__fname_from_uuid(int id[4], int swap, char *buf, char sep)
 618 {
 619         int i, j;
 620         char uuid[16];
 621         char *c = buf;
 622         strcpy(c, "UUID-");
 623         c += strlen(c);
 624         copy_uuid(uuid, id, swap);
 625         for (i = 0; i < 4; i++) {
 626                 if (i)
 627                         *c++ = sep;
 628                 for (j = 3; j >= 0; j--) {
 629                         sprintf(c,"%02x", (unsigned char) uuid[j+4*i]);
 630                         c+= 2;
 631                 }
 632         }
 633         return buf;
 634
 635 }
 636
 637 char *fname_from_uuid(struct supertype *st, struct mdinfo *info, char *buf, char sep)
 638 {
 639         // dirty hack to work around an issue with super1 superblocks...
 640         // super1 superblocks need swapuuid set in order for assembly to
 641         // work, but can't have it set if we want this printout to match
 642         // all the other uuid printouts in super1.c, so we force swapuuid
 643         // to 1 to make our printout match the rest of super1
 644         return __fname_from_uuid(info->uuid, (st->ss == &super1) ? 1 : st->ss->swapuuid, buf, sep);
 645 }
 646
 647 #ifndef MDASSEMBLE
 648 int check_ext2(int fd, char *name)
 649 {
 650         /*
 651          * Check for an ext2fs file system.
 652          * Superblock is always 1K at 1K offset
 653          *
 654          * s_magic is le16 at 56 == 0xEF53
 655          * report mtime - le32 at 44
 656          * blocks - le32 at 4
 657          * logblksize - le32 at 24
 658          */
 659         unsigned char sb[1024];
 660         time_t mtime;
 661         unsigned long long size;
 662         int bsize;
 663         if (lseek(fd, 1024,0)!= 1024)
 664                 return 0;
 665         if (read(fd, sb, 1024)!= 1024)
 666                 return 0;
 667         if (sb[56] != 0x53 || sb[57] != 0xef)
 668                 return 0;
 669
 670         mtime = sb[44]|(sb[45]|(sb[46]|sb[47]<<8)<<8)<<8;
 671         bsize = sb[24]|(sb[25]|(sb[26]|sb[27]<<8)<<8)<<8;
 672         size = sb[4]|(sb[5]|(sb[6]|sb[7]<<8)<<8)<<8;
 673         size <<= bsize;
 674         pr_err("%s appears to contain an ext2fs file system\n",
 675                 name);
 676         cont_err("size=%lluK  mtime=%s", size, ctime(&mtime));
 677         return 1;
 678 }
 679
 680 int check_reiser(int fd, char *name)
 681 {
 682         /*
 683          * superblock is at 64K
 684          * size is 1024;
 685          * Magic string "ReIsErFs" or "ReIsEr2Fs" at 52
 686          *
 687          */
 688         unsigned char sb[1024];
 689         unsigned long long size;
 690         if (lseek(fd, 64*1024, 0) != 64*1024)
 691                 return 0;
 692         if (read(fd, sb, 1024) != 1024)
 693                 return 0;
 694         if (strncmp((char*)sb+52, "ReIsErFs",8) != 0 &&
 695             strncmp((char*)sb+52, "ReIsEr2Fs",9) != 0)
 696                 return 0;
 697         pr_err("%s appears to contain a reiserfs file system\n",name);
 698         size = sb[0]|(sb[1]|(sb[2]|sb[3]<<8)<<8)<<8;
 699         cont_err("size = %lluK\n", size*4);
 700
 701         return 1;
 702 }
 703
 704 int check_raid(int fd, char *name)
 705 {
 706         struct mdinfo info;
 707         time_t crtime;
 708         char *level;
 709         struct supertype *st = guess_super(fd);
 710
 711         if (!st)
 712                 return 0;
 713         st->ss->load_super(st, fd, name);
 714         /* Looks like a raid array .. */
 715         pr_err("%s appears to be part of a raid array:\n",
 716                 name);
 717         st->ss->getinfo_super(st, &info, NULL);
 718         st->ss->free_super(st);
 719         crtime = info.array.ctime;
 720         level = map_num(pers, info.array.level);
 721         if (!level) level = "-unknown-";
 722         cont_err("level=%s devices=%d ctime=%s",
 723                  level, info.array.raid_disks, ctime(&crtime));
 724         return 1;
 725 }
 726
 727 int ask(char *mesg)
 728 {
 729         char *add = "";
 730         int i;
 731         for (i = 0; i < 5; i++) {
 732                 char buf[100];
 733                 fprintf(stderr, "%s%s", mesg, add);
 734                 fflush(stderr);
 735                 if (fgets(buf, 100, stdin)==NULL)
 736                         return 0;
 737                 if (buf[0]=='y' || buf[0]=='Y')
 738                         return 1;
 739                 if (buf[0]=='n' || buf[0]=='N')
 740                         return 0;
 741                 add = "(y/n) ";
 742         }
 743         pr_err("assuming 'no'\n");
 744         return 0;
 745 }
 746 #endif /* MDASSEMBLE */
 747
 748 int is_standard(char *dev, int *nump)
 749 {
 750         /* tests if dev is a "standard" md dev name.
 751          * i.e if the last component is "/dNN" or "/mdNN",
 752          * where NN is a string of digits
 753          * Returns 1 if a partitionable standard,
 754          *   -1 if non-partitonable,
 755          *   0 if not a standard name.
 756          */
 757         char *d = strrchr(dev, '/');
 758         int type = 0;
 759         int num;
 760         if (!d)
 761                 return 0;
 762         if (strncmp(d, "/d",2) == 0)
 763                 d += 2, type = 1; /* /dev/md/dN{pM} */
 764         else if (strncmp(d, "/md_d", 5) == 0)
 765                 d += 5, type = 1; /* /dev/md_dN{pM} */
 766         else if (strncmp(d, "/md", 3) == 0)
 767                 d += 3, type = -1; /* /dev/mdN */
 768         else if (d-dev > 3 && strncmp(d-2, "md/", 3) == 0)
 769                 d += 1, type = -1; /* /dev/md/N */
 770         else
 771                 return 0;
 772         if (!*d)
 773                 return 0;
 774         num = atoi(d);
 775         while (isdigit(*d))
 776                 d++;
 777         if (*d)
 778                 return 0;
 779         if (nump) *nump = num;
 780
 781         return type;
 782 }
 783
 784 unsigned long calc_csum(void *super, int bytes)
 785 {
 786         unsigned long long newcsum = 0;
 787         int i;
 788         unsigned int csum;
 789         unsigned int *superc = (unsigned int*) super;
 790
 791         for(i = 0; i < bytes/4; i++)
 792                 newcsum += superc[i];
 793         csum = (newcsum& 0xffffffff) + (newcsum>>32);
 794 #ifdef __alpha__
 795 /* The in-kernel checksum calculation is always 16bit on
 796  * the alpha, though it is 32 bit on i386...
 797  * I wonder what it is elsewhere... (it uses an API in
 798  * a way that it shouldn't).
 799  */
 800         csum = (csum & 0xffff) + (csum >> 16);
 801         csum = (csum & 0xffff) + (csum >> 16);
 802 #endif
 803         return csum;
 804 }
 805
 806 #ifndef MDASSEMBLE
 807 char *human_size(long long bytes)
 808 {
 809         static char buf[30];
 810
 811         /* We convert bytes to either centi-M{ega,ibi}bytes or
 812          * centi-G{igi,ibi}bytes, with appropriate rounding,
 813          * and then print 1/100th of those as a decimal.
 814          * We allow upto 2048Megabytes before converting to
 815          * gigabytes, as that shows more precision and isn't
 816          * too large a number.
 817          * Terabytes are not yet handled.
 818          */
 819
 820         if (bytes < 5000*1024)
 821                 buf[0] = 0;
 822         else if (bytes < 2*1024LL*1024LL*1024LL) {
 823                 long cMiB = (bytes * 200LL / (1LL<<20) + 1) / 2;
 824                 long cMB  = (bytes / ( 1000000LL / 200LL ) +1) /2;
 825                 snprintf(buf, sizeof(buf), " (%ld.%02ld MiB %ld.%02ld MB)",
 826                         cMiB/100 , cMiB % 100,
 827                         cMB/100, cMB % 100);
 828         } else {
 829                 long cGiB = (bytes * 200LL / (1LL<<30) +1) / 2;
 830                 long cGB  = (bytes / (1000000000LL/200LL ) +1) /2;
 831                 snprintf(buf, sizeof(buf), " (%ld.%02ld GiB %ld.%02ld GB)",
 832                         cGiB/100 , cGiB % 100,
 833                         cGB/100, cGB % 100);
 834         }
 835         return buf;
 836 }
 837
 838 char *human_size_brief(long long bytes, int prefix)
 839 {
 840         static char buf[30];
 841
 842         /* We convert bytes to either centi-M{ega,ibi}bytes or
 843          * centi-G{igi,ibi}bytes, with appropriate rounding,
 844          * and then print 1/100th of those as a decimal.
 845          * We allow upto 2048Megabytes before converting to
 846          * gigabytes, as that shows more precision and isn't
 847          * too large a number.
 848          * Terabytes are not yet handled.
 849          *
 850          * If prefix == IEC, we mean prefixes like kibi,mebi,gibi etc.
 851          * If prefix == JEDEC, we mean prefixes like kilo,mega,giga etc.
 852          */
 853
 854         if (bytes < 5000*1024)
 855                 buf[0] = 0;
 856         else if (prefix == IEC) {
 857                 if (bytes < 2*1024LL*1024LL*1024LL) {
 858                         long cMiB = (bytes * 200LL / (1LL<<20) +1) /2;
 859                         snprintf(buf, sizeof(buf), "%ld.%02ldMiB",
 860                                 cMiB/100 , cMiB % 100);
 861                 } else {
 862                         long cGiB = (bytes * 200LL / (1LL<<30) +1) /2;
 863                         snprintf(buf, sizeof(buf), "%ld.%02ldGiB",
 864                                         cGiB/100 , cGiB % 100);
 865                 }
 866         }
 867         else if (prefix == JEDEC) {
 868                 if (bytes < 2*1024LL*1024LL*1024LL) {
 869                         long cMB  = (bytes / ( 1000000LL / 200LL ) +1) /2;
 870                         snprintf(buf, sizeof(buf), "%ld.%02ldMB",
 871                                         cMB/100, cMB % 100);
 872                 } else {
 873                         long cGB  = (bytes / (1000000000LL/200LL ) +1) /2;
 874                         snprintf(buf, sizeof(buf), "%ld.%02ldGB",
 875                                         cGB/100 , cGB % 100);
 876                 }
 877         }
 878         else
 879                 buf[0] = 0;
 880
 881         return buf;
 882 }
 883
 884 void print_r10_layout(int layout)
 885 {
 886         int near = layout & 255;
 887         int far = (layout >> 8) & 255;
 888         int offset = (layout&0x10000);
 889         char *sep = "";
 890
 891         if (near != 1) {
 892                 printf("%s near=%d", sep, near);
 893                 sep = ",";
 894         }
 895         if (far != 1)
 896                 printf("%s %s=%d", sep, offset?"offset":"far", far);
 897         if (near*far == 1)
 898                 printf("NO REDUNDANCY");
 899 }
 900 #endif
 901
 902 unsigned long long calc_array_size(int level, int raid_disks, int layout,
 903                                    int chunksize, unsigned long long devsize)
 904 {
 905         if (level == 1)
 906                 return devsize;
 907         devsize &= ~(unsigned long long)((chunksize>>9)-1);
 908         return get_data_disks(level, layout, raid_disks) * devsize;
 909 }
 910
 911 int get_data_disks(int level, int layout, int raid_disks)
 912 {
 913         int data_disks = 0;
 914         switch (level) {
 915         case 0: data_disks = raid_disks;
 916                 break;
 917         case 1: data_disks = 1;
 918                 break;
 919         case 4:
 920         case 5: data_disks = raid_disks - 1;
 921                 break;
 922         case 6: data_disks = raid_disks - 2;
 923                 break;
 924         case 10: data_disks = raid_disks / (layout & 255) / ((layout>>8)&255);
 925                 break;
 926         }
 927
 928         return data_disks;
 929 }
 930
 931 dev_t devnm2devid(char *devnm)
 932 {
 933         /* First look in /sys/block/$DEVNM/dev for %d:%d
 934          * If that fails, try parsing out a number
 935          */
 936         char path[100];
 937         char *ep;
 938         int fd;
 939         int mjr,mnr;
 940
 941         sprintf(path, "/sys/block/%s/dev", devnm);
 942         fd = open(path, O_RDONLY);
 943         if (fd >= 0) {
 944                 char buf[20];
 945                 int n = read(fd, buf, sizeof(buf));
 946                 close(fd);
 947                 if (n > 0)
 948                         buf[n] = 0;
 949                 if (n > 0 && sscanf(buf, "%d:%d\n", &mjr, &mnr) == 2)
 950                         return makedev(mjr, mnr);
 951         }
 952         if (strncmp(devnm, "md_d", 4) == 0 &&
 953             isdigit(devnm[4]) &&
 954             (mnr = strtoul(devnm+4, &ep, 10)) >= 0 &&
 955             ep > devnm && *ep == 0)
 956                 return makedev(get_mdp_major(), mnr << MdpMinorShift);
 957
 958         if (strncmp(devnm, "md", 2) == 0 &&
 959             isdigit(devnm[2]) &&
 960             (mnr = strtoul(devnm+2, &ep, 10)) >= 0 &&
 961             ep > devnm && *ep == 0)
 962                 return makedev(MD_MAJOR, mnr);
 963
 964         return 0;
 965 }
 966
 967 #if !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO)
 968 char *get_md_name(char *devnm)
 969 {
 970         /* find /dev/md%d or /dev/md/%d or make a device /dev/.tmp.md%d */
 971         /* if dev < 0, want /dev/md/d%d or find mdp in /proc/devices ... */
 972
 973         static char devname[50];
 974         struct stat stb;
 975         dev_t rdev = devnm2devid(devnm);
 976         char *dn;
 977
 978         if (rdev == 0)
 979                 return 0;
 980         if (strncmp(devnm, "md_", 3) == 0) {
 981                 snprintf(devname, sizeof(devname), "/dev/md/%s",
 982                         devnm + 3);
 983                 if (stat(devname, &stb) == 0
 984                     && (S_IFMT&stb.st_mode) == S_IFBLK
 985                     && (stb.st_rdev == rdev))
 986                         return devname;
 987         }
 988         snprintf(devname, sizeof(devname), "/dev/%s", devnm);
 989         if (stat(devname, &stb) == 0
 990             && (S_IFMT&stb.st_mode) == S_IFBLK
 991             && (stb.st_rdev == rdev))
 992                 return devname;
 993
 994         snprintf(devname, sizeof(devname), "/dev/md/%s", devnm+2);
 995         if (stat(devname, &stb) == 0
 996             && (S_IFMT&stb.st_mode) == S_IFBLK
 997             && (stb.st_rdev == rdev))
 998                 return devname;
 999
1000         dn = map_dev(major(rdev), minor(rdev), 0);
1001         if (dn)
1002                 return dn;
1003         snprintf(devname, sizeof(devname), "/dev/.tmp.%s", devnm);
1004         if (mknod(devname, S_IFBLK | 0600, rdev) == -1)
1005                 if (errno != EEXIST)
1006                         return NULL;
1007
1008         if (stat(devname, &stb) == 0
1009             && (S_IFMT&stb.st_mode) == S_IFBLK
1010             && (stb.st_rdev == rdev))
1011                 return devname;
1012         unlink(devname);
1013         return NULL;
1014 }
1015
1016 void put_md_name(char *name)
1017 {
1018         if (strncmp(name, "/dev/.tmp.md", 12) == 0)
1019                 unlink(name);
1020 }
1021 #endif /* !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO) */
1022
1023 int get_maj_min(char *dev, int *major, int *minor)
1024 {
1025         char *e;
1026         *major = strtoul(dev, &e, 0);
1027         return (e > dev && *e == ':' && e[1] &&
1028                 (*minor = strtoul(e+1, &e, 0)) >= 0 &&
1029                 *e == 0);
1030 }
1031
1032 int dev_open(char *dev, int flags)
1033 {
1034         /* like 'open', but if 'dev' matches %d:%d, create a temp
1035          * block device and open that
1036          */
1037         int fd = -1;
1038         char devname[32];
1039         int major;
1040         int minor;
1041
1042         if (!dev) return -1;
1043         flags |= O_DIRECT;
1044
1045         if (get_maj_min(dev, &major, &minor)) {
1046                 snprintf(devname, sizeof(devname), "/dev/.tmp.md.%d:%d:%d",
1047                          (int)getpid(), major, minor);
1048                 if (mknod(devname, S_IFBLK|0600, makedev(major, minor)) == 0) {
1049                         fd = open(devname, flags);
1050                         unlink(devname);
1051                 }
1052                 if (fd < 0) {
1053                         /* Try /tmp as /dev appear to be read-only */
1054                         snprintf(devname, sizeof(devname), "/tmp/.tmp.md.%d:%d:%d",
1055                                  (int)getpid(), major, minor);
1056                         if (mknod(devname, S_IFBLK|0600, makedev(major, minor)) == 0) {
1057                                 fd = open(devname, flags);
1058                                 unlink(devname);
1059                         }
1060                 }
1061         } else
1062                 fd = open(dev, flags);
1063         return fd;
1064 }
1065
1066 int open_dev_flags(char *devnm, int flags)
1067 {
1068         dev_t devid;
1069         char buf[20];
1070
1071         devid = devnm2devid(devnm);
1072         sprintf(buf, "%d:%d", major(devid), minor(devid));
1073         return dev_open(buf, flags);
1074 }
1075
1076 int open_dev(char *devnm)
1077 {
1078         return open_dev_flags(devnm, O_RDONLY);
1079 }
1080
1081 int open_dev_excl(char *devnm)
1082 {
1083         char buf[20];
1084         int i;
1085         int flags = O_RDWR;
1086         dev_t devid = devnm2devid(devnm);
1087         long delay = 1000;
1088
1089         sprintf(buf, "%d:%d", major(devid), minor(devid));
1090         for (i = 0 ; i < 25 ; i++) {
1091                 int fd = dev_open(buf, flags|O_EXCL);
1092                 if (fd >= 0)
1093                         return fd;
1094                 if (errno == EACCES && flags == O_RDWR) {
1095                         flags = O_RDONLY;
1096                         continue;
1097                 }
1098                 if (errno != EBUSY)
1099                         return fd;
1100                 usleep(delay);
1101                 if (delay < 200000)
1102                         delay *= 2;
1103         }
1104         return -1;
1105 }
1106
1107 int same_dev(char *one, char *two)
1108 {
1109         struct stat st1, st2;
1110         if (stat(one, &st1) != 0)
1111                 return 0;
1112         if (stat(two, &st2) != 0)
1113                 return 0;
1114         if ((st1.st_mode & S_IFMT) != S_IFBLK)
1115                 return 0;
1116         if ((st2.st_mode & S_IFMT) != S_IFBLK)
1117                 return 0;
1118         return st1.st_rdev == st2.st_rdev;
1119 }
1120
1121 void wait_for(char *dev, int fd)
1122 {
1123         int i;
1124         struct stat stb_want;
1125         long delay = 1000;
1126
1127         if (fstat(fd, &stb_want) != 0 ||
1128             (stb_want.st_mode & S_IFMT) != S_IFBLK)
1129                 return;
1130
1131         for (i = 0 ; i < 25 ; i++) {
1132                 struct stat stb;
1133                 if (stat(dev, &stb) == 0 &&
1134                     (stb.st_mode & S_IFMT) == S_IFBLK &&
1135                     (stb.st_rdev == stb_want.st_rdev))
1136                         return;
1137                 usleep(delay);
1138                 if (delay < 200000)
1139                         delay *= 2;
1140         }
1141         if (i == 25)
1142                 dprintf("timeout waiting for %s\n", dev);
1143 }
1144
1145 struct superswitch *superlist[] =
1146 {
1147         &super0, &super1,
1148         &super_ddf, &super_imsm,
1149         &mbr, &gpt,
1150         NULL };
1151
1152 #if !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO)
1153
1154 struct supertype *super_by_fd(int fd, char **subarrayp)
1155 {
1156         mdu_array_info_t array;
1157         int vers;
1158         int minor;
1159         struct supertype *st = NULL;
1160         struct mdinfo *sra;
1161         char *verstr;
1162         char version[20];
1163         int i;
1164         char *subarray = NULL;
1165         char container[32] = "";
1166
1167         sra = sysfs_read(fd, NULL, GET_VERSION);
1168
1169         if (sra) {
1170                 vers = sra->array.major_version;
1171                 minor = sra->array.minor_version;
1172                 verstr = sra->text_version;
1173         } else {
1174                 if (ioctl(fd, GET_ARRAY_INFO, &array))
1175                         array.major_version = array.minor_version = 0;
1176                 vers = array.major_version;
1177                 minor = array.minor_version;
1178                 verstr = "";
1179         }
1180
1181         if (vers != -1) {
1182                 sprintf(version, "%d.%d", vers, minor);
1183                 verstr = version;
1184         }
1185         if (minor == -2 && is_subarray(verstr)) {
1186                 char *dev = verstr+1;
1187
1188                 subarray = strchr(dev, '/');
1189                 if (subarray) {
1190                         *subarray++ = '\0';
1191                         subarray = xstrdup(subarray);
1192                 }
1193                 strcpy(container, dev);
1194                 sysfs_free(sra);
1195                 sra = sysfs_read(-1, container, GET_VERSION);
1196                 if (sra && sra->text_version[0])
1197                         verstr = sra->text_version;
1198                 else
1199                         verstr = "-no-metadata-";
1200         }
1201
1202         for (i = 0; st == NULL && superlist[i] ; i++)
1203                 st = superlist[i]->match_metadata_desc(verstr);
1204
1205         sysfs_free(sra);
1206         if (st) {
1207                 st->sb = NULL;
1208                 if (subarrayp)
1209                         *subarrayp = subarray;
1210                 strcpy(st->container_devnm, container);
1211                 strcpy(st->devnm, fd2devnm(fd));
1212         } else
1213                 free(subarray);
1214
1215         return st;
1216 }
1217 #endif /* !defined(MDASSEMBLE) || defined(MDASSEMBLE) && defined(MDASSEMBLE_AUTO) */
1218
1219 int dev_size_from_id(dev_t id, unsigned long long *size)
1220 {
1221         char buf[20];
1222         int fd;
1223
1224         sprintf(buf, "%d:%d", major(id), minor(id));
1225         fd = dev_open(buf, O_RDONLY);
1226         if (fd < 0)
1227                 return 0;
1228         if (get_dev_size(fd, NULL, size)) {
1229                 close(fd);
1230                 return 1;
1231         }
1232         close(fd);
1233         return 0;
1234 }
1235
1236 struct supertype *dup_super(struct supertype *orig)
1237 {
1238         struct supertype *st;
1239
1240         if (!orig)
1241                 return orig;
1242         st = xcalloc(1, sizeof(*st));
1243         st->ss = orig->ss;
1244         st->max_devs = orig->max_devs;
1245         st->minor_version = orig->minor_version;
1246         st->ignore_hw_compat = orig->ignore_hw_compat;
1247         st->data_offset = orig->data_offset;
1248         st->sb = NULL;
1249         st->info = NULL;
1250         return st;
1251 }
1252
1253 struct supertype *guess_super_type(int fd, enum guess_types guess_type)
1254 {
1255         /* try each load_super to find the best match,
1256          * and return the best superswitch
1257          */
1258         struct superswitch  *ss;
1259         struct supertype *st;
1260         unsigned int besttime = 0;
1261         int bestsuper = -1;
1262         int i;
1263
1264         st = xcalloc(1, sizeof(*st));
1265         st->container_devnm[0] = 0;
1266
1267         for (i = 0 ; superlist[i]; i++) {
1268                 int rv;
1269                 ss = superlist[i];
1270                 if (guess_type == guess_array && ss->add_to_super == NULL)
1271                         continue;
1272                 if (guess_type == guess_partitions && ss->add_to_super != NULL)
1273                         continue;
1274                 memset(st, 0, sizeof(*st));
1275                 st->ignore_hw_compat = 1;
1276                 rv = ss->load_super(st, fd, NULL);
1277                 if (rv == 0) {
1278                         struct mdinfo info;
1279                         st->ss->getinfo_super(st, &info, NULL);
1280                         if (bestsuper == -1 ||
1281                             besttime < info.array.ctime) {
1282                                 bestsuper = i;
1283                                 besttime = info.array.ctime;
1284                         }
1285                         ss->free_super(st);
1286                 }
1287         }
1288         if (bestsuper != -1) {
1289                 int rv;
1290                 memset(st, 0, sizeof(*st));
1291                 st->ignore_hw_compat = 1;
1292                 rv = superlist[bestsuper]->load_super(st, fd, NULL);
1293                 if (rv == 0) {
1294                         superlist[bestsuper]->free_super(st);
1295                         return st;
1296                 }
1297         }
1298         free(st);
1299         return NULL;
1300 }
1301
1302 /* Return size of device in bytes */
1303 int get_dev_size(int fd, char *dname, unsigned long long *sizep)
1304 {
1305         unsigned long long ldsize;
1306         struct stat st;
1307
1308         if (fstat(fd, &st) != -1 && S_ISREG(st.st_mode))
1309                 ldsize = (unsigned long long)st.st_size;
1310         else
1311 #ifdef BLKGETSIZE64
1312         if (ioctl(fd, BLKGETSIZE64, &ldsize) != 0)
1313 #endif
1314         {
1315                 unsigned long dsize;
1316                 if (ioctl(fd, BLKGETSIZE, &dsize) == 0) {
1317                         ldsize = dsize;
1318                         ldsize <<= 9;
1319                 } else {
1320                         if (dname)
1321                                 pr_err("Cannot get size of %s: %s\b",
1322                                         dname, strerror(errno));
1323                         return 0;
1324                 }
1325         }
1326         *sizep = ldsize;
1327         return 1;
1328 }
1329
1330 /* Return true if this can only be a container, not a member device.
1331  * i.e. is and md device and size is zero
1332  */
1333 int must_be_container(int fd)
1334 {
1335         unsigned long long size;
1336         if (md_get_version(fd) < 0)
1337                 return 0;
1338         if (get_dev_size(fd, NULL, &size) == 0)
1339                 return 1;
1340         if (size == 0)
1341                 return 1;
1342         return 0;
1343 }
1344
1345 /* Sets endofpart parameter to the last block used by the last GPT partition on the device.
1346  * Returns: 1 if successful
1347  *         -1 for unknown partition type
1348  *          0 for other errors
1349  */
1350 static int get_gpt_last_partition_end(int fd, unsigned long long *endofpart)
1351 {
1352         struct GPT gpt;
1353         unsigned char empty_gpt_entry[16]= {0};
1354         struct GPT_part_entry *part;
1355         char buf[512];
1356         unsigned long long curr_part_end;
1357         unsigned all_partitions, entry_size;
1358         unsigned part_nr;
1359
1360         *endofpart = 0;
1361
1362         BUILD_BUG_ON(sizeof(gpt) != 512);
1363         /* skip protective MBR */
1364         lseek(fd, 512, SEEK_SET);
1365         /* read GPT header */
1366         if (read(fd, &gpt, 512) != 512)
1367                 return 0;
1368
1369         /* get the number of partition entries and the entry size */
1370         all_partitions = __le32_to_cpu(gpt.part_cnt);
1371         entry_size = __le32_to_cpu(gpt.part_size);
1372
1373         /* Check GPT signature*/
1374         if (gpt.magic != GPT_SIGNATURE_MAGIC)
1375                 return -1;
1376
1377         /* sanity checks */
1378         if (all_partitions > 1024 ||
1379             entry_size > sizeof(buf))
1380                 return -1;
1381
1382         part = (struct GPT_part_entry *)buf;
1383
1384         for (part_nr = 0; part_nr < all_partitions; part_nr++) {
1385                 /* read partition entry */
1386                 if (read(fd, buf, entry_size) != (ssize_t)entry_size)
1387                         return 0;
1388
1389                 /* is this valid partition? */
1390                 if (memcmp(part->type_guid, empty_gpt_entry, 16) != 0) {
1391                         /* check the last lba for the current partition */
1392                         curr_part_end = __le64_to_cpu(part->ending_lba);
1393                         if (curr_part_end > *endofpart)
1394                                 *endofpart = curr_part_end;
1395                 }
1396
1397         }
1398         return 1;
1399 }
1400
1401 /* Sets endofpart parameter to the last block used by the last partition on the device.
1402  * Returns: 1 if successful
1403  *         -1 for unknown partition type
1404  *          0 for other errors
1405  */
1406 static int get_last_partition_end(int fd, unsigned long long *endofpart)
1407 {
1408         struct MBR boot_sect;
1409         struct MBR_part_record *part;
1410         unsigned long long curr_part_end;
1411         unsigned part_nr;
1412         int retval = 0;
1413
1414         *endofpart = 0;
1415
1416         BUILD_BUG_ON(sizeof(boot_sect) != 512);
1417         /* read MBR */
1418         lseek(fd, 0, 0);
1419         if (read(fd, &boot_sect, 512) != 512)
1420                 goto abort;
1421
1422         /* check MBP signature */
1423         if (boot_sect.magic == MBR_SIGNATURE_MAGIC) {
1424                 retval = 1;
1425                 /* found the correct signature */
1426                 part = boot_sect.parts;
1427
1428                 for (part_nr = 0; part_nr < MBR_PARTITIONS; part_nr++) {
1429                         /* check for GPT type */
1430                         if (part->part_type == MBR_GPT_PARTITION_TYPE) {
1431                                 retval = get_gpt_last_partition_end(fd, endofpart);
1432                                 break;
1433                         }
1434                         /* check the last used lba for the current partition  */
1435                         curr_part_end = __le32_to_cpu(part->first_sect_lba) +
1436                                 __le32_to_cpu(part->blocks_num);
1437                         if (curr_part_end > *endofpart)
1438                                 *endofpart = curr_part_end;
1439
1440                         part++;
1441                 }
1442         } else {
1443                 /* Unknown partition table */
1444                 retval = -1;
1445         }
1446  abort:
1447         return retval;
1448 }
1449
1450 int check_partitions(int fd, char *dname, unsigned long long freesize,
1451                         unsigned long long size)
1452 {
1453         /*
1454          * Check where the last partition ends
1455          */
1456         unsigned long long endofpart;
1457         int ret;
1458
1459         if ((ret = get_last_partition_end(fd, &endofpart)) > 0) {
1460                 /* There appears to be a partition table here */
1461                 if (freesize == 0) {
1462                         /* partitions will not be visible in new device */
1463                         pr_err("partition table exists on %s but will be lost or\n"
1464                                "       meaningless after creating array\n",
1465                                dname);
1466                         return 1;
1467                 } else if (endofpart > freesize) {
1468                         /* last partition overlaps metadata */
1469                         pr_err("metadata will over-write last partition on %s.\n",
1470                                dname);
1471                         return 1;
1472                 } else if (size && endofpart > size) {
1473                         /* partitions will be truncated in new device */
1474                         pr_err("array size is too small to cover all partitions on %s.\n",
1475                                dname);
1476                         return 1;
1477                 }
1478         }
1479         return 0;
1480 }
1481
1482 int open_container(int fd)
1483 {
1484         /* 'fd' is a block device.  Find out if it is in use
1485          * by a container, and return an open fd on that container.
1486          */
1487         char path[256];
1488         char *e;
1489         DIR *dir;
1490         struct dirent *de;
1491         int dfd, n;
1492         char buf[200];
1493         int major, minor;
1494         struct stat st;
1495
1496         if (fstat(fd, &st) != 0)
1497                 return -1;
1498         sprintf(path, "/sys/dev/block/%d:%d/holders",
1499                 (int)major(st.st_rdev), (int)minor(st.st_rdev));
1500         e = path + strlen(path);
1501
1502         dir = opendir(path);
1503         if (!dir)
1504                 return -1;
1505         while ((de = readdir(dir))) {
1506                 if (de->d_ino == 0)
1507                         continue;
1508                 if (de->d_name[0] == '.')
1509                         continue;
1510                 /* Need to make sure it is a container and not a volume */
1511                 sprintf(e, "/%s/md/metadata_version", de->d_name);
1512                 dfd = open(path, O_RDONLY);
1513                 if (dfd < 0)
1514                         continue;
1515                 n = read(dfd, buf, sizeof(buf));
1516                 close(dfd);
1517                 if (n <= 0 || (unsigned)n >= sizeof(buf))
1518                         continue;
1519                 buf[n] = 0;
1520                 if (strncmp(buf, "external", 8) != 0 ||
1521                     n < 10 ||
1522                     buf[9] == '/')
1523                         continue;
1524                 sprintf(e, "/%s/dev", de->d_name);
1525                 dfd = open(path, O_RDONLY);
1526                 if (dfd < 0)
1527                         continue;
1528                 n = read(dfd, buf, sizeof(buf));
1529                 close(dfd);
1530                 if (n <= 0 || (unsigned)n >= sizeof(buf))
1531                         continue;
1532                 buf[n] = 0;
1533                 if (sscanf(buf, "%d:%d", &major, &minor) != 2)
1534                         continue;
1535                 sprintf(buf, "%d:%d", major, minor);
1536                 dfd = dev_open(buf, O_RDONLY);
1537                 if (dfd >= 0) {
1538                         closedir(dir);
1539                         return dfd;
1540                 }
1541         }
1542         closedir(dir);
1543         return -1;
1544 }
1545
1546 struct superswitch *version_to_superswitch(char *vers)
1547 {
1548         int i;
1549
1550         for (i = 0; superlist[i]; i++) {
1551                 struct superswitch *ss = superlist[i];
1552
1553                 if (strcmp(vers, ss->name) == 0)
1554                         return ss;
1555         }
1556
1557         return NULL;
1558 }
1559
1560 int metadata_container_matches(char *metadata, char *devnm)
1561 {
1562         /* Check if 'devnm' is the container named in 'metadata'
1563          * which is
1564          *   /containername/componentname  or
1565          *   -containername/componentname
1566          */
1567         int l;
1568         if (*metadata != '/' && *metadata != '-')
1569                 return 0;
1570         l = strlen(devnm);
1571         if (strncmp(metadata+1, devnm, l) != 0)
1572                 return 0;
1573         if (metadata[l+1] != '/')
1574                 return 0;
1575         return 1;
1576 }
1577
1578 int metadata_subdev_matches(char *metadata, char *devnm)
1579 {
1580         /* Check if 'devnm' is the subdev named in 'metadata'
1581          * which is
1582          *   /containername/subdev  or
1583          *   -containername/subdev
1584          */
1585         char *sl;
1586         if (*metadata != '/' && *metadata != '-')
1587                 return 0;
1588         sl = strchr(metadata+1, '/');
1589         if (!sl)
1590                 return 0;
1591         if (strcmp(sl+1, devnm) == 0)
1592                 return 1;
1593         return 0;
1594 }
1595
1596 int is_container_member(struct mdstat_ent *mdstat, char *container)
1597 {
1598         if (mdstat->metadata_version == NULL ||
1599             strncmp(mdstat->metadata_version, "external:", 9) != 0 ||
1600             !metadata_container_matches(mdstat->metadata_version+9, container))
1601                 return 0;
1602
1603         return 1;
1604 }
1605
1606 int is_subarray_active(char *subarray, char *container)
1607 {
1608         struct mdstat_ent *mdstat = mdstat_read(0, 0);
1609         struct mdstat_ent *ent;
1610
1611         for (ent = mdstat; ent; ent = ent->next)
1612                 if (is_container_member(ent, container))
1613                         if (strcmp(to_subarray(ent, container), subarray) == 0)
1614                                 break;
1615
1616         free_mdstat(mdstat);
1617
1618         return ent != NULL;
1619 }
1620
1621 /* open_subarray - opens a subarray in a container
1622  * @dev: container device name
1623  * @st: empty supertype
1624  * @quiet: block reporting errors flag
1625  *
1626  * On success returns an fd to a container and fills in *st
1627  */
1628 int open_subarray(char *dev, char *subarray, struct supertype *st, int quiet)
1629 {
1630         struct mdinfo *mdi;
1631         struct mdinfo *info;
1632         int fd, err = 1;
1633         char *_devnm;
1634
1635         fd = open(dev, O_RDWR|O_EXCL);
1636         if (fd < 0) {
1637                 if (!quiet)
1638                         pr_err("Couldn't open %s, aborting\n",
1639                                 dev);
1640                 return -1;
1641         }
1642
1643         _devnm = fd2devnm(fd);
1644         if (_devnm == NULL) {
1645                 if (!quiet)
1646                         pr_err("Failed to determine device number for %s\n",
1647                                dev);
1648                 goto close_fd;
1649         }
1650         strcpy(st->devnm, _devnm);
1651
1652         mdi = sysfs_read(fd, st->devnm, GET_VERSION|GET_LEVEL);
1653         if (!mdi) {
1654                 if (!quiet)
1655                         pr_err("Failed to read sysfs for %s\n",
1656                                 dev);
1657                 goto close_fd;
1658         }
1659
1660         if (mdi->array.level != UnSet) {
1661                 if (!quiet)
1662                         pr_err("%s is not a container\n", dev);
1663                 goto free_sysfs;
1664         }
1665
1666         st->ss = version_to_superswitch(mdi->text_version);
1667         if (!st->ss) {
1668                 if (!quiet)
1669                         pr_err("Operation not supported for %s metadata\n",
1670                                mdi->text_version);
1671                 goto free_sysfs;
1672         }
1673
1674         if (st->devnm[0] == 0) {
1675                 if (!quiet)
1676                         pr_err("Failed to allocate device name\n");
1677                 goto free_sysfs;
1678         }
1679
1680         if (!st->ss->load_container) {
1681                 if (!quiet)
1682                         pr_err("%s is not a container\n", dev);
1683                 goto free_sysfs;
1684         }
1685
1686         if (st->ss->load_container(st, fd, NULL)) {
1687                 if (!quiet)
1688                         pr_err("Failed to load metadata for %s\n",
1689                                 dev);
1690                 goto free_sysfs;
1691         }
1692
1693         info = st->ss->container_content(st, subarray);
1694         if (!info) {
1695                 if (!quiet)
1696                         pr_err("Failed to find subarray-%s in %s\n",
1697                                 subarray, dev);
1698                 goto free_super;
1699         }
1700         free(info);
1701
1702         err = 0;
1703
1704  free_super:
1705         if (err)
1706                 st->ss->free_super(st);
1707  free_sysfs:
1708         sysfs_free(mdi);
1709  close_fd:
1710         if (err)
1711                 close(fd);
1712
1713         if (err)
1714                 return -1;
1715         else
1716                 return fd;
1717 }
1718
1719 int add_disk(int mdfd, struct supertype *st,
1720              struct mdinfo *sra, struct mdinfo *info)
1721 {
1722         /* Add a device to an array, in one of 2 ways. */
1723         int rv;
1724 #ifndef MDASSEMBLE
1725         if (st->ss->external) {
1726                 if (info->disk.state & (1<<MD_DISK_SYNC))
1727                         info->recovery_start = MaxSector;
1728                 else
1729                         info->recovery_start = 0;
1730                 rv = sysfs_add_disk(sra, info, 0);
1731                 if (! rv) {
1732                         struct mdinfo *sd2;
1733                         for (sd2 = sra->devs; sd2; sd2=sd2->next)
1734                                 if (sd2 == info)
1735                                         break;
1736                         if (sd2 == NULL) {
1737                                 sd2 = xmalloc(sizeof(*sd2));
1738                                 *sd2 = *info;
1739                                 sd2->next = sra->devs;
1740                                 sra->devs = sd2;
1741                         }
1742                 }
1743         } else
1744 #endif
1745                 rv = ioctl(mdfd, ADD_NEW_DISK, &info->disk);
1746         return rv;
1747 }
1748
1749 int remove_disk(int mdfd, struct supertype *st,
1750                 struct mdinfo *sra, struct mdinfo *info)
1751 {
1752         int rv;
1753         /* Remove the disk given by 'info' from the array */
1754 #ifndef MDASSEMBLE
1755         if (st->ss->external)
1756                 rv = sysfs_set_str(sra, info, "slot", "none");
1757         else
1758 #endif
1759                 rv = ioctl(mdfd, HOT_REMOVE_DISK, makedev(info->disk.major,
1760                                                           info->disk.minor));
1761         return rv;
1762 }
1763
1764 int set_array_info(int mdfd, struct supertype *st, struct mdinfo *info)
1765 {
1766         /* Initialise kernel's knowledge of array.
1767          * This varies between externally managed arrays
1768          * and older kernels
1769          */
1770         int vers = md_get_version(mdfd);
1771         int rv;
1772
1773 #ifndef MDASSEMBLE
1774         if (st->ss->external)
1775                 rv = sysfs_set_array(info, vers);
1776         else
1777 #endif
1778                 if ((vers % 100) >= 1) { /* can use different versions */
1779                 mdu_array_info_t inf;
1780                 memset(&inf, 0, sizeof(inf));
1781                 inf.major_version = info->array.major_version;
1782                 inf.minor_version = info->array.minor_version;
1783                 rv = ioctl(mdfd, SET_ARRAY_INFO, &inf);
1784         } else
1785                 rv = ioctl(mdfd, SET_ARRAY_INFO, NULL);
1786         return rv;
1787 }
1788
1789 unsigned long long min_recovery_start(struct mdinfo *array)
1790 {
1791         /* find the minimum recovery_start in an array for metadata
1792          * formats that only record per-array recovery progress instead
1793          * of per-device
1794          */
1795         unsigned long long recovery_start = MaxSector;
1796         struct mdinfo *d;
1797
1798         for (d = array->devs; d; d = d->next)
1799                 recovery_start = min(recovery_start, d->recovery_start);
1800
1801         return recovery_start;
1802 }
1803
1804 int mdmon_pid(char *devnm)
1805 {
1806         char path[100];
1807         char pid[10];
1808         int fd;
1809         int n;
1810
1811         sprintf(path, "%s/%s.pid", MDMON_DIR, devnm);
1812
1813         fd = open(path, O_RDONLY | O_NOATIME, 0);
1814
1815         if (fd < 0)
1816                 return -1;
1817         n = read(fd, pid, 9);
1818         close(fd);
1819         if (n <= 0)
1820                 return -1;
1821         return atoi(pid);
1822 }
1823
1824 int mdmon_running(char *devnm)
1825 {
1826         int pid = mdmon_pid(devnm);
1827         if (pid <= 0)
1828                 return 0;
1829         if (kill(pid, 0) == 0)
1830                 return 1;
1831         return 0;
1832 }
1833
1834 int start_mdmon(char *devnm)
1835 {
1836         int i, skipped;
1837         int len;
1838         pid_t pid;
1839         int status;
1840         char pathbuf[1024];
1841         char *paths[4] = {
1842                 pathbuf,
1843                 BINDIR "/mdmon",
1844                 "./mdmon",
1845                 NULL
1846         };
1847
1848         if (check_env("MDADM_NO_MDMON"))
1849                 return 0;
1850
1851         len = readlink("/proc/self/exe", pathbuf, sizeof(pathbuf)-1);
1852         if (len > 0) {
1853                 char *sl;
1854                 pathbuf[len] = 0;
1855                 sl = strrchr(pathbuf, '/');
1856                 if (sl)
1857                         sl++;
1858                 else
1859                         sl = pathbuf;
1860                 strcpy(sl, "mdmon");
1861         } else
1862                 pathbuf[0] = '\0';
1863
1864         /* First try to run systemctl */
1865         if (!check_env("MDADM_NO_SYSTEMCTL"))
1866                 switch(fork()) {
1867                 case 0:
1868                         /* FIXME yuk. CLOSE_EXEC?? */
1869                         skipped = 0;
1870                         for (i = 3; skipped < 20; i++)
1871                                 if (close(i) < 0)
1872                                         skipped++;
1873                                 else
1874                                         skipped = 0;
1875
1876                         /* Don't want to see error messages from
1877                          * systemctl.  If the service doesn't exist,
1878                          * we start mdmon ourselves.
1879                          */
1880                         close(2);
1881                         open("/dev/null", O_WRONLY);
1882                         snprintf(pathbuf, sizeof(pathbuf), "mdmon@%s.service",
1883                                  devnm);
1884                         status = execl("/usr/bin/systemctl", "systemctl",
1885                                        "start",
1886                                        pathbuf, NULL);
1887                         status = execl("/bin/systemctl", "systemctl", "start",
1888                                        pathbuf, NULL);
1889                         exit(1);
1890                 case -1: pr_err("cannot run mdmon. Array remains readonly\n");
1891                         return -1;
1892                 default: /* parent - good */
1893                         pid = wait(&status);
1894                         if (pid >= 0 && status == 0)
1895                                 return 0;
1896                 }
1897
1898         /* That failed, try running mdmon directly */
1899         switch(fork()) {
1900         case 0:
1901                 /* FIXME yuk. CLOSE_EXEC?? */
1902                 skipped = 0;
1903                 for (i = 3; skipped < 20; i++)
1904                         if (close(i) < 0)
1905                                 skipped++;
1906                         else
1907                                 skipped = 0;
1908
1909                 for (i = 0; paths[i]; i++)
1910                         if (paths[i][0]) {
1911                                 execl(paths[i], paths[i],
1912                                       devnm, NULL);
1913                         }
1914                 exit(1);
1915         case -1: pr_err("cannot run mdmon. Array remains readonly\n");
1916                 return -1;
1917         default: /* parent - good */
1918                 pid = wait(&status);
1919                 if (pid < 0 || status != 0) {
1920                         pr_err("failed to launch mdmon. Array remains readonly\n");
1921                         return -1;
1922                 }
1923         }
1924         return 0;
1925 }
1926
1927 __u32 random32(void)
1928 {
1929         __u32 rv;
1930         int rfd = open("/dev/urandom", O_RDONLY);
1931         if (rfd < 0 || read(rfd, &rv, 4) != 4)
1932                 rv = random();
1933         if (rfd >= 0)
1934                 close(rfd);
1935         return rv;
1936 }
1937
1938 #ifndef MDASSEMBLE
1939 int flush_metadata_updates(struct supertype *st)
1940 {
1941         int sfd;
1942         if (!st->updates) {
1943                 st->update_tail = NULL;
1944                 return -1;
1945         }
1946
1947         sfd = connect_monitor(st->container_devnm);
1948         if (sfd < 0)
1949                 return -1;
1950
1951         while (st->updates) {
1952                 struct metadata_update *mu = st->updates;
1953                 st->updates = mu->next;
1954
1955                 send_message(sfd, mu, 0);
1956                 wait_reply(sfd, 0);
1957                 free(mu->buf);
1958                 free(mu);
1959         }
1960         ack(sfd, 0);
1961         wait_reply(sfd, 0);
1962         close(sfd);
1963         st->update_tail = NULL;
1964         return 0;
1965 }
1966
1967 void append_metadata_update(struct supertype *st, void *buf, int len)
1968 {
1969
1970         struct metadata_update *mu = xmalloc(sizeof(*mu));
1971
1972         mu->buf = buf;
1973         mu->len = len;
1974         mu->space = NULL;
1975         mu->space_list = NULL;
1976         mu->next = NULL;
1977         *st->update_tail = mu;
1978         st->update_tail = &mu->next;
1979 }
1980 #endif /* MDASSEMBLE */
1981
1982 #ifdef __TINYC__
1983 /* tinyc doesn't optimize this check in ioctl.h out ... */
1984 unsigned int __invalid_size_argument_for_IOC = 0;
1985 #endif
1986
1987 int experimental(void)
1988 {
1989         if (check_env("MDADM_EXPERIMENTAL"))
1990                 return 1;
1991         else {
1992                 pr_err("To use this feature MDADM_EXPERIMENTAL environment variable has to be defined.\n");
1993                 return 0;
1994         }
1995 }
1996
1997 /* Pick all spares matching given criteria from a container
1998  * if min_size == 0 do not check size
1999  * if domlist == NULL do not check domains
2000  * if spare_group given add it to domains of each spare
2001  * metadata allows to test domains using metadata of destination array */
2002 struct mdinfo *container_choose_spares(struct supertype *st,
2003                                        unsigned long long min_size,
2004                                        struct domainlist *domlist,
2005                                        char *spare_group,
2006                                        const char *metadata, int get_one)
2007 {
2008         struct mdinfo *d, **dp, *disks = NULL;
2009
2010         /* get list of all disks in container */
2011         if (st->ss->getinfo_super_disks)
2012                 disks = st->ss->getinfo_super_disks(st);
2013
2014         if (!disks)
2015                 return disks;
2016         /* find spare devices on the list */
2017         dp = &disks->devs;
2018         disks->array.spare_disks = 0;
2019         while (*dp) {
2020                 int found = 0;
2021                 d = *dp;
2022                 if (d->disk.state == 0) {
2023                         /* check if size is acceptable */
2024                         unsigned long long dev_size;
2025                         dev_t dev = makedev(d->disk.major,d->disk.minor);
2026
2027                         if (!min_size ||
2028                            (dev_size_from_id(dev,  &dev_size) &&
2029                             dev_size >= min_size))
2030                                 found = 1;
2031                         /* check if domain matches */
2032                         if (found && domlist) {
2033                                 struct dev_policy *pol = devid_policy(dev);
2034                                 if (spare_group)
2035                                         pol_add(&pol, pol_domain,
2036                                                 spare_group, NULL);
2037                                 if (domain_test(domlist, pol, metadata) != 1)
2038                                         found = 0;
2039                                 dev_policy_free(pol);
2040                         }
2041                 }
2042                 if (found) {
2043                         dp = &d->next;
2044                         disks->array.spare_disks++;
2045                         if (get_one) {
2046                                 sysfs_free(*dp);
2047                                 d->next = NULL;
2048                         }
2049                 } else {
2050                         *dp = d->next;
2051                         d->next = NULL;
2052                         sysfs_free(d);
2053                 }
2054         }
2055         return disks;
2056 }
2057
2058 /* Checks if paths point to the same device
2059  * Returns 0 if they do.
2060  * Returns 1 if they don't.
2061  * Returns -1 if something went wrong,
2062  * e.g. paths are empty or the files
2063  * they point to don't exist */
2064 int compare_paths (char* path1, char* path2)
2065 {
2066         struct stat st1,st2;
2067
2068         if (path1 == NULL || path2 == NULL)
2069                 return -1;
2070         if (stat(path1,&st1) != 0)
2071                 return -1;
2072         if (stat(path2,&st2) != 0)
2073                 return -1;
2074         if ((st1.st_ino == st2.st_ino) && (st1.st_dev == st2.st_dev))
2075                 return 0;
2076         return 1;
2077 }
2078
2079 /* Make sure we can open as many devices as needed */
2080 void enable_fds(int devices)
2081 {
2082         unsigned int fds = 20 + devices;
2083         struct rlimit lim;
2084         if (getrlimit(RLIMIT_NOFILE, &lim) != 0
2085             || lim.rlim_cur >= fds)
2086                 return;
2087         if (lim.rlim_max < fds)
2088                 lim.rlim_max = fds;
2089         lim.rlim_cur = fds;
2090         setrlimit(RLIMIT_NOFILE, &lim);
2091 }
2092
2093 int in_initrd(void)
2094 {
2095         /* This is based on similar function in systemd. */
2096         struct statfs s;
2097         /* statfs.f_type is signed long on s390x and MIPS, causing all
2098            sorts of sign extension problems with RAMFS_MAGIC being
2099            defined as 0x858458f6 */
2100         return  statfs("/", &s) >= 0 &&
2101                 ((unsigned long)s.f_type == TMPFS_MAGIC ||
2102                  ((unsigned long)s.f_type & 0xFFFFFFFFUL) ==
2103                  ((unsigned long)RAMFS_MAGIC & 0xFFFFFFFFUL));
2104 }
2105
2106 void reopen_mddev(int mdfd)
2107 {
2108         /* Re-open without any O_EXCL, but keep
2109          * the same fd
2110          */
2111         char *devnm;
2112         int fd;
2113         devnm = fd2devnm(mdfd);
2114         close(mdfd);
2115         fd = open_dev(devnm);
2116         if (fd >= 0 && fd != mdfd)
2117                 dup2(fd, mdfd);
2118 }
2119
2120 #ifndef MDASSEMBLE
2121 static struct cmap_hooks *cmap_hooks = NULL;
2122 static int is_cmap_hooks_ready = 0;
2123
2124 void set_cmap_hooks(void)
2125 {
2126         cmap_hooks = xmalloc(sizeof(struct cmap_hooks));
2127         cmap_hooks->cmap_handle = dlopen("libcmap.so.4", RTLD_NOW | RTLD_LOCAL);
2128         if (!cmap_hooks->cmap_handle)
2129                 return;
2130
2131         cmap_hooks->initialize = dlsym(cmap_hooks->cmap_handle, "cmap_initialize");
2132         cmap_hooks->get_string = dlsym(cmap_hooks->cmap_handle, "cmap_get_string");
2133         cmap_hooks->finalize = dlsym(cmap_hooks->cmap_handle, "cmap_finalize");
2134
2135         if (!cmap_hooks->initialize || !cmap_hooks->get_string ||
2136             !cmap_hooks->finalize)
2137                 dlclose(cmap_hooks->cmap_handle);
2138         else
2139                 is_cmap_hooks_ready = 1;
2140 }
2141
2142 int get_cluster_name(char **cluster_name)
2143 {
2144         int rv = -1;
2145         cmap_handle_t handle;
2146
2147         if (!is_cmap_hooks_ready)
2148                 return rv;
2149
2150         rv = cmap_hooks->initialize(&handle);
2151         if (rv != CS_OK)
2152                 goto out;
2153
2154         rv = cmap_hooks->get_string(handle, "totem.cluster_name", cluster_name);
2155         if (rv != CS_OK) {
2156                 free(*cluster_name);
2157                 rv = -1;
2158                 goto name_err;
2159         }
2160
2161         rv = 0;
2162 name_err:
2163         cmap_hooks->finalize(handle);
2164 out:
2165         return rv;
2166 }
2167
2168 void set_dlm_hooks(void)
2169 {
2170         dlm_hooks = xmalloc(sizeof(struct dlm_hooks));
2171         dlm_hooks->dlm_handle = dlopen("libdlm_lt.so.3", RTLD_NOW | RTLD_LOCAL);
2172         if (!dlm_hooks->dlm_handle)
2173                 return;
2174
2175         dlm_hooks->create_lockspace = dlsym(dlm_hooks->dlm_handle, "dlm_create_lockspace");
2176         dlm_hooks->release_lockspace = dlsym(dlm_hooks->dlm_handle, "dlm_release_lockspace");
2177         dlm_hooks->ls_lock = dlsym(dlm_hooks->dlm_handle, "dlm_ls_lock");
2178         dlm_hooks->ls_unlock = dlsym(dlm_hooks->dlm_handle, "dlm_ls_unlock");
2179         dlm_hooks->ls_get_fd = dlsym(dlm_hooks->dlm_handle, "dlm_ls_get_fd");
2180         dlm_hooks->dispatch = dlsym(dlm_hooks->dlm_handle, "dlm_dispatch");
2181
2182         if (!dlm_hooks->create_lockspace || !dlm_hooks->ls_lock ||
2183             !dlm_hooks->ls_unlock || !dlm_hooks->release_lockspace ||
2184             !dlm_hooks->ls_get_fd || !dlm_hooks->dispatch)
2185                 dlclose(dlm_hooks->dlm_handle);
2186         else
2187                 is_dlm_hooks_ready = 1;
2188 }
2189
2190 void set_hooks(void)
2191 {
2192         set_dlm_hooks();
2193         set_cmap_hooks();
2194 }
2195 #endif