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 void pol_new(struct dev_policy **pol, char *name, char *val, char *metadata)
  44 {
  45         struct dev_policy *n = malloc(sizeof(*n));
  46         const char *real_metadata = NULL;
  47         int i;
  48
  49         n->name = name;
  50         n->value = val;
  51
  52         /* We need to normalise the metadata name */
  53         if (metadata) {
  54                 for (i = 0; superlist[i] ; i++)
  55                         if (strcmp(metadata, superlist[i]->name) == 0) {
  56                                 real_metadata = superlist[i]->name;
  57                                 break;
  58                         }
  59                 if (!real_metadata) {
  60                         if (strcmp(metadata, "1") == 0 ||
  61                             strcmp(metadata, "1.0") == 0 ||
  62                             strcmp(metadata, "1.1") == 0 ||
  63                             strcmp(metadata, "1.2") == 0)
  64                                 real_metadata = super1.name;
  65                 }
  66                 if (!real_metadata) {
  67                         static char *prev = NULL;
  68                         if (prev != metadata) {
  69                                 fprintf(stderr, Name ": metadata=%s unrecognised - ignoring rule\n",
  70                                         metadata);
  71                                 prev = metadata;
  72                         }
  73                         real_metadata = "unknown";
  74                 }
  75         }
  76
  77         n->metadata = real_metadata;
  78         n->next = *pol;
  79         *pol = n;
  80 }
  81
  82 static int pol_lesseq(struct dev_policy *a, struct dev_policy *b)
  83 {
  84         int cmp;
  85
  86         if (a->name < b->name)
  87                 return 1;
  88         if (a->name > b->name)
  89                 return 0;
  90
  91         cmp = strcmp(a->value, b->value);
  92         if (cmp < 0)
  93                 return 1;
  94         if (cmp > 0)
  95                 return 0;
  96
  97         return (a->metadata <= b->metadata);
  98 }
  99
 100 static void pol_sort(struct dev_policy **pol)
 101 {
 102         /* sort policy list in *pol by name/metadata/value
 103          * using merge sort
 104          */
 105
 106         struct dev_policy *pl[2];
 107         pl[0] = *pol;
 108         pl[1] = NULL;
 109
 110         do {
 111                 struct dev_policy **plp[2], *p[2];
 112                 int curr = 0;
 113                 struct dev_policy nul = { NULL, NULL, NULL, NULL };
 114                 struct dev_policy *prev = &nul;
 115                 int next = 0;
 116
 117                 /* p[] are the two lists that we are merging.
 118                  * plp[] are the ends of the two lists we create
 119                  * from the merge.
 120                  * 'curr' is which of plp[] that we are currently
 121                  *   adding items to.
 122                  * 'next' is which if p[] we will take the next
 123                  *   item from.
 124                  * 'prev' is that last value, which was placed in
 125                  * plp[curr].
 126                  */
 127                 plp[0] = &pl[0];
 128                 plp[1] = &pl[1];
 129                 p[0] = pl[0];
 130                 p[1] = pl[1];
 131
 132                 /* take least of p[0] and p[1]
 133                  * if it is larger than prev, add to
 134                  * plp[curr], else swap curr then add
 135                  */
 136                 while (p[0] || p[1]) {
 137                         if (p[next] == NULL ||
 138                             (p[1-next] != NULL &&
 139                              !(pol_lesseq(prev, p[1-next])
 140                                ^pol_lesseq(prev, p[next])
 141                                ^pol_lesseq(p[next], p[1-next])))
 142                                 )
 143                                 next = 1 - next;
 144
 145                         if (!pol_lesseq(prev, p[next]))
 146                                 curr = 1 - curr;
 147
 148                         *plp[curr] = prev = p[next];
 149                         plp[curr] = &p[next]->next;
 150                         p[next] = p[next]->next;
 151                 }
 152                 *plp[0] = NULL;
 153                 *plp[1] = NULL;
 154         } while (pl[0] && pl[1]);
 155         if (pl[0])
 156                 *pol = pl[0];
 157         else
 158                 *pol = pl[1];
 159 }
 160
 161 static void pol_dedup(struct dev_policy *pol)
 162 {
 163         /* This is a sorted list - remove duplicates. */
 164         while (pol && pol->next) {
 165                 if (pol_lesseq(pol->next, pol)) {
 166                         struct dev_policy *tmp = pol->next;
 167                         pol->next = tmp->next;
 168                         free(tmp);
 169                 } else
 170                         pol = pol->next;
 171         }
 172 }
 173
 174 /*
 175  * pol_find finds the first entry in the policy
 176  * list to match name.
 177  * If it returns non-NULL there is at least one
 178  * value, but how many can only be found by
 179  * iterating through the list.
 180  */
 181 struct dev_policy *pol_find(struct dev_policy *pol, char *name)
 182 {
 183         while (pol && pol->name < name)
 184                 pol = pol->next;
 185
 186         if (!pol || pol->name != name)
 187                 return NULL;
 188         return pol;
 189 }
 190
 191 static char *disk_path(struct mdinfo *disk)
 192 {
 193         struct stat stb;
 194         int prefix_len;
 195         DIR *by_path;
 196         char symlink[PATH_MAX] = "/dev/disk/by-path/";
 197         struct dirent *ent;
 198
 199         by_path = opendir(symlink);
 200         if (!by_path)
 201                 return NULL;
 202         prefix_len = strlen(symlink);
 203
 204         while ((ent = readdir(by_path)) != NULL) {
 205                 if (ent->d_type != DT_LNK)
 206                         continue;
 207                 strncpy(symlink + prefix_len,
 208                         ent->d_name,
 209                         sizeof(symlink) - prefix_len);
 210                 if (stat(symlink, &stb) < 0)
 211                         continue;
 212                 if ((stb.st_mode & S_IFMT) != S_IFBLK)
 213                         continue;
 214                 if (stb.st_rdev != makedev(disk->disk.major, disk->disk.minor))
 215                         continue;
 216                 closedir(by_path);
 217                 return strdup(ent->d_name);
 218         }
 219         closedir(by_path);
 220         return NULL;
 221 }
 222
 223 char type_part[] = "part";
 224 char type_disk[] = "disk";
 225 static char *disk_type(struct mdinfo *disk)
 226 {
 227         char buf[30+20+20];
 228         struct stat stb;
 229         sprintf(buf, "/sys/dev/block/%d:%d/partition",
 230                 disk->disk.major, disk->disk.minor);
 231         if (stat(buf, &stb) == 0)
 232                 return type_part;
 233         else
 234                 return type_disk;
 235 }
 236
 237 static int pol_match(struct rule *rule, char *path, char *type)
 238 {
 239         /* check if this rule matches on path and type */
 240         int pathok = 0; /* 0 == no path, 1 == match, -1 == no match yet */
 241         int typeok = 0;
 242
 243         while (rule) {
 244                 if (rule->name == rule_path) {
 245                         if (pathok == 0)
 246                                 pathok = -1;
 247                         if (fnmatch(rule->value, path, 0) == 0)
 248                                 pathok = 1;
 249                 }
 250                 if (rule->name == rule_type) {
 251                         if (typeok == 0)
 252                                 typeok = -1;
 253                         if (strcmp(rule->value, type) == 0)
 254                                 typeok = 1;
 255                 }
 256                 rule = rule->next;
 257         }
 258         return pathok >= 0 && typeok >= 0;
 259 }
 260
 261 static void pol_merge(struct dev_policy **pol, struct rule *rule)
 262 {
 263         /* copy any name assignments from rule into pol */
 264         struct rule *r;
 265         char *metadata = NULL;
 266         for (r = rule; r ; r = r->next)
 267                 if (r->name == pol_metadata)
 268                         metadata = r->value;
 269
 270         for (r = rule; r ; r = r->next)
 271                 if (r->name == pol_act ||
 272                     r->name == pol_domain)
 273                         pol_new(pol, r->name, r->value, metadata);
 274 }
 275
 276 static int path_has_part(char *path, char **part)
 277 {
 278         /* check if path ends with "-partNN" and
 279          * if it does, place a pointer to "-pathNN"
 280          * in 'part'.
 281          */
 282         int l = strlen(path);
 283         while (l > 1 && isdigit(path[l-1]))
 284                 l--;
 285         if (l < 5 || strncmp(path+l-5, "-part", 5) != 0)
 286                 return 0;
 287         *part = path+l-4;
 288         return 1;
 289 }
 290
 291 static void pol_merge_part(struct dev_policy **pol, struct rule *rule, char *part)
 292 {
 293         /* copy any name assignments from rule into pol, appending
 294          * -part to any domain.  The string with -part appended is
 295          * stored with the rule so it has a lifetime to match
 296          * the rule.
 297          */
 298         struct rule *r;
 299         char *metadata = NULL;
 300         for (r = rule; r ; r = r->next)
 301                 if (r->name == pol_metadata)
 302                         metadata = r->value;
 303
 304         for (r = rule; r ; r = r->next) {
 305                 if (r->name == pol_act)
 306                         pol_new(pol, r->name, r->value, metadata);
 307                 else if (r->name == pol_domain) {
 308                         char *dom;
 309                         int len;
 310                         if (r->dups == NULL)
 311                                 r->dups = dl_head();
 312                         len = strlen(r->value);
 313                         for (dom = dl_next(r->dups); dom != r->dups;
 314                              dom = dl_next(dom))
 315                                 if (strcmp(dom+len+1, part)== 0)
 316                                         break;
 317                         if (dom == r->dups) {
 318                                 char *newdom = dl_strndup(
 319                                         r->value, len + 1 + strlen(part));
 320                                 strcat(strcat(newdom, "-"), part);
 321                                 dl_add(r->dups, newdom);
 322                                 dom = newdom;
 323                         }
 324                         pol_new(pol, r->name, dom, metadata);
 325                 }
 326         }
 327 }
 328
 329 static struct pol_rule *config_rules = NULL;
 330 static struct pol_rule **config_rules_end = NULL;
 331 static int config_rules_has_path = 0;
 332
 333 /*
 334  * most policy comes from a set policy rules that are
 335  * read from the config file.
 336  * path_policy() gathers policy information for the
 337  * disk described in the given a 'path' and a 'type'.
 338  */
 339 struct dev_policy *path_policy(char *path, char *type)
 340 {
 341         struct pol_rule *rules;
 342         struct dev_policy *pol = NULL;
 343
 344         if (!type)
 345                 return NULL;
 346
 347         rules = config_rules;
 348
 349         while (rules) {
 350                 char *part;
 351                 if (rules->type == rule_policy)
 352                         if (pol_match(rules->rule, path, type))
 353                                 pol_merge(&pol, rules->rule);
 354                 if (rules->type == rule_part && strcmp(type, type_part) == 0)
 355                         if (path_has_part(path, &part)) {
 356                                 *part = 0;
 357                                 if (pol_match(rules->rule, path, type_disk))
 358                                         pol_merge_part(&pol, rules->rule, part+1);
 359                                 *part = '-';
 360                         }
 361                 rules = rules->next;
 362         }
 363         pol_sort(&pol);
 364         pol_dedup(pol);
 365         return pol;
 366 }
 367
 368 /*
 369  * disk_policy() gathers policy information for the
 370  * disk described in the given mdinfo (disk.{major,minor}).
 371  */
 372 struct dev_policy *disk_policy(struct mdinfo *disk)
 373 {
 374         char *path = NULL;
 375         char *type = disk_type(disk);
 376         struct dev_policy *pol = NULL;
 377
 378         if (!type)
 379                 return NULL;
 380         if (config_rules_has_path)
 381                 path = disk_path(disk);
 382         if (!path)
 383                 return NULL;
 384
 385         pol = path_policy(path, type);
 386
 387         free(path);
 388         return pol;
 389 }
 390
 391 struct dev_policy *devnum_policy(int dev)
 392 {
 393         struct mdinfo disk;
 394         disk.disk.major = major(dev);
 395         disk.disk.minor = minor(dev);
 396         return disk_policy(&disk);
 397 }
 398
 399 /*
 400  * process policy rules read from config file.
 401  */
 402
 403 char rule_path[] = "path";
 404 char rule_type[] = "type";
 405
 406 char rule_policy[] = "policy";
 407 char rule_part[] = "part-policy";
 408
 409 char pol_metadata[] = "metadata";
 410 char pol_act[] = "action";
 411 char pol_domain[] = "domain";
 412 char pol_auto[] = "auto";
 413
 414 static int try_rule(char *w, char *name, struct rule **rp)
 415 {
 416         struct rule *r;
 417         int len = strlen(name);
 418         if (strncmp(w, name, len) != 0 ||
 419             w[len] != '=')
 420                 return 0;
 421         r = malloc(sizeof(*r));
 422         r->next = *rp;
 423         r->name = name;
 424         r->value = strdup(w+len+1);
 425         r->dups = NULL;
 426         *rp = r;
 427         return 1;
 428 }
 429
 430 void policyline(char *line, char *type)
 431 {
 432         struct pol_rule *pr;
 433         char *w;
 434
 435         if (config_rules_end == NULL)
 436                 config_rules_end = &config_rules;
 437
 438         pr = malloc(sizeof(*pr));
 439         pr->type = type;
 440         pr->rule = NULL;
 441         for (w = dl_next(line); w != line ; w = dl_next(w)) {
 442                 if (try_rule(w, rule_path, &pr->rule))
 443                         config_rules_has_path = 1;
 444                 else if (! try_rule(w, rule_type, &pr->rule) &&
 445                          ! try_rule(w, pol_metadata, &pr->rule) &&
 446                          ! try_rule(w, pol_act, &pr->rule) &&
 447                          ! try_rule(w, pol_domain, &pr->rule) &&
 448                          ! try_rule(w, pol_auto, &pr->rule))
 449                         fprintf(stderr, Name ": policy rule %s unrecognised and ignored\n",
 450                                 w);
 451         }
 452         pr->next = config_rules;
 453         config_rules = pr;
 454 }
 455
 456 void policy_add(char *type, ...)
 457 {
 458         va_list ap;
 459         struct pol_rule *pr;
 460         char *name, *val;
 461
 462         pr = malloc(sizeof(*pr));
 463         pr->type = type;
 464         pr->rule = NULL;
 465
 466         va_start(ap, type);
 467         while ((name = va_arg(ap, char*)) != NULL) {
 468                 struct rule *r;
 469
 470                 val = va_arg(ap, char*);
 471                 r = malloc(sizeof(*r));
 472                 r->next = pr->rule;
 473                 r->name = name;
 474                 r->value = strdup(val);
 475                 r->dups = NULL;
 476                 pr->rule = r;
 477         }
 478         pr->next = config_rules;
 479         config_rules = pr;
 480 }
 481
 482 void policy_free(void)
 483 {
 484         while (config_rules) {
 485                 struct pol_rule *pr = config_rules;
 486                 struct rule *r;
 487
 488                 config_rules = config_rules->next;
 489
 490                 for (r = pr->rule; r; ) {
 491                         struct rule *next = r->next;
 492                         free(r->value);
 493                         if (r->dups)
 494                                 free_line(r->dups);
 495                         free(r);
 496                         r = next;
 497                 }
 498                 free(pr);
 499         }
 500         config_rules_end = NULL;
 501         config_rules_has_path = 0;
 502 }
 503
 504 void dev_policy_free(struct dev_policy *p)
 505 {
 506         struct dev_policy *t;
 507         while (p) {
 508                 t = p;
 509                 p = p->next;
 510                 free(t);
 511         }
 512 }
 513
 514 static enum policy_action map_act(char *act)
 515 {
 516         if (strcmp(act, "include") == 0)
 517                 return act_include;
 518         if (strcmp(act, "re-add") == 0)
 519                 return act_re_add;
 520         if (strcmp(act, "spare") == 0)
 521                 return act_spare;
 522         if (strcmp(act, "spare-same-slot") == 0)
 523                 return act_spare_same_slot;
 524         if (strcmp(act, "force-spare") == 0)
 525                 return act_force_spare;
 526         return act_err;
 527 }
 528
 529 static enum policy_action policy_action(struct dev_policy *plist, const char *metadata)
 530 {
 531         enum policy_action rv = act_default;
 532         struct dev_policy *p;
 533
 534         plist = pol_find(plist, pol_act);
 535         pol_for_each(p, plist, metadata) {
 536                 enum policy_action a = map_act(p->value);
 537                 if (a > rv)
 538                         rv = a;
 539         }
 540         return rv;
 541 }
 542
 543 int policy_action_allows(struct dev_policy *plist, const char *metadata, enum policy_action want)
 544 {
 545         enum policy_action act = policy_action(plist, metadata);
 546
 547         if (act == act_err)
 548                 return 0;
 549         return (act >= want);
 550 }
 551
 552 int disk_action_allows(struct mdinfo *disk, const char *metadata, enum policy_action want)
 553 {
 554         struct dev_policy *pol = disk_policy(disk);
 555         int rv = policy_action_allows(pol, metadata, want);
 556
 557         dev_policy_free(pol);
 558         return rv;
 559 }
 560
 561
 562 /* Domain policy:
 563  * Any device can have a list of domains asserted by different policy
 564  * statements.
 565  * An array also has a list of domains comprising all the domains of
 566  * all the devices in an array.
 567  * Where an array has a spare-group, that becomes an addition domain for
 568  * every device in the array and thus for the array.
 569  *
 570  * We keep the list of domains in a sorted linked list
 571  * As dev policies are already sorted, this is fairly easy to manage.
 572  */
 573
 574 static struct domainlist **domain_merge_one(struct domainlist **domp, char *domain)
 575 {
 576         /* merge a domain name into a sorted list and return the
 577          * location of the insertion or match
 578          */
 579         struct domainlist *dom = *domp;
 580
 581         while (dom && strcmp(dom->dom, domain) < 0) {
 582                 domp = &dom->next;
 583                 dom = *domp;
 584         }
 585         if (dom == NULL || strcmp(dom->dom, domain) != 0) {
 586                 dom = malloc(sizeof(*dom));
 587                 dom->next = *domp;
 588                 dom->dom = domain;
 589                 *domp = dom;
 590         }
 591         return domp;
 592 }
 593
 594 void domain_merge(struct domainlist **domp, struct dev_policy *pollist,
 595                          const char *metadata)
 596 {
 597         /* Add to 'domp' all the domains in pol that apply to 'metadata'
 598          * which are not already in domp
 599          */
 600         struct dev_policy *pol;
 601         pollist = pol_find(pollist, pol_domain);
 602         pol_for_each(pol, pollist, metadata)
 603                 domp = domain_merge_one(domp, pol->value);
 604 }
 605
 606 int domain_test(struct domainlist *dom, struct dev_policy *pol,
 607                 const char *metadata)
 608 {
 609         /* Check that all domains in pol (for metadata) are also in
 610          * dom.  Both lists are sorted.
 611          * If pol has no domains, we don't really know about this device
 612          * so we reject the match.
 613          */
 614         int found_any = 0;
 615         struct dev_policy *p;
 616
 617         pol = pol_find(pol, pol_domain);
 618         pol_for_each(p, pol, metadata) {
 619                 found_any = 1;
 620                 while (dom && strcmp(dom->dom, p->value) < 0)
 621                         dom = dom->next;
 622                 if (!dom || strcmp(dom->dom, p->value) != 0)
 623                         return 0;
 624         }
 625         return found_any;
 626 }
 627
 628 struct domainlist *domain_from_array(struct mdinfo *mdi, const char *metadata)
 629 {
 630         struct domainlist *domlist = NULL;
 631
 632         for (mdi = mdi->devs ; mdi ; mdi = mdi->next) {
 633                 struct dev_policy *pol = disk_policy(mdi);
 634
 635                 domain_merge(&domlist, pol, metadata);
 636                 dev_policy_free(pol);
 637         }
 638         return domlist;
 639 }
 640
 641 void domain_free(struct domainlist *dl)
 642 {
 643         while (dl) {
 644                 struct domainlist *head = dl;
 645                 dl = dl->next;
 646                 free(head);
 647         }
 648 }
 649
 650 /*
 651  * same-path policy.
 652  * Some policy decisions are guided by knowledge of which
 653  * array previously owned the device at a given physical location (path).
 654  * When removing a device from an array we might record the array against
 655  * the path, and when finding a new device, we might look for which
 656  * array previously used that path.
 657  *
 658  * The 'array' is described by a map_ent, and the path by a the disk in an
 659  * mdinfo, or a string.
 660  */
 661
 662 void policy_save_path(char *id_path, struct map_ent *array)
 663 {
 664         char path[PATH_MAX];
 665         FILE *f = NULL;
 666
 667         if (mkdir(FAILED_SLOTS_DIR, S_IRWXU) < 0 && errno != EEXIST) {
 668                 fprintf(stderr, Name ": can't create file to save path "
 669                         "to old disk: %s\n", strerror(errno));
 670                 return;
 671         }
 672
 673         snprintf(path, PATH_MAX, FAILED_SLOTS_DIR "/%s", id_path);
 674         f = fopen(path, "w");
 675         if (!f) {
 676                 fprintf(stderr, Name ": can't create file to"
 677                         " save path to old disk: %s\n",
 678                         strerror(errno));
 679                 return;
 680         }
 681
 682         if (fprintf(f, "%s %08x:%08x:%08x:%08x\n",
 683                     array->metadata,
 684                     array->uuid[0], array->uuid[1],
 685                     array->uuid[2], array->uuid[3]) <= 0)
 686                 fprintf(stderr, Name ": Failed to write to "
 687                         "<id_path> cookie\n");
 688
 689         fclose(f);
 690 }
 691
 692 int policy_check_path(struct mdinfo *disk, struct map_ent *array)
 693 {
 694         char path[PATH_MAX];
 695         FILE *f = NULL;
 696         char *id_path = disk_path(disk);
 697         int rv;
 698
 699         if (!id_path)
 700                 return 0;
 701
 702         snprintf(path, PATH_MAX, FAILED_SLOTS_DIR "/%s", id_path);
 703         f = fopen(path, "r");
 704         if (!f)
 705                 return 0;
 706
 707         rv = fscanf(f, " %s %x:%x:%x:%x\n",
 708                     array->metadata,
 709                     array->uuid,
 710                     array->uuid+1,
 711                     array->uuid+2,
 712                     array->uuid+3);
 713         fclose(f);
 714         return rv == 5;
 715 }