mdstat.c

   1 /*
   2  * mdstat - parse /proc/mdstat file. Part of:
   3  * mdadm - manage Linux "md" devices aka RAID arrays.
   4  *
   5  * Copyright (C) 2002-2009 Neil Brown <neilb@suse.de>
   6  *
   7  *
   8  *    This program is free software; you can redistribute it and/or modify
   9  *    it under the terms of the GNU General Public License as published by
  10  *    the Free Software Foundation; either version 2 of the License, or
  11  *    (at your option) any later version.
  12  *
  13  *    This program is distributed in the hope that it will be useful,
  14  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *    GNU General Public License for more details.
  17  *
  18  *    You should have received a copy of the GNU General Public License
  19  *    along with this program; if not, write to the Free Software
  20  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  *    Author: Neil Brown
  23  *    Email: <neilb@suse.de>
  24  */
  25
  26 /*
  27  * The /proc/mdstat file comes in at least 3 flavours:
  28  * In an unpatched 2.2 kernel (md 0.36.6):
  29  *  Personalities : [n raidx] ...
  30  *  read_ahead {not set|%d sectors}
  31  *  md0 : {in}active{ raidX /dev/hda...  %d blocks{ maxfault=%d}}
  32  *  md1 : .....
  33  *
  34  * Normally only 4 md lines, but all are listed.
  35  *
  36  * In a patched 2.2 kernel (md 0.90.0)
  37  *  Personalities : [raidx] ...
  38  *  read_ahead {not set|%d sectors}
  39  *  mdN : {in}active {(readonly)} raidX dev[%d]{(F)} ... %d blocks STATUS RESYNC
  40  *  ... Only initialised arrays listed
  41  *  unused devices: {dev dev ... | <none>}
  42  *
  43  * STATUS is personality dependant:
  44  *    linear:  %dk rounding
  45  *    raid0:   %dk chunks
  46  *    raid1:   [%d/%d] [U_U]   ( raid/working.  operational or not)
  47  *    raid5:   level 4/5, %dk chunk, algorithm %d [%d/%d] [U_U]
  48  *
  49  * RESYNC is  empty or:
  50  *    {resync|recovery}=%u%% finish=%u.%umin
  51  *  or
  52  *    resync=DELAYED
  53  *
  54  * In a 2.4 kernel (md 0.90.0/2.4)
  55  *  Personalities : [raidX] ...
  56  *  read_ahead {not set|%d sectors}
  57  *  mdN : {in}active {(read-only)} raidX dev[%d]{(F)} ...
  58  *       %d blocks STATUS
  59  *       RESYNC
  60  *  unused devices: {dev dev .. | <none>}
  61  *
  62  *  STATUS matches 0.90.0/2.2
  63  *  RESYNC includes [===>....],
  64  *          adds a space after {resync|recovery} and before and after '='
  65  *          adds a decimal to the recovery percent.
  66  *          adds (%d/%d) resync amount  and max_blocks, before finish.
  67  *          adds speed=%dK/sec after finish
  68  *
  69  *
  70  *
  71  * Out of this we want to extract:
  72  *   list of devices, active or not
  73  *   pattern of failed drives (so need number of drives)
  74  *   percent resync complete
  75  *
  76  * As continuation is indicated by leading space, we use
  77  *  conf_line from config.c to read logical lines
  78  *
  79  */
  80
  81 #include        "mdadm.h"
  82 #include        "dlink.h"
  83 #include        <sys/select.h>
  84 #include        <ctype.h>
  85
  86 static void free_member_devnames(struct dev_member *m)
  87 {
  88         while(m) {
  89                 struct dev_member *t = m;
  90
  91                 m = m->next;
  92                 free(t->name);
  93                 free(t);
  94         }
  95 }
  96
  97 static int add_member_devname(struct dev_member **m, char *name)
  98 {
  99         struct dev_member *new;
 100         char *t;
 101
 102         if ((t = strchr(name, '[')) == NULL)
 103                 /* not a device */
 104                 return 0;
 105
 106         new = xmalloc(sizeof(*new));
 107         new->name = strndup(name, t - name);
 108         new->next = *m;
 109         *m = new;
 110         return 1;
 111 }
 112
 113 void free_mdstat(struct mdstat_ent *ms)
 114 {
 115         while (ms) {
 116                 struct mdstat_ent *t;
 117                 free(ms->level);
 118                 free(ms->pattern);
 119                 free(ms->metadata_version);
 120                 free_member_devnames(ms->members);
 121                 t = ms;
 122                 ms = ms->next;
 123                 free(t);
 124         }
 125 }
 126
 127 static int mdstat_fd = -1;
 128 struct mdstat_ent *mdstat_read(int hold, int start)
 129 {
 130         FILE *f;
 131         struct mdstat_ent *all, *rv, **end, **insert_here;
 132         char *line;
 133         int fd;
 134
 135         if (hold && mdstat_fd != -1) {
 136                 off_t offset = lseek(mdstat_fd, 0L, 0);
 137                 if (offset == (off_t)-1) {
 138                         return NULL;
 139                 }
 140                 fd = dup(mdstat_fd);
 141                 if (fd >= 0)
 142                         f = fdopen(fd, "r");
 143                 else
 144                         return NULL;
 145         } else
 146                 f = fopen("/proc/mdstat", "r");
 147         if (f == NULL)
 148                 return NULL;
 149         else
 150                 fcntl(fileno(f), F_SETFD, FD_CLOEXEC);
 151
 152         all = NULL;
 153         end = &all;
 154         for (; (line = conf_line(f)) ; free_line(line)) {
 155                 struct mdstat_ent *ent;
 156                 char *w;
 157                 char devnm[32];
 158                 int in_devs = 0;
 159
 160                 if (strcmp(line, "Personalities") == 0)
 161                         continue;
 162                 if (strcmp(line, "read_ahead") == 0)
 163                         continue;
 164                 if (strcmp(line, "unused") == 0)
 165                         continue;
 166                 insert_here = NULL;
 167                 /* Better be an md line.. */
 168                 if (strncmp(line, "md", 2)!= 0 || strlen(line) >= 32 ||
 169                     (line[2] != '_' && !isdigit(line[2])))
 170                         continue;
 171                 strcpy(devnm, line);
 172
 173                 ent = xmalloc(sizeof(*ent));
 174                 ent->level = ent->pattern= NULL;
 175                 ent->next = NULL;
 176                 ent->percent = RESYNC_NONE;
 177                 ent->active = -1;
 178                 ent->resync = 0;
 179                 ent->metadata_version = NULL;
 180                 ent->raid_disks = 0;
 181                 ent->devcnt = 0;
 182                 ent->members = NULL;
 183
 184                 strcpy(ent->devnm, devnm);
 185
 186                 for (w=dl_next(line); w!= line ; w=dl_next(w)) {
 187                         int l = strlen(w);
 188                         char *eq;
 189                         if (strcmp(w, "active") == 0)
 190                                 ent->active = 1;
 191                         else if (strcmp(w, "inactive") == 0) {
 192                                 ent->active = 0;
 193                                 in_devs = 1;
 194                         } else if (strcmp(w, "bitmap:") == 0) {
 195                                 /* We need to stop parsing here;
 196                                  * otherwise, ent->raid_disks will be
 197                                  * overwritten by the wrong value.
 198                                  */
 199                                 break;
 200                         } else if (ent->active > 0 &&
 201                                  ent->level == NULL &&
 202                                  w[0] != '(' /*readonly*/) {
 203                                 ent->level = xstrdup(w);
 204                                 in_devs = 1;
 205                         } else if (in_devs && strcmp(w, "blocks") == 0)
 206                                 in_devs = 0;
 207                         else if (in_devs) {
 208                                 char *ep = strchr(w, '[');
 209                                 ent->devcnt +=
 210                                         add_member_devname(&ent->members, w);
 211                                 if (ep && strncmp(w, "md", 2) == 0) {
 212                                         /* This has an md device as a component.
 213                                          * If that device is already in the
 214                                          * list, make sure we insert before
 215                                          * there.
 216                                          */
 217                                         struct mdstat_ent **ih;
 218                                         ih = &all;
 219                                         while (ih != insert_here && *ih &&
 220                                                ((int)strlen((*ih)->devnm) !=
 221                                                 ep-w ||
 222                                                 strncmp((*ih)->devnm, w,
 223                                                         ep-w) != 0))
 224                                                 ih = & (*ih)->next;
 225                                         insert_here = ih;
 226                                 }
 227                         } else if (strcmp(w, "super") == 0 &&
 228                                    dl_next(w) != line) {
 229                                 w = dl_next(w);
 230                                 ent->metadata_version = xstrdup(w);
 231                         } else if (w[0] == '[' && isdigit(w[1])) {
 232                                 ent->raid_disks = atoi(w+1);
 233                         } else if (!ent->pattern &&
 234                                    w[0] == '[' &&
 235                                    (w[1] == 'U' || w[1] == '_')) {
 236                                 ent->pattern = xstrdup(w+1);
 237                                 if (ent->pattern[l-2] == ']')
 238                                         ent->pattern[l-2] = '\0';
 239                         } else if (ent->percent == RESYNC_NONE &&
 240                                    strncmp(w, "re", 2) == 0 &&
 241                                    w[l-1] == '%' &&
 242                                    (eq = strchr(w, '=')) != NULL ) {
 243                                 ent->percent = atoi(eq+1);
 244                                 if (strncmp(w,"resync", 6) == 0)
 245                                         ent->resync = 1;
 246                                 else if (strncmp(w, "reshape", 7) == 0)
 247                                         ent->resync = 2;
 248                                 else
 249                                         ent->resync = 0;
 250                         } else if (ent->percent == RESYNC_NONE &&
 251                                    (w[0] == 'r' || w[0] == 'c')) {
 252                                 if (strncmp(w, "resync", 6) == 0)
 253                                         ent->resync = 1;
 254                                 if (strncmp(w, "reshape", 7) == 0)
 255                                         ent->resync = 2;
 256                                 if (strncmp(w, "recovery", 8) == 0)
 257                                         ent->resync = 0;
 258                                 if (strncmp(w, "check", 5) == 0)
 259                                         ent->resync = 3;
 260
 261                                 if (l > 8 && strcmp(w+l-8, "=DELAYED") == 0)
 262                                         ent->percent = RESYNC_DELAYED;
 263                                 if (l > 8 && strcmp(w+l-8, "=PENDING") == 0)
 264                                         ent->percent = RESYNC_PENDING;
 265                                 if (l > 7 && strcmp(w+l-7, "=REMOTE") == 0)
 266                                         ent->percent = RESYNC_REMOTE;
 267                         } else if (ent->percent == RESYNC_NONE &&
 268                                    w[0] >= '0' &&
 269                                    w[0] <= '9' &&
 270                                    w[l-1] == '%') {
 271                                 ent->percent = atoi(w);
 272                         }
 273                 }
 274                 if (insert_here && (*insert_here)) {
 275                         ent->next = *insert_here;
 276                         *insert_here = ent;
 277                 } else {
 278                         *end = ent;
 279                         end = &ent->next;
 280                 }
 281         }
 282         if (hold && mdstat_fd == -1) {
 283                 mdstat_fd = dup(fileno(f));
 284                 fcntl(mdstat_fd, F_SETFD, FD_CLOEXEC);
 285         }
 286         fclose(f);
 287
 288         /* If we might want to start array,
 289          * reverse the order, so that components comes before composites
 290          */
 291         if (start) {
 292                 rv = NULL;
 293                 while (all) {
 294                         struct mdstat_ent *e = all;
 295                         all = all->next;
 296                         e->next = rv;
 297                         rv = e;
 298                 }
 299         } else
 300                 rv = all;
 301         return rv;
 302 }
 303
 304 void mdstat_close(void)
 305 {
 306         if (mdstat_fd >= 0)
 307                 close(mdstat_fd);
 308         mdstat_fd = -1;
 309 }
 310
 311 /*
 312  * function: mdstat_wait
 313  * Description: Function waits for event on mdstat.
 314  * Parameters:
 315  *              seconds - timeout for waiting
 316  * Returns:
 317  *              > 0 - detected event
 318  *              0 - timeout
 319  *              < 0 - detected error
 320  */
 321 int mdstat_wait(int seconds)
 322 {
 323         fd_set fds;
 324         struct timeval tm;
 325         int maxfd = 0;
 326         FD_ZERO(&fds);
 327         if (mdstat_fd >= 0) {
 328                 FD_SET(mdstat_fd, &fds);
 329                 maxfd = mdstat_fd;
 330         } else
 331                 return -1;
 332
 333         tm.tv_sec = seconds;
 334         tm.tv_usec = 0;
 335
 336         return select(maxfd + 1, NULL, NULL, &fds, &tm);
 337 }
 338
 339 void mdstat_wait_fd(int fd, const sigset_t *sigmask)
 340 {
 341         fd_set fds, rfds;
 342         int maxfd = 0;
 343
 344         FD_ZERO(&fds);
 345         FD_ZERO(&rfds);
 346         if (mdstat_fd >= 0)
 347                 FD_SET(mdstat_fd, &fds);
 348
 349         if (fd >= 0) {
 350                 struct stat stb;
 351                 fstat(fd, &stb);
 352                 if ((stb.st_mode & S_IFMT) == S_IFREG)
 353                         /* Must be a /proc or /sys fd, so expect
 354                          * POLLPRI
 355                          * i.e. an 'exceptional' event.
 356                          */
 357                         FD_SET(fd, &fds);
 358                 else
 359                         FD_SET(fd, &rfds);
 360
 361                 if (fd > maxfd)
 362                         maxfd = fd;
 363
 364         }
 365         if (mdstat_fd > maxfd)
 366                 maxfd = mdstat_fd;
 367
 368         pselect(maxfd + 1, &rfds, NULL, &fds,
 369                 NULL, sigmask);
 370 }
 371
 372 int mddev_busy(char *devnm)
 373 {
 374         struct mdstat_ent *mdstat = mdstat_read(0, 0);
 375         struct mdstat_ent *me;
 376
 377         for (me = mdstat ; me ; me = me->next)
 378                 if (strcmp(me->devnm, devnm) == 0)
 379                         break;
 380         free_mdstat(mdstat);
 381         return me != NULL;
 382 }
 383
 384 struct mdstat_ent *mdstat_by_component(char *name)
 385 {
 386         struct mdstat_ent *mdstat = mdstat_read(0, 0);
 387
 388         while (mdstat) {
 389                 struct dev_member *m;
 390                 struct mdstat_ent *ent;
 391                 if (mdstat->metadata_version &&
 392                     strncmp(mdstat->metadata_version, "external:", 9) == 0 &&
 393                     is_subarray(mdstat->metadata_version+9))
 394                         /* don't return subarrays, only containers */
 395                         ;
 396                 else for (m = mdstat->members; m; m = m->next) {
 397                                 if (strcmp(m->name, name) == 0) {
 398                                         free_mdstat(mdstat->next);
 399                                         mdstat->next = NULL;
 400                                         return mdstat;
 401                                 }
 402                         }
 403                 ent = mdstat;
 404                 mdstat = mdstat->next;
 405                 ent->next = NULL;
 406                 free_mdstat(ent);
 407         }
 408         return NULL;
 409 }
 410
 411 struct mdstat_ent *mdstat_by_subdev(char *subdev, char *container)
 412 {
 413         struct mdstat_ent *mdstat = mdstat_read(0, 0);
 414         struct mdstat_ent *ent = NULL;
 415
 416         while (mdstat) {
 417                 /* metadata version must match:
 418                  *   external:[/-]%s/%s
 419                  * where first %s is 'container' and second %s is 'subdev'
 420                  */
 421                 if (ent)
 422                         free_mdstat(ent);
 423                 ent = mdstat;
 424                 mdstat = mdstat->next;
 425                 ent->next = NULL;
 426
 427                 if (ent->metadata_version == NULL ||
 428                     strncmp(ent->metadata_version, "external:", 9) != 0)
 429                         continue;
 430
 431                 if (!metadata_container_matches(ent->metadata_version+9,
 432                                                container) ||
 433                     !metadata_subdev_matches(ent->metadata_version+9,
 434                                              subdev))
 435                         continue;
 436
 437                 free_mdstat(mdstat);
 438                 return ent;
 439         }
 440         return NULL;
 441 }