policy.c

   1 /*
   2  * mdadm - manage Linux "md" devices aka RAID arrays.
   3  *
   4  * Copyright (C) 2001-2009 Neil Brown <neilb@suse.de>
   5  *
   6  *
   7  *    This program is free software; you can redistribute it and/or modify
   8  *    it under the terms of the GNU General Public License as published by
   9  *    the Free Software Foundation; either version 2 of the License, or
  10  *    (at your option) any later version.
  11  *
  12  *    This program is distributed in the hope that it will be useful,
  13  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *    GNU General Public License for more details.
  16  *
  17  *    You should have received a copy of the GNU General Public License
  18  *    along with this program; if not, write to the Free Software
  19  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  *    Author: Neil Brown
  22  *    Email: <neilb@suse.de>
  23  */
  24
  25 #include "mdadm.h"
  26 #include <dirent.h>
  27 #include <fnmatch.h>
  28 #include <ctype.h>
  29 #include "dlink.h"
  30 /*
  31  * Policy module for mdadm.
  32  * A policy statement about a device lists a set of values for each
  33  * of a set of names.  Each value can have a metadata type as context.
  34  *
  35  * names include:
  36  *   action - the actions that can be taken on hot-plug
  37  *   domain - the domain(s) that the device is part of
  38  *
  39  * Policy information is extracted from various sources, but
  40  * particularly from a set of policy rules in mdadm.conf
  41  */
  42
  43 static void pol_new(struct dev_policy **pol, char *name, const char *val,
  44                     const char *metadata)
  45 {
  46         struct dev_policy *n = xmalloc(sizeof(*n));
  47         const char *real_metadata = NULL;
  48         int i;
  49
  50         n->name = name;
  51         n->value = val;
  52
  53         /* We need to normalise the metadata name */
  54         if (metadata) {
  55                 for (i = 0; superlist[i] ; i++)
  56                         if (strcmp(metadata, superlist[i]->name) == 0) {
  57                                 real_metadata = superlist[i]->name;
  58                                 break;
  59                         }
  60                 if (!real_metadata) {
  61                         if (strcmp(metadata, "1") == 0 ||
  62                             strcmp(metadata, "1.0") == 0 ||
  63                             strcmp(metadata, "1.1") == 0 ||
  64                             strcmp(metadata, "1.2") == 0)
  65                                 real_metadata = super1.name;
  66                 }
  67                 if (!real_metadata) {
  68                         static const char *prev = NULL;
  69                         if (prev != metadata) {
  70                                 pr_err("metadata=%s unrecognised - ignoring rule\n",
  71                                         metadata);
  72                                 prev = metadata;
  73                         }
  74                         real_metadata = "unknown";
  75                 }
  76         }
  77
  78         n->metadata = real_metadata;
  79         n->next = *pol;
  80         *pol = n;
  81 }
  82
  83 static int pol_lesseq(struct dev_policy *a, struct dev_policy *b)
  84 {
  85         int cmp;
  86
  87         if (a->name < b->name)
  88                 return 1;
  89         if (a->name > b->name)
  90                 return 0;
  91
  92         cmp = strcmp(a->value, b->value);
  93         if (cmp < 0)
  94                 return 1;
  95         if (cmp > 0)
  96                 return 0;
  97
  98         return (a->metadata <= b->metadata);
  99 }
 100
 101 static void pol_sort(struct dev_policy **pol)
 102 {
 103         /* sort policy list in *pol by name/metadata/value
 104          * using merge sort
 105          */
 106
 107         struct dev_policy *pl[2];
 108         pl[0] = *pol;
 109         pl[1] = NULL;
 110
 111         do {
 112                 struct dev_policy **plp[2], *p[2];
 113                 int curr = 0;
 114                 struct dev_policy nul = { NULL, NULL, NULL, NULL };
 115                 struct dev_policy *prev = &nul;
 116                 int next = 0;
 117
 118                 /* p[] are the two lists that we are merging.
 119                  * plp[] are the ends of the two lists we create
 120                  * from the merge.
 121                  * 'curr' is which of plp[] that we are currently
 122                  *   adding items to.
 123                  * 'next' is which if p[] we will take the next
 124                  *   item from.
 125                  * 'prev' is that last value, which was placed in
 126                  * plp[curr].
 127                  */
 128                 plp[0] = &pl[0];
 129                 plp[1] = &pl[1];
 130                 p[0] = pl[0];
 131                 p[1] = pl[1];
 132
 133                 /* take least of p[0] and p[1]
 134                  * if it is larger than prev, add to
 135                  * plp[curr], else swap curr then add
 136                  */
 137                 while (p[0] || p[1]) {
 138                         if (p[next] == NULL ||
 139                             (p[1-next] != NULL &&
 140                              !(pol_lesseq(prev, p[1-next])
 141                                ^pol_lesseq(prev, p[next])
 142                                ^pol_lesseq(p[next], p[1-next])))
 143                                 )
 144                                 next = 1 - next;
 145
 146                         if (!pol_lesseq(prev, p[next]))
 147                                 curr = 1 - curr;
 148
 149                         *plp[curr] = prev = p[next];
 150                         plp[curr] = &p[next]->next;
 151                         p[next] = p[next]->next;
 152                 }
 153                 *plp[0] = NULL;
 154                 *plp[1] = NULL;
 155         } while (pl[0] && pl[1]);
 156         if (pl[0])
 157                 *pol = pl[0];
 158         else
 159                 *pol = pl[1];
 160 }
 161
 162 static void pol_dedup(struct dev_policy *pol)
 163 {
 164         /* This is a sorted list - remove duplicates. */
 165         while (pol && pol->next) {
 166                 if (pol_lesseq(pol->next, pol)) {
 167                         struct dev_policy *tmp = pol->next;
 168                         pol->next = tmp->next;
 169                         free(tmp);
 170                 } else
 171                         pol = pol->next;
 172         }
 173 }
 174
 175 /*
 176  * pol_find finds the first entry in the policy
 177  * list to match name.
 178  * If it returns non-NULL there is at least one
 179  * value, but how many can only be found by
 180  * iterating through the list.
 181  */
 182 struct dev_policy *pol_find(struct dev_policy *pol, char *name)
 183 {
 184         while (pol && pol->name < name)
 185                 pol = pol->next;
 186
 187         if (!pol || pol->name != name)
 188                 return NULL;
 189         return pol;
 190 }
 191
 192 static char **disk_paths(struct mdinfo *disk)
 193 {
 194         struct stat stb;
 195         int prefix_len;
 196         DIR *by_path;
 197         char symlink[PATH_MAX] = "/dev/disk/by-path/";
 198         char **paths;
 199         int cnt = 0;
 200         struct dirent *ent;
 201
 202         paths = xmalloc(sizeof(*paths) * (cnt+1));
 203
 204         by_path = opendir(symlink);
 205         if (by_path) {
 206                 prefix_len = strlen(symlink);
 207                 while ((ent = readdir(by_path)) != NULL) {
 208                         if (ent->d_type != DT_LNK)
 209                                 continue;
 210                         strncpy(symlink + prefix_len,
 211                                         ent->d_name,
 212                                         sizeof(symlink) - prefix_len);
 213                         if (stat(symlink, &stb) < 0)
 214                                 continue;
 215                         if ((stb.st_mode & S_IFMT) != S_IFBLK)
 216                                 continue;
 217                         if (stb.st_rdev != makedev(disk->disk.major, disk->disk.minor))
 218                                 continue;
 219                         paths[cnt++] = xstrdup(ent->d_name);
 220                         paths = xrealloc(paths, sizeof(*paths) * (cnt+1));
 221                 }
 222                 closedir(by_path);
 223         }
 224         paths[cnt] = NULL;
 225         return paths;
 226 }
 227
 228 char type_part[] = "part";
 229 char type_disk[] = "disk";
 230 static char *disk_type(struct mdinfo *disk)
 231 {
 232         char buf[30+20+20];
 233         struct stat stb;
 234         sprintf(buf, "/sys/dev/block/%d:%d/partition",
 235                 disk->disk.major, disk->disk.minor);
 236         if (stat(buf, &stb) == 0)
 237                 return type_part;
 238         else
 239                 return type_disk;
 240 }
 241
 242 static int path_has_part(char *path, char **part)
 243 {
 244         /* check if path ends with "-partNN" and
 245          * if it does, place a pointer to "-pathNN"
 246          * in 'part'.
 247          */
 248         int l;
 249         if (!path)
 250                 return 0;
 251         l = strlen(path);
 252         while (l > 1 && isdigit(path[l-1]))
 253                 l--;
 254         if (l < 5 || strncmp(path+l-5, "-part", 5) != 0)
 255                 return 0;
 256         *part = path+l-5;
 257         return 1;
 258 }
 259
 260 static int pol_match(struct rule *rule, char **paths, char *type, char **part)
 261 {
 262         /* Check if this rule matches on any path and type.
 263          * If 'part' is not NULL, then 'path' must end in -partN, which
 264          * we ignore for matching, and return in *part on success.
 265          */
 266         int pathok = 0; /* 0 == no path, 1 == match, -1 == no match yet */
 267         int typeok = 0;
 268
 269         for (; rule; rule = rule->next) {
 270                 if (rule->name == rule_path) {
 271                         char *p = NULL;
 272                         int i;
 273                         if (pathok == 0)
 274                                 pathok = -1;
 275                         if (!paths)
 276                                 continue;
 277                         for (i = 0; paths[i]; i++) {
 278                                 if (part) {
 279                                         if (!path_has_part(paths[i], &p))
 280                                                 continue;
 281                                         *p = '\0';
 282                                         *part = p+1;
 283                                 }
 284                                 if (fnmatch(rule->value, paths[i], 0) == 0)
 285                                         pathok = 1;
 286                                 if (part)
 287                                         *p = '-';
 288                         }
 289                 }
 290                 if (rule->name == rule_type) {
 291                         if (typeok == 0)
 292                                 typeok = -1;
 293                         if (type && strcmp(rule->value, type) == 0)
 294                                 typeok = 1;
 295                 }
 296         }
 297         return pathok >= 0 && typeok >= 0;
 298 }
 299
 300 static void pol_merge(struct dev_policy **pol, struct rule *rule)
 301 {
 302         /* copy any name assignments from rule into pol */
 303         struct rule *r;
 304         char *metadata = NULL;
 305         for (r = rule; r ; r = r->next)
 306                 if (r->name == pol_metadata)
 307                         metadata = r->value;
 308
 309         for (r = rule; r ; r = r->next)
 310                 if (r->name == pol_act ||
 311                     r->name == pol_domain ||
 312                     r->name == pol_auto)
 313                         pol_new(pol, r->name, r->value, metadata);
 314 }
 315
 316 static void pol_merge_part(struct dev_policy **pol, struct rule *rule, char *part)
 317 {
 318         /* copy any name assignments from rule into pol, appending
 319          * -part to any domain.  The string with -part appended is
 320          * stored with the rule so it has a lifetime to match
 321          * the rule.
 322          */
 323         struct rule *r;
 324         char *metadata = NULL;
 325         for (r = rule; r ; r = r->next)
 326                 if (r->name == pol_metadata)
 327                         metadata = r->value;
 328
 329         for (r = rule; r ; r = r->next) {
 330                 if (r->name == pol_act)
 331                         pol_new(pol, r->name, r->value, metadata);
 332                 else if (r->name == pol_domain) {
 333                         char *dom;
 334                         int len;
 335                         if (r->dups == NULL)
 336                                 r->dups = dl_head();
 337                         len = strlen(r->value);
 338                         for (dom = dl_next(r->dups); dom != r->dups;
 339                              dom = dl_next(dom))
 340                                 if (strcmp(dom+len+1, part)== 0)
 341                                         break;
 342                         if (dom == r->dups) {
 343                                 char *newdom = dl_strndup(
 344                                         r->value, len + 1 + strlen(part));
 345                                 strcat(strcat(newdom, "-"), part);
 346                                 dl_add(r->dups, newdom);
 347                                 dom = newdom;
 348                         }
 349                         pol_new(pol, r->name, dom, metadata);
 350                 }
 351         }
 352 }
 353
 354 static struct pol_rule *config_rules = NULL;
 355 static struct pol_rule **config_rules_end = NULL;
 356 static int config_rules_has_path = 0;
 357
 358 /*
 359  * most policy comes from a set policy rules that are
 360  * read from the config file.
 361  * path_policy() gathers policy information for the
 362  * disk described in the given a 'path' and a 'type'.
 363  */
 364 struct dev_policy *path_policy(char **paths, char *type)
 365 {
 366         struct pol_rule *rules;
 367         struct dev_policy *pol = NULL;
 368
 369         rules = config_rules;
 370
 371         while (rules) {
 372                 char *part = NULL;
 373                 if (rules->type == rule_policy)
 374                         if (pol_match(rules->rule, paths, type, NULL))
 375                                 pol_merge(&pol, rules->rule);
 376                 if (rules->type == rule_part && strcmp(type, type_part) == 0)
 377                         if (pol_match(rules->rule, paths, type_disk, &part))
 378                                         pol_merge_part(&pol, rules->rule, part);
 379                 rules = rules->next;
 380         }
 381
 382         pol_sort(&pol);
 383         pol_dedup(pol);
 384         return pol;
 385 }
 386
 387 /**
 388  * drive_test_and_add_policies() - get policies for drive and add them to pols.
 389  * @st: supertype.
 390  * @pols: pointer to pointer of first list entry, cannot be NULL, may point to NULL.
 391  * @fd: device descriptor.
 392  * @verbose: verbose flag.
 393  *
 394  * If supertype doesn't support this functionality return success. Use metadata handler to get
 395  * policies.
 396  */
 397 mdadm_status_t drive_test_and_add_policies(struct supertype *st, dev_policy_t **pols, int fd,
 398                                            const int verbose)
 399 {
 400         if (!st->ss->test_and_add_drive_policies)
 401                 return MDADM_STATUS_SUCCESS;
 402
 403         if (st->ss->test_and_add_drive_policies(pols, fd, verbose) == MDADM_STATUS_SUCCESS) {
 404                 /* After successful call list cannot be empty */
 405                 assert(*pols);
 406                 return MDADM_STATUS_SUCCESS;
 407         }
 408
 409         return MDADM_STATUS_ERROR;
 410 }
 411
 412 /**
 413  * sysfs_test_and_add_policies() - get policies for mddev and add them to pols.
 414  * @st: supertype.
 415  * @pols: pointer to pointer of first list entry, cannot be NULL, may point to NULL.
 416  * @mdi: mdinfo describes the MD array, must have GET_DISKS option.
 417  * @verbose: verbose flag.
 418  *
 419  * If supertype doesn't support this functionality return success. To get policies, all disks
 420  * connected to mddev are analyzed.
 421  */
 422 mdadm_status_t sysfs_test_and_add_drive_policies(struct supertype *st, dev_policy_t **pols,
 423                                                  struct mdinfo *mdi, const int verbose)
 424 {
 425         struct mdinfo *sd;
 426
 427         if (!st->ss->test_and_add_drive_policies)
 428                 return MDADM_STATUS_SUCCESS;
 429
 430         for (sd = mdi->devs; sd; sd = sd->next) {
 431                 char *devpath = map_dev(sd->disk.major, sd->disk.minor, 0);
 432                 int fd = dev_open(devpath, O_RDONLY);
 433                 int rv;
 434
 435                 if (!is_fd_valid(fd)) {
 436                         pr_err("Cannot open fd for %s\n", devpath);
 437                         return MDADM_STATUS_ERROR;
 438                 }
 439
 440                 rv = drive_test_and_add_policies(st, pols, fd, verbose);
 441                 close(fd);
 442
 443                 if (rv)
 444                         return MDADM_STATUS_ERROR;
 445         }
 446
 447         return MDADM_STATUS_SUCCESS;
 448 }
 449
 450 /**
 451  * mddev_test_and_add_policies() - get policies for mddev and add them to pols.
 452  * @st: supertype.
 453  * @pols: pointer to pointer of first list entry, cannot be NULL, may point to NULL.
 454  * @array_fd: MD device descriptor.
 455  * @verbose: verbose flag.
 456  *
 457  * If supertype doesn't support this functionality return success. Use fd to extract disks.
 458  */
 459 mdadm_status_t mddev_test_and_add_drive_policies(struct supertype *st, dev_policy_t **pols,
 460                                                  int array_fd, const int verbose)
 461 {
 462         struct mdinfo *sra;
 463         int ret;
 464
 465         if (!st->ss->test_and_add_drive_policies)
 466                 return MDADM_STATUS_SUCCESS;
 467
 468         sra = sysfs_read(array_fd, NULL, GET_DEVS);
 469         if (!sra) {
 470                 pr_err("Cannot load sysfs for %s\n", fd2devnm(array_fd));
 471                 return MDADM_STATUS_ERROR;
 472         }
 473
 474         ret = sysfs_test_and_add_drive_policies(st, pols, sra, verbose);
 475
 476         sysfs_free(sra);
 477         return ret;
 478 }
 479
 480 void pol_add(struct dev_policy **pol,
 481                     char *name, char *val,
 482                     char *metadata)
 483 {
 484         pol_new(pol, name, val, metadata);
 485         pol_sort(pol);
 486         pol_dedup(*pol);
 487 }
 488
 489 static void free_paths(char **paths)
 490 {
 491         int i;
 492
 493         if (!paths)
 494                 return;
 495
 496         for (i = 0; paths[i]; i++)
 497                 free(paths[i]);
 498         free(paths);
 499 }
 500
 501 /*
 502  * disk_policy() gathers policy information for the
 503  * disk described in the given mdinfo (disk.{major,minor}).
 504  */
 505 struct dev_policy *disk_policy(struct mdinfo *disk)
 506 {
 507         char **paths = NULL;
 508         char *type = disk_type(disk);
 509         struct dev_policy *pol = NULL;
 510
 511         if (config_rules_has_path)
 512                 paths = disk_paths(disk);
 513
 514         pol = path_policy(paths, type);
 515
 516         free_paths(paths);
 517         return pol;
 518 }
 519
 520 struct dev_policy *devid_policy(int dev)
 521 {
 522         struct mdinfo disk;
 523         disk.disk.major = major(dev);
 524         disk.disk.minor = minor(dev);
 525         return disk_policy(&disk);
 526 }
 527
 528 /*
 529  * process policy rules read from config file.
 530  */
 531
 532 char rule_path[] = "path";
 533 char rule_type[] = "type";
 534
 535 char rule_policy[] = "policy";
 536 char rule_part[] = "part-policy";
 537
 538 char pol_metadata[] = "metadata";
 539 char pol_act[] = "action";
 540 char pol_domain[] = "domain";
 541 char pol_auto[] = "auto";
 542
 543 static int try_rule(char *w, char *name, struct rule **rp)
 544 {
 545         struct rule *r;
 546         int len = strlen(name);
 547         if (strncmp(w, name, len) != 0 ||
 548             w[len] != '=')
 549                 return 0;
 550         r = xmalloc(sizeof(*r));
 551         r->next = *rp;
 552         r->name = name;
 553         r->value = xstrdup(w+len+1);
 554         r->dups = NULL;
 555         *rp = r;
 556         return 1;
 557 }
 558
 559 void policyline(char *line, char *type)
 560 {
 561         struct pol_rule *pr;
 562         char *w;
 563
 564         if (config_rules_end == NULL)
 565                 config_rules_end = &config_rules;
 566
 567         pr = xmalloc(sizeof(*pr));
 568         pr->type = type;
 569         pr->rule = NULL;
 570         for (w = dl_next(line); w != line ; w = dl_next(w)) {
 571                 if (try_rule(w, rule_path, &pr->rule))
 572                         config_rules_has_path = 1;
 573                 else if (! try_rule(w, rule_type, &pr->rule) &&
 574                          ! try_rule(w, pol_metadata, &pr->rule) &&
 575                          ! try_rule(w, pol_act, &pr->rule) &&
 576                          ! try_rule(w, pol_domain, &pr->rule) &&
 577                          ! try_rule(w, pol_auto, &pr->rule))
 578                         pr_err("policy rule %s unrecognised and ignored\n",
 579                                 w);
 580         }
 581         pr->next = config_rules;
 582         config_rules = pr;
 583 }
 584
 585 void policy_add(char *type, ...)
 586 {
 587         va_list ap;
 588         struct pol_rule *pr;
 589         char *name, *val;
 590
 591         pr = xmalloc(sizeof(*pr));
 592         pr->type = type;
 593         pr->rule = NULL;
 594
 595         va_start(ap, type);
 596         while ((name = va_arg(ap, char*)) != NULL) {
 597                 struct rule *r;
 598
 599                 val = va_arg(ap, char*);
 600                 r = xmalloc(sizeof(*r));
 601                 r->next = pr->rule;
 602                 r->name = name;
 603                 r->value = xstrdup(val);
 604                 r->dups = NULL;
 605                 pr->rule = r;
 606         }
 607         pr->next = config_rules;
 608         config_rules = pr;
 609         va_end(ap);
 610 }
 611
 612 void policy_free(void)
 613 {
 614         while (config_rules) {
 615                 struct pol_rule *pr = config_rules;
 616                 struct rule *r;
 617
 618                 config_rules = config_rules->next;
 619
 620                 for (r = pr->rule; r; ) {
 621                         struct rule *next = r->next;
 622                         free(r->value);
 623                         if (r->dups)
 624                                 free_line(r->dups);
 625                         free(r);
 626                         r = next;
 627                 }
 628                 free(pr);
 629         }
 630         config_rules_end = NULL;
 631         config_rules_has_path = 0;
 632 }
 633
 634 void dev_policy_free(struct dev_policy *p)
 635 {
 636         struct dev_policy *t;
 637         while (p) {
 638                 t = p;
 639                 p = p->next;
 640                 free(t);
 641         }
 642 }
 643
 644 static enum policy_action map_act(const char *act)
 645 {
 646         if (strcmp(act, "include") == 0)
 647                 return act_include;
 648         if (strcmp(act, "re-add") == 0)
 649                 return act_re_add;
 650         if (strcmp(act, "spare") == 0)
 651                 return act_spare;
 652         if (strcmp(act, "spare-same-slot") == 0)
 653                 return act_spare_same_slot;
 654         if (strcmp(act, "force-spare") == 0)
 655                 return act_force_spare;
 656         return act_err;
 657 }
 658
 659 static enum policy_action policy_action(struct dev_policy *plist, const char *metadata)
 660 {
 661         enum policy_action rv = act_default;
 662         struct dev_policy *p;
 663
 664         plist = pol_find(plist, pol_act);
 665         pol_for_each(p, plist, metadata) {
 666                 enum policy_action a = map_act(p->value);
 667                 if (a > rv)
 668                         rv = a;
 669         }
 670         return rv;
 671 }
 672
 673 int policy_action_allows(struct dev_policy *plist, const char *metadata, enum policy_action want)
 674 {
 675         enum policy_action act = policy_action(plist, metadata);
 676
 677         if (act == act_err)
 678                 return 0;
 679         return (act >= want);
 680 }
 681
 682 int disk_action_allows(struct mdinfo *disk, const char *metadata, enum policy_action want)
 683 {
 684         struct dev_policy *pol = disk_policy(disk);
 685         int rv = policy_action_allows(pol, metadata, want);
 686
 687         dev_policy_free(pol);
 688         return rv;
 689 }
 690
 691 /* Domain policy:
 692  * Any device can have a list of domains asserted by different policy
 693  * statements.
 694  * An array also has a list of domains comprising all the domains of
 695  * all the devices in an array.
 696  * Where an array has a spare-group, that becomes an addition domain for
 697  * every device in the array and thus for the array.
 698  *
 699  * We keep the list of domains in a sorted linked list
 700  * As dev policies are already sorted, this is fairly easy to manage.
 701  */
 702
 703 static struct domainlist **domain_merge_one(struct domainlist **domp,
 704                                             const char *domain)
 705 {
 706         /* merge a domain name into a sorted list and return the
 707          * location of the insertion or match
 708          */
 709         struct domainlist *dom = *domp;
 710
 711         while (dom && strcmp(dom->dom, domain) < 0) {
 712                 domp = &dom->next;
 713                 dom = *domp;
 714         }
 715         if (dom == NULL || strcmp(dom->dom, domain) != 0) {
 716                 dom = xmalloc(sizeof(*dom));
 717                 dom->next = *domp;
 718                 dom->dom = domain;
 719                 *domp = dom;
 720         }
 721         return domp;
 722 }
 723
 724 #if (DEBUG)
 725 void dump_policy(struct dev_policy *policy)
 726 {
 727         while (policy) {
 728                 dprintf("policy: %p name: %s value: %s metadata: %s\n",
 729                         policy,
 730                         policy->name,
 731                         policy->value,
 732                         policy->metadata);
 733                 policy = policy->next;
 734         }
 735 }
 736 #endif
 737
 738 void domain_merge(struct domainlist **domp, struct dev_policy *pollist,
 739                          const char *metadata)
 740 {
 741         /* Add to 'domp' all the domains in pol that apply to 'metadata'
 742          * which are not already in domp
 743          */
 744         struct dev_policy *pol;
 745         pollist = pol_find(pollist, pol_domain);
 746         pol_for_each(pol, pollist, metadata)
 747                 domain_merge_one(domp, pol->value);
 748 }
 749
 750 int domain_test(struct domainlist *dom, struct dev_policy *pol,
 751                 const char *metadata)
 752 {
 753         /* Check that all domains in pol (for metadata) are also in
 754          * dom.  Both lists are sorted.
 755          * If pol has no domains, we don't really know about this device
 756          * so we allow caller to choose:
 757          * -1:  has no domains
 758          *  0:  has domains, not all match
 759          *  1:  has domains, all match
 760          */
 761         int found_any = -1;
 762         struct dev_policy *p;
 763
 764         pol = pol_find(pol, pol_domain);
 765         pol_for_each(p, pol, metadata) {
 766                 found_any = 1;
 767                 while (dom && strcmp(dom->dom, p->value) < 0)
 768                         dom = dom->next;
 769                 if (!dom || strcmp(dom->dom, p->value) != 0)
 770                         return 0;
 771         }
 772         return found_any;
 773 }
 774
 775 void domainlist_add_dev(struct domainlist **dom, int devid, const char *metadata)
 776 {
 777         struct dev_policy *pol = devid_policy(devid);
 778         domain_merge(dom, pol, metadata);
 779         dev_policy_free(pol);
 780 }
 781
 782 struct domainlist *domain_from_array(struct mdinfo *mdi, const char *metadata)
 783 {
 784         struct domainlist *domlist = NULL;
 785
 786         if (!mdi)
 787                 return NULL;
 788         for (mdi = mdi->devs ; mdi ; mdi = mdi->next)
 789                 domainlist_add_dev(&domlist, makedev(mdi->disk.major,
 790                                                      mdi->disk.minor),
 791                                    metadata);
 792
 793         return domlist;
 794 }
 795
 796 void domain_add(struct domainlist **domp, char *domain)
 797 {
 798         domain_merge_one(domp, domain);
 799 }
 800
 801 void domain_free(struct domainlist *dl)
 802 {
 803         while (dl) {
 804                 struct domainlist *head = dl;
 805                 dl = dl->next;
 806                 free(head);
 807         }
 808 }
 809
 810 /*
 811  * same-path policy.
 812  * Some policy decisions are guided by knowledge of which
 813  * array previously owned the device at a given physical location (path).
 814  * When removing a device from an array we might record the array against
 815  * the path, and when finding a new device, we might look for which
 816  * array previously used that path.
 817  *
 818  * The 'array' is described by a map_ent, and the path by a the disk in an
 819  * mdinfo, or a string.
 820  */
 821
 822 void policy_save_path(char *id_path, struct map_ent *array)
 823 {
 824         char path[PATH_MAX];
 825         FILE *f = NULL;
 826
 827         if (mkdir(FAILED_SLOTS_DIR, S_IRWXU) < 0 && errno != EEXIST) {
 828                 pr_err("can't create file to save path to old disk: %s\n", strerror(errno));
 829                 return;
 830         }
 831
 832         snprintf(path, PATH_MAX, FAILED_SLOTS_DIR "/%s", id_path);
 833         f = fopen(path, "w");
 834         if (!f) {
 835                 pr_err("can't create file to save path to old disk: %s\n",
 836                         strerror(errno));
 837                 return;
 838         }
 839
 840         if (fprintf(f, "%20s %08x:%08x:%08x:%08x\n",
 841                     array->metadata,
 842                     array->uuid[0], array->uuid[1],
 843                     array->uuid[2], array->uuid[3]) <= 0)
 844                 pr_err("Failed to write to <id_path> cookie\n");
 845
 846         fclose(f);
 847 }
 848
 849 int policy_check_path(struct mdinfo *disk, struct map_ent *array)
 850 {
 851         char path[PATH_MAX];
 852         FILE *f = NULL;
 853         char **id_paths = disk_paths(disk);
 854         int i;
 855         int rv = 0;
 856
 857         for (i = 0; id_paths[i]; i++) {
 858                 snprintf(path, PATH_MAX, FAILED_SLOTS_DIR "/%s", id_paths[i]);
 859                 f = fopen(path, "r");
 860                 if (!f)
 861                         continue;
 862
 863                 rv = fscanf(f, " %20s %x:%x:%x:%x\n",
 864                             array->metadata,
 865                             array->uuid,
 866                             array->uuid+1,
 867                             array->uuid+2,
 868                             array->uuid+3);
 869                 fclose(f);
 870                 break;
 871         }
 872         free_paths(id_paths);
 873         return rv == 5;
 874 }
 875
 876 /* invocation of udev rule file */
 877 char udev_template_start[] =
 878 "# do not edit this file, it is automatically generated by mdadm\n"
 879 "\n";
 880
 881 /* find rule named rule_type and return its value */
 882 char *find_rule(struct rule *rule, char *rule_type)
 883 {
 884         while (rule) {
 885                 if (rule->name == rule_type)
 886                         return rule->value;
 887
 888                 rule = rule->next;
 889         }
 890         return NULL;
 891 }
 892
 893 #define UDEV_RULE_FORMAT \
 894 "ACTION==\"add\", SUBSYSTEM==\"block\", " \
 895 "ENV{DEVTYPE}==\"%s\", ENV{ID_PATH}==\"%s\", " \
 896 "RUN+=\"" BINDIR "/mdadm --incremental $env{DEVNAME}\"\n"
 897
 898 #define UDEV_RULE_FORMAT_NOTYPE \
 899 "ACTION==\"add\", SUBSYSTEM==\"block\", " \
 900 "ENV{ID_PATH}==\"%s\", " \
 901 "RUN+=\"" BINDIR "/mdadm --incremental $env{DEVNAME}\"\n"
 902
 903 /* Write rule in the rule file. Use format from UDEV_RULE_FORMAT */
 904 int write_rule(struct rule *rule, int fd, int force_part)
 905 {
 906         char line[1024];
 907         char *pth = find_rule(rule, rule_path);
 908         char *typ = find_rule(rule, rule_type);
 909         if (!pth)
 910                 return -1;
 911
 912         if (force_part)
 913                 typ = type_part;
 914         if (typ)
 915                 snprintf(line, sizeof(line) - 1, UDEV_RULE_FORMAT, typ, pth);
 916         else
 917                 snprintf(line, sizeof(line) - 1, UDEV_RULE_FORMAT_NOTYPE, pth);
 918         return write(fd, line, strlen(line)) == (int)strlen(line);
 919 }
 920
 921 /* Generate single entry in udev rule basing on POLICY line found in config
 922  * file. Take only those with paths, only first occurrence if paths are equal
 923  * and if actions supports handling of spares (>=act_spare_same_slot)
 924  */
 925 int generate_entries(int fd)
 926 {
 927         struct pol_rule *loop, *dup;
 928         char *loop_value, *dup_value;
 929         int duplicate;
 930
 931         for (loop = config_rules; loop; loop = loop->next) {
 932                 if (loop->type != rule_policy && loop->type != rule_part)
 933                         continue;
 934                 duplicate = 0;
 935
 936                 /* only policies with paths and with actions supporting
 937                  * bare disks are considered */
 938                 loop_value = find_rule(loop->rule, pol_act);
 939                 if (!loop_value || map_act(loop_value) < act_spare_same_slot)
 940                         continue;
 941                 loop_value = find_rule(loop->rule, rule_path);
 942                 if (!loop_value)
 943                         continue;
 944                 for (dup = config_rules; dup != loop; dup = dup->next) {
 945                         if (dup->type != rule_policy && loop->type != rule_part)
 946                                 continue;
 947                         dup_value = find_rule(dup->rule, pol_act);
 948                         if (!dup_value || map_act(dup_value) < act_spare_same_slot)
 949                                 continue;
 950                         dup_value = find_rule(dup->rule, rule_path);
 951                         if (!dup_value)
 952                                 continue;
 953                         if (strcmp(loop_value, dup_value) == 0) {
 954                                 duplicate = 1;
 955                                 break;
 956                         }
 957                 }
 958
 959                 /* not a dup or first occurrence */
 960                 if (!duplicate)
 961                         if (!write_rule(loop->rule, fd, loop->type == rule_part) )
 962                                 return 0;
 963         }
 964         return 1;
 965 }
 966
 967 /* Write_rules routine creates dynamic udev rules used to handle
 968  * hot-plug events for bare devices (and making them spares)
 969  */
 970 int Write_rules(char *rule_name)
 971 {
 972         int fd;
 973         char udev_rule_file[PATH_MAX];
 974
 975         if (rule_name) {
 976                 strncpy(udev_rule_file, rule_name, sizeof(udev_rule_file) - 6);
 977                 udev_rule_file[sizeof(udev_rule_file) - 6] = '\0';
 978                 strcat(udev_rule_file, ".temp");
 979                 fd = creat(udev_rule_file,
 980                            S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 981                 if (fd == -1)
 982                         return 1;
 983         } else
 984                 fd = 1;
 985
 986         /* write static invocation */
 987         if (write(fd, udev_template_start, sizeof(udev_template_start) - 1) !=
 988             (int)sizeof(udev_template_start) - 1)
 989                 goto abort;
 990
 991         /* iterate, if none created or error occurred, remove file */
 992         if (generate_entries(fd) < 0)
 993                 goto abort;
 994
 995         fsync(fd);
 996         if (rule_name) {
 997                 close(fd);
 998                 rename(udev_rule_file, rule_name);
 999         }
1000         return 0;
1001 abort:
1002         if (rule_name) {
1003                 close(fd);
1004                 unlink(udev_rule_file);
1005         }
1006         return 1;
1007 }