1 /*****************************************************************************\
2 * slurm_protocol_defs.c - functions for initializing and releasing
3 * storage for RPC data structures. these are the functions used by
4 * the slurm daemons directly, not for user client use.
5 *****************************************************************************
6 * Portions Copyright (C) 2010-2017 SchedMD LLC <https://www.schedmd.com>.
7 * Copyright (C) 2002-2007 The Regents of the University of California.
8 * Copyright (C) 2008-2010 Lawrence Livermore National Security.
9 * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
10 * Written by Kevin Tew <tew1@llnl.gov> et. al.
11 * CODE-OCEC-09-009. All rights reserved.
12 *
13 * This file is part of Slurm, a resource management program.
14 * For details, see <https://slurm.schedmd.com/>.
15 * Please also read the included file: DISCLAIMER.
16 *
17 * Slurm is free software; you can redistribute it and/or modify it under
18 * the terms of the GNU General Public License as published by the Free
19 * Software Foundation; either version 2 of the License, or (at your option)
20 * any later version.
21 *
22 * In addition, as a special exception, the copyright holders give permission
23 * to link the code of portions of this program with the OpenSSL library under
24 * certain conditions as described in each individual source file, and
25 * distribute linked combinations including the two. You must obey the GNU
26 * General Public License in all respects for all of the code used other than
27 * OpenSSL. If you modify file(s) with this exception, you may extend this
28 * exception to your version of the file(s), but you are not obligated to do
29 * so. If you do not wish to do so, delete this exception statement from your
30 * version. If you delete this exception statement from all source files in
31 * the program, then also delete it here.
32 *
33 * Slurm is distributed in the hope that it will be useful, but WITHOUT ANY
34 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
35 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
36 * details.
37 *
38 * You should have received a copy of the GNU General Public License along
39 * with Slurm; if not, write to the Free Software Foundation, Inc.,
40 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
41 \*****************************************************************************/
42
43 #include <ctype.h>
44 #include <stdio.h>
45 #include <stdlib.h>
46
47 #include "src/common/forward.h"
48 #include "src/common/job_options.h"
49 #include "src/common/log.h"
50 #include "src/common/node_select.h"
51 #include "src/common/parse_time.h"
52 #include "src/common/power.h"
53 #include "src/common/slurm_accounting_storage.h"
54 #include "src/common/slurm_acct_gather_energy.h"
55 #include "src/common/slurm_cred.h"
56 #include "src/common/slurm_ext_sensors.h"
57 #include "src/common/slurm_jobacct_gather.h"
58 #include "src/common/slurm_protocol_defs.h"
59 #include "src/common/slurm_time.h"
60 #include "src/common/switch.h"
61 #include "src/common/uid.h"
62 #include "src/common/xmalloc.h"
63 #include "src/common/xstring.h"
64
65 /*
66 ** Define slurm-specific aliases for use by plugins, see slurm_xlator.h
67 ** for details.
68 */
69 strong_alias(preempt_mode_string, slurm_preempt_mode_string);
70 strong_alias(preempt_mode_num, slurm_preempt_mode_num);
71 strong_alias(job_reason_string, slurm_job_reason_string);
72 strong_alias(job_reason_num, slurm_job_reason_num);
73 strong_alias(job_share_string, slurm_job_share_string);
74 strong_alias(job_state_string, slurm_job_state_string);
75 strong_alias(job_state_string_compact, slurm_job_state_string_compact);
76 strong_alias(job_state_num, slurm_job_state_num);
77 strong_alias(node_state_string, slurm_node_state_string);
78 strong_alias(node_state_string_compact, slurm_node_state_string_compact);
79 strong_alias(private_data_string, slurm_private_data_string);
80 strong_alias(accounting_enforce_string, slurm_accounting_enforce_string);
81 strong_alias(cray_nodelist2nids, slurm_cray_nodelist2nids);
82 strong_alias(reservation_flags_string, slurm_reservation_flags_string);
83 strong_alias(print_multi_line_string, slurm_print_multi_line_string);
84
85 static void _free_all_front_end_info(front_end_info_msg_t *msg);
86
87 static void _free_all_job_info (job_info_msg_t *msg);
88
89 static void _free_all_node_info (node_info_msg_t *msg);
90
91 static void _free_all_partitions (partition_info_msg_t *msg);
92
93 static void _free_all_reservations(reserve_info_msg_t *msg);
94
95 static void _free_all_step_info (job_step_info_response_msg_t *msg);
96
_convert_to_id(char * name,bool gid)97 static char *_convert_to_id(char *name, bool gid)
98 {
99 if (gid) {
100 gid_t gid;
101 if (gid_from_string( name, &gid )) {
102 error("Invalid group id: %s", name);
103 return NULL;
104 }
105 xfree(name);
106 name = xstrdup_printf( "%d", (int) gid );
107 } else {
108 uid_t uid;
109 if (uid_from_string( name, &uid )) {
110 error("Invalid user id: %s", name);
111 return NULL;
112 }
113 xfree(name);
114 name = xstrdup_printf( "%d", (int) uid );
115 }
116 return name;
117 }
118
119 /*
120 * slurm_msg_t_init - initialize a slurm message
121 * OUT msg - pointer to the slurm_msg_t structure which will be initialized
122 */
slurm_msg_t_init(slurm_msg_t * msg)123 extern void slurm_msg_t_init(slurm_msg_t *msg)
124 {
125 memset(msg, 0, sizeof(slurm_msg_t));
126
127 msg->conn_fd = -1;
128 msg->msg_type = NO_VAL16;
129 msg->protocol_version = NO_VAL16;
130
131 #ifndef NDEBUG
132 msg->flags = drop_priv_flag;
133 #endif
134
135 forward_init(&msg->forward);
136 }
137
138 /*
139 * slurm_msg_t_copy - initialize a slurm_msg_t structure "dest" with
140 * values from the "src" slurm_msg_t structure.
141 * IN src - Pointer to the initialized message from which "dest" will
142 * be initialized.
143 * OUT dest - Pointer to the slurm_msg_t which will be initialized.
144 * NOTE: the "dest" structure will contain pointers into the contents of "src".
145 */
slurm_msg_t_copy(slurm_msg_t * dest,slurm_msg_t * src)146 extern void slurm_msg_t_copy(slurm_msg_t *dest, slurm_msg_t *src)
147 {
148 slurm_msg_t_init(dest);
149 dest->protocol_version = src->protocol_version;
150 dest->forward = src->forward;
151 dest->ret_list = src->ret_list;
152 dest->forward_struct = src->forward_struct;
153 dest->orig_addr.sin_addr.s_addr = 0;
154 return;
155 }
156
157 /* here to add \\ to all \" in a string this needs to be xfreed later */
slurm_add_slash_to_quotes(char * str)158 extern char *slurm_add_slash_to_quotes(char *str)
159 {
160 char *dup, *copy = NULL;
161 int len = 0;
162 if (!str || !(len = strlen(str)))
163 return NULL;
164
165 /* make a buffer 2 times the size just to be safe */
166 copy = dup = xmalloc((2 * len) + 1);
167 if (copy)
168 do if (*str == '\\' || *str == '\'' || *str == '"')
169 *dup++ = '\\';
170 while ((*dup++ = *str++));
171
172 return copy;
173 }
174
slurm_copy_char_list(List char_list)175 extern List slurm_copy_char_list(List char_list)
176 {
177 List ret_list = NULL;
178 char *tmp_char = NULL;
179 ListIterator itr = NULL;
180
181 if (!char_list || !list_count(char_list))
182 return NULL;
183
184 itr = list_iterator_create(char_list);
185 ret_list = list_create(xfree_ptr);
186
187 while ((tmp_char = list_next(itr)))
188 list_append(ret_list, xstrdup(tmp_char));
189
190 list_iterator_destroy(itr);
191
192 return ret_list;
193 }
194
slurm_find_char_in_list(void * x,void * key)195 extern int slurm_find_char_in_list(void *x, void *key)
196 {
197 char *char1 = (char *)x;
198 char *char2 = (char *)key;
199
200 if (!xstrcasecmp(char1, char2))
201 return 1;
202
203 return 0;
204 }
205
_char_list_append_str(void * x,void * arg)206 static int _char_list_append_str(void *x, void *arg)
207 {
208 char *char_item = (char *)x;
209 char **out_str = (char **)arg;
210
211 xassert(char_item);
212 xassert(out_str);
213
214 xstrfmtcat(*out_str, "%s%s", *out_str ? "," : "", char_item);
215
216 return SLURM_SUCCESS;
217 }
218
slurm_char_list_to_xstr(List char_list)219 extern char *slurm_char_list_to_xstr(List char_list)
220 {
221 char *out = NULL;
222
223 if (!char_list)
224 return NULL;
225
226 list_sort(char_list, (ListCmpF)slurm_sort_char_list_asc);
227 list_for_each(char_list, _char_list_append_str, &out);
228
229 return out;
230 }
231
_char_list_copy(void * item,void * dst)232 static int _char_list_copy(void *item, void *dst)
233 {
234 list_append((List)dst, xstrdup((char *)item));
235 return SLURM_SUCCESS;
236 }
237
slurm_char_list_copy(List dst,List src)238 extern int slurm_char_list_copy(List dst, List src)
239 {
240 xassert(dst);
241 xassert(src);
242
243 list_for_each(src, _char_list_copy, dst);
244
245 return SLURM_SUCCESS;
246 }
247
slurm_addto_char_list(List char_list,char * names)248 extern int slurm_addto_char_list(List char_list, char *names)
249 {
250 return slurm_addto_char_list_with_case(char_list, names, true);
251 }
252
253 /* returns number of objects added to list */
slurm_addto_char_list_with_case(List char_list,char * names,bool lower_case_normalization)254 extern int slurm_addto_char_list_with_case(List char_list, char *names,
255 bool lower_case_normalization)
256 {
257 int i = 0, start = 0, cnt = 0;
258 char *name = NULL;
259 ListIterator itr = NULL;
260 char quote_c = '\0';
261 int quote = 0;
262 int count = 0;
263 bool brack_not = false;
264 bool first_brack = false;
265 char *this_node_name;
266 char *tmp_this_node_name;
267 hostlist_t host_list;
268
269 if (!char_list) {
270 error("No list was given to fill in");
271 return 0;
272 }
273
274 itr = list_iterator_create(char_list);
275 if (names) {
276 if (names[i] == '\"' || names[i] == '\'') {
277 quote_c = names[i];
278 quote = 1;
279 i++;
280 }
281 start = i;
282 cnt = list_count(char_list);
283 while (names[i]) {
284 //info("got %d - %d = %d", i, start, i-start);
285 if (quote && (names[i] == quote_c))
286 break;
287 else if ((names[i] == '\"') || (names[i] == '\''))
288 names[i] = '`';
289 else if (names[i] == '[')
290 /*
291 * Make sure there is a open bracket. This
292 * check is to allow comma sperated notation
293 * within the bracket (e.g. "linux[0-1,2]").
294 */
295 first_brack = true;
296 else if (names[i] == ',' && !first_brack) {
297 /* Check that the string before , was
298 * not a [] notation value */
299 if (!brack_not) {
300 /*
301 * If there is a comma at the end just
302 * ignore it
303 */
304 if (!names[i+1])
305 break;
306
307 name = xstrndup(names+start,
308 (i-start));
309 //info("got %s %d", name, i-start);
310
311 /*
312 * If we get a duplicate remove the
313 * first one and tack this on the end.
314 * This is needed for get associations
315 * with QOS.
316 */
317 if (list_find(itr,
318 slurm_find_char_in_list,
319 name)) {
320 list_delete_item(itr);
321 } else
322 count++;
323 if (lower_case_normalization)
324 xstrtolower(name);
325 list_append(char_list, name);
326
327 list_iterator_reset(itr);
328
329 i++;
330 start = i;
331 if (!names[i]) {
332 info("There is a problem "
333 "with your request. "
334 "It appears you have "
335 "spaces inside your "
336 "list.");
337 count = 0;
338 goto endit;
339 }
340 } else {
341 brack_not = false;
342 /*
343 * Skip over the "," so it is
344 * not included in the char list
345 */
346 start = ++i;
347 }
348 } else if (names[i] == ']') {
349 brack_not = true;
350 first_brack = false;
351 name = xstrndup(names+start, ((i + 1)-start));
352 //info("got %s %d", name, i-start);
353
354 if ((host_list = hostlist_create(name))) {
355 while ((tmp_this_node_name =
356 hostlist_shift(host_list))) {
357 /*
358 * Move from malloc-ed to
359 * xmalloc-ed memory
360 */
361 this_node_name =
362 xstrdup(tmp_this_node_name);
363 free(tmp_this_node_name);
364 /*
365 * If we get a duplicate
366 * remove the first one and tack
367 * this on the end. This is
368 * needed for get associations
369 * with QOS.
370 */
371 if (list_find(
372 itr,
373 slurm_find_char_in_list,
374 this_node_name)) {
375 list_delete_item(itr);
376 } else
377 count++;
378 if (lower_case_normalization)
379 xstrtolower(this_node_name);
380 list_append(char_list,
381 this_node_name);
382
383 list_iterator_reset(itr);
384
385 start = i + 1;
386 }
387 }
388 hostlist_destroy(host_list);
389 xfree(name);
390 }
391 i++;
392 }
393
394 /* check for empty strings user='' etc */
395 if ((cnt == list_count(char_list)) || (i - start)) {
396 name = xstrndup(names+start, (i-start));
397 /*
398 * If we get a duplicate remove the first one and
399 * tack this on the end. This is needed for get
400 * associations with QOS.
401 */
402 if (list_find(itr, slurm_find_char_in_list, name)) {
403 list_delete_item(itr);
404 } else
405 count++;
406 if (lower_case_normalization)
407 xstrtolower(name);
408 list_append(char_list, name);
409 }
410 }
411 endit:
412 list_iterator_destroy(itr);
413 return count;
414 }
415
416 /* Parses string and converts names to either uid or gid list */
slurm_addto_id_char_list(List char_list,char * names,bool gid)417 extern int slurm_addto_id_char_list(List char_list, char *names, bool gid)
418 {
419 int i=0, start=0;
420 char *name = NULL, *tmp_char = NULL;
421 ListIterator itr = NULL;
422 char quote_c = '\0';
423 int quote = 0;
424 int count = 0;
425
426 if (!char_list) {
427 error("No list was given to fill in");
428 return 0;
429 }
430
431 itr = list_iterator_create(char_list);
432 if (names) {
433 if (names[i] == '\"' || names[i] == '\'') {
434 quote_c = names[i];
435 quote = 1;
436 i++;
437 }
438 start = i;
439 while (names[i]) {
440 //info("got %d - %d = %d", i, start, i-start);
441 if (quote && names[i] == quote_c)
442 break;
443 else if (names[i] == '\"' || names[i] == '\'')
444 names[i] = '`';
445 else if (names[i] == ',') {
446 if ((i-start) > 0) {
447 name = xmalloc((i-start+1));
448 memcpy(name, names+start, (i-start));
449 //info("got %s %d", name, i-start);
450 name = _convert_to_id(name, gid);
451 if (!name)
452 return 0;
453 while ((tmp_char = list_next(itr))) {
454 if (!xstrcasecmp(tmp_char,
455 name))
456 break;
457 }
458
459 if (!tmp_char) {
460 list_append(char_list, name);
461 count++;
462 } else
463 xfree(name);
464 list_iterator_reset(itr);
465 }
466 i++;
467 start = i;
468 if (!names[i]) {
469 info("There is a problem with your request. It appears you have spaces inside your list.");
470 break;
471 }
472 }
473 i++;
474 }
475 if ((i-start) > 0) {
476 name = xmalloc((i-start)+1);
477 memcpy(name, names+start, (i-start));
478 name = _convert_to_id(name, gid);
479 if (!name)
480 return 0;
481
482 while ((tmp_char = list_next(itr))) {
483 if (!xstrcasecmp(tmp_char, name))
484 break;
485 }
486
487 if (!tmp_char) {
488 list_append(char_list, name);
489 count++;
490 } else
491 xfree(name);
492 }
493 }
494 list_iterator_destroy(itr);
495 return count;
496 }
497
498 /* Parses strings such as stra,+strb,-strc and appends the default mode to each
499 * string in the list if no specific mode is listed.
500 * RET: returns the number of items added to the list. -1 on error. */
slurm_addto_mode_char_list(List char_list,char * names,int mode)501 extern int slurm_addto_mode_char_list(List char_list, char *names, int mode)
502 {
503 int i=0, start=0;
504 char *m_name = NULL, *name = NULL, *tmp_char = NULL;
505 ListIterator itr = NULL;
506 char quote_c = '\0';
507 int quote = 0;
508 int count = 0;
509 int equal_set = 0;
510 int add_set = 0;
511 char *err_msg = "You can't use '=' and '+' or '-' in the same line";
512
513 if (!char_list) {
514 error("No list was given to fill in");
515 return 0;
516 }
517
518 if (!names) {
519 error("You gave me an empty name list");
520 return 0;
521 }
522
523 itr = list_iterator_create(char_list);
524 if (names[i] == '\"' || names[i] == '\'') {
525 quote_c = names[i];
526 quote = 1;
527 i++;
528 }
529 start = i;
530 while(names[i]) {
531 if (quote && names[i] == quote_c)
532 break;
533 else if (names[i] == '\"' || names[i] == '\'')
534 names[i] = '`';
535 else if (names[i] == ',') {
536 if ((i-start) > 0) {
537 int tmp_mode = mode;
538 if (names[start] == '+' ||
539 names[start] == '-') {
540 tmp_mode = names[start];
541 start++;
542 }
543 name = xstrndup(names+start, (i-start));
544 if (tmp_mode) {
545 if (equal_set) {
546 count = -1;
547 error("%s", err_msg);
548 goto end_it;
549 }
550 add_set = 1;
551 m_name = xstrdup_printf(
552 "%c%s", tmp_mode, name);
553 } else {
554 if (add_set) {
555 count = -1;
556 error("%s", err_msg);
557 goto end_it;
558 }
559 equal_set = 1;
560 m_name = xstrdup_printf("%s", name);
561 }
562 while((tmp_char = list_next(itr))) {
563 if (!strcasecmp(tmp_char, m_name))
564 break;
565 }
566 list_iterator_reset(itr);
567
568 if (!tmp_char) {
569 list_append(char_list, m_name);
570 count++;
571 } else
572 xfree(m_name);
573 xfree(name);
574 }
575
576 i++;
577 start = i;
578 if (!names[i]) {
579 error("There is a problem with "
580 "your request. It appears you "
581 "have spaces inside your list.");
582 break;
583 }
584 }
585 i++;
586 }
587
588 list_iterator_reset(itr);
589 if ((i-start) > 0) {
590 int tmp_mode = mode;
591 if (names[start] == '+' ||
592 names[start] == '-') {
593 tmp_mode = names[start];
594 start++;
595 }
596 name = xstrndup(names+start, (i-start));
597 if (tmp_mode) {
598 if (equal_set) {
599 count = -1;
600 error("%s", err_msg);
601 goto end_it;
602 }
603 m_name = xstrdup_printf(
604 "%c%s", tmp_mode, name);
605 } else {
606 if (add_set) {
607 count = -1;
608 error("%s", err_msg);
609 goto end_it;
610 }
611 m_name = xstrdup_printf("%s", name);
612 }
613 while((tmp_char = list_next(itr))) {
614 if (!strcasecmp(tmp_char, m_name))
615 break;
616 }
617 list_iterator_reset(itr);
618
619 if (!tmp_char) {
620 list_append(char_list, m_name);
621 count++;
622 } else
623 xfree(m_name);
624 xfree(name);
625 }
626
627 end_it:
628 xfree(name);
629 list_iterator_destroy(itr);
630 return count;
631 }
632
_addto_step_list_internal(List step_list,char * names,int start,int end)633 static int _addto_step_list_internal(List step_list, char *names,
634 int start, int end)
635 {
636 int count = 0;
637 char *dot, *name, *plus, *under;
638 slurmdb_selected_step_t *selected_step = NULL;
639
640 if ((end-start) <= 0)
641 return 0;
642
643 name = xmalloc((end-start+1));
644 memcpy(name, names+start, (end-start));
645
646 if (!isdigit(*name)) {
647 fatal("Bad job/step specified: %s", name);
648 xfree(name);
649 return 0;
650 }
651
652 selected_step = xmalloc(sizeof(slurmdb_selected_step_t));
653
654 if ((dot = strstr(name, "."))) {
655 *dot++ = 0;
656 /* can't use NO_VAL since that means all */
657 if (!xstrcmp(dot, "batch"))
658 selected_step->stepid = INFINITE;
659 else if (isdigit(*dot))
660 selected_step->stepid = atoi(dot);
661 else
662 fatal("Bad step specified: %s", name);
663 } else {
664 debug2("No jobstep requested");
665 selected_step->stepid = NO_VAL;
666 }
667
668 if ((under = strstr(name, "_"))) {
669 *under++ = 0;
670 if (isdigit(*under))
671 selected_step->array_task_id = atoi(under);
672 else
673 fatal("Bad job array element specified: %s", name);
674 selected_step->het_job_offset = NO_VAL;
675 } else if ((plus = strstr(name, "+"))) {
676 selected_step->array_task_id = NO_VAL;
677 *plus++ = 0;
678 if (isdigit(*plus))
679 selected_step->het_job_offset = atoi(plus);
680 else
681 fatal("Bad hetjob offset specified: %s", name);
682 } else {
683 debug2("No jobarray or hetjob requested");
684 selected_step->array_task_id = NO_VAL;
685 selected_step->het_job_offset = NO_VAL;
686 }
687
688 selected_step->jobid = atoi(name);
689 xfree(name);
690
691 if (!list_find_first(step_list,
692 slurmdb_find_selected_step_in_list,
693 selected_step)) {
694 list_append(step_list, selected_step);
695 count++;
696 } else
697 slurmdb_destroy_selected_step(selected_step);
698
699 return count;
700 }
701
702 /* returns number of objects added to list */
slurm_addto_step_list(List step_list,char * names)703 extern int slurm_addto_step_list(List step_list, char *names)
704 {
705 int i = 0, start = 0;
706 char quote_c = '\0';
707 int quote = 0;
708 int count = 0;
709
710 if (!step_list) {
711 error("No list was given to fill in");
712 return 0;
713 } else if (!names)
714 return 0;
715
716 if (names[i] == '\"' || names[i] == '\'') {
717 quote_c = names[i];
718 quote = 1;
719 i++;
720 }
721 start = i;
722 while (names[i]) {
723 //info("got %d - %d = %d", i, start, i-start);
724 if (quote && names[i] == quote_c)
725 break;
726 else if (names[i] == '\"' || names[i] == '\'')
727 names[i] = '`';
728 else if (names[i] == ',') {
729 count += _addto_step_list_internal(
730 step_list, names, start, i);
731 start = i + 1;
732 }
733 i++;
734 }
735
736 count += _addto_step_list_internal(step_list, names, start, i);
737
738 return count;
739 }
740
slurm_sort_char_list_asc(void * v1,void * v2)741 extern int slurm_sort_char_list_asc(void *v1, void *v2)
742 {
743 char *name_a = *(char **)v1;
744 char *name_b = *(char **)v2;
745 int diff = xstrcmp(name_a, name_b);
746
747 if (diff < 0)
748 return -1;
749 else if (diff > 0)
750 return 1;
751
752 return 0;
753 }
754
slurm_sort_char_list_desc(void * v1,void * v2)755 extern int slurm_sort_char_list_desc(void *v1, void *v2)
756 {
757 char *name_a = *(char **)v1;
758 char *name_b = *(char **)v2;
759 int diff = xstrcmp(name_a, name_b);
760
761 if (diff > 0)
762 return -1;
763 else if (diff < 0)
764 return 1;
765
766 return 0;
767 }
768
slurm_free_last_update_msg(last_update_msg_t * msg)769 extern void slurm_free_last_update_msg(last_update_msg_t * msg)
770 {
771 xfree(msg);
772 }
773
slurm_init_reboot_msg(reboot_msg_t * msg,bool clear)774 extern void slurm_init_reboot_msg(reboot_msg_t *msg, bool clear)
775 {
776 xassert(msg);
777
778 if (clear)
779 memset(msg, 0, sizeof(reboot_msg_t));
780
781 msg->next_state = NO_VAL;
782 }
783
slurm_free_reboot_msg(reboot_msg_t * msg)784 extern void slurm_free_reboot_msg(reboot_msg_t * msg)
785 {
786 if (msg) {
787 xfree(msg->features);
788 xfree(msg->node_list);
789 xfree(msg->reason);
790 xfree(msg);
791 }
792 }
793
slurm_free_shutdown_msg(shutdown_msg_t * msg)794 extern void slurm_free_shutdown_msg(shutdown_msg_t * msg)
795 {
796 xfree(msg);
797 }
798
slurm_free_job_alloc_info_msg(job_alloc_info_msg_t * msg)799 extern void slurm_free_job_alloc_info_msg(job_alloc_info_msg_t * msg)
800 {
801 if (msg) {
802 xfree(msg->req_cluster);
803 xfree(msg);
804 }
805 }
806
slurm_free_step_alloc_info_msg(step_alloc_info_msg_t * msg)807 extern void slurm_free_step_alloc_info_msg(step_alloc_info_msg_t * msg)
808 {
809 xfree(msg);
810 }
811
slurm_free_return_code_msg(return_code_msg_t * msg)812 extern void slurm_free_return_code_msg(return_code_msg_t * msg)
813 {
814 xfree(msg);
815 }
816
slurm_free_reroute_msg(reroute_msg_t * msg)817 extern void slurm_free_reroute_msg(reroute_msg_t *msg)
818 {
819 if (msg) {
820 slurmdb_destroy_cluster_rec(msg->working_cluster_rec);
821 xfree(msg);
822 }
823 }
824
slurm_free_batch_script_msg(char * msg)825 extern void slurm_free_batch_script_msg(char *msg)
826 {
827 xfree(msg);
828 }
829
slurm_free_job_id_msg(job_id_msg_t * msg)830 extern void slurm_free_job_id_msg(job_id_msg_t * msg)
831 {
832 xfree(msg);
833 }
834
slurm_free_job_user_id_msg(job_user_id_msg_t * msg)835 extern void slurm_free_job_user_id_msg(job_user_id_msg_t * msg)
836 {
837 xfree(msg);
838 }
839
slurm_free_job_step_id_msg(job_step_id_msg_t * msg)840 extern void slurm_free_job_step_id_msg(job_step_id_msg_t * msg)
841 {
842 xfree(msg);
843 }
844
slurm_free_job_id_request_msg(job_id_request_msg_t * msg)845 extern void slurm_free_job_id_request_msg(job_id_request_msg_t * msg)
846 {
847 xfree(msg);
848 }
849
slurm_free_config_request_msg(config_request_msg_t * msg)850 extern void slurm_free_config_request_msg(config_request_msg_t *msg)
851 {
852 if (msg) {
853 xfree(msg);
854 }
855 }
856
slurm_free_config_response_msg(config_response_msg_t * msg)857 extern void slurm_free_config_response_msg(config_response_msg_t *msg)
858 {
859 if (msg) {
860 xfree(msg->config);
861 xfree(msg->acct_gather_config);
862 xfree(msg->cgroup_config);
863 xfree(msg->cgroup_allowed_devices_file_config);
864 xfree(msg->ext_sensors_config);
865 xfree(msg->gres_config);
866 xfree(msg->knl_cray_config);
867 xfree(msg->knl_generic_config);
868 xfree(msg->plugstack_config);
869 xfree(msg->topology_config);
870 xfree(msg->xtra_config);
871 xfree(msg->slurmd_spooldir);
872 xfree(msg);
873 }
874 }
875
slurm_free_update_step_msg(step_update_request_msg_t * msg)876 extern void slurm_free_update_step_msg(step_update_request_msg_t * msg)
877 {
878 if (msg) {
879 jobacctinfo_destroy(msg->jobacct);
880 xfree(msg->name);
881 xfree(msg);
882 }
883 }
884
slurm_free_job_id_response_msg(job_id_response_msg_t * msg)885 extern void slurm_free_job_id_response_msg(job_id_response_msg_t * msg)
886 {
887 xfree(msg);
888 }
889
slurm_free_job_step_kill_msg(job_step_kill_msg_t * msg)890 extern void slurm_free_job_step_kill_msg(job_step_kill_msg_t * msg)
891 {
892 if (msg) {
893 xfree(msg->sibling);
894 xfree(msg->sjob_id);
895 xfree(msg);
896 }
897 }
898
slurm_free_job_info_request_msg(job_info_request_msg_t * msg)899 extern void slurm_free_job_info_request_msg(job_info_request_msg_t *msg)
900 {
901 if (msg) {
902 FREE_NULL_LIST(msg->job_ids);
903 xfree(msg);
904 }
905 }
906
slurm_free_job_step_info_request_msg(job_step_info_request_msg_t * msg)907 extern void slurm_free_job_step_info_request_msg(job_step_info_request_msg_t *msg)
908 {
909 xfree(msg);
910 }
911
slurm_free_front_end_info_request_msg(front_end_info_request_msg_t * msg)912 extern void slurm_free_front_end_info_request_msg
913 (front_end_info_request_msg_t *msg)
914 {
915 xfree(msg);
916 }
917
slurm_free_node_info_request_msg(node_info_request_msg_t * msg)918 extern void slurm_free_node_info_request_msg(node_info_request_msg_t *msg)
919 {
920 xfree(msg);
921 }
922
slurm_free_node_info_single_msg(node_info_single_msg_t * msg)923 extern void slurm_free_node_info_single_msg(node_info_single_msg_t *msg)
924 {
925 if (msg) {
926 xfree(msg->node_name);
927 xfree(msg);
928 }
929 }
930
slurm_free_part_info_request_msg(part_info_request_msg_t * msg)931 extern void slurm_free_part_info_request_msg(part_info_request_msg_t *msg)
932 {
933 xfree(msg);
934 }
935
slurm_free_job_desc_msg(job_desc_msg_t * msg)936 extern void slurm_free_job_desc_msg(job_desc_msg_t *msg)
937 {
938 int i;
939
940 if (msg) {
941 xfree(msg->account);
942 xfree(msg->acctg_freq);
943 xfree(msg->admin_comment);
944 xfree(msg->alloc_node);
945 if (msg->argv) {
946 for (i = 0; i < msg->argc; i++)
947 xfree(msg->argv[i]);
948 }
949 xfree(msg->argv);
950 FREE_NULL_BITMAP(msg->array_bitmap);
951 xfree(msg->array_inx);
952 xfree(msg->batch_features);
953 xfree(msg->burst_buffer);
954 xfree(msg->clusters);
955 xfree(msg->comment);
956 xfree(msg->cpu_bind);
957 xfree(msg->cpus_per_tres);
958 xfree(msg->dependency);
959 env_array_free(msg->environment);
960 msg->environment = NULL;
961 xfree(msg->extra);
962 xfree(msg->exc_nodes);
963 xfree(msg->features);
964 xfree(msg->cluster_features);
965 xfree(msg->job_id_str);
966 xfree(msg->licenses);
967 xfree(msg->mail_user);
968 xfree(msg->mcs_label);
969 xfree(msg->mem_bind);
970 xfree(msg->mem_per_tres);
971 xfree(msg->name);
972 xfree(msg->network);
973 xfree(msg->origin_cluster);
974 xfree(msg->partition);
975 xfree(msg->qos);
976 xfree(msg->req_nodes);
977 xfree(msg->reservation);
978 xfree(msg->resp_host);
979 xfree(msg->script);
980 free_buf(msg->script_buf);
981 select_g_select_jobinfo_free(msg->select_jobinfo);
982 msg->select_jobinfo = NULL;
983 xfree(msg->std_err);
984 xfree(msg->std_in);
985 xfree(msg->std_out);
986 if (msg->spank_job_env) {
987 for (i = 0; i < msg->spank_job_env_size; i++)
988 xfree(msg->spank_job_env[i]);
989 xfree(msg->spank_job_env);
990 }
991 xfree(msg->tres_bind);
992 xfree(msg->tres_freq);
993 xfree(msg->tres_req_cnt);
994 xfree(msg->tres_per_job);
995 xfree(msg->tres_per_node);
996 xfree(msg->tres_per_socket);
997 xfree(msg->tres_per_task);
998 xfree(msg->wckey);
999 xfree(msg->work_dir);
1000 xfree(msg->x11_magic_cookie);
1001 xfree(msg->x11_target);
1002 xfree(msg);
1003 }
1004 }
1005
slurm_free_sib_msg(sib_msg_t * msg)1006 extern void slurm_free_sib_msg(sib_msg_t *msg)
1007 {
1008 if (msg) {
1009 free_buf(msg->data_buffer);
1010 xfree(msg->resp_host);
1011 if (msg->data)
1012 slurm_free_msg_data(msg->data_type, msg->data);
1013 xfree(msg);
1014 }
1015 }
1016
slurm_free_dep_msg(dep_msg_t * msg)1017 extern void slurm_free_dep_msg(dep_msg_t *msg)
1018 {
1019 if (msg) {
1020 xfree(msg->dependency);
1021 xfree(msg->job_name);
1022 }
1023 }
1024
slurm_free_dep_update_origin_msg(dep_update_origin_msg_t * msg)1025 extern void slurm_free_dep_update_origin_msg(dep_update_origin_msg_t *msg)
1026 {
1027 if (msg) {
1028 FREE_NULL_LIST(msg->depend_list);
1029 }
1030 }
1031
slurm_free_event_log_msg(slurm_event_log_msg_t * msg)1032 extern void slurm_free_event_log_msg(slurm_event_log_msg_t * msg)
1033 {
1034 if (msg) {
1035 xfree(msg->string);
1036 xfree(msg);
1037 }
1038 }
1039
slurm_free_prolog_launch_msg(prolog_launch_msg_t * msg)1040 extern void slurm_free_prolog_launch_msg(prolog_launch_msg_t * msg)
1041 {
1042 int i;
1043
1044 if (msg) {
1045 xfree(msg->alias_list);
1046 FREE_NULL_LIST(msg->job_gres_info);
1047 xfree(msg->nodes);
1048 xfree(msg->partition);
1049 xfree(msg->std_err);
1050 xfree(msg->std_out);
1051 xfree(msg->work_dir);
1052 xfree(msg->user_name);
1053
1054 xfree(msg->x11_alloc_host);
1055 xfree(msg->x11_magic_cookie);
1056 xfree(msg->x11_target);
1057
1058 if (msg->spank_job_env) {
1059 for (i = 0; i < msg->spank_job_env_size; i++)
1060 xfree(msg->spank_job_env[i]);
1061 xfree(msg->spank_job_env);
1062 }
1063 slurm_cred_destroy(msg->cred);
1064
1065 xfree(msg);
1066 }
1067 }
1068
slurm_free_complete_prolog_msg(complete_prolog_msg_t * msg)1069 extern void slurm_free_complete_prolog_msg(complete_prolog_msg_t * msg)
1070 {
1071 xfree(msg);
1072 }
1073
slurm_free_job_launch_msg(batch_job_launch_msg_t * msg)1074 extern void slurm_free_job_launch_msg(batch_job_launch_msg_t * msg)
1075 {
1076 int i;
1077
1078 if (msg) {
1079 xfree(msg->account);
1080 xfree(msg->acctg_freq);
1081 xfree(msg->alias_list);
1082 if (msg->argv) {
1083 for (i = 0; i < msg->argc; i++)
1084 xfree(msg->argv[i]);
1085 xfree(msg->argv);
1086 }
1087 xfree(msg->cpu_bind);
1088 xfree(msg->cpus_per_node);
1089 xfree(msg->cpu_count_reps);
1090 slurm_cred_destroy(msg->cred);
1091 if (msg->environment) {
1092 for (i = 0; i < msg->envc; i++)
1093 xfree(msg->environment[i]);
1094 xfree(msg->environment);
1095 }
1096 xfree(msg->gids);
1097 xfree(msg->nodes);
1098 xfree(msg->partition);
1099 xfree(msg->qos);
1100 xfree(msg->resv_name);
1101 xfree(msg->script);
1102 free_buf(msg->script_buf);
1103 select_g_select_jobinfo_free(msg->select_jobinfo);
1104 if (msg->spank_job_env) {
1105 for (i = 0; i < msg->spank_job_env_size; i++)
1106 xfree(msg->spank_job_env[i]);
1107 xfree(msg->spank_job_env);
1108 }
1109 xfree(msg->std_err);
1110 xfree(msg->std_in);
1111 xfree(msg->std_out);
1112 xfree(msg->tres_bind);
1113 xfree(msg->tres_freq);
1114 xfree(msg->user_name);
1115 xfree(msg->work_dir);
1116 xfree(msg);
1117 }
1118 }
1119
slurm_free_job_info(job_info_t * job)1120 extern void slurm_free_job_info(job_info_t * job)
1121 {
1122 if (job) {
1123 slurm_free_job_info_members(job);
1124 xfree(job);
1125 }
1126 }
1127
slurm_free_job_info_members(job_info_t * job)1128 extern void slurm_free_job_info_members(job_info_t * job)
1129 {
1130 int i;
1131
1132 if (job) {
1133 xfree(job->account);
1134 xfree(job->alloc_node);
1135 if (job->array_bitmap)
1136 bit_free((bitstr_t *) job->array_bitmap);
1137 xfree(job->array_task_str);
1138 xfree(job->batch_features);
1139 xfree(job->batch_host);
1140 xfree(job->burst_buffer);
1141 xfree(job->burst_buffer_state);
1142 xfree(job->cluster);
1143 xfree(job->command);
1144 xfree(job->comment);
1145 xfree(job->cpus_per_tres);
1146 xfree(job->dependency);
1147 xfree(job->exc_nodes);
1148 xfree(job->exc_node_inx);
1149 xfree(job->features);
1150 xfree(job->fed_origin_str);
1151 xfree(job->fed_siblings_active_str);
1152 xfree(job->fed_siblings_viable_str);
1153 xfree(job->gres_total);
1154 if (job->gres_detail_str) {
1155 for (i = 0; i < job->gres_detail_cnt; i++)
1156 xfree(job->gres_detail_str[i]);
1157 xfree(job->gres_detail_str);
1158 }
1159 xfree(job->het_job_id_set);
1160 xfree(job->licenses);
1161 xfree(job->mail_user);
1162 xfree(job->mcs_label);
1163 xfree(job->mem_per_tres);
1164 xfree(job->name);
1165 xfree(job->network);
1166 xfree(job->node_inx);
1167 xfree(job->nodes);
1168 xfree(job->sched_nodes);
1169 xfree(job->partition);
1170 xfree(job->qos);
1171 xfree(job->req_node_inx);
1172 xfree(job->req_nodes);
1173 xfree(job->resv_name);
1174 select_g_select_jobinfo_free(job->select_jobinfo);
1175 job->select_jobinfo = NULL;
1176 free_job_resources(&job->job_resrcs);
1177 xfree(job->state_desc);
1178 xfree(job->std_err);
1179 xfree(job->std_in);
1180 xfree(job->std_out);
1181 xfree(job->tres_alloc_str);
1182 xfree(job->tres_bind);
1183 xfree(job->tres_freq);
1184 xfree(job->tres_per_job);
1185 xfree(job->tres_per_node);
1186 xfree(job->tres_per_socket);
1187 xfree(job->tres_per_task);
1188 xfree(job->tres_req_str);
1189 xfree(job->user_name);
1190 xfree(job->wckey);
1191 xfree(job->work_dir);
1192 }
1193 }
1194
1195
slurm_free_acct_gather_node_resp_msg(acct_gather_node_resp_msg_t * msg)1196 extern void slurm_free_acct_gather_node_resp_msg(
1197 acct_gather_node_resp_msg_t *msg)
1198 {
1199 if (msg) {
1200 xfree(msg->node_name);
1201 acct_gather_energy_destroy(msg->energy);
1202 xfree(msg);
1203 }
1204 }
1205
slurm_free_acct_gather_energy_req_msg(acct_gather_energy_req_msg_t * msg)1206 extern void slurm_free_acct_gather_energy_req_msg(
1207 acct_gather_energy_req_msg_t *msg)
1208 {
1209 if (msg) {
1210 xfree(msg);
1211 }
1212 }
1213
slurm_free_node_registration_status_msg(slurm_node_registration_status_msg_t * msg)1214 extern void slurm_free_node_registration_status_msg(
1215 slurm_node_registration_status_msg_t * msg)
1216 {
1217 if (msg) {
1218 xfree(msg->arch);
1219 xfree(msg->cpu_spec_list);
1220 if (msg->energy)
1221 acct_gather_energy_destroy(msg->energy);
1222 xfree(msg->features_active);
1223 xfree(msg->features_avail);
1224 if (msg->gres_info)
1225 free_buf(msg->gres_info);
1226 xfree(msg->job_id);
1227 xfree(msg->node_name);
1228 xfree(msg->os);
1229 xfree(msg->step_id);
1230 if (msg->switch_nodeinfo)
1231 switch_g_free_node_info(&msg->switch_nodeinfo);
1232 xfree(msg->version);
1233 xfree(msg);
1234 }
1235 }
1236
slurm_free_node_reg_resp_msg(slurm_node_reg_resp_msg_t * msg)1237 extern void slurm_free_node_reg_resp_msg(
1238 slurm_node_reg_resp_msg_t *msg)
1239 {
1240 if (!msg)
1241 return;
1242
1243 FREE_NULL_LIST(msg->tres_list);
1244 xfree(msg);
1245 }
1246
slurm_free_update_front_end_msg(update_front_end_msg_t * msg)1247 extern void slurm_free_update_front_end_msg(update_front_end_msg_t * msg)
1248 {
1249 if (msg) {
1250 xfree(msg->name);
1251 xfree(msg->reason);
1252 xfree(msg);
1253 }
1254 }
1255
slurm_free_update_node_msg(update_node_msg_t * msg)1256 extern void slurm_free_update_node_msg(update_node_msg_t * msg)
1257 {
1258 if (msg) {
1259 xfree(msg->features);
1260 xfree(msg->features_act);
1261 xfree(msg->gres);
1262 xfree(msg->node_addr);
1263 xfree(msg->node_hostname);
1264 xfree(msg->node_names);
1265 xfree(msg->reason);
1266 xfree(msg);
1267 }
1268 }
1269
slurm_free_update_layout_msg(update_layout_msg_t * msg)1270 extern void slurm_free_update_layout_msg(update_layout_msg_t * msg)
1271 {
1272 if (msg) {
1273 xfree(msg->layout);
1274 xfree(msg->arg);
1275 xfree(msg);
1276 }
1277 }
1278
slurm_free_update_part_msg(update_part_msg_t * msg)1279 extern void slurm_free_update_part_msg(update_part_msg_t * msg)
1280 {
1281 if (msg) {
1282 slurm_free_partition_info_members((partition_info_t *)msg);
1283 xfree(msg);
1284 }
1285 }
1286
slurm_free_delete_part_msg(delete_part_msg_t * msg)1287 extern void slurm_free_delete_part_msg(delete_part_msg_t * msg)
1288 {
1289 if (msg) {
1290 xfree(msg->name);
1291 xfree(msg);
1292 }
1293 }
1294
slurm_free_resv_desc_msg(resv_desc_msg_t * msg)1295 extern void slurm_free_resv_desc_msg(resv_desc_msg_t * msg)
1296 {
1297 if (msg) {
1298 xfree(msg->accounts);
1299 xfree(msg->burst_buffer);
1300 xfree(msg->core_cnt);
1301 xfree(msg->features);
1302 xfree(msg->licenses);
1303 xfree(msg->name);
1304 xfree(msg->node_cnt);
1305 xfree(msg->node_list);
1306 xfree(msg->partition);
1307 xfree(msg->users);
1308 xfree(msg);
1309 }
1310 }
1311
slurm_free_resv_name_msg(reservation_name_msg_t * msg)1312 extern void slurm_free_resv_name_msg(reservation_name_msg_t * msg)
1313 {
1314 if (msg) {
1315 xfree(msg->name);
1316 xfree(msg);
1317 }
1318 }
1319
slurm_free_resv_info_request_msg(resv_info_request_msg_t * msg)1320 extern void slurm_free_resv_info_request_msg(resv_info_request_msg_t * msg)
1321 {
1322 xfree(msg);
1323 }
1324
slurm_free_layout_info_request_msg(layout_info_request_msg_t * msg)1325 extern void slurm_free_layout_info_request_msg(layout_info_request_msg_t * msg)
1326 {
1327 if (msg) {
1328 xfree(msg->layout_type);
1329 xfree(msg->entities);
1330 xfree(msg);
1331 }
1332 }
1333
slurm_free_layout_info_msg(layout_info_msg_t * msg)1334 extern void slurm_free_layout_info_msg(layout_info_msg_t * msg)
1335 {
1336 int i;
1337
1338 if (msg) {
1339 if (msg->records) {
1340 for (i = 0; i < msg->record_count; i++)
1341 xfree(msg->records[i]);
1342 xfree(msg->records);
1343 }
1344 xfree(msg);
1345 }
1346 }
1347
slurm_free_job_step_create_request_msg(job_step_create_request_msg_t * msg)1348 extern void slurm_free_job_step_create_request_msg(
1349 job_step_create_request_msg_t *msg)
1350 {
1351 if (msg) {
1352 xfree(msg->cpus_per_tres);
1353 xfree(msg->features);
1354 xfree(msg->host);
1355 xfree(msg->mem_per_tres);
1356 xfree(msg->name);
1357 xfree(msg->network);
1358 xfree(msg->node_list);
1359 xfree(msg->tres_bind);
1360 xfree(msg->tres_freq);
1361 xfree(msg->tres_per_step);
1362 xfree(msg->tres_per_node);
1363 xfree(msg->tres_per_socket);
1364 xfree(msg->tres_per_task);
1365 xfree(msg);
1366 }
1367 }
1368
slurm_free_complete_job_allocation_msg(complete_job_allocation_msg_t * msg)1369 extern void slurm_free_complete_job_allocation_msg(
1370 complete_job_allocation_msg_t * msg)
1371 {
1372 xfree(msg);
1373 }
1374
slurm_free_complete_batch_script_msg(complete_batch_script_msg_t * msg)1375 extern void slurm_free_complete_batch_script_msg(
1376 complete_batch_script_msg_t * msg)
1377 {
1378 if (msg) {
1379 jobacctinfo_destroy(msg->jobacct);
1380 xfree(msg->node_name);
1381 xfree(msg);
1382 }
1383 }
1384
1385
slurm_free_launch_tasks_response_msg(launch_tasks_response_msg_t * msg)1386 extern void slurm_free_launch_tasks_response_msg(
1387 launch_tasks_response_msg_t *msg)
1388 {
1389 if (msg) {
1390 xfree(msg->node_name);
1391 xfree(msg->local_pids);
1392 xfree(msg->task_ids);
1393 xfree(msg);
1394 }
1395 }
1396
slurm_free_kill_job_msg(kill_job_msg_t * msg)1397 extern void slurm_free_kill_job_msg(kill_job_msg_t * msg)
1398 {
1399 if (msg) {
1400 int i;
1401 FREE_NULL_LIST(msg->job_gres_info);
1402 xfree(msg->nodes);
1403 select_g_select_jobinfo_free(msg->select_jobinfo);
1404 msg->select_jobinfo = NULL;
1405
1406 if (msg->spank_job_env) {
1407 for (i = 0; i < msg->spank_job_env_size; i++)
1408 xfree(msg->spank_job_env[i]);
1409 xfree(msg->spank_job_env);
1410 }
1411 xfree(msg);
1412 }
1413 }
1414
slurm_free_update_job_time_msg(job_time_msg_t * msg)1415 extern void slurm_free_update_job_time_msg(job_time_msg_t * msg)
1416 {
1417 xfree(msg);
1418 }
1419
slurm_free_task_exit_msg(task_exit_msg_t * msg)1420 extern void slurm_free_task_exit_msg(task_exit_msg_t * msg)
1421 {
1422 if (msg) {
1423 xfree(msg->task_id_list);
1424 xfree(msg);
1425 }
1426 }
1427
slurm_free_launch_tasks_request_msg(launch_tasks_request_msg_t * msg)1428 extern void slurm_free_launch_tasks_request_msg(launch_tasks_request_msg_t * msg)
1429 {
1430 int i;
1431
1432 if (msg == NULL)
1433 return;
1434
1435 slurm_cred_destroy(msg->cred);
1436
1437 if (msg->env) {
1438 for (i = 0; i < msg->envc; i++) {
1439 xfree(msg->env[i]);
1440 }
1441 xfree(msg->env);
1442 }
1443 xfree(msg->acctg_freq);
1444 xfree(msg->user_name);
1445 xfree(msg->alias_list);
1446 xfree(msg->cwd);
1447 xfree(msg->cpu_bind);
1448 xfree(msg->mem_bind);
1449 if (msg->argv) {
1450 for (i = 0; i < msg->argc; i++) {
1451 xfree(msg->argv[i]);
1452 }
1453 xfree(msg->argv);
1454 }
1455 if (msg->spank_job_env) {
1456 for (i = 0; i < msg->spank_job_env_size; i++) {
1457 xfree(msg->spank_job_env[i]);
1458 }
1459 xfree(msg->spank_job_env);
1460 }
1461 if (msg->global_task_ids) {
1462 for (i = 0; i < msg->nnodes; i++) {
1463 xfree(msg->global_task_ids[i]);
1464 }
1465 xfree(msg->global_task_ids);
1466 }
1467 xfree(msg->gids);
1468 xfree(msg->het_job_node_list);
1469 xfree(msg->het_job_task_cnts);
1470 if ((msg->het_job_nnodes != NO_VAL) && msg->het_job_tids) {
1471 /* het_job_tids == NULL if request from pre-v19.05 srun */
1472 for (i = 0; i < msg->het_job_nnodes; i++)
1473 xfree(msg->het_job_tids[i]);
1474 xfree(msg->het_job_tids);
1475 }
1476 xfree(msg->het_job_tid_offsets);
1477 xfree(msg->tasks_to_launch);
1478 xfree(msg->resp_port);
1479 xfree(msg->io_port);
1480 xfree(msg->global_task_ids);
1481 xfree(msg->ifname);
1482 xfree(msg->ofname);
1483 xfree(msg->efname);
1484
1485 xfree(msg->task_prolog);
1486 xfree(msg->task_epilog);
1487 xfree(msg->complete_nodelist);
1488
1489 xfree(msg->partition);
1490
1491 if (msg->switch_job)
1492 switch_g_free_jobinfo(msg->switch_job);
1493
1494 if (msg->options)
1495 job_options_destroy(msg->options);
1496
1497 if (msg->select_jobinfo)
1498 select_g_select_jobinfo_free(msg->select_jobinfo);
1499
1500 xfree(msg->tres_bind);
1501 xfree(msg->tres_freq);
1502 xfree(msg->x11_alloc_host);
1503 xfree(msg->x11_magic_cookie);
1504 xfree(msg->x11_target);
1505
1506 xfree(msg);
1507 }
1508
slurm_free_task_user_managed_io_stream_msg(task_user_managed_io_msg_t * msg)1509 extern void slurm_free_task_user_managed_io_stream_msg(
1510 task_user_managed_io_msg_t *msg)
1511 {
1512 xfree(msg);
1513 }
1514
slurm_free_reattach_tasks_request_msg(reattach_tasks_request_msg_t * msg)1515 extern void slurm_free_reattach_tasks_request_msg(
1516 reattach_tasks_request_msg_t *msg)
1517 {
1518 if (msg) {
1519 xfree(msg->resp_port);
1520 xfree(msg->io_port);
1521 slurm_cred_destroy(msg->cred);
1522 xfree(msg);
1523 }
1524 }
1525
slurm_free_reattach_tasks_response_msg(reattach_tasks_response_msg_t * msg)1526 extern void slurm_free_reattach_tasks_response_msg(
1527 reattach_tasks_response_msg_t *msg)
1528 {
1529 int i;
1530
1531 if (msg) {
1532 xfree(msg->node_name);
1533 xfree(msg->local_pids);
1534 xfree(msg->gtids);
1535 if (msg->executable_names) {
1536 for (i = 0; i < msg->ntasks; i++) {
1537 xfree(msg->executable_names[i]);
1538 }
1539 xfree(msg->executable_names);
1540 }
1541 xfree(msg);
1542 }
1543 }
1544
slurm_free_signal_tasks_msg(signal_tasks_msg_t * msg)1545 extern void slurm_free_signal_tasks_msg(signal_tasks_msg_t *msg)
1546 {
1547 xfree(msg);
1548 }
1549
slurm_free_epilog_complete_msg(epilog_complete_msg_t * msg)1550 extern void slurm_free_epilog_complete_msg(epilog_complete_msg_t * msg)
1551 {
1552 if (msg) {
1553 xfree(msg->node_name);
1554 xfree(msg);
1555 }
1556 }
1557
slurm_free_srun_job_complete_msg(srun_job_complete_msg_t * msg)1558 extern void slurm_free_srun_job_complete_msg(
1559 srun_job_complete_msg_t * msg)
1560 {
1561 xfree(msg);
1562 }
1563
slurm_free_srun_exec_msg(srun_exec_msg_t * msg)1564 extern void slurm_free_srun_exec_msg(srun_exec_msg_t *msg)
1565 {
1566 int i;
1567
1568 if (msg) {
1569 if (msg->argv) {
1570 for (i = 0; i < msg->argc; i++)
1571 xfree(msg->argv[i]);
1572 xfree(msg->argv);
1573 }
1574 xfree(msg);
1575 }
1576 }
1577
slurm_free_srun_ping_msg(srun_ping_msg_t * msg)1578 extern void slurm_free_srun_ping_msg(srun_ping_msg_t * msg)
1579 {
1580 xfree(msg);
1581 }
1582
slurm_free_net_forward_msg(net_forward_msg_t * msg)1583 extern void slurm_free_net_forward_msg(net_forward_msg_t *msg)
1584 {
1585 if (msg) {
1586 xfree(msg->target);
1587 xfree(msg);
1588 }
1589 }
1590
slurm_free_srun_node_fail_msg(srun_node_fail_msg_t * msg)1591 extern void slurm_free_srun_node_fail_msg(srun_node_fail_msg_t * msg)
1592 {
1593 if (msg) {
1594 xfree(msg->nodelist);
1595 xfree(msg);
1596 }
1597 }
1598
slurm_free_srun_step_missing_msg(srun_step_missing_msg_t * msg)1599 extern void slurm_free_srun_step_missing_msg(srun_step_missing_msg_t * msg)
1600 {
1601 if (msg) {
1602 xfree(msg->nodelist);
1603 xfree(msg);
1604 }
1605 }
1606
slurm_free_srun_timeout_msg(srun_timeout_msg_t * msg)1607 extern void slurm_free_srun_timeout_msg(srun_timeout_msg_t * msg)
1608 {
1609 xfree(msg);
1610 }
1611
slurm_free_srun_user_msg(srun_user_msg_t * user_msg)1612 extern void slurm_free_srun_user_msg(srun_user_msg_t * user_msg)
1613 {
1614 if (user_msg) {
1615 xfree(user_msg->msg);
1616 xfree(user_msg);
1617 }
1618 }
1619
slurm_free_suspend_msg(suspend_msg_t * msg)1620 extern void slurm_free_suspend_msg(suspend_msg_t *msg)
1621 {
1622 if (msg) {
1623 xfree(msg->job_id_str);
1624 xfree(msg);
1625 }
1626 }
1627
slurm_free_top_job_msg(top_job_msg_t * msg)1628 extern void slurm_free_top_job_msg(top_job_msg_t *msg)
1629 {
1630 if (msg) {
1631 xfree(msg->job_id_str);
1632 xfree(msg);
1633 }
1634 }
1635
slurm_free_token_request_msg(token_request_msg_t * msg)1636 extern void slurm_free_token_request_msg(token_request_msg_t *msg)
1637 {
1638 if (msg) {
1639 xfree(msg->username);
1640 xfree(msg);
1641 }
1642 }
1643
slurm_free_token_response_msg(token_response_msg_t * msg)1644 extern void slurm_free_token_response_msg(token_response_msg_t *msg)
1645 {
1646 if (msg) {
1647 xfree(msg->token);
1648 xfree(msg);
1649 }
1650 }
1651
1652 extern void
slurm_free_requeue_msg(requeue_msg_t * msg)1653 slurm_free_requeue_msg(requeue_msg_t *msg)
1654 {
1655 if (msg) {
1656 xfree(msg->job_id_str);
1657 xfree(msg);
1658 }
1659 }
1660
slurm_free_suspend_int_msg(suspend_int_msg_t * msg)1661 extern void slurm_free_suspend_int_msg(suspend_int_msg_t *msg)
1662 {
1663 if (msg) {
1664 switch_g_job_suspend_info_free(msg->switch_info);
1665 xfree(msg);
1666 }
1667 }
1668
slurm_free_stats_response_msg(stats_info_response_msg_t * msg)1669 extern void slurm_free_stats_response_msg(stats_info_response_msg_t *msg)
1670 {
1671 int i;
1672 if (msg) {
1673 xfree(msg->rpc_type_id);
1674 xfree(msg->rpc_type_cnt);
1675 xfree(msg->rpc_type_time);
1676 xfree(msg->rpc_user_id);
1677 xfree(msg->rpc_user_cnt);
1678 xfree(msg->rpc_user_time);
1679 xfree(msg->rpc_queue_type_id);
1680 xfree(msg->rpc_queue_count);
1681 xfree(msg->rpc_dump_types);
1682 for (i = 0; i < msg->rpc_dump_count; i++) {
1683 xfree(msg->rpc_dump_hostlist[i]);
1684 }
1685 xfree(msg->rpc_dump_hostlist);
1686 xfree(msg);
1687 }
1688 }
1689
slurm_free_spank_env_request_msg(spank_env_request_msg_t * msg)1690 extern void slurm_free_spank_env_request_msg(spank_env_request_msg_t *msg)
1691 {
1692 xfree(msg);
1693 }
1694
slurm_free_spank_env_responce_msg(spank_env_responce_msg_t * msg)1695 extern void slurm_free_spank_env_responce_msg(spank_env_responce_msg_t *msg)
1696 {
1697 uint32_t i;
1698
1699 if (msg->spank_job_env) {
1700 for (i = 0; i < msg->spank_job_env_size; i++)
1701 xfree(msg->spank_job_env[i]);
1702 xfree(msg->spank_job_env);
1703 }
1704 xfree(msg);
1705 }
1706
1707 /* Free job array oriented response with individual return codes by task ID */
slurm_free_job_array_resp(job_array_resp_msg_t * msg)1708 extern void slurm_free_job_array_resp(job_array_resp_msg_t *msg)
1709 {
1710 uint32_t i;
1711
1712 if (msg) {
1713 if (msg->job_array_id) {
1714 for (i = 0; i < msg->job_array_count; i++)
1715 xfree(msg->job_array_id[i]);
1716 xfree(msg->job_array_id);
1717 }
1718 xfree(msg->error_code);
1719 xfree(msg);
1720 }
1721 }
1722
1723 /* Given a job's reason for waiting, return a descriptive string */
job_reason_string(enum job_state_reason inx)1724 extern char *job_reason_string(enum job_state_reason inx)
1725 {
1726 static char val[32];
1727
1728 switch (inx) {
1729 case WAIT_NO_REASON:
1730 return "None";
1731 case WAIT_PROLOG:
1732 return "Prolog";
1733 case WAIT_PRIORITY:
1734 return "Priority";
1735 case WAIT_DEPENDENCY:
1736 return "Dependency";
1737 case WAIT_RESOURCES:
1738 return "Resources";
1739 case WAIT_PART_NODE_LIMIT:
1740 return "PartitionNodeLimit";
1741 case WAIT_PART_TIME_LIMIT:
1742 return "PartitionTimeLimit";
1743 case WAIT_PART_DOWN:
1744 return "PartitionDown";
1745 case WAIT_PART_INACTIVE:
1746 return "PartitionInactive";
1747 case WAIT_HELD:
1748 return "JobHeldAdmin";
1749 case WAIT_HELD_USER:
1750 return "JobHeldUser";
1751 case WAIT_TIME:
1752 return "BeginTime";
1753 case WAIT_LICENSES:
1754 return "Licenses";
1755 case WAIT_ASSOC_JOB_LIMIT:
1756 return "AssociationJobLimit";
1757 case WAIT_ASSOC_RESOURCE_LIMIT:
1758 return "AssociationResourceLimit";
1759 case WAIT_ASSOC_TIME_LIMIT:
1760 return "AssociationTimeLimit";
1761 case WAIT_RESERVATION:
1762 return "Reservation";
1763 case WAIT_NODE_NOT_AVAIL:
1764 return "ReqNodeNotAvail";
1765 case WAIT_FRONT_END:
1766 return "FrontEndDown";
1767 case FAIL_DEFER:
1768 return "SchedDefer";
1769 case FAIL_DOWN_PARTITION:
1770 return "PartitionDown";
1771 case FAIL_DOWN_NODE:
1772 return "NodeDown";
1773 case FAIL_BAD_CONSTRAINTS:
1774 return "BadConstraints";
1775 case FAIL_SYSTEM:
1776 return "SystemFailure";
1777 case FAIL_LAUNCH:
1778 return "JobLaunchFailure";
1779 case FAIL_EXIT_CODE:
1780 return "NonZeroExitCode";
1781 case FAIL_TIMEOUT:
1782 return "TimeLimit";
1783 case FAIL_INACTIVE_LIMIT:
1784 return "InactiveLimit";
1785 case FAIL_ACCOUNT:
1786 return "InvalidAccount";
1787 case FAIL_QOS:
1788 return "InvalidQOS";
1789 case WAIT_QOS_THRES:
1790 return "QOSUsageThreshold";
1791 case WAIT_QOS_JOB_LIMIT:
1792 return "QOSJobLimit";
1793 case WAIT_QOS_RESOURCE_LIMIT:
1794 return "QOSResourceLimit";
1795 case WAIT_QOS_TIME_LIMIT:
1796 return "QOSTimeLimit";
1797 case WAIT_BLOCK_MAX_ERR:
1798 return "BlockMaxError";
1799 case WAIT_BLOCK_D_ACTION:
1800 return "BlockFreeAction";
1801 case WAIT_CLEANING:
1802 return "Cleaning";
1803 case WAIT_QOS:
1804 return "QOSNotAllowed";
1805 case WAIT_ACCOUNT:
1806 return "AccountNotAllowed";
1807 case WAIT_DEP_INVALID:
1808 return "DependencyNeverSatisfied";
1809 case WAIT_QOS_GRP_CPU:
1810 return "QOSGrpCpuLimit";
1811 case WAIT_QOS_GRP_CPU_MIN:
1812 return "QOSGrpCPUMinutesLimit";
1813 case WAIT_QOS_GRP_CPU_RUN_MIN:
1814 return "QOSGrpCPURunMinutesLimit";
1815 case WAIT_QOS_GRP_JOB:
1816 return"QOSGrpJobsLimit";
1817 case WAIT_QOS_GRP_MEM:
1818 return "QOSGrpMemLimit";
1819 case WAIT_QOS_GRP_NODE:
1820 return "QOSGrpNodeLimit";
1821 case WAIT_QOS_GRP_SUB_JOB:
1822 return "QOSGrpSubmitJobsLimit";
1823 case WAIT_QOS_GRP_WALL:
1824 return "QOSGrpWallLimit";
1825 case WAIT_QOS_MAX_CPU_PER_JOB:
1826 return "QOSMaxCpuPerJobLimit";
1827 case WAIT_QOS_MAX_CPU_MINS_PER_JOB:
1828 return "QOSMaxCpuMinutesPerJobLimit";
1829 case WAIT_QOS_MAX_NODE_PER_JOB:
1830 return "QOSMaxNodePerJobLimit";
1831 case WAIT_QOS_MAX_WALL_PER_JOB:
1832 return "QOSMaxWallDurationPerJobLimit";
1833 case WAIT_QOS_MAX_CPU_PER_USER:
1834 return "QOSMaxCpuPerUserLimit";
1835 case WAIT_QOS_MAX_JOB_PER_USER:
1836 return "QOSMaxJobsPerUserLimit";
1837 case WAIT_QOS_MAX_NODE_PER_USER:
1838 return "QOSMaxNodePerUserLimit";
1839 case WAIT_QOS_MAX_SUB_JOB:
1840 return "QOSMaxSubmitJobPerUserLimit";
1841 case WAIT_QOS_MIN_CPU:
1842 return "QOSMinCpuNotSatisfied";
1843 case WAIT_ASSOC_GRP_CPU:
1844 return "AssocGrpCpuLimit";
1845 case WAIT_ASSOC_GRP_CPU_MIN:
1846 return "AssocGrpCPUMinutesLimit";
1847 case WAIT_ASSOC_GRP_CPU_RUN_MIN:
1848 return "AssocGrpCPURunMinutesLimit";
1849 case WAIT_ASSOC_GRP_JOB:
1850 return"AssocGrpJobsLimit";
1851 case WAIT_ASSOC_GRP_MEM:
1852 return "AssocGrpMemLimit";
1853 case WAIT_ASSOC_GRP_NODE:
1854 return "AssocGrpNodeLimit";
1855 case WAIT_ASSOC_GRP_SUB_JOB:
1856 return "AssocGrpSubmitJobsLimit";
1857 case WAIT_ASSOC_GRP_WALL:
1858 return "AssocGrpWallLimit";
1859 case WAIT_ASSOC_MAX_JOBS:
1860 return "AssocMaxJobsLimit";
1861 case WAIT_ASSOC_MAX_CPU_PER_JOB:
1862 return "AssocMaxCpuPerJobLimit";
1863 case WAIT_ASSOC_MAX_CPU_MINS_PER_JOB:
1864 return "AssocMaxCpuMinutesPerJobLimit";
1865 case WAIT_ASSOC_MAX_NODE_PER_JOB:
1866 return "AssocMaxNodePerJobLimit";
1867 case WAIT_ASSOC_MAX_WALL_PER_JOB:
1868 return "AssocMaxWallDurationPerJobLimit";
1869 case WAIT_ASSOC_MAX_SUB_JOB:
1870 return "AssocMaxSubmitJobLimit";
1871 case WAIT_MAX_REQUEUE:
1872 return "JobHoldMaxRequeue";
1873 case WAIT_ARRAY_TASK_LIMIT:
1874 return "JobArrayTaskLimit";
1875 case WAIT_BURST_BUFFER_RESOURCE:
1876 return "BurstBufferResources";
1877 case WAIT_BURST_BUFFER_STAGING:
1878 return "BurstBufferStageIn";
1879 case FAIL_BURST_BUFFER_OP:
1880 return "BurstBufferOperation";
1881 case WAIT_POWER_NOT_AVAIL:
1882 return "PowerNotAvail";
1883 case WAIT_POWER_RESERVED:
1884 return "PowerReserved";
1885 case WAIT_ASSOC_GRP_UNK:
1886 return "AssocGrpUnknown";
1887 case WAIT_ASSOC_GRP_UNK_MIN:
1888 return "AssocGrpUnknownMinutes";
1889 case WAIT_ASSOC_GRP_UNK_RUN_MIN:
1890 return "AssocGrpUnknownRunMinutes";
1891 case WAIT_ASSOC_MAX_UNK_PER_JOB:
1892 return "AssocMaxUnknownPerJob";
1893 case WAIT_ASSOC_MAX_UNK_PER_NODE:
1894 return "AssocMaxUnknownPerNode";
1895 case WAIT_ASSOC_MAX_UNK_MINS_PER_JOB:
1896 return "AssocMaxUnknownMinutesPerJob";
1897 case WAIT_ASSOC_MAX_CPU_PER_NODE:
1898 return "AssocMaxCpuPerNode";
1899 case WAIT_ASSOC_GRP_MEM_MIN:
1900 return "AssocGrpMemMinutes";
1901 case WAIT_ASSOC_GRP_MEM_RUN_MIN:
1902 return "AssocGrpMemRunMinutes";
1903 case WAIT_ASSOC_MAX_MEM_PER_JOB:
1904 return "AssocMaxMemPerJob";
1905 case WAIT_ASSOC_MAX_MEM_PER_NODE:
1906 return "AssocMaxMemPerNode";
1907 case WAIT_ASSOC_MAX_MEM_MINS_PER_JOB:
1908 return "AssocMaxMemMinutesPerJob";
1909 case WAIT_ASSOC_GRP_NODE_MIN:
1910 return "AssocGrpNodeMinutes";
1911 case WAIT_ASSOC_GRP_NODE_RUN_MIN:
1912 return "AssocGrpNodeRunMinutes";
1913 case WAIT_ASSOC_MAX_NODE_MINS_PER_JOB:
1914 return "AssocMaxNodeMinutesPerJob";
1915 case WAIT_ASSOC_GRP_ENERGY:
1916 return "AssocGrpEnergy";
1917 case WAIT_ASSOC_GRP_ENERGY_MIN:
1918 return "AssocGrpEnergyMinutes";
1919 case WAIT_ASSOC_GRP_ENERGY_RUN_MIN:
1920 return "AssocGrpEnergyRunMinutes";
1921 case WAIT_ASSOC_MAX_ENERGY_PER_JOB:
1922 return "AssocMaxEnergyPerJob";
1923 case WAIT_ASSOC_MAX_ENERGY_PER_NODE:
1924 return "AssocMaxEnergyPerNode";
1925 case WAIT_ASSOC_MAX_ENERGY_MINS_PER_JOB:
1926 return "AssocMaxEnergyMinutesPerJob";
1927 case WAIT_ASSOC_GRP_GRES:
1928 return "AssocGrpGRES";
1929 case WAIT_ASSOC_GRP_GRES_MIN:
1930 return "AssocGrpGRESMinutes";
1931 case WAIT_ASSOC_GRP_GRES_RUN_MIN:
1932 return "AssocGrpGRESRunMinutes";
1933 case WAIT_ASSOC_MAX_GRES_PER_JOB:
1934 return "AssocMaxGRESPerJob";
1935 case WAIT_ASSOC_MAX_GRES_PER_NODE:
1936 return "AssocMaxGRESPerNode";
1937 case WAIT_ASSOC_MAX_GRES_MINS_PER_JOB:
1938 return "AssocMaxGRESMinutesPerJob";
1939 case WAIT_ASSOC_GRP_LIC:
1940 return "AssocGrpLicense";
1941 case WAIT_ASSOC_GRP_LIC_MIN:
1942 return "AssocGrpLicenseMinutes";
1943 case WAIT_ASSOC_GRP_LIC_RUN_MIN:
1944 return "AssocGrpLicenseRunMinutes";
1945 case WAIT_ASSOC_MAX_LIC_PER_JOB:
1946 return "AssocMaxLicensePerJob";
1947 case WAIT_ASSOC_MAX_LIC_MINS_PER_JOB:
1948 return "AssocMaxLicenseMinutesPerJob";
1949 case WAIT_ASSOC_GRP_BB:
1950 return "AssocGrpBB";
1951 case WAIT_ASSOC_GRP_BB_MIN:
1952 return "AssocGrpBBMinutes";
1953 case WAIT_ASSOC_GRP_BB_RUN_MIN:
1954 return "AssocGrpBBRunMinutes";
1955 case WAIT_ASSOC_MAX_BB_PER_JOB:
1956 return "AssocMaxBBPerJob";
1957 case WAIT_ASSOC_MAX_BB_PER_NODE:
1958 return "AssocMaxBBPerNode";
1959 case WAIT_ASSOC_MAX_BB_MINS_PER_JOB:
1960 return "AssocMaxBBMinutesPerJob";
1961
1962 case WAIT_QOS_GRP_UNK:
1963 return "QOSGrpUnknown";
1964 case WAIT_QOS_GRP_UNK_MIN:
1965 return "QOSGrpUnknownMinutes";
1966 case WAIT_QOS_GRP_UNK_RUN_MIN:
1967 return "QOSGrpUnknownRunMinutes";
1968 case WAIT_QOS_MAX_UNK_PER_JOB:
1969 return "QOSMaxUnknownPerJob";
1970 case WAIT_QOS_MAX_UNK_PER_NODE:
1971 return "QOSMaxUnknownPerNode";
1972 case WAIT_QOS_MAX_UNK_PER_USER:
1973 return "QOSMaxUnknownPerUser";
1974 case WAIT_QOS_MAX_UNK_MINS_PER_JOB:
1975 return "QOSMaxUnknownMinutesPerJob";
1976 case WAIT_QOS_MIN_UNK:
1977 return "QOSMinUnknown";
1978 case WAIT_QOS_MAX_CPU_PER_NODE:
1979 return "QOSMaxCpuPerNode";
1980 case WAIT_QOS_GRP_MEM_MIN:
1981 return "QOSGrpMemoryMinutes";
1982 case WAIT_QOS_GRP_MEM_RUN_MIN:
1983 return "QOSGrpMemoryRunMinutes";
1984 case WAIT_QOS_MAX_MEM_PER_JOB:
1985 return "QOSMaxMemoryPerJob";
1986 case WAIT_QOS_MAX_MEM_PER_NODE:
1987 return "QOSMaxMemoryPerNode";
1988 case WAIT_QOS_MAX_MEM_PER_USER:
1989 return "QOSMaxMemoryPerUser";
1990 case WAIT_QOS_MAX_MEM_MINS_PER_JOB:
1991 return "QOSMaxMemoryMinutesPerJob";
1992 case WAIT_QOS_MIN_MEM:
1993 return "QOSMinMemory";
1994 case WAIT_QOS_GRP_NODE_MIN:
1995 return "QOSGrpNodeMinutes";
1996 case WAIT_QOS_GRP_NODE_RUN_MIN:
1997 return "QOSGrpNodeRunMinutes";
1998 case WAIT_QOS_MAX_NODE_MINS_PER_JOB:
1999 return "QOSMaxNodeMinutesPerJob";
2000 case WAIT_QOS_MIN_NODE:
2001 return "QOSMinNode";
2002 case WAIT_QOS_GRP_ENERGY:
2003 return "QOSGrpEnergy";
2004 case WAIT_QOS_GRP_ENERGY_MIN:
2005 return "QOSGrpEnergyMinutes";
2006 case WAIT_QOS_GRP_ENERGY_RUN_MIN:
2007 return "QOSGrpEnergyRunMinutes";
2008 case WAIT_QOS_MAX_ENERGY_PER_JOB:
2009 return "QOSMaxEnergyPerJob";
2010 case WAIT_QOS_MAX_ENERGY_PER_NODE:
2011 return "QOSMaxEnergyPerNode";
2012 case WAIT_QOS_MAX_ENERGY_PER_USER:
2013 return "QOSMaxEnergyPerUser";
2014 case WAIT_QOS_MAX_ENERGY_MINS_PER_JOB:
2015 return "QOSMaxEnergyMinutesPerJob";
2016 case WAIT_QOS_MIN_ENERGY:
2017 return "QOSMinEnergy";
2018 case WAIT_QOS_GRP_GRES:
2019 return "QOSGrpGRES";
2020 case WAIT_QOS_GRP_GRES_MIN:
2021 return "QOSGrpGRESMinutes";
2022 case WAIT_QOS_GRP_GRES_RUN_MIN:
2023 return "QOSGrpGRESRunMinutes";
2024 case WAIT_QOS_MAX_GRES_PER_JOB:
2025 return "QOSMaxGRESPerJob";
2026 case WAIT_QOS_MAX_GRES_PER_NODE:
2027 return "QOSMaxGRESPerNode";
2028 case WAIT_QOS_MAX_GRES_PER_USER:
2029 return "QOSMaxGRESPerUser";
2030 case WAIT_QOS_MAX_GRES_MINS_PER_JOB:
2031 return "QOSMaxGRESMinutesPerJob";
2032 case WAIT_QOS_MIN_GRES:
2033 return "QOSMinGRES";
2034 case WAIT_QOS_GRP_LIC:
2035 return "QOSGrpLicense";
2036 case WAIT_QOS_GRP_LIC_MIN:
2037 return "QOSGrpLicenseMinutes";
2038 case WAIT_QOS_GRP_LIC_RUN_MIN:
2039 return "QOSGrpLicenseRunMinutes";
2040 case WAIT_QOS_MAX_LIC_PER_JOB:
2041 return "QOSMaxLicensePerJob";
2042 case WAIT_QOS_MAX_LIC_PER_USER:
2043 return "QOSMaxLicensePerUser";
2044 case WAIT_QOS_MAX_LIC_MINS_PER_JOB:
2045 return "QOSMaxLicenseMinutesPerJob";
2046 case WAIT_QOS_MIN_LIC:
2047 return "QOSMinLicense";
2048 case WAIT_QOS_GRP_BB:
2049 return "QOSGrpBB";
2050 case WAIT_QOS_GRP_BB_MIN:
2051 return "QOSGrpBBMinutes";
2052 case WAIT_QOS_GRP_BB_RUN_MIN:
2053 return "QOSGrpBBRunMinutes";
2054 case WAIT_QOS_MAX_BB_PER_JOB:
2055 return "QOSMaxBBPerJob";
2056 case WAIT_QOS_MAX_BB_PER_NODE:
2057 return "QOSMaxBBPerNode";
2058 case WAIT_QOS_MAX_BB_PER_USER:
2059 return "QOSMaxBBPerUser";
2060 case WAIT_QOS_MAX_BB_MINS_PER_JOB:
2061 return "AssocMaxBBMinutesPerJob";
2062 case WAIT_QOS_MIN_BB:
2063 return "QOSMinBB";
2064 case FAIL_DEADLINE:
2065 return "DeadLine";
2066 case WAIT_QOS_MAX_BB_PER_ACCT:
2067 return "MaxBBPerAccount";
2068 case WAIT_QOS_MAX_CPU_PER_ACCT:
2069 return "MaxCpuPerAccount";
2070 case WAIT_QOS_MAX_ENERGY_PER_ACCT:
2071 return "MaxEnergyPerAccount";
2072 case WAIT_QOS_MAX_GRES_PER_ACCT:
2073 return "MaxGRESPerAccount";
2074 case WAIT_QOS_MAX_NODE_PER_ACCT:
2075 return "MaxNodePerAccount";
2076 case WAIT_QOS_MAX_LIC_PER_ACCT:
2077 return "MaxLicensePerAccount";
2078 case WAIT_QOS_MAX_MEM_PER_ACCT:
2079 return "MaxMemoryPerAccount";
2080 case WAIT_QOS_MAX_UNK_PER_ACCT:
2081 return "MaxUnknownPerAccount";
2082 case WAIT_QOS_MAX_JOB_PER_ACCT:
2083 return "MaxJobsPerAccount";
2084 case WAIT_QOS_MAX_SUB_JOB_PER_ACCT:
2085 return "MaxSubmitJobsPerAccount";
2086 case WAIT_PART_CONFIG:
2087 return "PartitionConfig";
2088 case WAIT_ACCOUNT_POLICY:
2089 return "AccountingPolicy";
2090 case WAIT_FED_JOB_LOCK:
2091 return "FedJobLock";
2092 case FAIL_OOM:
2093 return "OutOfMemory";
2094 case WAIT_PN_MEM_LIMIT:
2095 return "MaxMemPerLimit";
2096 case WAIT_ASSOC_GRP_BILLING:
2097 return "AssocGrpBilling";
2098 case WAIT_ASSOC_GRP_BILLING_MIN:
2099 return "AssocGrpBillingMinutes";
2100 case WAIT_ASSOC_GRP_BILLING_RUN_MIN:
2101 return "AssocGrpBillingRunMinutes";
2102 case WAIT_ASSOC_MAX_BILLING_PER_JOB:
2103 return "AssocMaxBillingPerJob";
2104 case WAIT_ASSOC_MAX_BILLING_PER_NODE:
2105 return "AssocMaxBillingPerNode";
2106 case WAIT_ASSOC_MAX_BILLING_MINS_PER_JOB:
2107 return "AssocMaxBillingMinutesPerJob";
2108 case WAIT_QOS_GRP_BILLING:
2109 return "QOSGrpBilling";
2110 case WAIT_QOS_GRP_BILLING_MIN:
2111 return "QOSGrpBillingMinutes";
2112 case WAIT_QOS_GRP_BILLING_RUN_MIN:
2113 return "QOSGrpBillingRunMinutes";
2114 case WAIT_QOS_MAX_BILLING_PER_JOB:
2115 return "QOSMaxBillingPerJob";
2116 case WAIT_QOS_MAX_BILLING_PER_NODE:
2117 return "QOSMaxBillingPerNode";
2118 case WAIT_QOS_MAX_BILLING_PER_USER:
2119 return "QOSMaxBillingPerUser";
2120 case WAIT_QOS_MAX_BILLING_MINS_PER_JOB:
2121 return "QOSMaxBillingMinutesPerJob";
2122 case WAIT_QOS_MAX_BILLING_PER_ACCT:
2123 return "MaxBillingPerAccount";
2124 case WAIT_QOS_MIN_BILLING:
2125 return "QOSMinBilling";
2126 case WAIT_RESV_DELETED:
2127 return "ReservationDeleted";
2128 default:
2129 snprintf(val, sizeof(val), "%d", inx);
2130 return val;
2131 }
2132 }
2133
2134 /* Given a job's reason string for waiting, return enum job_state_reason */
job_reason_num(char * reason)2135 extern enum job_state_reason job_reason_num(char *reason)
2136 {
2137 if (!xstrcasecmp(reason, "None"))
2138 return WAIT_NO_REASON;
2139 if (!xstrcasecmp(reason, "Prolog"))
2140 return WAIT_PROLOG;
2141 if (!xstrcasecmp(reason, "Priority"))
2142 return WAIT_PRIORITY;
2143 if (!xstrcasecmp(reason, "Dependency"))
2144 return WAIT_DEPENDENCY;
2145 if (!xstrcasecmp(reason, "Resources"))
2146 return WAIT_RESOURCES;
2147 if (!xstrcasecmp(reason, "PartitionNodeLimit"))
2148 return WAIT_PART_NODE_LIMIT;
2149 if (!xstrcasecmp(reason, "PartitionTimeLimit"))
2150 return WAIT_PART_TIME_LIMIT;
2151 if (!xstrcasecmp(reason, "PartitionDown"))
2152 return WAIT_PART_DOWN;
2153 if (!xstrcasecmp(reason, "PartitionInactive"))
2154 return WAIT_PART_INACTIVE;
2155 if (!xstrcasecmp(reason, "JobHeldAdmin"))
2156 return WAIT_HELD;
2157 if (!xstrcasecmp(reason, "JobHeldUser"))
2158 return WAIT_HELD_USER;
2159 if (!xstrcasecmp(reason, "BeginTime"))
2160 return WAIT_TIME;
2161 if (!xstrcasecmp(reason, "Licenses"))
2162 return WAIT_LICENSES;
2163 if (!xstrcasecmp(reason, "AssociationJobLimit"))
2164 return WAIT_ASSOC_JOB_LIMIT;
2165 if (!xstrcasecmp(reason, "AssociationResourceLimit"))
2166 return WAIT_ASSOC_RESOURCE_LIMIT;
2167 if (!xstrcasecmp(reason, "AssociationTimeLimit"))
2168 return WAIT_ASSOC_TIME_LIMIT;
2169 if (!xstrcasecmp(reason, "Reservation"))
2170 return WAIT_RESERVATION;
2171 if (!xstrcasecmp(reason, "ReqNodeNotAvail"))
2172 return WAIT_NODE_NOT_AVAIL;
2173 if (!xstrcasecmp(reason, "FrontEndDown"))
2174 return WAIT_FRONT_END;
2175 if (!xstrcasecmp(reason, "PartitionDown"))
2176 return FAIL_DOWN_PARTITION;
2177 if (!xstrcasecmp(reason, "NodeDown"))
2178 return FAIL_DOWN_NODE;
2179 if (!xstrcasecmp(reason, "BadConstraints"))
2180 return FAIL_BAD_CONSTRAINTS;
2181 if (!xstrcasecmp(reason, "SystemFailure"))
2182 return FAIL_SYSTEM;
2183 if (!xstrcasecmp(reason, "JobLaunchFailure"))
2184 return FAIL_LAUNCH;
2185 if (!xstrcasecmp(reason, "NonZeroExitCode"))
2186 return FAIL_EXIT_CODE;
2187 if (!xstrcasecmp(reason, "TimeLimit"))
2188 return FAIL_TIMEOUT;
2189 if (!xstrcasecmp(reason, "InactiveLimit"))
2190 return FAIL_INACTIVE_LIMIT;
2191 if (!xstrcasecmp(reason, "InvalidAccount"))
2192 return FAIL_ACCOUNT;
2193 if (!xstrcasecmp(reason, "InvalidQOS"))
2194 return FAIL_QOS;
2195 if (!xstrcasecmp(reason, "QOSUsageThreshold"))
2196 return WAIT_QOS_THRES;
2197 if (!xstrcasecmp(reason, "QOSJobLimit"))
2198 return WAIT_QOS_JOB_LIMIT;
2199 if (!xstrcasecmp(reason, "QOSResourceLimit"))
2200 return WAIT_QOS_RESOURCE_LIMIT;
2201 if (!xstrcasecmp(reason, "QOSTimeLimit"))
2202 return WAIT_QOS_TIME_LIMIT;
2203 if (!xstrcasecmp(reason, "BlockMaxError"))
2204 return WAIT_BLOCK_MAX_ERR;
2205 if (!xstrcasecmp(reason, "BlockFreeAction"))
2206 return WAIT_BLOCK_D_ACTION;
2207 if (!xstrcasecmp(reason, "Cleaning"))
2208 return WAIT_CLEANING;
2209 if (!xstrcasecmp(reason, "QOSNotAllowed"))
2210 return WAIT_QOS;
2211 if (!xstrcasecmp(reason, "AccountNotAllowed"))
2212 return WAIT_ACCOUNT;
2213 if (!xstrcasecmp(reason, "DependencyNeverSatisfied"))
2214 return WAIT_DEP_INVALID;
2215 if (!xstrcasecmp(reason, "QOSGrpCpuLimit"))
2216 return WAIT_QOS_GRP_CPU;
2217 if (!xstrcasecmp(reason, "QOSGrpCPUMinutesLimit"))
2218 return WAIT_QOS_GRP_CPU_MIN;
2219 if (!xstrcasecmp(reason, "QOSGrpCPURunMinutesLimit"))
2220 return WAIT_QOS_GRP_CPU_RUN_MIN;
2221 if (!xstrcasecmp(reason, "QOSGrpJobsLimit"))
2222 return WAIT_QOS_GRP_JOB;
2223 if (!xstrcasecmp(reason, "QOSGrpMemLimit"))
2224 return WAIT_QOS_GRP_MEM;
2225 if (!xstrcasecmp(reason, "QOSGrpNodeLimit"))
2226 return WAIT_QOS_GRP_NODE;
2227 if (!xstrcasecmp(reason, "QOSGrpSubmitJobsLimit"))
2228 return WAIT_QOS_GRP_SUB_JOB;
2229 if (!xstrcasecmp(reason, "QOSGrpWallLimit"))
2230 return WAIT_QOS_GRP_WALL;
2231 if (!xstrcasecmp(reason, "QOSMaxCpuPerJobLimit"))
2232 return WAIT_QOS_MAX_CPU_PER_JOB;
2233 if (!xstrcasecmp(reason, "QOSMaxCpuMinutesPerJobLimit"))
2234 return WAIT_QOS_MAX_CPU_MINS_PER_JOB;
2235 if (!xstrcasecmp(reason, "QOSMaxNodePerJobLimit"))
2236 return WAIT_QOS_MAX_NODE_PER_JOB;
2237 if (!xstrcasecmp(reason, "QOSMaxWallDurationPerJobLimit"))
2238 return WAIT_QOS_MAX_WALL_PER_JOB;
2239 if (!xstrcasecmp(reason, "QOSMaxCpuPerUserLimit"))
2240 return WAIT_QOS_MAX_CPU_PER_USER;
2241 if (!xstrcasecmp(reason, "QOSMaxJobsPerUserLimit"))
2242 return WAIT_QOS_MAX_JOB_PER_USER;
2243 if (!xstrcasecmp(reason, "QOSMaxNodePerUserLimit"))
2244 return WAIT_QOS_MAX_NODE_PER_USER;
2245 if (!xstrcasecmp(reason, "QOSMaxSubmitJobPerUserLimit"))
2246 return WAIT_QOS_MAX_SUB_JOB;
2247 if (!xstrcasecmp(reason, "QOSMinCpuNotSatisfied"))
2248 return WAIT_QOS_MIN_CPU;
2249 if (!xstrcasecmp(reason, "AssocGrpCpuLimit"))
2250 return WAIT_ASSOC_GRP_CPU;
2251 if (!xstrcasecmp(reason, "AssocGrpCPUMinutesLimit"))
2252 return WAIT_ASSOC_GRP_CPU_MIN;
2253 if (!xstrcasecmp(reason, "AssocGrpCPURunMinutesLimit"))
2254 return WAIT_ASSOC_GRP_CPU_RUN_MIN;
2255 if (!xstrcasecmp(reason, "AssocGrpJobsLimit"))
2256 return WAIT_ASSOC_GRP_JOB;
2257 if (!xstrcasecmp(reason, "AssocGrpMemLimit"))
2258 return WAIT_ASSOC_GRP_MEM;
2259 if (!xstrcasecmp(reason, "AssocGrpNodeLimit"))
2260 return WAIT_ASSOC_GRP_NODE;
2261 if (!xstrcasecmp(reason, "AssocGrpSubmitJobsLimit"))
2262 return WAIT_ASSOC_GRP_SUB_JOB;
2263 if (!xstrcasecmp(reason, "AssocGrpWallLimit"))
2264 return WAIT_ASSOC_GRP_WALL;
2265 if (!xstrcasecmp(reason, "AssocMaxJobsLimit"))
2266 return WAIT_ASSOC_MAX_JOBS;
2267 if (!xstrcasecmp(reason, "AssocMaxCpuPerJobLimit"))
2268 return WAIT_ASSOC_MAX_CPU_PER_JOB;
2269 if (!xstrcasecmp(reason, "AssocMaxCpuMinutesPerJobLimit"))
2270 return WAIT_ASSOC_MAX_CPU_MINS_PER_JOB;
2271 if (!xstrcasecmp(reason, "AssocMaxNodePerJobLimit"))
2272 return WAIT_ASSOC_MAX_NODE_PER_JOB;
2273 if (!xstrcasecmp(reason, "AssocMaxWallDurationPerJobLimit"))
2274 return WAIT_ASSOC_MAX_WALL_PER_JOB;
2275 if (!xstrcasecmp(reason, "AssocMaxSubmitJobLimit"))
2276 return WAIT_ASSOC_MAX_SUB_JOB;
2277 if (!xstrcasecmp(reason, "JobHoldMaxRequeue"))
2278 return WAIT_MAX_REQUEUE;
2279 if (!xstrcasecmp(reason, "JobArrayTaskLimit"))
2280 return WAIT_ARRAY_TASK_LIMIT;
2281 if (!xstrcasecmp(reason, "BurstBufferResources"))
2282 return WAIT_BURST_BUFFER_RESOURCE;
2283 if (!xstrcasecmp(reason, "BurstBufferStageIn"))
2284 return WAIT_BURST_BUFFER_STAGING;
2285 if (!xstrcasecmp(reason, "BurstBufferOperation"))
2286 return FAIL_BURST_BUFFER_OP;
2287 if (!xstrcasecmp(reason, "PowerNotAvail"))
2288 return WAIT_POWER_NOT_AVAIL;
2289 if (!xstrcasecmp(reason, "PowerReserved"))
2290 return WAIT_POWER_RESERVED;
2291 if (!xstrcasecmp(reason, "AssocGrpUnknown"))
2292 return WAIT_ASSOC_GRP_UNK;
2293 if (!xstrcasecmp(reason, "AssocGrpUnknownMinutes"))
2294 return WAIT_ASSOC_GRP_UNK_MIN;
2295 if (!xstrcasecmp(reason, "AssocGrpUnknownRunMinutes"))
2296 return WAIT_ASSOC_GRP_UNK_RUN_MIN;
2297 if (!xstrcasecmp(reason, "AssocMaxUnknownPerJob"))
2298 return WAIT_ASSOC_MAX_UNK_PER_JOB;
2299 if (!xstrcasecmp(reason, "AssocMaxUnknownPerNode"))
2300 return WAIT_ASSOC_MAX_UNK_PER_NODE;
2301 if (!xstrcasecmp(reason, "AssocMaxUnknownMinutesPerJob"))
2302 return WAIT_ASSOC_MAX_UNK_MINS_PER_JOB;
2303 if (!xstrcasecmp(reason, "AssocMaxCpuPerNode"))
2304 return WAIT_ASSOC_MAX_CPU_PER_NODE;
2305 if (!xstrcasecmp(reason, "AssocGrpMemMinutes"))
2306 return WAIT_ASSOC_GRP_MEM_MIN;
2307 if (!xstrcasecmp(reason, "AssocGrpMemRunMinutes"))
2308 return WAIT_ASSOC_GRP_MEM_RUN_MIN;
2309 if (!xstrcasecmp(reason, "AssocMaxMemPerJob"))
2310 return WAIT_ASSOC_MAX_MEM_PER_JOB;
2311 if (!xstrcasecmp(reason, "AssocMaxMemPerNode"))
2312 return WAIT_ASSOC_MAX_MEM_PER_NODE;
2313 if (!xstrcasecmp(reason, "AssocMaxMemMinutesPerJob"))
2314 return WAIT_ASSOC_MAX_MEM_MINS_PER_JOB;
2315 if (!xstrcasecmp(reason, "AssocGrpNodeMinutes"))
2316 return WAIT_ASSOC_GRP_NODE_MIN;
2317 if (!xstrcasecmp(reason, "AssocGrpNodeRunMinutes"))
2318 return WAIT_ASSOC_GRP_NODE_RUN_MIN;
2319 if (!xstrcasecmp(reason, "AssocMaxNodeMinutesPerJob"))
2320 return WAIT_ASSOC_MAX_NODE_MINS_PER_JOB;
2321 if (!xstrcasecmp(reason, "AssocGrpEnergy"))
2322 return WAIT_ASSOC_GRP_ENERGY;
2323 if (!xstrcasecmp(reason, "AssocGrpEnergyMinutes"))
2324 return WAIT_ASSOC_GRP_ENERGY_MIN;
2325 if (!xstrcasecmp(reason, "AssocGrpEnergyRunMinutes"))
2326 return WAIT_ASSOC_GRP_ENERGY_RUN_MIN;
2327 if (!xstrcasecmp(reason, "AssocMaxEnergyPerJob"))
2328 return WAIT_ASSOC_MAX_ENERGY_PER_JOB;
2329 if (!xstrcasecmp(reason, "AssocMaxEnergyPerNode"))
2330 return WAIT_ASSOC_MAX_ENERGY_PER_NODE;
2331 if (!xstrcasecmp(reason, "AssocMaxEnergyMinutesPerJob"))
2332 return WAIT_ASSOC_MAX_ENERGY_MINS_PER_JOB;
2333 if (!xstrcasecmp(reason, "AssocGrpGRES"))
2334 return WAIT_ASSOC_GRP_GRES;
2335 if (!xstrcasecmp(reason, "AssocGrpGRESMinutes"))
2336 return WAIT_ASSOC_GRP_GRES_MIN;
2337 if (!xstrcasecmp(reason, "AssocGrpGRESRunMinutes"))
2338 return WAIT_ASSOC_GRP_GRES_RUN_MIN;
2339 if (!xstrcasecmp(reason, "AssocMaxGRESPerJob"))
2340 return WAIT_ASSOC_MAX_GRES_PER_JOB;
2341 if (!xstrcasecmp(reason, "AssocMaxGRESPerNode"))
2342 return WAIT_ASSOC_MAX_GRES_PER_NODE;
2343 if (!xstrcasecmp(reason, "AssocMaxGRESMinutesPerJob"))
2344 return WAIT_ASSOC_MAX_GRES_MINS_PER_JOB;
2345 if (!xstrcasecmp(reason, "AssocGrpLicense"))
2346 return WAIT_ASSOC_GRP_LIC;
2347 if (!xstrcasecmp(reason, "AssocGrpLicenseMinutes"))
2348 return WAIT_ASSOC_GRP_LIC_MIN;
2349 if (!xstrcasecmp(reason, "AssocGrpLicenseRunMinutes"))
2350 return WAIT_ASSOC_GRP_LIC_RUN_MIN;
2351 if (!xstrcasecmp(reason, "AssocMaxLicensePerJob"))
2352 return WAIT_ASSOC_MAX_LIC_PER_JOB;
2353 if (!xstrcasecmp(reason, "AssocMaxLicenseMinutesPerJob"))
2354 return WAIT_ASSOC_MAX_LIC_MINS_PER_JOB;
2355 if (!xstrcasecmp(reason, "AssocGrpBB"))
2356 return WAIT_ASSOC_GRP_BB;
2357 if (!xstrcasecmp(reason, "AssocGrpBBMinutes"))
2358 return WAIT_ASSOC_GRP_BB_MIN;
2359 if (!xstrcasecmp(reason, "AssocGrpBBRunMinutes"))
2360 return WAIT_ASSOC_GRP_BB_RUN_MIN;
2361 if (!xstrcasecmp(reason, "AssocMaxBBPerJob"))
2362 return WAIT_ASSOC_MAX_BB_PER_JOB;
2363 if (!xstrcasecmp(reason, "AssocMaxBBPerNode"))
2364 return WAIT_ASSOC_MAX_BB_PER_NODE;
2365 if (!xstrcasecmp(reason, "AssocMaxBBMinutesPerJob"))
2366 return WAIT_ASSOC_MAX_BB_MINS_PER_JOB;
2367 if (!xstrcasecmp(reason, "QOSGrpUnknown"))
2368 return WAIT_QOS_GRP_UNK;
2369 if (!xstrcasecmp(reason, "QOSGrpUnknownMinutes"))
2370 return WAIT_QOS_GRP_UNK_MIN;
2371 if (!xstrcasecmp(reason, "QOSGrpUnknownRunMinutes"))
2372 return WAIT_QOS_GRP_UNK_RUN_MIN;
2373 if (!xstrcasecmp(reason, "QOSMaxUnknownPerJob"))
2374 return WAIT_QOS_MAX_UNK_PER_JOB;
2375 if (!xstrcasecmp(reason, "QOSMaxUnknownPerNode"))
2376 return WAIT_QOS_MAX_UNK_PER_NODE;
2377 if (!xstrcasecmp(reason, "QOSMaxUnknownPerUser"))
2378 return WAIT_QOS_MAX_UNK_PER_USER;
2379 if (!xstrcasecmp(reason, "QOSMaxUnknownMinutesPerJob"))
2380 return WAIT_QOS_MAX_UNK_MINS_PER_JOB;
2381 if (!xstrcasecmp(reason, "QOSMinUnknown"))
2382 return WAIT_QOS_MIN_UNK;
2383 if (!xstrcasecmp(reason, "QOSMaxCpuPerNode"))
2384 return WAIT_QOS_MAX_CPU_PER_NODE;
2385 if (!xstrcasecmp(reason, "QOSGrpMemoryMinutes"))
2386 return WAIT_QOS_GRP_MEM_MIN;
2387 if (!xstrcasecmp(reason, "QOSGrpMemoryRunMinutes"))
2388 return WAIT_QOS_GRP_MEM_RUN_MIN;
2389 if (!xstrcasecmp(reason, "QOSMaxMemoryPerJob"))
2390 return WAIT_QOS_MAX_MEM_PER_JOB;
2391 if (!xstrcasecmp(reason, "QOSMaxMemoryPerNode"))
2392 return WAIT_QOS_MAX_MEM_PER_NODE;
2393 if (!xstrcasecmp(reason, "QOSMaxMemoryPerUser"))
2394 return WAIT_QOS_MAX_MEM_PER_USER;
2395 if (!xstrcasecmp(reason, "QOSMaxMemoryMinutesPerJob"))
2396 return WAIT_QOS_MAX_MEM_MINS_PER_JOB;
2397 if (!xstrcasecmp(reason, "QOSMinMemory"))
2398 return WAIT_QOS_MIN_MEM;
2399 if (!xstrcasecmp(reason, "QOSGrpNodeMinutes"))
2400 return WAIT_QOS_GRP_NODE_MIN;
2401 if (!xstrcasecmp(reason, "QOSGrpNodeRunMinutes"))
2402 return WAIT_QOS_GRP_NODE_RUN_MIN;
2403 if (!xstrcasecmp(reason, "QOSMaxNodeMinutesPerJob"))
2404 return WAIT_QOS_MAX_NODE_MINS_PER_JOB;
2405 if (!xstrcasecmp(reason, "QOSMinNode"))
2406 return WAIT_QOS_MIN_NODE;
2407 if (!xstrcasecmp(reason, "QOSGrpEnergy"))
2408 return WAIT_QOS_GRP_ENERGY;
2409 if (!xstrcasecmp(reason, "QOSGrpEnergyMinutes"))
2410 return WAIT_QOS_GRP_ENERGY_MIN;
2411 if (!xstrcasecmp(reason, "QOSGrpEnergyRunMinutes"))
2412 return WAIT_QOS_GRP_ENERGY_RUN_MIN;
2413 if (!xstrcasecmp(reason, "QOSMaxEnergyPerJob"))
2414 return WAIT_QOS_MAX_ENERGY_PER_JOB;
2415 if (!xstrcasecmp(reason, "QOSMaxEnergyPerNode"))
2416 return WAIT_QOS_MAX_ENERGY_PER_NODE;
2417 if (!xstrcasecmp(reason, "QOSMaxEnergyPerUser"))
2418 return WAIT_QOS_MAX_ENERGY_PER_USER;
2419 if (!xstrcasecmp(reason, "QOSMaxEnergyMinutesPerJob"))
2420 return WAIT_QOS_MAX_ENERGY_MINS_PER_JOB;
2421 if (!xstrcasecmp(reason, "QOSMinEnergy"))
2422 return WAIT_QOS_MIN_ENERGY;
2423 if (!xstrcasecmp(reason, "QOSGrpGRES"))
2424 return WAIT_QOS_GRP_GRES;
2425 if (!xstrcasecmp(reason, "QOSGrpGRESMinutes"))
2426 return WAIT_QOS_GRP_GRES_MIN;
2427 if (!xstrcasecmp(reason, "QOSGrpGRESRunMinutes"))
2428 return WAIT_QOS_GRP_GRES_RUN_MIN;
2429 if (!xstrcasecmp(reason, "QOSMaxGRESPerJob"))
2430 return WAIT_QOS_MAX_GRES_PER_JOB;
2431 if (!xstrcasecmp(reason, "QOSMaxGRESPerNode"))
2432 return WAIT_QOS_MAX_GRES_PER_NODE;
2433 if (!xstrcasecmp(reason, "QOSMaxGRESPerUser"))
2434 return WAIT_QOS_MAX_GRES_PER_USER;
2435 if (!xstrcasecmp(reason, "QOSMaxGRESMinutesPerJob"))
2436 return WAIT_QOS_MAX_GRES_MINS_PER_JOB;
2437 if (!xstrcasecmp(reason, "QOSMinGRES"))
2438 return WAIT_QOS_MIN_GRES;
2439 if (!xstrcasecmp(reason, "QOSGrpLicense"))
2440 return WAIT_QOS_GRP_LIC;
2441 if (!xstrcasecmp(reason, "QOSGrpLicenseMinutes"))
2442 return WAIT_QOS_GRP_LIC_MIN;
2443 if (!xstrcasecmp(reason, "QOSGrpLicenseRunMinutes"))
2444 return WAIT_QOS_GRP_LIC_RUN_MIN;
2445 if (!xstrcasecmp(reason, "QOSMaxLicensePerJob"))
2446 return WAIT_QOS_MAX_LIC_PER_JOB;
2447 if (!xstrcasecmp(reason, "QOSMaxLicensePerUser"))
2448 return WAIT_QOS_MAX_LIC_PER_USER;
2449 if (!xstrcasecmp(reason, "QOSMaxLicenseMinutesPerJob"))
2450 return WAIT_QOS_MAX_LIC_MINS_PER_JOB;
2451 if (!xstrcasecmp(reason, "QOSMinLicense"))
2452 return WAIT_QOS_MIN_LIC;
2453 if (!xstrcasecmp(reason, "QOSGrpBB"))
2454 return WAIT_QOS_GRP_BB;
2455 if (!xstrcasecmp(reason, "QOSGrpBBMinutes"))
2456 return WAIT_QOS_GRP_BB_MIN;
2457 if (!xstrcasecmp(reason, "QOSGrpBBRunMinutes"))
2458 return WAIT_QOS_GRP_BB_RUN_MIN;
2459 if (!xstrcasecmp(reason, "QOSMaxBBPerJob"))
2460 return WAIT_QOS_MAX_BB_PER_JOB;
2461 if (!xstrcasecmp(reason, "QOSMaxBBPerNode"))
2462 return WAIT_QOS_MAX_BB_PER_NODE;
2463 if (!xstrcasecmp(reason, "QOSMaxBBPerUser"))
2464 return WAIT_QOS_MAX_BB_PER_USER;
2465 if (!xstrcasecmp(reason, "AssocMaxBBMinutesPerJob"))
2466 return WAIT_QOS_MAX_BB_MINS_PER_JOB;
2467 if (!xstrcasecmp(reason, "QOSMinBB"))
2468 return WAIT_QOS_MIN_BB;
2469 if (!xstrcasecmp(reason, "DeadLine"))
2470 return FAIL_DEADLINE;
2471 if (!xstrcasecmp(reason, "MaxBBPerAccount"))
2472 return WAIT_QOS_MAX_BB_PER_ACCT;
2473 if (!xstrcasecmp(reason, "MaxCpuPerAccount"))
2474 return WAIT_QOS_MAX_CPU_PER_ACCT;
2475 if (!xstrcasecmp(reason, "MaxEnergyPerAccount"))
2476 return WAIT_QOS_MAX_ENERGY_PER_ACCT;
2477 if (!xstrcasecmp(reason, "MaxGRESPerAccount"))
2478 return WAIT_QOS_MAX_GRES_PER_ACCT;
2479 if (!xstrcasecmp(reason, "MaxNodePerAccount"))
2480 return WAIT_QOS_MAX_NODE_PER_ACCT;
2481 if (!xstrcasecmp(reason, "MaxLicensePerAccount"))
2482 return WAIT_QOS_MAX_LIC_PER_ACCT;
2483 if (!xstrcasecmp(reason, "MaxMemoryPerAccount"))
2484 return WAIT_QOS_MAX_MEM_PER_ACCT;
2485 if (!xstrcasecmp(reason, "MaxUnknownPerAccount"))
2486 return WAIT_QOS_MAX_UNK_PER_ACCT;
2487 if (!xstrcasecmp(reason, "MaxJobsPerAccount"))
2488 return WAIT_QOS_MAX_JOB_PER_ACCT;
2489 if (!xstrcasecmp(reason, "MaxSubmitJobsPerAccount"))
2490 return WAIT_QOS_MAX_SUB_JOB_PER_ACCT;
2491 if (!xstrcasecmp(reason, "PartitionConfig"))
2492 return WAIT_PART_CONFIG;
2493 if (!xstrcasecmp(reason, "AccountingPolicy"))
2494 return WAIT_ACCOUNT_POLICY;
2495 if (!xstrcasecmp(reason, "FedJobLock"))
2496 return WAIT_FED_JOB_LOCK;
2497 if (!xstrcasecmp(reason, "OutOfMemory"))
2498 return FAIL_OOM;
2499 if (!xstrcasecmp(reason, "MaxMemPerLimit"))
2500 return WAIT_PN_MEM_LIMIT;
2501 if (!xstrcasecmp(reason, "AssocGrpBilling"))
2502 return WAIT_ASSOC_GRP_BILLING;
2503 if (!xstrcasecmp(reason, "AssocGrpBillingMinutes"))
2504 return WAIT_ASSOC_GRP_BILLING_MIN;
2505 if (!xstrcasecmp(reason, "AssocGrpBillingRunMinutes"))
2506 return WAIT_ASSOC_GRP_BILLING_RUN_MIN;
2507 if (!xstrcasecmp(reason, "AssocMaxBillingPerJob"))
2508 return WAIT_ASSOC_MAX_BILLING_PER_JOB;
2509 if (!xstrcasecmp(reason, "AssocMaxBillingPerNode"))
2510 return WAIT_ASSOC_MAX_BILLING_PER_NODE;
2511 if (!xstrcasecmp(reason, "AssocMaxBillingMinutesPerJob"))
2512 return WAIT_ASSOC_MAX_BILLING_MINS_PER_JOB;
2513 if (!xstrcasecmp(reason, "QOSGrpBilling"))
2514 return WAIT_QOS_GRP_BILLING;
2515 if (!xstrcasecmp(reason, "QOSGrpBillingMinutes"))
2516 return WAIT_QOS_GRP_BILLING_MIN;
2517 if (!xstrcasecmp(reason, "QOSGrpBillingRunMinutes"))
2518 return WAIT_QOS_GRP_BILLING_RUN_MIN;
2519 if (!xstrcasecmp(reason, "QOSMaxBillingPerJob"))
2520 return WAIT_QOS_MAX_BILLING_PER_JOB;
2521 if (!xstrcasecmp(reason, "QOSMaxBillingPerNode"))
2522 return WAIT_QOS_MAX_BILLING_PER_NODE;
2523 if (!xstrcasecmp(reason, "QOSMaxBillingPerUser"))
2524 return WAIT_QOS_MAX_BILLING_PER_USER;
2525 if (!xstrcasecmp(reason, "QOSMaxBillingMinutesPerJob"))
2526 return WAIT_QOS_MAX_BILLING_MINS_PER_JOB;
2527 if (!xstrcasecmp(reason, "MaxBillingPerAccount"))
2528 return WAIT_QOS_MAX_BILLING_PER_ACCT;
2529 if (!xstrcasecmp(reason, "QOSMinBilling"))
2530 return WAIT_QOS_MIN_BILLING;
2531 if (!xstrcasecmp(reason, "ReservationDeleted"))
2532 return WAIT_RESV_DELETED;
2533
2534 return NO_VAL;
2535 }
2536
2537 /* If the job is held up by a QOS GRP limit return true else return false. */
job_state_qos_grp_limit(enum job_state_reason state_reason)2538 extern bool job_state_qos_grp_limit(enum job_state_reason state_reason)
2539 {
2540 if ((state_reason >= WAIT_QOS_GRP_CPU &&
2541 state_reason <= WAIT_QOS_GRP_WALL) ||
2542 (state_reason == WAIT_QOS_GRP_MEM_MIN) ||
2543 (state_reason == WAIT_QOS_GRP_MEM_RUN_MIN) ||
2544 (state_reason >= WAIT_QOS_GRP_ENERGY &&
2545 state_reason <= WAIT_QOS_GRP_ENERGY_RUN_MIN) ||
2546 (state_reason == WAIT_QOS_GRP_NODE_MIN) ||
2547 (state_reason == WAIT_QOS_GRP_NODE_RUN_MIN) ||
2548 (state_reason >= WAIT_QOS_GRP_GRES &&
2549 state_reason <= WAIT_QOS_GRP_GRES_RUN_MIN) ||
2550 (state_reason >= WAIT_QOS_GRP_LIC &&
2551 state_reason <= WAIT_QOS_GRP_LIC_RUN_MIN) ||
2552 (state_reason >= WAIT_QOS_GRP_BB &&
2553 state_reason <= WAIT_QOS_GRP_BB_RUN_MIN) ||
2554 (state_reason >= WAIT_QOS_GRP_BILLING &&
2555 state_reason <= WAIT_QOS_GRP_BILLING_RUN_MIN))
2556 return true;
2557 return false;
2558 }
2559
slurm_free_get_kvs_msg(kvs_get_msg_t * msg)2560 extern void slurm_free_get_kvs_msg(kvs_get_msg_t *msg)
2561 {
2562 if (msg) {
2563 xfree(msg->hostname);
2564 xfree(msg);
2565 }
2566 }
2567
slurm_free_kvs_comm_set(kvs_comm_set_t * msg)2568 extern void slurm_free_kvs_comm_set(kvs_comm_set_t *msg)
2569 {
2570 int i, j;
2571
2572 if (msg) {
2573 if (msg->kvs_host_ptr) {
2574 for (i = 0; i < msg->host_cnt; i++)
2575 xfree(msg->kvs_host_ptr[i].hostname);
2576 xfree(msg->kvs_host_ptr);
2577 }
2578 if (msg->kvs_comm_ptr) {
2579 for (i = 0; i < msg->kvs_comm_recs; i++) {
2580 if (!msg->kvs_comm_ptr[i])
2581 continue;
2582
2583 xfree(msg->kvs_comm_ptr[i]->kvs_name);
2584 for (j = 0; j < msg->kvs_comm_ptr[i]->kvs_cnt;
2585 j++) {
2586 xfree(msg->kvs_comm_ptr[i]->
2587 kvs_keys[j]);
2588 xfree(msg->kvs_comm_ptr[i]->
2589 kvs_values[j]);
2590 }
2591 xfree(msg->kvs_comm_ptr[i]->kvs_keys);
2592 xfree(msg->kvs_comm_ptr[i]->kvs_values);
2593 }
2594 xfree(msg->kvs_comm_ptr);
2595 }
2596 xfree(msg);
2597 }
2598 }
2599
slurm_free_will_run_response_msg(will_run_response_msg_t * msg)2600 extern void slurm_free_will_run_response_msg(will_run_response_msg_t *msg)
2601 {
2602 if (msg) {
2603 xfree(msg->job_submit_user_msg);
2604 xfree(msg->node_list);
2605 xfree(msg->part_name);
2606 FREE_NULL_LIST(msg->preemptee_job_id);
2607 xfree(msg);
2608 }
2609 }
2610
slurm_free_forward_data_msg(forward_data_msg_t * msg)2611 inline void slurm_free_forward_data_msg(forward_data_msg_t *msg)
2612 {
2613 if (msg) {
2614 xfree(msg->address);
2615 xfree(msg->data);
2616 xfree(msg);
2617 }
2618 }
2619
slurm_free_ping_slurmd_resp(ping_slurmd_resp_msg_t * msg)2620 extern void slurm_free_ping_slurmd_resp(ping_slurmd_resp_msg_t *msg)
2621 {
2622 xfree(msg);
2623 }
2624
2625 /*
2626 * structured as a static lookup table, which allows this
2627 * to be thread safe while avoiding any heap allocation
2628 */
preempt_mode_string(uint16_t preempt_mode)2629 extern const char *preempt_mode_string(uint16_t preempt_mode)
2630 {
2631 if (preempt_mode == PREEMPT_MODE_OFF)
2632 return "OFF";
2633 if (preempt_mode == PREEMPT_MODE_GANG)
2634 return "GANG";
2635
2636 if (preempt_mode & PREEMPT_MODE_GANG) {
2637 preempt_mode &= (~PREEMPT_MODE_GANG);
2638 if (preempt_mode == PREEMPT_MODE_CANCEL)
2639 return "GANG,CANCEL";
2640 else if (preempt_mode == PREEMPT_MODE_REQUEUE)
2641 return "GANG,REQUEUE";
2642 else if (preempt_mode == PREEMPT_MODE_SUSPEND)
2643 return "GANG,SUSPEND";
2644 return "GANG,UNKNOWN";
2645 } else {
2646 if (preempt_mode == PREEMPT_MODE_CANCEL)
2647 return "CANCEL";
2648 else if (preempt_mode == PREEMPT_MODE_REQUEUE)
2649 return "REQUEUE";
2650 else if (preempt_mode == PREEMPT_MODE_SUSPEND)
2651 return "SUSPEND";
2652 }
2653
2654 return "UNKNOWN";
2655 }
2656
preempt_mode_num(const char * preempt_mode)2657 extern uint16_t preempt_mode_num(const char *preempt_mode)
2658 {
2659 uint16_t mode_num = 0;
2660 int preempt_modes = 0;
2661 char *tmp_str, *last = NULL, *tok;
2662
2663 if (preempt_mode == NULL)
2664 return mode_num;
2665
2666 tmp_str = xstrdup(preempt_mode);
2667 tok = strtok_r(tmp_str, ",", &last);
2668 while (tok) {
2669 if (xstrcasecmp(tok, "gang") == 0) {
2670 mode_num |= PREEMPT_MODE_GANG;
2671 } else if ((xstrcasecmp(tok, "off") == 0)
2672 || (xstrcasecmp(tok, "cluster") == 0)) {
2673 mode_num += PREEMPT_MODE_OFF;
2674 preempt_modes++;
2675 } else if (xstrcasecmp(tok, "cancel") == 0) {
2676 mode_num += PREEMPT_MODE_CANCEL;
2677 preempt_modes++;
2678 } else if (xstrcasecmp(tok, "requeue") == 0) {
2679 mode_num += PREEMPT_MODE_REQUEUE;
2680 preempt_modes++;
2681 } else if ((xstrcasecmp(tok, "on") == 0) ||
2682 (xstrcasecmp(tok, "suspend") == 0)) {
2683 mode_num += PREEMPT_MODE_SUSPEND;
2684 preempt_modes++;
2685 } else {
2686 preempt_modes = 0;
2687 mode_num = NO_VAL16;
2688 break;
2689 }
2690 tok = strtok_r(NULL, ",", &last);
2691 }
2692 xfree(tmp_str);
2693 if (preempt_modes > 1) {
2694 mode_num = NO_VAL16;
2695 }
2696
2697 return mode_num;
2698 }
2699
2700 /* Convert log level number to equivalent string */
log_num2string(uint16_t inx)2701 extern char *log_num2string(uint16_t inx)
2702 {
2703 switch (inx) {
2704 case 0:
2705 return "quiet";
2706 case 1:
2707 return "fatal";
2708 case 2:
2709 return "error";
2710 case 3:
2711 return "info";
2712 case 4:
2713 return "verbose";
2714 case 5:
2715 return "debug";
2716 case 6:
2717 return "debug2";
2718 case 7:
2719 return "debug3";
2720 case 8:
2721 return "debug4";
2722 case 9:
2723 return "debug5";
2724 default:
2725 return "unknown";
2726 }
2727 }
2728
2729 /* Convert log level string to equivalent number */
log_string2num(const char * name)2730 extern uint16_t log_string2num(const char *name)
2731 {
2732 if (name == NULL)
2733 return NO_VAL16;
2734
2735 if ((name[0] >= '0') && (name[0] <= '9'))
2736 return (uint16_t) atoi(name);
2737
2738 if (!xstrcasecmp(name, "quiet"))
2739 return (uint16_t) 0;
2740 if (!xstrcasecmp(name, "fatal"))
2741 return (uint16_t) 1;
2742 if (!xstrcasecmp(name, "error"))
2743 return (uint16_t) 2;
2744 if (!xstrcasecmp(name, "info"))
2745 return (uint16_t) 3;
2746 if (!xstrcasecmp(name, "verbose"))
2747 return (uint16_t) 4;
2748 if (!xstrcasecmp(name, "debug"))
2749 return (uint16_t) 5;
2750 if (!xstrcasecmp(name, "debug2"))
2751 return (uint16_t) 6;
2752 if (!xstrcasecmp(name, "debug3"))
2753 return (uint16_t) 7;
2754 if (!xstrcasecmp(name, "debug4"))
2755 return (uint16_t) 8;
2756 if (!xstrcasecmp(name, "debug5"))
2757 return (uint16_t) 9;
2758
2759 return NO_VAL16;
2760 }
2761
job_share_string(uint16_t shared)2762 extern char *job_share_string(uint16_t shared)
2763 {
2764 if (shared == JOB_SHARED_NONE)
2765 return "NO";
2766 else if (shared == JOB_SHARED_OK)
2767 return "YES";
2768 else if (shared == JOB_SHARED_USER)
2769 return "USER";
2770 else if (shared == JOB_SHARED_MCS)
2771 return "MCS";
2772 else
2773 return "OK";
2774 }
2775
job_state_string(uint32_t inx)2776 extern char *job_state_string(uint32_t inx)
2777 {
2778 /* Process JOB_STATE_FLAGS */
2779 if (inx & JOB_COMPLETING)
2780 return "COMPLETING";
2781 if (inx & JOB_STAGE_OUT)
2782 return "STAGE_OUT";
2783 if (inx & JOB_CONFIGURING)
2784 return "CONFIGURING";
2785 if (inx & JOB_RESIZING)
2786 return "RESIZING";
2787 if (inx & JOB_REQUEUE)
2788 return "REQUEUED";
2789 if (inx & JOB_REQUEUE_FED)
2790 return "REQUEUE_FED";
2791 if (inx & JOB_REQUEUE_HOLD)
2792 return "REQUEUE_HOLD";
2793 if (inx & JOB_SPECIAL_EXIT)
2794 return "SPECIAL_EXIT";
2795 if (inx & JOB_STOPPED)
2796 return "STOPPED";
2797 if (inx & JOB_REVOKED)
2798 return "REVOKED";
2799 if (inx & JOB_RESV_DEL_HOLD)
2800 return "RESV_DEL_HOLD";
2801 if (inx & JOB_SIGNALING)
2802 return "SIGNALING";
2803
2804 /* Process JOB_STATE_BASE */
2805 switch (inx & JOB_STATE_BASE) {
2806 case JOB_PENDING:
2807 return "PENDING";
2808 case JOB_RUNNING:
2809 return "RUNNING";
2810 case JOB_SUSPENDED:
2811 return "SUSPENDED";
2812 case JOB_COMPLETE:
2813 return "COMPLETED";
2814 case JOB_CANCELLED:
2815 return "CANCELLED";
2816 case JOB_FAILED:
2817 return "FAILED";
2818 case JOB_TIMEOUT:
2819 return "TIMEOUT";
2820 case JOB_NODE_FAIL:
2821 return "NODE_FAIL";
2822 case JOB_PREEMPTED:
2823 return "PREEMPTED";
2824 case JOB_BOOT_FAIL:
2825 return "BOOT_FAIL";
2826 case JOB_DEADLINE:
2827 return "DEADLINE";
2828 case JOB_OOM:
2829 return "OUT_OF_MEMORY";
2830 default:
2831 return "?";
2832 }
2833 }
2834
job_state_string_compact(uint32_t inx)2835 extern char *job_state_string_compact(uint32_t inx)
2836 {
2837 /* Process JOB_STATE_FLAGS */
2838 if (inx & JOB_COMPLETING)
2839 return "CG";
2840 if (inx & JOB_STAGE_OUT)
2841 return "SO";
2842 if (inx & JOB_CONFIGURING)
2843 return "CF";
2844 if (inx & JOB_RESIZING)
2845 return "RS";
2846 if (inx & JOB_REQUEUE)
2847 return "RQ";
2848 if (inx & JOB_REQUEUE_FED)
2849 return "RF";
2850 if (inx & JOB_REQUEUE_HOLD)
2851 return "RH";
2852 if (inx & JOB_SPECIAL_EXIT)
2853 return "SE";
2854 if (inx & JOB_STOPPED)
2855 return "ST";
2856 if (inx & JOB_REVOKED)
2857 return "RV";
2858 if (inx & JOB_RESV_DEL_HOLD)
2859 return "RD";
2860 if (inx & JOB_SIGNALING)
2861 return "SI";
2862
2863 /* Process JOB_STATE_BASE */
2864 switch (inx & JOB_STATE_BASE) {
2865 case JOB_PENDING:
2866 return "PD";
2867 case JOB_RUNNING:
2868 return "R";
2869 case JOB_SUSPENDED:
2870 return "S";
2871 case JOB_COMPLETE:
2872 return "CD";
2873 case JOB_CANCELLED:
2874 return "CA";
2875 case JOB_FAILED:
2876 return "F";
2877 case JOB_TIMEOUT:
2878 return "TO";
2879 case JOB_NODE_FAIL:
2880 return "NF";
2881 case JOB_PREEMPTED:
2882 return "PR";
2883 case JOB_BOOT_FAIL:
2884 return "BF";
2885 case JOB_DEADLINE:
2886 return "DL";
2887 case JOB_OOM:
2888 return "OOM";
2889 default:
2890 return "?";
2891 }
2892 }
2893
2894 /*
2895 * job_state_string_complete - build a string describing the job state
2896 *
2897 * IN: state - job state
2898 * RET string representation of the job state;
2899 * NOTE: the caller must call xfree() on the RET value to free memory
2900 */
job_state_string_complete(uint32_t state)2901 extern char *job_state_string_complete(uint32_t state)
2902 {
2903 /* Malloc space ahead of time to avoid realloc inside of xstrcat. */
2904 char *state_str = xmalloc(100);
2905
2906 /* Process JOB_STATE_BASE */
2907 switch (state & JOB_STATE_BASE) {
2908 case JOB_PENDING:
2909 xstrcat(state_str, "PENDING");
2910 break;
2911 case JOB_RUNNING:
2912 xstrcat(state_str, "RUNNING");
2913 break;
2914 case JOB_SUSPENDED:
2915 xstrcat(state_str, "SUSPENDED");
2916 break;
2917 case JOB_COMPLETE:
2918 xstrcat(state_str, "COMPLETED");
2919 break;
2920 case JOB_CANCELLED:
2921 xstrcat(state_str, "CANCELLED");
2922 break;
2923 case JOB_FAILED:
2924 xstrcat(state_str, "FAILED");
2925 break;
2926 case JOB_TIMEOUT:
2927 xstrcat(state_str, "TIMEOUT");
2928 break;
2929 case JOB_NODE_FAIL:
2930 xstrcat(state_str, "NODE_FAIL");
2931 break;
2932 case JOB_PREEMPTED:
2933 xstrcat(state_str, "PREEMPTED");
2934 break;
2935 case JOB_BOOT_FAIL:
2936 xstrcat(state_str, "BOOT_FAIL");
2937 break;
2938 case JOB_DEADLINE:
2939 xstrcat(state_str, "DEADLINE");
2940 break;
2941 case JOB_OOM:
2942 xstrcat(state_str, "OUT_OF_MEMORY");
2943 break;
2944 default:
2945 xstrcat(state_str, "?");
2946 break;
2947 }
2948
2949 /* Process JOB_STATE_FLAGS */
2950 if (state & JOB_LAUNCH_FAILED)
2951 xstrcat(state_str, ",LAUNCH_FAILED");
2952 if (state & JOB_UPDATE_DB)
2953 xstrcat(state_str, ",UPDATE_DB");
2954 if (state & JOB_COMPLETING)
2955 xstrcat(state_str, ",COMPLETING");
2956 if (state & JOB_CONFIGURING)
2957 xstrcat(state_str, ",CONFIGURING");
2958 if (state & JOB_POWER_UP_NODE)
2959 xstrcat(state_str, ",POWER_UP_NODE");
2960 if (state & JOB_RECONFIG_FAIL)
2961 xstrcat(state_str, ",RECONFIG_FAIL");
2962 if (state & JOB_RESIZING)
2963 xstrcat(state_str, ",RESIZING");
2964 if (state & JOB_REQUEUE)
2965 xstrcat(state_str, ",REQUEUED");
2966 if (state & JOB_REQUEUE_FED)
2967 xstrcat(state_str, ",REQUEUE_FED");
2968 if (state & JOB_REQUEUE_HOLD)
2969 xstrcat(state_str, ",REQUEUE_HOLD");
2970 if (state & JOB_SPECIAL_EXIT)
2971 xstrcat(state_str, ",SPECIAL_EXIT");
2972 if (state & JOB_STOPPED)
2973 xstrcat(state_str, ",STOPPED");
2974 if (state & JOB_REVOKED)
2975 xstrcat(state_str, ",REVOKED");
2976 if (state & JOB_RESV_DEL_HOLD)
2977 xstrcat(state_str, ",RESV_DEL_HOLD");
2978 if (state & JOB_SIGNALING)
2979 xstrcat(state_str, ",SIGNALING");
2980 if (state & JOB_STAGE_OUT)
2981 xstrcat(state_str, ",STAGE_OUT");
2982
2983 return state_str;
2984 }
2985
_job_name_test(uint32_t state_num,const char * state_name)2986 static bool _job_name_test(uint32_t state_num, const char *state_name)
2987 {
2988 if (!xstrcasecmp(state_name, job_state_string(state_num)) ||
2989 !xstrcasecmp(state_name, job_state_string_compact(state_num))) {
2990 return true;
2991 }
2992 return false;
2993 }
2994
job_state_num(const char * state_name)2995 extern uint32_t job_state_num(const char *state_name)
2996 {
2997 uint32_t i;
2998
2999 for (i = 0; i < JOB_END; i++) {
3000 if (_job_name_test(i, state_name))
3001 return i;
3002 }
3003
3004 if (_job_name_test(JOB_STAGE_OUT, state_name))
3005 return JOB_STAGE_OUT;
3006 if (_job_name_test(JOB_COMPLETING, state_name))
3007 return JOB_COMPLETING;
3008 if (_job_name_test(JOB_CONFIGURING, state_name))
3009 return JOB_CONFIGURING;
3010 if (_job_name_test(JOB_RESIZING, state_name))
3011 return JOB_RESIZING;
3012 if (_job_name_test(JOB_REQUEUE, state_name))
3013 return JOB_REQUEUE;
3014 if (_job_name_test(JOB_REQUEUE_FED, state_name))
3015 return JOB_REQUEUE_FED;
3016 if (_job_name_test(JOB_REQUEUE_HOLD, state_name))
3017 return JOB_REQUEUE_HOLD;
3018 if (_job_name_test(JOB_SPECIAL_EXIT, state_name))
3019 return JOB_SPECIAL_EXIT;
3020 if (_job_name_test(JOB_STOPPED, state_name))
3021 return JOB_STOPPED;
3022 if (_job_name_test(JOB_REVOKED, state_name))
3023 return JOB_REVOKED;
3024 if (_job_name_test(JOB_SIGNALING, state_name))
3025 return JOB_SIGNALING;
3026
3027 return NO_VAL;
3028 }
3029
trigger_res_type(uint16_t res_type)3030 extern char *trigger_res_type(uint16_t res_type)
3031 {
3032 if (res_type == TRIGGER_RES_TYPE_JOB)
3033 return "job";
3034 else if (res_type == TRIGGER_RES_TYPE_NODE)
3035 return "node";
3036 else if (res_type == TRIGGER_RES_TYPE_SLURMCTLD)
3037 return "slurmctld";
3038 else if (res_type == TRIGGER_RES_TYPE_SLURMDBD)
3039 return "slurmdbd";
3040 else if (res_type == TRIGGER_RES_TYPE_DATABASE)
3041 return "database";
3042 else if (res_type == TRIGGER_RES_TYPE_FRONT_END)
3043 return "front_end";
3044 else if (res_type == TRIGGER_RES_TYPE_OTHER)
3045 return "other";
3046 else
3047 return "unknown";
3048 }
3049
3050 /* Convert HealthCheckNodeState numeric value to a string.
3051 * Caller must xfree() the return value */
health_check_node_state_str(uint32_t node_state)3052 extern char *health_check_node_state_str(uint32_t node_state)
3053 {
3054 char *state_str = NULL;
3055
3056 if (node_state & HEALTH_CHECK_CYCLE)
3057 state_str = xstrdup("CYCLE");
3058 else
3059 state_str = xstrdup("");
3060
3061 if ((node_state & HEALTH_CHECK_NODE_ANY) == HEALTH_CHECK_NODE_ANY) {
3062 if (state_str[0])
3063 xstrcat(state_str, ",");
3064 xstrcat(state_str, "ANY");
3065 return state_str;
3066 }
3067
3068 if (node_state & HEALTH_CHECK_NODE_IDLE)
3069 if (state_str[0])
3070 xstrcat(state_str, ",");
3071 xstrcat(state_str, "IDLE");
3072 if (node_state & HEALTH_CHECK_NODE_ALLOC) {
3073 if (state_str[0])
3074 xstrcat(state_str, ",");
3075 xstrcat(state_str, "ALLOC");
3076 }
3077 if (node_state & HEALTH_CHECK_NODE_MIXED) {
3078 if (state_str[0])
3079 xstrcat(state_str, ",");
3080 xstrcat(state_str, "MIXED");
3081 }
3082
3083 return state_str;
3084 }
3085
trigger_type(uint32_t trig_type)3086 extern char *trigger_type(uint32_t trig_type)
3087 {
3088 if (trig_type == TRIGGER_TYPE_UP)
3089 return "up";
3090 else if (trig_type == TRIGGER_TYPE_DOWN)
3091 return "down";
3092 else if (trig_type == TRIGGER_TYPE_DRAINED)
3093 return "drained";
3094 else if (trig_type == TRIGGER_TYPE_FAIL)
3095 return "fail";
3096 else if (trig_type == TRIGGER_TYPE_IDLE)
3097 return "idle";
3098 else if (trig_type == TRIGGER_TYPE_TIME)
3099 return "time";
3100 else if (trig_type == TRIGGER_TYPE_FINI)
3101 return "fini";
3102 else if (trig_type == TRIGGER_TYPE_RECONFIG)
3103 return "reconfig";
3104 else if (trig_type == TRIGGER_TYPE_PRI_CTLD_FAIL)
3105 return "primary_slurmctld_failure";
3106 else if (trig_type == TRIGGER_TYPE_PRI_CTLD_RES_OP)
3107 return "primary_slurmctld_resumed_operation";
3108 else if (trig_type == TRIGGER_TYPE_PRI_CTLD_RES_CTRL)
3109 return "primary_slurmctld_resumed_control";
3110 else if (trig_type == TRIGGER_TYPE_PRI_CTLD_ACCT_FULL)
3111 return "primary_slurmctld_acct_buffer_full";
3112 else if (trig_type == TRIGGER_TYPE_BU_CTLD_FAIL)
3113 return "backup_slurmctld_failure";
3114 else if (trig_type == TRIGGER_TYPE_BU_CTLD_RES_OP)
3115 return "backup_slurmctld_resumed_operation";
3116 else if (trig_type == TRIGGER_TYPE_BU_CTLD_AS_CTRL)
3117 return "backup_slurmctld_assumed_control";
3118 else if (trig_type == TRIGGER_TYPE_PRI_DBD_FAIL)
3119 return "primary_slurmdbd_failure";
3120 else if (trig_type == TRIGGER_TYPE_PRI_DBD_RES_OP)
3121 return "primary_slurmdbd_resumed_operation";
3122 else if (trig_type == TRIGGER_TYPE_PRI_DB_FAIL)
3123 return "primary_database_failure";
3124 else if (trig_type == TRIGGER_TYPE_PRI_DB_RES_OP)
3125 return "primary_database_resumed_operation";
3126 else if (trig_type == TRIGGER_TYPE_BURST_BUFFER)
3127 return "burst_buffer";
3128 else
3129 return "unknown";
3130 }
3131
3132 /* user needs to xfree return value */
reservation_flags_string(reserve_info_t * resv_ptr)3133 extern char *reservation_flags_string(reserve_info_t * resv_ptr)
3134 {
3135 char *flag_str = xstrdup("");
3136 uint64_t flags = resv_ptr->flags;
3137
3138 if (flags & RESERVE_FLAG_MAINT)
3139 xstrcat(flag_str, "MAINT");
3140 if (flags & RESERVE_FLAG_NO_MAINT) {
3141 if (flag_str[0])
3142 xstrcat(flag_str, ",");
3143 xstrcat(flag_str, "NO_MAINT");
3144 }
3145 if (flags & RESERVE_FLAG_FLEX) {
3146 if (flag_str[0])
3147 xstrcat(flag_str, ",");
3148 xstrcat(flag_str, "FLEX");
3149 }
3150 if (flags & RESERVE_FLAG_OVERLAP) {
3151 if (flag_str[0])
3152 xstrcat(flag_str, ",");
3153 xstrcat(flag_str, "OVERLAP");
3154 }
3155 if (flags & RESERVE_FLAG_IGN_JOBS) {
3156 if (flag_str[0])
3157 xstrcat(flag_str, ",");
3158 xstrcat(flag_str, "IGNORE_JOBS");
3159 }
3160 if (flags & RESERVE_FLAG_DAILY) {
3161 if (flag_str[0])
3162 xstrcat(flag_str, ",");
3163 xstrcat(flag_str, "DAILY");
3164 }
3165 if (flags & RESERVE_FLAG_NO_DAILY) {
3166 if (flag_str[0])
3167 xstrcat(flag_str, ",");
3168 xstrcat(flag_str, "NO_DAILY");
3169 }
3170 if (flags & RESERVE_FLAG_WEEKDAY) {
3171 if (flag_str[0])
3172 xstrcat(flag_str, ",");
3173 xstrcat(flag_str, "WEEKDAY");
3174 }
3175 if (flags & RESERVE_FLAG_WEEKEND) {
3176 if (flag_str[0])
3177 xstrcat(flag_str, ",");
3178 xstrcat(flag_str, "WEEKEND");
3179 }
3180 if (flags & RESERVE_FLAG_WEEKLY) {
3181 if (flag_str[0])
3182 xstrcat(flag_str, ",");
3183 xstrcat(flag_str, "WEEKLY");
3184 }
3185 if (flags & RESERVE_FLAG_NO_WEEKLY) {
3186 if (flag_str[0])
3187 xstrcat(flag_str, ",");
3188 xstrcat(flag_str, "NO_WEEKLY");
3189 }
3190 if (flags & RESERVE_FLAG_SPEC_NODES) {
3191 if (flag_str[0])
3192 xstrcat(flag_str, ",");
3193 xstrcat(flag_str, "SPEC_NODES");
3194 }
3195 if (flags & RESERVE_FLAG_ALL_NODES) {
3196 if (flag_str[0])
3197 xstrcat(flag_str, ",");
3198 xstrcat(flag_str, "ALL_NODES");
3199 }
3200 if (flags & RESERVE_FLAG_ANY_NODES) {
3201 if (flag_str[0])
3202 xstrcat(flag_str, ",");
3203 xstrcat(flag_str, "ANY_NODES");
3204 }
3205 if (flags & RESERVE_FLAG_NO_ANY_NODES) {
3206 if (flag_str[0])
3207 xstrcat(flag_str, ",");
3208 xstrcat(flag_str, "NO_ANY_NODES");
3209 }
3210 if (flags & RESERVE_FLAG_STATIC) {
3211 if (flag_str[0])
3212 xstrcat(flag_str, ",");
3213 xstrcat(flag_str, "STATIC");
3214 }
3215 if (flags & RESERVE_FLAG_NO_STATIC) {
3216 if (flag_str[0])
3217 xstrcat(flag_str, ",");
3218 xstrcat(flag_str, "NO_STATIC");
3219 }
3220 if (flags & RESERVE_FLAG_PART_NODES) {
3221 if (flag_str[0])
3222 xstrcat(flag_str, ",");
3223 xstrcat(flag_str, "PART_NODES");
3224 }
3225 if (flags & RESERVE_FLAG_NO_PART_NODES) {
3226 if (flag_str[0])
3227 xstrcat(flag_str, ",");
3228 xstrcat(flag_str, "NO_PART_NODES");
3229 }
3230 if (flags & RESERVE_FLAG_FIRST_CORES) {
3231 if (flag_str[0])
3232 xstrcat(flag_str, ",");
3233 xstrcat(flag_str, "FIRST_CORES");
3234 }
3235 if (flags & RESERVE_FLAG_TIME_FLOAT) {
3236 if (flag_str[0])
3237 xstrcat(flag_str, ",");
3238 xstrcat(flag_str, "TIME_FLOAT");
3239 }
3240 if (flags & RESERVE_FLAG_REPLACE) {
3241 if (flag_str[0])
3242 xstrcat(flag_str, ",");
3243 xstrcat(flag_str, "REPLACE");
3244 }
3245 if (flags & RESERVE_FLAG_REPLACE_DOWN) {
3246 if (flag_str[0])
3247 xstrcat(flag_str, ",");
3248 xstrcat(flag_str, "REPLACE_DOWN");
3249 }
3250 if (flags & RESERVE_FLAG_PURGE_COMP) {
3251 if (flag_str[0])
3252 xstrcat(flag_str, ",");
3253 if (resv_ptr->purge_comp_time) {
3254 char tmp_pct[40];
3255 secs2time_str(resv_ptr->purge_comp_time,
3256 tmp_pct, sizeof(tmp_pct));
3257 xstrfmtcat(flag_str, "PURGE_COMP=%s", tmp_pct);
3258 } else
3259 xstrcat(flag_str, "PURGE_COMP");
3260 }
3261 if (flags & RESERVE_FLAG_NO_HOLD_JOBS) {
3262 if (flag_str[0])
3263 xstrcat(flag_str, ",");
3264 xstrcat(flag_str, "NO_HOLD_JOBS_AFTER_END");
3265 }
3266 if (flags & RESERVE_FLAG_PROM) {
3267 if (flag_str[0])
3268 xstrcat(flag_str, ",");
3269 xstrcat(flag_str, "MAGNETIC");
3270 }
3271 if (flags & RESERVE_FLAG_NO_PROM) {
3272 if (flag_str[0])
3273 xstrcat(flag_str, ",");
3274 xstrcat(flag_str, "NO_MAGNETIC");
3275 }
3276
3277
3278 return flag_str;
3279 }
3280
3281 /* user needs to xfree return value */
priority_flags_string(uint16_t priority_flags)3282 extern char *priority_flags_string(uint16_t priority_flags)
3283 {
3284 char *flag_str = xstrdup("");
3285
3286 if (priority_flags & PRIORITY_FLAGS_ACCRUE_ALWAYS)
3287 xstrcat(flag_str, "ACCRUE_ALWAYS");
3288 if (priority_flags & PRIORITY_FLAGS_SIZE_RELATIVE) {
3289 if (flag_str[0])
3290 xstrcat(flag_str, ",");
3291 xstrcat(flag_str, "SMALL_RELATIVE_TO_TIME");
3292 }
3293 if (priority_flags & PRIORITY_FLAGS_CALCULATE_RUNNING) {
3294 if (flag_str[0])
3295 xstrcat(flag_str, ",");
3296 xstrcat(flag_str, "CALCULATE_RUNNING");
3297 }
3298 if (priority_flags & PRIORITY_FLAGS_DEPTH_OBLIVIOUS) {
3299 if (flag_str[0])
3300 xstrcat(flag_str, ",");
3301 xstrcat(flag_str, "DEPTH_OBLIVIOUS");
3302 }
3303 if (!(priority_flags & PRIORITY_FLAGS_FAIR_TREE)) {
3304 if (flag_str[0])
3305 xstrcat(flag_str, ",");
3306 xstrcat(flag_str, "NO_FAIR_TREE");
3307 }
3308 if (priority_flags & PRIORITY_FLAGS_INCR_ONLY) {
3309 if (flag_str[0])
3310 xstrcat(flag_str, ",");
3311 xstrcat(flag_str, "INCR_ONLY");
3312 }
3313 if (priority_flags & PRIORITY_FLAGS_MAX_TRES) {
3314 if (flag_str[0])
3315 xstrcat(flag_str, ",");
3316 xstrcat(flag_str, "MAX_TRES");
3317 }
3318 if (priority_flags & (PRIORITY_FLAGS_NO_NORMAL_ASSOC |
3319 PRIORITY_FLAGS_NO_NORMAL_PART |
3320 PRIORITY_FLAGS_NO_NORMAL_QOS |
3321 PRIORITY_FLAGS_NO_NORMAL_TRES)) {
3322 if (flag_str[0])
3323 xstrcat(flag_str, ",");
3324 xstrcat(flag_str, "NO_NORMAL_ALL");
3325 } else {
3326 if (priority_flags & PRIORITY_FLAGS_NO_NORMAL_ASSOC) {
3327 if (flag_str[0])
3328 xstrcat(flag_str, ",");
3329 xstrcat(flag_str, "NO_NORMAL_ASSOC");
3330 }
3331 if (priority_flags & PRIORITY_FLAGS_NO_NORMAL_PART) {
3332 if (flag_str[0])
3333 xstrcat(flag_str, ",");
3334 xstrcat(flag_str, "NO_NORMAL_PART");
3335 }
3336 if (priority_flags & PRIORITY_FLAGS_NO_NORMAL_QOS) {
3337 if (flag_str[0])
3338 xstrcat(flag_str, ",");
3339 xstrcat(flag_str, "NO_NORMAL_QOS");
3340 }
3341 if (priority_flags & PRIORITY_FLAGS_NO_NORMAL_TRES) {
3342 if (flag_str[0])
3343 xstrcat(flag_str, ",");
3344 xstrcat(flag_str, "NO_NORMAL_TRES");
3345 }
3346 }
3347
3348 return flag_str;
3349 }
3350
3351 /* Translate a burst buffer numeric value to its equivalant state string */
bb_state_string(uint16_t state)3352 extern char *bb_state_string(uint16_t state)
3353 {
3354 static char buf[16];
3355
3356 if (state == BB_STATE_PENDING)
3357 return "pending";
3358 if (state == BB_STATE_ALLOCATING)
3359 return "allocating";
3360 if (state == BB_STATE_ALLOCATED)
3361 return "allocated";
3362 if (state == BB_STATE_STAGING_IN)
3363 return "staging-in";
3364 if (state == BB_STATE_STAGED_IN)
3365 return "staged-in";
3366 if (state == BB_STATE_RUNNING)
3367 return "running";
3368 if (state == BB_STATE_SUSPEND)
3369 return "suspended";
3370 if (state == BB_STATE_STAGING_OUT)
3371 return "staging-out";
3372 if (state == BB_STATE_STAGED_OUT)
3373 return "staged-out";
3374 if (state == BB_STATE_TEARDOWN)
3375 return "teardown";
3376 if (state == BB_STATE_TEARDOWN_FAIL)
3377 return "teardown-fail";
3378 if (state == BB_STATE_COMPLETE)
3379 return "complete";
3380 snprintf(buf, sizeof(buf), "%u", state);
3381 return buf;
3382 }
3383
3384 /* Translate a burst buffer state string to its equivalant numeric value */
bb_state_num(char * tok)3385 extern uint16_t bb_state_num(char *tok)
3386 {
3387 if (!xstrcasecmp(tok, "pending"))
3388 return BB_STATE_PENDING;
3389 if (!xstrcasecmp(tok, "allocating"))
3390 return BB_STATE_ALLOCATING;
3391 if (!xstrcasecmp(tok, "allocated"))
3392 return BB_STATE_ALLOCATED;
3393 if (!xstrcasecmp(tok, "staging-in"))
3394 return BB_STATE_STAGING_IN;
3395 if (!xstrcasecmp(tok, "staged-in"))
3396 return BB_STATE_STAGED_IN;
3397 if (!xstrcasecmp(tok, "running"))
3398 return BB_STATE_RUNNING;
3399 if (!xstrcasecmp(tok, "suspend"))
3400 return BB_STATE_SUSPEND;
3401 if (!xstrcasecmp(tok, "staging-out"))
3402 return BB_STATE_STAGING_OUT;
3403 if (!xstrcasecmp(tok, "staged-out"))
3404 return BB_STATE_STAGED_OUT;
3405 if (!xstrcasecmp(tok, "teardown"))
3406 return BB_STATE_TEARDOWN;
3407 if (!xstrcasecmp(tok, "teardown-fail"))
3408 return BB_STATE_TEARDOWN_FAIL;
3409 if (!xstrcasecmp(tok, "complete"))
3410 return BB_STATE_COMPLETE;
3411 return 0;
3412 }
3413
node_state_string(uint32_t inx)3414 extern char *node_state_string(uint32_t inx)
3415 {
3416 int base = (inx & NODE_STATE_BASE);
3417 bool comp_flag = (inx & NODE_STATE_COMPLETING);
3418 bool drain_flag = (inx & NODE_STATE_DRAIN);
3419 bool fail_flag = (inx & NODE_STATE_FAIL);
3420 bool maint_flag = (inx & NODE_STATE_MAINT);
3421 bool net_flag = (inx & NODE_STATE_NET);
3422 bool reboot_flag = (inx & NODE_STATE_REBOOT);
3423 bool res_flag = (inx & NODE_STATE_RES);
3424 bool resume_flag = (inx & NODE_RESUME);
3425 bool no_resp_flag = (inx & NODE_STATE_NO_RESPOND);
3426 bool powered_down_flag = (inx & NODE_STATE_POWER_SAVE);
3427 bool power_up_flag = (inx & NODE_STATE_POWER_UP);
3428 bool powering_down_flag = (inx & NODE_STATE_POWERING_DOWN);
3429
3430 if (maint_flag) {
3431 if (drain_flag ||
3432 (base == NODE_STATE_ALLOCATED) ||
3433 (base == NODE_STATE_DOWN) ||
3434 (base == NODE_STATE_MIXED))
3435 ;
3436 else if (no_resp_flag)
3437 return "MAINT*";
3438 else
3439 return "MAINT";
3440 }
3441 if (reboot_flag) {
3442 if ((base == NODE_STATE_ALLOCATED) ||
3443 (base == NODE_STATE_MIXED))
3444 ;
3445 else if (no_resp_flag)
3446 return "REBOOT*";
3447 else
3448 return "REBOOT";
3449 }
3450 if (drain_flag) {
3451 if (comp_flag
3452 || (base == NODE_STATE_ALLOCATED)
3453 || (base == NODE_STATE_MIXED)) {
3454 if (maint_flag)
3455 return "DRAINING$";
3456 if (reboot_flag)
3457 return "DRAINING@";
3458 if (power_up_flag)
3459 return "DRAINING#";
3460 if (powering_down_flag)
3461 return "DRAINING%";
3462 if (powered_down_flag)
3463 return "DRAINING~";
3464 if (no_resp_flag)
3465 return "DRAINING*";
3466 return "DRAINING";
3467 } else {
3468 if (maint_flag)
3469 return "DRAINED$";
3470 if (reboot_flag)
3471 return "DRAINED@";
3472 if (power_up_flag)
3473 return "DRAINED#";
3474 if (powering_down_flag)
3475 return "DRAINED%";
3476 if (powered_down_flag)
3477 return "DRAINED~";
3478 if (no_resp_flag)
3479 return "DRAINED*";
3480 return "DRAINED";
3481 }
3482 }
3483 if (fail_flag) {
3484 if (comp_flag || (base == NODE_STATE_ALLOCATED)) {
3485 if (no_resp_flag)
3486 return "FAILING*";
3487 return "FAILING";
3488 } else {
3489 if (no_resp_flag)
3490 return "FAIL*";
3491 return "FAIL";
3492 }
3493 }
3494
3495 if (inx == NODE_STATE_CANCEL_REBOOT)
3496 return "CANCEL_REBOOT";
3497 if (inx == NODE_STATE_POWERING_DOWN)
3498 return "POWERING_DOWN";
3499 if (inx == NODE_STATE_POWER_SAVE)
3500 return "POWER_DOWN";
3501 if (inx == NODE_STATE_POWER_UP)
3502 return "POWER_UP";
3503 if (base == NODE_STATE_DOWN) {
3504 if (maint_flag)
3505 return "DOWN$";
3506 if (reboot_flag)
3507 return "DOWN@";
3508 if (power_up_flag)
3509 return "DOWN#";
3510 if (powering_down_flag)
3511 return "DOWN%";
3512 if (powered_down_flag)
3513 return "DOWN~";
3514 if (no_resp_flag)
3515 return "DOWN*";
3516 return "DOWN";
3517 }
3518
3519 if (base == NODE_STATE_ALLOCATED) {
3520 if (maint_flag)
3521 return "ALLOCATED$";
3522 if (reboot_flag)
3523 return "ALLOCATED@";
3524 if (power_up_flag)
3525 return "ALLOCATED#";
3526 if (powering_down_flag)
3527 return "ALLOCATED%";
3528 if (powered_down_flag)
3529 return "ALLOCATED~";
3530 if (no_resp_flag)
3531 return "ALLOCATED*";
3532 if (comp_flag)
3533 return "ALLOCATED+";
3534 return "ALLOCATED";
3535 }
3536 if (comp_flag) {
3537 if (maint_flag)
3538 return "COMPLETING$";
3539 if (reboot_flag)
3540 return "COMPLETING@";
3541 if (power_up_flag)
3542 return "COMPLETING#";
3543 if (powering_down_flag)
3544 return "COMPLETING%";
3545 if (powered_down_flag)
3546 return "COMPLETING~";
3547 if (no_resp_flag)
3548 return "COMPLETING*";
3549 return "COMPLETING";
3550 }
3551 if (base == NODE_STATE_IDLE) {
3552 if (maint_flag)
3553 return "IDLE$";
3554 if (reboot_flag)
3555 return "IDLE@";
3556 if (power_up_flag)
3557 return "IDLE#";
3558 if (powering_down_flag)
3559 return "IDLE%";
3560 if (powered_down_flag)
3561 return "IDLE~";
3562 if (no_resp_flag)
3563 return "IDLE*";
3564 if (net_flag)
3565 return "PERFCTRS";
3566 if (res_flag)
3567 return "RESERVED";
3568 return "IDLE";
3569 }
3570 if (base == NODE_STATE_MIXED) {
3571 if (maint_flag)
3572 return "MIXED$";
3573 if (reboot_flag)
3574 return "MIXED@";
3575 if (power_up_flag)
3576 return "MIXED#";
3577 if (powering_down_flag)
3578 return "MIXED%";
3579 if (powered_down_flag)
3580 return "MIXED~";
3581 if (no_resp_flag)
3582 return "MIXED*";
3583 return "MIXED";
3584 }
3585 if (base == NODE_STATE_FUTURE) {
3586 if (maint_flag)
3587 return "FUTURE$";
3588 if (reboot_flag)
3589 return "FUTURE@";
3590 if (power_up_flag)
3591 return "FUTURE#";
3592 if (powering_down_flag)
3593 return "FUTURE%";
3594 if (powered_down_flag)
3595 return "FUTURE~";
3596 if (no_resp_flag)
3597 return "FUTURE*";
3598 return "FUTURE";
3599 }
3600 if (resume_flag)
3601 return "RESUME";
3602 if (base == NODE_STATE_UNKNOWN) {
3603 if (no_resp_flag)
3604 return "UNKNOWN*";
3605 return "UNKNOWN";
3606 }
3607 return "?";
3608 }
3609
node_state_string_compact(uint32_t inx)3610 extern char *node_state_string_compact(uint32_t inx)
3611 {
3612 bool comp_flag = (inx & NODE_STATE_COMPLETING);
3613 bool drain_flag = (inx & NODE_STATE_DRAIN);
3614 bool fail_flag = (inx & NODE_STATE_FAIL);
3615 bool maint_flag = (inx & NODE_STATE_MAINT);
3616 bool net_flag = (inx & NODE_STATE_NET);
3617 bool reboot_flag = (inx & NODE_STATE_REBOOT);
3618 bool res_flag = (inx & NODE_STATE_RES);
3619 bool resume_flag = (inx & NODE_RESUME);
3620 bool no_resp_flag = (inx & NODE_STATE_NO_RESPOND);
3621 bool powered_down_flag = (inx & NODE_STATE_POWER_SAVE);
3622 bool power_up_flag = (inx & NODE_STATE_POWER_UP);
3623 bool powering_down_flag = (inx & NODE_STATE_POWERING_DOWN);
3624
3625 inx = (inx & NODE_STATE_BASE);
3626
3627 if (maint_flag) {
3628 if (drain_flag ||
3629 (inx == NODE_STATE_ALLOCATED) ||
3630 (inx == NODE_STATE_DOWN) ||
3631 (inx == NODE_STATE_MIXED))
3632 ;
3633 else if (no_resp_flag)
3634 return "MAINT*";
3635 else
3636 return "MAINT";
3637 }
3638 if (reboot_flag) {
3639 if ((inx == NODE_STATE_ALLOCATED) || (inx == NODE_STATE_MIXED))
3640 ;
3641 else if (no_resp_flag)
3642 return "BOOT*";
3643 else
3644 return "BOOT";
3645 }
3646 if (drain_flag) {
3647 if (comp_flag
3648 || (inx == NODE_STATE_ALLOCATED)
3649 || (inx == NODE_STATE_MIXED)) {
3650 if (maint_flag)
3651 return "DRNG$";
3652 if (reboot_flag)
3653 return "DRNG@";
3654 if (power_up_flag)
3655 return "DRNG#";
3656 if (powering_down_flag)
3657 return "DRNG%";
3658 if (powered_down_flag)
3659 return "DRNG~";
3660 if (no_resp_flag)
3661 return "DRNG*";
3662 return "DRNG";
3663 } else {
3664 if (maint_flag)
3665 return "DRAIN$";
3666 if (reboot_flag)
3667 return "DRAIN@";
3668 if (power_up_flag)
3669 return "DRAIN#";
3670 if (powering_down_flag)
3671 return "DRAIN%";
3672 if (powered_down_flag)
3673 return "DRAIN~";
3674 if (no_resp_flag)
3675 return "DRAIN*";
3676 return "DRAIN";
3677 }
3678 }
3679 if (fail_flag) {
3680 if (comp_flag || (inx == NODE_STATE_ALLOCATED)) {
3681 if (no_resp_flag)
3682 return "FAILG*";
3683 return "FAILG";
3684 } else {
3685 if (no_resp_flag)
3686 return "FAIL*";
3687 return "FAIL";
3688 }
3689 }
3690
3691 if (inx == NODE_STATE_CANCEL_REBOOT)
3692 return "CANC_R";
3693 if (inx == NODE_STATE_POWERING_DOWN)
3694 return "POWRNG_DN";
3695 if (inx == NODE_STATE_POWER_SAVE)
3696 return "POW_DN";
3697 if (inx == NODE_STATE_POWER_UP)
3698 return "POW_UP";
3699 if (inx == NODE_STATE_DOWN) {
3700 if (maint_flag)
3701 return "DOWN$";
3702 if (reboot_flag)
3703 return "DOWN@";
3704 if (power_up_flag)
3705 return "DOWN#";
3706 if (powering_down_flag)
3707 return "DOWN%";
3708 if (powered_down_flag)
3709 return "DOWN~";
3710 if (no_resp_flag)
3711 return "DOWN*";
3712 return "DOWN";
3713 }
3714
3715 if (inx == NODE_STATE_ALLOCATED) {
3716 if (maint_flag)
3717 return "ALLOC$";
3718 if (reboot_flag)
3719 return "ALLOC@";
3720 if (power_up_flag)
3721 return "ALLOC#";
3722 if (powering_down_flag)
3723 return "ALLOC%";
3724 if (powered_down_flag)
3725 return "ALLOC~";
3726 if (no_resp_flag)
3727 return "ALLOC*";
3728 if (comp_flag)
3729 return "ALLOC+";
3730 return "ALLOC";
3731 }
3732 if (comp_flag) {
3733 if (maint_flag)
3734 return "COMP$";
3735 if (reboot_flag)
3736 return "COMP@";
3737 if (power_up_flag)
3738 return "COMP#";
3739 if (powering_down_flag)
3740 return "COMP%";
3741 if (powered_down_flag)
3742 return "COMP~";
3743 if (no_resp_flag)
3744 return "COMP*";
3745 return "COMP";
3746 }
3747 if (inx == NODE_STATE_IDLE) {
3748 if (maint_flag)
3749 return "IDLE$";
3750 if (reboot_flag)
3751 return "IDLE@";
3752 if (power_up_flag)
3753 return "IDLE#";
3754 if (powering_down_flag)
3755 return "IDLE%";
3756 if (powered_down_flag)
3757 return "IDLE~";
3758 if (no_resp_flag)
3759 return "IDLE*";
3760 if (net_flag)
3761 return "NPC";
3762 if (res_flag)
3763 return "RESV";
3764 return "IDLE";
3765 }
3766 if (inx == NODE_STATE_MIXED) {
3767 if (maint_flag)
3768 return "MIX$";
3769 if (reboot_flag)
3770 return "MIX@";
3771 if (power_up_flag)
3772 return "MIX#";
3773 if (powering_down_flag)
3774 return "MIX%";
3775 if (powered_down_flag)
3776 return "MIX~";
3777 if (no_resp_flag)
3778 return "MIX*";
3779 return "MIX";
3780 }
3781 if (inx == NODE_STATE_FUTURE) {
3782 if (maint_flag)
3783 return "FUTR$";
3784 if (reboot_flag)
3785 return "FUTR@";
3786 if (power_up_flag)
3787 return "FUTR#";
3788 if (powering_down_flag)
3789 return "FUTR%";
3790 if (powered_down_flag)
3791 return "FUTR~";
3792 if (no_resp_flag)
3793 return "FUTR*";
3794 return "FUTR";
3795 }
3796 if (resume_flag)
3797 return "RESM";
3798 if (inx == NODE_STATE_UNKNOWN) {
3799 if (no_resp_flag)
3800 return "UNK*";
3801 return "UNK";
3802 }
3803 return "?";
3804 }
3805
power_flags_id(const char * power_flags)3806 extern uint16_t power_flags_id(const char *power_flags)
3807 {
3808 char *tmp, *tok, *save_ptr = NULL;
3809 uint16_t rc = 0;
3810
3811 if (!power_flags)
3812 return rc;
3813
3814 tmp = xstrdup(power_flags);
3815 tok = strtok_r(tmp, ",", &save_ptr);
3816 while (tok) {
3817 if (!xstrcasecmp(tok, "level"))
3818 rc |= SLURM_POWER_FLAGS_LEVEL;
3819 else
3820 error("Ignoring unrecognized power option (%s)", tok);
3821 tok = strtok_r(NULL, ",", &save_ptr);
3822 }
3823 xfree(tmp);
3824
3825 return rc;
3826 }
3827
power_flags_str(uint16_t power_flags)3828 extern char *power_flags_str(uint16_t power_flags)
3829 {
3830 if (power_flags & SLURM_POWER_FLAGS_LEVEL)
3831 return "LEVEL";
3832 return "";
3833 }
3834
private_data_string(uint16_t private_data,char * str,int str_len)3835 extern void private_data_string(uint16_t private_data, char *str, int str_len)
3836 {
3837 if (str_len > 0)
3838 str[0] = '\0';
3839 if (str_len < 69) {
3840 error("private_data_string: output buffer too small");
3841 return;
3842 }
3843
3844 if (private_data & PRIVATE_DATA_ACCOUNTS) {
3845 if (str[0])
3846 strcat(str, ",");
3847 strcat(str, "accounts"); //9 len
3848 }
3849 if (private_data & PRIVATE_CLOUD_NODES) {
3850 if (str[0])
3851 strcat(str, ",");
3852 strcat(str, "cloud"); //6 len
3853 }
3854 if (private_data & PRIVATE_DATA_EVENTS) {
3855 if (str[0])
3856 strcat(str, ",");
3857 strcat(str, "events"); //7 len
3858 }
3859 if (private_data & PRIVATE_DATA_JOBS) {
3860 if (str[0])
3861 strcat(str, ",");
3862 strcat(str, "jobs"); //5 len
3863 }
3864 if (private_data & PRIVATE_DATA_NODES) {
3865 if (str[0])
3866 strcat(str, ",");
3867 strcat(str, "nodes"); //6 len
3868 }
3869 if (private_data & PRIVATE_DATA_PARTITIONS) {
3870 if (str[0])
3871 strcat(str, ",");
3872 strcat(str, "partitions"); //11 len
3873 }
3874 if (private_data & PRIVATE_DATA_RESERVATIONS) {
3875 if (str[0])
3876 strcat(str, ",");
3877 strcat(str, "reservations"); //13 len
3878 }
3879 if (private_data & PRIVATE_DATA_USAGE) {
3880 if (str[0])
3881 strcat(str, ",");
3882 strcat(str, "usage"); //6 len
3883 }
3884 if (private_data & PRIVATE_DATA_USERS) {
3885 if (str[0])
3886 strcat(str, ",");
3887 strcat(str, "users"); //6 len
3888 }
3889
3890 // total len 69
3891
3892 if (str[0] == '\0')
3893 strcat(str, "none");
3894 }
3895
accounting_enforce_string(uint16_t enforce,char * str,int str_len)3896 extern void accounting_enforce_string(uint16_t enforce, char *str, int str_len)
3897 {
3898 if (str_len > 0)
3899 str[0] = '\0';
3900 if (str_len < 30) {
3901 error("enforce: output buffer too small");
3902 return;
3903 }
3904
3905 if (enforce & ACCOUNTING_ENFORCE_ASSOCS)
3906 strcat(str, "associations"); //12 len
3907 if (enforce & ACCOUNTING_ENFORCE_LIMITS) {
3908 if (str[0])
3909 strcat(str, ",");
3910 strcat(str, "limits"); //7 len
3911 }
3912 if (enforce & ACCOUNTING_ENFORCE_NO_JOBS) {
3913 if (str[0])
3914 strcat(str, ",");
3915 strcat(str, "nojobs"); //7 len
3916 }
3917 if (enforce & ACCOUNTING_ENFORCE_NO_STEPS) {
3918 if (str[0])
3919 strcat(str, ",");
3920 strcat(str, "nosteps"); //8 len
3921 }
3922 if (enforce & ACCOUNTING_ENFORCE_QOS) {
3923 if (str[0])
3924 strcat(str, ",");
3925 strcat(str, "qos"); //4 len
3926 }
3927 if (enforce & ACCOUNTING_ENFORCE_SAFE) {
3928 if (str[0])
3929 strcat(str, ",");
3930 strcat(str, "safe"); //5 len
3931 }
3932 if (enforce & ACCOUNTING_ENFORCE_WCKEYS) {
3933 if (str[0])
3934 strcat(str, ",");
3935 strcat(str, "wckeys"); //7 len
3936 }
3937 // total len 50
3938
3939 if (str[0] == '\0')
3940 strcat(str, "none");
3941 }
3942
cray_nodelist2nids(hostlist_t hl_in,char * nodelist)3943 extern char *cray_nodelist2nids(hostlist_t hl_in, char *nodelist)
3944 {
3945 hostlist_t hl = hl_in;
3946 char *nids = NULL, *node_name, *sep = "";
3947 int i, nid;
3948 int nid_begin = -1, nid_end = -1;
3949
3950 if (!nodelist && !hl_in)
3951 return NULL;
3952
3953 /* Make hl off nodelist */
3954 if (!hl_in) {
3955 hl = hostlist_create(nodelist);
3956 if (!hl) {
3957 error("Invalid hostlist: %s", nodelist);
3958 return NULL;
3959 }
3960 //info("input hostlist: %s", nodelist);
3961 hostlist_uniq(hl);
3962 }
3963
3964 while ((node_name = hostlist_shift(hl))) {
3965 for (i = 0; node_name[i]; i++) {
3966 if (!isdigit(node_name[i]))
3967 continue;
3968 nid = atoi(&node_name[i]);
3969 if (nid_begin == -1) {
3970 nid_begin = nid;
3971 nid_end = nid;
3972 } else if (nid == (nid_end + 1)) {
3973 nid_end = nid;
3974 } else {
3975 if (nid_begin == nid_end) {
3976 xstrfmtcat(nids, "%s%d", sep,
3977 nid_begin);
3978 } else {
3979 xstrfmtcat(nids, "%s%d-%d", sep,
3980 nid_begin, nid_end);
3981 }
3982 nid_begin = nid;
3983 nid_end = nid;
3984 sep = ",";
3985 }
3986 break;
3987 }
3988 free(node_name);
3989 }
3990 if (nid_begin == -1)
3991 ; /* No data to record */
3992 else if (nid_begin == nid_end)
3993 xstrfmtcat(nids, "%s%d", sep, nid_begin);
3994 else
3995 xstrfmtcat(nids, "%s%d-%d", sep, nid_begin, nid_end);
3996
3997 if (!hl_in)
3998 hostlist_destroy(hl);
3999 //info("output node IDs: %s", nids);
4000
4001 return nids;
4002 }
4003
slurm_free_resource_allocation_response_msg_members(resource_allocation_response_msg_t * msg)4004 extern void slurm_free_resource_allocation_response_msg_members (
4005 resource_allocation_response_msg_t * msg)
4006 {
4007 if (msg) {
4008 select_g_select_jobinfo_free(msg->select_jobinfo);
4009 msg->select_jobinfo = NULL;
4010 xfree(msg->account);
4011 xfree(msg->alias_list);
4012 xfree(msg->cpus_per_node);
4013 xfree(msg->cpu_count_reps);
4014 env_array_free(msg->environment);
4015 msg->environment = NULL;
4016 xfree(msg->job_submit_user_msg);
4017 xfree(msg->node_addr);
4018 xfree(msg->node_list);
4019 xfree(msg->partition);
4020 xfree(msg->qos);
4021 xfree(msg->resv_name);
4022 slurmdb_destroy_cluster_rec(msg->working_cluster_rec);
4023 }
4024 }
4025
4026 /*
4027 * slurm_free_resource_allocation_response_msg - free slurm resource
4028 * allocation response message
4029 * IN msg - pointer to allocation response message
4030 * NOTE: buffer is loaded by slurm_allocate_resources
4031 */
slurm_free_resource_allocation_response_msg(resource_allocation_response_msg_t * msg)4032 extern void slurm_free_resource_allocation_response_msg (
4033 resource_allocation_response_msg_t * msg)
4034 {
4035 slurm_free_resource_allocation_response_msg_members(msg);
4036 xfree(msg);
4037 }
4038
4039 /*
4040 * slurm_free_sbcast_cred_msg - free slurm resource allocation response
4041 * message including an sbcast credential
4042 * IN msg - pointer to response message from slurm_sbcast_lookup()
4043 * NOTE: buffer is loaded by slurm_allocate_resources
4044 */
slurm_free_sbcast_cred_msg(job_sbcast_cred_msg_t * msg)4045 extern void slurm_free_sbcast_cred_msg(job_sbcast_cred_msg_t * msg)
4046 {
4047 if (msg) {
4048 xfree(msg->node_addr);
4049 xfree(msg->node_list);
4050 delete_sbcast_cred(msg->sbcast_cred);
4051 xfree(msg);
4052 }
4053 }
4054
4055 /*
4056 * slurm_free_job_step_create_response_msg - free slurm
4057 * job step create response message
4058 * IN msg - pointer to job step create response message
4059 * NOTE: buffer is loaded by slurm_job_step_create
4060 */
slurm_free_job_step_create_response_msg(job_step_create_response_msg_t * msg)4061 extern void slurm_free_job_step_create_response_msg(
4062 job_step_create_response_msg_t * msg)
4063 {
4064 if (msg) {
4065 xfree(msg->resv_ports);
4066 slurm_step_layout_destroy(msg->step_layout);
4067 slurm_cred_destroy(msg->cred);
4068 if (msg->select_jobinfo)
4069 select_g_select_jobinfo_free(msg->select_jobinfo);
4070 if (msg->switch_job)
4071 switch_g_free_jobinfo(msg->switch_job);
4072
4073 xfree(msg);
4074 }
4075
4076 }
4077
4078
4079 /*
4080 * slurm_free_submit_response_response_msg - free slurm
4081 * job submit response message
4082 * IN msg - pointer to job submit response message
4083 * NOTE: buffer is loaded by slurm_submit_batch_job
4084 */
slurm_free_submit_response_response_msg(submit_response_msg_t * msg)4085 extern void slurm_free_submit_response_response_msg(submit_response_msg_t * msg)
4086 {
4087 if (msg) {
4088 xfree(msg->job_submit_user_msg);
4089 xfree(msg);
4090 }
4091 }
4092
4093
4094 /*
4095 * slurm_free_ctl_conf - free slurm control information response message
4096 * IN msg - pointer to slurm control information response message
4097 * NOTE: buffer is loaded by slurm_load_jobs
4098 */
slurm_free_ctl_conf(slurm_ctl_conf_info_msg_t * config_ptr)4099 extern void slurm_free_ctl_conf(slurm_ctl_conf_info_msg_t * config_ptr)
4100 {
4101 if (config_ptr) {
4102 free_slurm_conf(config_ptr, 0);
4103 xfree(config_ptr);
4104 }
4105 }
4106
4107 /*
4108 * slurm_free_slurmd_status - free slurmd state information
4109 * IN msg - pointer to slurmd state information
4110 * NOTE: buffer is loaded by slurm_load_slurmd_status
4111 */
slurm_free_slurmd_status(slurmd_status_t * slurmd_status_ptr)4112 extern void slurm_free_slurmd_status(slurmd_status_t* slurmd_status_ptr)
4113 {
4114 if (slurmd_status_ptr) {
4115 xfree(slurmd_status_ptr->hostname);
4116 xfree(slurmd_status_ptr->slurmd_logfile);
4117 xfree(slurmd_status_ptr->step_list);
4118 xfree(slurmd_status_ptr->version);
4119 xfree(slurmd_status_ptr);
4120 }
4121 }
4122
4123 /*
4124 * slurm_free_job_info - free the job information response message
4125 * IN msg - pointer to job information response message
4126 * NOTE: buffer is loaded by slurm_load_job.
4127 */
slurm_free_job_info_msg(job_info_msg_t * job_buffer_ptr)4128 extern void slurm_free_job_info_msg(job_info_msg_t * job_buffer_ptr)
4129 {
4130 if (job_buffer_ptr) {
4131 if (job_buffer_ptr->job_array) {
4132 _free_all_job_info(job_buffer_ptr);
4133 xfree(job_buffer_ptr->job_array);
4134 }
4135 xfree(job_buffer_ptr);
4136 }
4137 }
4138
_free_all_job_info(job_info_msg_t * msg)4139 static void _free_all_job_info(job_info_msg_t *msg)
4140 {
4141 int i;
4142
4143 if ((msg == NULL) ||
4144 (msg->job_array == NULL))
4145 return;
4146
4147 for (i = 0; i < msg->record_count; i++)
4148 slurm_free_job_info_members (&msg->job_array[i]);
4149 }
4150
4151 /*
4152 * slurm_free_job_step_info_response_msg - free the job step
4153 * information response message
4154 * IN msg - pointer to job step information response message
4155 * NOTE: buffer is loaded by slurm_get_job_steps.
4156 */
slurm_free_job_step_info_response_msg(job_step_info_response_msg_t * msg)4157 extern void slurm_free_job_step_info_response_msg(job_step_info_response_msg_t *
4158 msg)
4159 {
4160 if (msg != NULL) {
4161 if (msg->job_steps != NULL) {
4162 _free_all_step_info(msg);
4163 xfree(msg->job_steps);
4164 }
4165 xfree(msg);
4166 }
4167 }
4168
_free_all_step_info(job_step_info_response_msg_t * msg)4169 static void _free_all_step_info (job_step_info_response_msg_t *msg)
4170 {
4171 int i;
4172
4173 if ((msg == NULL) ||
4174 (msg->job_steps == NULL))
4175 return;
4176
4177 for (i = 0; i < msg->job_step_count; i++)
4178 slurm_free_job_step_info_members (&msg->job_steps[i]);
4179 }
4180
slurm_free_job_step_info_members(job_step_info_t * msg)4181 extern void slurm_free_job_step_info_members(job_step_info_t * msg)
4182 {
4183 if (msg) {
4184 xfree(msg->cluster);
4185 xfree(msg->tres_per_node);
4186 xfree(msg->mem_per_tres);
4187 xfree(msg->name);
4188 xfree(msg->network);
4189 xfree(msg->nodes);
4190 xfree(msg->node_inx);
4191 xfree(msg->partition);
4192 xfree(msg->resv_ports);
4193 select_g_select_jobinfo_free(msg->select_jobinfo);
4194 msg->select_jobinfo = NULL;
4195 xfree(msg->srun_host);
4196 xfree(msg->tres_alloc_str);
4197 xfree(msg->tres_bind);
4198 xfree(msg->tres_freq);
4199 xfree(msg->tres_per_step);
4200 xfree(msg->tres_per_node);
4201 xfree(msg->tres_per_socket);
4202 xfree(msg->tres_per_task);
4203 }
4204 }
4205
4206 /*
4207 * slurm_free_front_end_info - free the front_end information response message
4208 * IN msg - pointer to front_end information response message
4209 * NOTE: buffer is loaded by slurm_load_front_end.
4210 */
slurm_free_front_end_info_msg(front_end_info_msg_t * msg)4211 extern void slurm_free_front_end_info_msg(front_end_info_msg_t * msg)
4212 {
4213 if (msg) {
4214 if (msg->front_end_array) {
4215 _free_all_front_end_info(msg);
4216 xfree(msg->front_end_array);
4217 }
4218 xfree(msg);
4219 }
4220 }
4221
_free_all_front_end_info(front_end_info_msg_t * msg)4222 static void _free_all_front_end_info(front_end_info_msg_t *msg)
4223 {
4224 int i;
4225
4226 if ((msg == NULL) || (msg->front_end_array == NULL))
4227 return;
4228
4229 for (i = 0; i < msg->record_count; i++)
4230 slurm_free_front_end_info_members(&msg->front_end_array[i]);
4231 }
4232
slurm_free_front_end_info_members(front_end_info_t * front_end)4233 extern void slurm_free_front_end_info_members(front_end_info_t * front_end)
4234 {
4235 if (front_end) {
4236 xfree(front_end->allow_groups);
4237 xfree(front_end->allow_users);
4238 xfree(front_end->deny_groups);
4239 xfree(front_end->deny_users);
4240 xfree(front_end->name);
4241 xfree(front_end->reason);
4242 xfree(front_end->version);
4243 }
4244 }
4245
slurm_init_node_info_t(node_info_t * msg,bool clear)4246 extern void slurm_init_node_info_t(node_info_t *msg, bool clear)
4247 {
4248 xassert(msg);
4249
4250 if (clear)
4251 memset(msg, 0, sizeof(node_info_t));
4252
4253 msg->next_state = NO_VAL;
4254 }
4255
4256 /*
4257 * slurm_free_node_info - free the node information response message
4258 * IN msg - pointer to node information response message
4259 * NOTE: buffer is loaded by slurm_load_node.
4260 */
slurm_free_node_info_msg(node_info_msg_t * msg)4261 extern void slurm_free_node_info_msg(node_info_msg_t * msg)
4262 {
4263 if (msg) {
4264 if (msg->node_array) {
4265 _free_all_node_info(msg);
4266 xfree(msg->node_array);
4267 }
4268 xfree(msg);
4269 }
4270 }
4271
_free_all_node_info(node_info_msg_t * msg)4272 static void _free_all_node_info(node_info_msg_t *msg)
4273 {
4274 int i;
4275
4276 if ((msg == NULL) || (msg->node_array == NULL))
4277 return;
4278
4279 for (i = 0; i < msg->record_count; i++)
4280 slurm_free_node_info_members(&msg->node_array[i]);
4281 }
4282
slurm_free_node_info_members(node_info_t * node)4283 extern void slurm_free_node_info_members(node_info_t * node)
4284 {
4285 if (node) {
4286 xfree(node->arch);
4287 xfree(node->cluster_name);
4288 xfree(node->cpu_spec_list);
4289 acct_gather_energy_destroy(node->energy);
4290 ext_sensors_destroy(node->ext_sensors);
4291 power_mgmt_data_free(node->power);
4292 xfree(node->features);
4293 xfree(node->features_act);
4294 xfree(node->gres);
4295 xfree(node->gres_drain);
4296 xfree(node->gres_used);
4297 xfree(node->mcs_label);
4298 xfree(node->name);
4299 xfree(node->node_addr);
4300 xfree(node->node_hostname);
4301 xfree(node->os);
4302 xfree(node->partitions);
4303 xfree(node->reason);
4304 select_g_select_nodeinfo_free(node->select_nodeinfo);
4305 node->select_nodeinfo = NULL;
4306 xfree(node->tres_fmt_str);
4307 xfree(node->version);
4308 /* Do NOT free node, it is an element of an array */
4309 }
4310 }
4311
4312
4313 /*
4314 * slurm_free_partition_info_msg - free the partition information
4315 * response message
4316 * IN msg - pointer to partition information response message
4317 * NOTE: buffer is loaded by slurm_load_partitions
4318 */
slurm_free_partition_info_msg(partition_info_msg_t * msg)4319 extern void slurm_free_partition_info_msg(partition_info_msg_t * msg)
4320 {
4321 if (msg) {
4322 if (msg->partition_array) {
4323 _free_all_partitions(msg);
4324 xfree(msg->partition_array);
4325 }
4326 xfree(msg);
4327 }
4328 }
4329
_free_all_partitions(partition_info_msg_t * msg)4330 static void _free_all_partitions(partition_info_msg_t *msg)
4331 {
4332 int i;
4333
4334 if ((msg == NULL) ||
4335 (msg->partition_array == NULL))
4336 return;
4337
4338 for (i = 0; i < msg->record_count; i++)
4339 slurm_free_partition_info_members(
4340 &msg->partition_array[i]);
4341
4342 }
4343
slurm_free_partition_info_members(partition_info_t * part)4344 extern void slurm_free_partition_info_members(partition_info_t * part)
4345 {
4346 if (part) {
4347 xfree(part->allow_alloc_nodes);
4348 xfree(part->allow_accounts);
4349 xfree(part->allow_groups);
4350 xfree(part->allow_qos);
4351 xfree(part->alternate);
4352 xfree(part->billing_weights_str);
4353 xfree(part->cluster_name);
4354 xfree(part->deny_accounts);
4355 xfree(part->deny_qos);
4356 FREE_NULL_LIST(part->job_defaults_list);
4357 xfree(part->job_defaults_str);
4358 xfree(part->name);
4359 xfree(part->nodes);
4360 xfree(part->node_inx);
4361 xfree(part->qos_char);
4362 xfree(part->tres_fmt_str);
4363 }
4364 }
4365
4366 /*
4367 * slurm_free_reserve_info_msg - free the reservation information
4368 * response message
4369 * IN msg - pointer to reservation information response message
4370 * NOTE: buffer is loaded by slurm_load_reservation
4371 */
slurm_free_reservation_info_msg(reserve_info_msg_t * msg)4372 extern void slurm_free_reservation_info_msg(reserve_info_msg_t * msg)
4373 {
4374 if (msg) {
4375 if (msg->reservation_array) {
4376 _free_all_reservations(msg);
4377 xfree(msg->reservation_array);
4378 }
4379 xfree(msg);
4380 }
4381 }
4382
_free_all_reservations(reserve_info_msg_t * msg)4383 static void _free_all_reservations(reserve_info_msg_t *msg)
4384 {
4385 int i;
4386
4387 if ((msg == NULL) ||
4388 (msg->reservation_array == NULL))
4389 return;
4390
4391 for (i = 0; i < msg->record_count; i++) {
4392 slurm_free_reserve_info_members(
4393 &msg->reservation_array[i]);
4394 }
4395
4396 }
4397
slurm_free_reserve_info_members(reserve_info_t * resv)4398 extern void slurm_free_reserve_info_members(reserve_info_t * resv)
4399 {
4400 int i;
4401 if (resv) {
4402 xfree(resv->accounts);
4403 xfree(resv->burst_buffer);
4404 if (resv->core_spec) {
4405 for (i = 0; i < resv->core_spec_cnt; i++) {
4406 xfree(resv->core_spec[i].node_name);
4407 xfree(resv->core_spec[i].core_id);
4408 }
4409 xfree(resv->core_spec);
4410 }
4411 xfree(resv->features);
4412 xfree(resv->licenses);
4413 xfree(resv->name);
4414 xfree(resv->node_inx);
4415 xfree(resv->node_list);
4416 xfree(resv->partition);
4417 xfree(resv->tres_str);
4418 xfree(resv->users);
4419 }
4420 }
4421
4422 /*
4423 * slurm_free_topo_info_msg - free the switch topology configuration
4424 * information response message
4425 * IN msg - pointer to switch topology configuration response message
4426 * NOTE: buffer is loaded by slurm_load_topo.
4427 */
slurm_free_topo_info_msg(topo_info_response_msg_t * msg)4428 extern void slurm_free_topo_info_msg(topo_info_response_msg_t *msg)
4429 {
4430 int i;
4431
4432 if (msg) {
4433 if (msg->topo_array) {
4434 for (i = 0; i < msg->record_count; i++) {
4435 xfree(msg->topo_array[i].name);
4436 xfree(msg->topo_array[i].nodes);
4437 xfree(msg->topo_array[i].switches);
4438 }
4439 xfree(msg->topo_array);
4440 }
4441 xfree(msg);
4442 }
4443 }
4444
4445 /*
4446 * slurm_free_burst_buffer_info_msg - free buffer returned by
4447 * slurm_load_burst_buffer
4448 * IN burst_buffer_info_msg_ptr - pointer to burst_buffer_info_msg_t
4449 * RET 0 or a slurm error code
4450 */
slurm_free_burst_buffer_info_msg(burst_buffer_info_msg_t * msg)4451 extern void slurm_free_burst_buffer_info_msg(burst_buffer_info_msg_t *msg)
4452 {
4453 int i, j;
4454 burst_buffer_info_t *bb_info_ptr;
4455 burst_buffer_resv_t *bb_resv_ptr;
4456
4457 if (msg) {
4458 for (i = 0, bb_info_ptr = msg->burst_buffer_array;
4459 i < msg->record_count; i++, bb_info_ptr++) {
4460 xfree(bb_info_ptr->allow_users);
4461 xfree(bb_info_ptr->create_buffer);
4462 xfree(bb_info_ptr->deny_users);
4463 xfree(bb_info_ptr->destroy_buffer);
4464 xfree(bb_info_ptr->get_sys_state);
4465 xfree(bb_info_ptr->get_sys_status);
4466 xfree(bb_info_ptr->name);
4467 xfree(bb_info_ptr->start_stage_in);
4468 xfree(bb_info_ptr->start_stage_out);
4469 xfree(bb_info_ptr->stop_stage_in);
4470 xfree(bb_info_ptr->stop_stage_out);
4471 for (j = 0,
4472 bb_resv_ptr = bb_info_ptr->burst_buffer_resv_ptr;
4473 j < bb_info_ptr->buffer_count;
4474 j++, bb_resv_ptr++) {
4475 xfree(bb_resv_ptr->account);
4476 xfree(bb_resv_ptr->name);
4477 xfree(bb_resv_ptr->partition);
4478 xfree(bb_resv_ptr->pool);
4479 xfree(bb_resv_ptr->qos);
4480 }
4481 xfree(bb_info_ptr->burst_buffer_resv_ptr);
4482 xfree(bb_info_ptr->burst_buffer_use_ptr);
4483 }
4484 xfree(msg->burst_buffer_array);
4485 xfree(msg);
4486 }
4487 }
4488
4489 /*
4490 * slurm_free_powercap_info_msg - free the powercapping information
4491 * response message
4492 * IN msg - pointer to powercapping information response message
4493 * NOTE: buffer is loaded by slurm_load_powercap.
4494 */
slurm_free_powercap_info_msg(powercap_info_msg_t * msg)4495 extern void slurm_free_powercap_info_msg(powercap_info_msg_t *msg)
4496 {
4497 xfree(msg);
4498 }
4499
4500
slurm_free_file_bcast_msg(file_bcast_msg_t * msg)4501 extern void slurm_free_file_bcast_msg(file_bcast_msg_t *msg)
4502 {
4503 if (msg) {
4504 xfree(msg->block);
4505 xfree(msg->fname);
4506 xfree(msg->user_name);
4507 delete_sbcast_cred(msg->cred);
4508 xfree(msg);
4509 }
4510 }
4511
slurm_free_step_complete_msg(step_complete_msg_t * msg)4512 extern void slurm_free_step_complete_msg(step_complete_msg_t *msg)
4513 {
4514 if (msg) {
4515 jobacctinfo_destroy(msg->jobacct);
4516 xfree(msg);
4517 }
4518 }
4519
slurm_free_job_step_stat(void * object)4520 extern void slurm_free_job_step_stat(void *object)
4521 {
4522 job_step_stat_t *msg = (job_step_stat_t *)object;
4523 if (msg) {
4524 jobacctinfo_destroy(msg->jobacct);
4525 slurm_free_job_step_pids(msg->step_pids);
4526 xfree(msg);
4527 }
4528 }
4529
slurm_free_job_step_pids(void * object)4530 extern void slurm_free_job_step_pids(void *object)
4531 {
4532 job_step_pids_t *msg = (job_step_pids_t *)object;
4533 if (msg) {
4534 xfree(msg->node_name);
4535 xfree(msg->pid);
4536 xfree(msg);
4537 }
4538 }
4539
slurm_free_network_callerid_msg(network_callerid_msg_t * mesg)4540 extern void slurm_free_network_callerid_msg(network_callerid_msg_t *mesg)
4541 {
4542 xfree(mesg);
4543 }
4544
slurm_free_network_callerid_resp(network_callerid_resp_t * resp)4545 extern void slurm_free_network_callerid_resp(network_callerid_resp_t *resp)
4546 {
4547 if (resp) {
4548 xfree(resp->node_name);
4549 xfree(resp);
4550 }
4551 }
4552
slurm_free_trigger_msg(trigger_info_msg_t * msg)4553 extern void slurm_free_trigger_msg(trigger_info_msg_t *msg)
4554 {
4555 int i;
4556
4557 if (msg->trigger_array) {
4558 for (i = 0; i < msg->record_count; i++) {
4559 xfree(msg->trigger_array[i].res_id);
4560 xfree(msg->trigger_array[i].program);
4561 }
4562 xfree(msg->trigger_array);
4563 }
4564 xfree(msg);
4565 }
4566
slurm_free_set_debug_flags_msg(set_debug_flags_msg_t * msg)4567 extern void slurm_free_set_debug_flags_msg(set_debug_flags_msg_t *msg)
4568 {
4569 xfree(msg);
4570 }
4571
slurm_free_set_debug_level_msg(set_debug_level_msg_t * msg)4572 extern void slurm_free_set_debug_level_msg(set_debug_level_msg_t *msg)
4573 {
4574 xfree(msg);
4575 }
4576
slurm_destroy_assoc_shares_object(void * object)4577 extern void slurm_destroy_assoc_shares_object(void *object)
4578 {
4579 assoc_shares_object_t *obj_ptr =
4580 (assoc_shares_object_t *)object;
4581
4582 if (obj_ptr) {
4583 xfree(obj_ptr->cluster);
4584 xfree(obj_ptr->name);
4585 xfree(obj_ptr->parent);
4586 xfree(obj_ptr->partition);
4587 xfree(obj_ptr->tres_run_secs);
4588 xfree(obj_ptr->tres_grp_mins);
4589 xfree(obj_ptr->usage_tres_raw);
4590 xfree(obj_ptr);
4591 }
4592 }
4593
slurm_free_shares_request_msg(shares_request_msg_t * msg)4594 extern void slurm_free_shares_request_msg(shares_request_msg_t *msg)
4595 {
4596 if (msg) {
4597 FREE_NULL_LIST(msg->acct_list);
4598 FREE_NULL_LIST(msg->user_list);
4599 xfree(msg);
4600 }
4601 }
4602
slurm_free_shares_response_msg(shares_response_msg_t * msg)4603 extern void slurm_free_shares_response_msg(shares_response_msg_t *msg)
4604 {
4605 if (msg) {
4606 int i;
4607 if (msg->tres_names) {
4608 for (i=0; i<msg->tres_cnt; i++)
4609 xfree(msg->tres_names[i]);
4610 xfree(msg->tres_names);
4611 }
4612 FREE_NULL_LIST(msg->assoc_shares_list);
4613 xfree(msg);
4614 }
4615 }
4616
4617
slurm_free_stats_info_request_msg(stats_info_request_msg_t * msg)4618 inline void slurm_free_stats_info_request_msg(stats_info_request_msg_t *msg)
4619 {
4620 xfree(msg);
4621 }
4622
4623
slurm_destroy_priority_factors_object(void * object)4624 extern void slurm_destroy_priority_factors_object(void *object)
4625 {
4626 priority_factors_object_t *obj_ptr =
4627 (priority_factors_object_t *)object;
4628 xfree(obj_ptr->tres_weights);
4629 xfree(obj_ptr->tres_names);
4630 xfree(obj_ptr->priority_tres);
4631 xfree(obj_ptr);
4632 }
4633
slurm_copy_priority_factors_object(priority_factors_object_t * dest,priority_factors_object_t * src)4634 extern void slurm_copy_priority_factors_object(priority_factors_object_t *dest,
4635 priority_factors_object_t *src)
4636 {
4637 int size;
4638
4639 if (!dest || !src)
4640 return;
4641
4642 size = sizeof(double) * src->tres_cnt;
4643
4644 memcpy(dest, src, sizeof(priority_factors_object_t));
4645 dest->partition = xstrdup(src->partition);
4646
4647 if (src->priority_tres) {
4648 dest->priority_tres = xmalloc(size);
4649 memcpy(dest->priority_tres, src->priority_tres, size);
4650 }
4651
4652 if (src->tres_names) {
4653 int char_size = sizeof(char *) * src->tres_cnt;
4654 dest->tres_names = xmalloc(char_size);
4655 memcpy(dest->tres_names, src->tres_names, char_size);
4656 }
4657
4658 if (src->tres_weights) {
4659 dest->tres_weights = xmalloc(size);
4660 memcpy(dest->tres_weights, src->tres_weights, size);
4661 }
4662 }
4663
slurm_free_priority_factors_request_msg(priority_factors_request_msg_t * msg)4664 extern void slurm_free_priority_factors_request_msg(
4665 priority_factors_request_msg_t *msg)
4666 {
4667 if (msg) {
4668 FREE_NULL_LIST(msg->job_id_list);
4669 xfree(msg->partitions);
4670 FREE_NULL_LIST(msg->uid_list);
4671 xfree(msg);
4672 }
4673 }
4674
slurm_free_priority_factors_response_msg(priority_factors_response_msg_t * msg)4675 extern void slurm_free_priority_factors_response_msg(
4676 priority_factors_response_msg_t *msg)
4677 {
4678 if (msg) {
4679 FREE_NULL_LIST(msg->priority_factors_list);
4680 xfree(msg);
4681 }
4682 }
4683
4684
slurm_free_accounting_update_msg(accounting_update_msg_t * msg)4685 extern void slurm_free_accounting_update_msg(accounting_update_msg_t *msg)
4686 {
4687 if (msg) {
4688 FREE_NULL_LIST(msg->update_list);
4689 xfree(msg);
4690 }
4691 }
4692
slurm_free_comp_msg_list(void * x)4693 extern void slurm_free_comp_msg_list(void *x)
4694 {
4695 slurm_msg_t *msg = (slurm_msg_t*)x;
4696 if (msg) {
4697 if (msg->data_size)
4698 free_buf(msg->data);
4699 else
4700 slurm_free_msg_data(msg->msg_type, msg->data);
4701
4702 /* make sure the data is NULL here or we could cause a
4703 * double free in slurm_free_msg
4704 */
4705 msg->data = NULL;
4706
4707 slurm_free_msg(msg);
4708 }
4709 }
4710
slurm_free_composite_msg(composite_msg_t * msg)4711 extern void slurm_free_composite_msg(composite_msg_t *msg)
4712 {
4713 if (msg) {
4714 FREE_NULL_LIST(msg->msg_list);
4715 xfree(msg);
4716 }
4717 }
4718
slurm_free_set_fs_dampening_factor_msg(set_fs_dampening_factor_msg_t * msg)4719 extern void slurm_free_set_fs_dampening_factor_msg(
4720 set_fs_dampening_factor_msg_t *msg)
4721 {
4722 xfree(msg);
4723 }
4724
slurm_free_control_status_msg(control_status_msg_t * msg)4725 extern void slurm_free_control_status_msg(control_status_msg_t *msg)
4726 {
4727 xfree(msg);
4728 }
4729
slurm_free_bb_status_req_msg(bb_status_req_msg_t * msg)4730 extern void slurm_free_bb_status_req_msg(bb_status_req_msg_t *msg)
4731 {
4732 int i;
4733
4734 if (msg) {
4735 if (msg->argv) {
4736 for (i = 0; i < msg->argc; i++)
4737 xfree(msg->argv[i]);
4738 xfree(msg->argv);
4739 }
4740 xfree(msg);
4741 }
4742 }
4743
slurm_free_bb_status_resp_msg(bb_status_resp_msg_t * msg)4744 extern void slurm_free_bb_status_resp_msg(bb_status_resp_msg_t *msg)
4745 {
4746 if (msg) {
4747 xfree(msg->status_resp);
4748 xfree(msg);
4749 }
4750 }
4751
slurm_free_msg_data(slurm_msg_type_t type,void * data)4752 extern int slurm_free_msg_data(slurm_msg_type_t type, void *data)
4753 {
4754 if (!data)
4755 return SLURM_SUCCESS;
4756
4757 /* this message was never loaded */
4758 if ((uint16_t)type == NO_VAL16)
4759 return SLURM_SUCCESS;
4760
4761 switch (type) {
4762 case RESPONSE_LAUNCH_TASKS:
4763 slurm_free_launch_tasks_response_msg(data);
4764 break;
4765 case MESSAGE_TASK_EXIT:
4766 slurm_free_task_exit_msg(data);
4767 break;
4768 case REQUEST_BUILD_INFO:
4769 slurm_free_last_update_msg(data);
4770 break;
4771 case REQUEST_JOB_INFO:
4772 slurm_free_job_info_request_msg(data);
4773 break;
4774 case REQUEST_NODE_INFO:
4775 slurm_free_node_info_request_msg(data);
4776 break;
4777 case REQUEST_NODE_INFO_SINGLE:
4778 slurm_free_node_info_single_msg(data);
4779 break;
4780 case REQUEST_PARTITION_INFO:
4781 slurm_free_part_info_request_msg(data);
4782 break;
4783 case MESSAGE_EPILOG_COMPLETE:
4784 slurm_free_epilog_complete_msg(data);
4785 break;
4786 case REQUEST_KILL_JOB:
4787 case REQUEST_CANCEL_JOB_STEP:
4788 case SRUN_STEP_SIGNAL:
4789 slurm_free_job_step_kill_msg(data);
4790 break;
4791 case REQUEST_COMPLETE_JOB_ALLOCATION:
4792 slurm_free_complete_job_allocation_msg(data);
4793 break;
4794 case REQUEST_COMPLETE_PROLOG:
4795 slurm_free_complete_prolog_msg(data);
4796 break;
4797 case REQUEST_COMPLETE_BATCH_SCRIPT:
4798 slurm_free_complete_batch_script_msg(data);
4799 break;
4800 case REQUEST_JOB_STEP_CREATE:
4801 slurm_free_job_step_create_request_msg(data);
4802 break;
4803 case REQUEST_JOB_STEP_INFO:
4804 slurm_free_job_step_info_request_msg(data);
4805 break;
4806 case RESPONSE_JOB_STEP_PIDS:
4807 slurm_free_job_step_pids(data);
4808 break;
4809 case REQUEST_LAUNCH_PROLOG:
4810 slurm_free_prolog_launch_msg(data);
4811 break;
4812 case REQUEST_RESOURCE_ALLOCATION:
4813 case REQUEST_JOB_WILL_RUN:
4814 case REQUEST_SUBMIT_BATCH_JOB:
4815 case REQUEST_UPDATE_JOB:
4816 slurm_free_job_desc_msg(data);
4817 break;
4818 case REQUEST_SIB_JOB_LOCK:
4819 case REQUEST_SIB_JOB_UNLOCK:
4820 case REQUEST_SIB_MSG:
4821 slurm_free_sib_msg(data);
4822 break;
4823 case REQUEST_SEND_DEP:
4824 slurm_free_dep_msg(data);
4825 break;
4826 case REQUEST_UPDATE_ORIGIN_DEP:
4827 slurm_free_dep_update_origin_msg(data);
4828 break;
4829 case RESPONSE_JOB_WILL_RUN:
4830 slurm_free_will_run_response_msg(data);
4831 break;
4832 case RESPONSE_SUBMIT_BATCH_JOB:
4833 slurm_free_submit_response_response_msg(data);
4834 break;
4835 case RESPONSE_ACCT_GATHER_UPDATE:
4836 slurm_free_acct_gather_node_resp_msg(data);
4837 break;
4838 case RESPONSE_NODE_REGISTRATION:
4839 slurm_free_node_reg_resp_msg(data);
4840 break;
4841 case REQUEST_NODE_REGISTRATION_STATUS:
4842 case MESSAGE_NODE_REGISTRATION_STATUS:
4843 slurm_free_node_registration_status_msg(data);
4844 break;
4845 case REQUEST_JOB_ALLOCATION_INFO:
4846 case REQUEST_JOB_END_TIME:
4847 case REQUEST_HET_JOB_ALLOC_INFO:
4848 slurm_free_job_alloc_info_msg(data);
4849 break;
4850 case REQUEST_JOB_SBCAST_CRED:
4851 slurm_free_step_alloc_info_msg(data);
4852 break;
4853 case REQUEST_SHUTDOWN:
4854 slurm_free_shutdown_msg(data);
4855 break;
4856 case REQUEST_UPDATE_FRONT_END:
4857 slurm_free_update_front_end_msg(data);
4858 break;
4859 case REQUEST_UPDATE_NODE:
4860 slurm_free_update_node_msg(data);
4861 break;
4862 case REQUEST_UPDATE_LAYOUT:
4863 slurm_free_update_layout_msg(data);
4864 break;
4865 case REQUEST_CREATE_PARTITION:
4866 case REQUEST_UPDATE_PARTITION:
4867 slurm_free_update_part_msg(data);
4868 break;
4869 case REQUEST_UPDATE_POWERCAP:
4870 slurm_free_powercap_info_msg(data);
4871 break;
4872 case REQUEST_DELETE_PARTITION:
4873 slurm_free_delete_part_msg(data);
4874 break;
4875 case REQUEST_CREATE_RESERVATION:
4876 case REQUEST_UPDATE_RESERVATION:
4877 slurm_free_resv_desc_msg(data);
4878 break;
4879 case REQUEST_DELETE_RESERVATION:
4880 case RESPONSE_CREATE_RESERVATION:
4881 slurm_free_resv_name_msg(data);
4882 break;
4883 case REQUEST_RESERVATION_INFO:
4884 slurm_free_resv_info_request_msg(data);
4885 break;
4886 case REQUEST_LAYOUT_INFO:
4887 slurm_free_layout_info_request_msg(data);
4888 break;
4889 case REQUEST_FRONT_END_INFO:
4890 slurm_free_front_end_info_request_msg(data);
4891 break;
4892 case REQUEST_SUSPEND:
4893 case SRUN_REQUEST_SUSPEND:
4894 slurm_free_suspend_msg(data);
4895 break;
4896 case REQUEST_SUSPEND_INT:
4897 slurm_free_suspend_int_msg(data);
4898 break;
4899 case REQUEST_TOP_JOB:
4900 slurm_free_top_job_msg(data);
4901 break;
4902 case REQUEST_AUTH_TOKEN:
4903 slurm_free_token_request_msg(data);
4904 break;
4905 case RESPONSE_AUTH_TOKEN:
4906 slurm_free_token_response_msg(data);
4907 break;
4908 case REQUEST_JOB_REQUEUE:
4909 slurm_free_requeue_msg(data);
4910 break;
4911 case REQUEST_BATCH_SCRIPT:
4912 case REQUEST_JOB_READY:
4913 case REQUEST_JOB_INFO_SINGLE:
4914 slurm_free_job_id_msg(data);
4915 break;
4916 case RESPONSE_BATCH_SCRIPT:
4917 slurm_free_batch_script_msg(data);
4918 break;
4919 case REQUEST_JOB_USER_INFO:
4920 slurm_free_job_user_id_msg(data);
4921 break;
4922 case REQUEST_SHARE_INFO:
4923 slurm_free_shares_request_msg(data);
4924 break;
4925 case RESPONSE_SHARE_INFO:
4926 slurm_free_shares_response_msg(data);
4927 break;
4928 case REQUEST_PRIORITY_FACTORS:
4929 slurm_free_priority_factors_request_msg(data);
4930 break;
4931 case RESPONSE_PRIORITY_FACTORS:
4932 slurm_free_priority_factors_response_msg(data);
4933 break;
4934 case REQUEST_STEP_COMPLETE:
4935 case REQUEST_STEP_COMPLETE_AGGR:
4936 slurm_free_step_complete_msg(data);
4937 break;
4938 case REQUEST_JOB_STEP_STAT:
4939 case REQUEST_JOB_STEP_PIDS:
4940 case REQUEST_STEP_LAYOUT:
4941 slurm_free_job_step_id_msg(data);
4942 break;
4943 case RESPONSE_JOB_STEP_STAT:
4944 slurm_free_job_step_stat(data);
4945 break;
4946 case REQUEST_BATCH_JOB_LAUNCH:
4947 slurm_free_job_launch_msg(data);
4948 break;
4949 case REQUEST_LAUNCH_TASKS:
4950 slurm_free_launch_tasks_request_msg(data);
4951 break;
4952 case TASK_USER_MANAGED_IO_STREAM:
4953 slurm_free_task_user_managed_io_stream_msg(data);
4954 break;
4955 case REQUEST_SIGNAL_TASKS:
4956 case REQUEST_TERMINATE_TASKS:
4957 slurm_free_signal_tasks_msg(data);
4958 break;
4959 case REQUEST_KILL_PREEMPTED:
4960 case REQUEST_KILL_TIMELIMIT:
4961 slurm_free_timelimit_msg(data);
4962 break;
4963 case REQUEST_REATTACH_TASKS:
4964 slurm_free_reattach_tasks_request_msg(data);
4965 break;
4966 case RESPONSE_REATTACH_TASKS:
4967 slurm_free_reattach_tasks_response_msg(data);
4968 break;
4969 case REQUEST_ABORT_JOB:
4970 case REQUEST_TERMINATE_JOB:
4971 slurm_free_kill_job_msg(data);
4972 break;
4973 case REQUEST_UPDATE_JOB_TIME:
4974 slurm_free_update_job_time_msg(data);
4975 break;
4976 case REQUEST_JOB_ID:
4977 slurm_free_job_id_request_msg(data);
4978 break;
4979 case REQUEST_CONFIG:
4980 slurm_free_config_request_msg(data);
4981 break;
4982 case REQUEST_RECONFIGURE_WITH_CONFIG:
4983 case RESPONSE_CONFIG:
4984 slurm_free_config_response_msg(data);
4985 break;
4986 case REQUEST_FILE_BCAST:
4987 slurm_free_file_bcast_msg(data);
4988 break;
4989 case RESPONSE_SLURM_RC:
4990 slurm_free_return_code_msg(data);
4991 break;
4992 case REQUEST_SET_DEBUG_FLAGS:
4993 slurm_free_set_debug_flags_msg(data);
4994 break;
4995 case REQUEST_SET_DEBUG_LEVEL:
4996 case REQUEST_SET_SCHEDLOG_LEVEL:
4997 slurm_free_set_debug_level_msg(data);
4998 break;
4999 case REQUEST_PING:
5000 case REQUEST_RECONFIGURE:
5001 case REQUEST_CONTROL:
5002 case REQUEST_CONTROL_STATUS:
5003 case REQUEST_TAKEOVER:
5004 case REQUEST_SHUTDOWN_IMMEDIATE:
5005 case RESPONSE_FORWARD_FAILED:
5006 case REQUEST_DAEMON_STATUS:
5007 case REQUEST_HEALTH_CHECK:
5008 case REQUEST_ACCT_GATHER_UPDATE:
5009 case ACCOUNTING_FIRST_REG:
5010 case ACCOUNTING_TRES_CHANGE_DB:
5011 case ACCOUNTING_NODES_CHANGE_DB:
5012 case REQUEST_TOPO_INFO:
5013 case REQUEST_BURST_BUFFER_INFO:
5014 case REQUEST_POWERCAP_INFO:
5015 case ACCOUNTING_REGISTER_CTLD:
5016 case REQUEST_FED_INFO:
5017 /* No body to free */
5018 break;
5019 case RESPONSE_FED_INFO:
5020 slurmdb_destroy_federation_rec(data);
5021 break;
5022 case REQUEST_PERSIST_INIT:
5023 slurm_persist_free_init_req_msg(data);
5024 break;
5025 case PERSIST_RC:
5026 slurm_persist_free_rc_msg(data);
5027 break;
5028 case REQUEST_REBOOT_NODES:
5029 slurm_free_reboot_msg(data);
5030 break;
5031 case ACCOUNTING_UPDATE_MSG:
5032 slurm_free_accounting_update_msg(data);
5033 break;
5034 case RESPONSE_TOPO_INFO:
5035 slurm_free_topo_info_msg(data);
5036 break;
5037 case REQUEST_UPDATE_JOB_STEP:
5038 slurm_free_update_step_msg(data);
5039 break;
5040 case RESPONSE_PING_SLURMD:
5041 slurm_free_ping_slurmd_resp(data);
5042 break;
5043 case RESPONSE_JOB_ARRAY_ERRORS:
5044 slurm_free_job_array_resp(data);
5045 break;
5046 case RESPONSE_BURST_BUFFER_INFO:
5047 slurm_free_burst_buffer_info_msg(data);
5048 break;
5049 case REQUEST_TRIGGER_GET:
5050 case RESPONSE_TRIGGER_GET:
5051 case REQUEST_TRIGGER_SET:
5052 case REQUEST_TRIGGER_CLEAR:
5053 case REQUEST_TRIGGER_PULL:
5054 slurm_free_trigger_msg(data);
5055 break;
5056 case MESSAGE_COMPOSITE:
5057 case RESPONSE_MESSAGE_COMPOSITE:
5058 slurm_free_composite_msg(data);
5059 break;
5060 case REQUEST_JOB_NOTIFY:
5061 slurm_free_job_notify_msg(data);
5062 break;
5063 case REQUEST_STATS_INFO:
5064 slurm_free_stats_info_request_msg(data);
5065 break;
5066 case REQUEST_LICENSE_INFO:
5067 slurm_free_license_info_request_msg(data);
5068 break;
5069 case REQUEST_ACCT_GATHER_ENERGY:
5070 slurm_free_acct_gather_energy_req_msg(data);
5071 break;
5072 case REQUEST_FORWARD_DATA:
5073 slurm_free_forward_data_msg(data);
5074 break;
5075 case REQUEST_NETWORK_CALLERID:
5076 slurm_free_network_callerid_msg(data);
5077 break;
5078 case SRUN_JOB_COMPLETE:
5079 slurm_free_srun_job_complete_msg(data);
5080 break;
5081 case SRUN_PING:
5082 slurm_free_srun_ping_msg(data);
5083 break;
5084 case SRUN_EXEC:
5085 slurm_free_srun_exec_msg(data);
5086 break;
5087 case SRUN_TIMEOUT:
5088 slurm_free_srun_timeout_msg(data);
5089 break;
5090 case SRUN_USER_MSG:
5091 slurm_free_srun_user_msg(data);
5092 break;
5093 case SRUN_NODE_FAIL:
5094 slurm_free_srun_node_fail_msg(data);
5095 break;
5096 case SRUN_STEP_MISSING:
5097 slurm_free_srun_step_missing_msg(data);
5098 break;
5099 case SRUN_NET_FORWARD:
5100 slurm_free_net_forward_msg(data);
5101 break;
5102 case PMI_KVS_GET_REQ:
5103 slurm_free_get_kvs_msg(data);
5104 break;
5105 case PMI_KVS_GET_RESP:
5106 case PMI_KVS_PUT_REQ:
5107 slurm_free_kvs_comm_set(data);
5108 break;
5109 case RESPONSE_RESOURCE_ALLOCATION:
5110 slurm_free_resource_allocation_response_msg(data);
5111 break;
5112 case REQUEST_ASSOC_MGR_INFO:
5113 slurm_free_assoc_mgr_info_request_msg(data);
5114 break;
5115 case REQUEST_EVENT_LOG:
5116 slurm_free_event_log_msg(data);
5117 break;
5118 case REQUEST_CTLD_MULT_MSG:
5119 case RESPONSE_CTLD_MULT_MSG:
5120 slurm_free_ctld_multi_msg(data);
5121 break;
5122 case RESPONSE_JOB_INFO:
5123 slurm_free_job_info(data);
5124 break;
5125 case REQUEST_HET_JOB_ALLOCATION:
5126 case REQUEST_SUBMIT_BATCH_HET_JOB:
5127 case RESPONSE_HET_JOB_ALLOCATION:
5128 FREE_NULL_LIST(data);
5129 break;
5130 case REQUEST_SET_FS_DAMPENING_FACTOR:
5131 slurm_free_set_fs_dampening_factor_msg(data);
5132 break;
5133 case RESPONSE_CONTROL_STATUS:
5134 slurm_free_control_status_msg(data);
5135 break;
5136 case REQUEST_BURST_BUFFER_STATUS:
5137 slurm_free_bb_status_req_msg(data);
5138 break;
5139 case RESPONSE_BURST_BUFFER_STATUS:
5140 slurm_free_bb_status_resp_msg(data);
5141 break;
5142 default:
5143 error("invalid type trying to be freed %u", type);
5144 break;
5145 }
5146 return SLURM_SUCCESS;
5147 }
5148
slurm_get_return_code(slurm_msg_type_t type,void * data)5149 extern uint32_t slurm_get_return_code(slurm_msg_type_t type, void *data)
5150 {
5151 uint32_t rc = 0;
5152
5153 switch (type) {
5154 case MESSAGE_EPILOG_COMPLETE:
5155 rc = ((epilog_complete_msg_t *)data)->return_code;
5156 break;
5157 case RESPONSE_JOB_STEP_STAT:
5158 rc = ((job_step_stat_t *)data)->return_code;
5159 break;
5160 case RESPONSE_REATTACH_TASKS:
5161 rc = ((reattach_tasks_response_msg_t *)data)->return_code;
5162 break;
5163 case RESPONSE_JOB_ID:
5164 rc = ((job_id_response_msg_t *)data)->return_code;
5165 break;
5166 case RESPONSE_SLURM_RC:
5167 rc = ((return_code_msg_t *)data)->return_code;
5168 break;
5169 case RESPONSE_PING_SLURMD:
5170 rc = SLURM_SUCCESS;
5171 break;
5172 case RESPONSE_ACCT_GATHER_UPDATE:
5173 rc = SLURM_SUCCESS;
5174 break;
5175 case RESPONSE_FORWARD_FAILED:
5176 /* There may be other reasons for the failure, but
5177 * this may be a slurm_msg_t data type lacking the
5178 * err field found in ret_data_info_t data type */
5179 rc = SLURM_COMMUNICATIONS_CONNECTION_ERROR;
5180 break;
5181 default:
5182 error("don't know the rc for type %u returning %u", type, rc);
5183 break;
5184 }
5185 return rc;
5186 }
5187
slurm_free_job_notify_msg(job_notify_msg_t * msg)5188 extern void slurm_free_job_notify_msg(job_notify_msg_t * msg)
5189 {
5190 if (msg) {
5191 xfree(msg->message);
5192 xfree(msg);
5193 }
5194 }
5195
slurm_free_ctld_multi_msg(ctld_list_msg_t * msg)5196 extern void slurm_free_ctld_multi_msg(ctld_list_msg_t *msg)
5197 {
5198 if (msg) {
5199 FREE_NULL_LIST(msg->my_list);
5200 xfree(msg);
5201 }
5202 }
5203
5204 /*
5205 * Sanitize spank_job_env by prepending "SPANK_" to all entries,
5206 * thus rendering them harmless in environment of scripts and
5207 * programs running with root privileges.
5208 */
valid_spank_job_env(char ** spank_job_env,uint32_t spank_job_env_size,uid_t uid)5209 extern bool valid_spank_job_env(char **spank_job_env,
5210 uint32_t spank_job_env_size, uid_t uid)
5211 {
5212 int i;
5213 char *entry;
5214
5215 for (i=0; i<spank_job_env_size; i++) {
5216 if (!xstrncmp(spank_job_env[i], "SPANK_", 6))
5217 continue;
5218 entry = spank_job_env[i];
5219 spank_job_env[i] = xstrdup_printf ("SPANK_%s", entry);
5220 xfree (entry);
5221 }
5222 return true;
5223 }
5224
5225 /* slurm_free_license_info()
5226 *
5227 * Free the license info returned previously
5228 * from the controller.
5229 */
5230 extern void
slurm_free_license_info_msg(license_info_msg_t * msg)5231 slurm_free_license_info_msg(license_info_msg_t *msg)
5232 {
5233 int cc;
5234
5235 if (msg == NULL)
5236 return;
5237
5238 if (msg->lic_array) {
5239 for (cc = 0; cc < msg->num_lic; cc++) {
5240 xfree(msg->lic_array[cc].name);
5241 }
5242 xfree(msg->lic_array);
5243 }
5244 xfree(msg);
5245 }
slurm_free_license_info_request_msg(license_info_request_msg_t * msg)5246 extern void slurm_free_license_info_request_msg(license_info_request_msg_t *msg)
5247 {
5248 xfree(msg);
5249 }
5250
5251 /*
5252 * rpc_num2string()
5253 *
5254 * Given a protocol opcode return its string
5255 * description mapping the slurm_msg_type_t
5256 * to its name.
5257 */
5258 char *
rpc_num2string(uint16_t opcode)5259 rpc_num2string(uint16_t opcode)
5260 {
5261 static char buf[16];
5262
5263 switch (opcode) {
5264 case REQUEST_NODE_REGISTRATION_STATUS: /* 1001 */
5265 return "REQUEST_NODE_REGISTRATION_STATUS";
5266 case MESSAGE_NODE_REGISTRATION_STATUS:
5267 return "MESSAGE_NODE_REGISTRATION_STATUS";
5268 case REQUEST_RECONFIGURE:
5269 return "REQUEST_RECONFIGURE";
5270 case REQUEST_RECONFIGURE_WITH_CONFIG:
5271 return "REQUEST_RECONFIGURE_WITH_CONFIG";
5272 case REQUEST_SHUTDOWN: /* 1005 */
5273 return "REQUEST_SHUTDOWN";
5274 case REQUEST_SHUTDOWN_IMMEDIATE:
5275 return "REQUEST_SHUTDOWN_IMMEDIATE";
5276
5277 case REQUEST_PING: /* 1008 */
5278 return "REQUEST_PING";
5279 case REQUEST_CONTROL:
5280 return "REQUEST_CONTROL";
5281 case REQUEST_SET_DEBUG_LEVEL:
5282 return "REQUEST_SET_DEBUG_LEVEL"; /* 1010 */
5283 case REQUEST_HEALTH_CHECK:
5284 return "REQUEST_HEALTH_CHECK";
5285 case REQUEST_TAKEOVER:
5286 return "REQUEST_TAKEOVER";
5287 case REQUEST_SET_SCHEDLOG_LEVEL:
5288 return "REQUEST_SET_SCHEDLOG_LEVEL";
5289 case REQUEST_SET_DEBUG_FLAGS:
5290 return "REQUEST_SET_DEBUG_FLAGS";
5291 case REQUEST_REBOOT_NODES:
5292 return "REQUEST_REBOOT_NODES";
5293 case RESPONSE_PING_SLURMD:
5294 return "RESPONSE_PING_SLURMD";
5295 case REQUEST_ACCT_GATHER_UPDATE:
5296 return "REQUEST_ACCT_GATHER_UPDATE";
5297 case RESPONSE_ACCT_GATHER_UPDATE:
5298 return "RESPONSE_ACCT_GATHER_UPDATE";
5299 case REQUEST_ACCT_GATHER_ENERGY:
5300 return "REQUEST_ACCT_GATHER_ENERGY"; /* 1020 */
5301 case RESPONSE_ACCT_GATHER_ENERGY:
5302 return "RESPONSE_ACCT_GATHER_ENERGY";
5303 case REQUEST_LICENSE_INFO:
5304 return "REQUEST_LICENSE_INFO";
5305 case RESPONSE_LICENSE_INFO:
5306 return "RESPONSE_LICENSE_INFO";
5307 case REQUEST_SET_FS_DAMPENING_FACTOR:
5308 return "REQUEST_SET_FS_DAMPENING_FACTOR,";
5309
5310 case REQUEST_BUILD_INFO: /* 2001 */
5311 return "REQUEST_BUILD_INFO";
5312 case RESPONSE_BUILD_INFO:
5313 return "RESPONSE_BUILD_INFO";
5314 case REQUEST_JOB_INFO:
5315 return "REQUEST_JOB_INFO";
5316 case RESPONSE_JOB_INFO:
5317 return "RESPONSE_JOB_INFO";
5318 case REQUEST_JOB_STEP_INFO:
5319 return "REQUEST_JOB_STEP_INFO";
5320 case RESPONSE_JOB_STEP_INFO:
5321 return "RESPONSE_JOB_STEP_INFO";
5322 case REQUEST_NODE_INFO:
5323 return "REQUEST_NODE_INFO";
5324 case RESPONSE_NODE_INFO:
5325 return "RESPONSE_NODE_INFO";
5326 case REQUEST_PARTITION_INFO:
5327 return "REQUEST_PARTITION_INFO";
5328 case RESPONSE_PARTITION_INFO:
5329 return "RESPONSE_PARTITION_INFO"; /* 2010 */
5330
5331 case REQUEST_JOB_ID: /* 2013 */
5332 return "REQUEST_JOB_ID";
5333 case RESPONSE_JOB_ID:
5334 return "RESPONSE_JOB_ID";
5335 case REQUEST_CONFIG:
5336 return "REQUEST_CONFIG";
5337 case RESPONSE_CONFIG:
5338 return "RESPONSE_CONFIG";
5339 case REQUEST_TRIGGER_SET: /* 2017 */
5340 return "REQUEST_TRIGGER_SET";
5341 case REQUEST_TRIGGER_GET:
5342 return "REQUEST_TRIGGER_GET";
5343 case REQUEST_TRIGGER_CLEAR:
5344 return "REQUEST_TRIGGER_CLEAR";
5345 case RESPONSE_TRIGGER_GET:
5346 return "RESPONSE_TRIGGER_GET"; /* 2020 */
5347 case REQUEST_JOB_INFO_SINGLE:
5348 return "REQUEST_JOB_INFO_SINGLE";
5349 case REQUEST_SHARE_INFO:
5350 return "REQUEST_SHARE_INFO";
5351 case RESPONSE_SHARE_INFO:
5352 return "RESPONSE_SHARE_INFO";
5353 case REQUEST_RESERVATION_INFO:
5354 return "REQUEST_RESERVATION_INFO";
5355 case RESPONSE_RESERVATION_INFO:
5356 return "RESPONSE_RESERVATION_INFO";
5357 case REQUEST_PRIORITY_FACTORS:
5358 return "REQUEST_PRIORITY_FACTORS";
5359 case RESPONSE_PRIORITY_FACTORS:
5360 return "RESPONSE_PRIORITY_FACTORS";
5361 case REQUEST_TOPO_INFO:
5362 return "REQUEST_TOPO_INFO";
5363 case RESPONSE_TOPO_INFO:
5364 return "RESPONSE_TOPO_INFO";
5365 case REQUEST_TRIGGER_PULL:
5366 return "REQUEST_TRIGGER_PULL"; /* 2030 */
5367 case REQUEST_FRONT_END_INFO:
5368 return "REQUEST_FRONT_END_INFO";
5369 case RESPONSE_FRONT_END_INFO:
5370 return "RESPONSE_FRONT_END_INFO";
5371
5372 case REQUEST_STATS_INFO: /* 2035 */
5373 return "REQUEST_STATS_INFO";
5374 case RESPONSE_STATS_INFO:
5375 return "RESPONSE_STATS_INFO";
5376 case REQUEST_BURST_BUFFER_INFO:
5377 return "REQUEST_BURST_BUFFER_INFO";
5378 case RESPONSE_BURST_BUFFER_INFO:
5379 return "RESPONSE_BURST_BUFFER_INFO";
5380 case REQUEST_JOB_USER_INFO:
5381 return "REQUEST_JOB_USER_INFO";
5382 case REQUEST_NODE_INFO_SINGLE: /* 2040 */
5383 return "REQUEST_NODE_INFO_SINGLE";
5384 case REQUEST_POWERCAP_INFO:
5385 return "REQUEST_POWERCAP_INFO";
5386 case RESPONSE_POWERCAP_INFO:
5387 return "RESPONSE_POWERCAP_INFO";
5388 case REQUEST_ASSOC_MGR_INFO:
5389 return "REQUEST_ASSOC_MGR_INFO";
5390 case RESPONSE_ASSOC_MGR_INFO:
5391 return "RESPONSE_ASSOC_MGR_INFO";
5392 case REQUEST_EVENT_LOG:
5393 return "REQUEST_EVENT_LOG";
5394 case REQUEST_LAYOUT_INFO:
5395 return "REQUEST_LAYOUT_INFO";
5396 case RESPONSE_LAYOUT_INFO:
5397 return "RESPONSE_LAYOUT_INFO";
5398 case REQUEST_FED_INFO:
5399 return "REQUEST_FED_INFO";
5400 case RESPONSE_FED_INFO:
5401 return "RESPONSE_FED_INFO";
5402 case REQUEST_BATCH_SCRIPT:
5403 return "REQUEST_BATCH_SCRIPT";
5404 case RESPONSE_BATCH_SCRIPT:
5405 return "RESPONSE_BATCH_SCRIPT";
5406 case REQUEST_CONTROL_STATUS:
5407 return "REQUEST_CONTROL_STATUS";
5408 case RESPONSE_CONTROL_STATUS:
5409 return "RESPONSE_CONTROL_STATUS";
5410 case REQUEST_BURST_BUFFER_STATUS:
5411 return "REQUEST_BURST_BUFFER_STATUS";
5412 case RESPONSE_BURST_BUFFER_STATUS:
5413 return "RESPONSE_BURST_BUFFER_STATUS";
5414
5415 case REQUEST_UPDATE_JOB: /* 3001 */
5416 return "REQUEST_UPDATE_JOB";
5417 case REQUEST_UPDATE_NODE:
5418 return "REQUEST_UPDATE_NODE";
5419 case REQUEST_CREATE_PARTITION:
5420 return "REQUEST_CREATE_PARTITION";
5421 case REQUEST_DELETE_PARTITION:
5422 return "REQUEST_DELETE_PARTITION";
5423 case REQUEST_UPDATE_PARTITION:
5424 return "REQUEST_UPDATE_PARTITION";
5425 case REQUEST_CREATE_RESERVATION:
5426 return "REQUEST_CREATE_RESERVATION";
5427 case RESPONSE_CREATE_RESERVATION:
5428 return "RESPONSE_CREATE_RESERVATION";
5429 case REQUEST_DELETE_RESERVATION:
5430 return "REQUEST_DELETE_RESERVATION";
5431 case REQUEST_UPDATE_RESERVATION:
5432 return "REQUEST_UPDATE_RESERVATION";
5433 case REQUEST_UPDATE_FRONT_END: /* 3011 */
5434 return "REQUEST_UPDATE_FRONT_END";
5435 case REQUEST_UPDATE_LAYOUT:
5436 return "REQUEST_UPDATE_LAYOUT";
5437 case REQUEST_UPDATE_POWERCAP:
5438 return "REQUEST_UPDATE_POWERCAP";
5439
5440 case REQUEST_RESOURCE_ALLOCATION: /* 4001 */
5441 return "REQUEST_RESOURCE_ALLOCATION";
5442 case RESPONSE_RESOURCE_ALLOCATION:
5443 return "RESPONSE_RESOURCE_ALLOCATION";
5444 case REQUEST_SUBMIT_BATCH_JOB:
5445 return "REQUEST_SUBMIT_BATCH_JOB";
5446 case RESPONSE_SUBMIT_BATCH_JOB:
5447 return "RESPONSE_SUBMIT_BATCH_JOB";
5448 case REQUEST_BATCH_JOB_LAUNCH:
5449 return "REQUEST_BATCH_JOB_LAUNCH";
5450 case REQUEST_CANCEL_JOB:
5451 return "REQUEST_CANCEL_JOB";
5452
5453 case REQUEST_JOB_WILL_RUN: /* 4012 */
5454 return "REQUEST_JOB_WILL_RUN";
5455 case RESPONSE_JOB_WILL_RUN:
5456 return "RESPONSE_JOB_WILL_RUN";
5457 case REQUEST_JOB_ALLOCATION_INFO:
5458 return "REQUEST_JOB_ALLOCATION_INFO";
5459 case RESPONSE_JOB_ALLOCATION_INFO:
5460 return "RESPONSE_JOB_ALLOCATION_INFO";
5461 case REQUEST_HET_JOB_ALLOCATION:
5462 return "REQUEST_HET_JOB_ALLOCATION";
5463 case RESPONSE_HET_JOB_ALLOCATION:
5464 return "RESPONSE_HET_JOB_ALLOCATION";
5465 case REQUEST_UPDATE_JOB_TIME:
5466 return "REQUEST_UPDATE_JOB_TIME";
5467 case REQUEST_JOB_READY:
5468 return "REQUEST_JOB_READY";
5469 case RESPONSE_JOB_READY: /* 4020 */
5470 return "RESPONSE_JOB_READY";
5471 case REQUEST_JOB_END_TIME:
5472 return "REQUEST_JOB_END_TIME";
5473 case REQUEST_JOB_NOTIFY:
5474 return "REQUEST_JOB_NOTIFY";
5475 case REQUEST_JOB_SBCAST_CRED:
5476 return "REQUEST_JOB_SBCAST_CRED";
5477 case RESPONSE_JOB_SBCAST_CRED:
5478 return "RESPONSE_JOB_SBCAST_CRED";
5479
5480 case REQUEST_SIB_JOB_LOCK: /* 4050 */
5481 return "REQUEST_SIB_JOB_LOCK";
5482 case REQUEST_SIB_JOB_UNLOCK:
5483 return "REQUEST_SIB_JOB_UNLOCK";
5484 case REQUEST_SEND_DEP:
5485 return "REQUEST_SEND_DEP";
5486 case REQUEST_UPDATE_ORIGIN_DEP:
5487 return "REQUEST_UPDATE_ORIGIN_DEP";
5488 case REQUEST_CTLD_MULT_MSG:
5489 return "REQUEST_CTLD_MULT_MSG";
5490 case RESPONSE_CTLD_MULT_MSG:
5491 return "RESPONSE_CTLD_MULT_MSG";
5492 case REQUEST_SIB_MSG:
5493 return "REQUEST_SIB_MSG";
5494 case REQUEST_HET_JOB_ALLOC_INFO:
5495 return "REQUEST_HET_JOB_ALLOC_INFO";
5496 case REQUEST_SUBMIT_BATCH_HET_JOB:
5497 return "REQUEST_SUBMIT_BATCH_HET_JOB";
5498
5499 case REQUEST_JOB_STEP_CREATE: /* 5001 */
5500 return "REQUEST_JOB_STEP_CREATE";
5501 case RESPONSE_JOB_STEP_CREATE:
5502 return "RESPONSE_JOB_STEP_CREATE";
5503
5504 case REQUEST_CANCEL_JOB_STEP: /* 5005 */
5505 return "REQUEST_CANCEL_JOB_STEP";
5506
5507 case REQUEST_UPDATE_JOB_STEP: /* 5007 */
5508 return "REQUEST_UPDATE_JOB_STEP";
5509
5510 case REQUEST_SUSPEND: /* 5014 */
5511 return "REQUEST_SUSPEND";
5512 case REQUEST_STEP_COMPLETE:
5513 return "REQUEST_STEP_COMPLETE";
5514 case REQUEST_COMPLETE_JOB_ALLOCATION:
5515 return "REQUEST_COMPLETE_JOB_ALLOCATION";
5516 case REQUEST_COMPLETE_BATCH_SCRIPT:
5517 return "REQUEST_COMPLETE_BATCH_SCRIPT";
5518 case REQUEST_JOB_STEP_STAT:
5519 return "REQUEST_JOB_STEP_STAT";
5520 case RESPONSE_JOB_STEP_STAT: /* 5020 */
5521 return "RESPONSE_JOB_STEP_STAT";
5522 case REQUEST_STEP_LAYOUT:
5523 return "REQUEST_STEP_LAYOUT";
5524 case RESPONSE_STEP_LAYOUT:
5525 return "RESPONSE_STEP_LAYOUT";
5526 case REQUEST_JOB_REQUEUE:
5527 return "REQUEST_JOB_REQUEUE";
5528 case REQUEST_DAEMON_STATUS:
5529 return "REQUEST_DAEMON_STATUS";
5530 case RESPONSE_SLURMD_STATUS:
5531 return "RESPONSE_SLURMD_STATUS";
5532
5533 case REQUEST_JOB_STEP_PIDS: /* 5027 */
5534 return "REQUEST_JOB_STEP_PIDS";
5535 case RESPONSE_JOB_STEP_PIDS:
5536 return "RESPONSE_JOB_STEP_PIDS";
5537 case REQUEST_FORWARD_DATA:
5538 return "REQUEST_FORWARD_DATA";
5539
5540 case REQUEST_SUSPEND_INT: /* 5031 */
5541 return "REQUEST_SUSPEND_INT";
5542 case REQUEST_KILL_JOB:
5543 return "REQUEST_KILL_JOB";
5544
5545 case RESPONSE_JOB_ARRAY_ERRORS: /* 5034 */
5546 return "RESPONSE_JOB_ARRAY_ERRORS";
5547 case REQUEST_NETWORK_CALLERID:
5548 return "REQUEST_NETWORK_CALLERID";
5549 case RESPONSE_NETWORK_CALLERID:
5550 return "RESPONSE_NETWORK_CALLERID";
5551 case REQUEST_STEP_COMPLETE_AGGR:
5552 return "REQUEST_STEP_COMPLETE_AGGR";
5553 case REQUEST_TOP_JOB:
5554 return "REQUEST_TOP_JOB";
5555 case REQUEST_AUTH_TOKEN:
5556 return "REQUEST_AUTH_TOKEN";
5557 case RESPONSE_AUTH_TOKEN:
5558 return "RESPONSE_AUTH_TOKEN";
5559
5560 case REQUEST_LAUNCH_TASKS: /* 6001 */
5561 return "REQUEST_LAUNCH_TASKS";
5562 case RESPONSE_LAUNCH_TASKS:
5563 return "RESPONSE_LAUNCH_TASKS";
5564 case MESSAGE_TASK_EXIT:
5565 return "MESSAGE_TASK_EXIT";
5566 case REQUEST_SIGNAL_TASKS:
5567 return "REQUEST_SIGNAL_TASKS";
5568
5569 case REQUEST_TERMINATE_TASKS: /* 6006 */
5570 return "REQUEST_TERMINATE_TASKS";
5571 case REQUEST_REATTACH_TASKS:
5572 return "REQUEST_REATTACH_TASKS";
5573 case RESPONSE_REATTACH_TASKS:
5574 return "RESPONSE_REATTACH_TASKS";
5575 case REQUEST_KILL_TIMELIMIT:
5576 return "REQUEST_KILL_TIMELIMIT";
5577
5578 case REQUEST_TERMINATE_JOB: /* 6011 */
5579 return "REQUEST_TERMINATE_JOB";
5580 case MESSAGE_EPILOG_COMPLETE:
5581 return "MESSAGE_EPILOG_COMPLETE";
5582 case REQUEST_ABORT_JOB:
5583 return "REQUEST_ABORT_JOB";
5584 case REQUEST_FILE_BCAST:
5585 return "REQUEST_FILE_BCAST";
5586 case TASK_USER_MANAGED_IO_STREAM:
5587 return "TASK_USER_MANAGED_IO_STREAM";
5588 case REQUEST_KILL_PREEMPTED:
5589 return "REQUEST_KILL_PREEMPTED";
5590 case REQUEST_LAUNCH_PROLOG:
5591 return "REQUEST_LAUNCH_PROLOG";
5592 case REQUEST_COMPLETE_PROLOG:
5593 return "REQUEST_COMPLETE_PROLOG";
5594 case RESPONSE_PROLOG_EXECUTING: /* 6019 */
5595 return "RESPONSE_PROLOG_EXECUTING";
5596
5597 case SRUN_PING: /* 7001 */
5598 return "SRUN_PING";
5599 case SRUN_TIMEOUT:
5600 return "SRUN_TIMEOUT";
5601 case SRUN_NODE_FAIL:
5602 return "SRUN_NODE_FAIL";
5603 case SRUN_JOB_COMPLETE:
5604 return "SRUN_JOB_COMPLETE";
5605 case SRUN_USER_MSG:
5606 return "SRUN_USER_MSG";
5607 case SRUN_EXEC:
5608 return "SRUN_EXEC";
5609 case SRUN_STEP_MISSING:
5610 return "SRUN_STEP_MISSING";
5611 case SRUN_REQUEST_SUSPEND:
5612 return "SRUN_REQUEST_SUSPEND";
5613 case SRUN_STEP_SIGNAL:
5614 return "SRUN_STEP_SIGNAL";
5615 case SRUN_NET_FORWARD:
5616 return "SRUN_NET_FORWARD";
5617
5618 case PMI_KVS_PUT_REQ: /* 7201 */
5619 return "PMI_KVS_PUT_REQ";
5620
5621 case PMI_KVS_GET_REQ: /* 7203 */
5622 return "PMI_KVS_GET_REQ";
5623 case PMI_KVS_GET_RESP:
5624 return "PMI_KVS_GET_RESP";
5625
5626 case RESPONSE_SLURM_RC: /* 8001 */
5627 return "RESPONSE_SLURM_RC";
5628 case RESPONSE_SLURM_RC_MSG:
5629 return "RESPONSE_SLURM_RC_MSG";
5630 case RESPONSE_SLURM_REROUTE_MSG:
5631 return "RESPONSE_SLURM_REROUTE_MSG";
5632
5633 case RESPONSE_FORWARD_FAILED: /* 9001 */
5634 return "RESPONSE_FORWARD_FAILED";
5635
5636 case ACCOUNTING_UPDATE_MSG: /* 10001 */
5637 return "ACCOUNTING_UPDATE_MSG";
5638 case ACCOUNTING_FIRST_REG:
5639 return "ACCOUNTING_FIRST_REG";
5640 case ACCOUNTING_REGISTER_CTLD:
5641 return "ACCOUNTING_REGISTER_CTLD";
5642 case ACCOUNTING_TRES_CHANGE_DB:
5643 return "ACCOUNTING_TRES_CHANGE_DB";
5644 case ACCOUNTING_NODES_CHANGE_DB:
5645 return "ACCOUNTING_NODES_CHANGE_DB";
5646
5647 case MESSAGE_COMPOSITE: /* 110001 */
5648 return "MESSAGE_COMPOSITE";
5649 case RESPONSE_MESSAGE_COMPOSITE:
5650 return "RESPONSE_MESSAGE_COMPOSITE";
5651
5652 case REQUEST_PERSIST_INIT:
5653 return "REQUEST_PERSIST_INIT";
5654 case PERSIST_RC:
5655 return "PERSIST_RC";
5656
5657 default:
5658 (void) snprintf(buf, sizeof(buf), "%u", opcode);
5659 return buf;
5660 }
5661 }
5662
5663 extern char *
slurm_bb_flags2str(uint32_t bb_flags)5664 slurm_bb_flags2str(uint32_t bb_flags)
5665 {
5666 static char bb_str[1024];
5667
5668 bb_str[0] = '\0';
5669 if (bb_flags & BB_FLAG_DISABLE_PERSISTENT) {
5670 if (bb_str[0])
5671 strcat(bb_str, ",");
5672 strcat(bb_str, "DisablePersistent");
5673 }
5674 if (bb_flags & BB_FLAG_EMULATE_CRAY) {
5675 if (bb_str[0])
5676 strcat(bb_str, ",");
5677 strcat(bb_str, "EmulateCray");
5678 }
5679 if (bb_flags & BB_FLAG_ENABLE_PERSISTENT) {
5680 if (bb_str[0])
5681 strcat(bb_str, ",");
5682 strcat(bb_str, "EnablePersistent");
5683 }
5684 if (bb_flags & BB_FLAG_PRIVATE_DATA) {
5685 if (bb_str[0])
5686 strcat(bb_str, ",");
5687 strcat(bb_str, "PrivateData");
5688 }
5689 if (bb_flags & BB_FLAG_SET_EXEC_HOST) {
5690 if (bb_str[0])
5691 strcat(bb_str, ",");
5692 strcat(bb_str, "SetExecHost");
5693 }
5694 if (bb_flags & BB_FLAG_TEARDOWN_FAILURE) {
5695 if (bb_str[0])
5696 strcat(bb_str, ",");
5697 strcat(bb_str, "TeardownFailure");
5698 }
5699
5700 return bb_str;
5701 }
5702
5703 extern uint32_t
slurm_bb_str2flags(char * bb_str)5704 slurm_bb_str2flags(char *bb_str)
5705 {
5706 uint32_t bb_flags = 0;
5707
5708 if (bb_str && strstr(bb_str, "DisablePersistent"))
5709 bb_flags |= BB_FLAG_DISABLE_PERSISTENT;
5710 if (bb_str && strstr(bb_str, "EmulateCray"))
5711 bb_flags |= BB_FLAG_EMULATE_CRAY;
5712 if (bb_str && strstr(bb_str, "EnablePersistent"))
5713 bb_flags |= BB_FLAG_ENABLE_PERSISTENT;
5714 if (bb_str && strstr(bb_str, "PrivateData"))
5715 bb_flags |= BB_FLAG_PRIVATE_DATA;
5716 if (bb_str && strstr(bb_str, "SetExecHost"))
5717 bb_flags |= BB_FLAG_SET_EXEC_HOST;
5718 if (bb_str && strstr(bb_str, "TeardownFailure"))
5719 bb_flags |= BB_FLAG_TEARDOWN_FAILURE;
5720
5721 return bb_flags;
5722 }
5723
5724 extern void
slurm_free_assoc_mgr_info_msg(assoc_mgr_info_msg_t * msg)5725 slurm_free_assoc_mgr_info_msg(assoc_mgr_info_msg_t *msg)
5726 {
5727 if (!msg)
5728 return;
5729
5730 FREE_NULL_LIST(msg->assoc_list);
5731 FREE_NULL_LIST(msg->qos_list);
5732 if (msg->tres_names) {
5733 int i;
5734 for (i=0; i<msg->tres_cnt; i++)
5735 xfree(msg->tres_names[i]);
5736 xfree(msg->tres_names);
5737 }
5738 FREE_NULL_LIST(msg->user_list);
5739 xfree(msg);
5740 }
5741
slurm_free_assoc_mgr_info_request_members(assoc_mgr_info_request_msg_t * msg)5742 extern void slurm_free_assoc_mgr_info_request_members(
5743 assoc_mgr_info_request_msg_t *msg)
5744 {
5745 if (!msg)
5746 return;
5747
5748 FREE_NULL_LIST(msg->acct_list);
5749 FREE_NULL_LIST(msg->qos_list);
5750 FREE_NULL_LIST(msg->user_list);
5751 }
5752
slurm_free_assoc_mgr_info_request_msg(assoc_mgr_info_request_msg_t * msg)5753 extern void slurm_free_assoc_mgr_info_request_msg(
5754 assoc_mgr_info_request_msg_t *msg)
5755 {
5756 if (!msg)
5757 return;
5758
5759 slurm_free_assoc_mgr_info_request_members(msg);
5760 xfree(msg);
5761 }
5762
parse_part_enforce_type(char * enforce_part_type,uint16_t * param)5763 extern int parse_part_enforce_type(char *enforce_part_type, uint16_t *param)
5764 {
5765 int rc = SLURM_SUCCESS;
5766
5767 char *value = xstrdup(enforce_part_type);
5768
5769 if (!xstrcasecmp(value, "yes")
5770 || !xstrcasecmp(value, "up")
5771 || !xstrcasecmp(value, "true")
5772 || !xstrcasecmp(value, "1") || !xstrcasecmp(value, "any")) {
5773 *param = PARTITION_ENFORCE_ANY;
5774 } else if (!xstrcasecmp(value, "no")
5775 || !xstrcasecmp(value, "down")
5776 || !xstrcasecmp(value, "false")
5777 || !xstrcasecmp(value, "0")) {
5778 *param = PARTITION_ENFORCE_NONE;
5779 } else if (!xstrcasecmp(value, "all")) {
5780 *param = PARTITION_ENFORCE_ALL;
5781 } else {
5782 error("Bad EnforcePartLimits: %s\n", value);
5783 rc = SLURM_ERROR;
5784 }
5785
5786 xfree(value);
5787 return rc;
5788 }
5789
parse_part_enforce_type_2str(uint16_t type)5790 extern char * parse_part_enforce_type_2str (uint16_t type)
5791 {
5792 static char type_str[1024];
5793
5794 if (type == PARTITION_ENFORCE_NONE) {
5795 strcpy(type_str, "NO");
5796 } else if (type == PARTITION_ENFORCE_ANY) {
5797 strcpy(type_str, "ANY");
5798 } else if (type == PARTITION_ENFORCE_ALL) {
5799 strcpy(type_str, "ALL");
5800 }
5801
5802 return type_str;
5803 }
5804
5805 /* Return true if this cluster_name is in a federation */
cluster_in_federation(void * ptr,char * cluster_name)5806 extern bool cluster_in_federation(void *ptr, char *cluster_name)
5807 {
5808 slurmdb_federation_rec_t *fed = (slurmdb_federation_rec_t *) ptr;
5809 slurmdb_cluster_rec_t *cluster;
5810 ListIterator iter;
5811 bool status = false;
5812
5813 if (!fed || !fed->cluster_list) /* NULL if no federations */
5814 return status;
5815 iter = list_iterator_create(fed->cluster_list);
5816 while ((cluster = (slurmdb_cluster_rec_t *) list_next(iter))) {
5817 if (!xstrcasecmp(cluster->name, cluster_name)) {
5818 status = true;
5819 break;
5820 }
5821 }
5822 list_iterator_destroy(iter);
5823 return status;
5824 }
5825
5826 /* Find where cluster_name nodes start in the node_array */
get_cluster_node_offset(char * cluster_name,node_info_msg_t * node_info_ptr)5827 extern int get_cluster_node_offset(char *cluster_name,
5828 node_info_msg_t *node_info_ptr)
5829 {
5830 int offset;
5831
5832 xassert(cluster_name);
5833 xassert(node_info_ptr);
5834
5835 for (offset = 0; offset < node_info_ptr->record_count; offset++)
5836 if (!xstrcmp(cluster_name,
5837 node_info_ptr->node_array[offset].cluster_name))
5838 return offset;
5839
5840 return 0;
5841 }
5842
print_multi_line_string(char * user_msg,int inx,log_level_t log_lvl)5843 extern void print_multi_line_string(char *user_msg, int inx,
5844 log_level_t log_lvl)
5845 {
5846 char *line, *buf, *ptrptr = NULL;
5847
5848 if (!user_msg)
5849 return;
5850
5851 buf = xstrdup(user_msg);
5852 line = strtok_r(buf, "\n", &ptrptr);
5853 while (line) {
5854 if (inx == -1)
5855 log_var(log_lvl, "%s", line);
5856 else
5857 log_var(log_lvl, "%d: %s", inx, line);
5858 line = strtok_r(NULL, "\n", &ptrptr);
5859 }
5860 xfree(buf);
5861 }
5862
5863 /*
5864 * Given a numeric suffix, return the equivalent multiplier for the numeric
5865 * portion. For example: "k" returns 1024, "KB" returns 1000, etc.
5866 * The return value for an invalid suffix is NO_VAL64.
5867 */
suffix_mult(char * suffix)5868 extern uint64_t suffix_mult(char *suffix)
5869 {
5870 uint64_t multiplier;
5871
5872 if (!suffix || (suffix[0] == '\0')) {
5873 multiplier = 1;
5874
5875 } else if (!xstrcasecmp(suffix, "k") ||
5876 !xstrcasecmp(suffix, "kib")) {
5877 multiplier = 1024;
5878 } else if (!xstrcasecmp(suffix, "kb")) {
5879 multiplier = 1000;
5880
5881 } else if (!xstrcasecmp(suffix, "m") ||
5882 !xstrcasecmp(suffix, "mib")) {
5883 multiplier = ((uint64_t)1024 * 1024);
5884 } else if (!xstrcasecmp(suffix, "mb")) {
5885 multiplier = ((uint64_t)1000 * 1000);
5886
5887 } else if (!xstrcasecmp(suffix, "g") ||
5888 !xstrcasecmp(suffix, "gib")) {
5889 multiplier = ((uint64_t)1024 * 1024 * 1024);
5890 } else if (!xstrcasecmp(suffix, "gb")) {
5891 multiplier = ((uint64_t)1000 * 1000 * 1000);
5892
5893 } else if (!xstrcasecmp(suffix, "t") ||
5894 !xstrcasecmp(suffix, "tib")) {
5895 multiplier = ((uint64_t)1024 * 1024 * 1024 * 1024);
5896 } else if (!xstrcasecmp(suffix, "tb")) {
5897 multiplier = ((uint64_t)1000 * 1000 * 1000 * 1000);
5898
5899 } else if (!xstrcasecmp(suffix, "p") ||
5900 !xstrcasecmp(suffix, "pib")) {
5901 multiplier = ((uint64_t)1024 * 1024 * 1024 * 1024 * 1024);
5902 } else if (!xstrcasecmp(suffix, "pb")) {
5903 multiplier = ((uint64_t)1000 * 1000 * 1000 * 1000 * 1000);
5904
5905 } else {
5906 debug("%s: Unrecognized numeric suffix '%s'", __func__, suffix);
5907 multiplier = NO_VAL64;
5908 }
5909
5910 return multiplier;
5911 }
5912