[lib] don't pretend config file has setup parameters
[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->bl_product)
159                 FREE(hwe->bl_product);
160
161         FREE(hwe);
162 }
163
164 void
165 free_hwtable (vector hwtable)
166 {
167         int i;
168         struct hwentry * hwe;
169
170         if (!hwtable)
171                 return;
172
173         vector_foreach_slot (hwtable, hwe, i)
174                 free_hwe(hwe);
175
176         vector_free(hwtable);
177 }
178
179 void
180 free_mpe (struct mpentry * mpe)
181 {
182         if (!mpe)
183                 return;
184
185         if (mpe->wwid)
186                 FREE(mpe->wwid);
187
188         if (mpe->selector)
189                 FREE(mpe->selector);
190
191         if (mpe->getuid)
192                 FREE(mpe->getuid);
193
194         if (mpe->alias)
195                 FREE(mpe->alias);
196
197         FREE(mpe);
198 }
199
200 void
201 free_mptable (vector mptable)
202 {
203         int i;
204         struct mpentry * mpe;
205
206         if (!mptable)
207                 return;
208
209         vector_foreach_slot (mptable, mpe, i)
210                 free_mpe(mpe);
211
212         vector_free(mptable);
213 }
214
215 struct mpentry *
216 alloc_mpe (void)
217 {
218         struct mpentry * mpe = (struct mpentry *)
219                                 MALLOC(sizeof(struct mpentry));
220
221         return mpe;
222 }
223
224 struct hwentry *
225 alloc_hwe (void)
226 {
227         struct hwentry * hwe = (struct hwentry *)
228                                 MALLOC(sizeof(struct hwentry));
229
230         return hwe;
231 }
232
233 static char *
234 set_param_str(char * str)
235 {
236         char * dst;
237         int len;
238
239         if (!str)
240                 return NULL;
241
242         len = strlen(str);
243
244         if (!len)
245                 return NULL;
246
247         dst = (char *)MALLOC(len + 1);
248
249         if (!dst)
250                 return NULL;
251
252         strcpy(dst, str);
253         return dst;
254 }
255
256 #define merge_str(s) \
257         if (hwe2->s) { \
258                 if (hwe1->s) \
259                         FREE(hwe1->s); \
260                 if (!(hwe1->s = set_param_str(hwe2->s))) \
261                         return 1; \
262         }
263
264 #define merge_num(s) \
265         if (hwe2->s) \
266                 hwe1->s = hwe2->s
267
268
269 static int
270 merge_hwe (struct hwentry * hwe1, struct hwentry * hwe2)
271 {
272         merge_str(vendor);
273         merge_str(product);
274         merge_str(revision);
275         merge_str(getuid);
276         merge_str(features);
277         merge_str(hwhandler);
278         merge_str(selector);
279         merge_str(checker_name);
280         merge_str(prio_name);
281         merge_str(bl_product);
282         merge_num(pgpolicy);
283         merge_num(pgfailback);
284         merge_num(rr_weight);
285         merge_num(no_path_retry);
286         merge_num(minio);
287
288         return 0;
289 }
290
291 int
292 store_hwe (vector hwtable, struct hwentry * dhwe)
293 {
294         struct hwentry * hwe;
295
296         if (find_hwe_strmatch(hwtable, dhwe))
297                 return 0;
298
299         if (!(hwe = alloc_hwe()))
300                 return 1;
301
302         if (!dhwe->vendor || !(hwe->vendor = set_param_str(dhwe->vendor)))
303                 goto out;
304
305         if (!dhwe->product || !(hwe->product = set_param_str(dhwe->product)))
306                 goto out;
307
308         if (dhwe->revision && !(hwe->revision = set_param_str(dhwe->revision)))
309                 goto out;
310
311         if (dhwe->getuid && !(hwe->getuid = set_param_str(dhwe->getuid)))
312                 goto out;
313
314         if (dhwe->features && !(hwe->features = set_param_str(dhwe->features)))
315                 goto out;
316
317         if (dhwe->hwhandler && !(hwe->hwhandler = set_param_str(dhwe->hwhandler)))
318                 goto out;
319
320         if (dhwe->selector && !(hwe->selector = set_param_str(dhwe->selector)))
321                 goto out;
322
323         if (dhwe->checker_name && !(hwe->checker_name = set_param_str(dhwe->checker_name)))
324                 goto out;
325                                 
326         if (dhwe->prio_name && !(hwe->prio_name = set_param_str(dhwe->prio_name)))
327                 goto out;
328                                 
329         hwe->pgpolicy = dhwe->pgpolicy;
330         hwe->pgfailback = dhwe->pgfailback;
331         hwe->rr_weight = dhwe->rr_weight;
332         hwe->no_path_retry = dhwe->no_path_retry;
333         hwe->minio = dhwe->minio;
334
335         if (dhwe->bl_product && !(hwe->bl_product = set_param_str(dhwe->bl_product)))
336                 goto out;
337
338         if (!vector_alloc_slot(hwtable))
339                 goto out;
340
341         vector_set_slot(hwtable, hwe);
342         return 0;
343 out:
344         free_hwe(hwe);
345         return 1;
346 }
347
348 static int
349 factorize_hwtable (vector hw)
350 {
351         struct hwentry *hwe1, *hwe2;
352         int i, j;
353
354         vector_foreach_slot(hw, hwe1, i) {
355                 j = i+1;
356                 vector_foreach_slot_after(hw, hwe2, j) {
357                         if (hwe_strmatch(hwe1, hwe2))
358                                 continue;
359                         /* dup */
360                         merge_hwe(hwe1, hwe2);
361                         free_hwe(hwe2);
362                         vector_del_slot(hw, j);
363                         j--;
364                 }
365         }
366         return 0;
367 }
368
369 struct config *
370 alloc_config (void)
371 {
372         return (struct config *)MALLOC(sizeof(struct config));
373 }
374
375 void
376 free_config (struct config * conf)
377 {
378         if (!conf)
379                 return;
380
381         if (conf->dev)
382                 FREE(conf->dev);
383
384         if (conf->udev_dir)
385                 FREE(conf->udev_dir);
386
387         if (conf->multipath_dir)
388                 FREE(conf->multipath_dir);
389
390         if (conf->selector)
391                 FREE(conf->selector);
392
393         if (conf->getuid)
394                 FREE(conf->getuid);
395
396         if (conf->features)
397                 FREE(conf->features);
398
399         if (conf->hwhandler)
400                 FREE(conf->hwhandler);
401
402         if (conf->prio_name)
403                 FREE(conf->prio_name);
404
405         if (conf->checker_name)
406                 FREE(conf->checker_name);
407
408         free_blacklist(conf->blist_devnode);
409         free_blacklist(conf->blist_wwid);
410         free_blacklist_device(conf->blist_device);
411
412         free_blacklist(conf->elist_devnode);
413         free_blacklist(conf->elist_wwid);
414         free_blacklist_device(conf->elist_device);
415
416         free_mptable(conf->mptable);
417         free_hwtable(conf->hwtable);
418         free_keywords(conf->keywords);
419         FREE(conf);
420 }
421
422 int
423 load_config (char * file)
424 {
425         if (!conf)
426                 conf = alloc_config();
427
428         if (!conf)
429                 return 1;
430
431         /*
432          * internal defaults
433          */
434         if (!conf->verbosity)
435                 conf->verbosity = DEFAULT_VERBOSITY;
436
437         conf->dev_type = DEV_NONE;
438         conf->minio = 1000;
439         conf->max_fds = 0;
440         conf->bindings_file = DEFAULT_BINDINGS_FILE;
441         conf->multipath_dir = set_default(DEFAULT_MULTIPATHDIR);
442         conf->flush_on_last_del = 0;
443         conf->attribute_flags = 0;
444
445         /*
446          * preload default hwtable
447          */
448         if (conf->hwtable == NULL) {
449                 conf->hwtable = vector_alloc();
450
451                 if (!conf->hwtable)
452                         goto out;
453         }
454         if (setup_default_hwtable(conf->hwtable))
455                 goto out;
456
457         /*
458          * read the config file
459          */
460         if (filepresent(file)) {
461                 set_current_keywords(&conf->keywords);
462                 if (init_data(file, init_keywords)) {
463                         condlog(0, "error parsing config file");
464                         goto out;
465                 }
466         }
467
468         /*
469          * remove duplica in hwtable. config file takes precedence
470          * over build-in hwtable
471          */
472         factorize_hwtable(conf->hwtable);
473
474         /*
475          * fill the voids left in the config file
476          */
477         if (conf->blist_devnode == NULL) {
478                 conf->blist_devnode = vector_alloc();
479
480                 if (!conf->blist_devnode)
481                         goto out;
482         }
483         if (conf->blist_wwid == NULL) {
484                 conf->blist_wwid = vector_alloc();
485
486                 if (!conf->blist_wwid)
487                         goto out;
488         }
489         if (conf->blist_device == NULL) {
490                 conf->blist_device = vector_alloc();
491
492                 if (!conf->blist_device)
493                         goto out;
494         }
495         if (setup_default_blist(conf))
496                 goto out;
497
498         if (conf->elist_devnode == NULL) {
499                 conf->elist_devnode = vector_alloc();
500
501                 if (!conf->elist_devnode)
502                         goto out;
503         }
504         if (conf->elist_wwid == NULL) {
505                 conf->elist_wwid = vector_alloc();
506
507                 if (!conf->elist_wwid)
508                         goto out;
509         }
510
511         if (conf->elist_device == NULL) {
512                 conf->elist_device = vector_alloc();
513
514                 if (!conf->elist_device)
515                         goto out;
516         }
517
518         if (conf->mptable == NULL) {
519                 conf->mptable = vector_alloc();
520                 if (!conf->mptable)
521                         goto out;
522         }
523         if (conf->udev_dir == NULL)
524                 conf->udev_dir = set_default(DEFAULT_UDEVDIR);
525
526         if (!conf->udev_dir || !conf->multipath_dir)
527                 goto out;
528
529         return 0;
530 out:
531         free_config(conf);
532         return 1;
533 }
534