add "max_sectors_kb" config parameter
[multipath-tools/.git] / libmultipath / dict.c
1 /*
2  * Based on Alexandre Cassen template for keepalived
3  * Copyright (c) 2004, 2005, 2006  Christophe Varoqui
4  * Copyright (c) 2005 Benjamin Marzinski, Redhat
5  * Copyright (c) 2005 Kiyoshi Ueda, NEC
6  */
7 #include <sys/types.h>
8 #include <pwd.h>
9 #include <string.h>
10 #include "checkers.h"
11 #include "vector.h"
12 #include "hwtable.h"
13 #include "structs.h"
14 #include "parser.h"
15 #include "config.h"
16 #include "debug.h"
17 #include "memory.h"
18 #include "pgpolicies.h"
19 #include "blacklist.h"
20 #include "defaults.h"
21 #include "prio.h"
22 #include <errno.h>
23 #include <inttypes.h>
24 #include "mpath_cmd.h"
25
26 static int
27 set_int(vector strvec, void *ptr)
28 {
29         int *int_ptr = (int *)ptr;
30         char * buff;
31
32         buff = VECTOR_SLOT(strvec, 1);
33         *int_ptr = atoi(buff);
34
35         return 0;
36 }
37
38 static int
39 set_str(vector strvec, void *ptr)
40 {
41         char **str_ptr = (char **)ptr;
42
43         if (*str_ptr)
44                 FREE(*str_ptr);
45         *str_ptr = set_value(strvec);
46
47         if (!*str_ptr)
48                 return 1;
49
50         return 0;
51 }
52
53 static int
54 set_yes_no(vector strvec, void *ptr)
55 {
56         char * buff;
57         int *int_ptr = (int *)ptr;
58
59         buff = set_value(strvec);
60         if (!buff)
61                 return 1;
62
63         if (strcmp(buff, "yes") == 0 || strcmp(buff, "1") == 0)
64                 *int_ptr = YN_YES;
65         else
66                 *int_ptr = YN_NO;
67
68         FREE(buff);
69         return 0;
70 }
71
72 static int
73 set_yes_no_undef(vector strvec, void *ptr)
74 {
75         char * buff;
76         int *int_ptr = (int *)ptr;
77
78         buff = set_value(strvec);
79         if (!buff)
80                 return 1;
81
82         if (strcmp(buff, "no") == 0 || strcmp(buff, "0") == 0)
83                 *int_ptr = YNU_NO;
84         else if (strcmp(buff, "yes") == 0 || strcmp(buff, "1") == 0)
85                 *int_ptr = YNU_YES;
86         else
87                 *int_ptr = YNU_UNDEF;
88
89         FREE(buff);
90         return 0;
91 }
92
93 static int
94 print_int (char *buff, int len, void *ptr)
95 {
96         int *int_ptr = (int *)ptr;
97         return snprintf(buff, len, "%i", *int_ptr);
98 }
99
100 static int
101 print_nonzero (char *buff, int len, void *ptr)
102 {
103         int *int_ptr = (int *)ptr;
104         if (!*int_ptr)
105                 return 0;
106         return snprintf(buff, len, "%i", *int_ptr);
107 }
108
109 static int
110 print_str (char *buff, int len, void *ptr)
111 {
112         char **str_ptr = (char **)ptr;
113         if (!*str_ptr)
114                 return 0;
115         return snprintf(buff, len, "\"%s\"", *str_ptr);
116 }
117
118 static int
119 print_yes_no (char *buff, int len, void *ptr)
120 {
121         int *int_ptr = (int *)ptr;
122         return snprintf(buff, len, "\"%s\"",
123                         (*int_ptr == YN_NO)? "no" : "yes");
124 }
125
126 static int
127 print_yes_no_undef (char *buff, int len, void *ptr)
128 {
129         int *int_ptr = (int *)ptr;
130         if (!*int_ptr)
131                 return 0;
132         return snprintf(buff, len, "\"%s\"",
133                         (*int_ptr == YNU_NO)? "no" : "yes");
134 }
135
136 #define declare_def_handler(option, function)                           \
137 static int                                                              \
138 def_ ## option ## _handler (struct config *conf, vector strvec)         \
139 {                                                                       \
140         return function (strvec, &conf->option);                        \
141 }
142
143 #define declare_def_snprint(option, function)                           \
144 static int                                                              \
145 snprint_def_ ## option (struct config *conf, char * buff, int len, void * data) \
146 {                                                                       \
147         return function (buff, len, &conf->option);                     \
148 }
149
150 #define declare_def_snprint_defint(option, function, value)             \
151 static int                                                              \
152 snprint_def_ ## option (struct config *conf, char * buff, int len, void * data) \
153 {                                                                       \
154         int i = value;                                                  \
155         if (!conf->option)                                              \
156                 return function (buff, len, &i);                        \
157         return function (buff, len, &conf->option);                     \
158 }
159
160 #define declare_def_snprint_defstr(option, function, value)             \
161 static int                                                              \
162 snprint_def_ ## option (struct config *conf, char * buff, int len, void * data) \
163 {                                                                       \
164         char *s = value;                                                \
165         if (!conf->option)                                              \
166                 return function (buff, len, &s);                        \
167         return function (buff, len, &conf->option);                     \
168 }
169
170 #define declare_hw_handler(option, function)                            \
171 static int                                                              \
172 hw_ ## option ## _handler (struct config *conf, vector strvec)          \
173 {                                                                       \
174         struct hwentry * hwe = VECTOR_LAST_SLOT(conf->hwtable);         \
175         if (!hwe)                                                       \
176                 return 1;                                               \
177         return function (strvec, &hwe->option);                         \
178 }
179
180 #define declare_hw_snprint(option, function)                            \
181 static int                                                              \
182 snprint_hw_ ## option (struct config *conf, char * buff, int len, void * data) \
183 {                                                                       \
184         struct hwentry * hwe = (struct hwentry *)data;                  \
185         return function (buff, len, &hwe->option);                      \
186 }
187
188 #define declare_ovr_handler(option, function)                           \
189 static int                                                              \
190 ovr_ ## option ## _handler (struct config *conf, vector strvec)         \
191 {                                                                       \
192         if (!conf->overrides)                                           \
193                 return 1;                                               \
194         return function (strvec, &conf->overrides->option);             \
195 }
196
197 #define declare_ovr_snprint(option, function)                           \
198 static int                                                              \
199 snprint_ovr_ ## option (struct config *conf, char * buff, int len, void * data) \
200 {                                                                       \
201         return function (buff, len, &conf->overrides->option);          \
202 }
203
204 #define declare_mp_handler(option, function)                            \
205 static int                                                              \
206 mp_ ## option ## _handler (struct config *conf, vector strvec)          \
207 {                                                                       \
208         struct mpentry * mpe = VECTOR_LAST_SLOT(conf->mptable);         \
209         if (!mpe)                                                       \
210                 return 1;                                               \
211         return function (strvec, &mpe->option);                         \
212 }
213
214 #define declare_mp_snprint(option, function)                            \
215 static int                                                              \
216 snprint_mp_ ## option (struct config *conf, char * buff, int len, void * data) \
217 {                                                                       \
218         struct mpentry * mpe = (struct mpentry *)data;                  \
219         return function (buff, len, &mpe->option);                      \
220 }
221
222 declare_def_handler(checkint, set_int)
223 declare_def_snprint(checkint, print_int)
224
225 declare_def_handler(max_checkint, set_int)
226 declare_def_snprint(max_checkint, print_int)
227
228 declare_def_handler(verbosity, set_int)
229 declare_def_snprint(verbosity, print_int)
230
231 declare_def_handler(reassign_maps, set_yes_no)
232 declare_def_snprint(reassign_maps, print_yes_no)
233
234 declare_def_handler(multipath_dir, set_str)
235 declare_def_snprint(multipath_dir, print_str)
236
237 declare_def_handler(partition_delim, set_str)
238 declare_def_snprint(partition_delim, print_str)
239
240 declare_def_handler(find_multipaths, set_yes_no)
241 declare_def_snprint(find_multipaths, print_yes_no)
242
243 declare_def_handler(selector, set_str)
244 declare_def_snprint_defstr(selector, print_str, DEFAULT_SELECTOR)
245 declare_hw_handler(selector, set_str)
246 declare_hw_snprint(selector, print_str)
247 declare_ovr_handler(selector, set_str)
248 declare_ovr_snprint(selector, print_str)
249 declare_mp_handler(selector, set_str)
250 declare_mp_snprint(selector, print_str)
251
252 declare_def_handler(uid_attribute, set_str)
253 declare_def_snprint_defstr(uid_attribute, print_str, DEFAULT_UID_ATTRIBUTE)
254 declare_ovr_handler(uid_attribute, set_str)
255 declare_ovr_snprint(uid_attribute, print_str)
256 declare_hw_handler(uid_attribute, set_str)
257 declare_hw_snprint(uid_attribute, print_str)
258
259 declare_def_handler(getuid, set_str)
260 declare_def_snprint(getuid, print_str)
261 declare_ovr_handler(getuid, set_str)
262 declare_ovr_snprint(getuid, print_str)
263 declare_hw_handler(getuid, set_str)
264 declare_hw_snprint(getuid, print_str)
265
266 declare_def_handler(prio_name, set_str)
267 declare_def_snprint_defstr(prio_name, print_str, DEFAULT_PRIO)
268 declare_ovr_handler(prio_name, set_str)
269 declare_ovr_snprint(prio_name, print_str)
270 declare_hw_handler(prio_name, set_str)
271 declare_hw_snprint(prio_name, print_str)
272 declare_mp_handler(prio_name, set_str)
273 declare_mp_snprint(prio_name, print_str)
274
275 declare_def_handler(alias_prefix, set_str)
276 declare_def_snprint_defstr(alias_prefix, print_str, DEFAULT_ALIAS_PREFIX)
277 declare_ovr_handler(alias_prefix, set_str)
278 declare_ovr_snprint(alias_prefix, print_str)
279 declare_hw_handler(alias_prefix, set_str)
280 declare_hw_snprint(alias_prefix, print_str)
281
282 declare_def_handler(prio_args, set_str)
283 declare_def_snprint_defstr(prio_args, print_str, DEFAULT_PRIO_ARGS)
284 declare_ovr_handler(prio_args, set_str)
285 declare_ovr_snprint(prio_args, print_str)
286 declare_hw_handler(prio_args, set_str)
287 declare_hw_snprint(prio_args, print_str)
288 declare_mp_handler(prio_args, set_str)
289 declare_mp_snprint(prio_args, print_str)
290
291 declare_def_handler(features, set_str)
292 declare_def_snprint_defstr(features, print_str, DEFAULT_FEATURES)
293 declare_ovr_handler(features, set_str)
294 declare_ovr_snprint(features, print_str)
295 declare_hw_handler(features, set_str)
296 declare_hw_snprint(features, print_str)
297 declare_mp_handler(features, set_str)
298 declare_mp_snprint(features, print_str)
299
300 declare_def_handler(checker_name, set_str)
301 declare_def_snprint_defstr(checker_name, print_str, DEFAULT_CHECKER)
302 declare_ovr_handler(checker_name, set_str)
303 declare_ovr_snprint(checker_name, print_str)
304 declare_hw_handler(checker_name, set_str)
305 declare_hw_snprint(checker_name, print_str)
306
307 declare_def_handler(minio, set_int)
308 declare_def_snprint_defint(minio, print_int, DEFAULT_MINIO)
309 declare_ovr_handler(minio, set_int)
310 declare_ovr_snprint(minio, print_nonzero)
311 declare_hw_handler(minio, set_int)
312 declare_hw_snprint(minio, print_nonzero)
313 declare_mp_handler(minio, set_int)
314 declare_mp_snprint(minio, print_nonzero)
315
316 declare_def_handler(minio_rq, set_int)
317 declare_def_snprint_defint(minio_rq, print_int, DEFAULT_MINIO_RQ)
318 declare_ovr_handler(minio_rq, set_int)
319 declare_ovr_snprint(minio_rq, print_nonzero)
320 declare_hw_handler(minio_rq, set_int)
321 declare_hw_snprint(minio_rq, print_nonzero)
322 declare_mp_handler(minio_rq, set_int)
323 declare_mp_snprint(minio_rq, print_nonzero)
324
325 declare_def_handler(queue_without_daemon, set_yes_no)
326 static int
327 snprint_def_queue_without_daemon (struct config *conf,
328                                   char * buff, int len, void * data)
329 {
330         switch (conf->queue_without_daemon) {
331         case QUE_NO_DAEMON_OFF:
332                 return snprintf(buff, len, "\"no\"");
333         case QUE_NO_DAEMON_ON:
334                 return snprintf(buff, len, "\"yes\"");
335         case QUE_NO_DAEMON_FORCE:
336                 return snprintf(buff, len, "\"forced\"");
337         }
338         return 0;
339 }
340
341 declare_def_handler(checker_timeout, set_int)
342 declare_def_snprint(checker_timeout, print_nonzero)
343
344 declare_def_handler(flush_on_last_del, set_yes_no_undef)
345 declare_def_snprint_defint(flush_on_last_del, print_yes_no_undef, YNU_NO)
346 declare_ovr_handler(flush_on_last_del, set_yes_no_undef)
347 declare_ovr_snprint(flush_on_last_del, print_yes_no_undef)
348 declare_hw_handler(flush_on_last_del, set_yes_no_undef)
349 declare_hw_snprint(flush_on_last_del, print_yes_no_undef)
350 declare_mp_handler(flush_on_last_del, set_yes_no_undef)
351 declare_mp_snprint(flush_on_last_del, print_yes_no_undef)
352
353 declare_def_handler(user_friendly_names, set_yes_no_undef)
354 declare_def_snprint_defint(user_friendly_names, print_yes_no_undef, YNU_NO)
355 declare_ovr_handler(user_friendly_names, set_yes_no_undef)
356 declare_ovr_snprint(user_friendly_names, print_yes_no_undef)
357 declare_hw_handler(user_friendly_names, set_yes_no_undef)
358 declare_hw_snprint(user_friendly_names, print_yes_no_undef)
359 declare_mp_handler(user_friendly_names, set_yes_no_undef)
360 declare_mp_snprint(user_friendly_names, print_yes_no_undef)
361
362 declare_def_handler(bindings_file, set_str)
363 declare_def_snprint(bindings_file, print_str)
364
365 declare_def_handler(wwids_file, set_str)
366 declare_def_snprint(wwids_file, print_str)
367
368 declare_def_handler(retain_hwhandler, set_yes_no_undef)
369 declare_def_snprint_defint(retain_hwhandler, print_yes_no_undef, YNU_NO)
370 declare_ovr_handler(retain_hwhandler, set_yes_no_undef)
371 declare_ovr_snprint(retain_hwhandler, print_yes_no_undef)
372 declare_hw_handler(retain_hwhandler, set_yes_no_undef)
373 declare_hw_snprint(retain_hwhandler, print_yes_no_undef)
374
375 declare_def_handler(detect_prio, set_yes_no_undef)
376 declare_def_snprint_defint(detect_prio, print_yes_no_undef, YNU_NO)
377 declare_ovr_handler(detect_prio, set_yes_no_undef)
378 declare_ovr_snprint(detect_prio, print_yes_no_undef)
379 declare_hw_handler(detect_prio, set_yes_no_undef)
380 declare_hw_snprint(detect_prio, print_yes_no_undef)
381
382 declare_def_handler(force_sync, set_yes_no)
383 declare_def_snprint(force_sync, print_yes_no)
384
385 declare_def_handler(deferred_remove, set_yes_no_undef)
386 declare_def_snprint_defint(deferred_remove, print_yes_no_undef, YNU_NO)
387 declare_ovr_handler(deferred_remove, set_yes_no_undef)
388 declare_ovr_snprint(deferred_remove, print_yes_no_undef)
389 declare_hw_handler(deferred_remove, set_yes_no_undef)
390 declare_hw_snprint(deferred_remove, print_yes_no_undef)
391 declare_mp_handler(deferred_remove, set_yes_no_undef)
392 declare_mp_snprint(deferred_remove, print_yes_no_undef)
393
394 declare_def_handler(retrigger_tries, set_int)
395 declare_def_snprint(retrigger_tries, print_int)
396
397 declare_def_handler(retrigger_delay, set_int)
398 declare_def_snprint(retrigger_delay, print_int)
399
400 declare_def_handler(uev_wait_timeout, set_int)
401 declare_def_snprint(uev_wait_timeout, print_int)
402
403 declare_def_handler(strict_timing, set_yes_no)
404 declare_def_snprint(strict_timing, print_yes_no)
405
406 declare_def_handler(skip_kpartx, set_yes_no_undef)
407 declare_def_snprint_defint(skip_kpartx, print_yes_no_undef, YNU_NO)
408 declare_ovr_handler(skip_kpartx, set_yes_no_undef)
409 declare_ovr_snprint(skip_kpartx, print_yes_no_undef)
410 declare_hw_handler(skip_kpartx, set_yes_no_undef)
411 declare_hw_snprint(skip_kpartx, print_yes_no_undef)
412 declare_mp_handler(skip_kpartx, set_yes_no_undef)
413 declare_mp_snprint(skip_kpartx, print_yes_no_undef)
414
415 declare_def_handler(disable_changed_wwids, set_yes_no)
416 declare_def_snprint(disable_changed_wwids, print_yes_no)
417
418 declare_def_handler(remove_retries, set_int)
419 declare_def_snprint(remove_retries, print_int)
420
421 declare_def_handler(max_sectors_kb, set_int)
422 declare_def_snprint(max_sectors_kb, print_nonzero)
423 declare_ovr_handler(max_sectors_kb, set_int)
424 declare_ovr_snprint(max_sectors_kb, print_nonzero)
425 declare_hw_handler(max_sectors_kb, set_int)
426 declare_hw_snprint(max_sectors_kb, print_nonzero)
427 declare_mp_handler(max_sectors_kb, set_int)
428 declare_mp_snprint(max_sectors_kb, print_nonzero)
429
430 static int
431 def_config_dir_handler(struct config *conf, vector strvec)
432 {
433         /* this is only valid in the main config file */
434         if (conf->processed_main_config)
435                 return 0;
436         return set_str(strvec, &conf->config_dir);
437 }
438 declare_def_snprint(config_dir, print_str)
439
440 #define declare_def_attr_handler(option, function)                      \
441 static int                                                              \
442 def_ ## option ## _handler (struct config *conf, vector strvec)         \
443 {                                                                       \
444         return function (strvec, &conf->option, &conf->attribute_flags);\
445 }
446
447 #define declare_def_attr_snprint(option, function)                      \
448 static int                                                              \
449 snprint_def_ ## option (struct config *conf, char * buff, int len, void * data) \
450 {                                                                       \
451         return function (buff, len, &conf->option,                      \
452                          &conf->attribute_flags);                       \
453 }
454
455 #define declare_mp_attr_handler(option, function)                       \
456 static int                                                              \
457 mp_ ## option ## _handler (struct config *conf, vector strvec)          \
458 {                                                                       \
459         struct mpentry * mpe = VECTOR_LAST_SLOT(conf->mptable);         \
460         if (!mpe)                                                       \
461                 return 1;                                               \
462         return function (strvec, &mpe->option, &mpe->attribute_flags);  \
463 }
464
465 #define declare_mp_attr_snprint(option, function)                       \
466 static int                                                              \
467 snprint_mp_ ## option (struct config *conf, char * buff, int len, void * data) \
468 {                                                                       \
469         struct mpentry * mpe = (struct mpentry *)data;                  \
470         return function (buff, len, &mpe->option,                       \
471                          &mpe->attribute_flags);                        \
472 }
473
474 static int
475 set_mode(vector strvec, void *ptr, int *flags)
476 {
477         mode_t mode;
478         mode_t *mode_ptr = (mode_t *)ptr;
479         char *buff;
480
481         buff = set_value(strvec);
482
483         if (!buff)
484                 return 1;
485
486         if (sscanf(buff, "%o", &mode) == 1 && mode <= 0777) {
487                 *flags |= (1 << ATTR_MODE);
488                 *mode_ptr = mode;
489         }
490
491         FREE(buff);
492         return 0;
493 }
494
495 static int
496 set_uid(vector strvec, void *ptr, int *flags)
497 {
498         uid_t uid;
499         uid_t *uid_ptr = (uid_t *)ptr;
500         char *buff;
501         char passwd_buf[1024];
502         struct passwd info, *found;
503
504         buff = set_value(strvec);
505         if (!buff)
506                 return 1;
507         if (getpwnam_r(buff, &info, passwd_buf, 1024, &found) == 0 && found) {
508                 *flags |= (1 << ATTR_UID);
509                 *uid_ptr = info.pw_uid;
510         }
511         else if (sscanf(buff, "%u", &uid) == 1){
512                 *flags |= (1 << ATTR_UID);
513                 *uid_ptr = uid;
514         }
515
516         FREE(buff);
517         return 0;
518 }
519
520 static int
521 set_gid(vector strvec, void *ptr, int *flags)
522 {
523         gid_t gid;
524         gid_t *gid_ptr = (gid_t *)ptr;
525         char *buff;
526         char passwd_buf[1024];
527         struct passwd info, *found;
528
529         buff = set_value(strvec);
530         if (!buff)
531                 return 1;
532
533         if (getpwnam_r(buff, &info, passwd_buf, 1024, &found) == 0 && found) {
534                 *flags |= (1 << ATTR_GID);
535                 *gid_ptr = info.pw_gid;
536         }
537         else if (sscanf(buff, "%u", &gid) == 1){
538                 *flags |= (1 << ATTR_GID);
539                 *gid_ptr = gid;
540         }
541         FREE(buff);
542         return 0;
543 }
544
545 static int
546 print_mode(char * buff, int len, void *ptr, int *flags)
547 {
548         mode_t *mode_ptr = (mode_t *)ptr;
549         if ((*flags & (1 << ATTR_MODE)) == 0)
550                 return 0;
551         return snprintf(buff, len, "0%o", *mode_ptr);
552 }
553
554 static int
555 print_uid(char * buff, int len, void *ptr, int *flags)
556 {
557         uid_t *uid_ptr = (uid_t *)ptr;
558         if ((*flags & (1 << ATTR_UID)) == 0)
559                 return 0;
560         return snprintf(buff, len, "0%o", *uid_ptr);
561 }
562
563 static int
564 print_gid(char * buff, int len, void *ptr, int *flags)
565 {
566         gid_t *gid_ptr = (gid_t *)ptr;
567         if ((*flags & (1 << ATTR_GID)) == 0)
568                 return 0;
569         return snprintf(buff, len, "0%o", *gid_ptr);
570 }
571
572 declare_def_attr_handler(mode, set_mode)
573 declare_def_attr_snprint(mode, print_mode)
574 declare_mp_attr_handler(mode, set_mode)
575 declare_mp_attr_snprint(mode, print_mode)
576
577 declare_def_attr_handler(uid, set_uid)
578 declare_def_attr_snprint(uid, print_uid)
579 declare_mp_attr_handler(uid, set_uid)
580 declare_mp_attr_snprint(uid, print_uid)
581
582 declare_def_attr_handler(gid, set_gid)
583 declare_def_attr_snprint(gid, print_gid)
584 declare_mp_attr_handler(gid, set_gid)
585 declare_mp_attr_snprint(gid, print_gid)
586
587 static int
588 set_fast_io_fail(vector strvec, void *ptr)
589 {
590         char * buff;
591         int *int_ptr = (int *)ptr;
592
593         buff = set_value(strvec);
594         if (!buff)
595                 return 1;
596
597         if (strcmp(buff, "off") == 0)
598                 *int_ptr = MP_FAST_IO_FAIL_OFF;
599         else if (sscanf(buff, "%d", int_ptr) != 1 ||
600                  *int_ptr < MP_FAST_IO_FAIL_ZERO)
601                 *int_ptr = MP_FAST_IO_FAIL_UNSET;
602         else if (*int_ptr == 0)
603                 *int_ptr = MP_FAST_IO_FAIL_ZERO;
604
605         FREE(buff);
606         return 0;
607 }
608
609 int
610 print_fast_io_fail(char * buff, int len, void *ptr)
611 {
612         int *int_ptr = (int *)ptr;
613
614         if (*int_ptr == MP_FAST_IO_FAIL_UNSET)
615                 return 0;
616         if (*int_ptr == MP_FAST_IO_FAIL_OFF)
617                 return snprintf(buff, len, "\"off\"");
618         if (*int_ptr == MP_FAST_IO_FAIL_ZERO)
619                 return snprintf(buff, len, "0");
620         return snprintf(buff, len, "%d", *int_ptr);
621 }
622
623 declare_def_handler(fast_io_fail, set_fast_io_fail)
624 declare_def_snprint(fast_io_fail, print_fast_io_fail)
625 declare_ovr_handler(fast_io_fail, set_fast_io_fail)
626 declare_ovr_snprint(fast_io_fail, print_fast_io_fail)
627 declare_hw_handler(fast_io_fail, set_fast_io_fail)
628 declare_hw_snprint(fast_io_fail, print_fast_io_fail)
629
630 static int
631 set_dev_loss(vector strvec, void *ptr)
632 {
633         char * buff;
634         unsigned int *uint_ptr = (unsigned int *)ptr;
635
636         buff = set_value(strvec);
637         if (!buff)
638                 return 1;
639
640         if (!strcmp(buff, "infinity"))
641                 *uint_ptr = MAX_DEV_LOSS_TMO;
642         else if (sscanf(buff, "%u", uint_ptr) != 1)
643                 *uint_ptr = 0;
644
645         FREE(buff);
646         return 0;
647 }
648
649 int
650 print_dev_loss(char * buff, int len, void *ptr)
651 {
652         unsigned int *uint_ptr = (unsigned int *)ptr;
653
654         if (!*uint_ptr)
655                 return 0;
656         if (*uint_ptr >= MAX_DEV_LOSS_TMO)
657                 return snprintf(buff, len, "\"infinity\"");
658         return snprintf(buff, len, "%u", *uint_ptr);
659 }
660
661 declare_def_handler(dev_loss, set_dev_loss)
662 declare_def_snprint(dev_loss, print_dev_loss)
663 declare_ovr_handler(dev_loss, set_dev_loss)
664 declare_ovr_snprint(dev_loss, print_dev_loss)
665 declare_hw_handler(dev_loss, set_dev_loss)
666 declare_hw_snprint(dev_loss, print_dev_loss)
667
668 static int
669 set_pgpolicy(vector strvec, void *ptr)
670 {
671         char * buff;
672         int *int_ptr = (int *)ptr;
673
674         buff = set_value(strvec);
675         if (!buff)
676                 return 1;
677
678         *int_ptr = get_pgpolicy_id(buff);
679         FREE(buff);
680
681         return 0;
682 }
683
684 int
685 print_pgpolicy(char * buff, int len, void *ptr)
686 {
687         char str[POLICY_NAME_SIZE];
688         int pgpolicy = *(int *)ptr;
689
690         if (!pgpolicy)
691                 return 0;
692
693         get_pgpolicy_name(str, POLICY_NAME_SIZE, pgpolicy);
694
695         return snprintf(buff, len, "\"%s\"", str);
696 }
697
698 declare_def_handler(pgpolicy, set_pgpolicy)
699 declare_def_snprint_defint(pgpolicy, print_pgpolicy, DEFAULT_PGPOLICY)
700 declare_ovr_handler(pgpolicy, set_pgpolicy)
701 declare_ovr_snprint(pgpolicy, print_pgpolicy)
702 declare_hw_handler(pgpolicy, set_pgpolicy)
703 declare_hw_snprint(pgpolicy, print_pgpolicy)
704 declare_mp_handler(pgpolicy, set_pgpolicy)
705 declare_mp_snprint(pgpolicy, print_pgpolicy)
706
707 int
708 get_sys_max_fds(int *max_fds)
709 {
710         FILE *file;
711         int nr_open;
712         int ret = 1;
713
714         file = fopen("/proc/sys/fs/nr_open", "r");
715         if (!file) {
716                 fprintf(stderr, "Cannot open /proc/sys/fs/nr_open : %s\n",
717                         strerror(errno));
718                 return 1;
719         }
720         if (fscanf(file, "%d", &nr_open) != 1) {
721                 fprintf(stderr, "Cannot read max open fds from /proc/sys/fs/nr_open");
722                 if (ferror(file))
723                         fprintf(stderr, " : %s\n", strerror(errno));
724                 else
725                         fprintf(stderr, "\n");
726         } else {
727                 *max_fds = nr_open;
728                 ret = 0;
729         }
730         fclose(file);
731         return ret;
732 }
733
734
735 static int
736 max_fds_handler(struct config *conf, vector strvec)
737 {
738         char * buff;
739         int r = 0, max_fds;
740
741         buff = set_value(strvec);
742
743         if (!buff)
744                 return 1;
745
746         r = get_sys_max_fds(&max_fds);
747         if (r) {
748                 /* Assume safe limit */
749                 max_fds = 4096;
750         }
751         if (strlen(buff) == 3 &&
752             !strcmp(buff, "max"))
753                 conf->max_fds = max_fds;
754         else
755                 conf->max_fds = atoi(buff);
756
757         if (conf->max_fds > max_fds)
758                 conf->max_fds = max_fds;
759
760         FREE(buff);
761
762         return r;
763 }
764
765 static int
766 snprint_max_fds (struct config *conf, char * buff, int len, void * data)
767 {
768         int r = 0, max_fds;
769
770         if (!conf->max_fds)
771                 return 0;
772
773         r = get_sys_max_fds(&max_fds);
774         if (!r && conf->max_fds >= max_fds)
775                 return snprintf(buff, len, "\"max\"");
776         else
777                 return snprintf(buff, len, "%d", conf->max_fds);
778 }
779
780 static int
781 set_rr_weight(vector strvec, void *ptr)
782 {
783         int *int_ptr = (int *)ptr;
784         char * buff;
785
786         buff = set_value(strvec);
787
788         if (!buff)
789                 return 1;
790
791         if (!strcmp(buff, "priorities"))
792                 *int_ptr = RR_WEIGHT_PRIO;
793
794         if (!strcmp(buff, "uniform"))
795                 *int_ptr = RR_WEIGHT_NONE;
796
797         FREE(buff);
798
799         return 0;
800 }
801
802 int
803 print_rr_weight (char * buff, int len, void *ptr)
804 {
805         int *int_ptr = (int *)ptr;
806
807         if (!*int_ptr)
808                 return 0;
809         if (*int_ptr == RR_WEIGHT_PRIO)
810                 return snprintf(buff, len, "\"priorities\"");
811         if (*int_ptr == RR_WEIGHT_NONE)
812                 return snprintf(buff, len, "\"uniform\"");
813
814         return 0;
815 }
816
817 declare_def_handler(rr_weight, set_rr_weight)
818 declare_def_snprint_defint(rr_weight, print_rr_weight, RR_WEIGHT_NONE)
819 declare_ovr_handler(rr_weight, set_rr_weight)
820 declare_ovr_snprint(rr_weight, print_rr_weight)
821 declare_hw_handler(rr_weight, set_rr_weight)
822 declare_hw_snprint(rr_weight, print_rr_weight)
823 declare_mp_handler(rr_weight, set_rr_weight)
824 declare_mp_snprint(rr_weight, print_rr_weight)
825
826 static int
827 set_pgfailback(vector strvec, void *ptr)
828 {
829         int *int_ptr = (int *)ptr;
830         char * buff;
831
832         buff = set_value(strvec);
833         if (!buff)
834                 return 1;
835
836         if (strlen(buff) == 6 && !strcmp(buff, "manual"))
837                 *int_ptr = -FAILBACK_MANUAL;
838         else if (strlen(buff) == 9 && !strcmp(buff, "immediate"))
839                 *int_ptr = -FAILBACK_IMMEDIATE;
840         else if (strlen(buff) == 10 && !strcmp(buff, "followover"))
841                 *int_ptr = -FAILBACK_FOLLOWOVER;
842         else
843                 *int_ptr = atoi(buff);
844
845         FREE(buff);
846
847         return 0;
848 }
849
850 int
851 print_pgfailback (char * buff, int len, void *ptr)
852 {
853         int *int_ptr = (int *)ptr;
854
855         switch(*int_ptr) {
856         case  FAILBACK_UNDEF:
857                 return 0;
858         case -FAILBACK_MANUAL:
859                 return snprintf(buff, len, "\"manual\"");
860         case -FAILBACK_IMMEDIATE:
861                 return snprintf(buff, len, "\"immediate\"");
862         case -FAILBACK_FOLLOWOVER:
863                 return snprintf(buff, len, "\"followover\"");
864         default:
865                 return snprintf(buff, len, "%i", *int_ptr);
866         }
867 }
868
869 declare_def_handler(pgfailback, set_pgfailback)
870 declare_def_snprint_defint(pgfailback, print_pgfailback, DEFAULT_FAILBACK)
871 declare_ovr_handler(pgfailback, set_pgfailback)
872 declare_ovr_snprint(pgfailback, print_pgfailback)
873 declare_hw_handler(pgfailback, set_pgfailback)
874 declare_hw_snprint(pgfailback, print_pgfailback)
875 declare_mp_handler(pgfailback, set_pgfailback)
876 declare_mp_snprint(pgfailback, print_pgfailback)
877
878 static int
879 set_no_path_retry(vector strvec, void *ptr)
880 {
881         int *int_ptr = (int *)ptr;
882         char * buff;
883
884         buff = set_value(strvec);
885         if (!buff)
886                 return 1;
887
888         if (!strcmp(buff, "fail") || !strcmp(buff, "0"))
889                 *int_ptr = NO_PATH_RETRY_FAIL;
890         else if (!strcmp(buff, "queue"))
891                 *int_ptr = NO_PATH_RETRY_QUEUE;
892         else if ((*int_ptr = atoi(buff)) < 1)
893                 *int_ptr = NO_PATH_RETRY_UNDEF;
894
895         FREE(buff);
896         return 0;
897 }
898
899 int
900 print_no_path_retry(char * buff, int len, void *ptr)
901 {
902         int *int_ptr = (int *)ptr;
903
904         switch(*int_ptr) {
905         case NO_PATH_RETRY_UNDEF:
906                 return 0;
907         case NO_PATH_RETRY_FAIL:
908                 return snprintf(buff, len, "\"fail\"");
909         case NO_PATH_RETRY_QUEUE:
910                 return snprintf(buff, len, "\"queue\"");
911         default:
912                 return snprintf(buff, len, "%i", *int_ptr);
913         }
914 }
915
916 declare_def_handler(no_path_retry, set_no_path_retry)
917 declare_def_snprint(no_path_retry, print_no_path_retry)
918 declare_ovr_handler(no_path_retry, set_no_path_retry)
919 declare_ovr_snprint(no_path_retry, print_no_path_retry)
920 declare_hw_handler(no_path_retry, set_no_path_retry)
921 declare_hw_snprint(no_path_retry, print_no_path_retry)
922 declare_mp_handler(no_path_retry, set_no_path_retry)
923 declare_mp_snprint(no_path_retry, print_no_path_retry)
924
925 static int
926 def_log_checker_err_handler(struct config *conf, vector strvec)
927 {
928         char * buff;
929
930         buff = set_value(strvec);
931
932         if (!buff)
933                 return 1;
934
935         if (strlen(buff) == 4 && !strcmp(buff, "once"))
936                 conf->log_checker_err = LOG_CHKR_ERR_ONCE;
937         else if (strlen(buff) == 6 && !strcmp(buff, "always"))
938                 conf->log_checker_err = LOG_CHKR_ERR_ALWAYS;
939
940         free(buff);
941         return 0;
942 }
943
944 static int
945 snprint_def_log_checker_err (struct config *conf, char * buff, int len, void * data)
946 {
947         if (conf->log_checker_err == LOG_CHKR_ERR_ONCE)
948                 return snprintf(buff, len, "once");
949         return snprintf(buff, len, "always");
950 }
951
952 static int
953 set_reservation_key(vector strvec, void *ptr)
954 {
955         unsigned char **uchar_ptr = (unsigned char **)ptr;
956         char *buff;
957         char *tbuff;
958         int j, k;
959         int len;
960         uint64_t prkey;
961
962         buff = set_value(strvec);
963         if (!buff)
964                 return 1;
965
966         tbuff = buff;
967
968         if (!memcmp("0x",buff, 2))
969                 buff = buff + 2;
970
971         len = strlen(buff);
972
973         k = strspn(buff, "0123456789aAbBcCdDeEfF");
974
975         if (len != k) {
976                 FREE(tbuff);
977                 return 1;
978         }
979
980         if (1 != sscanf (buff, "%" SCNx64 "", &prkey))
981         {
982                 FREE(tbuff);
983                 return 1;
984         }
985
986         if (!*uchar_ptr)
987                 *uchar_ptr = (unsigned char *) malloc(8);
988
989         memset(*uchar_ptr, 0, 8);
990
991         for (j = 7; j >= 0; --j) {
992                 (*uchar_ptr)[j] = (prkey & 0xff);
993                 prkey >>= 8;
994         }
995
996         FREE(tbuff);
997         return 0;
998 }
999
1000 int
1001 print_reservation_key(char * buff, int len, void * ptr)
1002 {
1003         unsigned char **uchar_ptr = (unsigned char **)ptr;
1004         int i;
1005         unsigned char *keyp;
1006         uint64_t prkey = 0;
1007
1008         if (!*uchar_ptr)
1009                 return 0;
1010         keyp = (unsigned char *)(*uchar_ptr);
1011         for (i = 0; i < 8; i++) {
1012                 if (i > 0)
1013                         prkey <<= 8;
1014                 prkey |= *keyp;
1015                 keyp++;
1016         }
1017         return snprintf(buff, len, "0x%" PRIx64, prkey);
1018 }
1019
1020 declare_def_handler(reservation_key, set_reservation_key)
1021 declare_def_snprint(reservation_key, print_reservation_key)
1022 declare_mp_handler(reservation_key, set_reservation_key)
1023 declare_mp_snprint(reservation_key, print_reservation_key)
1024
1025 static int
1026 set_delay_checks(vector strvec, void *ptr)
1027 {
1028         int *int_ptr = (int *)ptr;
1029         char * buff;
1030
1031         buff = set_value(strvec);
1032         if (!buff)
1033                 return 1;
1034
1035         if (!strcmp(buff, "no") || !strcmp(buff, "0"))
1036                 *int_ptr = DELAY_CHECKS_OFF;
1037         else if ((*int_ptr = atoi(buff)) < 1)
1038                 *int_ptr = DELAY_CHECKS_UNDEF;
1039
1040         FREE(buff);
1041         return 0;
1042 }
1043
1044 int
1045 print_delay_checks(char * buff, int len, void *ptr)
1046 {
1047         int *int_ptr = (int *)ptr;
1048
1049         switch(*int_ptr) {
1050         case DELAY_CHECKS_UNDEF:
1051                 return 0;
1052         case DELAY_CHECKS_OFF:
1053                 return snprintf(buff, len, "\"off\"");
1054         default:
1055                 return snprintf(buff, len, "%i", *int_ptr);
1056         }
1057 }
1058
1059 declare_def_handler(delay_watch_checks, set_delay_checks)
1060 declare_def_snprint(delay_watch_checks, print_delay_checks)
1061 declare_ovr_handler(delay_watch_checks, set_delay_checks)
1062 declare_ovr_snprint(delay_watch_checks, print_delay_checks)
1063 declare_hw_handler(delay_watch_checks, set_delay_checks)
1064 declare_hw_snprint(delay_watch_checks, print_delay_checks)
1065 declare_mp_handler(delay_watch_checks, set_delay_checks)
1066 declare_mp_snprint(delay_watch_checks, print_delay_checks)
1067
1068 declare_def_handler(delay_wait_checks, set_delay_checks)
1069 declare_def_snprint(delay_wait_checks, print_delay_checks)
1070 declare_ovr_handler(delay_wait_checks, set_delay_checks)
1071 declare_ovr_snprint(delay_wait_checks, print_delay_checks)
1072 declare_hw_handler(delay_wait_checks, set_delay_checks)
1073 declare_hw_snprint(delay_wait_checks, print_delay_checks)
1074 declare_mp_handler(delay_wait_checks, set_delay_checks)
1075 declare_mp_snprint(delay_wait_checks, print_delay_checks)
1076
1077 static int
1078 def_uxsock_timeout_handler(struct config *conf, vector strvec)
1079 {
1080         unsigned int uxsock_timeout;
1081         char *buff;
1082
1083         buff = set_value(strvec);
1084         if (!buff)
1085                 return 1;
1086
1087         if (sscanf(buff, "%u", &uxsock_timeout) == 1 &&
1088             uxsock_timeout > DEFAULT_REPLY_TIMEOUT)
1089                 conf->uxsock_timeout = uxsock_timeout;
1090         else
1091                 conf->uxsock_timeout = DEFAULT_REPLY_TIMEOUT;
1092
1093         free(buff);
1094         return 0;
1095 }
1096
1097 /*
1098  * blacklist block handlers
1099  */
1100 static int
1101 blacklist_handler(struct config *conf, vector strvec)
1102 {
1103         if (!conf->blist_devnode)
1104                 conf->blist_devnode = vector_alloc();
1105         if (!conf->blist_wwid)
1106                 conf->blist_wwid = vector_alloc();
1107         if (!conf->blist_device)
1108                 conf->blist_device = vector_alloc();
1109         if (!conf->blist_property)
1110                 conf->blist_property = vector_alloc();
1111
1112         if (!conf->blist_devnode || !conf->blist_wwid ||
1113             !conf->blist_device || !conf->blist_property)
1114                 return 1;
1115
1116         return 0;
1117 }
1118
1119 static int
1120 blacklist_exceptions_handler(struct config *conf, vector strvec)
1121 {
1122         if (!conf->elist_devnode)
1123                 conf->elist_devnode = vector_alloc();
1124         if (!conf->elist_wwid)
1125                 conf->elist_wwid = vector_alloc();
1126         if (!conf->elist_device)
1127                 conf->elist_device = vector_alloc();
1128         if (!conf->elist_property)
1129                 conf->elist_property = vector_alloc();
1130
1131         if (!conf->elist_devnode || !conf->elist_wwid ||
1132             !conf->elist_device || !conf->elist_property)
1133                 return 1;
1134
1135         return 0;
1136 }
1137
1138 #define declare_ble_handler(option)                                     \
1139 static int                                                              \
1140 ble_ ## option ## _handler (struct config *conf, vector strvec)         \
1141 {                                                                       \
1142         char * buff;                                                    \
1143                                                                         \
1144         if (!conf->option)                                              \
1145                 return 1;                                               \
1146                                                                         \
1147         buff = set_value(strvec);                                       \
1148         if (!buff)                                                      \
1149                 return 1;                                               \
1150                                                                         \
1151         return store_ble(conf->option, buff, ORIGIN_CONFIG);            \
1152 }
1153
1154 #define declare_ble_device_handler(name, option, vend, prod)            \
1155 static int                                                              \
1156 ble_ ## option ## _ ## name ## _handler (struct config *conf, vector strvec) \
1157 {                                                                       \
1158         char * buff;                                                    \
1159                                                                         \
1160         if (!conf->option)                                              \
1161                 return 1;                                               \
1162                                                                         \
1163         buff = set_value(strvec);                                       \
1164         if (!buff)                                                      \
1165                 return 1;                                               \
1166                                                                         \
1167         return set_ble_device(conf->option, vend, prod, ORIGIN_CONFIG); \
1168 }
1169
1170 declare_ble_handler(blist_devnode)
1171 declare_ble_handler(elist_devnode)
1172 declare_ble_handler(blist_wwid)
1173 declare_ble_handler(elist_wwid)
1174 declare_ble_handler(blist_property)
1175 declare_ble_handler(elist_property)
1176
1177 static int
1178 snprint_def_uxsock_timeout(struct config *conf, char * buff, int len, void * data)
1179 {
1180         return snprintf(buff, len, "%u", conf->uxsock_timeout);
1181 }
1182
1183 static int
1184 snprint_ble_simple (struct config *conf, char * buff, int len, void * data)
1185 {
1186         struct blentry * ble = (struct blentry *)data;
1187
1188         return snprintf(buff, len, "\"%s\"", ble->str);
1189 }
1190
1191 static int
1192 ble_device_handler(struct config *conf, vector strvec)
1193 {
1194         return alloc_ble_device(conf->blist_device);
1195 }
1196
1197 static int
1198 ble_except_device_handler(struct config *conf, vector strvec)
1199 {
1200         return alloc_ble_device(conf->elist_device);
1201 }
1202
1203 declare_ble_device_handler(vendor, blist_device, buff, NULL)
1204 declare_ble_device_handler(vendor, elist_device, buff, NULL)
1205 declare_ble_device_handler(product, blist_device, NULL, buff)
1206 declare_ble_device_handler(product, elist_device, NULL, buff)
1207
1208 static int
1209 snprint_bled_vendor (struct config *conf, char * buff, int len, void * data)
1210 {
1211         struct blentry_device * bled = (struct blentry_device *)data;
1212
1213         return snprintf(buff, len, "\"%s\"", bled->vendor);
1214 }
1215
1216 static int
1217 snprint_bled_product (struct config *conf, char * buff, int len, void * data)
1218 {
1219         struct blentry_device * bled = (struct blentry_device *)data;
1220
1221         return snprintf(buff, len, "\"%s\"", bled->product);
1222 }
1223
1224 /*
1225  * devices block handlers
1226  */
1227 static int
1228 devices_handler(struct config *conf, vector strvec)
1229 {
1230         if (!conf->hwtable)
1231                 conf->hwtable = vector_alloc();
1232
1233         if (!conf->hwtable)
1234                 return 1;
1235
1236         return 0;
1237 }
1238
1239 static int
1240 device_handler(struct config *conf, vector strvec)
1241 {
1242         struct hwentry * hwe;
1243
1244         hwe = alloc_hwe();
1245
1246         if (!hwe)
1247                 return 1;
1248
1249         if (!vector_alloc_slot(conf->hwtable)) {
1250                 free_hwe(hwe);
1251                 return 1;
1252         }
1253         vector_set_slot(conf->hwtable, hwe);
1254
1255         return 0;
1256 }
1257
1258 declare_hw_handler(vendor, set_str)
1259 declare_hw_snprint(vendor, print_str)
1260
1261 declare_hw_handler(product, set_str)
1262 declare_hw_snprint(product, print_str)
1263
1264 declare_hw_handler(revision, set_str)
1265 declare_hw_snprint(revision, print_str)
1266
1267 declare_hw_handler(bl_product, set_str)
1268 declare_hw_snprint(bl_product, print_str)
1269
1270 declare_hw_handler(hwhandler, set_str)
1271 declare_hw_snprint(hwhandler, print_str)
1272
1273 /*
1274  * overrides handlers
1275  */
1276 static int
1277 overrides_handler(struct config *conf, vector strvec)
1278 {
1279         if (!conf->overrides)
1280                 conf->overrides = alloc_hwe();
1281
1282         if (!conf->overrides)
1283                 return 1;
1284
1285         return 0;
1286 }
1287
1288
1289
1290 /*
1291  * multipaths block handlers
1292  */
1293 static int
1294 multipaths_handler(struct config *conf, vector strvec)
1295 {
1296         if (!conf->mptable)
1297                 conf->mptable = vector_alloc();
1298
1299         if (!conf->mptable)
1300                 return 1;
1301
1302         return 0;
1303 }
1304
1305 static int
1306 multipath_handler(struct config *conf, vector strvec)
1307 {
1308         struct mpentry * mpe;
1309
1310         mpe = alloc_mpe();
1311
1312         if (!mpe)
1313                 return 1;
1314
1315         if (!vector_alloc_slot(conf->mptable)) {
1316                 free_mpe(mpe);
1317                 return 1;
1318         }
1319         vector_set_slot(conf->mptable, mpe);
1320
1321         return 0;
1322 }
1323
1324 declare_mp_handler(wwid, set_str)
1325 declare_mp_snprint(wwid, print_str)
1326
1327 declare_mp_handler(alias, set_str)
1328 declare_mp_snprint(alias, print_str)
1329
1330 /*
1331  * deprecated handlers
1332  */
1333
1334 static int
1335 deprecated_handler(struct config *conf, vector strvec)
1336 {
1337         char * buff;
1338
1339         buff = set_value(strvec);
1340
1341         if (!buff)
1342                 return 1;
1343
1344         FREE(buff);
1345         return 0;
1346 }
1347
1348 static int
1349 snprint_deprecated (struct config *conf, char * buff, int len, void * data)
1350 {
1351         return 0;
1352 }
1353
1354 #define __deprecated
1355
1356 /*
1357  * If you add or remove a keyword also update multipath/multipath.conf.5
1358  */
1359 void
1360 init_keywords(vector keywords)
1361 {
1362         install_keyword_root("defaults", NULL);
1363         install_keyword("verbosity", &def_verbosity_handler, &snprint_def_verbosity);
1364         install_keyword("polling_interval", &def_checkint_handler, &snprint_def_checkint);
1365         install_keyword("max_polling_interval", &def_max_checkint_handler, &snprint_def_max_checkint);
1366         install_keyword("reassign_maps", &def_reassign_maps_handler, &snprint_def_reassign_maps);
1367         install_keyword("multipath_dir", &def_multipath_dir_handler, &snprint_def_multipath_dir);
1368         install_keyword("path_selector", &def_selector_handler, &snprint_def_selector);
1369         install_keyword("path_grouping_policy", &def_pgpolicy_handler, &snprint_def_pgpolicy);
1370         install_keyword("uid_attribute", &def_uid_attribute_handler, &snprint_def_uid_attribute);
1371         install_keyword("getuid_callout", &def_getuid_handler, &snprint_def_getuid);
1372         install_keyword("prio", &def_prio_name_handler, &snprint_def_prio_name);
1373         install_keyword("prio_args", &def_prio_args_handler, &snprint_def_prio_args);
1374         install_keyword("features", &def_features_handler, &snprint_def_features);
1375         install_keyword("path_checker", &def_checker_name_handler, &snprint_def_checker_name);
1376         install_keyword("checker", &def_checker_name_handler, NULL);
1377         install_keyword("alias_prefix", &def_alias_prefix_handler, &snprint_def_alias_prefix);
1378         install_keyword("failback", &def_pgfailback_handler, &snprint_def_pgfailback);
1379         install_keyword("rr_min_io", &def_minio_handler, &snprint_def_minio);
1380         install_keyword("rr_min_io_rq", &def_minio_rq_handler, &snprint_def_minio_rq);
1381         install_keyword("max_fds", &max_fds_handler, &snprint_max_fds);
1382         install_keyword("rr_weight", &def_rr_weight_handler, &snprint_def_rr_weight);
1383         install_keyword("no_path_retry", &def_no_path_retry_handler, &snprint_def_no_path_retry);
1384         install_keyword("queue_without_daemon", &def_queue_without_daemon_handler, &snprint_def_queue_without_daemon);
1385         install_keyword("checker_timeout", &def_checker_timeout_handler, &snprint_def_checker_timeout);
1386         install_keyword("pg_timeout", &deprecated_handler, &snprint_deprecated);
1387         install_keyword("flush_on_last_del", &def_flush_on_last_del_handler, &snprint_def_flush_on_last_del);
1388         install_keyword("user_friendly_names", &def_user_friendly_names_handler, &snprint_def_user_friendly_names);
1389         install_keyword("mode", &def_mode_handler, &snprint_def_mode);
1390         install_keyword("uid", &def_uid_handler, &snprint_def_uid);
1391         install_keyword("gid", &def_gid_handler, &snprint_def_gid);
1392         install_keyword("fast_io_fail_tmo", &def_fast_io_fail_handler, &snprint_def_fast_io_fail);
1393         install_keyword("dev_loss_tmo", &def_dev_loss_handler, &snprint_def_dev_loss);
1394         install_keyword("bindings_file", &def_bindings_file_handler, &snprint_def_bindings_file);
1395         install_keyword("wwids_file", &def_wwids_file_handler, &snprint_def_wwids_file);
1396         install_keyword("log_checker_err", &def_log_checker_err_handler, &snprint_def_log_checker_err);
1397         install_keyword("reservation_key", &def_reservation_key_handler, &snprint_def_reservation_key);
1398         install_keyword("retain_attached_hw_handler", &def_retain_hwhandler_handler, &snprint_def_retain_hwhandler);
1399         install_keyword("detect_prio", &def_detect_prio_handler, &snprint_def_detect_prio);
1400         install_keyword("force_sync", &def_force_sync_handler, &snprint_def_force_sync);
1401         install_keyword("strict_timing", &def_strict_timing_handler, &snprint_def_strict_timing);
1402         install_keyword("deferred_remove", &def_deferred_remove_handler, &snprint_def_deferred_remove);
1403         install_keyword("partition_delimiter", &def_partition_delim_handler, &snprint_def_partition_delim);
1404         install_keyword("config_dir", &def_config_dir_handler, &snprint_def_config_dir);
1405         install_keyword("delay_watch_checks", &def_delay_watch_checks_handler, &snprint_def_delay_watch_checks);
1406         install_keyword("delay_wait_checks", &def_delay_wait_checks_handler, &snprint_def_delay_wait_checks);
1407         install_keyword("find_multipaths", &def_find_multipaths_handler, &snprint_def_find_multipaths);
1408         install_keyword("uxsock_timeout", &def_uxsock_timeout_handler, &snprint_def_uxsock_timeout);
1409         install_keyword("retrigger_tries", &def_retrigger_tries_handler, &snprint_def_retrigger_tries);
1410         install_keyword("retrigger_delay", &def_retrigger_delay_handler, &snprint_def_retrigger_delay);
1411         install_keyword("missing_uev_wait_timeout", &def_uev_wait_timeout_handler, &snprint_def_uev_wait_timeout);
1412         install_keyword("skip_kpartx", &def_skip_kpartx_handler, &snprint_def_skip_kpartx);
1413         install_keyword("disable_changed_wwids", &def_disable_changed_wwids_handler, &snprint_def_disable_changed_wwids);
1414         install_keyword("remove_retries", &def_remove_retries_handler, &snprint_def_remove_retries);
1415         install_keyword("max_sectors_kb", &def_max_sectors_kb_handler, &snprint_def_max_sectors_kb);
1416         __deprecated install_keyword("default_selector", &def_selector_handler, NULL);
1417         __deprecated install_keyword("default_path_grouping_policy", &def_pgpolicy_handler, NULL);
1418         __deprecated install_keyword("default_uid_attribute", &def_uid_attribute_handler, NULL);
1419         __deprecated install_keyword("default_getuid_callout", &def_getuid_handler, NULL);
1420         __deprecated install_keyword("default_features", &def_features_handler, NULL);
1421         __deprecated install_keyword("default_path_checker", &def_checker_name_handler, NULL);
1422
1423         install_keyword_root("blacklist", &blacklist_handler);
1424         install_keyword_multi("devnode", &ble_blist_devnode_handler, &snprint_ble_simple);
1425         install_keyword_multi("wwid", &ble_blist_wwid_handler, &snprint_ble_simple);
1426         install_keyword_multi("property", &ble_blist_property_handler, &snprint_ble_simple);
1427         install_keyword_multi("device", &ble_device_handler, NULL);
1428         install_sublevel();
1429         install_keyword("vendor", &ble_blist_device_vendor_handler, &snprint_bled_vendor);
1430         install_keyword("product", &ble_blist_device_product_handler, &snprint_bled_product);
1431         install_sublevel_end();
1432         install_keyword_root("blacklist_exceptions", &blacklist_exceptions_handler);
1433         install_keyword_multi("devnode", &ble_elist_devnode_handler, &snprint_ble_simple);
1434         install_keyword_multi("wwid", &ble_elist_wwid_handler, &snprint_ble_simple);
1435         install_keyword_multi("property", &ble_elist_property_handler, &snprint_ble_simple);
1436         install_keyword_multi("device", &ble_except_device_handler, NULL);
1437         install_sublevel();
1438         install_keyword("vendor", &ble_elist_device_vendor_handler, &snprint_bled_vendor);
1439         install_keyword("product", &ble_elist_device_product_handler, &snprint_bled_product);
1440         install_sublevel_end();
1441
1442 #if 0
1443         __deprecated install_keyword_root("devnode_blacklist", &blacklist_handler);
1444         __deprecated install_keyword("devnode", &ble_devnode_handler, &snprint_ble_simple);
1445         __deprecated install_keyword("wwid", &ble_wwid_handler, &snprint_ble_simple);
1446         __deprecated install_keyword("device", &ble_device_handler, NULL);
1447         __deprecated install_sublevel();
1448         __deprecated install_keyword("vendor", &ble_vendor_handler, &snprint_bled_vendor);
1449         __deprecated install_keyword("product", &ble_product_handler, &snprint_bled_product);
1450         __deprecated install_sublevel_end();
1451 #endif
1452 /*
1453  * If you add or remove a "device subsection" keyword also update
1454  * multipath/multipath.conf.5 and the TEMPLATE in libmultipath/hwtable.c
1455  */
1456         install_keyword_root("devices", &devices_handler);
1457         install_keyword_multi("device", &device_handler, NULL);
1458         install_sublevel();
1459         install_keyword("vendor", &hw_vendor_handler, &snprint_hw_vendor);
1460         install_keyword("product", &hw_product_handler, &snprint_hw_product);
1461         install_keyword("revision", &hw_revision_handler, &snprint_hw_revision);
1462         install_keyword("product_blacklist", &hw_bl_product_handler, &snprint_hw_bl_product);
1463         install_keyword("path_grouping_policy", &hw_pgpolicy_handler, &snprint_hw_pgpolicy);
1464         install_keyword("uid_attribute", &hw_uid_attribute_handler, &snprint_hw_uid_attribute);
1465         install_keyword("getuid_callout", &hw_getuid_handler, &snprint_hw_getuid);
1466         install_keyword("path_selector", &hw_selector_handler, &snprint_hw_selector);
1467         install_keyword("path_checker", &hw_checker_name_handler, &snprint_hw_checker_name);
1468         install_keyword("checker", &hw_checker_name_handler, NULL);
1469         install_keyword("alias_prefix", &hw_alias_prefix_handler, &snprint_hw_alias_prefix);
1470         install_keyword("features", &hw_features_handler, &snprint_hw_features);
1471         install_keyword("hardware_handler", &hw_hwhandler_handler, &snprint_hw_hwhandler);
1472         install_keyword("prio", &hw_prio_name_handler, &snprint_hw_prio_name);
1473         install_keyword("prio_args", &hw_prio_args_handler, &snprint_hw_prio_args);
1474         install_keyword("failback", &hw_pgfailback_handler, &snprint_hw_pgfailback);
1475         install_keyword("rr_weight", &hw_rr_weight_handler, &snprint_hw_rr_weight);
1476         install_keyword("no_path_retry", &hw_no_path_retry_handler, &snprint_hw_no_path_retry);
1477         install_keyword("rr_min_io", &hw_minio_handler, &snprint_hw_minio);
1478         install_keyword("rr_min_io_rq", &hw_minio_rq_handler, &snprint_hw_minio_rq);
1479         install_keyword("pg_timeout", &deprecated_handler, &snprint_deprecated);
1480         install_keyword("flush_on_last_del", &hw_flush_on_last_del_handler, &snprint_hw_flush_on_last_del);
1481         install_keyword("fast_io_fail_tmo", &hw_fast_io_fail_handler, &snprint_hw_fast_io_fail);
1482         install_keyword("dev_loss_tmo", &hw_dev_loss_handler, &snprint_hw_dev_loss);
1483         install_keyword("user_friendly_names", &hw_user_friendly_names_handler, &snprint_hw_user_friendly_names);
1484         install_keyword("retain_attached_hw_handler", &hw_retain_hwhandler_handler, &snprint_hw_retain_hwhandler);
1485         install_keyword("detect_prio", &hw_detect_prio_handler, &snprint_hw_detect_prio);
1486         install_keyword("deferred_remove", &hw_deferred_remove_handler, &snprint_hw_deferred_remove);
1487         install_keyword("delay_watch_checks", &hw_delay_watch_checks_handler, &snprint_hw_delay_watch_checks);
1488         install_keyword("delay_wait_checks", &hw_delay_wait_checks_handler, &snprint_hw_delay_wait_checks);
1489         install_keyword("skip_kpartx", &hw_skip_kpartx_handler, &snprint_hw_skip_kpartx);
1490         install_keyword("max_sectors_kb", &hw_max_sectors_kb_handler, &snprint_hw_max_sectors_kb);
1491         install_sublevel_end();
1492
1493         install_keyword_root("overrides", &overrides_handler);
1494         install_keyword("path_grouping_policy", &ovr_pgpolicy_handler, &snprint_ovr_pgpolicy);
1495         install_keyword("uid_attribute", &ovr_uid_attribute_handler, &snprint_ovr_uid_attribute);
1496         install_keyword("getuid_callout", &ovr_getuid_handler, &snprint_ovr_getuid);
1497         install_keyword("path_selector", &ovr_selector_handler, &snprint_ovr_selector);
1498         install_keyword("path_checker", &ovr_checker_name_handler, &snprint_ovr_checker_name);
1499         install_keyword("checker", &ovr_checker_name_handler, NULL);
1500         install_keyword("alias_prefix", &ovr_alias_prefix_handler, &snprint_ovr_alias_prefix);
1501         install_keyword("features", &ovr_features_handler, &snprint_ovr_features);
1502         install_keyword("prio", &ovr_prio_name_handler, &snprint_ovr_prio_name);
1503         install_keyword("prio_args", &ovr_prio_args_handler, &snprint_ovr_prio_args);
1504         install_keyword("failback", &ovr_pgfailback_handler, &snprint_ovr_pgfailback);
1505         install_keyword("rr_weight", &ovr_rr_weight_handler, &snprint_ovr_rr_weight);
1506         install_keyword("no_path_retry", &ovr_no_path_retry_handler, &snprint_ovr_no_path_retry);
1507         install_keyword("rr_min_io", &ovr_minio_handler, &snprint_ovr_minio);
1508         install_keyword("rr_min_io_rq", &ovr_minio_rq_handler, &snprint_ovr_minio_rq);
1509         install_keyword("flush_on_last_del", &ovr_flush_on_last_del_handler, &snprint_ovr_flush_on_last_del);
1510         install_keyword("fast_io_fail_tmo", &ovr_fast_io_fail_handler, &snprint_ovr_fast_io_fail);
1511         install_keyword("dev_loss_tmo", &ovr_dev_loss_handler, &snprint_ovr_dev_loss);
1512         install_keyword("user_friendly_names", &ovr_user_friendly_names_handler, &snprint_ovr_user_friendly_names);
1513         install_keyword("retain_attached_hw_handler", &ovr_retain_hwhandler_handler, &snprint_ovr_retain_hwhandler);
1514         install_keyword("detect_prio", &ovr_detect_prio_handler, &snprint_ovr_detect_prio);
1515         install_keyword("deferred_remove", &ovr_deferred_remove_handler, &snprint_ovr_deferred_remove);
1516         install_keyword("delay_watch_checks", &ovr_delay_watch_checks_handler, &snprint_ovr_delay_watch_checks);
1517         install_keyword("delay_wait_checks", &ovr_delay_wait_checks_handler, &snprint_ovr_delay_wait_checks);
1518         install_keyword("skip_kpartx", &ovr_skip_kpartx_handler, &snprint_ovr_skip_kpartx);
1519         install_keyword("max_sectors_kb", &ovr_max_sectors_kb_handler, &snprint_ovr_max_sectors_kb);
1520
1521         install_keyword_root("multipaths", &multipaths_handler);
1522         install_keyword_multi("multipath", &multipath_handler, NULL);
1523         install_sublevel();
1524         install_keyword("wwid", &mp_wwid_handler, &snprint_mp_wwid);
1525         install_keyword("alias", &mp_alias_handler, &snprint_mp_alias);
1526         install_keyword("path_grouping_policy", &mp_pgpolicy_handler, &snprint_mp_pgpolicy);
1527         install_keyword("path_selector", &mp_selector_handler, &snprint_mp_selector);
1528         install_keyword("prio", &mp_prio_name_handler, &snprint_mp_prio_name);
1529         install_keyword("prio_args", &mp_prio_args_handler, &snprint_mp_prio_args);
1530         install_keyword("failback", &mp_pgfailback_handler, &snprint_mp_pgfailback);
1531         install_keyword("rr_weight", &mp_rr_weight_handler, &snprint_mp_rr_weight);
1532         install_keyword("no_path_retry", &mp_no_path_retry_handler, &snprint_mp_no_path_retry);
1533         install_keyword("rr_min_io", &mp_minio_handler, &snprint_mp_minio);
1534         install_keyword("rr_min_io_rq", &mp_minio_rq_handler, &snprint_mp_minio_rq);
1535         install_keyword("pg_timeout", &deprecated_handler, &snprint_deprecated);
1536         install_keyword("flush_on_last_del", &mp_flush_on_last_del_handler, &snprint_mp_flush_on_last_del);
1537         install_keyword("features", &mp_features_handler, &snprint_mp_features);
1538         install_keyword("mode", &mp_mode_handler, &snprint_mp_mode);
1539         install_keyword("uid", &mp_uid_handler, &snprint_mp_uid);
1540         install_keyword("gid", &mp_gid_handler, &snprint_mp_gid);
1541         install_keyword("reservation_key", &mp_reservation_key_handler, &snprint_mp_reservation_key);
1542         install_keyword("user_friendly_names", &mp_user_friendly_names_handler, &snprint_mp_user_friendly_names);
1543         install_keyword("deferred_remove", &mp_deferred_remove_handler, &snprint_mp_deferred_remove);
1544         install_keyword("delay_watch_checks", &mp_delay_watch_checks_handler, &snprint_mp_delay_watch_checks);
1545         install_keyword("delay_wait_checks", &mp_delay_wait_checks_handler, &snprint_mp_delay_wait_checks);
1546         install_keyword("skip_kpartx", &mp_skip_kpartx_handler, &snprint_mp_skip_kpartx);
1547         install_keyword("max_sectors_kb", &mp_max_sectors_kb_handler, &snprint_mp_max_sectors_kb);
1548         install_sublevel_end();
1549 }