This source file includes following definitions.
- orte_get_attribute
- orte_set_attribute
- orte_fetch_attribute
- orte_add_attribute
- orte_prepend_attribute
- orte_remove_attribute
- orte_attr_register
- orte_attr_key_to_str
- orte_attr_load
- orte_attr_unload
1
2
3
4
5
6
7
8
9
10
11
12
13 #include "orte_config.h"
14 #include "orte/types.h"
15 #include "orte/constants.h"
16
17 #include "opal/dss/dss.h"
18 #include "opal/util/output.h"
19 #include "opal/util/string_copy.h"
20
21 #include "orte/mca/errmgr/errmgr.h"
22
23 #include "orte/util/attr.h"
24
25 #define MAX_CONVERTERS 5
26 #define MAX_CONVERTER_PROJECT_LEN 10
27
28 typedef struct {
29 int init;
30 char project[MAX_CONVERTER_PROJECT_LEN];
31 orte_attribute_key_t key_base;
32 orte_attribute_key_t key_max;
33 orte_attr2str_fn_t converter;
34 } orte_attr_converter_t;
35
36
37 static orte_attr_converter_t converters[MAX_CONVERTERS];
38
39 bool orte_get_attribute(opal_list_t *attributes,
40 orte_attribute_key_t key,
41 void **data, opal_data_type_t type)
42 {
43 orte_attribute_t *kv;
44 int rc;
45
46 OPAL_LIST_FOREACH(kv, attributes, orte_attribute_t) {
47 if (key == kv->key) {
48 if (kv->type != type) {
49 ORTE_ERROR_LOG(ORTE_ERR_TYPE_MISMATCH);
50 return false;
51 }
52 if (NULL != data) {
53 if (ORTE_SUCCESS != (rc = orte_attr_unload(kv, data, type))) {
54 ORTE_ERROR_LOG(rc);
55 }
56 }
57 return true;
58 }
59 }
60
61 return false;
62 }
63
64 int orte_set_attribute(opal_list_t *attributes,
65 orte_attribute_key_t key, bool local,
66 void *data, opal_data_type_t type)
67 {
68 orte_attribute_t *kv;
69 int rc;
70
71 OPAL_LIST_FOREACH(kv, attributes, orte_attribute_t) {
72 if (key == kv->key) {
73 if (kv->type != type) {
74 return ORTE_ERR_TYPE_MISMATCH;
75 }
76 if (ORTE_SUCCESS != (rc = orte_attr_load(kv, data, type))) {
77 ORTE_ERROR_LOG(rc);
78 }
79 return rc;
80 }
81 }
82
83 kv = OBJ_NEW(orte_attribute_t);
84 kv->key = key;
85 kv->local = local;
86 if (OPAL_SUCCESS != (rc = orte_attr_load(kv, data, type))) {
87 OBJ_RELEASE(kv);
88 return rc;
89 }
90 opal_list_append(attributes, &kv->super);
91 return ORTE_SUCCESS;
92 }
93
94 orte_attribute_t* orte_fetch_attribute(opal_list_t *attributes,
95 orte_attribute_t *prev,
96 orte_attribute_key_t key)
97 {
98 orte_attribute_t *kv, *end, *next;
99
100
101
102 if (NULL == prev) {
103 OPAL_LIST_FOREACH(kv, attributes, orte_attribute_t) {
104 if (key == kv->key) {
105 return kv;
106 }
107 }
108
109 return NULL;
110 }
111
112
113 end = (orte_attribute_t*)opal_list_get_end(attributes);
114 if (prev == end || end == (orte_attribute_t*)opal_list_get_next(&prev->super) ||
115 NULL == opal_list_get_next(&prev->super)) {
116 return NULL;
117 }
118
119
120
121 next = (orte_attribute_t*)opal_list_get_next(&prev->super);
122 while (NULL != next) {
123 if (next->key == key) {
124 return next;
125 }
126 next = (orte_attribute_t*)opal_list_get_next(&next->super);
127 }
128
129
130 return NULL;
131 }
132
133 int orte_add_attribute(opal_list_t *attributes,
134 orte_attribute_key_t key, bool local,
135 void *data, opal_data_type_t type)
136 {
137 orte_attribute_t *kv;
138 int rc;
139
140 kv = OBJ_NEW(orte_attribute_t);
141 kv->key = key;
142 kv->local = local;
143 if (OPAL_SUCCESS != (rc = orte_attr_load(kv, data, type))) {
144 OBJ_RELEASE(kv);
145 return rc;
146 }
147 opal_list_append(attributes, &kv->super);
148 return ORTE_SUCCESS;
149 }
150
151 int orte_prepend_attribute(opal_list_t *attributes,
152 orte_attribute_key_t key, bool local,
153 void *data, opal_data_type_t type)
154 {
155 orte_attribute_t *kv;
156 int rc;
157
158 kv = OBJ_NEW(orte_attribute_t);
159 kv->key = key;
160 kv->local = local;
161 if (OPAL_SUCCESS != (rc = orte_attr_load(kv, data, type))) {
162 OBJ_RELEASE(kv);
163 return rc;
164 }
165 opal_list_prepend(attributes, &kv->super);
166 return ORTE_SUCCESS;
167 }
168
169 void orte_remove_attribute(opal_list_t *attributes, orte_attribute_key_t key)
170 {
171 orte_attribute_t *kv;
172
173 OPAL_LIST_FOREACH(kv, attributes, orte_attribute_t) {
174 if (key == kv->key) {
175 opal_list_remove_item(attributes, &kv->super);
176 OBJ_RELEASE(kv);
177 return;
178 }
179 }
180 }
181
182 int orte_attr_register(const char *project,
183 orte_attribute_key_t key_base,
184 orte_attribute_key_t key_max,
185 orte_attr2str_fn_t converter)
186 {
187 int i;
188
189 for (i = 0 ; i < MAX_CONVERTERS ; ++i) {
190 if (0 == converters[i].init) {
191 converters[i].init = 1;
192 opal_string_copy(converters[i].project, project,
193 MAX_CONVERTER_PROJECT_LEN);
194 converters[i].project[MAX_CONVERTER_PROJECT_LEN-1] = '\0';
195 converters[i].key_base = key_base;
196 converters[i].key_max = key_max;
197 converters[i].converter = converter;
198 return ORTE_SUCCESS;
199 }
200 }
201
202 return ORTE_ERR_OUT_OF_RESOURCE;
203 }
204
205 const char *orte_attr_key_to_str(orte_attribute_key_t key)
206 {
207 int i;
208
209 if (ORTE_ATTR_KEY_BASE < key &&
210 key < ORTE_ATTR_KEY_MAX) {
211
212 switch(key) {
213 case ORTE_APP_HOSTFILE:
214 return "APP-HOSTFILE";
215 case ORTE_APP_ADD_HOSTFILE:
216 return "APP-ADD-HOSTFILE";
217 case ORTE_APP_DASH_HOST:
218 return "APP-DASH-HOST";
219 case ORTE_APP_ADD_HOST:
220 return "APP-ADD-HOST";
221 case ORTE_APP_USER_CWD:
222 return "APP-USER-CWD";
223 case ORTE_APP_SSNDIR_CWD:
224 return "APP-USE-SESSION-DIR-AS-CWD";
225 case ORTE_APP_PRELOAD_BIN:
226 return "APP-PRELOAD-BIN";
227 case ORTE_APP_PRELOAD_FILES:
228 return "APP-PRELOAD-FILES";
229 case ORTE_APP_SSTORE_LOAD:
230 return "APP-SSTORE-LOAD";
231 case ORTE_APP_RECOV_DEF:
232 return "APP-RECOVERY-DEFINED";
233 case ORTE_APP_MAX_RESTARTS:
234 return "APP-MAX-RESTARTS";
235 case ORTE_APP_MIN_NODES:
236 return "APP-MIN-NODES";
237 case ORTE_APP_MANDATORY:
238 return "APP-NODES-MANDATORY";
239 case ORTE_APP_MAX_PPN:
240 return "APP-MAX-PPN";
241 case ORTE_APP_PREFIX_DIR:
242 return "APP-PREFIX-DIR";
243 case ORTE_APP_NO_CACHEDIR:
244 return "ORTE_APP_NO_CACHEDIR";
245 case ORTE_APP_SET_ENVAR:
246 return "ORTE_APP_SET_ENVAR";
247 case ORTE_APP_UNSET_ENVAR:
248 return "ORTE_APP_UNSET_ENVAR";
249 case ORTE_APP_PREPEND_ENVAR:
250 return "ORTE_APP_PREPEND_ENVAR";
251 case ORTE_APP_APPEND_ENVAR:
252 return "ORTE_APP_APPEND_ENVAR";
253 case ORTE_APP_ADD_ENVAR:
254 return "ORTE_APP_ADD_ENVAR";
255 case ORTE_APP_PSET_NAME:
256 return "ORTE_APP_PSET_NAME";
257
258 case ORTE_NODE_USERNAME:
259 return "NODE-USERNAME";
260 case ORTE_NODE_PORT:
261 return "NODE-PORT";
262 case ORTE_NODE_LAUNCH_ID:
263 return "NODE-LAUNCHID";
264 case ORTE_NODE_HOSTID:
265 return "NODE-HOSTID";
266 case ORTE_NODE_ALIAS:
267 return "NODE-ALIAS";
268 case ORTE_NODE_SERIAL_NUMBER:
269 return "NODE-SERIAL-NUM";
270
271 case ORTE_JOB_LAUNCH_MSG_SENT:
272 return "JOB-LAUNCH-MSG-SENT";
273 case ORTE_JOB_LAUNCH_MSG_RECVD:
274 return "JOB-LAUNCH-MSG-RECVD";
275 case ORTE_JOB_MAX_LAUNCH_MSG_RECVD:
276 return "JOB-MAX-LAUNCH-MSG-RECVD";
277 case ORTE_JOB_CKPT_STATE:
278 return "JOB-CKPT-STATE";
279 case ORTE_JOB_SNAPSHOT_REF:
280 return "JOB-SNAPSHOT-REF";
281 case ORTE_JOB_SNAPSHOT_LOC:
282 return "JOB-SNAPSHOT-LOC";
283 case ORTE_JOB_SNAPC_INIT_BAR:
284 return "JOB-SNAPC-INIT-BARRIER-ID";
285 case ORTE_JOB_SNAPC_FINI_BAR:
286 return "JOB-SNAPC-FINI-BARRIER-ID";
287 case ORTE_JOB_NUM_NONZERO_EXIT:
288 return "JOB-NUM-NONZERO-EXIT";
289 case ORTE_JOB_FAILURE_TIMER_EVENT:
290 return "JOB-FAILURE-TIMER-EVENT";
291 case ORTE_JOB_ABORTED_PROC:
292 return "JOB-ABORTED-PROC";
293 case ORTE_JOB_MAPPER:
294 return "JOB-MAPPER";
295 case ORTE_JOB_REDUCER:
296 return "JOB-REDUCER";
297 case ORTE_JOB_COMBINER:
298 return "JOB-COMBINER";
299 case ORTE_JOB_INDEX_ARGV:
300 return "JOB-INDEX-ARGV";
301 case ORTE_JOB_NO_VM:
302 return "JOB-NO-VM";
303 case ORTE_JOB_SPIN_FOR_DEBUG:
304 return "JOB-SPIN-FOR-DEBUG";
305 case ORTE_JOB_CONTINUOUS_OP:
306 return "JOB-CONTINUOUS-OP";
307 case ORTE_JOB_RECOVER_DEFINED:
308 return "JOB-RECOVERY-DEFINED";
309 case ORTE_JOB_NON_ORTE_JOB:
310 return "JOB-NON-ORTE-JOB";
311 case ORTE_JOB_STDOUT_TARGET:
312 return "JOB-STDOUT-TARGET";
313 case ORTE_JOB_POWER:
314 return "JOB-POWER";
315 case ORTE_JOB_MAX_FREQ:
316 return "JOB-MAX_FREQ";
317 case ORTE_JOB_MIN_FREQ:
318 return "JOB-MIN_FREQ";
319 case ORTE_JOB_GOVERNOR:
320 return "JOB-FREQ-GOVERNOR";
321 case ORTE_JOB_FAIL_NOTIFIED:
322 return "JOB-FAIL-NOTIFIED";
323 case ORTE_JOB_TERM_NOTIFIED:
324 return "JOB-TERM-NOTIFIED";
325 case ORTE_JOB_PEER_MODX_ID:
326 return "JOB-PEER-MODX-ID";
327 case ORTE_JOB_INIT_BAR_ID:
328 return "JOB-INIT-BAR-ID";
329 case ORTE_JOB_FINI_BAR_ID:
330 return "JOB-FINI-BAR-ID";
331 case ORTE_JOB_FWDIO_TO_TOOL:
332 return "JOB-FWD-IO-TO-TOOL";
333 case ORTE_JOB_PHYSICAL_CPUIDS:
334 return "JOB-PHYSICAL-CPUIDS";
335 case ORTE_JOB_LAUNCHED_DAEMONS:
336 return "JOB-LAUNCHED-DAEMONS";
337 case ORTE_JOB_REPORT_BINDINGS:
338 return "JOB-REPORT-BINDINGS";
339 case ORTE_JOB_CPU_LIST:
340 return "JOB-CPU-LIST";
341 case ORTE_JOB_NOTIFICATIONS:
342 return "JOB-NOTIFICATIONS";
343 case ORTE_JOB_ROOM_NUM:
344 return "JOB-ROOM-NUM";
345 case ORTE_JOB_LAUNCH_PROXY:
346 return "JOB-LAUNCH-PROXY";
347 case ORTE_JOB_NSPACE_REGISTERED:
348 return "JOB-NSPACE-REGISTERED";
349 case ORTE_JOB_FIXED_DVM:
350 return "ORTE-JOB-FIXED-DVM";
351 case ORTE_JOB_DVM_JOB:
352 return "ORTE-JOB-DVM-JOB";
353 case ORTE_JOB_CANCELLED:
354 return "ORTE-JOB-CANCELLED";
355 case ORTE_JOB_OUTPUT_TO_FILE:
356 return "ORTE-JOB-OUTPUT-TO-FILE";
357 case ORTE_JOB_MERGE_STDERR_STDOUT:
358 return "ORTE-JOB-MERGE-STDERR-STDOUT";
359 case ORTE_JOB_TAG_OUTPUT:
360 return "ORTE-JOB-TAG-OUTPUT";
361 case ORTE_JOB_TIMESTAMP_OUTPUT:
362 return "ORTE-JOB-TIMESTAMP-OUTPUT";
363 case ORTE_JOB_MULTI_DAEMON_SIM:
364 return "ORTE_JOB_MULTI_DAEMON_SIM";
365 case ORTE_JOB_NOTIFY_COMPLETION:
366 return "ORTE_JOB_NOTIFY_COMPLETION";
367 case ORTE_JOB_TRANSPORT_KEY:
368 return "ORTE_JOB_TRANSPORT_KEY";
369 case ORTE_JOB_INFO_CACHE:
370 return "ORTE_JOB_INFO_CACHE";
371 case ORTE_JOB_FULLY_DESCRIBED:
372 return "ORTE_JOB_FULLY_DESCRIBED";
373 case ORTE_JOB_SILENT_TERMINATION:
374 return "ORTE_JOB_SILENT_TERMINATION";
375 case ORTE_JOB_SET_ENVAR:
376 return "ORTE_JOB_SET_ENVAR";
377 case ORTE_JOB_UNSET_ENVAR:
378 return "ORTE_JOB_UNSET_ENVAR";
379 case ORTE_JOB_PREPEND_ENVAR:
380 return "ORTE_JOB_PREPEND_ENVAR";
381 case ORTE_JOB_APPEND_ENVAR:
382 return "ORTE_JOB_APPEND_ENVAR";
383 case ORTE_JOB_ADD_ENVAR:
384 return "ORTE_APP_ADD_ENVAR";
385 case ORTE_JOB_APP_SETUP_DATA:
386 return "ORTE_JOB_APP_SETUP_DATA";
387
388 case ORTE_PROC_NOBARRIER:
389 return "PROC-NOBARRIER";
390 case ORTE_PROC_CPU_BITMAP:
391 return "PROC-CPU-BITMAP";
392 case ORTE_PROC_HWLOC_LOCALE:
393 return "PROC-HWLOC-LOCALE";
394 case ORTE_PROC_HWLOC_BOUND:
395 return "PROC-HWLOC-BOUND";
396 case ORTE_PROC_PRIOR_NODE:
397 return "PROC-PRIOR-NODE";
398 case ORTE_PROC_NRESTARTS:
399 return "PROC-NUM-RESTARTS";
400 case ORTE_PROC_RESTART_TIME:
401 return "PROC-RESTART-TIME";
402 case ORTE_PROC_FAST_FAILS:
403 return "PROC-FAST-FAILS";
404 case ORTE_PROC_CKPT_STATE:
405 return "PROC-CKPT-STATE";
406 case ORTE_PROC_SNAPSHOT_REF:
407 return "PROC-SNAPHOT-REF";
408 case ORTE_PROC_SNAPSHOT_LOC:
409 return "PROC-SNAPSHOT-LOC";
410 case ORTE_PROC_NODENAME:
411 return "PROC-NODENAME";
412 case ORTE_PROC_CGROUP:
413 return "PROC-CGROUP";
414 case ORTE_PROC_NBEATS:
415 return "PROC-NBEATS";
416
417 case ORTE_RML_TRANSPORT_TYPE:
418 return "RML-TRANSPORT-TYPE";
419 case ORTE_RML_PROTOCOL_TYPE:
420 return "RML-PROTOCOL-TYPE";
421 case ORTE_RML_CONDUIT_ID:
422 return "RML-CONDUIT-ID";
423 case ORTE_RML_INCLUDE_COMP_ATTRIB:
424 return "RML-INCLUDE";
425 case ORTE_RML_EXCLUDE_COMP_ATTRIB:
426 return "RML-EXCLUDE";
427 case ORTE_RML_TRANSPORT_ATTRIB:
428 return "RML-TRANSPORT";
429 case ORTE_RML_QUALIFIER_ATTRIB:
430 return "RML-QUALIFIER";
431 case ORTE_RML_PROVIDER_ATTRIB:
432 return "RML-DESIRED-PROVIDERS";
433 case ORTE_RML_PROTOCOL_ATTRIB:
434 return "RML-DESIRED-PROTOCOLS";
435 case ORTE_RML_ROUTED_ATTRIB:
436 return "RML-DESIRED-ROUTED-MODULES";
437 default:
438 return "UNKNOWN-KEY";
439 }
440 }
441
442
443 for (i = 0 ; i < MAX_CONVERTERS ; ++i) {
444 if (0 != converters[i].init) {
445 if (converters[i].key_base < key &&
446 key < converters[i].key_max) {
447 return converters[i].converter(key);
448 }
449 }
450 }
451
452
453 return "UNKNOWN-KEY";
454 }
455
456
457 int orte_attr_load(orte_attribute_t *kv,
458 void *data, opal_data_type_t type)
459 {
460 opal_byte_object_t *boptr;
461 struct timeval *tv;
462 opal_envar_t *envar;
463
464 kv->type = type;
465 if (NULL == data) {
466
467
468
469
470 if (OPAL_BOOL == type) {
471 kv->data.flag = true;
472 } else {
473
474
475 if (OPAL_STRING == type && NULL != kv->data.string) {
476 free(kv->data.string);
477 } else if (OPAL_BYTE_OBJECT == type && NULL != kv->data.bo.bytes) {
478 free(kv->data.bo.bytes);
479 }
480
481 memset(&kv->data, 0, sizeof(kv->data));
482 }
483 return OPAL_SUCCESS;
484 }
485
486 switch (type) {
487 case OPAL_BOOL:
488 kv->data.flag = *(bool*)(data);
489 break;
490 case OPAL_BYTE:
491 kv->data.byte = *(uint8_t*)(data);
492 break;
493 case OPAL_STRING:
494 if (NULL != kv->data.string) {
495 free(kv->data.string);
496 }
497 if (NULL != data) {
498 kv->data.string = strdup( (const char *) data);
499 } else {
500 kv->data.string = NULL;
501 }
502 break;
503 case OPAL_SIZE:
504 kv->data.size = *(size_t*)(data);
505 break;
506 case OPAL_PID:
507 kv->data.pid = *(pid_t*)(data);
508 break;
509
510 case OPAL_INT:
511 kv->data.integer = *(int*)(data);
512 break;
513 case OPAL_INT8:
514 kv->data.int8 = *(int8_t*)(data);
515 break;
516 case OPAL_INT16:
517 kv->data.int16 = *(int16_t*)(data);
518 break;
519 case OPAL_INT32:
520 kv->data.int32 = *(int32_t*)(data);
521 break;
522 case OPAL_INT64:
523 kv->data.int64 = *(int64_t*)(data);
524 break;
525
526 case OPAL_UINT:
527 kv->data.uint = *(unsigned int*)(data);
528 break;
529 case OPAL_UINT8:
530 kv->data.uint8 = *(uint8_t*)(data);
531 break;
532 case OPAL_UINT16:
533 kv->data.uint16 = *(uint16_t*)(data);
534 break;
535 case OPAL_UINT32:
536 kv->data.uint32 = *(uint32_t*)data;
537 break;
538 case OPAL_UINT64:
539 kv->data.uint64 = *(uint64_t*)(data);
540 break;
541
542 case OPAL_BYTE_OBJECT:
543 if (NULL != kv->data.bo.bytes) {
544 free(kv->data.bo.bytes);
545 }
546 boptr = (opal_byte_object_t*)data;
547 if (NULL != boptr && NULL != boptr->bytes && 0 < boptr->size) {
548 kv->data.bo.bytes = (uint8_t *) malloc(boptr->size);
549 memcpy(kv->data.bo.bytes, boptr->bytes, boptr->size);
550 kv->data.bo.size = boptr->size;
551 } else {
552 kv->data.bo.bytes = NULL;
553 kv->data.bo.size = 0;
554 }
555 break;
556
557 case OPAL_FLOAT:
558 kv->data.fval = *(float*)(data);
559 break;
560
561 case OPAL_TIMEVAL:
562 tv = (struct timeval*)data;
563 kv->data.tv.tv_sec = tv->tv_sec;
564 kv->data.tv.tv_usec = tv->tv_usec;
565 break;
566
567 case OPAL_PTR:
568 kv->data.ptr = data;
569 break;
570
571 case OPAL_VPID:
572 kv->data.vpid = *(orte_vpid_t *)data;
573 break;
574
575 case OPAL_JOBID:
576 kv->data.jobid = *(orte_jobid_t *)data;
577 break;
578
579 case OPAL_NAME:
580 kv->data.name = *(opal_process_name_t *)data;
581 break;
582
583 case OPAL_ENVAR:
584 OBJ_CONSTRUCT(&kv->data.envar, opal_envar_t);
585 envar = (opal_envar_t*)data;
586 if (NULL != envar->envar) {
587 kv->data.envar.envar = strdup(envar->envar);
588 }
589 if (NULL != envar->value) {
590 kv->data.envar.value = strdup(envar->value);
591 }
592 kv->data.envar.separator = envar->separator;
593 break;
594
595 default:
596 OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
597 return OPAL_ERR_NOT_SUPPORTED;
598 }
599 return OPAL_SUCCESS;
600 }
601
602 int orte_attr_unload(orte_attribute_t *kv,
603 void **data, opal_data_type_t type)
604 {
605 opal_byte_object_t *boptr;
606 opal_envar_t *envar;
607
608 if (type != kv->type) {
609 return OPAL_ERR_TYPE_MISMATCH;
610 }
611 if (NULL == data ||
612 (OPAL_STRING != type && OPAL_BYTE_OBJECT != type &&
613 OPAL_BUFFER != type && OPAL_PTR != type && NULL == *data)) {
614 assert(0);
615 OPAL_ERROR_LOG(OPAL_ERR_BAD_PARAM);
616 return OPAL_ERR_BAD_PARAM;
617 }
618
619 switch (type) {
620 case OPAL_BOOL:
621 memcpy(*data, &kv->data.flag, sizeof(bool));
622 break;
623 case OPAL_BYTE:
624 memcpy(*data, &kv->data.byte, sizeof(uint8_t));
625 break;
626 case OPAL_STRING:
627 if (NULL != kv->data.string) {
628 *data = strdup(kv->data.string);
629 } else {
630 *data = NULL;
631 }
632 break;
633 case OPAL_SIZE:
634 memcpy(*data, &kv->data.size, sizeof(size_t));
635 break;
636 case OPAL_PID:
637 memcpy(*data, &kv->data.pid, sizeof(pid_t));
638 break;
639
640 case OPAL_INT:
641 memcpy(*data, &kv->data.integer, sizeof(int));
642 break;
643 case OPAL_INT8:
644 memcpy(*data, &kv->data.int8, sizeof(int8_t));
645 break;
646 case OPAL_INT16:
647 memcpy(*data, &kv->data.int16, sizeof(int16_t));
648 break;
649 case OPAL_INT32:
650 memcpy(*data, &kv->data.int32, sizeof(int32_t));
651 break;
652 case OPAL_INT64:
653 memcpy(*data, &kv->data.int64, sizeof(int64_t));
654 break;
655
656 case OPAL_UINT:
657 memcpy(*data, &kv->data.uint, sizeof(unsigned int));
658 break;
659 case OPAL_UINT8:
660 memcpy(*data, &kv->data.uint8, 1);
661 break;
662 case OPAL_UINT16:
663 memcpy(*data, &kv->data.uint16, 2);
664 break;
665 case OPAL_UINT32:
666 memcpy(*data, &kv->data.uint32, 4);
667 break;
668 case OPAL_UINT64:
669 memcpy(*data, &kv->data.uint64, 8);
670 break;
671
672 case OPAL_BYTE_OBJECT:
673 boptr = (opal_byte_object_t*)malloc(sizeof(opal_byte_object_t));
674 if (NULL != kv->data.bo.bytes && 0 < kv->data.bo.size) {
675 boptr->bytes = (uint8_t *) malloc(kv->data.bo.size);
676 memcpy(boptr->bytes, kv->data.bo.bytes, kv->data.bo.size);
677 boptr->size = kv->data.bo.size;
678 } else {
679 boptr->bytes = NULL;
680 boptr->size = 0;
681 }
682 *data = boptr;
683 break;
684
685 case OPAL_BUFFER:
686 *data = OBJ_NEW(opal_buffer_t);
687 opal_dss.copy_payload(*data, &kv->data.buf);
688 break;
689
690 case OPAL_FLOAT:
691 memcpy(*data, &kv->data.fval, sizeof(float));
692 break;
693
694 case OPAL_TIMEVAL:
695 memcpy(*data, &kv->data.tv, sizeof(struct timeval));
696 break;
697
698 case OPAL_PTR:
699 *data = kv->data.ptr;
700 break;
701
702 case OPAL_VPID:
703 memcpy(*data, &kv->data.vpid, sizeof(orte_vpid_t));
704 break;
705
706 case OPAL_JOBID:
707 memcpy(*data, &kv->data.jobid, sizeof(orte_jobid_t));
708 break;
709
710 case OPAL_NAME:
711 memcpy(*data, &kv->data.name, sizeof(orte_process_name_t));
712 break;
713
714 case OPAL_ENVAR:
715 envar = OBJ_NEW(opal_envar_t);
716 if (NULL != kv->data.envar.envar) {
717 envar->envar = strdup(kv->data.envar.envar);
718 }
719 if (NULL != kv->data.envar.value) {
720 envar->value = strdup(kv->data.envar.value);
721 }
722 envar->separator = kv->data.envar.separator;
723 *data = envar;
724 break;
725
726 default:
727 OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED);
728 return OPAL_ERR_NOT_SUPPORTED;
729 }
730 return OPAL_SUCCESS;
731 }