]> git.ipfire.org Git - thirdparty/mdadm.git/blob - policy.c
Assemble(): don't dup_super() before we need it.
[thirdparty/mdadm.git] / 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 = malloc(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 fprintf(stderr, Name ": 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_path(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 nm[PATH_MAX];
199 struct dirent *ent;
200 int rv;
201
202 by_path = opendir(symlink);
203 if (!by_path)
204 return NULL;
205 prefix_len = strlen(symlink);
206
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 closedir(by_path);
220 return strdup(ent->d_name);
221 }
222 closedir(by_path);
223 /* A NULL path isn't really acceptable - use the devname.. */
224 sprintf(symlink, "/sys/dev/block/%d:%d", disk->disk.major, disk->disk.minor);
225 rv = readlink(symlink, nm, sizeof(nm)-1);
226 if (rv > 0) {
227 char *dname;
228 nm[rv] = 0;
229 dname = strrchr(nm, '/');
230 if (dname)
231 return strdup(dname + 1);
232 }
233 return strdup("unknown");
234 }
235
236 char type_part[] = "part";
237 char type_disk[] = "disk";
238 static char *disk_type(struct mdinfo *disk)
239 {
240 char buf[30+20+20];
241 struct stat stb;
242 sprintf(buf, "/sys/dev/block/%d:%d/partition",
243 disk->disk.major, disk->disk.minor);
244 if (stat(buf, &stb) == 0)
245 return type_part;
246 else
247 return type_disk;
248 }
249
250 static int pol_match(struct rule *rule, char *path, char *type)
251 {
252 /* check if this rule matches on path and type */
253 int pathok = 0; /* 0 == no path, 1 == match, -1 == no match yet */
254 int typeok = 0;
255
256 while (rule) {
257 if (rule->name == rule_path) {
258 if (pathok == 0)
259 pathok = -1;
260 if (path && fnmatch(rule->value, path, 0) == 0)
261 pathok = 1;
262 }
263 if (rule->name == rule_type) {
264 if (typeok == 0)
265 typeok = -1;
266 if (type && strcmp(rule->value, type) == 0)
267 typeok = 1;
268 }
269 rule = rule->next;
270 }
271 return pathok >= 0 && typeok >= 0;
272 }
273
274 static void pol_merge(struct dev_policy **pol, struct rule *rule)
275 {
276 /* copy any name assignments from rule into pol */
277 struct rule *r;
278 char *metadata = NULL;
279 for (r = rule; r ; r = r->next)
280 if (r->name == pol_metadata)
281 metadata = r->value;
282
283 for (r = rule; r ; r = r->next)
284 if (r->name == pol_act ||
285 r->name == pol_domain ||
286 r->name == pol_auto)
287 pol_new(pol, r->name, r->value, metadata);
288 }
289
290 static int path_has_part(char *path, char **part)
291 {
292 /* check if path ends with "-partNN" and
293 * if it does, place a pointer to "-pathNN"
294 * in 'part'.
295 */
296 int l;
297 if (!path)
298 return 0;
299 l = strlen(path);
300 while (l > 1 && isdigit(path[l-1]))
301 l--;
302 if (l < 5 || strncmp(path+l-5, "-part", 5) != 0)
303 return 0;
304 *part = path+l-4;
305 return 1;
306 }
307
308 static void pol_merge_part(struct dev_policy **pol, struct rule *rule, char *part)
309 {
310 /* copy any name assignments from rule into pol, appending
311 * -part to any domain. The string with -part appended is
312 * stored with the rule so it has a lifetime to match
313 * the rule.
314 */
315 struct rule *r;
316 char *metadata = NULL;
317 for (r = rule; r ; r = r->next)
318 if (r->name == pol_metadata)
319 metadata = r->value;
320
321 for (r = rule; r ; r = r->next) {
322 if (r->name == pol_act)
323 pol_new(pol, r->name, r->value, metadata);
324 else if (r->name == pol_domain) {
325 char *dom;
326 int len;
327 if (r->dups == NULL)
328 r->dups = dl_head();
329 len = strlen(r->value);
330 for (dom = dl_next(r->dups); dom != r->dups;
331 dom = dl_next(dom))
332 if (strcmp(dom+len+1, part)== 0)
333 break;
334 if (dom == r->dups) {
335 char *newdom = dl_strndup(
336 r->value, len + 1 + strlen(part));
337 strcat(strcat(newdom, "-"), part);
338 dl_add(r->dups, newdom);
339 dom = newdom;
340 }
341 pol_new(pol, r->name, dom, metadata);
342 }
343 }
344 }
345
346 static struct pol_rule *config_rules = NULL;
347 static struct pol_rule **config_rules_end = NULL;
348 static int config_rules_has_path = 0;
349
350 /*
351 * most policy comes from a set policy rules that are
352 * read from the config file.
353 * path_policy() gathers policy information for the
354 * disk described in the given a 'path' and a 'type'.
355 */
356 struct dev_policy *path_policy(char *path, char *type)
357 {
358 struct pol_rule *rules;
359 struct dev_policy *pol = NULL;
360 int i;
361
362 rules = config_rules;
363
364 while (rules) {
365 char *part;
366 if (rules->type == rule_policy)
367 if (pol_match(rules->rule, path, type))
368 pol_merge(&pol, rules->rule);
369 if (rules->type == rule_part && strcmp(type, type_part) == 0)
370 if (path_has_part(path, &part)) {
371 *part = 0;
372 if (pol_match(rules->rule, path, type_disk))
373 pol_merge_part(&pol, rules->rule, part+1);
374 *part = '-';
375 }
376 rules = rules->next;
377 }
378
379 /* Now add any metadata-specific internal knowledge
380 * about this path
381 */
382 for (i=0; path && superlist[i]; i++)
383 if (superlist[i]->get_disk_controller_domain) {
384 const char *d =
385 superlist[i]->get_disk_controller_domain(path);
386 if (d)
387 pol_new(&pol, pol_domain, d, superlist[i]->name);
388 }
389
390 pol_sort(&pol);
391 pol_dedup(pol);
392 return pol;
393 }
394
395 void pol_add(struct dev_policy **pol,
396 char *name, char *val,
397 char *metadata)
398 {
399 pol_new(pol, name, val, metadata);
400 pol_sort(pol);
401 pol_dedup(*pol);
402 }
403
404
405 /*
406 * disk_policy() gathers policy information for the
407 * disk described in the given mdinfo (disk.{major,minor}).
408 */
409 struct dev_policy *disk_policy(struct mdinfo *disk)
410 {
411 char *path = NULL;
412 char *type = disk_type(disk);
413 struct dev_policy *pol = NULL;
414
415 if (config_rules_has_path)
416 path = disk_path(disk);
417
418 pol = path_policy(path, type);
419
420 free(path);
421 return pol;
422 }
423
424 struct dev_policy *devnum_policy(int dev)
425 {
426 struct mdinfo disk;
427 disk.disk.major = major(dev);
428 disk.disk.minor = minor(dev);
429 return disk_policy(&disk);
430 }
431
432 /*
433 * process policy rules read from config file.
434 */
435
436 char rule_path[] = "path";
437 char rule_type[] = "type";
438
439 char rule_policy[] = "policy";
440 char rule_part[] = "part-policy";
441
442 char pol_metadata[] = "metadata";
443 char pol_act[] = "action";
444 char pol_domain[] = "domain";
445 char pol_auto[] = "auto";
446
447 static int try_rule(char *w, char *name, struct rule **rp)
448 {
449 struct rule *r;
450 int len = strlen(name);
451 if (strncmp(w, name, len) != 0 ||
452 w[len] != '=')
453 return 0;
454 r = malloc(sizeof(*r));
455 r->next = *rp;
456 r->name = name;
457 r->value = strdup(w+len+1);
458 r->dups = NULL;
459 *rp = r;
460 return 1;
461 }
462
463 void policyline(char *line, char *type)
464 {
465 struct pol_rule *pr;
466 char *w;
467
468 if (config_rules_end == NULL)
469 config_rules_end = &config_rules;
470
471 pr = malloc(sizeof(*pr));
472 pr->type = type;
473 pr->rule = NULL;
474 for (w = dl_next(line); w != line ; w = dl_next(w)) {
475 if (try_rule(w, rule_path, &pr->rule))
476 config_rules_has_path = 1;
477 else if (! try_rule(w, rule_type, &pr->rule) &&
478 ! try_rule(w, pol_metadata, &pr->rule) &&
479 ! try_rule(w, pol_act, &pr->rule) &&
480 ! try_rule(w, pol_domain, &pr->rule) &&
481 ! try_rule(w, pol_auto, &pr->rule))
482 fprintf(stderr, Name ": policy rule %s unrecognised and ignored\n",
483 w);
484 }
485 pr->next = config_rules;
486 config_rules = pr;
487 }
488
489 void policy_add(char *type, ...)
490 {
491 va_list ap;
492 struct pol_rule *pr;
493 char *name, *val;
494
495 pr = malloc(sizeof(*pr));
496 pr->type = type;
497 pr->rule = NULL;
498
499 va_start(ap, type);
500 while ((name = va_arg(ap, char*)) != NULL) {
501 struct rule *r;
502
503 val = va_arg(ap, char*);
504 r = malloc(sizeof(*r));
505 r->next = pr->rule;
506 r->name = name;
507 r->value = strdup(val);
508 r->dups = NULL;
509 pr->rule = r;
510 }
511 pr->next = config_rules;
512 config_rules = pr;
513 va_end(ap);
514 }
515
516 void policy_free(void)
517 {
518 while (config_rules) {
519 struct pol_rule *pr = config_rules;
520 struct rule *r;
521
522 config_rules = config_rules->next;
523
524 for (r = pr->rule; r; ) {
525 struct rule *next = r->next;
526 free(r->value);
527 if (r->dups)
528 free_line(r->dups);
529 free(r);
530 r = next;
531 }
532 free(pr);
533 }
534 config_rules_end = NULL;
535 config_rules_has_path = 0;
536 }
537
538 void dev_policy_free(struct dev_policy *p)
539 {
540 struct dev_policy *t;
541 while (p) {
542 t = p;
543 p = p->next;
544 free(t);
545 }
546 }
547
548 static enum policy_action map_act(const char *act)
549 {
550 if (strcmp(act, "include") == 0)
551 return act_include;
552 if (strcmp(act, "re-add") == 0)
553 return act_re_add;
554 if (strcmp(act, "spare") == 0)
555 return act_spare;
556 if (strcmp(act, "spare-same-slot") == 0)
557 return act_spare_same_slot;
558 if (strcmp(act, "force-spare") == 0)
559 return act_force_spare;
560 return act_err;
561 }
562
563 static enum policy_action policy_action(struct dev_policy *plist, const char *metadata)
564 {
565 enum policy_action rv = act_default;
566 struct dev_policy *p;
567
568 plist = pol_find(plist, pol_act);
569 pol_for_each(p, plist, metadata) {
570 enum policy_action a = map_act(p->value);
571 if (a > rv)
572 rv = a;
573 }
574 return rv;
575 }
576
577 int policy_action_allows(struct dev_policy *plist, const char *metadata, enum policy_action want)
578 {
579 enum policy_action act = policy_action(plist, metadata);
580
581 if (act == act_err)
582 return 0;
583 return (act >= want);
584 }
585
586 int disk_action_allows(struct mdinfo *disk, const char *metadata, enum policy_action want)
587 {
588 struct dev_policy *pol = disk_policy(disk);
589 int rv = policy_action_allows(pol, metadata, want);
590
591 dev_policy_free(pol);
592 return rv;
593 }
594
595
596 /* Domain policy:
597 * Any device can have a list of domains asserted by different policy
598 * statements.
599 * An array also has a list of domains comprising all the domains of
600 * all the devices in an array.
601 * Where an array has a spare-group, that becomes an addition domain for
602 * every device in the array and thus for the array.
603 *
604 * We keep the list of domains in a sorted linked list
605 * As dev policies are already sorted, this is fairly easy to manage.
606 */
607
608 static struct domainlist **domain_merge_one(struct domainlist **domp,
609 const char *domain)
610 {
611 /* merge a domain name into a sorted list and return the
612 * location of the insertion or match
613 */
614 struct domainlist *dom = *domp;
615
616 while (dom && strcmp(dom->dom, domain) < 0) {
617 domp = &dom->next;
618 dom = *domp;
619 }
620 if (dom == NULL || strcmp(dom->dom, domain) != 0) {
621 dom = malloc(sizeof(*dom));
622 dom->next = *domp;
623 dom->dom = domain;
624 *domp = dom;
625 }
626 return domp;
627 }
628
629 #if (DEBUG)
630 void dump_policy(struct dev_policy *policy)
631 {
632 while (policy) {
633 dprintf("policy: %p name: %s value: %s metadata: %s\n",
634 policy,
635 policy->name,
636 policy->value,
637 policy->metadata);
638 policy = policy->next;
639 }
640 }
641 #endif
642
643 void domain_merge(struct domainlist **domp, struct dev_policy *pollist,
644 const char *metadata)
645 {
646 /* Add to 'domp' all the domains in pol that apply to 'metadata'
647 * which are not already in domp
648 */
649 struct dev_policy *pol;
650 pollist = pol_find(pollist, pol_domain);
651 pol_for_each(pol, pollist, metadata)
652 domain_merge_one(domp, pol->value);
653 }
654
655 int domain_test(struct domainlist *dom, struct dev_policy *pol,
656 const char *metadata)
657 {
658 /* Check that all domains in pol (for metadata) are also in
659 * dom. Both lists are sorted.
660 * If pol has no domains, we don't really know about this device
661 * so we allow caller to choose:
662 * -1: has no domains
663 * 0: has domains, not all match
664 * 1: has domains, all match
665 */
666 int found_any = -1;
667 struct dev_policy *p;
668
669 pol = pol_find(pol, pol_domain);
670 pol_for_each(p, pol, metadata) {
671 found_any = 1;
672 while (dom && strcmp(dom->dom, p->value) < 0)
673 dom = dom->next;
674 if (!dom || strcmp(dom->dom, p->value) != 0)
675 return 0;
676 }
677 return found_any;
678 }
679
680 void domainlist_add_dev(struct domainlist **dom, int devnum, const char *metadata)
681 {
682 struct dev_policy *pol = devnum_policy(devnum);
683 domain_merge(dom, pol, metadata);
684 dev_policy_free(pol);
685 }
686
687 struct domainlist *domain_from_array(struct mdinfo *mdi, const char *metadata)
688 {
689 struct domainlist *domlist = NULL;
690
691 if (!mdi)
692 return NULL;
693 for (mdi = mdi->devs ; mdi ; mdi = mdi->next)
694 domainlist_add_dev(&domlist, makedev(mdi->disk.major,
695 mdi->disk.minor),
696 metadata);
697
698 return domlist;
699 }
700
701 void domain_add(struct domainlist **domp, char *domain)
702 {
703 domain_merge_one(domp, domain);
704 }
705
706
707 void domain_free(struct domainlist *dl)
708 {
709 while (dl) {
710 struct domainlist *head = dl;
711 dl = dl->next;
712 free(head);
713 }
714 }
715
716 /*
717 * same-path policy.
718 * Some policy decisions are guided by knowledge of which
719 * array previously owned the device at a given physical location (path).
720 * When removing a device from an array we might record the array against
721 * the path, and when finding a new device, we might look for which
722 * array previously used that path.
723 *
724 * The 'array' is described by a map_ent, and the path by a the disk in an
725 * mdinfo, or a string.
726 */
727
728 void policy_save_path(char *id_path, struct map_ent *array)
729 {
730 char path[PATH_MAX];
731 FILE *f = NULL;
732
733 if (mkdir(FAILED_SLOTS_DIR, S_IRWXU) < 0 && errno != EEXIST) {
734 fprintf(stderr, Name ": can't create file to save path "
735 "to old disk: %s\n", strerror(errno));
736 return;
737 }
738
739 snprintf(path, PATH_MAX, FAILED_SLOTS_DIR "/%s", id_path);
740 f = fopen(path, "w");
741 if (!f) {
742 fprintf(stderr, Name ": can't create file to"
743 " save path to old disk: %s\n",
744 strerror(errno));
745 return;
746 }
747
748 if (fprintf(f, "%s %08x:%08x:%08x:%08x\n",
749 array->metadata,
750 array->uuid[0], array->uuid[1],
751 array->uuid[2], array->uuid[3]) <= 0)
752 fprintf(stderr, Name ": Failed to write to "
753 "<id_path> cookie\n");
754
755 fclose(f);
756 }
757
758 int policy_check_path(struct mdinfo *disk, struct map_ent *array)
759 {
760 char path[PATH_MAX];
761 FILE *f = NULL;
762 char *id_path = disk_path(disk);
763 int rv;
764
765 if (!id_path)
766 return 0;
767
768 snprintf(path, PATH_MAX, FAILED_SLOTS_DIR "/%s", id_path);
769 f = fopen(path, "r");
770 if (!f) {
771 free(id_path);
772 return 0;
773 }
774
775 rv = fscanf(f, " %s %x:%x:%x:%x\n",
776 array->metadata,
777 array->uuid,
778 array->uuid+1,
779 array->uuid+2,
780 array->uuid+3);
781 fclose(f);
782 free(id_path);
783 return rv == 5;
784 }
785
786 /* invocation of udev rule file */
787 char udev_template_start[] =
788 "# do not edit this file, it is automatically generated by mdadm\n"
789 "\n";
790
791 /* find rule named rule_type and return its value */
792 char *find_rule(struct rule *rule, char *rule_type)
793 {
794 while (rule) {
795 if (rule->name == rule_type)
796 return rule->value;
797
798 rule = rule->next;
799 }
800 return NULL;
801 }
802
803 #define UDEV_RULE_FORMAT \
804 "ACTION==\"add\", SUBSYSTEM==\"block\", " \
805 "ENV{DEVTYPE}==\"%s\", ENV{ID_PATH}==\"%s\", " \
806 "RUN+=\"/sbin/mdadm --incremental $env{DEVNAME}\"\n"
807
808 #define UDEV_RULE_FORMAT_NOTYPE \
809 "ACTION==\"add\", SUBSYSTEM==\"block\", " \
810 "ENV{ID_PATH}==\"%s\", " \
811 "RUN+=\"/sbin/mdadm --incremental $env{DEVNAME}\"\n"
812
813 /* Write rule in the rule file. Use format from UDEV_RULE_FORMAT */
814 int write_rule(struct rule *rule, int fd, int force_part)
815 {
816 char line[1024];
817 char *pth = find_rule(rule, rule_path);
818 char *typ = find_rule(rule, rule_type);
819 if (!pth)
820 return -1;
821
822 if (force_part)
823 typ = type_part;
824 if (typ)
825 snprintf(line, sizeof(line) - 1, UDEV_RULE_FORMAT, typ, pth);
826 else
827 snprintf(line, sizeof(line) - 1, UDEV_RULE_FORMAT_NOTYPE, pth);
828 return write(fd, line, strlen(line)) == (int)strlen(line);
829 }
830
831 /* Generate single entry in udev rule basing on POLICY line found in config
832 * file. Take only those with paths, only first occurrence if paths are equal
833 * and if actions supports handling of spares (>=act_spare_same_slot)
834 */
835 int generate_entries(int fd)
836 {
837 struct pol_rule *loop, *dup;
838 char *loop_value, *dup_value;
839 int duplicate;
840
841 for (loop = config_rules; loop; loop = loop->next) {
842 if (loop->type != rule_policy && loop->type != rule_part)
843 continue;
844 duplicate = 0;
845
846 /* only policies with paths and with actions supporting
847 * bare disks are considered */
848 loop_value = find_rule(loop->rule, pol_act);
849 if (!loop_value || map_act(loop_value) < act_spare_same_slot)
850 continue;
851 loop_value = find_rule(loop->rule, rule_path);
852 if (!loop_value)
853 continue;
854 for (dup = config_rules; dup != loop; dup = dup->next) {
855 if (dup->type != rule_policy && loop->type != rule_part)
856 continue;
857 dup_value = find_rule(dup->rule, pol_act);
858 if (!dup_value || map_act(dup_value) < act_spare_same_slot)
859 continue;
860 dup_value = find_rule(dup->rule, rule_path);
861 if (!dup_value)
862 continue;
863 if (strcmp(loop_value, dup_value) == 0) {
864 duplicate = 1;
865 break;
866 }
867 }
868
869 /* not a dup or first occurrence */
870 if (!duplicate)
871 if (!write_rule(loop->rule, fd, loop->type == rule_part) )
872 return 0;
873 }
874 return 1;
875 }
876
877 /* Write_rules routine creates dynamic udev rules used to handle
878 * hot-plug events for bare devices (and making them spares)
879 */
880 int Write_rules(char *rule_name)
881 {
882 int fd;
883 char udev_rule_file[PATH_MAX];
884
885 if (rule_name) {
886 strncpy(udev_rule_file, rule_name, sizeof(udev_rule_file) - 6);
887 udev_rule_file[sizeof(udev_rule_file) - 6] = '\0';
888 strcat(udev_rule_file, ".temp");
889 fd = creat(udev_rule_file,
890 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
891 if (fd == -1)
892 return 1;
893 } else
894 fd = 1;
895
896 /* write static invocation */
897 if (write(fd, udev_template_start,
898 sizeof(udev_template_start) - 1)
899 != (int)sizeof(udev_template_start)-1)
900 goto abort;
901
902 /* iterate, if none created or error occurred, remove file */
903 if (generate_entries(fd) < 0)
904 goto abort;
905
906 fsync(fd);
907 if (rule_name) {
908 close(fd);
909 rename(udev_rule_file, rule_name);
910 }
911 return 0;
912 abort:
913 if (rule_name) {
914 close(fd);
915 unlink(udev_rule_file);
916 }
917 return 1;
918 }