Manage.c

   1 /*
   2  * mdadm - manage Linux "md" devices aka RAID arrays.
   3  *
   4  * Copyright (C) 2001-2009 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_u.h"
  27 #include "md_p.h"
  28 #include <ctype.h>
  29
  30 #define REGISTER_DEV            _IO (MD_MAJOR, 1)
  31 #define START_MD                _IO (MD_MAJOR, 2)
  32 #define STOP_MD                 _IO (MD_MAJOR, 3)
  33
  34 int Manage_ro(char *devname, int fd, int readonly)
  35 {
  36         /* switch to readonly or rw
  37          *
  38          * requires >= 0.90.0
  39          * first check that array is runing
  40          * use RESTART_ARRAY_RW or STOP_ARRAY_RO
  41          *
  42          */
  43         mdu_array_info_t array;
  44 #ifndef MDASSEMBLE
  45         struct mdinfo *mdi;
  46 #endif
  47
  48         if (md_get_version(fd) < 9000) {
  49                 fprintf(stderr, Name ": need md driver version 0.90.0 or later\n");
  50                 return 1;
  51         }
  52 #ifndef MDASSEMBLE
  53         /* If this is an externally-manage array, we need to modify the
  54          * metadata_version so that mdmon doesn't undo our change.
  55          */
  56         mdi = sysfs_read(fd, -1, GET_LEVEL|GET_VERSION);
  57         if (mdi &&
  58             mdi->array.major_version == -1 &&
  59             is_subarray(mdi->text_version)) {
  60                 char vers[64];
  61                 strcpy(vers, "external:");
  62                 strcat(vers, mdi->text_version);
  63                 if (readonly > 0) {
  64                         int rv;
  65                         /* We set readonly ourselves. */
  66                         vers[9] = '-';
  67                         sysfs_set_str(mdi, NULL, "metadata_version", vers);
  68
  69                         close(fd);
  70                         rv = sysfs_set_str(mdi, NULL, "array_state", "readonly");
  71
  72                         if (rv < 0) {
  73                                 fprintf(stderr, Name ": failed to set readonly for %s: %s\n",
  74                                         devname, strerror(errno));
  75
  76                                 vers[9] = mdi->text_version[0];
  77                                 sysfs_set_str(mdi, NULL, "metadata_version", vers);
  78                                 return 1;
  79                         }
  80                 } else {
  81                         char *cp;
  82                         /* We cannot set read/write - must signal mdmon */
  83                         vers[9] = '/';
  84                         sysfs_set_str(mdi, NULL, "metadata_version", vers);
  85
  86                         cp = strchr(vers+10, '/');
  87                         if (*cp)
  88                                 *cp = 0;
  89                         ping_monitor(vers+10);
  90                         if (mdi->array.level <= 0)
  91                                 sysfs_set_str(mdi, NULL, "array_state", "active");
  92                 }
  93                 return 0;
  94         }
  95 #endif
  96         if (ioctl(fd, GET_ARRAY_INFO, &array)) {
  97                 fprintf(stderr, Name ": %s does not appear to be active.\n",
  98                         devname);
  99                 return 1;
 100         }
 101
 102         if (readonly>0) {
 103                 if (ioctl(fd, STOP_ARRAY_RO, NULL)) {
 104                         fprintf(stderr, Name ": failed to set readonly for %s: %s\n",
 105                                 devname, strerror(errno));
 106                         return 1;
 107                 }
 108         } else if (readonly < 0) {
 109                 if (ioctl(fd, RESTART_ARRAY_RW, NULL)) {
 110                         fprintf(stderr, Name ": failed to set writable for %s: %s\n",
 111                                 devname, strerror(errno));
 112                         return 1;
 113                 }
 114         }
 115         return 0;
 116 }
 117
 118 #ifndef MDASSEMBLE
 119
 120 static void remove_devices(int devnum, char *path)
 121 {
 122         /*
 123          * Remove names at 'path' - possibly with
 124          * partition suffixes - which link to the 'standard'
 125          * name for devnum.  These were probably created
 126          * by mdadm when the array was assembled.
 127          */
 128         char base[40];
 129         char *path2;
 130         char link[1024];
 131         int n;
 132         int part;
 133         char *be;
 134         char *pe;
 135
 136         if (!path)
 137                 return;
 138
 139         if (devnum >= 0)
 140                 sprintf(base, "/dev/md%d", devnum);
 141         else
 142                 sprintf(base, "/dev/md_d%d", -1-devnum);
 143         be = base + strlen(base);
 144
 145         path2 = malloc(strlen(path)+20);
 146         strcpy(path2, path);
 147         pe = path2 + strlen(path2);
 148
 149         for (part = 0; part < 16; part++) {
 150                 if (part) {
 151                         sprintf(be, "p%d", part);
 152
 153                         if (isdigit(pe[-1]))
 154                                 sprintf(pe, "p%d", part);
 155                         else
 156                                 sprintf(pe, "%d", part);
 157                 }
 158                 n = readlink(path2, link, sizeof(link));
 159                 if (n && (int)strlen(base) == n &&
 160                     strncmp(link, base, n) == 0)
 161                         unlink(path2);
 162         }
 163         free(path2);
 164 }
 165
 166
 167 int Manage_runstop(char *devname, int fd, int runstop, int quiet)
 168 {
 169         /* Run or stop the array. array must already be configured
 170          * required >= 0.90.0
 171          * Only print failure messages if quiet == 0;
 172          * quiet > 0 means really be quiet
 173          * quiet < 0 means we will try again if it fails.
 174          */
 175         mdu_param_t param; /* unused */
 176
 177         if (runstop == -1 && md_get_version(fd) < 9000) {
 178                 if (ioctl(fd, STOP_MD, 0)) {
 179                         if (quiet == 0) fprintf(stderr,
 180                                                 Name ": stopping device %s "
 181                                                 "failed: %s\n",
 182                                                 devname, strerror(errno));
 183                         return 1;
 184                 }
 185         }
 186
 187         if (md_get_version(fd) < 9000) {
 188                 fprintf(stderr, Name ": need md driver version 0.90.0 or later\n");
 189                 return 1;
 190         }
 191         /*
 192         if (ioctl(fd, GET_ARRAY_INFO, &array)) {
 193                 fprintf(stderr, Name ": %s does not appear to be active.\n",
 194                         devname);
 195                 return 1;
 196         }
 197         */
 198         if (runstop>0) {
 199                 if (ioctl(fd, RUN_ARRAY, &param)) {
 200                         fprintf(stderr, Name ": failed to run array %s: %s\n",
 201                                 devname, strerror(errno));
 202                         return 1;
 203                 }
 204                 if (quiet <= 0)
 205                         fprintf(stderr, Name ": started %s\n", devname);
 206         } else if (runstop < 0){
 207                 struct map_ent *map = NULL;
 208                 struct stat stb;
 209                 struct mdinfo *mdi;
 210                 int devnum;
 211                 /* If this is an mdmon managed array, just write 'inactive'
 212                  * to the array state and let mdmon clear up.
 213                  */
 214                 devnum = fd2devnum(fd);
 215                 mdi = sysfs_read(fd, -1, GET_LEVEL|GET_VERSION);
 216                 if (mdi &&
 217                     mdi->array.level > 0 &&
 218                     is_subarray(mdi->text_version)) {
 219                         /* This is mdmon managed. */
 220                         close(fd);
 221                         if (sysfs_set_str(mdi, NULL,
 222                                           "array_state", "inactive") < 0) {
 223                                 if (quiet == 0)
 224                                         fprintf(stderr, Name
 225                                                 ": failed to stop array %s: %s\n",
 226                                                 devname, strerror(errno));
 227                                 return 1;
 228                         }
 229
 230                         /* Give monitor a chance to act */
 231                         ping_monitor(mdi->text_version);
 232
 233                         fd = open(devname, O_RDONLY);
 234                 } else if (mdi &&
 235                            mdi->array.major_version == -1 &&
 236                            mdi->array.minor_version == -2 &&
 237                            !is_subarray(mdi->text_version)) {
 238                         struct mdstat_ent *mds, *m;
 239                         /* container, possibly mdmon-managed.
 240                          * Make sure mdmon isn't opening it, which
 241                          * would interfere with the 'stop'
 242                          */
 243                         ping_monitor(mdi->sys_name);
 244
 245                         /* now check that there are no existing arrays
 246                          * which are members of this array
 247                          */
 248                         mds = mdstat_read(0, 0);
 249                         for (m=mds; m; m=m->next)
 250                                 if (m->metadata_version &&
 251                                     strncmp(m->metadata_version, "external:", 9)==0 &&
 252                                     is_subarray(m->metadata_version+9) &&
 253                                     devname2devnum(m->metadata_version+10) == devnum) {
 254                                         if (!quiet)
 255                                                 fprintf(stderr, Name
 256                                                         ": Cannot stop container %s: "
 257                                                         "member %s still active\n",
 258                                                         devname, m->dev);
 259                                         free_mdstat(mds);
 260                                         if (mdi)
 261                                                 sysfs_free(mdi);
 262                                         return 1;
 263                                 }
 264                 }
 265
 266                 if (fd >= 0 && ioctl(fd, STOP_ARRAY, NULL)) {
 267                         if (quiet == 0) {
 268                                 fprintf(stderr, Name
 269                                         ": failed to stop array %s: %s\n",
 270                                         devname, strerror(errno));
 271                                 if (errno == EBUSY)
 272                                         fprintf(stderr, "Perhaps a running "
 273                                                 "process, mounted filesystem "
 274                                                 "or active volume group?\n");
 275                         }
 276                         if (mdi)
 277                                 sysfs_free(mdi);
 278                         return 1;
 279                 }
 280                 /* prior to 2.6.28, KOBJ_CHANGE was not sent when an md array
 281                  * was stopped, so We'll do it here just to be sure.  Drop any
 282                  * partitions as well...
 283                  */
 284                 if (fd >= 0)
 285                         ioctl(fd, BLKRRPART, 0);
 286                 if (mdi)
 287                         sysfs_uevent(mdi, "change");
 288
 289
 290                 if (devnum != NoMdDev &&
 291                     (stat("/dev/.udev", &stb) != 0 ||
 292                      check_env("MDADM_NO_UDEV"))) {
 293                         struct map_ent *mp = map_by_devnum(&map, devnum);
 294                         remove_devices(devnum, mp ? mp->path : NULL);
 295                 }
 296
 297
 298                 if (quiet <= 0)
 299                         fprintf(stderr, Name ": stopped %s\n", devname);
 300                 map_lock(&map);
 301                 map_remove(&map, devnum);
 302                 map_unlock(&map);
 303         }
 304         return 0;
 305 }
 306
 307 int Manage_resize(char *devname, int fd, long long size, int raid_disks)
 308 {
 309         mdu_array_info_t info;
 310         if (ioctl(fd, GET_ARRAY_INFO, &info) != 0) {
 311                 fprintf(stderr, Name ": Cannot get array information for %s: %s\n",
 312                         devname, strerror(errno));
 313                 return 1;
 314         }
 315         if (size >= 0)
 316                 info.size = size;
 317         if (raid_disks > 0)
 318                 info.raid_disks = raid_disks;
 319         if (ioctl(fd, SET_ARRAY_INFO, &info) != 0) {
 320                 fprintf(stderr, Name ": Cannot set device size/shape for %s: %s\n",
 321                         devname, strerror(errno));
 322                 return 1;
 323         }
 324         return 0;
 325 }
 326
 327 int Manage_subdevs(char *devname, int fd,
 328                    struct mddev_dev *devlist, int verbose, int test,
 329                    char *update)
 330 {
 331         /* do something to each dev.
 332          * devmode can be
 333          *  'a' - add the device
 334          *         try HOT_ADD_DISK
 335          *         If that fails EINVAL, try ADD_NEW_DISK
 336          *  'r' - remove the device HOT_REMOVE_DISK
 337          *        device can be 'faulty' or 'detached' in which case all
 338          *        matching devices are removed.
 339          *  'f' - set the device faulty SET_DISK_FAULTY
 340          *        device can be 'detached' in which case any device that
 341          *        is inaccessible will be marked faulty.
 342          * For 'f' and 'r', the device can also be a kernel-internal
 343          * name such as 'sdb'.
 344          */
 345         struct mddev_dev *add_devlist = NULL;
 346         mdu_array_info_t array;
 347         mdu_disk_info_t disc;
 348         unsigned long long array_size;
 349         struct mddev_dev *dv, *next = NULL;
 350         struct stat stb;
 351         int j, jnext = 0;
 352         int tfd = -1;
 353         struct supertype *st, *tst;
 354         char *subarray = NULL;
 355         int duuid[4];
 356         int ouuid[4];
 357         int lfd = -1;
 358         int sysfd = -1;
 359         int count = 0; /* number of actions taken */
 360
 361         if (ioctl(fd, GET_ARRAY_INFO, &array)) {
 362                 fprintf(stderr, Name ": cannot get array info for %s\n",
 363                         devname);
 364                 return 1;
 365         }
 366
 367         /* array.size is only 32 bit and may be truncated.
 368          * So read from sysfs if possible, and record number of sectors
 369          */
 370
 371         array_size = get_component_size(fd);
 372         if (array_size <= 0)
 373                 array_size = array.size * 2;
 374
 375         tst = super_by_fd(fd, &subarray);
 376         if (!tst) {
 377                 fprintf(stderr, Name ": unsupport array - version %d.%d\n",
 378                         array.major_version, array.minor_version);
 379                 return 1;
 380         }
 381
 382         stb.st_rdev = 0;
 383         for (dv = devlist, j=0 ; dv; dv = next, j = jnext) {
 384                 unsigned long long ldsize;
 385                 char dvname[20];
 386                 char *dnprintable = dv->devname;
 387                 char *add_dev = dv->devname;
 388                 int err;
 389                 int re_add_failed = 0;
 390
 391                 next = dv->next;
 392                 jnext = 0;
 393
 394                 if (strcmp(dv->devname, "failed")==0 ||
 395                     strcmp(dv->devname, "faulty")==0) {
 396                         if (dv->disposition != 'r') {
 397                                 fprintf(stderr, Name ": %s only meaningful "
 398                                         "with -r, not -%c\n",
 399                                         dv->devname, dv->disposition);
 400                                 return 1;
 401                         }
 402                         for (; j < array.raid_disks + array.nr_disks ; j++) {
 403                                 unsigned dev;
 404                                 disc.number = j;
 405                                 if (ioctl(fd, GET_DISK_INFO, &disc))
 406                                         continue;
 407                                 if (disc.major == 0 && disc.minor == 0)
 408                                         continue;
 409                                 if ((disc.state & 1) == 0) /* faulty */
 410                                         continue;
 411                                 dev = makedev(disc.major, disc.minor);
 412                                 if (stb.st_rdev == dev)
 413                                         /* already did that one */
 414                                         continue;
 415                                 stb.st_rdev = dev;
 416                                 next = dv;
 417                                 /* same slot again next time - things might
 418                                  * have reshuffled */
 419                                 jnext = j;
 420                                 sprintf(dvname,"%d:%d", disc.major, disc.minor);
 421                                 dnprintable = dvname;
 422                                 break;
 423                         }
 424                         if (jnext == 0)
 425                                 continue;
 426                 } else if (strcmp(dv->devname, "detached") == 0) {
 427                         if (dv->disposition != 'r' && dv->disposition != 'f') {
 428                                 fprintf(stderr, Name ": %s only meaningful "
 429                                         "with -r of -f, not -%c\n",
 430                                         dv->devname, dv->disposition);
 431                                 return 1;
 432                         }
 433                         for (; j < array.raid_disks + array.nr_disks; j++) {
 434                                 int sfd;
 435                                 unsigned dev;
 436                                 disc.number = j;
 437                                 if (ioctl(fd, GET_DISK_INFO, &disc))
 438                                         continue;
 439                                 if (disc.major == 0 && disc.minor == 0)
 440                                         continue;
 441                                 sprintf(dvname,"%d:%d", disc.major, disc.minor);
 442                                 sfd = dev_open(dvname, O_RDONLY);
 443                                 if (sfd >= 0) {
 444                                         close(sfd);
 445                                         continue;
 446                                 }
 447                                 if (dv->disposition == 'f' &&
 448                                     (disc.state & 1) == 1) /* already faulty */
 449                                         continue;
 450                                 if (errno != ENXIO)
 451                                         continue;
 452                                 dev = makedev(disc.major, disc.minor);
 453                                 if (stb.st_rdev == dev)
 454                                         /* already did that one */
 455                                         continue;
 456                                 stb.st_rdev = dev;
 457                                 next = dv;
 458                                 /* same slot again next time - things might
 459                                  * have reshuffled */
 460                                 jnext = j;
 461                                 dnprintable = dvname;
 462                                 break;
 463                         }
 464                         if (jnext == 0)
 465                                 continue;
 466                 } else if (strcmp(dv->devname, "missing") == 0) {
 467                         if (dv->disposition != 'a' || dv->re_add == 0) {
 468                                 fprintf(stderr, Name ": 'missing' only meaningful "
 469                                         "with --re-add\n");
 470                                 return 1;
 471                         }
 472                         if (add_devlist == NULL)
 473                                 add_devlist = conf_get_devs();
 474                         if (add_devlist == NULL) {
 475                                 fprintf(stderr, Name ": no devices to scan for missing members.");
 476                                 continue;
 477                         }
 478                         add_dev = add_devlist->devname;
 479                         add_devlist = add_devlist->next;
 480                         if (add_devlist != NULL)
 481                                 next = dv;
 482                         if (stat(add_dev, &stb) < 0)
 483                                 continue;
 484                 } else if (strchr(dv->devname, '/') == NULL &&
 485                            strchr(dv->devname, ':') == NULL &&
 486                            strlen(dv->devname) < 50) {
 487                         /* Assume this is a kernel-internal name like 'sda1' */
 488                         int found = 0;
 489                         char dname[55];
 490                         if (dv->disposition != 'r' && dv->disposition != 'f') {
 491                                 fprintf(stderr, Name ": %s only meaningful "
 492                                         "with -r or -f, not -%c\n",
 493                                         dv->devname, dv->disposition);
 494                                 return 1;
 495                         }
 496
 497                         sprintf(dname, "dev-%s", dv->devname);
 498                         sysfd = sysfs_open(fd2devnum(fd), dname, "block/dev");
 499                         if (sysfd >= 0) {
 500                                 char dn[20];
 501                                 int mj,mn;
 502                                 if (sysfs_fd_get_str(sysfd, dn, 20) > 0 &&
 503                                     sscanf(dn, "%d:%d", &mj,&mn) == 2) {
 504                                         stb.st_rdev = makedev(mj,mn);
 505                                         found = 1;
 506                                 }
 507                                 close(sysfd);
 508                                 sysfd = -1;
 509                         }
 510                         if (!found) {
 511                                 sysfd = sysfs_open(fd2devnum(fd), dname, "state");
 512                                 if (sysfd < 0) {
 513                                         fprintf(stderr, Name ": %s does not appear "
 514                                                 "to be a component of %s\n",
 515                                                 dv->devname, devname);
 516                                         return 1;
 517                                 }
 518                         }
 519                 } else {
 520                         j = 0;
 521
 522                         tfd = dev_open(dv->devname, O_RDONLY);
 523                         if (tfd < 0 && dv->disposition == 'r' &&
 524                             lstat(dv->devname, &stb) == 0)
 525                                 /* Be happy, the lstat worked, that is
 526                                  * enough for --remove
 527                                  */
 528                                 ;
 529                         else {
 530                                 if (tfd < 0 || fstat(tfd, &stb) != 0) {
 531                                         fprintf(stderr, Name ": cannot find %s: %s\n",
 532                                                 dv->devname, strerror(errno));
 533                                         if (tfd >= 0)
 534                                                 close(tfd);
 535                                         return 1;
 536                                 }
 537                                 close(tfd);
 538                                 tfd = -1;
 539                         }
 540                         if ((stb.st_mode & S_IFMT) != S_IFBLK) {
 541                                 fprintf(stderr, Name ": %s is not a "
 542                                         "block device.\n",
 543                                         dv->devname);
 544                                 return 1;
 545                         }
 546                 }
 547                 switch(dv->disposition){
 548                 default:
 549                         fprintf(stderr, Name ": internal error - devmode[%s]=%d\n",
 550                                 dv->devname, dv->disposition);
 551                         return 1;
 552                 case 'a':
 553                         /* add the device */
 554                         if (subarray) {
 555                                 fprintf(stderr, Name ": Cannot add disks to a"
 556                                         " \'member\' array, perform this"
 557                                         " operation on the parent container\n");
 558                                 return 1;
 559                         }
 560                         /* Make sure it isn't in use (in 2.6 or later) */
 561                         tfd = dev_open(add_dev, O_RDONLY|O_EXCL|O_DIRECT);
 562                         if (tfd < 0 && add_dev != dv->devname)
 563                                 continue;
 564                         if (tfd < 0) {
 565                                 fprintf(stderr, Name ": Cannot open %s: %s\n",
 566                                         dv->devname, strerror(errno));
 567                                 return 1;
 568                         }
 569
 570                         st = dup_super(tst);
 571
 572                         if (array.not_persistent==0)
 573                                 st->ss->load_super(st, tfd, NULL);
 574
 575                         if (add_dev == dv->devname) {
 576                                 if (!get_dev_size(tfd, dv->devname, &ldsize)) {
 577                                         close(tfd);
 578                                         return 1;
 579                                 }
 580                         } else if (!get_dev_size(tfd, NULL, &ldsize)) {
 581                                 close(tfd);
 582                                 tfd = -1;
 583                                 continue;
 584                         }
 585
 586                         if (!tst->ss->external &&
 587                             array.major_version == 0 &&
 588                             md_get_version(fd)%100 < 2) {
 589                                 close(tfd);
 590                                 tfd = -1;
 591                                 if (ioctl(fd, HOT_ADD_DISK,
 592                                           (unsigned long)stb.st_rdev)==0) {
 593                                         if (verbose >= 0)
 594                                                 fprintf(stderr, Name ": hot added %s\n",
 595                                                         add_dev);
 596                                         continue;
 597                                 }
 598
 599                                 fprintf(stderr, Name ": hot add failed for %s: %s\n",
 600                                         add_dev, strerror(errno));
 601                                 return 1;
 602                         }
 603
 604                         if (array.not_persistent == 0 || tst->ss->external) {
 605
 606                                 /* need to find a sample superblock to copy, and
 607                                  * a spare slot to use.
 608                                  * For 'external' array (well, container based),
 609                                  * We can just load the metadata for the array.
 610                                  */
 611                                 if (tst->sb)
 612                                         /* already loaded */;
 613                                 else if (tst->ss->external) {
 614                                         tst->ss->load_container(tst, fd, NULL);
 615                                 } else for (j = 0; j < tst->max_devs; j++) {
 616                                         char *dev;
 617                                         int dfd;
 618                                         disc.number = j;
 619                                         if (ioctl(fd, GET_DISK_INFO, &disc))
 620                                                 continue;
 621                                         if (disc.major==0 && disc.minor==0)
 622                                                 continue;
 623                                         if ((disc.state & 4)==0) continue; /* sync */
 624                                         /* Looks like a good device to try */
 625                                         dev = map_dev(disc.major, disc.minor, 1);
 626                                         if (!dev) continue;
 627                                         dfd = dev_open(dev, O_RDONLY);
 628                                         if (dfd < 0) continue;
 629                                         if (tst->ss->load_super(tst, dfd,
 630                                                                 NULL)) {
 631                                                 close(dfd);
 632                                                 continue;
 633                                         }
 634                                         close(dfd);
 635                                         break;
 636                                 }
 637                                 /* FIXME this is a bad test to be using */
 638                                 if (!tst->sb) {
 639                                         close(tfd);
 640                                         fprintf(stderr, Name ": cannot find valid superblock in this array - HELP\n");
 641                                         return 1;
 642                                 }
 643
 644                                 /* Make sure device is large enough */
 645                                 if (tst->ss->avail_size(tst, ldsize/512) <
 646                                     array_size) {
 647                                         close(tfd);
 648                                         tfd = -1;
 649                                         if (add_dev != dv->devname)
 650                                                 continue;
 651                                         fprintf(stderr, Name ": %s not large enough to join array\n",
 652                                                 dv->devname);
 653                                         return 1;
 654                                 }
 655
 656                                 /* Possibly this device was recently part of the array
 657                                  * and was temporarily removed, and is now being re-added.
 658                                  * If so, we can simply re-add it.
 659                                  */
 660                                 tst->ss->uuid_from_super(tst, duuid);
 661
 662                                 /* re-add doesn't work for version-1 superblocks
 663                                  * before 2.6.18 :-(
 664                                  */
 665                                 if (array.major_version == 1 &&
 666                                     get_linux_version() <= 2006018)
 667                                         ;
 668                                 else if (st->sb) {
 669                                         struct mdinfo mdi;
 670                                         st->ss->getinfo_super(st, &mdi, NULL);
 671                                         st->ss->uuid_from_super(st, ouuid);
 672                                         if ((mdi.disk.state & (1<<MD_DISK_ACTIVE)) &&
 673                                             !(mdi.disk.state & (1<<MD_DISK_FAULTY)) &&
 674                                             memcmp(duuid, ouuid, sizeof(ouuid))==0) {
 675                                                 /* look like it is worth a try.  Need to
 676                                                  * make sure kernel will accept it though.
 677                                                  */
 678                                                 disc.number = mdi.disk.number;
 679                                                 if (ioctl(fd, GET_DISK_INFO, &disc) != 0
 680                                                     || disc.major != 0 || disc.minor != 0
 681                                                     || !enough_fd(fd))
 682                                                         goto skip_re_add;
 683                                                 disc.major = major(stb.st_rdev);
 684                                                 disc.minor = minor(stb.st_rdev);
 685                                                 disc.number = mdi.disk.number;
 686                                                 disc.raid_disk = mdi.disk.raid_disk;
 687                                                 disc.state = mdi.disk.state;
 688                                                 if (dv->writemostly == 1)
 689                                                         disc.state |= 1 << MD_DISK_WRITEMOSTLY;
 690                                                 if (dv->writemostly == 2)
 691                                                         disc.state &= ~(1 << MD_DISK_WRITEMOSTLY);
 692                                                 remove_partitions(tfd);
 693                                                 close(tfd);
 694                                                 tfd = -1;
 695                                                 if (update) {
 696                                                         int rv = -1;
 697                                                         tfd = dev_open(dv->devname, O_RDWR);
 698
 699                                                         if (tfd >= 0)
 700                                                                 rv = st->ss->update_super(
 701                                                                         st, NULL, update,
 702                                                                         devname, verbose, 0, NULL);
 703                                                         if (rv == 0)
 704                                                                 rv = tst->ss->store_super(st, tfd);
 705                                                         close(tfd);
 706                                                         tfd = -1;
 707                                                         if (rv != 0) {
 708                                                                 fprintf(stderr, Name ": failed to update"
 709                                                                         " superblock during re-add\n");
 710                                                                 return 1;
 711                                                         }
 712                                                 }
 713                                                 /* don't even try if disk is marked as faulty */
 714                                                 errno = 0;
 715                                                 if (ioctl(fd, ADD_NEW_DISK, &disc) == 0) {
 716                                                         if (verbose >= 0)
 717                                                                 fprintf(stderr, Name ": re-added %s\n", add_dev);
 718                                                         count++;
 719                                                         continue;
 720                                                 }
 721                                                 if (errno == ENOMEM || errno == EROFS) {
 722                                                         fprintf(stderr, Name ": add new device failed for %s: %s\n",
 723                                                                 add_dev, strerror(errno));
 724                                                         if (add_dev != dv->devname)
 725                                                                 continue;
 726                                                         return 1;
 727                                                 }
 728                                         skip_re_add:
 729                                                 re_add_failed = 1;
 730                                         }
 731                                 }
 732                                 if (add_dev != dv->devname) {
 733                                         if (verbose > 0)
 734                                                 fprintf(stderr, Name
 735                                                         ": --re-add for %s to %s is not possible\n",
 736                                                         add_dev, devname);
 737                                         if (tfd >= 0) {
 738                                                 close(tfd);
 739                                                 tfd = -1;
 740                                         }
 741                                         continue;
 742                                 }
 743                                 if (dv->re_add) {
 744                                         if (tfd >= 0)
 745                                                 close(tfd);
 746                                         fprintf(stderr, Name
 747                                                 ": --re-add for %s to %s is not possible\n",
 748                                                 dv->devname, devname);
 749                                         return 1;
 750                                 }
 751                                 if (re_add_failed) {
 752                                         fprintf(stderr, Name ": %s reports being an active member for %s, but a --re-add fails.\n",
 753                                                 dv->devname, devname);
 754                                         fprintf(stderr, Name ": not performing --add as that would convert %s in to a spare.\n",
 755                                                 dv->devname);
 756                                         fprintf(stderr, Name ": To make this a spare, use \"mdadm --zero-superblock %s\" first.\n",
 757                                                 dv->devname);
 758                                         if (tfd >= 0)
 759                                                 close(tfd);
 760                                         return 1;
 761                                 }
 762                         } else {
 763                                 /* non-persistent. Must ensure that new drive
 764                                  * is at least array.size big.
 765                                  */
 766                                 if (ldsize/512 < array_size) {
 767                                         fprintf(stderr, Name ": %s not large enough to join array\n",
 768                                                 dv->devname);
 769                                         if (tfd >= 0)
 770                                                 close(tfd);
 771                                         return 1;
 772                                 }
 773                         }
 774                         /* committed to really trying this device now*/
 775                         if (tfd >= 0) {
 776                                 remove_partitions(tfd);
 777                                 close(tfd);
 778                                 tfd = -1;
 779                         }
 780                         /* in 2.6.17 and earlier, version-1 superblocks won't
 781                          * use the number we write, but will choose a free number.
 782                          * we must choose the same free number, which requires
 783                          * starting at 'raid_disks' and counting up
 784                          */
 785                         for (j = array.raid_disks; j< tst->max_devs; j++) {
 786                                 disc.number = j;
 787                                 if (ioctl(fd, GET_DISK_INFO, &disc))
 788                                         break;
 789                                 if (disc.major==0 && disc.minor==0)
 790                                         break;
 791                                 if (disc.state & 8) /* removed */
 792                                         break;
 793                         }
 794                         disc.major = major(stb.st_rdev);
 795                         disc.minor = minor(stb.st_rdev);
 796                         disc.number =j;
 797                         disc.state = 0;
 798                         if (array.not_persistent==0 || tst->ss->external) {
 799                                 int dfd;
 800                                 if (dv->writemostly == 1)
 801                                         disc.state |= 1 << MD_DISK_WRITEMOSTLY;
 802                                 dfd = dev_open(dv->devname, O_RDWR | O_EXCL|O_DIRECT);
 803                                 if (tst->ss->add_to_super(tst, &disc, dfd,
 804                                                           dv->devname)) {
 805                                         close(dfd);
 806                                         return 1;
 807                                 }
 808                                 /* write_init_super will close 'dfd' */
 809                                 if (tst->ss->external)
 810                                         /* mdmon will write the metadata */
 811                                         close(dfd);
 812                                 else if (tst->ss->write_init_super(tst))
 813                                         return 1;
 814                         } else if (dv->re_add) {
 815                                 /*  this had better be raid1.
 816                                  * As we are "--re-add"ing we must find a spare slot
 817                                  * to fill.
 818                                  */
 819                                 char *used = malloc(array.raid_disks);
 820                                 memset(used, 0, array.raid_disks);
 821                                 for (j=0; j< tst->max_devs; j++) {
 822                                         mdu_disk_info_t disc2;
 823                                         disc2.number = j;
 824                                         if (ioctl(fd, GET_DISK_INFO, &disc2))
 825                                                 continue;
 826                                         if (disc2.major==0 && disc2.minor==0)
 827                                                 continue;
 828                                         if (disc2.state & 8) /* removed */
 829                                                 continue;
 830                                         if (disc2.raid_disk < 0)
 831                                                 continue;
 832                                         if (disc2.raid_disk > array.raid_disks)
 833                                                 continue;
 834                                         used[disc2.raid_disk] = 1;
 835                                 }
 836                                 for (j=0 ; j<array.raid_disks; j++)
 837                                         if (!used[j]) {
 838                                                 disc.raid_disk = j;
 839                                                 disc.state |= (1<<MD_DISK_SYNC);
 840                                                 break;
 841                                         }
 842                                 free(used);
 843                         }
 844                         if (dv->writemostly == 1)
 845                                 disc.state |= (1 << MD_DISK_WRITEMOSTLY);
 846                         if (tst->ss->external) {
 847                                 /* add a disk to an external metadata container
 848                                  * only if mdmon is around to see it
 849                                  */
 850                                 struct mdinfo new_mdi;
 851                                 struct mdinfo *sra;
 852                                 int container_fd;
 853                                 int devnum = fd2devnum(fd);
 854
 855                                 container_fd = open_dev_excl(devnum);
 856                                 if (container_fd < 0) {
 857                                         fprintf(stderr, Name ": add failed for %s:"
 858                                                 " could not get exclusive access to container\n",
 859                                                 dv->devname);
 860                                         return 1;
 861                                 }
 862
 863                                 if (!mdmon_running(devnum)) {
 864                                         fprintf(stderr, Name ": add failed for %s: mdmon not running\n",
 865                                                 dv->devname);
 866                                         close(container_fd);
 867                                         return 1;
 868                                 }
 869
 870                                 sra = sysfs_read(container_fd, -1, 0);
 871                                 if (!sra) {
 872                                         fprintf(stderr, Name ": add failed for %s: sysfs_read failed\n",
 873                                                 dv->devname);
 874                                         close(container_fd);
 875                                         return 1;
 876                                 }
 877                                 sra->array.level = LEVEL_CONTAINER;
 878                                 /* Need to set data_offset and component_size */
 879                                 tst->ss->getinfo_super(tst, &new_mdi, NULL);
 880                                 new_mdi.disk.major = disc.major;
 881                                 new_mdi.disk.minor = disc.minor;
 882                                 new_mdi.recovery_start = 0;
 883                                 if (sysfs_add_disk(sra, &new_mdi, 0) != 0) {
 884                                         fprintf(stderr, Name ": add new device to external metadata"
 885                                                 " failed for %s\n", dv->devname);
 886                                         close(container_fd);
 887                                         return 1;
 888                                 }
 889                                 ping_monitor(devnum2devname(devnum));
 890                                 sysfs_free(sra);
 891                                 close(container_fd);
 892                         } else if (ioctl(fd, ADD_NEW_DISK, &disc)) {
 893                                 fprintf(stderr, Name ": add new device failed for %s as %d: %s\n",
 894                                         dv->devname, j, strerror(errno));
 895                                 return 1;
 896                         }
 897                         if (verbose >= 0)
 898                                 fprintf(stderr, Name ": added %s\n", dv->devname);
 899                         break;
 900
 901                 case 'r':
 902                         /* hot remove */
 903                         if (subarray) {
 904                                 fprintf(stderr, Name ": Cannot remove disks from a"
 905                                         " \'member\' array, perform this"
 906                                         " operation on the parent container\n");
 907                                 if (sysfd >= 0)
 908                                         close(sysfd);
 909                                 return 1;
 910                         }
 911                         if (tst->ss->external) {
 912                                 /* To remove a device from a container, we must
 913                                  * check that it isn't in use in an array.
 914                                  * This involves looking in the 'holders'
 915                                  * directory - there must be just one entry,
 916                                  * the container.
 917                                  * To ensure that it doesn't get used as a
 918                                  * hold spare while we are checking, we
 919                                  * get an O_EXCL open on the container
 920                                  */
 921                                 int dnum = fd2devnum(fd);
 922                                 lfd = open_dev_excl(dnum);
 923                                 if (lfd < 0) {
 924                                         fprintf(stderr, Name
 925                                                 ": Cannot get exclusive access "
 926                                                 " to container - odd\n");
 927                                         if (sysfd >= 0)
 928                                                 close(sysfd);
 929                                         return 1;
 930                                 }
 931                                 /* in the detached case it is not possible to
 932                                  * check if we are the unique holder, so just
 933                                  * rely on the 'detached' checks
 934                                  */
 935                                 if (strcmp(dv->devname, "detached") == 0 ||
 936                                     sysfd >= 0 ||
 937                                     sysfs_unique_holder(dnum, stb.st_rdev))
 938                                         /* pass */;
 939                                 else {
 940                                         fprintf(stderr, Name
 941                                                 ": %s is %s, cannot remove.\n",
 942                                                 dnprintable,
 943                                                 errno == EEXIST ? "still in use":
 944                                                 "not a member");
 945                                         close(lfd);
 946                                         return 1;
 947                                 }
 948                         }
 949                         /* FIXME check that it is a current member */
 950                         if (sysfd >= 0) {
 951                                 /* device has been removed and we don't know
 952                                  * the major:minor number
 953                                  */
 954                                 int n = write(sysfd, "remove", 6);
 955                                 if (n != 6)
 956                                         err = -1;
 957                                 else
 958                                         err = 0;
 959                                 close(sysfd);
 960                                 sysfd = -1;
 961                         } else {
 962                                 err = ioctl(fd, HOT_REMOVE_DISK, (unsigned long)stb.st_rdev);
 963                                 if (err && errno == ENODEV) {
 964                                         /* Old kernels rejected this if no personality
 965                                          * registered */
 966                                         struct mdinfo *sra = sysfs_read(fd, 0, GET_DEVS);
 967                                         struct mdinfo *dv = NULL;
 968                                         if (sra)
 969                                                 dv = sra->devs;
 970                                         for ( ; dv ; dv=dv->next)
 971                                                 if (dv->disk.major == (int)major(stb.st_rdev) &&
 972                                                     dv->disk.minor == (int)minor(stb.st_rdev))
 973                                                         break;
 974                                         if (dv)
 975                                                 err = sysfs_set_str(sra, dv,
 976                                                                     "state", "remove");
 977                                         else
 978                                                 err = -1;
 979                                         if (sra)
 980                                                 sysfs_free(sra);
 981                                 }
 982                         }
 983                         if (err) {
 984                                 fprintf(stderr, Name ": hot remove failed "
 985                                         "for %s: %s\n", dnprintable,
 986                                         strerror(errno));
 987                                 if (lfd >= 0)
 988                                         close(lfd);
 989                                 return 1;
 990                         }
 991                         if (tst->ss->external) {
 992                                 /*
 993                                  * Before dropping our exclusive open we make an
 994                                  * attempt at preventing mdmon from seeing an
 995                                  * 'add' event before reconciling this 'remove'
 996                                  * event.
 997                                  */
 998                                 char *name = devnum2devname(fd2devnum(fd));
 999
1000                                 if (!name) {
1001                                         fprintf(stderr, Name ": unable to get container name\n");
1002                                         return 1;
1003                                 }
1004
1005                                 ping_manager(name);
1006                                 free(name);
1007                         }
1008                         if (lfd >= 0)
1009                                 close(lfd);
1010                         count++;
1011                         if (verbose >= 0)
1012                                 fprintf(stderr, Name ": hot removed %s from %s\n",
1013                                         dnprintable, devname);
1014                         break;
1015
1016                 case 'f': /* set faulty */
1017                         /* FIXME check current member */
1018                         if ((sysfd >= 0 && write(sysfd, "faulty", 6) != 6) ||
1019                             (sysfd < 0 && ioctl(fd, SET_DISK_FAULTY,
1020                                                 (unsigned long) stb.st_rdev))) {
1021                                 fprintf(stderr, Name ": set device faulty failed for %s:  %s\n",
1022                                         dnprintable, strerror(errno));
1023                                 if (sysfd >= 0)
1024                                         close(sysfd);
1025                                 return 1;
1026                         }
1027                         if (sysfd >= 0)
1028                                 close(sysfd);
1029                         sysfd = -1;
1030                         count++;
1031                         if (verbose >= 0)
1032                                 fprintf(stderr, Name ": set %s faulty in %s\n",
1033                                         dnprintable, devname);
1034                         break;
1035                 }
1036         }
1037         if (test && count == 0)
1038                 return 2;
1039         return 0;
1040 }
1041
1042 int autodetect(void)
1043 {
1044         /* Open any md device, and issue the RAID_AUTORUN ioctl */
1045         int rv = 1;
1046         int fd = dev_open("9:0", O_RDONLY);
1047         if (fd >= 0) {
1048                 if (ioctl(fd, RAID_AUTORUN, 0) == 0)
1049                         rv = 0;
1050                 close(fd);
1051         }
1052         return rv;
1053 }
1054
1055 int Update_subarray(char *dev, char *subarray, char *update, struct mddev_ident *ident, int quiet)
1056 {
1057         struct supertype supertype, *st = &supertype;
1058         int fd, rv = 2;
1059
1060         memset(st, 0, sizeof(*st));
1061
1062         fd = open_subarray(dev, subarray, st, quiet);
1063         if (fd < 0)
1064                 return 2;
1065
1066         if (!st->ss->update_subarray) {
1067                 if (!quiet)
1068                         fprintf(stderr,
1069                                 Name ": Operation not supported for %s metadata\n",
1070                                 st->ss->name);
1071                 goto free_super;
1072         }
1073
1074         if (mdmon_running(st->devnum))
1075                 st->update_tail = &st->updates;
1076
1077         rv = st->ss->update_subarray(st, subarray, update, ident);
1078
1079         if (rv) {
1080                 if (!quiet)
1081                         fprintf(stderr, Name ": Failed to update %s of subarray-%s in %s\n",
1082                                 update, subarray, dev);
1083         } else if (st->update_tail)
1084                 flush_metadata_updates(st);
1085         else
1086                 st->ss->sync_metadata(st);
1087
1088         if (rv == 0 && strcmp(update, "name") == 0 && !quiet)
1089                 fprintf(stderr,
1090                         Name ": Updated subarray-%s name from %s, UUIDs may have changed\n",
1091                         subarray, dev);
1092
1093  free_super:
1094         st->ss->free_super(st);
1095         close(fd);
1096
1097         return rv;
1098 }
1099 #endif