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