Add alias_prefix to get multipath names based on storage type
[multipath-tools/.git] / libmultipath / config.c
1 /*
2  * Copyright (c) 2004, 2005 Christophe Varoqui
3  * Copyright (c) 2005 Benjamin Marzinski, Redhat
4  * Copyright (c) 2005 Edward Goggin, EMC
5  */
6 #include <stdio.h>
7 #include <string.h>
8
9 #include "checkers.h"
10 #include "memory.h"
11 #include "util.h"
12 #include "debug.h"
13 #include "parser.h"
14 #include "dict.h"
15 #include "hwtable.h"
16 #include "vector.h"
17 #include "structs.h"
18 #include "config.h"
19 #include "blacklist.h"
20 #include "defaults.h"
21 #include "prio.h"
22
23 static int
24 hwe_strmatch (struct hwentry *hwe1, struct hwentry *hwe2)
25 {
26         if (hwe1->vendor && hwe2->vendor && strcmp(hwe1->vendor, hwe2->vendor))
27                 return 1;
28
29         if (hwe1->product && hwe2->product && strcmp(hwe1->product, hwe2->product))
30                 return 1;
31
32         if (hwe1->revision && hwe2->revision && strcmp(hwe1->revision, hwe2->revision))
33                 return 1;
34
35         return 0;
36 }
37
38 static struct hwentry *
39 find_hwe_strmatch (vector hwtable, struct hwentry *hwe)
40 {
41         int i;
42         struct hwentry *tmp, *ret = NULL;
43
44         vector_foreach_slot (hwtable, tmp, i) {
45                 if (hwe_strmatch(tmp, hwe))
46                         continue;
47                 ret = tmp;
48                 break;
49         }
50         return ret;
51 }
52
53 struct hwentry *
54 find_hwe (vector hwtable, char * vendor, char * product, char * revision)
55 {
56         int i;
57         struct hwentry *hwe, *ret = NULL;
58         regex_t vre, pre, rre;
59
60         vector_foreach_slot (hwtable, hwe, i) {
61                 if (hwe->vendor &&
62                     regcomp(&vre, hwe->vendor, REG_EXTENDED|REG_NOSUB))
63                         break;
64                 if (hwe->product &&
65                     regcomp(&pre, hwe->product, REG_EXTENDED|REG_NOSUB)) {
66                         regfree(&vre);
67                         break;
68                 }
69                 if (hwe->revision &&
70                     regcomp(&rre, hwe->revision, REG_EXTENDED|REG_NOSUB)) {
71                         regfree(&vre);
72                         regfree(&pre);
73                         break;
74                 }
75                 if ((!hwe->vendor || !regexec(&vre, vendor, 0, NULL, 0)) &&
76                     (!hwe->product || !regexec(&pre, product, 0, NULL, 0)) &&
77                     (!hwe->revision || !regexec(&rre, revision, 0, NULL, 0)))
78                         ret = hwe;
79
80                 if (hwe->revision)
81                         regfree(&rre);
82                 if (hwe->product)
83                         regfree(&pre);
84                 if (hwe->vendor)
85                         regfree(&vre);
86
87                 if (ret)
88                         break;
89         }
90         return ret;
91 }
92
93 extern struct mpentry *
94 find_mpe (char * wwid)
95 {
96         int i;
97         struct mpentry * mpe;
98
99         if (!wwid)
100                 return NULL;
101
102         vector_foreach_slot (conf->mptable, mpe, i)
103                 if (mpe->wwid && !strcmp(mpe->wwid, wwid))
104                         return mpe;
105
106         return NULL;
107 }
108
109 extern char *
110 get_mpe_wwid (char * alias)
111 {
112         int i;
113         struct mpentry * mpe;
114
115         if (!alias)
116                 return NULL;
117
118         vector_foreach_slot (conf->mptable, mpe, i)
119                 if (mpe->alias && strcmp(mpe->alias, alias) == 0)
120                         return mpe->wwid;
121
122         return NULL;
123 }
124
125 void
126 free_hwe (struct hwentry * hwe)
127 {
128         if (!hwe)
129                 return;
130
131         if (hwe->vendor)
132                 FREE(hwe->vendor);
133
134         if (hwe->product)
135                 FREE(hwe->product);
136
137         if (hwe->revision)
138                 FREE(hwe->revision);
139
140         if (hwe->getuid)
141                 FREE(hwe->getuid);
142
143         if (hwe->features)
144                 FREE(hwe->features);
145
146         if (hwe->hwhandler)
147                 FREE(hwe->hwhandler);
148
149         if (hwe->selector)
150                 FREE(hwe->selector);
151
152         if (hwe->checker_name)
153                 FREE(hwe->checker_name);
154
155         if (hwe->prio_name)
156                 FREE(hwe->prio_name);
157
158         if (hwe->prio_args)
159                 FREE(hwe->prio_args);
160
161         if (hwe->alias_prefix)
162                 FREE(hwe->alias_prefix);
163
164         if (hwe->bl_product)
165                 FREE(hwe->bl_product);
166
167         FREE(hwe);
168 }
169
170 void
171 free_hwtable (vector hwtable)
172 {
173         int i;
174         struct hwentry * hwe;
175
176         if (!hwtable)
177                 return;
178
179         vector_foreach_slot (hwtable, hwe, i)
180                 free_hwe(hwe);
181
182         vector_free(hwtable);
183 }
184
185 void
186 free_mpe (struct mpentry * mpe)
187 {
188         if (!mpe)
189                 return;
190
191         if (mpe->wwid)
192                 FREE(mpe->wwid);
193
194         if (mpe->selector)
195                 FREE(mpe->selector);
196
197         if (mpe->getuid)
198                 FREE(mpe->getuid);
199
200         if (mpe->alias)
201                 FREE(mpe->alias);
202
203         FREE(mpe);
204 }
205
206 void
207 free_mptable (vector mptable)
208 {
209         int i;
210         struct mpentry * mpe;
211
212         if (!mptable)
213                 return;
214
215         vector_foreach_slot (mptable, mpe, i)
216                 free_mpe(mpe);
217
218         vector_free(mptable);
219 }
220
221 struct mpentry *
222 alloc_mpe (void)
223 {
224         struct mpentry * mpe = (struct mpentry *)
225                                 MALLOC(sizeof(struct mpentry));
226
227         return mpe;
228 }
229
230 struct hwentry *
231 alloc_hwe (void)
232 {
233         struct hwentry * hwe = (struct hwentry *)
234                                 MALLOC(sizeof(struct hwentry));
235
236         return hwe;
237 }
238
239 static char *
240 set_param_str(char * str)
241 {
242         char * dst;
243         int len;
244
245         if (!str)
246                 return NULL;
247
248         len = strlen(str);
249
250         if (!len)
251                 return NULL;
252
253         dst = (char *)MALLOC(len + 1);
254
255         if (!dst)
256                 return NULL;
257
258         strcpy(dst, str);
259         return dst;
260 }
261
262 #define merge_str(s) \
263         if (hwe2->s) { \
264                 if (hwe1->s) \
265                         FREE(hwe1->s); \
266                 if (!(hwe1->s = set_param_str(hwe2->s))) \
267                         return 1; \
268         }
269
270 #define merge_num(s) \
271         if (hwe2->s) \
272                 hwe1->s = hwe2->s
273
274
275 static int
276 merge_hwe (struct hwentry * hwe1, struct hwentry * hwe2)
277 {
278         merge_str(vendor);
279         merge_str(product);
280         merge_str(revision);
281         merge_str(getuid);
282         merge_str(features);
283         merge_str(hwhandler);
284         merge_str(selector);
285         merge_str(checker_name);
286         merge_str(prio_name);
287         merge_str(prio_args);
288         merge_str(alias_prefix);
289         merge_str(bl_product);
290         merge_num(pgpolicy);
291         merge_num(pgfailback);
292         merge_num(rr_weight);
293         merge_num(no_path_retry);
294         merge_num(minio);
295
296         return 0;
297 }
298
299 int
300 store_hwe (vector hwtable, struct hwentry * dhwe)
301 {
302         struct hwentry * hwe;
303
304         if (find_hwe_strmatch(hwtable, dhwe))
305                 return 0;
306
307         if (!(hwe = alloc_hwe()))
308                 return 1;
309
310         if (!dhwe->vendor || !(hwe->vendor = set_param_str(dhwe->vendor)))
311                 goto out;
312
313         if (!dhwe->product || !(hwe->product = set_param_str(dhwe->product)))
314                 goto out;
315
316         if (dhwe->revision && !(hwe->revision = set_param_str(dhwe->revision)))
317                 goto out;
318
319         if (dhwe->getuid && !(hwe->getuid = set_param_str(dhwe->getuid)))
320                 goto out;
321
322         if (dhwe->features && !(hwe->features = set_param_str(dhwe->features)))
323                 goto out;
324
325         if (dhwe->hwhandler && !(hwe->hwhandler = set_param_str(dhwe->hwhandler)))
326                 goto out;
327
328         if (dhwe->selector && !(hwe->selector = set_param_str(dhwe->selector)))
329                 goto out;
330
331         if (dhwe->checker_name && !(hwe->checker_name = set_param_str(dhwe->checker_name)))
332                 goto out;
333
334         if (dhwe->prio_name && !(hwe->prio_name = set_param_str(dhwe->prio_name)))
335                 goto out;
336
337         if (dhwe->prio_args && !(hwe->prio_args = set_param_str(dhwe->prio_args)))
338                 goto out;
339
340         if (dhwe->alias_prefix && !(hwe->alias_prefix = set_param_str(dhwe->alias_prefix)))
341                 goto out;
342
343         hwe->pgpolicy = dhwe->pgpolicy;
344         hwe->pgfailback = dhwe->pgfailback;
345         hwe->rr_weight = dhwe->rr_weight;
346         hwe->no_path_retry = dhwe->no_path_retry;
347         hwe->minio = dhwe->minio;
348
349         if (dhwe->bl_product && !(hwe->bl_product = set_param_str(dhwe->bl_product)))
350                 goto out;
351
352         if (!vector_alloc_slot(hwtable))
353                 goto out;
354
355         vector_set_slot(hwtable, hwe);
356         return 0;
357 out:
358         free_hwe(hwe);
359         return 1;
360 }
361
362 static int
363 factorize_hwtable (vector hw)
364 {
365         struct hwentry *hwe1, *hwe2;
366         int i, j;
367
368         vector_foreach_slot(hw, hwe1, i) {
369                 j = i+1;
370                 vector_foreach_slot_after(hw, hwe2, j) {
371                         if (hwe_strmatch(hwe1, hwe2))
372                                 continue;
373                         /* dup */
374                         merge_hwe(hwe1, hwe2);
375                         free_hwe(hwe2);
376                         vector_del_slot(hw, j);
377                         j--;
378                 }
379         }
380         return 0;
381 }
382
383 struct config *
384 alloc_config (void)
385 {
386         return (struct config *)MALLOC(sizeof(struct config));
387 }
388
389 void
390 free_config (struct config * conf)
391 {
392         if (!conf)
393                 return;
394
395         if (conf->dev)
396                 FREE(conf->dev);
397
398         if (conf->udev_dir)
399                 FREE(conf->udev_dir);
400
401         if (conf->multipath_dir)
402                 FREE(conf->multipath_dir);
403
404         if (conf->selector)
405                 FREE(conf->selector);
406
407         if (conf->getuid)
408                 FREE(conf->getuid);
409
410         if (conf->features)
411                 FREE(conf->features);
412
413         if (conf->hwhandler)
414                 FREE(conf->hwhandler);
415
416         if (conf->prio_name)
417                 FREE(conf->prio_name);
418
419         if (conf->alias_prefix)
420                 FREE(conf->alias_prefix);
421
422         if (conf->prio_args)
423                 FREE(conf->prio_args);
424
425         if (conf->checker_name)
426                 FREE(conf->checker_name);
427
428         free_blacklist(conf->blist_devnode);
429         free_blacklist(conf->blist_wwid);
430         free_blacklist_device(conf->blist_device);
431
432         free_blacklist(conf->elist_devnode);
433         free_blacklist(conf->elist_wwid);
434         free_blacklist_device(conf->elist_device);
435
436         free_mptable(conf->mptable);
437         free_hwtable(conf->hwtable);
438         free_keywords(conf->keywords);
439         FREE(conf);
440 }
441
442 int
443 load_config (char * file)
444 {
445         if (!conf)
446                 conf = alloc_config();
447
448         if (!conf)
449                 return 1;
450
451         /*
452          * internal defaults
453          */
454         if (!conf->verbosity)
455                 conf->verbosity = DEFAULT_VERBOSITY;
456
457         conf->dev_type = DEV_NONE;
458         conf->minio = 1000;
459         conf->max_fds = 0;
460         conf->bindings_file = DEFAULT_BINDINGS_FILE;
461         conf->multipath_dir = set_default(DEFAULT_MULTIPATHDIR);
462         conf->flush_on_last_del = 0;
463         conf->attribute_flags = 0;
464
465         /*
466          * preload default hwtable
467          */
468         if (conf->hwtable == NULL) {
469                 conf->hwtable = vector_alloc();
470
471                 if (!conf->hwtable)
472                         goto out;
473         }
474         if (setup_default_hwtable(conf->hwtable))
475                 goto out;
476
477         /*
478          * read the config file
479          */
480         if (filepresent(file)) {
481                 set_current_keywords(&conf->keywords);
482                 if (init_data(file, init_keywords)) {
483                         condlog(0, "error parsing config file");
484                         goto out;
485                 }
486         }
487
488         /*
489          * remove duplica in hwtable. config file takes precedence
490          * over build-in hwtable
491          */
492         factorize_hwtable(conf->hwtable);
493
494         /*
495          * fill the voids left in the config file
496          */
497         if (conf->blist_devnode == NULL) {
498                 conf->blist_devnode = vector_alloc();
499
500                 if (!conf->blist_devnode)
501                         goto out;
502         }
503         if (conf->blist_wwid == NULL) {
504                 conf->blist_wwid = vector_alloc();
505
506                 if (!conf->blist_wwid)
507                         goto out;
508         }
509         if (conf->blist_device == NULL) {
510                 conf->blist_device = vector_alloc();
511
512                 if (!conf->blist_device)
513                         goto out;
514         }
515         if (setup_default_blist(conf))
516                 goto out;
517
518         if (conf->elist_devnode == NULL) {
519                 conf->elist_devnode = vector_alloc();
520
521                 if (!conf->elist_devnode)
522                         goto out;
523         }
524         if (conf->elist_wwid == NULL) {
525                 conf->elist_wwid = vector_alloc();
526
527                 if (!conf->elist_wwid)
528                         goto out;
529         }
530
531         if (conf->elist_device == NULL) {
532                 conf->elist_device = vector_alloc();
533
534                 if (!conf->elist_device)
535                         goto out;
536         }
537
538         if (conf->mptable == NULL) {
539                 conf->mptable = vector_alloc();
540                 if (!conf->mptable)
541                         goto out;
542         }
543         if (conf->udev_dir == NULL)
544                 conf->udev_dir = set_default(DEFAULT_UDEVDIR);
545
546         if (!conf->udev_dir || !conf->multipath_dir)
547                 goto out;
548
549         return 0;
550 out:
551         free_config(conf);
552         return 1;
553 }
554