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         close(aa->action_fd);
 121         close(aa->info.state_fd);
 122         close(aa->resync_start_fd);
 123         close(aa->metadata_fd);
 124         close(aa->sync_completed_fd);
 125 }
 126
 127 static void free_aa(struct active_array *aa)
 128 {
 129         /* Note that this doesn't close fds if they are being used
 130          * by a clone.  ->container will be set for a clone
 131          */
 132         dprintf("%s: devnum: %d\n", __func__, aa->devnum);
 133         if (!aa->container)
 134                 close_aa(aa);
 135         while (aa->info.devs) {
 136                 struct mdinfo *d = aa->info.devs;
 137                 aa->info.devs = d->next;
 138                 free(d);
 139         }
 140         free(aa);
 141 }
 142
 143 static struct active_array *duplicate_aa(struct active_array *aa)
 144 {
 145         struct active_array *newa = malloc(sizeof(*newa));
 146         struct mdinfo **dp1, **dp2;
 147
 148         *newa = *aa;
 149         newa->next = NULL;
 150         newa->replaces = NULL;
 151         newa->info.next = NULL;
 152
 153         dp2 = &newa->info.devs;
 154
 155         for (dp1 = &aa->info.devs; *dp1; dp1 = &(*dp1)->next) {
 156                 struct mdinfo *d;
 157                 if ((*dp1)->state_fd < 0)
 158                         continue;
 159
 160                 d = malloc(sizeof(*d));
 161                 *d = **dp1;
 162                 *dp2 = d;
 163                 dp2 = & d->next;
 164         }
 165         *dp2 = NULL;
 166
 167         return newa;
 168 }
 169
 170 static void wakeup_monitor(void)
 171 {
 172         /* tgkill(getpid(), mon_tid, SIGUSR1); */
 173         int pid = getpid();
 174         syscall(SYS_tgkill, pid, mon_tid, SIGUSR1);
 175 }
 176
 177 static void remove_old(void)
 178 {
 179         if (discard_this) {
 180                 discard_this->next = NULL;
 181                 free_aa(discard_this);
 182                 if (pending_discard == discard_this)
 183                         pending_discard = NULL;
 184                 discard_this = NULL;
 185                 wakeup_monitor();
 186         }
 187 }
 188
 189 static void replace_array(struct supertype *container,
 190                           struct active_array *old,
 191                           struct active_array *new)
 192 {
 193         /* To replace an array, we add it to the top of the list
 194          * marked with ->replaces to point to the original.
 195          * 'monitor' will take the original out of the list
 196          * and put it on 'discard_this'.  We take it from there
 197          * and discard it.
 198          */
 199         remove_old();
 200         while (pending_discard) {
 201                 while (discard_this == NULL)
 202                         sleep(1);
 203                 remove_old();
 204         }
 205         pending_discard = old;
 206         new->replaces = old;
 207         new->next = container->arrays;
 208         container->arrays = new;
 209         wakeup_monitor();
 210 }
 211
 212 struct metadata_update *update_queue = NULL;
 213 struct metadata_update *update_queue_handled = NULL;
 214 struct metadata_update *update_queue_pending = NULL;
 215
 216 static void free_updates(struct metadata_update **update)
 217 {
 218         while (*update) {
 219                 struct metadata_update *this = *update;
 220
 221                 *update = this->next;
 222                 free(this->buf);
 223                 free(this->space);
 224                 free(this);
 225         }
 226 }
 227
 228 void check_update_queue(struct supertype *container)
 229 {
 230         free_updates(&update_queue_handled);
 231
 232         if (update_queue == NULL &&
 233             update_queue_pending) {
 234                 update_queue = update_queue_pending;
 235                 update_queue_pending = NULL;
 236                 wakeup_monitor();
 237         }
 238 }
 239
 240 static void queue_metadata_update(struct metadata_update *mu)
 241 {
 242         struct metadata_update **qp;
 243
 244         qp = &update_queue_pending;
 245         while (*qp)
 246                 qp = & ((*qp)->next);
 247         *qp = mu;
 248 }
 249
 250 static void add_disk_to_container(struct supertype *st, struct mdinfo *sd)
 251 {
 252         int dfd;
 253         char nm[20];
 254         struct supertype *st2;
 255         struct metadata_update *update = NULL;
 256         struct mdinfo info;
 257         mdu_disk_info_t dk = {
 258                 .number = -1,
 259                 .major = sd->disk.major,
 260                 .minor = sd->disk.minor,
 261                 .raid_disk = -1,
 262                 .state = 0,
 263         };
 264
 265         dprintf("%s: add %d:%d to container\n",
 266                 __func__, sd->disk.major, sd->disk.minor);
 267
 268         sd->next = st->devs;
 269         st->devs = sd;
 270
 271         sprintf(nm, "%d:%d", sd->disk.major, sd->disk.minor);
 272         dfd = dev_open(nm, O_RDWR);
 273         if (dfd < 0)
 274                 return;
 275
 276         /* Check the metadata and see if it is already part of this
 277          * array
 278          */
 279         st2 = dup_super(st);
 280         if (st2->ss->load_super(st2, dfd, NULL) == 0) {
 281                 st2->ss->getinfo_super(st, &info, NULL);
 282                 if (st->ss->compare_super(st, st2) == 0 &&
 283                     info.disk.raid_disk >= 0) {
 284                         /* Looks like a good member of array.
 285                          * Just accept it.
 286                          * mdadm will incorporate any parts into
 287                          * active arrays.
 288                          */
 289                         st2->ss->free_super(st2);
 290                         return;
 291                 }
 292         }
 293         st2->ss->free_super(st2);
 294
 295         st->update_tail = &update;
 296         st->ss->add_to_super(st, &dk, dfd, NULL);
 297         st->ss->write_init_super(st);
 298         queue_metadata_update(update);
 299         st->update_tail = NULL;
 300 }
 301
 302 static void manage_container(struct mdstat_ent *mdstat,
 303                              struct supertype *container)
 304 {
 305         /* The only thing of interest here is if a new device
 306          * has been added to the container.  We add it to the
 307          * array ignoring any metadata on it.
 308          * FIXME should we look for compatible metadata and take hints
 309          * about spare assignment.... probably not.
 310          */
 311         if (mdstat->devcnt != container->devcnt) {
 312                 struct mdinfo **cdp, *cd, *di, *mdi;
 313                 int found;
 314
 315                 /* read /sys/block/NAME/md/dev-??/block/dev to find out
 316                  * what is there, and compare with container->info.devs
 317                  * To see what is removed and what is added.
 318                  * These need to be remove from, or added to, the array
 319                  */
 320                 mdi = sysfs_read(-1, mdstat->devnum, GET_DEVS);
 321                 if (!mdi) {
 322                         /* invalidate the current count so we can try again */
 323                         container->devcnt = -1;
 324                         return;
 325                 }
 326
 327                 /* check for removals */
 328                 for (cdp = &container->devs; *cdp; ) {
 329                         found = 0;
 330                         for (di = mdi->devs; di; di = di->next)
 331                                 if (di->disk.major == (*cdp)->disk.major &&
 332                                     di->disk.minor == (*cdp)->disk.minor) {
 333                                         found = 1;
 334                                         break;
 335                                 }
 336                         if (!found) {
 337                                 cd = *cdp;
 338                                 *cdp = (*cdp)->next;
 339                                 free(cd);
 340                         } else
 341                                 cdp = &(*cdp)->next;
 342                 }
 343
 344                 /* check for additions */
 345                 for (di = mdi->devs; di; di = di->next) {
 346                         for (cd = container->devs; cd; cd = cd->next)
 347                                 if (di->disk.major == cd->disk.major &&
 348                                     di->disk.minor == cd->disk.minor)
 349                                         break;
 350                         if (!cd) {
 351                                 struct mdinfo *newd = malloc(sizeof(*newd));
 352
 353                                 if (!newd) {
 354                                         container->devcnt = -1;
 355                                         continue;
 356                                 }
 357                                 *newd = *di;
 358                                 add_disk_to_container(container, newd);
 359                         }
 360                 }
 361                 sysfs_free(mdi);
 362                 container->devcnt = mdstat->devcnt;
 363         }
 364 }
 365
 366 static int disk_init_and_add(struct mdinfo *disk, struct mdinfo *clone,
 367                              struct active_array *aa)
 368 {
 369         if (!disk || !clone)
 370                 return -1;
 371
 372         *disk = *clone;
 373         disk->recovery_fd = sysfs_open(aa->devnum, disk->sys_name, "recovery_start");
 374         disk->state_fd = sysfs_open(aa->devnum, disk->sys_name, "state");
 375         disk->prev_state = read_dev_state(disk->state_fd);
 376         disk->curr_state = disk->prev_state;
 377         disk->next = aa->info.devs;
 378         aa->info.devs = disk;
 379
 380         return 0;
 381 }
 382
 383 static void manage_member(struct mdstat_ent *mdstat,
 384                           struct active_array *a)
 385 {
 386         /* Compare mdstat info with known state of member array.
 387          * We do not need to look for device state changes here, that
 388          * is dealt with by the monitor.
 389          *
 390          * We just look for changes which suggest that a reshape is
 391          * being requested.
 392          * Unfortunately decreases in raid_disks don't show up in
 393          * mdstat until the reshape completes FIXME.
 394          *
 395          * Actually, we also want to handle degraded arrays here by
 396          * trying to find and assign a spare.
 397          * We do that whenever the monitor tells us too.
 398          */
 399         char buf[64];
 400         int frozen;
 401
 402         // FIXME
 403         a->info.array.raid_disks = mdstat->raid_disks;
 404         // MORE
 405
 406         /* honor 'frozen' */
 407         if (sysfs_get_str(&a->info, NULL, "metadata_version", buf, sizeof(buf)) > 0)
 408                 frozen = buf[9] == '-';
 409         else
 410                 frozen = 1; /* can't read metadata_version assume the worst */
 411
 412         if (a->check_degraded && !frozen) {
 413                 struct metadata_update *updates = NULL;
 414                 struct mdinfo *newdev = NULL;
 415                 struct active_array *newa;
 416                 struct mdinfo *d;
 417
 418                 a->check_degraded = 0;
 419
 420                 /* The array may not be degraded, this is just a good time
 421                  * to check.
 422                  */
 423                 newdev = a->container->ss->activate_spare(a, &updates);
 424                 if (!newdev)
 425                         return;
 426
 427                 newa = duplicate_aa(a);
 428                 if (!newa)
 429                         goto out;
 430                 /* Cool, we can add a device or several. */
 431
 432                 /* Add device to array and set offset/size/slot.
 433                  * and open files for each newdev */
 434                 for (d = newdev; d ; d = d->next) {
 435                         struct mdinfo *newd;
 436
 437                         newd = malloc(sizeof(*newd));
 438                         if (!newd)
 439                                 continue;
 440                         if (sysfs_add_disk(&newa->info, d, 0) < 0) {
 441                                 free(newd);
 442                                 continue;
 443                         }
 444                         disk_init_and_add(newd, d, newa);
 445                 }
 446                 queue_metadata_update(updates);
 447                 updates = NULL;
 448                 replace_array(a->container, a, newa);
 449                 sysfs_set_str(&a->info, NULL, "sync_action", "recover");
 450  out:
 451                 while (newdev) {
 452                         d = newdev->next;
 453                         free(newdev);
 454                         newdev = d;
 455                 }
 456                 free_updates(&updates);
 457         }
 458 }
 459
 460 static int aa_ready(struct active_array *aa)
 461 {
 462         struct mdinfo *d;
 463         int level = aa->info.array.level;
 464
 465         for (d = aa->info.devs; d; d = d->next)
 466                 if (d->state_fd < 0)
 467                         return 0;
 468
 469         if (aa->info.state_fd < 0)
 470                 return 0;
 471
 472         if (level > 0 && (aa->action_fd < 0 || aa->resync_start_fd < 0))
 473                 return 0;
 474
 475         if (!aa->container)
 476                 return 0;
 477
 478         return 1;
 479 }
 480
 481 static void manage_new(struct mdstat_ent *mdstat,
 482                        struct supertype *container,
 483                        struct active_array *victim)
 484 {
 485         /* A new array has appeared in this container.
 486          * Hopefully it is already recorded in the metadata.
 487          * Check, then create the new array to report it to
 488          * the monitor.
 489          */
 490
 491         struct active_array *new;
 492         struct mdinfo *mdi, *di;
 493         char *inst;
 494         int i;
 495         int failed = 0;
 496
 497         /* check if array is ready to be monitored */
 498         if (!mdstat->active)
 499                 return;
 500
 501         mdi = sysfs_read(-1, mdstat->devnum,
 502                          GET_LEVEL|GET_CHUNK|GET_DISKS|GET_COMPONENT|
 503                          GET_DEGRADED|GET_DEVS|GET_OFFSET|GET_SIZE|GET_STATE);
 504
 505         new = malloc(sizeof(*new));
 506
 507         if (!new || !mdi) {
 508                 if (mdi)
 509                         sysfs_free(mdi);
 510                 if (new)
 511                         free(new);
 512                 return;
 513         }
 514         memset(new, 0, sizeof(*new));
 515
 516         new->devnum = mdstat->devnum;
 517         strcpy(new->info.sys_name, devnum2devname(new->devnum));
 518
 519         new->prev_state = new->curr_state = new->next_state = inactive;
 520         new->prev_action= new->curr_action= new->next_action= idle;
 521
 522         new->container = container;
 523
 524         inst = to_subarray(mdstat, container->devname);
 525
 526         new->info.array = mdi->array;
 527         new->info.component_size = mdi->component_size;
 528
 529         for (i = 0; i < new->info.array.raid_disks; i++) {
 530                 struct mdinfo *newd = malloc(sizeof(*newd));
 531
 532                 for (di = mdi->devs; di; di = di->next)
 533                         if (i == di->disk.raid_disk)
 534                                 break;
 535
 536                 if (disk_init_and_add(newd, di, new) != 0) {
 537                         if (newd)
 538                                 free(newd);
 539
 540                         failed++;
 541                         if (failed > new->info.array.failed_disks) {
 542                                 /* we cannot properly monitor without all working disks */
 543                                 new->container = NULL;
 544                                 break;
 545                         }
 546                 }
 547         }
 548
 549         new->action_fd = sysfs_open(new->devnum, NULL, "sync_action");
 550         new->info.state_fd = sysfs_open(new->devnum, NULL, "array_state");
 551         new->resync_start_fd = sysfs_open(new->devnum, NULL, "resync_start");
 552         new->metadata_fd = sysfs_open(new->devnum, NULL, "metadata_version");
 553         new->sync_completed_fd = sysfs_open(new->devnum, NULL, "sync_completed");
 554         dprintf("%s: inst: %d action: %d state: %d\n", __func__, atoi(inst),
 555                 new->action_fd, new->info.state_fd);
 556
 557         sysfs_free(mdi);
 558
 559         /* if everything checks out tell the metadata handler we want to
 560          * manage this instance
 561          */
 562         if (!aa_ready(new) || container->ss->open_new(container, new, inst) < 0) {
 563                 fprintf(stderr, "mdmon: failed to monitor %s\n",
 564                         mdstat->metadata_version);
 565                 new->container = NULL;
 566                 free_aa(new);
 567         } else {
 568                 replace_array(container, victim, new);
 569                 if (failed) {
 570                         new->check_degraded = 1;
 571                         manage_member(mdstat, new);
 572                 }
 573         }
 574 }
 575
 576 void manage(struct mdstat_ent *mdstat, struct supertype *container)
 577 {
 578         /* We have just read mdstat and need to compare it with
 579          * the known active arrays.
 580          * Arrays with the wrong metadata are ignored.
 581          */
 582
 583         for ( ; mdstat ; mdstat = mdstat->next) {
 584                 struct active_array *a;
 585                 if (mdstat->devnum == container->devnum) {
 586                         manage_container(mdstat, container);
 587                         continue;
 588                 }
 589                 if (!is_container_member(mdstat, container->devname))
 590                         /* Not for this array */
 591                         continue;
 592                 /* Looks like a member of this container */
 593                 for (a = container->arrays; a; a = a->next) {
 594                         if (mdstat->devnum == a->devnum) {
 595                                 if (a->container)
 596                                         manage_member(mdstat, a);
 597                                 break;
 598                         }
 599                 }
 600                 if (a == NULL || !a->container)
 601                         manage_new(mdstat, container, a);
 602         }
 603 }
 604
 605 static void handle_message(struct supertype *container, struct metadata_update *msg)
 606 {
 607         /* queue this metadata update through to the monitor */
 608
 609         struct metadata_update *mu;
 610
 611         if (msg->len <= 0)
 612                 while (update_queue_pending || update_queue) {
 613                         check_update_queue(container);
 614                         usleep(15*1000);
 615                 }
 616
 617         if (msg->len == 0) { /* ping_monitor */
 618                 int cnt;
 619
 620                 cnt = monitor_loop_cnt;
 621                 if (cnt & 1)
 622                         cnt += 2; /* wait until next pselect */
 623                 else
 624                         cnt += 3; /* wait for 2 pselects */
 625                 wakeup_monitor();
 626
 627                 while (monitor_loop_cnt - cnt < 0)
 628                         usleep(10 * 1000);
 629         } else if (msg->len == -1) { /* ping_manager */
 630                 struct mdstat_ent *mdstat = mdstat_read(1, 0);
 631
 632                 manage(mdstat, container);
 633                 free_mdstat(mdstat);
 634         } else if (!sigterm) {
 635                 mu = malloc(sizeof(*mu));
 636                 mu->len = msg->len;
 637                 mu->buf = msg->buf;
 638                 msg->buf = NULL;
 639                 mu->space = NULL;
 640                 mu->next = NULL;
 641                 if (container->ss->prepare_update)
 642                         container->ss->prepare_update(container, mu);
 643                 queue_metadata_update(mu);
 644         }
 645 }
 646
 647 void read_sock(struct supertype *container)
 648 {
 649         int fd;
 650         struct metadata_update msg;
 651         int terminate = 0;
 652         long fl;
 653         int tmo = 3; /* 3 second timeout before hanging up the socket */
 654
 655         fd = accept(container->sock, NULL, NULL);
 656         if (fd < 0)
 657                 return;
 658
 659         fl = fcntl(fd, F_GETFL, 0);
 660         fl |= O_NONBLOCK;
 661         fcntl(fd, F_SETFL, fl);
 662
 663         do {
 664                 msg.buf = NULL;
 665
 666                 /* read and validate the message */
 667                 if (receive_message(fd, &msg, tmo) == 0) {
 668                         handle_message(container, &msg);
 669                         if (msg.len == 0) {
 670                                 /* ping reply with version */
 671                                 msg.buf = Version;
 672                                 msg.len = strlen(Version) + 1;
 673                                 if (send_message(fd, &msg, tmo) < 0)
 674                                         terminate = 1;
 675                         } else if (ack(fd, tmo) < 0)
 676                                 terminate = 1;
 677                 } else
 678                         terminate = 1;
 679
 680         } while (!terminate);
 681
 682         close(fd);
 683 }
 684
 685 int exit_now = 0;
 686 int manager_ready = 0;
 687 void do_manager(struct supertype *container)
 688 {
 689         struct mdstat_ent *mdstat;
 690         sigset_t set;
 691
 692         sigprocmask(SIG_UNBLOCK, NULL, &set);
 693         sigdelset(&set, SIGUSR1);
 694         sigdelset(&set, SIGTERM);
 695
 696         do {
 697
 698                 if (exit_now)
 699                         exit(0);
 700
 701                 /* Can only 'manage' things if 'monitor' is not making
 702                  * structural changes to metadata, so need to check
 703                  * update_queue
 704                  */
 705                 if (update_queue == NULL) {
 706                         mdstat = mdstat_read(1, 0);
 707
 708                         manage(mdstat, container);
 709
 710                         read_sock(container);
 711
 712                         free_mdstat(mdstat);
 713                 }
 714                 remove_old();
 715
 716                 check_update_queue(container);
 717
 718                 manager_ready = 1;
 719
 720                 if (sigterm)
 721                         wakeup_monitor();
 722
 723                 if (update_queue == NULL)
 724                         mdstat_wait_fd(container->sock, &set);
 725                 else
 726                         /* If an update is happening, just wait for signal */
 727                         pselect(0, NULL, NULL, NULL, NULL, &set);
 728         } while(1);
 729 }