managemon.c

   1 /*
   2  * mdmon - monitor external metadata arrays
   3  *
   4  * Copyright (C) 2007-2009 Neil Brown <neilb@suse.de>
   5  * Copyright (C) 2007-2009 Intel Corporation
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms and conditions of the GNU General Public License,
   9  * version 2, as published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14  * more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with
  17  * this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  19  */
  20
  21 /*
  22  * The management thread for monitoring active md arrays.
  23  * This thread does things which might block such as memory
  24  * allocation.
  25  * In particular:
  26  *
  27  * - Find out about new arrays in this container.
  28  *   Allocate the data structures and open the files.
  29  *
  30  *   For this we watch /proc/mdstat and find new arrays with
  31  *   metadata type that confirms sharing. e.g. "md4"
  32  *   When we find a new array we slip it into the list of
  33  *   arrays and signal 'monitor' by writing to a pipe.
  34  *
  35  * - Respond to reshape requests by allocating new data structures
  36  *   and opening new files.
  37  *
  38  *   These come as a change to raid_disks.  We allocate a new
  39  *   version of the data structures and slip it into the list.
  40  *   'monitor' will notice and release the old version.
  41  *   Changes to level, chunksize, layout.. do not need re-allocation.
  42  *   Reductions in raid_disks don't really either, but we handle
  43  *   them the same way for consistency.
  44  *
  45  * - When a device is added to the container, we add it to the metadata
  46  *   as a spare.
  47  *
  48  * - Deal with degraded array
  49  *    We only do this when first noticing the array is degraded.
  50  *    This can be when we first see the array, when sync completes or
  51  *    when recovery completes.
  52  *
  53  *    Check if number of failed devices suggests recovery is needed, and
  54  *    skip if not.
  55  *    Ask metadata to allocate a spare device
  56  *    Add device as not in_sync and give a role
  57  *    Update metadata.
  58  *    Open sysfs files and pass to monitor.
  59  *    Make sure that monitor Starts recovery....
  60  *
  61  * - Pass on metadata updates from external programs such as
  62  *   mdadm creating a new array.
  63  *
  64  *   This is most-messy.
  65  *   It might involve adding a new array or changing the status of
  66  *   a spare, or any reconfig that the kernel doesn't get involved in.
  67  *
  68  *   The required updates are received via a named pipe.  There will
  69  *   be one named pipe for each container. Each message contains a
  70  *   sync marker: 0x5a5aa5a5, A byte count, and the message.  This is
  71  *   passed to the metadata handler which will interpret and process it.
  72  *   For 'DDF' messages are internal data blocks with the leading
  73  *   'magic number' signifying what sort of data it is.
  74  *
  75  */
  76
  77 /*
  78  * We select on /proc/mdstat and the named pipe.
  79  * We create new arrays or updated version of arrays and slip
  80  * them into the head of the list, then signal 'monitor' via a pipe write.
  81  * 'monitor' will notice and place the old array on a return list.
  82  * Metadata updates are placed on a queue just like they arrive
  83  * from the named pipe.
  84  *
  85  * When new arrays are found based on correct metadata string, we
  86  * need to identify them with an entry in the metadata.  Maybe we require
  87  * the metadata to be mdX/NN  when NN is the index into an appropriate table.
  88  *
  89  */
  90
  91 /*
  92  * List of tasks:
  93  * - Watch for spares to be added to the container, and write updated
  94  *   metadata to them.
  95  * - Watch for new arrays using this container, confirm they match metadata
  96  *   and if so, start monitoring them
  97  * - Watch for spares being added to monitored arrays.  This shouldn't
  98  *   happen, as we should do all the adding.  Just remove them.
  99  * - Watch for change in raid-disks, chunk-size, etc.  Update metadata and
 100  *   start a reshape.
 101  */
 102 #ifndef _GNU_SOURCE
 103 #define _GNU_SOURCE
 104 #endif
 105 #include        "mdadm.h"
 106 #include        "mdmon.h"
 107 #include        <sys/syscall.h>
 108 #include        <sys/socket.h>
 109 #include        <signal.h>
 110
 111 static void close_aa(struct active_array *aa)
 112 {
 113         struct mdinfo *d;
 114
 115         for (d = aa->info.devs; d; d = d->next) {
 116                 close(d->recovery_fd);
 117                 close(d->state_fd);
 118                 close(d->bb_fd);
 119                 close(d->ubb_fd);
 120         }
 121
 122         if (aa->action_fd >= 0)
 123                 close(aa->action_fd);
 124         if (aa->info.state_fd >= 0)
 125                 close(aa->info.state_fd);
 126         if (aa->resync_start_fd >= 0)
 127                 close(aa->resync_start_fd);
 128         if (aa->metadata_fd >= 0)
 129                 close(aa->metadata_fd);
 130         if (aa->sync_completed_fd >= 0)
 131                 close(aa->sync_completed_fd);
 132 }
 133
 134 static void free_aa(struct active_array *aa)
 135 {
 136         /* Note that this doesn't close fds if they are being used
 137          * by a clone.  ->container will be set for a clone
 138          */
 139         dprintf("sys_name: %s\n", aa->info.sys_name);
 140         if (!aa->container)
 141                 close_aa(aa);
 142         while (aa->info.devs) {
 143                 struct mdinfo *d = aa->info.devs;
 144                 aa->info.devs = d->next;
 145                 free(d);
 146         }
 147         free(aa);
 148 }
 149
 150 static struct active_array *duplicate_aa(struct active_array *aa)
 151 {
 152         struct active_array *newa = xmalloc(sizeof(*newa));
 153         struct mdinfo **dp1, **dp2;
 154
 155         *newa = *aa;
 156         newa->next = NULL;
 157         newa->replaces = NULL;
 158         newa->info.next = NULL;
 159
 160         dp2 = &newa->info.devs;
 161
 162         for (dp1 = &aa->info.devs; *dp1; dp1 = &(*dp1)->next) {
 163                 struct mdinfo *d;
 164                 if ((*dp1)->state_fd < 0)
 165                         continue;
 166
 167                 d = xmalloc(sizeof(*d));
 168                 *d = **dp1;
 169                 *dp2 = d;
 170                 dp2 = & d->next;
 171         }
 172         *dp2 = NULL;
 173
 174         return newa;
 175 }
 176
 177 static void wakeup_monitor(void)
 178 {
 179         /* tgkill(getpid(), mon_tid, SIGUSR1); */
 180         int pid = getpid();
 181         syscall(SYS_tgkill, pid, mon_tid, SIGUSR1);
 182 }
 183
 184 static void remove_old(void)
 185 {
 186         if (discard_this) {
 187                 discard_this->next = NULL;
 188                 free_aa(discard_this);
 189                 if (pending_discard == discard_this)
 190                         pending_discard = NULL;
 191                 discard_this = NULL;
 192                 wakeup_monitor();
 193         }
 194 }
 195
 196 static void replace_array(struct supertype *container,
 197                           struct active_array *old,
 198                           struct active_array *new)
 199 {
 200         /* To replace an array, we add it to the top of the list
 201          * marked with ->replaces to point to the original.
 202          * 'monitor' will take the original out of the list
 203          * and put it on 'discard_this'.  We take it from there
 204          * and discard it.
 205          */
 206         remove_old();
 207         while (pending_discard) {
 208                 while (discard_this == NULL)
 209                         sleep(1);
 210                 remove_old();
 211         }
 212         pending_discard = old;
 213         new->replaces = old;
 214         new->next = container->arrays;
 215         container->arrays = new;
 216         wakeup_monitor();
 217 }
 218
 219 struct metadata_update *update_queue = NULL;
 220 struct metadata_update *update_queue_handled = NULL;
 221 struct metadata_update *update_queue_pending = NULL;
 222
 223 static void free_updates(struct metadata_update **update)
 224 {
 225         while (*update) {
 226                 struct metadata_update *this = *update;
 227                 void **space_list = this->space_list;
 228
 229                 *update = this->next;
 230                 free(this->buf);
 231                 free(this->space);
 232                 while (space_list) {
 233                         void *space = space_list;
 234                         space_list = *space_list;
 235                         free(space);
 236                 }
 237                 free(this);
 238         }
 239 }
 240
 241 void check_update_queue(struct supertype *container)
 242 {
 243         free_updates(&update_queue_handled);
 244
 245         if (update_queue == NULL &&
 246             update_queue_pending) {
 247                 update_queue = update_queue_pending;
 248                 update_queue_pending = NULL;
 249                 wakeup_monitor();
 250         }
 251 }
 252
 253 static void queue_metadata_update(struct metadata_update *mu)
 254 {
 255         struct metadata_update **qp;
 256
 257         qp = &update_queue_pending;
 258         while (*qp)
 259                 qp = & ((*qp)->next);
 260         *qp = mu;
 261 }
 262
 263 static void add_disk_to_container(struct supertype *st, struct mdinfo *sd)
 264 {
 265         int dfd;
 266         char nm[20];
 267         struct supertype *st2;
 268         struct metadata_update *update = NULL;
 269         struct mdinfo info;
 270         mdu_disk_info_t dk = {
 271                 .number = -1,
 272                 .major = sd->disk.major,
 273                 .minor = sd->disk.minor,
 274                 .raid_disk = -1,
 275                 .state = 0,
 276         };
 277
 278         dprintf("add %d:%d to container\n", sd->disk.major, sd->disk.minor);
 279
 280         sd->next = st->devs;
 281         st->devs = sd;
 282
 283         sprintf(nm, "%d:%d", sd->disk.major, sd->disk.minor);
 284         dfd = dev_open(nm, O_RDWR);
 285         if (dfd < 0)
 286                 return;
 287
 288         /* Check the metadata and see if it is already part of this
 289          * array
 290          */
 291         st2 = dup_super(st);
 292         if (st2->ss->load_super(st2, dfd, NULL) == 0) {
 293                 st2->ss->getinfo_super(st2, &info, NULL);
 294                 if (st->ss->compare_super(st, st2) == 0 &&
 295                     info.disk.raid_disk >= 0) {
 296                         /* Looks like a good member of array.
 297                          * Just accept it.
 298                          * mdadm will incorporate any parts into
 299                          * active arrays.
 300                          */
 301                         st2->ss->free_super(st2);
 302                         return;
 303                 }
 304         }
 305         st2->ss->free_super(st2);
 306
 307         st->update_tail = &update;
 308         st->ss->add_to_super(st, &dk, dfd, NULL, INVALID_SECTORS);
 309         st->ss->write_init_super(st);
 310         queue_metadata_update(update);
 311         st->update_tail = NULL;
 312 }
 313
 314 /*
 315  * Create and queue update structure about the removed disks.
 316  * The update is prepared by super type handler and passed to the monitor
 317  * thread.
 318  */
 319 static void remove_disk_from_container(struct supertype *st, struct mdinfo *sd)
 320 {
 321         struct metadata_update *update = NULL;
 322         mdu_disk_info_t dk = {
 323                 .number = -1,
 324                 .major = sd->disk.major,
 325                 .minor = sd->disk.minor,
 326                 .raid_disk = -1,
 327                 .state = 0,
 328         };
 329         dprintf("remove %d:%d from container\n",
 330                 sd->disk.major, sd->disk.minor);
 331
 332         st->update_tail = &update;
 333         st->ss->remove_from_super(st, &dk);
 334         /* FIXME this write_init_super shouldn't be here.
 335          * We have it after add_to_super to write to new device,
 336          * but with 'remove' we don't ant to write to that device!
 337          */
 338         st->ss->write_init_super(st);
 339         queue_metadata_update(update);
 340         st->update_tail = NULL;
 341 }
 342
 343 static void manage_container(struct mdstat_ent *mdstat,
 344                              struct supertype *container)
 345 {
 346         /* Of interest here are:
 347          * - if a new device has been added to the container, we
 348          *   add it to the array ignoring any metadata on it.
 349          * - if a device has been removed from the container, we
 350          *   remove it from the device list and update the metadata.
 351          * FIXME should we look for compatible metadata and take hints
 352          * about spare assignment.... probably not.
 353          */
 354         if (mdstat->devcnt != container->devcnt) {
 355                 struct mdinfo **cdp, *cd, *di, *mdi;
 356                 int found;
 357
 358                 /* read /sys/block/NAME/md/dev-??/block/dev to find out
 359                  * what is there, and compare with container->info.devs
 360                  * To see what is removed and what is added.
 361                  * These need to be remove from, or added to, the array
 362                  */
 363                 mdi = sysfs_read(-1, mdstat->devnm, GET_DEVS);
 364                 if (!mdi) {
 365                         /* invalidate the current count so we can try again */
 366                         container->devcnt = -1;
 367                         return;
 368                 }
 369
 370                 /* check for removals */
 371                 for (cdp = &container->devs; *cdp; ) {
 372                         found = 0;
 373                         for (di = mdi->devs; di; di = di->next)
 374                                 if (di->disk.major == (*cdp)->disk.major &&
 375                                     di->disk.minor == (*cdp)->disk.minor) {
 376                                         found = 1;
 377                                         break;
 378                                 }
 379                         if (!found) {
 380                                 cd = *cdp;
 381                                 *cdp = (*cdp)->next;
 382                                 remove_disk_from_container(container, cd);
 383                                 free(cd);
 384                         } else
 385                                 cdp = &(*cdp)->next;
 386                 }
 387
 388                 /* check for additions */
 389                 for (di = mdi->devs; di; di = di->next) {
 390                         for (cd = container->devs; cd; cd = cd->next)
 391                                 if (di->disk.major == cd->disk.major &&
 392                                     di->disk.minor == cd->disk.minor)
 393                                         break;
 394                         if (!cd) {
 395                                 struct mdinfo *newd = xmalloc(sizeof(*newd));
 396
 397                                 *newd = *di;
 398                                 add_disk_to_container(container, newd);
 399                         }
 400                 }
 401                 sysfs_free(mdi);
 402                 container->devcnt = mdstat->devcnt;
 403         }
 404 }
 405
 406 static int sysfs_open2(char *devnum, char *name, char *attr)
 407 {
 408         int fd = sysfs_open(devnum, name, attr);
 409         if (fd >= 0) {
 410                 /* seq_file in the kernel allocates buffer space
 411                  * on the first read.  Do that now so 'monitor'
 412                  * never needs too.
 413                  */
 414                 char buf[200];
 415                 if (read(fd, buf, sizeof(buf)) < 0)
 416                         /* pretend not to ignore return value */
 417                         return fd;
 418         }
 419         return fd;
 420 }
 421
 422 static int disk_init_and_add(struct mdinfo *disk, struct mdinfo *clone,
 423                              struct active_array *aa)
 424 {
 425         if (!disk || !clone)
 426                 return -1;
 427
 428         *disk = *clone;
 429         disk->recovery_fd = sysfs_open2(aa->info.sys_name, disk->sys_name,
 430                                         "recovery_start");
 431         if (disk->recovery_fd < 0)
 432                 return -1;
 433         disk->state_fd = sysfs_open2(aa->info.sys_name, disk->sys_name, "state");
 434         if (disk->state_fd < 0) {
 435                 close(disk->recovery_fd);
 436                 return -1;
 437         }
 438         disk->bb_fd = sysfs_open2(aa->info.sys_name, disk->sys_name,
 439                                  "bad_blocks");
 440         if (disk->bb_fd < 0) {
 441                 close(disk->recovery_fd);
 442                 close(disk->state_fd);
 443                 return -1;
 444         }
 445         disk->ubb_fd = sysfs_open2(aa->info.sys_name, disk->sys_name,
 446                                   "unacknowledged_bad_blocks");
 447         if (disk->ubb_fd < 0) {
 448                 close(disk->recovery_fd);
 449                 close(disk->state_fd);
 450                 close(disk->bb_fd);
 451                 return -1;
 452         }
 453         disk->prev_state = read_dev_state(disk->state_fd);
 454         disk->curr_state = disk->prev_state;
 455         disk->next = aa->info.devs;
 456         aa->info.devs = disk;
 457
 458         return 0;
 459 }
 460
 461 static void manage_member(struct mdstat_ent *mdstat,
 462                           struct active_array *a)
 463 {
 464         /* Compare mdstat info with known state of member array.
 465          * We do not need to look for device state changes here, that
 466          * is dealt with by the monitor.
 467          *
 468          * If a reshape is being requested, monitor will have noticed
 469          * that sync_action changed and will have set check_reshape.
 470          * We just need to see if new devices have appeared.  All metadata
 471          * updates will already have been processed.
 472          *
 473          * We also want to handle degraded arrays here by
 474          * trying to find and assign a spare.
 475          * We do that whenever the monitor tells us too.
 476          */
 477         char buf[64];
 478         int frozen;
 479         struct supertype *container = a->container;
 480         unsigned long long int component_size = 0;
 481
 482         if (container == NULL)
 483                 /* Raced with something */
 484                 return;
 485
 486         if (mdstat->active) {
 487                 // FIXME
 488                 a->info.array.raid_disks = mdstat->raid_disks;
 489                 // MORE
 490         }
 491
 492         if (sysfs_get_ll(&a->info, NULL, "component_size", &component_size) >= 0)
 493                 a->info.component_size = component_size << 1;
 494
 495         /* honor 'frozen' */
 496         if (sysfs_get_str(&a->info, NULL, "metadata_version", buf, sizeof(buf)) > 0)
 497                 frozen = buf[9] == '-';
 498         else
 499                 frozen = 1; /* can't read metadata_version assume the worst */
 500
 501         /* If sync_action is not 'idle' then don't try recovery now */
 502         if (!frozen
 503             && sysfs_get_str(&a->info, NULL, "sync_action", buf, sizeof(buf)) > 0
 504             && strncmp(buf, "idle", 4) != 0)
 505                 frozen = 1;
 506
 507         if (mdstat->level) {
 508                 int level = map_name(pers, mdstat->level);
 509                 if (level == 0 || level == LEVEL_LINEAR) {
 510                         a->to_remove = 1;
 511                         wakeup_monitor();
 512                         return;
 513                 }
 514                 else if (a->info.array.level != level && level > 0) {
 515                         struct active_array *newa = duplicate_aa(a);
 516                         if (newa) {
 517                                 newa->info.array.level = level;
 518                                 replace_array(container, a, newa);
 519                                 a = newa;
 520                         }
 521                 }
 522         }
 523
 524         /* we are after monitor kick,
 525          * so container field can be cleared - check it again
 526          */
 527         if (a->container == NULL)
 528                 return;
 529
 530         if (sigterm && a->info.safe_mode_delay != 1) {
 531                 sysfs_set_safemode(&a->info, 1);
 532                 a->info.safe_mode_delay = 1;
 533         }
 534
 535         /* We don't check the array while any update is pending, as it
 536          * might container a change (such as a spare assignment) which
 537          * could affect our decisions.
 538          */
 539         if (a->check_degraded && !frozen &&
 540             update_queue == NULL && update_queue_pending == NULL) {
 541                 struct metadata_update *updates = NULL;
 542                 struct mdinfo *newdev = NULL;
 543                 struct active_array *newa;
 544                 struct mdinfo *d;
 545
 546                 a->check_degraded = 0;
 547
 548                 /* The array may not be degraded, this is just a good time
 549                  * to check.
 550                  */
 551                 newdev = container->ss->activate_spare(a, &updates);
 552                 if (!newdev)
 553                         return;
 554
 555                 newa = duplicate_aa(a);
 556                 if (!newa)
 557                         goto out;
 558                 /* prevent the kernel from activating the disk(s) before we
 559                  * finish adding them
 560                  */
 561                 dprintf("freezing %s\n", a->info.sys_name);
 562                 sysfs_set_str(&a->info, NULL, "sync_action", "frozen");
 563
 564                 /* Add device to array and set offset/size/slot.
 565                  * and open files for each newdev */
 566                 for (d = newdev; d ; d = d->next) {
 567                         struct mdinfo *newd;
 568
 569                         newd = xmalloc(sizeof(*newd));
 570                         if (sysfs_add_disk(&newa->info, d, 0) < 0) {
 571                                 free(newd);
 572                                 continue;
 573                         }
 574                         disk_init_and_add(newd, d, newa);
 575                 }
 576                 queue_metadata_update(updates);
 577                 updates = NULL;
 578                 while (update_queue_pending || update_queue) {
 579                         check_update_queue(container);
 580                         usleep(15*1000);
 581                 }
 582                 replace_array(container, a, newa);
 583                 if (sysfs_set_str(&a->info, NULL, "sync_action", "recover")
 584                     == 0)
 585                         newa->prev_action = recover;
 586                 dprintf("recovery started on %s\n", a->info.sys_name);
 587  out:
 588                 while (newdev) {
 589                         d = newdev->next;
 590                         free(newdev);
 591                         newdev = d;
 592                 }
 593                 free_updates(&updates);
 594         }
 595
 596         if (a->check_reshape) {
 597                 /* mdadm might have added some devices to the array.
 598                  * We want to disk_init_and_add any such device to a
 599                  * duplicate_aa and replace a with that.
 600                  * mdstat doesn't have enough info so we sysfs_read
 601                  * and look for new stuff.
 602                  */
 603                 struct mdinfo *info, *d, *d2, *newd;
 604                 unsigned long long array_size;
 605                 struct active_array *newa = NULL;
 606                 a->check_reshape = 0;
 607                 info = sysfs_read(-1, mdstat->devnm,
 608                                   GET_DEVS|GET_OFFSET|GET_SIZE|GET_STATE);
 609                 if (!info)
 610                         goto out2;
 611                 for (d = info->devs; d; d = d->next) {
 612                         if (d->disk.raid_disk < 0)
 613                                 continue;
 614                         for (d2 = a->info.devs; d2; d2 = d2->next)
 615                                 if (d2->disk.raid_disk ==
 616                                     d->disk.raid_disk)
 617                                         break;
 618                         if (d2)
 619                                 /* already have this one */
 620                                 continue;
 621                         if (!newa) {
 622                                 newa = duplicate_aa(a);
 623                                 if (!newa)
 624                                         break;
 625                         }
 626                         newd = xmalloc(sizeof(*newd));
 627                         disk_init_and_add(newd, d, newa);
 628                 }
 629                 if (sysfs_get_ll(info, NULL, "array_size", &array_size) == 0
 630                     && a->info.custom_array_size > array_size*2) {
 631                         sysfs_set_num(info, NULL, "array_size",
 632                                       a->info.custom_array_size/2);
 633                 }
 634         out2:
 635                 sysfs_free(info);
 636                 if (newa)
 637                         replace_array(container, a, newa);
 638         }
 639 }
 640
 641 static int aa_ready(struct active_array *aa)
 642 {
 643         struct mdinfo *d;
 644         int level = aa->info.array.level;
 645
 646         for (d = aa->info.devs; d; d = d->next)
 647                 if (d->state_fd < 0)
 648                         return 0;
 649
 650         if (aa->info.state_fd < 0)
 651                 return 0;
 652
 653         if (level > 0 && (aa->action_fd < 0 || aa->resync_start_fd < 0))
 654                 return 0;
 655
 656         if (!aa->container)
 657                 return 0;
 658
 659         return 1;
 660 }
 661
 662 static void manage_new(struct mdstat_ent *mdstat,
 663                        struct supertype *container,
 664                        struct active_array *victim)
 665 {
 666         /* A new array has appeared in this container.
 667          * Hopefully it is already recorded in the metadata.
 668          * Check, then create the new array to report it to
 669          * the monitor.
 670          */
 671
 672         struct active_array *new;
 673         struct mdinfo *mdi, *di;
 674         char *inst;
 675         int i;
 676         int failed = 0;
 677         char buf[40];
 678
 679         /* check if array is ready to be monitored */
 680         if (!mdstat->active || !mdstat->level)
 681                 return;
 682         if (strcmp(mdstat->level, "raid0") == 0 ||
 683             strcmp(mdstat->level, "linear") == 0)
 684                 return;
 685
 686         mdi = sysfs_read(-1, mdstat->devnm,
 687                          GET_LEVEL|GET_CHUNK|GET_DISKS|GET_COMPONENT|
 688                          GET_DEGRADED|GET_SAFEMODE|
 689                          GET_DEVS|GET_OFFSET|GET_SIZE|GET_STATE|GET_LAYOUT);
 690
 691         if (!mdi)
 692                 return;
 693         new = xcalloc(1, sizeof(*new));
 694
 695         strcpy(new->info.sys_name, mdstat->devnm);
 696
 697         new->prev_state = new->curr_state = new->next_state = inactive;
 698         new->prev_action= new->curr_action= new->next_action= idle;
 699
 700         new->container = container;
 701
 702         inst = to_subarray(mdstat, container->devnm);
 703
 704         new->info.array = mdi->array;
 705         new->info.component_size = mdi->component_size;
 706
 707         for (i = 0; i < new->info.array.raid_disks; i++) {
 708                 struct mdinfo *newd = xmalloc(sizeof(*newd));
 709
 710                 for (di = mdi->devs; di; di = di->next)
 711                         if (i == di->disk.raid_disk)
 712                                 break;
 713
 714                 if (disk_init_and_add(newd, di, new) != 0) {
 715                         if (newd)
 716                                 free(newd);
 717
 718                         failed++;
 719                         if (failed > new->info.array.failed_disks) {
 720                                 /* we cannot properly monitor without all working disks */
 721                                 new->container = NULL;
 722                                 break;
 723                         }
 724                 }
 725         }
 726
 727         new->action_fd = sysfs_open2(new->info.sys_name, NULL, "sync_action");
 728         new->info.state_fd = sysfs_open2(new->info.sys_name, NULL, "array_state");
 729         new->resync_start_fd = sysfs_open2(new->info.sys_name, NULL, "resync_start");
 730         new->metadata_fd = sysfs_open2(new->info.sys_name, NULL, "metadata_version");
 731         new->sync_completed_fd = sysfs_open2(new->info.sys_name, NULL, "sync_completed");
 732
 733         dprintf("inst: %s action: %d state: %d\n", inst,
 734                 new->action_fd, new->info.state_fd);
 735
 736         if (sigterm)
 737                 new->info.safe_mode_delay = 1;
 738         else if (mdi->safe_mode_delay >= 50)
 739                 /* Normal start, mdadm set this. */
 740                 new->info.safe_mode_delay = mdi->safe_mode_delay;
 741         else
 742                 /* Restart, just pick a number */
 743                 new->info.safe_mode_delay = 5000;
 744         sysfs_set_safemode(&new->info, new->info.safe_mode_delay);
 745
 746         /* reshape_position is set by mdadm in sysfs
 747          * read this information for new arrays only (empty victim)
 748          */
 749         if ((victim == NULL) &&
 750             (sysfs_get_str(mdi, NULL, "sync_action", buf, 40) > 0) &&
 751             (strncmp(buf, "reshape", 7) == 0)) {
 752                 if (sysfs_get_ll(mdi, NULL, "reshape_position",
 753                         &new->last_checkpoint) != 0)
 754                         new->last_checkpoint = 0;
 755                 else {
 756                         int data_disks = mdi->array.raid_disks;
 757                         if (mdi->array.level == 4 || mdi->array.level == 5)
 758                                 data_disks--;
 759                         if (mdi->array.level == 6)
 760                                 data_disks -= 2;
 761
 762                         new->last_checkpoint /= data_disks;
 763                 }
 764                 dprintf("mdmon: New monitored array is under reshape.\n"
 765                         "       Last checkpoint is: %llu\n",
 766                         new->last_checkpoint);
 767         }
 768
 769         sysfs_free(mdi);
 770
 771         /* if everything checks out tell the metadata handler we want to
 772          * manage this instance
 773          */
 774         if (!aa_ready(new) || container->ss->open_new(container, new, inst) < 0) {
 775                 pr_err("failed to monitor %s\n",
 776                         mdstat->metadata_version);
 777                 new->container = NULL;
 778                 free_aa(new);
 779         } else {
 780                 replace_array(container, victim, new);
 781                 if (failed) {
 782                         new->check_degraded = 1;
 783                         manage_member(mdstat, new);
 784                 }
 785         }
 786 }
 787
 788 void manage(struct mdstat_ent *mdstat, struct supertype *container)
 789 {
 790         /* We have just read mdstat and need to compare it with
 791          * the known active arrays.
 792          * Arrays with the wrong metadata are ignored.
 793          */
 794
 795         for ( ; mdstat ; mdstat = mdstat->next) {
 796                 struct active_array *a;
 797                 if (strcmp(mdstat->devnm, container->devnm) == 0) {
 798                         manage_container(mdstat, container);
 799                         continue;
 800                 }
 801                 if (!is_container_member(mdstat, container->devnm))
 802                         /* Not for this array */
 803                         continue;
 804                 /* Looks like a member of this container */
 805                 for (a = container->arrays; a; a = a->next) {
 806                         if (strcmp(mdstat->devnm, a->info.sys_name) == 0) {
 807                                 if (a->container && a->to_remove == 0)
 808                                         manage_member(mdstat, a);
 809                                 break;
 810                         }
 811                 }
 812                 if (a == NULL || !a->container)
 813                         manage_new(mdstat, container, a);
 814         }
 815 }
 816
 817 static void handle_message(struct supertype *container, struct metadata_update *msg)
 818 {
 819         /* queue this metadata update through to the monitor */
 820
 821         struct metadata_update *mu;
 822
 823         if (msg->len <= 0)
 824                 while (update_queue_pending || update_queue) {
 825                         check_update_queue(container);
 826                         usleep(15*1000);
 827                 }
 828
 829         if (msg->len == 0) { /* ping_monitor */
 830                 int cnt;
 831
 832                 cnt = monitor_loop_cnt;
 833                 if (cnt & 1)
 834                         cnt += 2; /* wait until next pselect */
 835                 else
 836                         cnt += 3; /* wait for 2 pselects */
 837                 wakeup_monitor();
 838
 839                 while (monitor_loop_cnt - cnt < 0)
 840                         usleep(10 * 1000);
 841         } else if (msg->len == -1) { /* ping_manager */
 842                 struct mdstat_ent *mdstat = mdstat_read(1, 0);
 843
 844                 manage(mdstat, container);
 845                 free_mdstat(mdstat);
 846         } else if (!sigterm) {
 847                 mu = xmalloc(sizeof(*mu));
 848                 mu->len = msg->len;
 849                 mu->buf = msg->buf;
 850                 msg->buf = NULL;
 851                 mu->space = NULL;
 852                 mu->space_list = NULL;
 853                 mu->next = NULL;
 854                 if (container->ss->prepare_update)
 855                         if (!container->ss->prepare_update(container, mu))
 856                                 free_updates(&mu);
 857                 queue_metadata_update(mu);
 858         }
 859 }
 860
 861 void read_sock(struct supertype *container)
 862 {
 863         int fd;
 864         struct metadata_update msg;
 865         int terminate = 0;
 866         long fl;
 867         int tmo = 3; /* 3 second timeout before hanging up the socket */
 868
 869         fd = accept(container->sock, NULL, NULL);
 870         if (fd < 0)
 871                 return;
 872
 873         fl = fcntl(fd, F_GETFL, 0);
 874         fl |= O_NONBLOCK;
 875         fcntl(fd, F_SETFL, fl);
 876
 877         do {
 878                 msg.buf = NULL;
 879
 880                 /* read and validate the message */
 881                 if (receive_message(fd, &msg, tmo) == 0) {
 882                         handle_message(container, &msg);
 883                         if (msg.len == 0) {
 884                                 /* ping reply with version */
 885                                 msg.buf = Version;
 886                                 msg.len = strlen(Version) + 1;
 887                                 if (send_message(fd, &msg, tmo) < 0)
 888                                         terminate = 1;
 889                         } else if (ack(fd, tmo) < 0)
 890                                 terminate = 1;
 891                 } else
 892                         terminate = 1;
 893
 894         } while (!terminate);
 895
 896         close(fd);
 897 }
 898
 899 int exit_now = 0;
 900 int manager_ready = 0;
 901 void do_manager(struct supertype *container)
 902 {
 903         struct mdstat_ent *mdstat;
 904         sigset_t set;
 905
 906         sigprocmask(SIG_UNBLOCK, NULL, &set);
 907         sigdelset(&set, SIGUSR1);
 908         sigdelset(&set, SIGTERM);
 909
 910         do {
 911
 912                 if (exit_now)
 913                         exit(0);
 914
 915                 /* Can only 'manage' things if 'monitor' is not making
 916                  * structural changes to metadata, so need to check
 917                  * update_queue
 918                  */
 919                 if (update_queue == NULL) {
 920                         mdstat = mdstat_read(1, 0);
 921
 922                         manage(mdstat, container);
 923
 924                         read_sock(container);
 925
 926                         free_mdstat(mdstat);
 927                 }
 928                 remove_old();
 929
 930                 check_update_queue(container);
 931
 932                 manager_ready = 1;
 933
 934                 if (sigterm)
 935                         wakeup_monitor();
 936
 937                 if (update_queue == NULL)
 938                         mdstat_wait_fd(container->sock, &set);
 939                 else
 940                         /* If an update is happening, just wait for signal */
 941                         pselect(0, NULL, NULL, NULL, NULL, &set);
 942         } while(1);
 943 }