This source file includes following definitions.
- mca_base_var_source_file
- mca_base_var_generate_full_name4
- compare_strings
- append_filename_to_list
- mca_base_var_init
- process_env_list
- mca_base_var_process_env_list
- mca_base_var_process_env_list_from_file
- resolve_relative_paths
- mca_base_var_cache_files
- mca_base_var_get_value
- var_set_string
- int_from_string
- var_set_from_string
- mca_base_var_set_value
- mca_base_var_deregister
- var_get
- mca_base_var_env_name
- var_find_by_name
- var_find
- mca_base_var_find
- mca_base_var_find_by_name
- mca_base_var_set_flag
- mca_base_var_get
- mca_base_var_build_env
- mca_base_var_finalize
- fixup_files
- read_files
- register_variable
- mca_base_var_register
- mca_base_component_var_register
- mca_base_framework_var_register
- mca_base_var_register_synonym
- var_get_env
- var_set_from_env
- var_set_from_file
- var_set_initial
- var_constructor
- var_destructor
- fv_constructor
- fv_destructor
- source_name
- var_value_string
- mca_base_var_check_exclusive
- mca_base_var_get_count
- mca_base_var_dump
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30 #include "opal_config.h"
31
32 #include <stdio.h>
33 #include <string.h>
34 #include <stdlib.h>
35 #ifdef HAVE_UNISTD_H
36 #include <unistd.h>
37 #endif
38 #ifdef HAVE_SYS_PARAM_H
39 #include <sys/param.h>
40 #endif
41 #include <errno.h>
42
43 #include "opal/include/opal_stdint.h"
44 #include "opal/mca/installdirs/installdirs.h"
45 #include "opal/util/os_path.h"
46 #include "opal/util/path.h"
47 #include "opal/util/show_help.h"
48 #include "opal/util/printf.h"
49 #include "opal/util/argv.h"
50 #include "opal/mca/mca.h"
51 #include "opal/mca/base/mca_base_vari.h"
52 #include "opal/constants.h"
53 #include "opal/util/output.h"
54 #include "opal/util/opal_environ.h"
55 #include "opal/runtime/opal.h"
56
57
58
59
60 static opal_pointer_array_t mca_base_vars;
61 static const char *mca_prefix = OPAL_MCA_PREFIX;
62 static char *home = NULL;
63 static char *cwd = NULL;
64 bool mca_base_var_initialized = false;
65 static char * force_agg_path = NULL;
66 static char *mca_base_var_files = NULL;
67 static char *mca_base_envar_files = NULL;
68 static char **mca_base_var_file_list = NULL;
69 static char *mca_base_var_override_file = NULL;
70 static char *mca_base_var_file_prefix = NULL;
71 static char *mca_base_envar_file_prefix = NULL;
72 static char *mca_base_param_file_path = NULL;
73 char *mca_base_env_list = NULL;
74 char *mca_base_env_list_sep = MCA_BASE_ENV_LIST_SEP_DEFAULT;
75 char *mca_base_env_list_internal = NULL;
76 static bool mca_base_var_suppress_override_warning = false;
77 static opal_list_t mca_base_var_file_values;
78 static opal_list_t mca_base_envar_file_values;
79 static opal_list_t mca_base_var_override_values;
80
81 static int mca_base_var_count = 0;
82
83 static opal_hash_table_t mca_base_var_index_hash;
84
85 const char *ompi_var_type_names[] = {
86 "int",
87 "unsigned_int",
88 "unsigned_long",
89 "unsigned_long_long",
90 "size_t",
91 "string",
92 "version_string",
93 "bool",
94 "double",
95 "long",
96 "int32_t",
97 "uint32_t",
98 "int64_t",
99 "uint64_t",
100 };
101
102 const size_t ompi_var_type_sizes[] = {
103 sizeof (int),
104 sizeof (unsigned),
105 sizeof (unsigned long),
106 sizeof (unsigned long long),
107 sizeof (size_t),
108 sizeof (char),
109 sizeof (char),
110 sizeof (bool),
111 sizeof (double),
112 sizeof (long),
113 sizeof (int32_t),
114 sizeof (uint32_t),
115 sizeof (int64_t),
116 sizeof (uint64_t),
117 };
118
119 static const char *var_source_names[] = {
120 "default",
121 "command line",
122 "environment",
123 "file",
124 "set",
125 "override"
126 };
127
128
129 static const char *info_lvl_strings[] = {
130 "user/basic",
131 "user/detail",
132 "user/all",
133 "tuner/basic",
134 "tuner/detail",
135 "tuner/all",
136 "dev/basic",
137 "dev/detail",
138 "dev/all"
139 };
140
141
142
143
144 static int fixup_files(char **file_list, char * path, bool rel_path_search, char sep);
145 static int read_files (char *file_list, opal_list_t *file_values, char sep);
146 static int var_set_initial (mca_base_var_t *var, mca_base_var_t *original);
147 static int var_get (int vari, mca_base_var_t **var_out, bool original);
148 static int var_value_string (mca_base_var_t *var, char **value_string);
149 static void mca_base_var_finalize (void);
150
151
152
153
154 static void var_constructor (mca_base_var_t *p);
155 static void var_destructor (mca_base_var_t *p);
156 OBJ_CLASS_INSTANCE(mca_base_var_t, opal_object_t,
157 var_constructor, var_destructor);
158
159 static void fv_constructor (mca_base_var_file_value_t *p);
160 static void fv_destructor (mca_base_var_file_value_t *p);
161 OBJ_CLASS_INSTANCE(mca_base_var_file_value_t, opal_list_item_t,
162 fv_constructor, fv_destructor);
163
164 static const char *mca_base_var_source_file (const mca_base_var_t *var)
165 {
166 mca_base_var_file_value_t *fv = (mca_base_var_file_value_t *) var->mbv_file_value;
167
168 if (NULL != var->mbv_source_file) {
169 return var->mbv_source_file;
170 }
171
172 if (fv) {
173 return fv->mbvfv_file;
174 }
175
176 return NULL;
177 }
178
179
180
181
182 int mca_base_var_generate_full_name4 (const char *project, const char *framework, const char *component,
183 const char *variable, char **full_name)
184 {
185 const char * const names[] = {project, framework, component, variable};
186 char *name, *tmp;
187 size_t i, len;
188
189 *full_name = NULL;
190
191 for (i = 0, len = 0 ; i < 4 ; ++i) {
192 if (NULL != names[i]) {
193
194 len += strlen (names[i]) + 1;
195 }
196 }
197
198 name = calloc (1, len);
199 if (NULL == name) {
200 return OPAL_ERR_OUT_OF_RESOURCE;
201 }
202
203 for (i = 0, tmp = name ; i < 4 ; ++i) {
204 if (NULL != names[i]) {
205 if (name != tmp) {
206 *tmp++ = '_';
207 }
208 strncat (name, names[i], len - (size_t)(uintptr_t)(tmp - name));
209 tmp += strlen (names[i]);
210 }
211 }
212
213 *full_name = name;
214 return OPAL_SUCCESS;
215 }
216
217 static int compare_strings (const char *str1, const char *str2) {
218 if ((NULL != str1 && 0 == strcmp (str1, "*")) ||
219 (NULL == str1 && NULL == str2)) {
220 return 0;
221 }
222
223 if (NULL != str1 && NULL != str2) {
224 return strcmp (str1, str2);
225 }
226
227 return 1;
228 }
229
230
231
232
233
234 static char *append_filename_to_list(const char *filename)
235 {
236 int i, count;
237
238 (void) opal_argv_append_unique_nosize(&mca_base_var_file_list, filename, false);
239
240 count = opal_argv_count(mca_base_var_file_list);
241
242 for (i = count - 1; i >= 0; --i) {
243 if (0 == strcmp (mca_base_var_file_list[i], filename)) {
244 return mca_base_var_file_list[i];
245 }
246 }
247
248
249 return NULL;
250 }
251
252
253
254
255 int mca_base_var_init(void)
256 {
257 int ret;
258
259 if (!mca_base_var_initialized) {
260
261
262 OBJ_CONSTRUCT(&mca_base_vars, opal_pointer_array_t);
263
264 ret = opal_pointer_array_init (&mca_base_vars, 128, 16384, 128);
265 if (OPAL_SUCCESS != ret) {
266 return ret;
267 }
268
269 mca_base_var_count = 0;
270
271
272
273 OBJ_CONSTRUCT(&mca_base_var_file_values, opal_list_t);
274 OBJ_CONSTRUCT(&mca_base_envar_file_values, opal_list_t);
275 OBJ_CONSTRUCT(&mca_base_var_override_values, opal_list_t);
276 OBJ_CONSTRUCT(&mca_base_var_index_hash, opal_hash_table_t);
277
278 ret = opal_hash_table_init (&mca_base_var_index_hash, 1024);
279 if (OPAL_SUCCESS != ret) {
280 return ret;
281 }
282
283 ret = mca_base_var_group_init ();
284 if (OPAL_SUCCESS != ret) {
285 return ret;
286 }
287
288 ret = mca_base_pvar_init ();
289 if (OPAL_SUCCESS != ret) {
290 return ret;
291 }
292
293
294
295 mca_base_var_initialized = true;
296
297 }
298
299 opal_finalize_register_cleanup (mca_base_var_finalize);
300
301 return OPAL_SUCCESS;
302 }
303
304 static void process_env_list(char *env_list, char ***argv, char sep)
305 {
306 char** tokens;
307 char *ptr, *value;
308
309 tokens = opal_argv_split(env_list, (int)sep);
310 if (NULL == tokens) {
311 return;
312 }
313
314 for (int i = 0 ; NULL != tokens[i] ; ++i) {
315 if (NULL == (ptr = strchr(tokens[i], '='))) {
316 value = getenv(tokens[i]);
317 if (NULL == value) {
318 opal_show_help("help-mca-var.txt", "incorrect-env-list-param",
319 true, tokens[i], env_list);
320 break;
321 }
322
323
324 value = strdup (value);
325 if (NULL == value) {
326
327 break;
328 }
329
330 if (NULL != (ptr = strchr(value, '='))) {
331 *ptr = '\0';
332 opal_setenv(value, ptr + 1, true, argv);
333 } else {
334 opal_setenv(tokens[i], value, true, argv);
335 }
336
337 free (value);
338 } else {
339 *ptr = '\0';
340 opal_setenv(tokens[i], ptr + 1, true, argv);
341
342 }
343 }
344
345 opal_argv_free(tokens);
346 }
347
348 int mca_base_var_process_env_list(char *list, char ***argv)
349 {
350 char sep;
351 sep = ';';
352 if (NULL != mca_base_env_list_sep) {
353 if (1 == strlen(mca_base_env_list_sep)) {
354 sep = mca_base_env_list_sep[0];
355 } else {
356 opal_show_help("help-mca-var.txt", "incorrect-env-list-sep",
357 true, mca_base_env_list_sep);
358 return OPAL_SUCCESS;
359 }
360 }
361 if (NULL != list) {
362 process_env_list(list, argv, sep);
363 } else if (NULL != mca_base_env_list) {
364 process_env_list(mca_base_env_list, argv, sep);
365 }
366
367 return OPAL_SUCCESS;
368 }
369
370 int mca_base_var_process_env_list_from_file(char ***argv)
371 {
372 if (NULL != mca_base_env_list_internal) {
373 process_env_list(mca_base_env_list_internal, argv, ';');
374 }
375 return OPAL_SUCCESS;
376 }
377
378 static void resolve_relative_paths(char **file_prefix, char *file_path, bool rel_path_search, char **files, char sep)
379 {
380 char *tmp_str;
381
382
383
384
385 if( OPAL_SUCCESS != fixup_files(file_prefix, file_path, rel_path_search, sep) ) {
386 #if 0
387
388 abort();
389 #else
390 ;
391 #endif
392 }
393 else {
394
395 opal_asprintf(&tmp_str, "%s%c%s", *file_prefix, sep, *files);
396 free (*files);
397 *files = tmp_str;
398 }
399 }
400
401 int mca_base_var_cache_files(bool rel_path_search)
402 {
403 char *tmp;
404 int ret;
405
406
407 home = (char*)opal_home_directory();
408
409 if (NULL == cwd) {
410 cwd = (char *) malloc(sizeof(char) * MAXPATHLEN);
411 if( NULL == (cwd = getcwd(cwd, MAXPATHLEN) )) {
412 opal_output(0, "Error: Unable to get the current working directory\n");
413 cwd = strdup(".");
414 }
415 }
416
417 #if OPAL_WANT_HOME_CONFIG_FILES
418 opal_asprintf(&mca_base_var_files, "%s"OPAL_PATH_SEP".openmpi" OPAL_PATH_SEP
419 "mca-params.conf%c%s" OPAL_PATH_SEP "openmpi-mca-params.conf",
420 home, ',', opal_install_dirs.sysconfdir);
421 #else
422 opal_asprintf(&mca_base_var_files, "%s" OPAL_PATH_SEP "openmpi-mca-params.conf",
423 opal_install_dirs.sysconfdir);
424 #endif
425
426
427
428 tmp = mca_base_var_files;
429 ret = mca_base_var_register ("opal", "mca", "base", "param_files", "Path for MCA "
430 "configuration files containing variable values",
431 MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0, OPAL_INFO_LVL_2,
432 MCA_BASE_VAR_SCOPE_READONLY, &mca_base_var_files);
433 free (tmp);
434 if (0 > ret) {
435 return ret;
436 }
437
438 mca_base_envar_files = strdup(mca_base_var_files);
439
440 (void) mca_base_var_register_synonym (ret, "opal", "mca", NULL, "param_files",
441 MCA_BASE_VAR_SYN_FLAG_DEPRECATED);
442
443 ret = opal_asprintf(&mca_base_var_override_file, "%s" OPAL_PATH_SEP "openmpi-mca-params-override.conf",
444 opal_install_dirs.sysconfdir);
445 if (0 > ret) {
446 return OPAL_ERR_OUT_OF_RESOURCE;
447 }
448
449 tmp = mca_base_var_override_file;
450 ret = mca_base_var_register ("opal", "mca", "base", "override_param_file",
451 "Variables set in this file will override any value set in"
452 "the environment or another configuration file",
453 MCA_BASE_VAR_TYPE_STRING, NULL, 0, MCA_BASE_VAR_FLAG_DEFAULT_ONLY,
454 OPAL_INFO_LVL_2, MCA_BASE_VAR_SCOPE_CONSTANT,
455 &mca_base_var_override_file);
456 free (tmp);
457 if (0 > ret) {
458 return ret;
459 }
460
461
462 if (0 == strcmp (mca_base_var_files, "none")) {
463 return OPAL_SUCCESS;
464 }
465
466 mca_base_var_suppress_override_warning = false;
467 ret = mca_base_var_register ("opal", "mca", "base", "suppress_override_warning",
468 "Suppress warnings when attempting to set an overridden value (default: false)",
469 MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0, OPAL_INFO_LVL_2,
470 MCA_BASE_VAR_SCOPE_LOCAL, &mca_base_var_suppress_override_warning);
471 if (0 > ret) {
472 return ret;
473 }
474
475
476
477
478
479 mca_base_var_file_prefix = NULL;
480 ret = mca_base_var_register ("opal", "mca", "base", "param_file_prefix",
481 "Aggregate MCA parameter file sets",
482 MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0, OPAL_INFO_LVL_3,
483 MCA_BASE_VAR_SCOPE_READONLY, &mca_base_var_file_prefix);
484 if (0 > ret) {
485 return ret;
486 }
487
488 mca_base_envar_file_prefix = NULL;
489 ret = mca_base_var_register ("opal", "mca", "base", "envar_file_prefix",
490 "Aggregate MCA parameter file set for env variables",
491 MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0, OPAL_INFO_LVL_3,
492 MCA_BASE_VAR_SCOPE_READONLY, &mca_base_envar_file_prefix);
493 if (0 > ret) {
494 return ret;
495 }
496
497 ret = opal_asprintf(&mca_base_param_file_path, "%s" OPAL_PATH_SEP "amca-param-sets%c%s",
498 opal_install_dirs.opaldatadir, OPAL_ENV_SEP, cwd);
499 if (0 > ret) {
500 return OPAL_ERR_OUT_OF_RESOURCE;
501 }
502
503 tmp = mca_base_param_file_path;
504 ret = mca_base_var_register ("opal", "mca", "base", "param_file_path",
505 "Aggregate MCA parameter Search path",
506 MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0, OPAL_INFO_LVL_3,
507 MCA_BASE_VAR_SCOPE_READONLY, &mca_base_param_file_path);
508 free (tmp);
509 if (0 > ret) {
510 return ret;
511 }
512
513 force_agg_path = NULL;
514 ret = mca_base_var_register ("opal", "mca", "base", "param_file_path_force",
515 "Forced Aggregate MCA parameter Search path",
516 MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0, OPAL_INFO_LVL_3,
517 MCA_BASE_VAR_SCOPE_READONLY, &force_agg_path);
518 if (0 > ret) {
519 return ret;
520 }
521
522 if (NULL != force_agg_path) {
523 if (NULL != mca_base_param_file_path) {
524 char *tmp_str = mca_base_param_file_path;
525
526 opal_asprintf(&mca_base_param_file_path, "%s%c%s", force_agg_path, OPAL_ENV_SEP, tmp_str);
527 free(tmp_str);
528 } else {
529 mca_base_param_file_path = strdup(force_agg_path);
530 }
531 }
532
533 if (NULL != mca_base_var_file_prefix) {
534 resolve_relative_paths(&mca_base_var_file_prefix, mca_base_param_file_path, rel_path_search, &mca_base_var_files, OPAL_ENV_SEP);
535 }
536 read_files (mca_base_var_files, &mca_base_var_file_values, ',');
537
538 if (NULL != mca_base_envar_file_prefix) {
539 resolve_relative_paths(&mca_base_envar_file_prefix, mca_base_param_file_path, rel_path_search, &mca_base_envar_files, ',');
540 }
541 read_files (mca_base_envar_files, &mca_base_envar_file_values, ',');
542
543 if (0 == access(mca_base_var_override_file, F_OK)) {
544 read_files (mca_base_var_override_file, &mca_base_var_override_values, OPAL_ENV_SEP);
545 }
546
547 return OPAL_SUCCESS;
548 }
549
550
551
552
553 int mca_base_var_get_value (int vari, const void *value,
554 mca_base_var_source_t *source,
555 const char **source_file)
556 {
557 mca_base_var_t *var;
558 void **tmp = (void **) value;
559 int ret;
560
561 ret = var_get (vari, &var, true);
562 if (OPAL_SUCCESS != ret) {
563 return ret;
564 }
565
566 if (!VAR_IS_VALID(var[0])) {
567 return OPAL_ERR_NOT_FOUND;
568 }
569
570 if (NULL != value) {
571
572
573 *tmp = var->mbv_storage;
574 }
575
576 if (NULL != source) {
577 *source = var->mbv_source;
578 }
579
580 if (NULL != source_file) {
581 *source_file = mca_base_var_source_file (var);
582 }
583
584 return OPAL_SUCCESS;
585 }
586
587 static int var_set_string (mca_base_var_t *var, char *value)
588 {
589 char *tmp;
590 int ret;
591
592 if (NULL != var->mbv_storage->stringval) {
593 free (var->mbv_storage->stringval);
594 }
595
596 var->mbv_storage->stringval = NULL;
597
598 if (NULL == value || 0 == strlen (value)) {
599 return OPAL_SUCCESS;
600 }
601
602
603
604
605 if (0 == strncmp (value, "~/", 2)) {
606 if (NULL != home) {
607 ret = opal_asprintf (&value, "%s/%s", home, value + 2);
608 if (0 > ret) {
609 return OPAL_ERROR;
610 }
611 } else {
612 value = strdup (value + 2);
613 }
614 } else {
615 value = strdup (value);
616 }
617
618 if (NULL == value) {
619 return OPAL_ERR_OUT_OF_RESOURCE;
620 }
621
622 while (NULL != (tmp = strstr (value, ":~/"))) {
623 tmp[0] = '\0';
624 tmp += 3;
625
626 ret = opal_asprintf (&tmp, "%s:%s%s%s", value,
627 home ? home : "", home ? "/" : "", tmp);
628
629 free (value);
630
631 if (0 > ret) {
632 return OPAL_ERR_OUT_OF_RESOURCE;
633 }
634
635 value = tmp;
636 }
637
638 var->mbv_storage->stringval = value;
639
640 return OPAL_SUCCESS;
641 }
642
643 static int int_from_string(const char *src, mca_base_var_enum_t *enumerator, uint64_t *value_out)
644 {
645 uint64_t value;
646 bool is_int;
647 char *tmp;
648
649 if (NULL == src || 0 == strlen (src)) {
650 if (NULL == enumerator) {
651 *value_out = 0;
652 }
653
654 return OPAL_SUCCESS;
655 }
656
657 if (enumerator) {
658 int int_val, ret;
659 ret = enumerator->value_from_string(enumerator, src, &int_val);
660 if (OPAL_SUCCESS != ret) {
661 return ret;
662 }
663 *value_out = (uint64_t) int_val;
664
665 return OPAL_SUCCESS;
666 }
667
668
669 value = strtoull (src, &tmp, 0);
670 is_int = tmp[0] == '\0';
671
672 if (!is_int && tmp != src) {
673 switch (tmp[0]) {
674 case 'G':
675 case 'g':
676 value <<= 10;
677 case 'M':
678 case 'm':
679 value <<= 10;
680 case 'K':
681 case 'k':
682 value <<= 10;
683 break;
684 default:
685 break;
686 }
687 }
688
689 *value_out = value;
690
691 return OPAL_SUCCESS;
692 }
693
694 static int var_set_from_string (mca_base_var_t *var, char *src)
695 {
696 mca_base_var_storage_t *dst = var->mbv_storage;
697 uint64_t int_value = 0;
698 int ret;
699
700 switch (var->mbv_type) {
701 case MCA_BASE_VAR_TYPE_INT:
702 case MCA_BASE_VAR_TYPE_INT32_T:
703 case MCA_BASE_VAR_TYPE_UINT32_T:
704 case MCA_BASE_VAR_TYPE_LONG:
705 case MCA_BASE_VAR_TYPE_UNSIGNED_INT:
706 case MCA_BASE_VAR_TYPE_UNSIGNED_LONG:
707 case MCA_BASE_VAR_TYPE_INT64_T:
708 case MCA_BASE_VAR_TYPE_UINT64_T:
709 case MCA_BASE_VAR_TYPE_UNSIGNED_LONG_LONG:
710 case MCA_BASE_VAR_TYPE_BOOL:
711 case MCA_BASE_VAR_TYPE_SIZE_T:
712 ret = int_from_string(src, var->mbv_enumerator, &int_value);
713 if (OPAL_SUCCESS != ret ||
714 (MCA_BASE_VAR_TYPE_INT == var->mbv_type && ((int) int_value != (int64_t) int_value)) ||
715 (MCA_BASE_VAR_TYPE_UNSIGNED_INT == var->mbv_type && ((unsigned int) int_value != int_value))) {
716 if (var->mbv_enumerator) {
717 char *valid_values;
718 (void) var->mbv_enumerator->dump(var->mbv_enumerator, &valid_values);
719 opal_show_help("help-mca-var.txt", "invalid-value-enum",
720 true, var->mbv_full_name, src, valid_values);
721 free(valid_values);
722 } else {
723 opal_show_help("help-mca-var.txt", "invalid-value",
724 true, var->mbv_full_name, src);
725 }
726
727 return OPAL_ERR_VALUE_OUT_OF_BOUNDS;
728 }
729
730 if (MCA_BASE_VAR_TYPE_INT == var->mbv_type ||
731 MCA_BASE_VAR_TYPE_UNSIGNED_INT == var->mbv_type) {
732 int *castme = (int*) var->mbv_storage;
733 *castme = int_value;
734 } else if (MCA_BASE_VAR_TYPE_INT32_T == var->mbv_type ||
735 MCA_BASE_VAR_TYPE_UINT32_T == var->mbv_type) {
736 int32_t *castme = (int32_t *) var->mbv_storage;
737 *castme = int_value;
738 } else if (MCA_BASE_VAR_TYPE_INT64_T == var->mbv_type ||
739 MCA_BASE_VAR_TYPE_UINT64_T == var->mbv_type) {
740 int64_t *castme = (int64_t *) var->mbv_storage;
741 *castme = int_value;
742 } else if (MCA_BASE_VAR_TYPE_LONG == var->mbv_type) {
743 long *castme = (long*) var->mbv_storage;
744 *castme = (long) int_value;
745 } else if (MCA_BASE_VAR_TYPE_UNSIGNED_LONG == var->mbv_type) {
746 unsigned long *castme = (unsigned long*) var->mbv_storage;
747 *castme = (unsigned long) int_value;
748 } else if (MCA_BASE_VAR_TYPE_UNSIGNED_LONG_LONG == var->mbv_type) {
749 unsigned long long *castme = (unsigned long long*) var->mbv_storage;
750 *castme = (unsigned long long) int_value;
751 } else if (MCA_BASE_VAR_TYPE_SIZE_T == var->mbv_type) {
752 size_t *castme = (size_t*) var->mbv_storage;
753 *castme = (size_t) int_value;
754 } else if (MCA_BASE_VAR_TYPE_BOOL == var->mbv_type) {
755 bool *castme = (bool*) var->mbv_storage;
756 *castme = !!int_value;
757 }
758
759 return ret;
760 case MCA_BASE_VAR_TYPE_DOUBLE:
761 dst->lfval = strtod (src, NULL);
762 break;
763 case MCA_BASE_VAR_TYPE_STRING:
764 case MCA_BASE_VAR_TYPE_VERSION_STRING:
765 var_set_string (var, src);
766 break;
767 case MCA_BASE_VAR_TYPE_MAX:
768 return OPAL_ERROR;
769 }
770
771 return OPAL_SUCCESS;
772 }
773
774
775
776
777 int mca_base_var_set_value (int vari, const void *value, size_t size, mca_base_var_source_t source,
778 const char *source_file)
779 {
780 mca_base_var_t *var;
781 int ret;
782
783 ret = var_get (vari, &var, true);
784 if (OPAL_SUCCESS != ret) {
785 return ret;
786 }
787
788 if (!VAR_IS_VALID(var[0])) {
789 return OPAL_ERR_BAD_PARAM;
790 }
791
792 if (!VAR_IS_SETTABLE(var[0])) {
793 return OPAL_ERR_PERM;
794 }
795
796 if (NULL != var->mbv_enumerator) {
797
798 ret = var->mbv_enumerator->string_from_value(var->mbv_enumerator,
799 ((int *) value)[0], NULL);
800 if (OPAL_SUCCESS != ret) {
801 return ret;
802 }
803 }
804
805 if (MCA_BASE_VAR_TYPE_STRING != var->mbv_type && MCA_BASE_VAR_TYPE_VERSION_STRING != var->mbv_type) {
806 memmove (var->mbv_storage, value, ompi_var_type_sizes[var->mbv_type]);
807 } else {
808 var_set_string (var, (char *) value);
809 }
810
811 var->mbv_source = source;
812
813 if (MCA_BASE_VAR_SOURCE_FILE == source && NULL != source_file) {
814 var->mbv_file_value = NULL;
815 var->mbv_source_file = append_filename_to_list(source_file);
816 }
817
818 return OPAL_SUCCESS;
819 }
820
821
822
823
824 int mca_base_var_deregister(int vari)
825 {
826 mca_base_var_t *var;
827 int ret;
828
829 ret = var_get (vari, &var, false);
830 if (OPAL_SUCCESS != ret) {
831 return ret;
832 }
833
834 if (!VAR_IS_VALID(var[0])) {
835 return OPAL_ERR_BAD_PARAM;
836 }
837
838
839
840 var->mbv_flags &= ~MCA_BASE_VAR_FLAG_VALID;
841
842
843 if (MCA_BASE_VAR_FLAG_SYNONYM & var->mbv_flags) {
844 return OPAL_SUCCESS;
845 }
846
847
848 if ((MCA_BASE_VAR_TYPE_STRING == var->mbv_type || MCA_BASE_VAR_TYPE_VERSION_STRING == var->mbv_type) &&
849 var->mbv_storage->stringval) {
850 free (var->mbv_storage->stringval);
851 var->mbv_storage->stringval = NULL;
852 } else if (var->mbv_enumerator && !var->mbv_enumerator->enum_is_static) {
853 OBJ_RELEASE(var->mbv_enumerator);
854 }
855
856 var->mbv_enumerator = NULL;
857
858 var->mbv_storage = NULL;
859
860 return OPAL_SUCCESS;
861 }
862
863 static int var_get (int vari, mca_base_var_t **var_out, bool original)
864 {
865 mca_base_var_t *var;
866
867 if (var_out) {
868 *var_out = NULL;
869 }
870
871
872 if (!mca_base_var_initialized) {
873 return OPAL_ERROR;
874 }
875
876 if (vari < 0) {
877 return OPAL_ERR_BAD_PARAM;
878 }
879
880 var = opal_pointer_array_get_item (&mca_base_vars, vari);
881 if (NULL == var) {
882 return OPAL_ERR_BAD_PARAM;
883 }
884
885 if (VAR_IS_SYNONYM(var[0]) && original) {
886 return var_get(var->mbv_synonym_for, var_out, false);
887 }
888
889 if (var_out) {
890 *var_out = var;
891 }
892
893 return OPAL_SUCCESS;
894 }
895
896 int mca_base_var_env_name(const char *param_name,
897 char **env_name)
898 {
899 int ret;
900
901 assert (NULL != env_name);
902
903 ret = opal_asprintf(env_name, "%s%s", mca_prefix, param_name);
904 if (0 > ret) {
905 return OPAL_ERR_OUT_OF_RESOURCE;
906 }
907
908 return OPAL_SUCCESS;
909 }
910
911
912
913
914 static int var_find_by_name (const char *full_name, int *vari, bool invalidok)
915 {
916 mca_base_var_t *var = NULL;
917 void *tmp;
918 int rc;
919
920 rc = opal_hash_table_get_value_ptr (&mca_base_var_index_hash, full_name, strlen (full_name),
921 &tmp);
922 if (OPAL_SUCCESS != rc) {
923 return rc;
924 }
925
926 (void) var_get ((int)(uintptr_t) tmp, &var, false);
927
928 if (invalidok || (var && VAR_IS_VALID(var[0]))) {
929 *vari = (int)(uintptr_t) tmp;
930 return OPAL_SUCCESS;
931 }
932
933 return OPAL_ERR_NOT_FOUND;
934 }
935
936 static int var_find (const char *project_name, const char *framework_name,
937 const char *component_name, const char *variable_name,
938 bool invalidok)
939 {
940 char *full_name;
941 int ret, vari;
942
943 ret = mca_base_var_generate_full_name4 (NULL, framework_name, component_name,
944 variable_name, &full_name);
945 if (OPAL_SUCCESS != ret) {
946 return OPAL_ERROR;
947 }
948
949 ret = var_find_by_name(full_name, &vari, invalidok);
950
951
952
953 free (full_name);
954
955 if (OPAL_SUCCESS != ret) {
956 return ret;
957 }
958
959 return vari;
960 }
961
962
963
964
965 int mca_base_var_find (const char *project_name, const char *framework_name,
966 const char *component_name, const char *variable_name)
967 {
968 return var_find (project_name, framework_name, component_name, variable_name, false);
969 }
970
971
972
973
974 int mca_base_var_find_by_name (const char *full_name, int *vari)
975 {
976 return var_find_by_name (full_name, vari, false);
977 }
978
979 int mca_base_var_set_flag (int vari, mca_base_var_flag_t flag, bool set)
980 {
981 mca_base_var_t *var;
982 int ret;
983
984 ret = var_get (vari, &var, true);
985 if (OPAL_SUCCESS != ret || VAR_IS_SYNONYM(var[0])) {
986 return OPAL_ERR_BAD_PARAM;
987 }
988
989 var->mbv_flags = (var->mbv_flags & ~flag) | (set ? flag : 0);
990
991
992 return OPAL_SUCCESS;
993 }
994
995
996
997
998 int mca_base_var_get (int vari, const mca_base_var_t **var)
999 {
1000 int ret;
1001 ret = var_get (vari, (mca_base_var_t **) var, false);
1002
1003 if (OPAL_SUCCESS != ret) {
1004 return ret;
1005 }
1006
1007 if (!VAR_IS_VALID(*(var[0]))) {
1008 return OPAL_ERR_NOT_FOUND;
1009 }
1010
1011 return OPAL_SUCCESS;
1012 }
1013
1014
1015
1016
1017 int mca_base_var_build_env(char ***env, int *num_env, bool internal)
1018 {
1019 mca_base_var_t *var;
1020 size_t i, len;
1021 int ret;
1022
1023
1024
1025 if (!mca_base_var_initialized) {
1026 return OPAL_ERROR;
1027 }
1028
1029
1030
1031 len = opal_pointer_array_get_size(&mca_base_vars);
1032 for (i = 0; i < len; ++i) {
1033 char *value_string;
1034 char *str = NULL;
1035
1036 var = opal_pointer_array_get_item (&mca_base_vars, i);
1037 if (NULL == var) {
1038 continue;
1039 }
1040
1041
1042
1043 if (MCA_BASE_VAR_SOURCE_DEFAULT == var->mbv_source ||
1044 (!internal && VAR_IS_INTERNAL(var[0]))) {
1045 continue;
1046 }
1047
1048 if ((MCA_BASE_VAR_TYPE_STRING == var->mbv_type || MCA_BASE_VAR_TYPE_VERSION_STRING == var->mbv_type) &&
1049 NULL == var->mbv_storage->stringval) {
1050 continue;
1051 }
1052
1053 ret = var_value_string (var, &value_string);
1054 if (OPAL_SUCCESS != ret) {
1055 goto cleanup;
1056 }
1057
1058 ret = opal_asprintf (&str, "%s%s=%s", mca_prefix, var->mbv_full_name,
1059 value_string);
1060 free (value_string);
1061 if (0 > ret) {
1062 goto cleanup;
1063 }
1064
1065 opal_argv_append(num_env, env, str);
1066 free(str);
1067
1068 switch (var->mbv_source) {
1069 case MCA_BASE_VAR_SOURCE_FILE:
1070 case MCA_BASE_VAR_SOURCE_OVERRIDE:
1071 opal_asprintf (&str, "%sSOURCE_%s=FILE:%s", mca_prefix, var->mbv_full_name,
1072 mca_base_var_source_file (var));
1073 break;
1074 case MCA_BASE_VAR_SOURCE_COMMAND_LINE:
1075 opal_asprintf (&str, "%sSOURCE_%s=COMMAND_LINE", mca_prefix, var->mbv_full_name);
1076 break;
1077 case MCA_BASE_VAR_SOURCE_ENV:
1078 case MCA_BASE_VAR_SOURCE_SET:
1079 case MCA_BASE_VAR_SOURCE_DEFAULT:
1080 str = NULL;
1081 break;
1082 case MCA_BASE_VAR_SOURCE_MAX:
1083 goto cleanup;
1084 }
1085
1086 if (NULL != str) {
1087 opal_argv_append(num_env, env, str);
1088 free(str);
1089 }
1090 }
1091
1092
1093
1094 return OPAL_SUCCESS;
1095
1096
1097
1098 cleanup:
1099 if (*num_env > 0) {
1100 opal_argv_free(*env);
1101 *num_env = 0;
1102 *env = NULL;
1103 }
1104 return OPAL_ERR_NOT_FOUND;
1105 }
1106
1107
1108
1109
1110
1111 static void mca_base_var_finalize (void)
1112 {
1113 opal_object_t *object;
1114 opal_list_item_t *item;
1115 int size, i;
1116
1117 if (mca_base_var_initialized) {
1118 size = opal_pointer_array_get_size(&mca_base_vars);
1119 for (i = 0 ; i < size ; ++i) {
1120 object = opal_pointer_array_get_item (&mca_base_vars, i);
1121 if (NULL != object) {
1122 OBJ_RELEASE(object);
1123 }
1124 }
1125 OBJ_DESTRUCT(&mca_base_vars);
1126
1127 while (NULL !=
1128 (item = opal_list_remove_first(&mca_base_var_file_values))) {
1129 OBJ_RELEASE(item);
1130 }
1131 OBJ_DESTRUCT(&mca_base_var_file_values);
1132
1133 while (NULL !=
1134 (item = opal_list_remove_first(&mca_base_envar_file_values))) {
1135 OBJ_RELEASE(item);
1136 }
1137 OBJ_DESTRUCT(&mca_base_envar_file_values);
1138
1139 while (NULL !=
1140 (item = opal_list_remove_first(&mca_base_var_override_values))) {
1141 OBJ_RELEASE(item);
1142 }
1143 OBJ_DESTRUCT(&mca_base_var_override_values);
1144
1145 if( NULL != cwd ) {
1146 free(cwd);
1147 cwd = NULL;
1148 }
1149
1150 mca_base_var_initialized = false;
1151 mca_base_var_count = 0;
1152
1153 if (NULL != mca_base_var_file_list) {
1154 opal_argv_free(mca_base_var_file_list);
1155 }
1156 mca_base_var_file_list = NULL;
1157
1158 (void) mca_base_var_group_finalize ();
1159 (void) mca_base_pvar_finalize ();
1160
1161 OBJ_DESTRUCT(&mca_base_var_index_hash);
1162
1163 free (mca_base_envar_files);
1164 mca_base_envar_files = NULL;
1165 }
1166 }
1167
1168
1169
1170 static int fixup_files(char **file_list, char * path, bool rel_path_search, char sep) {
1171 int exit_status = OPAL_SUCCESS;
1172 char **files = NULL;
1173 char **search_path = NULL;
1174 char * tmp_file = NULL;
1175 char **argv = NULL;
1176 char *rel_path;
1177 int mode = R_OK;
1178 int count, i, argc = 0;
1179
1180 search_path = opal_argv_split(path, OPAL_ENV_SEP);
1181 files = opal_argv_split(*file_list, sep);
1182 count = opal_argv_count(files);
1183
1184 rel_path = force_agg_path ? force_agg_path : cwd;
1185
1186
1187 for (i = 0 ; i < count; ++i) {
1188 char *msg_path = path;
1189 if (opal_path_is_absolute(files[i])) {
1190
1191 tmp_file = opal_path_access(files[i], NULL, mode);
1192 } else if (!rel_path_search && NULL != strchr(files[i], OPAL_PATH_SEP[0])) {
1193
1194
1195
1196
1197
1198
1199 msg_path = rel_path;
1200 tmp_file = opal_path_access(files[i], rel_path, mode);
1201 } else {
1202
1203
1204
1205
1206
1207 tmp_file = opal_path_find (files[i], search_path, mode, NULL);
1208 }
1209
1210 if (NULL == tmp_file) {
1211 opal_show_help("help-mca-var.txt", "missing-param-file",
1212 true, getpid(), files[i], msg_path);
1213 exit_status = OPAL_ERROR;
1214 break;
1215 }
1216
1217 opal_argv_append(&argc, &argv, tmp_file);
1218
1219 free(tmp_file);
1220 tmp_file = NULL;
1221 }
1222
1223 if (OPAL_SUCCESS == exit_status) {
1224 free(*file_list);
1225 *file_list = opal_argv_join(argv, sep);
1226 }
1227
1228 if( NULL != files ) {
1229 opal_argv_free(files);
1230 files = NULL;
1231 }
1232
1233 if( NULL != argv ) {
1234 opal_argv_free(argv);
1235 argv = NULL;
1236 }
1237
1238 if( NULL != search_path ) {
1239 opal_argv_free(search_path);
1240 search_path = NULL;
1241 }
1242
1243 return exit_status;
1244 }
1245
1246 static int read_files(char *file_list, opal_list_t *file_values, char sep)
1247 {
1248 char **tmp = opal_argv_split(file_list, sep);
1249 int i, count;
1250
1251 if (!tmp) {
1252 return OPAL_ERR_OUT_OF_RESOURCE;
1253 }
1254
1255 count = opal_argv_count(tmp);
1256
1257
1258
1259
1260
1261 for (i = count - 1; i >= 0; --i) {
1262 char *file_name = append_filename_to_list (tmp[i]);
1263 mca_base_parse_paramfile(file_name, file_values);
1264 }
1265
1266 opal_argv_free (tmp);
1267
1268 mca_base_internal_env_store();
1269
1270 return OPAL_SUCCESS;
1271 }
1272
1273
1274 static int register_variable (const char *project_name, const char *framework_name,
1275 const char *component_name, const char *variable_name,
1276 const char *description, mca_base_var_type_t type,
1277 mca_base_var_enum_t *enumerator, int bind,
1278 mca_base_var_flag_t flags, mca_base_var_info_lvl_t info_lvl,
1279 mca_base_var_scope_t scope, int synonym_for,
1280 void *storage)
1281 {
1282 int ret, var_index, group_index, tmp;
1283 mca_base_var_group_t *group;
1284 mca_base_var_t *var, *original = NULL;
1285
1286
1287 assert (((flags & MCA_BASE_VAR_FLAG_SYNONYM) || NULL != storage) && type >= 0 && type < MCA_BASE_VAR_TYPE_MAX);
1288
1289
1290 if (NULL != project_name &&
1291 strlen(project_name) > MCA_BASE_MAX_PROJECT_NAME_LEN) {
1292 return OPAL_ERR_BAD_PARAM;
1293 }
1294 if (NULL != framework_name &&
1295 strlen(framework_name) > MCA_BASE_MAX_TYPE_NAME_LEN) {
1296 return OPAL_ERR_BAD_PARAM;
1297 }
1298 if (NULL != component_name &&
1299 strlen(component_name) > MCA_BASE_MAX_COMPONENT_NAME_LEN) {
1300 return OPAL_ERR_BAD_PARAM;
1301 }
1302 if (NULL != variable_name &&
1303 strlen(variable_name) > MCA_BASE_MAX_VARIABLE_NAME_LEN) {
1304 return OPAL_ERR_BAD_PARAM;
1305 }
1306
1307 #if OPAL_ENABLE_DEBUG
1308
1309 uintptr_t align = 0;
1310 switch (type) {
1311 case MCA_BASE_VAR_TYPE_INT:
1312 case MCA_BASE_VAR_TYPE_UNSIGNED_INT:
1313 align = OPAL_ALIGNMENT_INT;
1314 break;
1315 case MCA_BASE_VAR_TYPE_INT32_T:
1316 case MCA_BASE_VAR_TYPE_UINT32_T:
1317 align = OPAL_ALIGNMENT_INT32;
1318 break;
1319 case MCA_BASE_VAR_TYPE_INT64_T:
1320 case MCA_BASE_VAR_TYPE_UINT64_T:
1321 align = OPAL_ALIGNMENT_INT64;
1322 break;
1323 case MCA_BASE_VAR_TYPE_LONG:
1324 case MCA_BASE_VAR_TYPE_UNSIGNED_LONG:
1325 align = OPAL_ALIGNMENT_LONG;
1326 break;
1327 case MCA_BASE_VAR_TYPE_UNSIGNED_LONG_LONG:
1328 align = OPAL_ALIGNMENT_LONG_LONG;
1329 break;
1330 case MCA_BASE_VAR_TYPE_SIZE_T:
1331 align = OPAL_ALIGNMENT_SIZE_T;
1332 break;
1333 case MCA_BASE_VAR_TYPE_BOOL:
1334 align = OPAL_ALIGNMENT_BOOL;
1335 break;
1336 case MCA_BASE_VAR_TYPE_DOUBLE:
1337 align = OPAL_ALIGNMENT_DOUBLE;
1338 break;
1339 case MCA_BASE_VAR_TYPE_VERSION_STRING:
1340 case MCA_BASE_VAR_TYPE_STRING:
1341 default:
1342 align = 0;
1343 break;
1344 }
1345
1346 if (0 != align) {
1347 assert(((uintptr_t) storage) % align == 0);
1348 }
1349
1350
1351
1352 if (flags & MCA_BASE_VAR_FLAG_SYNONYM && synonym_for < 0) {
1353 assert((flags & MCA_BASE_VAR_FLAG_SYNONYM) && synonym_for >= 0);
1354 }
1355 #endif
1356
1357 if (flags & MCA_BASE_VAR_FLAG_SYNONYM) {
1358 original = opal_pointer_array_get_item (&mca_base_vars, synonym_for);
1359 if (NULL == original) {
1360
1361
1362 assert (NULL != original);
1363 return OPAL_ERR_NOT_FOUND;
1364 }
1365 }
1366
1367
1368 OPAL_DEBUG_ZERO(var);
1369
1370
1371 if (!mca_base_var_initialized) {
1372 mca_base_var_init();
1373 }
1374
1375
1376 var_index = var_find (project_name, framework_name, component_name, variable_name,
1377 true);
1378
1379 if (0 > var_index) {
1380
1381 group_index = mca_base_var_group_register (project_name, framework_name, component_name,
1382 NULL);
1383 if (-1 > group_index) {
1384 return group_index;
1385 }
1386
1387
1388 if (scope < MCA_BASE_VAR_SCOPE_LOCAL || (flags & MCA_BASE_VAR_FLAG_DEFAULT_ONLY)) {
1389 if ((flags & MCA_BASE_VAR_FLAG_DEFAULT_ONLY) && (flags & MCA_BASE_VAR_FLAG_SETTABLE)) {
1390 opal_show_help("help-mca-var.txt", "invalid-flag-combination",
1391 true, "MCA_BASE_VAR_FLAG_DEFAULT_ONLY", "MCA_BASE_VAR_FLAG_SETTABLE");
1392 return OPAL_ERROR;
1393 }
1394
1395
1396 flags &= ~MCA_BASE_VAR_FLAG_SETTABLE;
1397 }
1398
1399 var = OBJ_NEW(mca_base_var_t);
1400
1401 var->mbv_type = type;
1402 var->mbv_flags = flags;
1403 var->mbv_group_index = group_index;
1404 var->mbv_info_lvl = info_lvl;
1405 var->mbv_scope = scope;
1406 var->mbv_synonym_for = synonym_for;
1407 var->mbv_bind = bind;
1408
1409 if (NULL != description) {
1410 var->mbv_description = strdup(description);
1411 }
1412
1413 ret = mca_base_var_generate_full_name4 (project_name, framework_name, component_name,
1414 variable_name, &var->mbv_long_name);
1415 if (OPAL_SUCCESS != ret) {
1416 OBJ_RELEASE(var);
1417 return OPAL_ERROR;
1418 }
1419
1420
1421
1422
1423 var->mbv_full_name = var->mbv_long_name +
1424 (NULL == project_name ? 0 : (strlen(project_name)+1));
1425 if( NULL != variable_name ) {
1426 var->mbv_variable_name = var->mbv_full_name +
1427 (NULL == framework_name ? 0 : (strlen(framework_name)+1)) +
1428 (NULL == component_name ? 0 : (strlen(component_name)+1));
1429 }
1430
1431
1432
1433
1434
1435 var_index = opal_pointer_array_add (&mca_base_vars, var);
1436 if (0 > var_index) {
1437 OBJ_RELEASE(var);
1438 return OPAL_ERROR;
1439 }
1440
1441 var->mbv_index = var_index;
1442
1443 if (0 <= group_index) {
1444 mca_base_var_group_add_var (group_index, var_index);
1445 }
1446
1447 mca_base_var_count++;
1448 if (0 <= var_find_by_name (var->mbv_full_name, &tmp, 0)) {
1449
1450 assert (0);
1451 }
1452
1453 opal_hash_table_set_value_ptr (&mca_base_var_index_hash, var->mbv_full_name, strlen (var->mbv_full_name),
1454 (void *)(uintptr_t) var_index);
1455 } else {
1456 ret = var_get (var_index, &var, false);
1457 if (OPAL_SUCCESS != ret) {
1458
1459 return OPAL_ERROR;
1460 }
1461
1462 ret = mca_base_var_group_get_internal (var->mbv_group_index, &group, true);
1463 if (OPAL_SUCCESS != ret) {
1464
1465 return OPAL_ERROR;
1466 }
1467
1468 if (!group->group_isvalid) {
1469 group->group_isvalid = true;
1470 }
1471
1472
1473 if (0 != compare_strings(framework_name, group->group_framework) ||
1474 0 != compare_strings(component_name, group->group_component) ||
1475 0 != compare_strings(variable_name, var->mbv_variable_name)) {
1476 opal_show_help("help-mca-var.txt", "var-name-conflict",
1477 true, var->mbv_full_name, framework_name,
1478 component_name, variable_name,
1479 group->group_framework, group->group_component,
1480 var->mbv_variable_name);
1481
1482 assert (0);
1483 return OPAL_ERROR;
1484 }
1485
1486 if (var->mbv_type != type) {
1487 #if OPAL_ENABLE_DEBUG
1488 opal_show_help("help-mca-var.txt",
1489 "re-register-with-different-type",
1490 true, var->mbv_full_name);
1491 #endif
1492 return OPAL_ERR_VALUE_OUT_OF_BOUNDS;
1493 }
1494 }
1495
1496 if (MCA_BASE_VAR_TYPE_BOOL == var->mbv_type) {
1497 enumerator = &mca_base_var_enum_bool;
1498 } else if (NULL != enumerator) {
1499 if (var->mbv_enumerator) {
1500 OBJ_RELEASE (var->mbv_enumerator);
1501 }
1502
1503 if (!enumerator->enum_is_static) {
1504 OBJ_RETAIN(enumerator);
1505 }
1506 }
1507
1508 var->mbv_enumerator = enumerator;
1509
1510 if (!original) {
1511 var->mbv_storage = storage;
1512
1513
1514 if ((MCA_BASE_VAR_TYPE_STRING == type || MCA_BASE_VAR_TYPE_VERSION_STRING == type) && NULL != ((char **)storage)[0]) {
1515 ((char **)storage)[0] = strdup (((char **)storage)[0]);
1516 }
1517 } else {
1518
1519 opal_value_array_append_item(&original->mbv_synonyms, &var_index);
1520 }
1521
1522
1523 var->mbv_flags |= MCA_BASE_VAR_FLAG_VALID;
1524
1525 ret = var_set_initial (var, original);
1526 if (OPAL_SUCCESS != ret) {
1527 return ret;
1528 }
1529
1530
1531 return var_index;
1532 }
1533
1534 int mca_base_var_register (const char *project_name, const char *framework_name,
1535 const char *component_name, const char *variable_name,
1536 const char *description, mca_base_var_type_t type,
1537 mca_base_var_enum_t *enumerator, int bind,
1538 mca_base_var_flag_t flags,
1539 mca_base_var_info_lvl_t info_lvl,
1540 mca_base_var_scope_t scope, void *storage)
1541 {
1542
1543 assert (NULL == enumerator || (MCA_BASE_VAR_TYPE_INT == type || MCA_BASE_VAR_TYPE_UNSIGNED_INT == type));
1544
1545 return register_variable (project_name, framework_name, component_name,
1546 variable_name, description, type, enumerator,
1547 bind, flags, info_lvl, scope, -1, storage);
1548 }
1549
1550 int mca_base_component_var_register (const mca_base_component_t *component,
1551 const char *variable_name, const char *description,
1552 mca_base_var_type_t type, mca_base_var_enum_t *enumerator,
1553 int bind, mca_base_var_flag_t flags,
1554 mca_base_var_info_lvl_t info_lvl,
1555 mca_base_var_scope_t scope, void *storage)
1556 {
1557 return mca_base_var_register (component->mca_project_name, component->mca_type_name,
1558 component->mca_component_name,
1559 variable_name, description, type, enumerator,
1560 bind, flags | MCA_BASE_VAR_FLAG_DWG,
1561 info_lvl, scope, storage);
1562 }
1563
1564 int mca_base_framework_var_register (const mca_base_framework_t *framework,
1565 const char *variable_name,
1566 const char *help_msg, mca_base_var_type_t type,
1567 mca_base_var_enum_t *enumerator, int bind,
1568 mca_base_var_flag_t flags,
1569 mca_base_var_info_lvl_t info_level,
1570 mca_base_var_scope_t scope, void *storage)
1571 {
1572 return mca_base_var_register (framework->framework_project, framework->framework_name,
1573 "base", variable_name, help_msg, type, enumerator, bind,
1574 flags | MCA_BASE_VAR_FLAG_DWG, info_level, scope, storage);
1575 }
1576
1577 int mca_base_var_register_synonym (int synonym_for, const char *project_name,
1578 const char *framework_name,
1579 const char *component_name,
1580 const char *synonym_name,
1581 mca_base_var_syn_flag_t flags)
1582 {
1583 mca_base_var_flag_t var_flags = (mca_base_var_flag_t) MCA_BASE_VAR_FLAG_SYNONYM;
1584 mca_base_var_t *var;
1585 int ret;
1586
1587 ret = var_get (synonym_for, &var, false);
1588 if (OPAL_SUCCESS != ret || VAR_IS_SYNONYM(var[0])) {
1589 return OPAL_ERR_BAD_PARAM;
1590 }
1591
1592 if (flags & MCA_BASE_VAR_SYN_FLAG_DEPRECATED) {
1593 var_flags |= MCA_BASE_VAR_FLAG_DEPRECATED;
1594 }
1595 if (flags & MCA_BASE_VAR_SYN_FLAG_INTERNAL) {
1596 var_flags |= MCA_BASE_VAR_FLAG_INTERNAL;
1597 }
1598
1599 return register_variable (project_name, framework_name, component_name,
1600 synonym_name, var->mbv_description, var->mbv_type, var->mbv_enumerator,
1601 var->mbv_bind, var_flags, var->mbv_info_lvl, var->mbv_scope,
1602 synonym_for, NULL);
1603 }
1604
1605 static int var_get_env (mca_base_var_t *var, const char *name, char **source, char **value)
1606 {
1607 const char source_prefix[] = "SOURCE_";
1608 const int max_len = strlen(mca_prefix) + strlen(source_prefix) +
1609 strlen(name) + 1;
1610 char *envvar = alloca(max_len);
1611 if (NULL == envvar) {
1612 return OPAL_ERR_OUT_OF_RESOURCE;
1613 }
1614
1615 int ret;
1616 ret = snprintf(envvar, max_len, "%s%s", mca_prefix, name);
1617 if (0 > ret) {
1618 return OPAL_ERROR;
1619 }
1620 *value = getenv(envvar);
1621 if( NULL == *value ) {
1622 *source = NULL;
1623 return OPAL_ERR_NOT_FOUND;
1624 }
1625
1626 ret = snprintf(envvar, max_len, "%s%s%s", mca_prefix,
1627 source_prefix, name);
1628 if( 0 > ret ) {
1629 return OPAL_ERROR;
1630 }
1631 *source = getenv(envvar);
1632
1633 return OPAL_SUCCESS;
1634 }
1635
1636
1637
1638
1639 static int var_set_from_env (mca_base_var_t *var, mca_base_var_t *original)
1640 {
1641 const char *var_full_name = var->mbv_full_name;
1642 const char *var_long_name = var->mbv_long_name;
1643 bool deprecated = VAR_IS_DEPRECATED(var[0]);
1644 bool is_synonym = VAR_IS_SYNONYM(var[0]);
1645 char *source_env, *value_env;
1646 int ret;
1647
1648 ret = var_get_env (var, var_long_name, &source_env, &value_env);
1649 if (OPAL_SUCCESS != ret) {
1650 ret = var_get_env (var, var_full_name, &source_env, &value_env);
1651 }
1652
1653 if (OPAL_SUCCESS != ret) {
1654 return ret;
1655 }
1656
1657
1658
1659 if (VAR_IS_DEFAULT_ONLY(original[0])) {
1660 opal_show_help("help-mca-var.txt", "default-only-param-set",
1661 true, var_full_name);
1662
1663 return OPAL_ERR_NOT_FOUND;
1664 }
1665
1666 if (MCA_BASE_VAR_SOURCE_OVERRIDE == original->mbv_source) {
1667 if (!mca_base_var_suppress_override_warning) {
1668 opal_show_help("help-mca-var.txt", "overridden-param-set",
1669 true, var_full_name);
1670 }
1671
1672 return OPAL_ERR_NOT_FOUND;
1673 }
1674
1675 original->mbv_source = MCA_BASE_VAR_SOURCE_ENV;
1676
1677 if (NULL != source_env) {
1678 if (0 == strncasecmp (source_env, "file:", 5)) {
1679 original->mbv_source_file = append_filename_to_list(source_env + 5);
1680 if (0 == strcmp (var->mbv_source_file, mca_base_var_override_file)) {
1681 original->mbv_source = MCA_BASE_VAR_SOURCE_OVERRIDE;
1682 } else {
1683 original->mbv_source = MCA_BASE_VAR_SOURCE_FILE;
1684 }
1685 } else if (0 == strcasecmp (source_env, "command")) {
1686 var->mbv_source = MCA_BASE_VAR_SOURCE_COMMAND_LINE;
1687 }
1688 }
1689
1690 if (deprecated) {
1691 const char *new_variable = "None (going away)";
1692
1693 if (is_synonym) {
1694 new_variable = original->mbv_full_name;
1695 }
1696
1697 switch (var->mbv_source) {
1698 case MCA_BASE_VAR_SOURCE_ENV:
1699 opal_show_help("help-mca-var.txt", "deprecated-mca-env",
1700 true, var_full_name, new_variable);
1701 break;
1702 case MCA_BASE_VAR_SOURCE_COMMAND_LINE:
1703 opal_show_help("help-mca-var.txt", "deprecated-mca-cli",
1704 true, var_full_name, new_variable);
1705 break;
1706 case MCA_BASE_VAR_SOURCE_FILE:
1707 case MCA_BASE_VAR_SOURCE_OVERRIDE:
1708 opal_show_help("help-mca-var.txt", "deprecated-mca-file",
1709 true, var_full_name, mca_base_var_source_file (var),
1710 new_variable);
1711 break;
1712
1713 case MCA_BASE_VAR_SOURCE_DEFAULT:
1714 case MCA_BASE_VAR_SOURCE_MAX:
1715 case MCA_BASE_VAR_SOURCE_SET:
1716
1717 break;
1718 }
1719 }
1720
1721 return var_set_from_string (original, value_env);
1722 }
1723
1724
1725
1726
1727 static int var_set_from_file (mca_base_var_t *var, mca_base_var_t *original, opal_list_t *file_values)
1728 {
1729 const char *var_full_name = var->mbv_full_name;
1730 const char *var_long_name = var->mbv_long_name;
1731 bool deprecated = VAR_IS_DEPRECATED(var[0]);
1732 bool is_synonym = VAR_IS_SYNONYM(var[0]);
1733 mca_base_var_file_value_t *fv;
1734
1735
1736
1737
1738
1739 OPAL_LIST_FOREACH(fv, file_values, mca_base_var_file_value_t) {
1740 if (0 != strcmp(fv->mbvfv_var, var_full_name) &&
1741 0 != strcmp(fv->mbvfv_var, var_long_name)) {
1742 continue;
1743 }
1744
1745
1746 if (VAR_IS_DEFAULT_ONLY(var[0])) {
1747 opal_show_help("help-mca-var.txt", "default-only-param-set",
1748 true, var_full_name);
1749
1750 return OPAL_ERR_NOT_FOUND;
1751 }
1752
1753 if (MCA_BASE_VAR_FLAG_ENVIRONMENT_ONLY & original->mbv_flags) {
1754 opal_show_help("help-mca-var.txt", "environment-only-param",
1755 true, var_full_name, fv->mbvfv_value,
1756 fv->mbvfv_file);
1757
1758 return OPAL_ERR_NOT_FOUND;
1759 }
1760
1761 if (MCA_BASE_VAR_SOURCE_OVERRIDE == original->mbv_source) {
1762 if (!mca_base_var_suppress_override_warning) {
1763 opal_show_help("help-mca-var.txt", "overridden-param-set",
1764 true, var_full_name);
1765 }
1766
1767 return OPAL_ERR_NOT_FOUND;
1768 }
1769
1770 if (deprecated) {
1771 const char *new_variable = "None (going away)";
1772
1773 if (is_synonym) {
1774 new_variable = original->mbv_full_name;
1775 }
1776
1777 opal_show_help("help-mca-var.txt", "deprecated-mca-file",
1778 true, var_full_name, fv->mbvfv_file,
1779 new_variable);
1780 }
1781
1782 original->mbv_file_value = (void *) fv;
1783 original->mbv_source = MCA_BASE_VAR_SOURCE_FILE;
1784 if (is_synonym) {
1785 var->mbv_file_value = (void *) fv;
1786 var->mbv_source = MCA_BASE_VAR_SOURCE_FILE;
1787 }
1788
1789 return var_set_from_string (original, fv->mbvfv_value);
1790 }
1791
1792 return OPAL_ERR_NOT_FOUND;
1793 }
1794
1795
1796
1797
1798 static int var_set_initial (mca_base_var_t *var, mca_base_var_t *original)
1799 {
1800 int ret;
1801
1802 if (original) {
1803
1804 var->mbv_source = original->mbv_source;
1805 var->mbv_file_value = original->mbv_file_value;
1806 var->mbv_source_file = original->mbv_source_file;
1807 } else {
1808 var->mbv_source = MCA_BASE_VAR_SOURCE_DEFAULT;
1809 original = var;
1810 }
1811
1812
1813
1814
1815
1816 ret = var_set_from_file (var, original, &mca_base_var_override_values);
1817 if (OPAL_SUCCESS == ret) {
1818 var->mbv_flags = ~MCA_BASE_VAR_FLAG_SETTABLE & (var->mbv_flags | MCA_BASE_VAR_FLAG_OVERRIDE);
1819 var->mbv_source = MCA_BASE_VAR_SOURCE_OVERRIDE;
1820 }
1821
1822 ret = var_set_from_env (var, original);
1823 if (OPAL_ERR_NOT_FOUND != ret) {
1824 return ret;
1825 }
1826
1827 ret = var_set_from_file (var, original, &mca_base_envar_file_values);
1828 if (OPAL_ERR_NOT_FOUND != ret) {
1829 return ret;
1830 }
1831
1832 ret = var_set_from_file (var, original, &mca_base_var_file_values);
1833 if (OPAL_ERR_NOT_FOUND != ret) {
1834 return ret;
1835 }
1836
1837 return OPAL_SUCCESS;
1838 }
1839
1840
1841
1842
1843 static void var_constructor(mca_base_var_t *var)
1844 {
1845 memset ((char *) var + sizeof (var->super), 0, sizeof (*var) - sizeof (var->super));
1846
1847 var->mbv_type = MCA_BASE_VAR_TYPE_MAX;
1848 OBJ_CONSTRUCT(&var->mbv_synonyms, opal_value_array_t);
1849 opal_value_array_init (&var->mbv_synonyms, sizeof (int));
1850 }
1851
1852
1853
1854
1855
1856 static void var_destructor(mca_base_var_t *var)
1857 {
1858 if ((MCA_BASE_VAR_TYPE_STRING == var->mbv_type ||
1859 MCA_BASE_VAR_TYPE_VERSION_STRING == var->mbv_type) &&
1860 NULL != var->mbv_storage &&
1861 NULL != var->mbv_storage->stringval) {
1862 free (var->mbv_storage->stringval);
1863 var->mbv_storage->stringval = NULL;
1864 }
1865
1866
1867 if (var->mbv_enumerator && !var->mbv_enumerator->enum_is_static) {
1868 OBJ_RELEASE(var->mbv_enumerator);
1869 }
1870
1871 if (NULL != var->mbv_long_name) {
1872 free(var->mbv_long_name);
1873 }
1874 var->mbv_full_name = NULL;
1875 var->mbv_variable_name = NULL;
1876
1877 if (NULL != var->mbv_description) {
1878 free(var->mbv_description);
1879 }
1880
1881
1882 OBJ_DESTRUCT(&var->mbv_synonyms);
1883
1884
1885 var->mbv_type = MCA_BASE_VAR_TYPE_MAX;
1886
1887 #if OPAL_ENABLE_DEBUG
1888
1889 memset ((char *) var + sizeof (var->super), 0, sizeof (*var) - sizeof (var->super));
1890 #endif
1891 }
1892
1893
1894 static void fv_constructor(mca_base_var_file_value_t *f)
1895 {
1896 memset ((char *) f + sizeof (f->super), 0, sizeof (*f) - sizeof (f->super));
1897 }
1898
1899
1900 static void fv_destructor(mca_base_var_file_value_t *f)
1901 {
1902 if (NULL != f->mbvfv_var) {
1903 free(f->mbvfv_var);
1904 }
1905 if (NULL != f->mbvfv_value) {
1906 free(f->mbvfv_value);
1907 }
1908
1909 fv_constructor(f);
1910 }
1911
1912 static char *source_name(mca_base_var_t *var)
1913 {
1914 char *ret;
1915
1916 if (MCA_BASE_VAR_SOURCE_FILE == var->mbv_source || MCA_BASE_VAR_SOURCE_OVERRIDE == var->mbv_source) {
1917 struct mca_base_var_file_value_t *fv = var->mbv_file_value;
1918 int rc;
1919
1920 if (fv) {
1921 rc = opal_asprintf(&ret, "file (%s:%d)", fv->mbvfv_file, fv->mbvfv_lineno);
1922 } else {
1923 rc = opal_asprintf(&ret, "file (%s)", var->mbv_source_file);
1924 }
1925
1926
1927 if (0 > rc) {
1928 return NULL;
1929 }
1930 return ret;
1931 } else if (MCA_BASE_VAR_SOURCE_MAX <= var->mbv_source) {
1932 return strdup ("unknown(!!)");
1933 }
1934
1935 return strdup (var_source_names[var->mbv_source]);
1936 }
1937
1938 static int var_value_string (mca_base_var_t *var, char **value_string)
1939 {
1940 const mca_base_var_storage_t *value=NULL;
1941 int ret;
1942
1943 assert (MCA_BASE_VAR_TYPE_MAX > var->mbv_type);
1944
1945
1946
1947 if ((var->mbv_flags & MCA_BASE_VAR_FLAG_DEF_UNSET) &&
1948 (MCA_BASE_VAR_SOURCE_DEFAULT == var->mbv_source)){
1949 opal_asprintf (value_string, "%s", "unset");
1950 return OPAL_SUCCESS;
1951 }
1952
1953 ret = mca_base_var_get_value(var->mbv_index, &value, NULL, NULL);
1954 if (OPAL_SUCCESS != ret || NULL == value) {
1955 return ret;
1956 }
1957
1958 if (NULL == var->mbv_enumerator) {
1959 switch (var->mbv_type) {
1960 case MCA_BASE_VAR_TYPE_INT:
1961 ret = opal_asprintf (value_string, "%d", value->intval);
1962 break;
1963 case MCA_BASE_VAR_TYPE_INT32_T:
1964 ret = opal_asprintf (value_string, "%" PRId32, value->int32tval);
1965 break;
1966 case MCA_BASE_VAR_TYPE_UINT32_T:
1967 ret = opal_asprintf (value_string, "%" PRIu32, value->uint32tval);
1968 break;
1969 case MCA_BASE_VAR_TYPE_INT64_T:
1970 ret = opal_asprintf (value_string, "%" PRId64, value->int64tval);
1971 break;
1972 case MCA_BASE_VAR_TYPE_UINT64_T:
1973 ret = opal_asprintf (value_string, "%" PRIu64, value->uint64tval);
1974 break;
1975 case MCA_BASE_VAR_TYPE_LONG:
1976 ret = opal_asprintf (value_string, "%ld", value->longval);
1977 break;
1978 case MCA_BASE_VAR_TYPE_UNSIGNED_INT:
1979 ret = opal_asprintf (value_string, "%u", value->uintval);
1980 break;
1981 case MCA_BASE_VAR_TYPE_UNSIGNED_LONG:
1982 ret = opal_asprintf (value_string, "%lu", value->ulval);
1983 break;
1984 case MCA_BASE_VAR_TYPE_UNSIGNED_LONG_LONG:
1985 ret = opal_asprintf (value_string, "%llu", value->ullval);
1986 break;
1987 case MCA_BASE_VAR_TYPE_SIZE_T:
1988 ret = opal_asprintf (value_string, "%" PRIsize_t, value->sizetval);
1989 break;
1990 case MCA_BASE_VAR_TYPE_STRING:
1991 case MCA_BASE_VAR_TYPE_VERSION_STRING:
1992 ret = opal_asprintf (value_string, "%s",
1993 value->stringval ? value->stringval : "");
1994 break;
1995 case MCA_BASE_VAR_TYPE_BOOL:
1996 ret = opal_asprintf (value_string, "%d", value->boolval);
1997 break;
1998 case MCA_BASE_VAR_TYPE_DOUBLE:
1999 ret = opal_asprintf (value_string, "%lf", value->lfval);
2000 break;
2001 default:
2002 ret = -1;
2003 break;
2004 }
2005
2006 ret = (0 > ret) ? OPAL_ERR_OUT_OF_RESOURCE : OPAL_SUCCESS;
2007 } else {
2008
2009 if (MCA_BASE_VAR_TYPE_BOOL == var->mbv_type) {
2010 ret = var->mbv_enumerator->string_from_value(var->mbv_enumerator, value->boolval, value_string);
2011 } else {
2012 ret = var->mbv_enumerator->string_from_value(var->mbv_enumerator, value->intval, value_string);
2013 }
2014 }
2015
2016 return ret;
2017 }
2018
2019 int mca_base_var_check_exclusive (const char *project,
2020 const char *type_a,
2021 const char *component_a,
2022 const char *param_a,
2023 const char *type_b,
2024 const char *component_b,
2025 const char *param_b)
2026 {
2027 mca_base_var_t *var_a = NULL, *var_b = NULL;
2028 int var_ai, var_bi;
2029
2030
2031 project = NULL;
2032
2033 var_ai = mca_base_var_find (project, type_a, component_a, param_a);
2034 var_bi = mca_base_var_find (project, type_b, component_b, param_b);
2035 if (var_bi < 0 || var_ai < 0) {
2036 return OPAL_ERR_NOT_FOUND;
2037 }
2038
2039 (void) var_get (var_ai, &var_a, true);
2040 (void) var_get (var_bi, &var_b, true);
2041 if (NULL == var_a || NULL == var_b) {
2042 return OPAL_ERR_NOT_FOUND;
2043 }
2044
2045 if (MCA_BASE_VAR_SOURCE_DEFAULT != var_a->mbv_source &&
2046 MCA_BASE_VAR_SOURCE_DEFAULT != var_b->mbv_source) {
2047 char *str_a, *str_b;
2048
2049
2050 str_a = source_name(var_a);
2051
2052
2053 str_b = source_name(var_b);
2054
2055
2056 opal_show_help("help-mca-var.txt",
2057 "mutually-exclusive-vars",
2058 true, var_a->mbv_full_name,
2059 str_a, var_b->mbv_full_name,
2060 str_b);
2061
2062
2063 free(str_a);
2064 free(str_b);
2065
2066 return OPAL_ERR_BAD_PARAM;
2067 }
2068
2069 return OPAL_SUCCESS;
2070 }
2071
2072 int mca_base_var_get_count (void)
2073 {
2074 return mca_base_var_count;
2075 }
2076
2077 int mca_base_var_dump(int vari, char ***out, mca_base_var_dump_type_t output_type)
2078 {
2079 const char *framework, *component, *full_name;
2080 int i, line_count, line = 0, enum_count = 0;
2081 char *value_string, *source_string, *tmp;
2082 int synonym_count, ret, *synonyms = NULL;
2083 mca_base_var_t *var, *original=NULL;
2084 mca_base_var_group_t *group;
2085
2086 ret = var_get(vari, &var, false);
2087 if (OPAL_SUCCESS != ret) {
2088 return ret;
2089 }
2090
2091 ret = mca_base_var_group_get_internal(var->mbv_group_index, &group, false);
2092 if (OPAL_SUCCESS != ret) {
2093 return ret;
2094 }
2095
2096 if (VAR_IS_SYNONYM(var[0])) {
2097 ret = var_get(var->mbv_synonym_for, &original, false);
2098 if (OPAL_SUCCESS != ret) {
2099 return ret;
2100 }
2101
2102 if (NULL == original) {
2103 return OPAL_ERR_NOT_FOUND;
2104 }
2105 }
2106
2107 framework = group->group_framework;
2108 component = group->group_component ? group->group_component : "base";
2109 full_name = var->mbv_full_name;
2110
2111 synonym_count = opal_value_array_get_size(&var->mbv_synonyms);
2112 if (synonym_count) {
2113 synonyms = OPAL_VALUE_ARRAY_GET_BASE(&var->mbv_synonyms, int);
2114 }
2115
2116 ret = var_value_string (var, &value_string);
2117 if (OPAL_SUCCESS != ret) {
2118 return ret;
2119 }
2120
2121 source_string = source_name(var);
2122 if (NULL == source_string) {
2123 free (value_string);
2124 return OPAL_ERR_OUT_OF_RESOURCE;
2125 }
2126
2127 if (MCA_BASE_VAR_DUMP_PARSABLE == output_type) {
2128 if (NULL != var->mbv_enumerator) {
2129 (void) var->mbv_enumerator->get_count(var->mbv_enumerator, &enum_count);
2130 }
2131
2132 line_count = 8 + (var->mbv_description ? 1 : 0) + (VAR_IS_SYNONYM(var[0]) ? 1 : synonym_count) +
2133 enum_count;
2134
2135 *out = (char **) calloc (line_count + 1, sizeof (char *));
2136 if (NULL == *out) {
2137 free (value_string);
2138 free (source_string);
2139 return OPAL_ERR_OUT_OF_RESOURCE;
2140 }
2141
2142
2143 opal_asprintf(&tmp, "mca:%s:%s:param:%s:", framework, component,
2144 full_name);
2145
2146
2147 char *colon = strchr(value_string, ':');
2148 if (NULL != colon) {
2149 opal_asprintf(out[0] + line++, "%svalue:\"%s\"", tmp, value_string);
2150 } else {
2151 opal_asprintf(out[0] + line++, "%svalue:%s", tmp, value_string);
2152 }
2153
2154
2155 opal_asprintf(out[0] + line++, "%ssource:%s", tmp, source_string);
2156
2157
2158 opal_asprintf(out[0] + line++, "%sstatus:%s", tmp,
2159 VAR_IS_SETTABLE(var[0]) ? "writeable" : "read-only");
2160
2161
2162 opal_asprintf(out[0] + line++, "%slevel:%d", tmp, var->mbv_info_lvl + 1);
2163
2164
2165 if (var->mbv_description) {
2166 opal_asprintf(out[0] + line++, "%shelp:%s", tmp, var->mbv_description);
2167 }
2168
2169 if (NULL != var->mbv_enumerator) {
2170 for (i = 0 ; i < enum_count ; ++i) {
2171 const char *enum_string = NULL;
2172 int enum_value;
2173
2174 ret = var->mbv_enumerator->get_value(var->mbv_enumerator, i, &enum_value,
2175 &enum_string);
2176 if (OPAL_SUCCESS != ret) {
2177 continue;
2178 }
2179
2180 opal_asprintf(out[0] + line++, "%senumerator:value:%d:%s", tmp, enum_value, enum_string);
2181 }
2182 }
2183
2184
2185 opal_asprintf(out[0] + line++, "%sdeprecated:%s", tmp, VAR_IS_DEPRECATED(var[0]) ? "yes" : "no");
2186
2187 opal_asprintf(out[0] + line++, "%stype:%s", tmp, ompi_var_type_names[var->mbv_type]);
2188
2189
2190 if (VAR_IS_SYNONYM(var[0])) {
2191 opal_asprintf(out[0] + line++, "%ssynonym_of:name:%s", tmp, original->mbv_full_name);
2192 } else if (opal_value_array_get_size(&var->mbv_synonyms)) {
2193 for (i = 0 ; i < synonym_count ; ++i) {
2194 mca_base_var_t *synonym;
2195
2196 ret = var_get(synonyms[i], &synonym, false);
2197 if (OPAL_SUCCESS != ret) {
2198 continue;
2199 }
2200
2201 opal_asprintf(out[0] + line++, "%ssynonym:name:%s", tmp, synonym->mbv_full_name);
2202 }
2203 }
2204
2205 free (tmp);
2206 } else if (MCA_BASE_VAR_DUMP_READABLE == output_type) {
2207
2208 *out = (char **) calloc (4, sizeof (char *));
2209 if (NULL == *out) {
2210 free (value_string);
2211 free (source_string);
2212 return OPAL_ERR_OUT_OF_RESOURCE;
2213 }
2214
2215 opal_asprintf (out[0], "%s \"%s\" (current value: \"%s\", data source: %s, level: %d %s, type: %s",
2216 VAR_IS_DEFAULT_ONLY(var[0]) ? "informational" : "parameter",
2217 full_name, value_string, source_string, var->mbv_info_lvl + 1,
2218 info_lvl_strings[var->mbv_info_lvl], ompi_var_type_names[var->mbv_type]);
2219
2220 tmp = out[0][0];
2221 if (VAR_IS_DEPRECATED(var[0])) {
2222 opal_asprintf (out[0], "%s, deprecated", tmp);
2223 free (tmp);
2224 tmp = out[0][0];
2225 }
2226
2227
2228 if (VAR_IS_SYNONYM(var[0])) {
2229 opal_asprintf(out[0], "%s, synonym of: %s)", tmp, original->mbv_full_name);
2230 free (tmp);
2231 } else if (synonym_count) {
2232 opal_asprintf(out[0], "%s, synonyms: ", tmp);
2233 free (tmp);
2234
2235 for (i = 0 ; i < synonym_count ; ++i) {
2236 mca_base_var_t *synonym;
2237
2238 ret = var_get(synonyms[i], &synonym, false);
2239 if (OPAL_SUCCESS != ret) {
2240 continue;
2241 }
2242
2243 tmp = out[0][0];
2244 if (synonym_count == i+1) {
2245 opal_asprintf(out[0], "%s%s)", tmp, synonym->mbv_full_name);
2246 } else {
2247 opal_asprintf(out[0], "%s%s, ", tmp, synonym->mbv_full_name);
2248 }
2249 free(tmp);
2250 }
2251 } else {
2252 opal_asprintf(out[0], "%s)", tmp);
2253 free(tmp);
2254 }
2255
2256 line++;
2257
2258 if (var->mbv_description) {
2259 opal_asprintf(out[0] + line++, "%s", var->mbv_description);
2260 }
2261
2262 if (NULL != var->mbv_enumerator) {
2263 char *values;
2264
2265 ret = var->mbv_enumerator->dump(var->mbv_enumerator, &values);
2266 if (OPAL_SUCCESS == ret) {
2267 opal_asprintf (out[0] + line++, "Valid values: %s", values);
2268 free (values);
2269 }
2270 }
2271 } else if (MCA_BASE_VAR_DUMP_SIMPLE == output_type) {
2272 *out = (char **) calloc (2, sizeof (char *));
2273 if (NULL == *out) {
2274 free (value_string);
2275 free (source_string);
2276 return OPAL_ERR_OUT_OF_RESOURCE;
2277 }
2278
2279 opal_asprintf(out[0], "%s=%s (%s)", var->mbv_full_name, value_string, source_string);
2280 }
2281
2282 free (value_string);
2283 free (source_string);
2284
2285 return OPAL_SUCCESS;
2286 }
2287