diff --git a/src/common/forward.c b/src/common/forward.c
index d996366fd708936a90e6fb88c5e1c46f14519279..a620ca9025f5adcdaf0c6af1dcb0feffbf11c255 100644
--- a/src/common/forward.c
+++ b/src/common/forward.c
@@ -60,7 +60,7 @@ void *_forward_thread(void *arg)
slurm_fd fd;
ret_data_info_t *ret_data_info = NULL;
ListIterator itr;
- char name[MAX_NAME_LEN];
+ char name[MAX_SLURM_NAME];
msg.forward.cnt = 0;
@@ -109,8 +109,8 @@ void *_forward_thread(void *arg)
for(i=0; i<fwd_msg->header.forward.cnt; i++) {
strncpy(name,
&fwd_msg->header.
- forward.name[i * MAX_NAME_LEN],
- MAX_NAME_LEN);
+ forward.name[i * MAX_SLURM_NAME],
+ MAX_SLURM_NAME);
ret_data_info = xmalloc(sizeof(ret_data_info_t));
list_push(type->ret_data_list, ret_data_info);
ret_data_info->node_name = xstrdup(name);
@@ -246,8 +246,8 @@ extern int forward_msg(forward_struct_t *forward_struct,
&header->forward.addr[i],
sizeof(slurm_addr));
strncpy(forward_msg->node_name,
- &header->forward.name[i * MAX_NAME_LEN],
- MAX_NAME_LEN);
+ &header->forward.name[i * MAX_SLURM_NAME],
+ MAX_SLURM_NAME);
forward_set(&forward_msg->header.forward,
span[thr_count],
@@ -277,7 +277,7 @@ extern int forward_msg(forward_struct_t *forward_struct,
* correct start after forwarding
* information has been added.
* IN: forward_addr- sockaddr_in * - list of address structures to forward to
- * IN: forward_names - char * - list of names in MAX_NAME_LEN increments
+ * IN: forward_names - char * - list of names in MAX_SLURM_NAME increments
* RET: SLURM_SUCCESS - int
*/
extern int forward_set(forward_t *forward,
@@ -288,15 +288,15 @@ extern int forward_set(forward_t *forward,
int j = 1;
int total = from->cnt;
- /* char name[MAX_NAME_LEN]; */
+ /* char name[MAX_SLURM_NAME]; */
/* strncpy(name, */
-/* &from->name[(*pos) * MAX_NAME_LEN], */
-/* MAX_NAME_LEN); */
+/* &from->name[(*pos) * MAX_SLURM_NAME], */
+/* MAX_SLURM_NAME); */
/* info("forwarding to %s",name); */
if(span > 0) {
forward->addr = xmalloc(sizeof(slurm_addr) * span);
- forward->name = xmalloc(sizeof(char) * (MAX_NAME_LEN * span));
+ forward->name = xmalloc(sizeof(char) * (MAX_SLURM_NAME * span));
forward->node_id = xmalloc(sizeof(int32_t) * span);
forward->timeout = from->timeout;
forward->init = FORWARD_INIT;
@@ -306,9 +306,9 @@ extern int forward_set(forward_t *forward,
&from->addr[*pos+j],
sizeof(slurm_addr));
//forward->addr[j-1] = forward_addr[*pos+j];
- strncpy(&forward->name[(j-1) * MAX_NAME_LEN],
- &from->name[(*pos+j) * MAX_NAME_LEN],
- MAX_NAME_LEN);
+ strncpy(&forward->name[(j-1) * MAX_SLURM_NAME],
+ &from->name[(*pos+j) * MAX_SLURM_NAME],
+ MAX_SLURM_NAME);
if(from->node_id)
forward->node_id[j-1] = from->node_id[*pos+j];
@@ -316,8 +316,8 @@ extern int forward_set(forward_t *forward,
forward->node_id[j-1] = 0;
/* strncpy(name, */
-/* &from->name[(*pos+j) * MAX_NAME_LEN], */
-/* MAX_NAME_LEN); */
+/* &from->name[(*pos+j) * MAX_SLURM_NAME], */
+/* MAX_SLURM_NAME); */
/* info("along with %s",name); */
j++;
}
@@ -344,15 +344,15 @@ extern int forward_set_launch(forward_t *forward,
char *host = NULL;
int total = step_layout->num_hosts;
- /* char name[MAX_NAME_LEN]; */
+ /* char name[MAX_SLURM_NAME]; */
/* strncpy(name, */
/* step_layout->host[*pos], */
-/* MAX_NAME_LEN); */
+/* MAX_SLURM_NAME); */
/* info("forwarding to %s",name); */
if(span > 0) {
forward->addr = xmalloc(sizeof(slurm_addr) * span);
- forward->name = xmalloc(sizeof(char) * (MAX_NAME_LEN * span));
+ forward->name = xmalloc(sizeof(char) * (MAX_SLURM_NAME * span));
forward->node_id = xmalloc(sizeof(int32_t) * span);
forward->timeout = timeout;
forward->init = FORWARD_INIT;
@@ -373,13 +373,13 @@ extern int forward_set_launch(forward_t *forward,
&slurmd_addr[i],
sizeof(slurm_addr));
//forward->addr[j-1] = slurmd_addr[i];
- strncpy(&forward->name[(j-1) * MAX_NAME_LEN],
+ strncpy(&forward->name[(j-1) * MAX_SLURM_NAME],
step_layout->host[*pos+j],
- MAX_NAME_LEN);
+ MAX_SLURM_NAME);
forward->node_id[j-1] = (*pos+j);
/* strncpy(name, */
/* step_layout->host[*pos+j], */
-/* MAX_NAME_LEN); */
+/* MAX_SLURM_NAME); */
/* info("along with %s",name); */
j++;
}
@@ -398,7 +398,7 @@ extern int no_resp_forwards(forward_t *forward, List *ret_list, int err)
{
ret_types_t *type = NULL;
ret_data_info_t *ret_data_info = NULL;
- char name[MAX_NAME_LEN];
+ char name[MAX_SLURM_NAME];
int i=0;
if(forward->cnt == 0)
goto no_forward;
@@ -412,7 +412,7 @@ extern int no_resp_forwards(forward_t *forward, List *ret_list, int err)
type->err = err;
type->ret_data_list = list_create(destroy_data_info);
for(i=0; i<forward->cnt; i++) {
- strncpy(name, &forward->name[i * MAX_NAME_LEN], MAX_NAME_LEN);
+ strncpy(name, &forward->name[i * MAX_SLURM_NAME], MAX_SLURM_NAME);
ret_data_info = xmalloc(sizeof(ret_data_info_t));
list_push(type->ret_data_list, ret_data_info);
ret_data_info->node_name = xstrdup(name);
diff --git a/src/common/read_config.c b/src/common/read_config.c
index 7e72de7e40671e4cdbc9666a5ff81c431686a94c..ce54c442b0bdd2fd6de9a8ad6c5ca7fcd61bb6ca 100644
--- a/src/common/read_config.c
+++ b/src/common/read_config.c
@@ -175,8 +175,8 @@ static void _register_conf_node_aliases(char *node_name, char *node_hostname)
return;
}
if (!this_hostname) {
- this_hostname = xmalloc(MAX_NAME_LEN);
- getnodename(this_hostname, MAX_NAME_LEN);
+ this_hostname = xmalloc(MAX_SLURM_NAME);
+ getnodename(this_hostname, MAX_SLURM_NAME);
}
if (strcasecmp(node_name, "localhost") == 0)
node_name = this_hostname;
@@ -1269,9 +1269,9 @@ validate_config (slurm_ctl_conf_t *ctl_conf_ptr)
if ((ctl_conf_ptr->backup_controller != NULL) &&
(strcasecmp("localhost", ctl_conf_ptr->backup_controller) == 0)) {
xfree (ctl_conf_ptr->backup_controller);
- ctl_conf_ptr->backup_controller = xmalloc (MAX_NAME_LEN);
+ ctl_conf_ptr->backup_controller = xmalloc (MAX_SLURM_NAME);
if ( getnodename (ctl_conf_ptr->backup_controller,
- MAX_NAME_LEN) )
+ MAX_SLURM_NAME) )
fatal ("getnodename: %m");
}
@@ -1290,9 +1290,9 @@ validate_config (slurm_ctl_conf_t *ctl_conf_ptr)
fatal ("validate_config: ControlMachine not specified.");
else if (strcasecmp("localhost", ctl_conf_ptr->control_machine) == 0) {
xfree (ctl_conf_ptr->control_machine);
- ctl_conf_ptr->control_machine = xmalloc (MAX_NAME_LEN);
+ ctl_conf_ptr->control_machine = xmalloc (MAX_SLURM_NAME);
if ( getnodename (ctl_conf_ptr->control_machine,
- MAX_NAME_LEN) )
+ MAX_SLURM_NAME) )
fatal ("getnodename: %m");
}
diff --git a/src/common/slurm_protocol_defs.h b/src/common/slurm_protocol_defs.h
index 9b7f6a9467106fffc7f014726b65e714bc7edeea..408993bf77789e0daf2b6d1ad3d08b405a4a821f 100644
--- a/src/common/slurm_protocol_defs.h
+++ b/src/common/slurm_protocol_defs.h
@@ -50,7 +50,7 @@
#include "src/common/switch.h"
#include "src/common/xassert.h"
-#define MAX_NAME_LEN 64
+#define MAX_SLURM_NAME 64
#define FORWARD_INIT 0xffff
/* used to define flags of the launch_tasks_request_msg_t.and
@@ -243,7 +243,7 @@ typedef struct forward_message {
List ret_list;
pthread_mutex_t *forward_mutex;
pthread_cond_t *notify;
- char node_name[MAX_NAME_LEN];
+ char node_name[MAX_SLURM_NAME];
} forward_msg_t;
typedef struct forward_struct {
diff --git a/src/common/slurm_protocol_pack.c b/src/common/slurm_protocol_pack.c
index 14b38fafeef0b90216b8ff735ad86e3f3698ade0..c0fe832cbe4639feed5dd167292a3af87f074c16 100644
--- a/src/common/slurm_protocol_pack.c
+++ b/src/common/slurm_protocol_pack.c
@@ -298,7 +298,7 @@ pack_header(header_t * header, Buf buffer)
_pack_slurm_addr_array(header->forward.addr,
header->forward.cnt, buffer);
packmem(header->forward.name,
- (header->forward.cnt * MAX_NAME_LEN),
+ (header->forward.cnt * MAX_SLURM_NAME),
buffer);
pack32_array(header->forward.node_id,
header->forward.cnt,
diff --git a/src/plugins/select/cons_res/select_cons_res.c b/src/plugins/select/cons_res/select_cons_res.c
index 8a9d5d1ead8de225ae9b0720d516ca43e712dda9..3c658d39a78769db5d638d95b118d624d09f9ce2 100644
--- a/src/plugins/select/cons_res/select_cons_res.c
+++ b/src/plugins/select/cons_res/select_cons_res.c
@@ -279,7 +279,7 @@ _find_cr_node_record (const char *name)
this_node = cr_node_hash_table[i];
while (this_node) {
xassert(this_node->node_ptr->magic == NODE_MAGIC);
- if (strncmp(this_node->node_ptr->name, name, MAX_NAME_LEN) == 0) {
+ if (strncmp(this_node->node_ptr->name, name, MAX_SLURM_NAME) == 0) {
debug3(" cons_res _find_cr_node_record: hash %s", name);
return this_node;
}
diff --git a/src/plugins/select/linear/select_linear.c b/src/plugins/select/linear/select_linear.c
index f9a56960db8650629f00be75ffeed1ade15bdfa1..2b36644275671c3c3cbaa407d5a98bc1aa147079 100644
--- a/src/plugins/select/linear/select_linear.c
+++ b/src/plugins/select/linear/select_linear.c
@@ -84,7 +84,7 @@ const char plugin_name[] = "Linear node selection plugin";
const char plugin_type[] = "select/linear";
const uint32_t plugin_version = 90;
-static struct node_record *select_node_ptr;
+static struct node_record *select_node_ptr = NULL;
static int select_node_cnt;
static uint16_t select_fast_schedule;
diff --git a/src/scontrol/scontrol.c b/src/scontrol/scontrol.c
index 69c73deff9e8963e62f2eac956d7bd6fded33f60..090bd7232c54d262f004cc1c5e96132a50996560 100644
--- a/src/scontrol/scontrol.c
+++ b/src/scontrol/scontrol.c
@@ -671,14 +671,14 @@ static void
_print_daemons (void)
{
slurm_ctl_conf_info_msg_t conf;
- char me[MAX_NAME_LEN], *b, *c, *n;
+ char me[MAX_SLURM_NAME], *b, *c, *n;
int actld = 0, ctld = 0, d = 0;
char daemon_list[] = "slurmctld slurmd";
bzero(&conf, sizeof(conf));
if (read_slurm_conf_ctl(&conf, true) != SLURM_SUCCESS)
return;
- getnodename(me, MAX_NAME_LEN);
+ getnodename(me, MAX_SLURM_NAME);
if ((b = conf.backup_controller)) {
if ((strcmp(b, me) == 0) ||
(strcasecmp(b, "localhost") == 0))
diff --git a/src/slurmctld/agent.c b/src/slurmctld/agent.c
index a6039507fedb769cc977c724b6b597d956ccd490..0c288fc86b08ae64af7968a5de419e287edf97b4 100644
--- a/src/slurmctld/agent.c
+++ b/src/slurmctld/agent.c
@@ -112,7 +112,7 @@ typedef struct thd {
forward_t forward; /* structure holding info for all
forwarding info
*/
- char node_name[MAX_NAME_LEN]; /* node's name */
+ char node_name[MAX_SLURM_NAME]; /* node's name */
List ret_list;
} thd_t;
@@ -374,8 +374,8 @@ static agent_info_t *_make_agent_info(agent_arg_t *agent_arg_ptr)
thread_ptr[thr_count].slurm_addr =
agent_arg_ptr->slurm_addr[i];
strncpy(thread_ptr[thr_count].node_name,
- &agent_arg_ptr->node_names[i * MAX_NAME_LEN],
- MAX_NAME_LEN);
+ &agent_arg_ptr->node_names[i * MAX_SLURM_NAME],
+ MAX_SLURM_NAME);
forward_set(&thread_ptr[thr_count].forward,
span[thr_count],
@@ -987,7 +987,7 @@ static void _queue_agent_retry(agent_info_t * agent_info_ptr, int count)
agent_arg_ptr->retry = 1;
agent_arg_ptr->slurm_addr = xmalloc(sizeof(slurm_addr) * count);
agent_arg_ptr->node_names =
- xmalloc(sizeof(char) * MAX_NAME_LEN * count);
+ xmalloc(sizeof(char) * MAX_SLURM_NAME * count);
agent_arg_ptr->msg_type = agent_info_ptr->msg_type;
agent_arg_ptr->msg_args = *(agent_info_ptr->msg_args_pptr);
*(agent_info_ptr->msg_args_pptr) = NULL;
@@ -997,8 +997,8 @@ static void _queue_agent_retry(agent_info_t * agent_info_ptr, int count)
if (thread_ptr[i].state != DSH_NO_RESP)
continue;
agent_arg_ptr->slurm_addr[j] = thread_ptr[i].slurm_addr;
- strncpy(&agent_arg_ptr->node_names[j * MAX_NAME_LEN],
- thread_ptr[i].node_name, MAX_NAME_LEN);
+ strncpy(&agent_arg_ptr->node_names[j * MAX_SLURM_NAME],
+ thread_ptr[i].node_name, MAX_SLURM_NAME);
if ((++j) == count)
break;
}
diff --git a/src/slurmctld/agent.h b/src/slurmctld/agent.h
index a4f009a71e1624360b86d338660ea9934b51f81b..587eaba2887bf03e383959a3949801365b5672e3 100644
--- a/src/slurmctld/agent.h
+++ b/src/slurmctld/agent.h
@@ -49,7 +49,7 @@ typedef struct agent_arg {
* with */
uint16_t retry; /* if set, keep trying */
slurm_addr *slurm_addr; /* array of network addresses */
- char *node_names; /* array with MAX_NAME_LEN bytes
+ char *node_names; /* array with MAX_SLURM_NAME bytes
* per node */
slurm_msg_type_t msg_type; /* RPC to be issued */
void *msg_args; /* RPC data to be transmitted */
diff --git a/src/slurmctld/controller.c b/src/slurmctld/controller.c
index b579020d7a0af2189ed573c262ca3eec83795f87..2830d24e3b6861274b07dcecc9815d346fb8e252 100644
--- a/src/slurmctld/controller.c
+++ b/src/slurmctld/controller.c
@@ -115,7 +115,7 @@ static int daemonize = DEFAULT_DAEMONIZE;
static int debug_level = 0;
static char *debug_logfile = NULL;
static bool dump_core = false;
-static char node_name[MAX_NAME_LEN];
+static char node_name[MAX_SLURM_NAME];
static int recover = DEFAULT_RECOVER;
static pthread_cond_t server_thread_cond = PTHREAD_COND_INITIALIZER;
static pid_t slurmctld_pid;
@@ -210,7 +210,7 @@ int main(int argc, char *argv[])
}
info("slurmctld version %s started", SLURM_VERSION);
- if ((error_code = getnodename(node_name, MAX_NAME_LEN)))
+ if ((error_code = getnodename(node_name, MAX_SLURM_NAME)))
fatal("getnodename error %s", slurm_strerror(error_code));
/* init job credential stuff */
diff --git a/src/slurmctld/job_mgr.c b/src/slurmctld/job_mgr.c
index 937ef03af220d20eed984922cac717df4c74ddf7..4ab9a3c98fed07a166a112faa20a5f47c39af30e 100644
--- a/src/slurmctld/job_mgr.c
+++ b/src/slurmctld/job_mgr.c
@@ -651,7 +651,7 @@ static int _load_job_state(Buf buffer)
xfree(job_ptr->alloc_node);
job_ptr->alloc_node = alloc_node;
alloc_node = NULL; /* reused, nothing left to free */
- strncpy(job_ptr->partition, partition, MAX_NAME_LEN);
+ strncpy(job_ptr->partition, partition, MAX_SLURM_NAME);
xfree(partition);
job_ptr->account = account;
account = NULL; /* reused, nothing left to free */
@@ -1541,9 +1541,9 @@ _signal_batch_job(struct job_record *job_ptr, uint16_t signal)
agent_args->slurm_addr = xmalloc(sizeof(struct sockaddr_in));
memcpy(agent_args->slurm_addr, &node_record_table_ptr[i].slurm_addr,
sizeof(struct sockaddr_in));
- agent_args->node_names = xmalloc(MAX_NAME_LEN);
+ agent_args->node_names = xmalloc(MAX_SLURM_NAME);
strncpy(agent_args->node_names, node_record_table_ptr[i].name,
- MAX_NAME_LEN);
+ MAX_SLURM_NAME);
kill_tasks_msg = xmalloc(sizeof(kill_tasks_msg_t));
kill_tasks_msg->job_id = job_ptr->job_id;
@@ -2196,7 +2196,7 @@ _copy_job_desc_to_job_record(job_desc_msg_t * job_desc,
if (error_code)
return error_code;
- strncpy(job_ptr->partition, part_ptr->name, MAX_NAME_LEN);
+ strncpy(job_ptr->partition, part_ptr->name, MAX_SLURM_NAME);
job_ptr->part_ptr = part_ptr;
if (job_desc->job_id != NO_VAL) /* already confirmed unique */
job_ptr->job_id = job_desc->job_id;
@@ -3261,7 +3261,7 @@ int update_job(job_desc_msg_t * job_specs, uid_t uid)
error_code = ESLURM_INVALID_PARTITION_NAME;
if ((super_user && tmp_part_ptr)) {
strncpy(job_ptr->partition, job_specs->partition,
- MAX_NAME_LEN);
+ MAX_SLURM_NAME);
job_ptr->part_ptr = tmp_part_ptr;
info("update_job: setting partition to %s for "
"job_id %u", job_specs->partition,
@@ -3713,13 +3713,13 @@ _xmit_new_end_time(struct job_record *job_ptr)
(sizeof(struct sockaddr_in) *
buf_rec_size));
xrealloc((agent_args->node_names),
- (MAX_NAME_LEN * buf_rec_size));
+ (MAX_SLURM_NAME * buf_rec_size));
}
agent_args->slurm_addr[agent_args->node_count] =
node_record_table_ptr[i].slurm_addr;
strncpy(&agent_args->
- node_names[MAX_NAME_LEN * agent_args->node_count],
- node_record_table_ptr[i].name, MAX_NAME_LEN);
+ node_names[MAX_SLURM_NAME * agent_args->node_count],
+ node_record_table_ptr[i].name, MAX_SLURM_NAME);
agent_args->node_count++;
#ifdef HAVE_FRONT_END /* operate only on front-end node */
break;
@@ -3915,13 +3915,13 @@ static void _signal_job(struct job_record *job_ptr, int signal)
(sizeof(struct sockaddr_in) *
buf_rec_size));
xrealloc((agent_args->node_names),
- (MAX_NAME_LEN * buf_rec_size));
+ (MAX_SLURM_NAME * buf_rec_size));
}
agent_args->slurm_addr[agent_args->node_count] =
node_record_table_ptr[i].slurm_addr;
strncpy(&agent_args->
- node_names[MAX_NAME_LEN * agent_args->node_count],
- node_record_table_ptr[i].name, MAX_NAME_LEN);
+ node_names[MAX_SLURM_NAME * agent_args->node_count],
+ node_record_table_ptr[i].name, MAX_SLURM_NAME);
agent_args->node_count++;
#ifdef HAVE_FRONT_END /* Operate only on front-end */
break;
@@ -3962,13 +3962,13 @@ static void _suspend_job(struct job_record *job_ptr, uint16_t op)
(sizeof(struct sockaddr_in) *
buf_rec_size));
xrealloc((agent_args->node_names),
- (MAX_NAME_LEN * buf_rec_size));
+ (MAX_SLURM_NAME * buf_rec_size));
}
agent_args->slurm_addr[agent_args->node_count] =
node_record_table_ptr[i].slurm_addr;
strncpy(&agent_args->
- node_names[MAX_NAME_LEN * agent_args->node_count],
- node_record_table_ptr[i].name, MAX_NAME_LEN);
+ node_names[MAX_SLURM_NAME * agent_args->node_count],
+ node_record_table_ptr[i].name, MAX_SLURM_NAME);
agent_args->node_count++;
#ifdef HAVE_FRONT_END /* Operate only on front-end */
break;
diff --git a/src/slurmctld/node_mgr.c b/src/slurmctld/node_mgr.c
index 1bc67bde4c93f53b3836695c75f42b23a61851e8..b77c968cf5a19385bbdd339a78893c99bd3120c9 100644
--- a/src/slurmctld/node_mgr.c
+++ b/src/slurmctld/node_mgr.c
@@ -176,7 +176,7 @@ create_node_record (struct config_record *config_ptr, char *node_name)
last_node_update = time (NULL);
xassert(config_ptr);
xassert(node_name);
- xassert(strlen (node_name) < MAX_NAME_LEN);
+ xassert(strlen (node_name) < MAX_SLURM_NAME);
/* round up the buffer size to reduce overhead of xrealloc */
old_buffer_size = (node_record_count) * sizeof (struct node_record);
@@ -463,7 +463,7 @@ find_node_record (char *name)
node_ptr = node_hash_table[i];
while (node_ptr) {
xassert(node_ptr->magic == NODE_MAGIC);
- if (strncmp(node_ptr->name, name, MAX_NAME_LEN) == 0)
+ if (strncmp(node_ptr->name, name, MAX_SLURM_NAME) == 0)
return node_ptr;
node_ptr = node_ptr->node_next;
}
@@ -1661,7 +1661,7 @@ void msg_to_slurmd (slurm_msg_type_t msg_type)
kill_agent_args->slurm_addr = xmalloc (
sizeof (struct sockaddr_in) *
(node_record_count + 1));
- kill_agent_args->node_names = xmalloc (MAX_NAME_LEN *
+ kill_agent_args->node_names = xmalloc (MAX_SLURM_NAME *
(node_record_count + 1));
if (msg_type == REQUEST_SHUTDOWN) {
shutdown_req = xmalloc(sizeof(shutdown_msg_t));
@@ -1672,9 +1672,9 @@ void msg_to_slurmd (slurm_msg_type_t msg_type)
for (i = 0; i < node_record_count; i++) {
kill_agent_args->slurm_addr[kill_agent_args->node_count] =
node_record_table_ptr[i].slurm_addr;
- pos = MAX_NAME_LEN * kill_agent_args->node_count;
+ pos = MAX_SLURM_NAME * kill_agent_args->node_count;
strncpy (&kill_agent_args->node_names[pos],
- node_record_table_ptr[i].name, MAX_NAME_LEN);
+ node_record_table_ptr[i].name, MAX_SLURM_NAME);
kill_agent_args->node_count++;
#ifdef HAVE_FRONT_END /* Operate only on front-end */
break;
diff --git a/src/slurmctld/node_scheduler.c b/src/slurmctld/node_scheduler.c
index 9d9fed75b83a6ffbb7743051dd22040f89aa6f8f..62db52fe68a7f0b73ac5ca568aa01541404e866e 100644
--- a/src/slurmctld/node_scheduler.c
+++ b/src/slurmctld/node_scheduler.c
@@ -197,13 +197,13 @@ extern void deallocate_nodes(struct job_record *job_ptr, bool timeout,
(sizeof(struct sockaddr_in) *
buf_rec_size));
xrealloc((agent_args->node_names),
- (MAX_NAME_LEN * buf_rec_size));
+ (MAX_SLURM_NAME * buf_rec_size));
}
agent_args->slurm_addr[agent_args->node_count] =
node_ptr->slurm_addr;
strncpy(&agent_args->
- node_names[MAX_NAME_LEN * agent_args->node_count],
- node_ptr->name, MAX_NAME_LEN);
+ node_names[MAX_SLURM_NAME * agent_args->node_count],
+ node_ptr->name, MAX_SLURM_NAME);
agent_args->node_count++;
}
@@ -1388,13 +1388,13 @@ extern void re_kill_job(struct job_record *job_ptr)
xrealloc((agent_args->slurm_addr),
(sizeof(struct sockaddr_in) * buf_rec_size));
xrealloc((agent_args->node_names),
- (MAX_NAME_LEN * buf_rec_size));
+ (MAX_SLURM_NAME * buf_rec_size));
}
agent_args->slurm_addr[agent_args->node_count] =
node_ptr->slurm_addr;
strncpy(&agent_args->
- node_names[MAX_NAME_LEN * agent_args->node_count],
- node_ptr->name, MAX_NAME_LEN);
+ node_names[MAX_SLURM_NAME * agent_args->node_count],
+ node_ptr->name, MAX_SLURM_NAME);
agent_args->node_count++;
}
diff --git a/src/slurmctld/partition_mgr.c b/src/slurmctld/partition_mgr.c
index 2ddc82a6990c67aaafa73704dc7a48a0a5c58bdf..ffe4d94f3ec1407d8c2c626fbc1277ce0eabf438 100644
--- a/src/slurmctld/partition_mgr.c
+++ b/src/slurmctld/partition_mgr.c
@@ -59,7 +59,7 @@
/* Global variables */
struct part_record default_part; /* default configuration values */
List part_list = NULL; /* partition list */
-char default_part_name[MAX_NAME_LEN]; /* name of default partition */
+char default_part_name[MAX_SLURM_NAME]; /* name of default partition */
struct part_record *default_part_loc = NULL; /* default partition location */
time_t last_part_update; /* time of last update to partition records */
@@ -464,7 +464,7 @@ int load_all_part_state(void)
part_ptr->max_nodes = max_nodes;
part_ptr->min_nodes = min_nodes;
if (def_part_flag) {
- strncpy(default_part_name, part_name, MAX_NAME_LEN);
+ strncpy(default_part_name, part_name, MAX_SLURM_NAME);
default_part_loc = part_ptr;
}
part_ptr->root_only = root_only;
@@ -593,7 +593,7 @@ int list_find_part(void *part_entry, void *key)
return 1;
if (strncmp(((struct part_record *) part_entry)->name,
- (char *) key, MAX_NAME_LEN) == 0)
+ (char *) key, MAX_SLURM_NAME) == 0)
return 1;
return 0;
@@ -740,7 +740,7 @@ int update_part(update_part_msg_t * part_desc)
struct part_record *part_ptr;
if ((part_desc->name == NULL) ||
- (strlen(part_desc->name) >= MAX_NAME_LEN)) {
+ (strlen(part_desc->name) >= MAX_SLURM_NAME)) {
error("update_part: invalid partition name %s",
part_desc->name);
return ESLURM_INVALID_PARTITION_NAME;
@@ -805,7 +805,7 @@ int update_part(update_part_msg_t * part_desc)
(strcmp(default_part_name, part_desc->name) != 0)) {
info("update_part: changing default partition from %s to %s",
default_part_name, part_desc->name);
- strncpy(default_part_name, part_desc->name, MAX_NAME_LEN);
+ strncpy(default_part_name, part_desc->name, MAX_SLURM_NAME);
default_part_loc = part_ptr;
}
diff --git a/src/slurmctld/ping_nodes.c b/src/slurmctld/ping_nodes.c
index cddd5bc2d94d1b043ddced17cddfed4e69d60d96..e8ff2171e15edb8d511012965767542eaca80fcd 100644
--- a/src/slurmctld/ping_nodes.c
+++ b/src/slurmctld/ping_nodes.c
@@ -127,7 +127,7 @@ void ping_nodes (void)
hostlist_t ping_hostlist = hostlist_create("");
hostlist_t reg_hostlist = hostlist_create("");
hostlist_t down_hostlist = NULL;
- char host_str[MAX_NAME_LEN];
+ char host_str[MAX_SLURM_NAME];
int ping_buf_rec_size = 0;
agent_arg_t *ping_agent_args;
@@ -221,13 +221,13 @@ void ping_nodes (void)
(sizeof (struct sockaddr_in) *
reg_buf_rec_size));
xrealloc ((reg_agent_args->node_names),
- (MAX_NAME_LEN * reg_buf_rec_size));
+ (MAX_SLURM_NAME * reg_buf_rec_size));
}
reg_agent_args->slurm_addr[reg_agent_args->node_count] =
node_ptr->slurm_addr;
- pos = MAX_NAME_LEN * reg_agent_args->node_count;
+ pos = MAX_SLURM_NAME * reg_agent_args->node_count;
strncpy (®_agent_args->node_names[pos],
- node_ptr->name, MAX_NAME_LEN);
+ node_ptr->name, MAX_SLURM_NAME);
reg_agent_args->node_count++;
continue;
}
@@ -239,13 +239,13 @@ void ping_nodes (void)
(sizeof (struct sockaddr_in) *
ping_buf_rec_size));
xrealloc ((ping_agent_args->node_names),
- (MAX_NAME_LEN * ping_buf_rec_size));
+ (MAX_SLURM_NAME * ping_buf_rec_size));
}
ping_agent_args->slurm_addr[ping_agent_args->node_count] =
node_ptr->slurm_addr;
- pos = MAX_NAME_LEN * ping_agent_args->node_count;
+ pos = MAX_SLURM_NAME * ping_agent_args->node_count;
strncpy (&ping_agent_args->node_names[pos],
- node_ptr->name, MAX_NAME_LEN);
+ node_ptr->name, MAX_SLURM_NAME);
ping_agent_args->node_count++;
}
diff --git a/src/slurmctld/read_config.c b/src/slurmctld/read_config.c
index 4ef717bf41ef94a25d943b9e5a9209852a3a9ac1..d26a32ae9bf84079324c1c6a141bfa9a1b1c22ca 100644
--- a/src/slurmctld/read_config.c
+++ b/src/slurmctld/read_config.c
@@ -79,7 +79,7 @@ static int _sync_nodes_to_active_job(struct job_record *job_ptr);
static void _validate_node_proc_count(void);
#endif
-static char highest_node_name[MAX_NAME_LEN] = "";
+static char highest_node_name[MAX_SLURM_NAME] = "";
int node_record_count = 0;
@@ -300,8 +300,8 @@ static int _parse_node_spec(char *in_line)
return 0; /* no node info */
if (strcasecmp(node_name, "localhost") == 0) {
xfree(node_name);
- node_name = xmalloc(MAX_NAME_LEN);
- getnodename(node_name, MAX_NAME_LEN);
+ node_name = xmalloc(MAX_SLURM_NAME);
+ getnodename(node_name, MAX_SLURM_NAME);
}
error_code = slurm_parser(in_line,
@@ -432,7 +432,7 @@ static int _parse_node_spec(char *in_line)
node_ptr = find_node_record(this_node_name);
else {
strncpy(highest_node_name, this_node_name,
- MAX_NAME_LEN);
+ MAX_SLURM_NAME);
node_ptr = NULL;
}
@@ -446,13 +446,13 @@ static int _parse_node_spec(char *in_line)
#ifdef HAVE_FRONT_END /* Permit NodeAddr value reuse for front-end */
if (node_addr)
strncpy(node_ptr->comm_name,
- node_addr, MAX_NAME_LEN);
+ node_addr, MAX_SLURM_NAME);
else if (node_hostname)
strncpy(node_ptr->comm_name,
- node_hostname, MAX_NAME_LEN);
+ node_hostname, MAX_SLURM_NAME);
else
strncpy(node_ptr->comm_name,
- node_ptr->name, MAX_NAME_LEN);
+ node_ptr->name, MAX_SLURM_NAME);
#else
if (node_addr)
this_node_addr = hostlist_shift(addr_list);
@@ -460,11 +460,11 @@ static int _parse_node_spec(char *in_line)
this_node_addr = NULL;
if (this_node_addr) {
strncpy(node_ptr->comm_name,
- this_node_addr, MAX_NAME_LEN);
+ this_node_addr, MAX_SLURM_NAME);
free(this_node_addr);
} else
strncpy(node_ptr->comm_name,
- node_ptr->name, MAX_NAME_LEN);
+ node_ptr->name, MAX_SLURM_NAME);
#endif
#ifdef MULTIPLE_SLURMD
if (port != NO_VAL)
@@ -533,7 +533,7 @@ static int _parse_part_spec(char *in_line)
if (partition_name == NULL)
return 0; /* no partition info */
- if (strlen(partition_name) >= MAX_NAME_LEN) {
+ if (strlen(partition_name) >= MAX_SLURM_NAME) {
error("_parse_part_spec: partition name %s too long",
partition_name);
xfree(partition_name);
@@ -717,8 +717,8 @@ static int _parse_part_spec(char *in_line)
if (nodes) {
if (strcasecmp(nodes, "localhost") == 0) {
xfree(nodes);
- nodes = xmalloc(MAX_NAME_LEN);
- getnodename(nodes, MAX_NAME_LEN);
+ nodes = xmalloc(MAX_SLURM_NAME);
+ getnodename(nodes, MAX_SLURM_NAME);
}
if (part_ptr->nodes) {
xstrcat(part_ptr->nodes, ",");
diff --git a/src/slurmctld/slurmctld.h b/src/slurmctld/slurmctld.h
index 87ce0c6ad29af3f8a5e3b68b3dbb0b2791083608..b326112d6394cc211d4efa3cba8ab069252931f7 100644
--- a/src/slurmctld/slurmctld.h
+++ b/src/slurmctld/slurmctld.h
@@ -61,6 +61,7 @@
#include "src/common/pack.h"
#include "src/common/slurm_cred.h"
#include "src/common/slurm_protocol_api.h"
+#include "src/common/slurm_protocol_defs.h"
#include "src/common/switch.h"
#include "src/common/xmalloc.h"
@@ -157,7 +158,7 @@ extern List config_list; /* list of config_record entries */
struct node_record {
uint32_t magic; /* magic cookie for data integrity */
- char name[MAX_NAME_LEN]; /* name of the node. NULL==defunct */
+ char name[MAX_SLURM_NAME]; /* name of the node. NULL==defunct */
uint16_t node_state; /* enum node_states, ORed with
* NODE_STATE_NO_RESPOND if not
* responding */
@@ -169,7 +170,7 @@ struct node_record {
uint16_t part_cnt; /* number of associated partitions */
struct part_record **part_pptr; /* array of pointers to partitions
* associated with this node*/
- char comm_name[MAX_NAME_LEN]; /* communications path name to node */
+ char comm_name[MAX_SLURM_NAME]; /* communications path name to node */
uint16_t port; /* TCP port number of the slurmd */
slurm_addr slurm_addr; /* network address */
uint16_t comp_job_cnt; /* count of jobs completing on node */
@@ -199,7 +200,7 @@ extern struct node_record default_node_record;
struct part_record {
uint32_t magic; /* magic cookie to test data integrity */
- char name[MAX_NAME_LEN];/* name of the partition */
+ char name[MAX_SLURM_NAME];/* name of the partition */
uint16_t hidden; /* 1 if hidden by default */
uint32_t max_time; /* minutes or INFINITE */
uint32_t max_nodes; /* per job or INFINITE */
@@ -221,7 +222,7 @@ struct part_record {
extern List part_list; /* list of part_record entries */
extern time_t last_part_update; /* time of last part_list update */
extern struct part_record default_part; /* default configuration values */
-extern char default_part_name[MAX_NAME_LEN]; /* name of default partition */
+extern char default_part_name[MAX_SLURM_NAME]; /* name of default partition */
extern struct part_record *default_part_loc; /* default partition ptr */
/*****************************************************************************\
@@ -275,7 +276,7 @@ struct job_record {
uint32_t job_id; /* job ID */
uint32_t magic; /* magic cookie for data integrity */
char name[MAX_JOBNAME_LEN]; /* name of the job */
- char partition[MAX_NAME_LEN]; /* name of the partition */
+ char partition[MAX_SLURM_NAME]; /* name of the partition */
struct part_record *part_ptr; /* pointer to the partition record */
uint16_t batch_flag; /* 1 or 2 if batch job (with script),
* 2 indicates retry mode (one retry) */
diff --git a/src/slurmctld/srun_comm.c b/src/slurmctld/srun_comm.c
index 28637770e1a6032c44321f14543f6dfca1b1d197..119e4e78cbc192583a570fe1d39237b9571dc778 100644
--- a/src/slurmctld/srun_comm.c
+++ b/src/slurmctld/srun_comm.c
@@ -51,8 +51,8 @@ static void _srun_agent_launch(slurm_addr *addr, char *host,
agent_args->node_count = 1;
agent_args->retry = 0;
agent_args->slurm_addr = addr;
- agent_args->node_names = xmalloc(MAX_NAME_LEN);
- strncpy(agent_args->node_names, host, MAX_NAME_LEN);
+ agent_args->node_names = xmalloc(MAX_SLURM_NAME);
+ strncpy(agent_args->node_names, host, MAX_SLURM_NAME);
agent_args->msg_type = type;
agent_args->msg_args = msg_args;
agent_queue_request(agent_args);
diff --git a/src/slurmctld/step_mgr.c b/src/slurmctld/step_mgr.c
index dbecaa5828056a4f35a16dd1a181a02d5bb7dc95..7e4a157a9e74cf5da757d3f008e76db6e26aa1e8 100644
--- a/src/slurmctld/step_mgr.c
+++ b/src/slurmctld/step_mgr.c
@@ -300,13 +300,13 @@ void signal_step_tasks(struct step_record *step_ptr, uint16_t signal)
(sizeof(struct sockaddr_in) *
buf_rec_size));
xrealloc((agent_args->node_names),
- (MAX_NAME_LEN * buf_rec_size));
+ (MAX_SLURM_NAME * buf_rec_size));
}
agent_args->slurm_addr[agent_args->node_count] =
node_record_table_ptr[i].slurm_addr;
strncpy(&agent_args->
- node_names[MAX_NAME_LEN * agent_args->node_count],
- node_record_table_ptr[i].name, MAX_NAME_LEN);
+ node_names[MAX_SLURM_NAME * agent_args->node_count],
+ node_record_table_ptr[i].name, MAX_SLURM_NAME);
agent_args->node_count++;
#ifdef HAVE_FRONT_END /* Operate only on front-end */
break;
diff --git a/src/slurmd/slurmd/get_mach_stat.c b/src/slurmd/slurmd/get_mach_stat.c
index b8704f2c0d2624ea519bc16430052de782e66aeb..83a5ac1ec9889dbb59578779c4f436d444ef1985 100644
--- a/src/slurmd/slurmd/get_mach_stat.c
+++ b/src/slurmd/slurmd/get_mach_stat.c
@@ -65,7 +65,7 @@ main(int argc, char * argv[])
{
int error_code;
struct config_record this_node;
- char node_name[MAX_NAME_LEN];
+ char node_name[MAX_SLURM_NAME];
error_code = get_mach_name(node_name);
if (error_code != 0)
@@ -158,7 +158,7 @@ get_os_name(char *os_name)
/*
* get_mach_name - Return the name of this node
- * Input: node_name - buffer for the node name, must be at least MAX_NAME_LEN characters
+ * Input: node_name - buffer for the node name, must be at least MAX_SLURM_NAME characters
* Output: node_name - filled in with node name
* return code - 0 if no error, otherwise errno
*/
@@ -167,7 +167,7 @@ get_mach_name(char *node_name)
{
int error_code;
- error_code = getnodename(node_name, MAX_NAME_LEN);
+ error_code = getnodename(node_name, MAX_SLURM_NAME);
if (error_code != 0)
error ("get_mach_name: getnodename error %d\n", error_code);