This source file includes following definitions.
- opal_dss_unpack
- opal_dss_unpack_buffer
- opal_dss_unpack_bool
- opal_dss_unpack_int
- opal_dss_unpack_sizet
- opal_dss_unpack_pid
- opal_dss_unpack_null
- opal_dss_unpack_byte
- opal_dss_unpack_int16
- opal_dss_unpack_int32
- opal_dss_unpack_int64
- opal_dss_unpack_string
- opal_dss_unpack_float
- opal_dss_unpack_double
- opal_dss_unpack_timeval
- opal_dss_unpack_time
- opal_dss_unpack_data_type
- opal_dss_unpack_byte_object
- opal_dss_unpack_pstat
- unpack_disk_stats
- unpack_net_stats
- opal_dss_unpack_node_stat
- opal_dss_unpack_value
- opal_dss_unpack_buffer_contents
- opal_dss_unpack_name
- opal_dss_unpack_jobid
- opal_dss_unpack_vpid
- opal_dss_unpack_status
- opal_dss_unpack_envar
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 #include "opal_config.h"
25 #include "opal/types.h"
26 #include "opal/util/error.h"
27 #include "opal/util/output.h"
28 #include "opal/dss/dss_internal.h"
29
30 int opal_dss_unpack(opal_buffer_t *buffer, void *dst, int32_t *num_vals,
31 opal_data_type_t type)
32 {
33 int rc, ret;
34 int32_t local_num, n=1;
35 opal_data_type_t local_type;
36
37
38 if (NULL == buffer || NULL == dst || NULL == num_vals) {
39 return OPAL_ERR_BAD_PARAM;
40 }
41
42
43
44
45 if (0 == *num_vals) {
46 OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack: inadequate space ( %p, %p, %lu, %d )\n",
47 (void*)buffer, dst, (long unsigned int)*num_vals, (int)type ) );
48 return OPAL_ERR_UNPACK_INADEQUATE_SPACE;
49 }
50
51
52
53
54
55
56
57
58
59
60 if (OPAL_DSS_BUFFER_FULLY_DESC == buffer->type) {
61 if (OPAL_SUCCESS != (
62 rc = opal_dss_get_data_type(buffer, &local_type))) {
63 *num_vals = 0;
64 return rc;
65 }
66 if (OPAL_INT32 != local_type) {
67 *num_vals = 0;
68 return OPAL_ERR_UNPACK_FAILURE;
69 }
70 }
71
72 n=1;
73 if (OPAL_SUCCESS != (rc = opal_dss_unpack_int32(buffer, &local_num, &n, OPAL_INT32))) {
74 *num_vals = 0;
75 return rc;
76 }
77
78
79
80
81
82
83 if (local_num > *num_vals) {
84 local_num = *num_vals;
85 OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack: inadequate space ( %p, %p, %lu, %d )\n",
86 (void*)buffer, dst, (long unsigned int)*num_vals, (int)type ) );
87 ret = OPAL_ERR_UNPACK_INADEQUATE_SPACE;
88 } else {
89 *num_vals = local_num;
90 ret = OPAL_SUCCESS;
91 }
92
93
94 if (OPAL_SUCCESS != (rc = opal_dss_unpack_buffer(buffer, dst, &local_num, type))) {
95 *num_vals = 0;
96 ret = rc;
97 }
98
99 return ret;
100 }
101
102 int opal_dss_unpack_buffer(opal_buffer_t *buffer, void *dst, int32_t *num_vals,
103 opal_data_type_t type)
104 {
105 int rc;
106 opal_data_type_t local_type;
107 opal_dss_type_info_t *info;
108
109 OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack_buffer( %p, %p, %lu, %d )\n",
110 (void*)buffer, dst, (long unsigned int)*num_vals, (int)type ) );
111
112
113 if (OPAL_DSS_BUFFER_FULLY_DESC == buffer->type) {
114 if (OPAL_SUCCESS != (rc = opal_dss_get_data_type(buffer, &local_type))) {
115 return rc;
116 }
117
118 if (type != local_type) {
119 opal_output(0, "OPAL dss:unpack: got type %d when expecting type %d", local_type, type);
120 return OPAL_ERR_PACK_MISMATCH;
121 }
122 }
123
124
125
126 if (NULL == (info = (opal_dss_type_info_t*)opal_pointer_array_get_item(&opal_dss_types, type))) {
127 return OPAL_ERR_UNPACK_FAILURE;
128 }
129
130 return info->odti_unpack_fn(buffer, dst, num_vals, type);
131 }
132
133
134
135
136
137
138
139 int opal_dss_unpack_bool(opal_buffer_t *buffer, void *dest,
140 int32_t *num_vals, opal_data_type_t type)
141 {
142 int ret;
143 opal_data_type_t remote_type;
144
145 if (OPAL_DSS_BUFFER_FULLY_DESC == buffer->type) {
146
147 if (OPAL_SUCCESS != (ret = opal_dss_peek_type(buffer, &remote_type))) {
148 return ret;
149 }
150 } else {
151 if (OPAL_SUCCESS != (ret = opal_dss_get_data_type(buffer, &remote_type))) {
152 return ret;
153 }
154 }
155
156 if (remote_type == DSS_TYPE_BOOL) {
157
158
159 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, dest, num_vals, DSS_TYPE_BOOL))) {
160 }
161 } else {
162
163 UNPACK_SIZE_MISMATCH(bool, remote_type, ret);
164 }
165 return ret;
166 }
167
168
169
170
171 int opal_dss_unpack_int(opal_buffer_t *buffer, void *dest,
172 int32_t *num_vals, opal_data_type_t type)
173 {
174 int ret;
175 opal_data_type_t remote_type;
176
177 if (OPAL_DSS_BUFFER_FULLY_DESC == buffer->type) {
178
179 if (OPAL_SUCCESS != (ret = opal_dss_peek_type(buffer, &remote_type))) {
180 return ret;
181 }
182 } else {
183 if (OPAL_SUCCESS != (ret = opal_dss_get_data_type(buffer, &remote_type))) {
184 return ret;
185 }
186 }
187
188 if (remote_type == DSS_TYPE_INT) {
189
190
191 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, dest, num_vals, DSS_TYPE_INT))) {
192 }
193 } else {
194
195 UNPACK_SIZE_MISMATCH(int, remote_type, ret);
196 }
197
198 return ret;
199 }
200
201
202
203
204 int opal_dss_unpack_sizet(opal_buffer_t *buffer, void *dest,
205 int32_t *num_vals, opal_data_type_t type)
206 {
207 int ret;
208 opal_data_type_t remote_type;
209
210 if (OPAL_DSS_BUFFER_FULLY_DESC == buffer->type) {
211
212 if (OPAL_SUCCESS != (ret = opal_dss_peek_type(buffer, &remote_type))) {
213 return ret;
214 }
215 } else {
216 if (OPAL_SUCCESS != (ret = opal_dss_get_data_type(buffer, &remote_type))) {
217 return ret;
218 }
219 }
220
221 if (remote_type == DSS_TYPE_SIZE_T) {
222
223
224 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, dest, num_vals, DSS_TYPE_SIZE_T))) {
225 }
226 } else {
227
228 UNPACK_SIZE_MISMATCH(size_t, remote_type, ret);
229 }
230
231 return ret;
232 }
233
234
235
236
237 int opal_dss_unpack_pid(opal_buffer_t *buffer, void *dest,
238 int32_t *num_vals, opal_data_type_t type)
239 {
240 int ret;
241 opal_data_type_t remote_type;
242
243 if (OPAL_DSS_BUFFER_FULLY_DESC == buffer->type) {
244
245 if (OPAL_SUCCESS != (ret = opal_dss_peek_type(buffer, &remote_type))) {
246 return ret;
247 }
248 } else {
249 if (OPAL_SUCCESS != (ret = opal_dss_get_data_type(buffer, &remote_type))) {
250 return ret;
251 }
252 }
253
254 if (remote_type == DSS_TYPE_PID_T) {
255
256
257 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, dest, num_vals, DSS_TYPE_PID_T))) {
258 }
259 } else {
260
261 UNPACK_SIZE_MISMATCH(pid_t, remote_type, ret);
262 }
263
264 return ret;
265 }
266
267
268
269
270
271
272
273 int opal_dss_unpack_null(opal_buffer_t *buffer, void *dest,
274 int32_t *num_vals, opal_data_type_t type)
275 {
276 OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack_null * %d\n", (int)*num_vals ) );
277
278 if (opal_dss_too_small(buffer, *num_vals)) {
279 return OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
280 }
281
282
283 memcpy(dest, buffer->unpack_ptr, *num_vals);
284
285
286 buffer->unpack_ptr += *num_vals;
287
288 return OPAL_SUCCESS;
289 }
290
291
292
293
294 int opal_dss_unpack_byte(opal_buffer_t *buffer, void *dest,
295 int32_t *num_vals, opal_data_type_t type)
296 {
297 OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack_byte * %d\n", (int)*num_vals ) );
298
299 if (opal_dss_too_small(buffer, *num_vals)) {
300 return OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
301 }
302
303
304 memcpy(dest, buffer->unpack_ptr, *num_vals);
305
306
307 buffer->unpack_ptr += *num_vals;
308
309 return OPAL_SUCCESS;
310 }
311
312 int opal_dss_unpack_int16(opal_buffer_t *buffer, void *dest,
313 int32_t *num_vals, opal_data_type_t type)
314 {
315 int32_t i;
316 uint16_t tmp, *desttmp = (uint16_t*) dest;
317
318 OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack_int16 * %d\n", (int)*num_vals ) );
319
320 if (opal_dss_too_small(buffer, (*num_vals)*sizeof(tmp))) {
321 return OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
322 }
323
324
325 for (i = 0; i < (*num_vals); ++i) {
326 memcpy( &(tmp), buffer->unpack_ptr, sizeof(tmp) );
327 tmp = ntohs(tmp);
328 memcpy(&desttmp[i], &tmp, sizeof(tmp));
329 buffer->unpack_ptr += sizeof(tmp);
330 }
331
332 return OPAL_SUCCESS;
333 }
334
335 int opal_dss_unpack_int32(opal_buffer_t *buffer, void *dest,
336 int32_t *num_vals, opal_data_type_t type)
337 {
338 int32_t i;
339 uint32_t tmp, *desttmp = (uint32_t*) dest;
340
341 OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack_int32 * %d\n", (int)*num_vals ) );
342
343 if (opal_dss_too_small(buffer, (*num_vals)*sizeof(tmp))) {
344 return OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
345 }
346
347
348 for (i = 0; i < (*num_vals); ++i) {
349 memcpy( &(tmp), buffer->unpack_ptr, sizeof(tmp) );
350 tmp = ntohl(tmp);
351 memcpy(&desttmp[i], &tmp, sizeof(tmp));
352 buffer->unpack_ptr += sizeof(tmp);
353 }
354
355 return OPAL_SUCCESS;
356 }
357
358 int opal_dss_unpack_int64(opal_buffer_t *buffer, void *dest,
359 int32_t *num_vals, opal_data_type_t type)
360 {
361 int32_t i;
362 uint64_t tmp, *desttmp = (uint64_t*) dest;
363
364 OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack_int64 * %d\n", (int)*num_vals ) );
365
366 if (opal_dss_too_small(buffer, (*num_vals)*sizeof(tmp))) {
367 return OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
368 }
369
370
371 for (i = 0; i < (*num_vals); ++i) {
372 memcpy( &(tmp), buffer->unpack_ptr, sizeof(tmp) );
373 tmp = ntoh64(tmp);
374 memcpy(&desttmp[i], &tmp, sizeof(tmp));
375 buffer->unpack_ptr += sizeof(tmp);
376 }
377
378 return OPAL_SUCCESS;
379 }
380
381 int opal_dss_unpack_string(opal_buffer_t *buffer, void *dest,
382 int32_t *num_vals, opal_data_type_t type)
383 {
384 int ret;
385 int32_t i, len, n=1;
386 char **sdest = (char**) dest;
387
388 for (i = 0; i < (*num_vals); ++i) {
389 if (OPAL_SUCCESS != (ret = opal_dss_unpack_int32(buffer, &len, &n, OPAL_INT32))) {
390 return ret;
391 }
392 if (0 == len) {
393 sdest[i] = NULL;
394 } else {
395 sdest[i] = (char*)malloc(len);
396 if (NULL == sdest[i]) {
397 return OPAL_ERR_OUT_OF_RESOURCE;
398 }
399 if (OPAL_SUCCESS != (ret = opal_dss_unpack_byte(buffer, sdest[i], &len, OPAL_BYTE))) {
400 return ret;
401 }
402 }
403 }
404
405 return OPAL_SUCCESS;
406 }
407
408 int opal_dss_unpack_float(opal_buffer_t *buffer, void *dest,
409 int32_t *num_vals, opal_data_type_t type)
410 {
411 int32_t i, n;
412 float *desttmp = (float*) dest, tmp;
413 int ret;
414 char *convert;
415
416 OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack_float * %d\n", (int)*num_vals ) );
417
418 if (opal_dss_too_small(buffer, (*num_vals)*sizeof(float))) {
419 return OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
420 }
421
422
423 for (i = 0; i < (*num_vals); ++i) {
424 n=1;
425 if (OPAL_SUCCESS != (ret = opal_dss_unpack_string(buffer, &convert, &n, OPAL_STRING))) {
426 return ret;
427 }
428 if (NULL == convert) {
429 return OPAL_ERR_UNPACK_FAILURE;
430 }
431 tmp = strtof(convert, NULL);
432 memcpy(&desttmp[i], &tmp, sizeof(tmp));
433 free(convert);
434 convert = NULL;
435 }
436 return OPAL_SUCCESS;
437 }
438
439 int opal_dss_unpack_double(opal_buffer_t *buffer, void *dest,
440 int32_t *num_vals, opal_data_type_t type)
441 {
442 int32_t i, n;
443 double *desttmp = (double*) dest, tmp;
444 int ret;
445 char *convert;
446
447 OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack_double * %d\n", (int)*num_vals ) );
448
449 if (opal_dss_too_small(buffer, (*num_vals)*sizeof(double))) {
450 return OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
451 }
452
453
454 for (i = 0; i < (*num_vals); ++i) {
455 n=1;
456 if (OPAL_SUCCESS != (ret = opal_dss_unpack_string(buffer, &convert, &n, OPAL_STRING))) {
457 return ret;
458 }
459 if (NULL == convert) {
460 return OPAL_ERR_UNPACK_FAILURE;
461 }
462 tmp = strtod(convert, NULL);
463 memcpy(&desttmp[i], &tmp, sizeof(tmp));
464 free(convert);
465 convert = NULL;
466 }
467 return OPAL_SUCCESS;
468 }
469
470 int opal_dss_unpack_timeval(opal_buffer_t *buffer, void *dest,
471 int32_t *num_vals, opal_data_type_t type)
472 {
473 int32_t i, n;
474 int64_t tmp[2];
475 struct timeval *desttmp = (struct timeval *) dest, tt;
476 int ret;
477
478 OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack_timeval * %d\n", (int)*num_vals ) );
479
480 if (opal_dss_too_small(buffer, (*num_vals)*sizeof(struct timeval))) {
481 return OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
482 }
483
484
485 for (i = 0; i < (*num_vals); ++i) {
486 n=2;
487 if (OPAL_SUCCESS != (ret = opal_dss_unpack_int64(buffer, tmp, &n, OPAL_INT64))) {
488 return ret;
489 }
490 tt.tv_sec = tmp[0];
491 tt.tv_usec = tmp[1];
492 memcpy(&desttmp[i], &tt, sizeof(tt));
493 }
494 return OPAL_SUCCESS;
495 }
496
497 int opal_dss_unpack_time(opal_buffer_t *buffer, void *dest,
498 int32_t *num_vals, opal_data_type_t type)
499 {
500 int32_t i, n;
501 time_t *desttmp = (time_t *) dest, tmp;
502 int ret;
503 uint64_t ui64;
504
505
506
507
508
509 OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack_time * %d\n", (int)*num_vals ) );
510
511 if (opal_dss_too_small(buffer, (*num_vals)*(sizeof(uint64_t)))) {
512 return OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
513 }
514
515
516 for (i = 0; i < (*num_vals); ++i) {
517 n=1;
518 if (OPAL_SUCCESS != (ret = opal_dss_unpack_int64(buffer, &ui64, &n, OPAL_UINT64))) {
519 return ret;
520 }
521 tmp = (time_t)ui64;
522 memcpy(&desttmp[i], &tmp, sizeof(tmp));
523 }
524 return OPAL_SUCCESS;
525 }
526
527
528
529
530
531
532
533 int opal_dss_unpack_data_type(opal_buffer_t *buffer, void *dest, int32_t *num_vals,
534 opal_data_type_t type)
535 {
536
537 return opal_dss_unpack_buffer(buffer, dest, num_vals, OPAL_DATA_TYPE_T);
538 }
539
540
541
542
543 int opal_dss_unpack_byte_object(opal_buffer_t *buffer, void *dest, int32_t *num,
544 opal_data_type_t type)
545 {
546 int ret;
547 int32_t i, n, m=1;
548 opal_byte_object_t **dbyteptr;
549
550 dbyteptr = (opal_byte_object_t**)dest;
551 n = *num;
552 for(i=0; i<n; i++) {
553
554 dbyteptr[i] = (opal_byte_object_t*)malloc(sizeof(opal_byte_object_t));
555 if (NULL == dbyteptr[i]) {
556 return OPAL_ERR_OUT_OF_RESOURCE;
557 }
558
559
560 if (OPAL_SUCCESS != (ret = opal_dss_unpack_int32(buffer, &(dbyteptr[i]->size), &m, OPAL_INT32))) {
561 return ret;
562 }
563 if (0 < dbyteptr[i]->size) {
564 dbyteptr[i]->bytes = (uint8_t*)malloc(dbyteptr[i]->size);
565 if (NULL == dbyteptr[i]->bytes) {
566 return OPAL_ERR_OUT_OF_RESOURCE;
567 }
568 if (OPAL_SUCCESS != (ret = opal_dss_unpack_byte(buffer, (dbyteptr[i]->bytes),
569 &(dbyteptr[i]->size), OPAL_BYTE))) {
570 return ret;
571 }
572 } else {
573
574 dbyteptr[i]->bytes = NULL;
575 }
576 }
577
578 return OPAL_SUCCESS;
579 }
580
581
582
583
584 int opal_dss_unpack_pstat(opal_buffer_t *buffer, void *dest,
585 int32_t *num_vals, opal_data_type_t type)
586 {
587 opal_pstats_t **ptr;
588 int32_t i, n, m;
589 int ret;
590 char *cptr;
591
592 ptr = (opal_pstats_t **) dest;
593 n = *num_vals;
594
595 for (i = 0; i < n; ++i) {
596
597 ptr[i] = OBJ_NEW(opal_pstats_t);
598 if (NULL == ptr[i]) {
599 return OPAL_ERR_OUT_OF_RESOURCE;
600 }
601 m=1;
602 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &cptr, &m, OPAL_STRING))) {
603 OPAL_ERROR_LOG(ret);
604 return ret;
605 }
606 memmove(ptr[i]->node, cptr, strlen(cptr));
607 free(cptr);
608 m=1;
609 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->rank, &m, OPAL_INT32))) {
610 OPAL_ERROR_LOG(ret);
611 return ret;
612 }
613 m=1;
614 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->pid, &m, OPAL_PID))) {
615 OPAL_ERROR_LOG(ret);
616 return ret;
617 }
618 m=1;
619 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &cptr, &m, OPAL_STRING))) {
620 OPAL_ERROR_LOG(ret);
621 return ret;
622 }
623 memmove(ptr[i]->cmd, cptr, strlen(cptr));
624 free(cptr);
625 m=1;
626 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->state[0], &m, OPAL_BYTE))) {
627 OPAL_ERROR_LOG(ret);
628 return ret;
629 }
630 m=1;
631 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->time, &m, OPAL_TIMEVAL))) {
632 OPAL_ERROR_LOG(ret);
633 return ret;
634 }
635 m=1;
636 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->priority, &m, OPAL_INT32))) {
637 OPAL_ERROR_LOG(ret);
638 return ret;
639 }
640 m=1;
641 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->num_threads, &m, OPAL_INT16))) {
642 OPAL_ERROR_LOG(ret);
643 return ret;
644 }
645 m=1;
646 if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->pss, &m, OPAL_FLOAT))) {
647 OPAL_ERROR_LOG(ret);
648 return ret;
649 }
650 m=1;
651 if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->vsize, &m, OPAL_FLOAT))) {
652 OPAL_ERROR_LOG(ret);
653 return ret;
654 }
655 m=1;
656 if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->rss, &m, OPAL_FLOAT))) {
657 OPAL_ERROR_LOG(ret);
658 return ret;
659 }
660 m=1;
661 if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->peak_vsize, &m, OPAL_FLOAT))) {
662 OPAL_ERROR_LOG(ret);
663 return ret;
664 }
665 m=1;
666 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->processor, &m, OPAL_INT16))) {
667 OPAL_ERROR_LOG(ret);
668 return ret;
669 }
670 m=1;
671 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->sample_time, &m, OPAL_TIMEVAL))) {
672 OPAL_ERROR_LOG(ret);
673 return ret;
674 }
675 }
676
677 return OPAL_SUCCESS;
678 }
679
680 static int unpack_disk_stats(opal_buffer_t *buffer, opal_node_stats_t *ns)
681 {
682 int32_t i, m, n;
683 int ret;
684 opal_diskstats_t *dk;
685 uint64_t i64;
686
687
688 m=1;
689 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &n, &m, OPAL_INT32))) {
690 OPAL_ERROR_LOG(ret);
691 return ret;
692 }
693
694 for (i=0; i < n; i++) {
695 dk = OBJ_NEW(opal_diskstats_t);
696 assert(dk);
697 m=1;
698 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &dk->disk, &m, OPAL_STRING))) {
699 OPAL_ERROR_LOG(ret);
700 OBJ_RELEASE(dk);
701 return ret;
702 }
703 m=1;
704 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
705 OPAL_ERROR_LOG(ret);
706 OBJ_RELEASE(dk);
707 return ret;
708 }
709 dk->num_reads_completed = i64;
710 m=1;
711 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
712 OPAL_ERROR_LOG(ret);
713 OBJ_RELEASE(dk);
714 return ret;
715 }
716 dk->num_reads_merged = i64;
717 m=1;
718 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
719 OPAL_ERROR_LOG(ret);
720 OBJ_RELEASE(dk);
721 return ret;
722 }
723 dk->num_sectors_read = i64;
724 m=1;
725 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
726 OPAL_ERROR_LOG(ret);
727 OBJ_RELEASE(dk);
728 return ret;
729 }
730 dk->milliseconds_reading = i64;
731 m=1;
732 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
733 OPAL_ERROR_LOG(ret);
734 OBJ_RELEASE(dk);
735 return ret;
736 }
737 dk->num_writes_completed = i64;
738 m=1;
739 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
740 OPAL_ERROR_LOG(ret);
741 OBJ_RELEASE(dk);
742 return ret;
743 }
744 dk->num_writes_merged = i64;
745 m=1;
746 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
747 OPAL_ERROR_LOG(ret);
748 OBJ_RELEASE(dk);
749 return ret;
750 }
751 dk->num_sectors_written = i64;
752 m=1;
753 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
754 OPAL_ERROR_LOG(ret);
755 OBJ_RELEASE(dk);
756 return ret;
757 }
758 dk->milliseconds_writing = i64;
759 m=1;
760 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
761 OPAL_ERROR_LOG(ret);
762 OBJ_RELEASE(dk);
763 return ret;
764 }
765 dk->num_ios_in_progress = i64;
766 m=1;
767 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
768 OPAL_ERROR_LOG(ret);
769 OBJ_RELEASE(dk);
770 return ret;
771 }
772 dk->milliseconds_io = i64;
773 m=1;
774 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
775 OPAL_ERROR_LOG(ret);
776 OBJ_RELEASE(dk);
777 return ret;
778 }
779 dk->weighted_milliseconds_io = i64;
780 opal_list_append(&ns->diskstats, &dk->super);
781 }
782 return OPAL_SUCCESS;
783 }
784
785 static int unpack_net_stats(opal_buffer_t *buffer, opal_node_stats_t *ns)
786 {
787 int32_t i, m, n;
788 int ret;
789 opal_netstats_t *net;
790 uint64_t i64;
791
792
793 m=1;
794 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &n, &m, OPAL_INT32))) {
795 OPAL_ERROR_LOG(ret);
796 return ret;
797 }
798
799 for (i=0; i < n; i++) {
800 net = OBJ_NEW(opal_netstats_t);
801 assert(net);
802 m=1;
803 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &net->net_interface, &m, OPAL_STRING))) {
804 OPAL_ERROR_LOG(ret);
805 OBJ_RELEASE(net);
806 return ret;
807 }
808 m=1;
809 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
810 OPAL_ERROR_LOG(ret);
811 OBJ_RELEASE(net);
812 return ret;
813 }
814 net->num_bytes_recvd = i64;
815 m=1;
816 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
817 OPAL_ERROR_LOG(ret);
818 OBJ_RELEASE(net);
819 return ret;
820 }
821 net->num_packets_recvd = i64;
822 m=1;
823 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
824 OPAL_ERROR_LOG(ret);
825 OBJ_RELEASE(net);
826 return ret;
827 }
828 net->num_recv_errs = i64;
829 m=1;
830 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
831 OPAL_ERROR_LOG(ret);
832 OBJ_RELEASE(net);
833 return ret;
834 }
835 net->num_bytes_sent = i64;
836 m=1;
837 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
838 OPAL_ERROR_LOG(ret);
839 OBJ_RELEASE(net);
840 return ret;
841 }
842 net->num_packets_sent = i64;
843 m=1;
844 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
845 OPAL_ERROR_LOG(ret);
846 OBJ_RELEASE(net);
847 return ret;
848 }
849 net->num_send_errs = i64;
850 opal_list_append(&ns->netstats, &net->super);
851 }
852 return OPAL_SUCCESS;
853 }
854
855
856
857
858 int opal_dss_unpack_node_stat(opal_buffer_t *buffer, void *dest,
859 int32_t *num_vals, opal_data_type_t type)
860 {
861 opal_node_stats_t **ptr;
862 int32_t i, n, m;
863 int ret;
864
865 ptr = (opal_node_stats_t **) dest;
866 n = *num_vals;
867
868 for (i = 0; i < n; ++i) {
869
870 ptr[i] = OBJ_NEW(opal_node_stats_t);
871 if (NULL == ptr[i]) {
872 return OPAL_ERR_OUT_OF_RESOURCE;
873 }
874 m=1;
875 if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->la, &m, OPAL_FLOAT))) {
876 OPAL_ERROR_LOG(ret);
877 return ret;
878 }
879 m=1;
880 if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->la5, &m, OPAL_FLOAT))) {
881 OPAL_ERROR_LOG(ret);
882 return ret;
883 }
884 m=1;
885 if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->la15, &m, OPAL_FLOAT))) {
886 OPAL_ERROR_LOG(ret);
887 return ret;
888 }
889 m=1;
890 if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->total_mem, &m, OPAL_FLOAT))) {
891 OPAL_ERROR_LOG(ret);
892 return ret;
893 }
894 m=1;
895 if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->free_mem, &m, OPAL_FLOAT))) {
896 OPAL_ERROR_LOG(ret);
897 return ret;
898 }
899 m=1;
900 if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->buffers, &m, OPAL_FLOAT))) {
901 OPAL_ERROR_LOG(ret);
902 return ret;
903 }
904 m=1;
905 if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->cached, &m, OPAL_FLOAT))) {
906 OPAL_ERROR_LOG(ret);
907 return ret;
908 }
909 m=1;
910 if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->swap_cached, &m, OPAL_FLOAT))) {
911 OPAL_ERROR_LOG(ret);
912 return ret;
913 }
914 m=1;
915 if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->swap_total, &m, OPAL_FLOAT))) {
916 OPAL_ERROR_LOG(ret);
917 return ret;
918 }
919 m=1;
920 if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->swap_free, &m, OPAL_FLOAT))) {
921 OPAL_ERROR_LOG(ret);
922 return ret;
923 }
924 m=1;
925 if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->mapped, &m, OPAL_FLOAT))) {
926 OPAL_ERROR_LOG(ret);
927 return ret;
928 }
929 m=1;
930 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->sample_time, &m, OPAL_TIMEVAL))) {
931 OPAL_ERROR_LOG(ret);
932 return ret;
933 }
934
935 if (OPAL_SUCCESS != (ret = unpack_disk_stats(buffer, ptr[i]))) {
936 OPAL_ERROR_LOG(ret);
937 return ret;
938 }
939
940 if (OPAL_SUCCESS != (ret = unpack_net_stats(buffer, ptr[i]))) {
941 OPAL_ERROR_LOG(ret);
942 return ret;
943 }
944 OBJ_RELEASE(ptr[i]);
945 }
946
947 return OPAL_SUCCESS;
948 }
949
950
951
952
953 int opal_dss_unpack_value(opal_buffer_t *buffer, void *dest,
954 int32_t *num_vals, opal_data_type_t type)
955 {
956 opal_value_t **ptr;
957 int32_t i, n, m;
958 int ret;
959
960 ptr = (opal_value_t **) dest;
961 n = *num_vals;
962
963 for (i = 0; i < n; ++i) {
964
965 ptr[i] = OBJ_NEW(opal_value_t);
966 if (NULL == ptr[i]) {
967 return OPAL_ERR_OUT_OF_RESOURCE;
968 }
969
970 m=1;
971 if (OPAL_SUCCESS != (ret = opal_dss_unpack_string(buffer, &ptr[i]->key, &m, OPAL_STRING))) {
972 return ret;
973 }
974 m=1;
975 if (OPAL_SUCCESS != (ret = opal_dss_unpack_data_type(buffer, &ptr[i]->type, &m, OPAL_DATA_TYPE))) {
976 return ret;
977 }
978
979 m=1;
980 switch (ptr[i]->type) {
981 case OPAL_BOOL:
982 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.flag, &m, OPAL_BOOL))) {
983 return ret;
984 }
985 break;
986 case OPAL_BYTE:
987 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.byte, &m, OPAL_BYTE))) {
988 return ret;
989 }
990 break;
991 case OPAL_STRING:
992 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.string, &m, OPAL_STRING))) {
993 return ret;
994 }
995 break;
996 case OPAL_SIZE:
997 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.size, &m, OPAL_SIZE))) {
998 return ret;
999 }
1000 break;
1001 case OPAL_PID:
1002 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.pid, &m, OPAL_PID))) {
1003 return ret;
1004 }
1005 break;
1006 case OPAL_INT:
1007 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.integer, &m, OPAL_INT))) {
1008 return ret;
1009 }
1010 break;
1011 case OPAL_INT8:
1012 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.int8, &m, OPAL_INT8))) {
1013 return ret;
1014 }
1015 break;
1016 case OPAL_INT16:
1017 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.int16, &m, OPAL_INT16))) {
1018 return ret;
1019 }
1020 break;
1021 case OPAL_INT32:
1022 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.int32, &m, OPAL_INT32))) {
1023 return ret;
1024 }
1025 break;
1026 case OPAL_INT64:
1027 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.int64, &m, OPAL_INT64))) {
1028 return ret;
1029 }
1030 break;
1031 case OPAL_UINT:
1032 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.uint, &m, OPAL_UINT))) {
1033 return ret;
1034 }
1035 break;
1036 case OPAL_UINT8:
1037 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.uint8, &m, OPAL_UINT8))) {
1038 return ret;
1039 }
1040 break;
1041 case OPAL_UINT16:
1042 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.uint16, &m, OPAL_UINT16))) {
1043 return ret;
1044 }
1045 break;
1046 case OPAL_UINT32:
1047 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.uint32, &m, OPAL_UINT32))) {
1048 return ret;
1049 }
1050 break;
1051 case OPAL_UINT64:
1052 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.uint64, &m, OPAL_UINT64))) {
1053 return ret;
1054 }
1055 break;
1056 case OPAL_BYTE_OBJECT:
1057
1058 if (OPAL_SUCCESS != (ret = opal_dss_unpack_int32(buffer, &(ptr[i]->data.bo.size), &m, OPAL_INT32))) {
1059 return ret;
1060 }
1061 if (0 < ptr[i]->data.bo.size) {
1062 ptr[i]->data.bo.bytes = (uint8_t*)malloc(ptr[i]->data.bo.size);
1063 if (NULL == ptr[i]->data.bo.bytes) {
1064 return OPAL_ERR_OUT_OF_RESOURCE;
1065 }
1066 if (OPAL_SUCCESS != (ret = opal_dss_unpack_byte(buffer, ptr[i]->data.bo.bytes,
1067 &(ptr[i]->data.bo.size), OPAL_BYTE))) {
1068 return ret;
1069 }
1070 } else {
1071 ptr[i]->data.bo.bytes = NULL;
1072 }
1073 break;
1074 case OPAL_FLOAT:
1075 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.fval, &m, OPAL_FLOAT))) {
1076 return ret;
1077 }
1078 break;
1079 case OPAL_DOUBLE:
1080 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.dval, &m, OPAL_DOUBLE))) {
1081 return ret;
1082 }
1083 break;
1084 case OPAL_TIMEVAL:
1085 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.tv, &m, OPAL_TIMEVAL))) {
1086 return ret;
1087 }
1088 break;
1089 case OPAL_PTR:
1090
1091 break;
1092 case OPAL_NAME:
1093 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.name, &m, OPAL_NAME))) {
1094 return ret;
1095 }
1096 break;
1097 case OPAL_STATUS:
1098 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.status, &m, OPAL_INT))) {
1099 return ret;
1100 }
1101 break;
1102 case OPAL_ENVAR:
1103 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.envar, &m, OPAL_ENVAR))) {
1104 return ret;
1105 }
1106 break;
1107 default:
1108 opal_output(0, "UNPACK-OPAL-VALUE: UNSUPPORTED TYPE %d FOR KEY %s", (int)ptr[i]->type, ptr[i]->key);
1109 return OPAL_ERROR;
1110 }
1111 }
1112
1113 return OPAL_SUCCESS;
1114 }
1115
1116
1117
1118
1119 int opal_dss_unpack_buffer_contents(opal_buffer_t *buffer, void *dest,
1120 int32_t *num_vals, opal_data_type_t type)
1121 {
1122 opal_buffer_t **ptr;
1123 int32_t i, n, m;
1124 int ret;
1125 size_t nbytes;
1126
1127 ptr = (opal_buffer_t **) dest;
1128 n = *num_vals;
1129
1130 for (i = 0; i < n; ++i) {
1131
1132 ptr[i] = OBJ_NEW(opal_buffer_t);
1133 if (NULL == ptr[i]) {
1134 return OPAL_ERR_OUT_OF_RESOURCE;
1135 }
1136
1137 m=1;
1138 if (OPAL_SUCCESS != (ret = opal_dss_unpack_sizet(buffer, &nbytes, &m, OPAL_SIZE))) {
1139 return ret;
1140 }
1141 m = nbytes;
1142
1143 if (0 < nbytes) {
1144 ptr[i]->base_ptr = (char*)malloc(nbytes);
1145
1146 if (OPAL_SUCCESS != (ret = opal_dss_unpack_byte(buffer, ptr[i]->base_ptr, &m, OPAL_BYTE))) {
1147 return ret;
1148 }
1149 }
1150 ptr[i]->pack_ptr = ptr[i]->base_ptr + m;
1151 ptr[i]->unpack_ptr = ptr[i]->base_ptr;
1152 ptr[i]->bytes_allocated = nbytes;
1153 ptr[i]->bytes_used = m;
1154 }
1155 return OPAL_SUCCESS;
1156 }
1157
1158
1159
1160
1161 int opal_dss_unpack_name(opal_buffer_t *buffer, void *dest,
1162 int32_t *num_vals, opal_data_type_t type)
1163 {
1164 int rc;
1165 int32_t i, num;
1166 opal_process_name_t* proc;
1167 opal_jobid_t *jobid;
1168 opal_vpid_t *vpid;
1169
1170 num = *num_vals;
1171
1172
1173 jobid = (opal_jobid_t*)malloc(num * sizeof(opal_jobid_t));
1174 if (NULL == jobid) {
1175 OPAL_ERROR_LOG(OPAL_ERR_OUT_OF_RESOURCE);
1176 *num_vals = 0;
1177 return OPAL_ERR_OUT_OF_RESOURCE;
1178 }
1179
1180 if (OPAL_SUCCESS != (rc =
1181 opal_dss_unpack_jobid(buffer, jobid, num_vals, OPAL_JOBID))) {
1182 OPAL_ERROR_LOG(rc);
1183 *num_vals = 0;
1184 free(jobid);
1185 return rc;
1186 }
1187
1188
1189 vpid = (opal_vpid_t*)malloc(num * sizeof(opal_vpid_t));
1190 if (NULL == vpid) {
1191 OPAL_ERROR_LOG(OPAL_ERR_OUT_OF_RESOURCE);
1192 *num_vals = 0;
1193 free(jobid);
1194 return OPAL_ERR_OUT_OF_RESOURCE;
1195 }
1196
1197 if (OPAL_SUCCESS != (rc =
1198 opal_dss_unpack_vpid(buffer, vpid, num_vals, OPAL_VPID))) {
1199 OPAL_ERROR_LOG(rc);
1200 *num_vals = 0;
1201 free(vpid);
1202 free(jobid);
1203 return rc;
1204 }
1205
1206
1207 proc = (opal_process_name_t*)dest;
1208 for (i=0; i < num; i++) {
1209 proc->jobid = jobid[i];
1210 proc->vpid = vpid[i];
1211 proc++;
1212 }
1213
1214
1215 free(vpid);
1216 free(jobid);
1217
1218 return OPAL_SUCCESS;
1219 }
1220
1221
1222
1223
1224 int opal_dss_unpack_jobid(opal_buffer_t *buffer, void *dest,
1225 int32_t *num_vals, opal_data_type_t type)
1226 {
1227 int ret;
1228
1229
1230 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, dest, num_vals, OPAL_JOBID_T))) {
1231 OPAL_ERROR_LOG(ret);
1232 }
1233
1234 return ret;
1235 }
1236
1237
1238
1239
1240 int opal_dss_unpack_vpid(opal_buffer_t *buffer, void *dest,
1241 int32_t *num_vals, opal_data_type_t type)
1242 {
1243 int ret;
1244
1245
1246 if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, dest, num_vals, OPAL_VPID_T))) {
1247 OPAL_ERROR_LOG(ret);
1248 }
1249
1250 return ret;
1251 }
1252
1253
1254
1255
1256 int opal_dss_unpack_status(opal_buffer_t *buffer, void *dest,
1257 int32_t *num_vals, opal_data_type_t type)
1258 {
1259 int ret;
1260
1261
1262 ret = opal_dss_unpack_buffer(buffer, dest, num_vals, OPAL_INT);
1263 if (OPAL_SUCCESS != ret) {
1264 OPAL_ERROR_LOG(ret);
1265 }
1266
1267 return ret;
1268 }
1269
1270
1271 int opal_dss_unpack_envar(opal_buffer_t *buffer, void *dest,
1272 int32_t *num_vals, opal_data_type_t type)
1273 {
1274 opal_envar_t *ptr;
1275 int32_t i, n, m;
1276 int ret;
1277
1278 ptr = (opal_envar_t *) dest;
1279 n = *num_vals;
1280
1281 for (i = 0; i < n; ++i) {
1282 m=1;
1283 if (OPAL_SUCCESS != (ret = opal_dss_unpack_string(buffer, &ptr[i].envar, &m, OPAL_STRING))) {
1284 OPAL_ERROR_LOG(ret);
1285 return ret;
1286 }
1287 m=1;
1288 if (OPAL_SUCCESS != (ret = opal_dss_unpack_string(buffer, &ptr[i].value, &m, OPAL_STRING))) {
1289 OPAL_ERROR_LOG(ret);
1290 return ret;
1291 }
1292 m=1;
1293 if (OPAL_SUCCESS != (ret = opal_dss_unpack_byte(buffer, &ptr[i].separator, &m, OPAL_BYTE))) {
1294 OPAL_ERROR_LOG(ret);
1295 return ret;
1296 }
1297 }
1298
1299 return OPAL_SUCCESS;
1300 }