diff --git a/src/api/config_info.c b/src/api/config_info.c
index 63d2cb87c07a16066ea60a7a451ad836321653dc..20211de7dccd5a168a777a3311750e35ff8bae77 100644
--- a/src/api/config_info.c
+++ b/src/api/config_info.c
@@ -1,5 +1,5 @@
/*
- * build_info.c - get the build information of slurm
+ * slurm_ctl_conf.c - get the build information of slurm
* see slurm.h for documentation on external functions and data structures
*
* author: moe jette, jette@llnl.gov
@@ -13,32 +13,32 @@
#include <stdio.h>
#include <src/common/slurm_protocol_api.h>
-void slurm_print_build_info ( FILE* out, build_info_msg_t * build_table_ptr )
+void slurm_print_ctl_conf ( FILE* out, slurm_ctl_conf_info_msg_t * slurm_ctl_conf_ptr )
{
- if ( build_table_ptr == NULL )
+ if ( slurm_ctl_conf_ptr == NULL )
return ;
- fprintf(out, "Build updated at %lx\n", (time_t)build_table_ptr->last_update);
- fprintf(out, "BACKUP_INTERVAL = %u\n", build_table_ptr->backup_interval);
- fprintf(out, "BACKUP_LOCATION = %s\n", build_table_ptr->backup_location);
- fprintf(out, "BACKUP_MACHINE = %s\n", build_table_ptr->backup_machine);
- fprintf(out, "CONTROL_DAEMON = %s\n", build_table_ptr->control_daemon);
- fprintf(out, "CONTROL_MACHINE = %s\n", build_table_ptr->control_machine);
- fprintf(out, "EPILOG = %s\n", build_table_ptr->epilog);
- fprintf(out, "FAST_SCHEDULE = %u\n", build_table_ptr->fast_schedule);
- fprintf(out, "HASH_BASE = %u\n", build_table_ptr->hash_base);
- fprintf(out, "HEARTBEAT_INTERVAL = %u\n", build_table_ptr->heartbeat_interval);
- fprintf(out, "INIT_PROGRAM = %s\n", build_table_ptr->init_program);
- fprintf(out, "KILL_WAIT = %u\n", build_table_ptr->kill_wait);
- fprintf(out, "PRIORITIZE = %s\n", build_table_ptr->prioritize);
- fprintf(out, "PROLOG = %s\n", build_table_ptr->prolog);
- fprintf(out, "SERVER_DAEMON = %s\n", build_table_ptr->server_daemon);
- fprintf(out, "SERVER_TIMEOUT = %u\n", build_table_ptr->server_timeout);
- fprintf(out, "SLURM_CONF = %s\n", build_table_ptr->slurm_conf);
- fprintf(out, "TMP_FS = %s\n", build_table_ptr->tmp_fs);
+ fprintf(out, "Build updated at %lx\n", (time_t)slurm_ctl_conf_ptr->last_update);
+ fprintf(out, "BACKUP_INTERVAL = %u\n", slurm_ctl_conf_ptr->backup_interval);
+ fprintf(out, "BACKUP_LOCATION = %s\n", slurm_ctl_conf_ptr->backup_location);
+ fprintf(out, "BACKUP_MACHINE = %s\n", slurm_ctl_conf_ptr->backup_machine);
+ fprintf(out, "CONTROL_DAEMON = %s\n", slurm_ctl_conf_ptr->control_daemon);
+ fprintf(out, "CONTROL_MACHINE = %s\n", slurm_ctl_conf_ptr->control_machine);
+ fprintf(out, "EPILOG = %s\n", slurm_ctl_conf_ptr->epilog);
+ fprintf(out, "FAST_SCHEDULE = %u\n", slurm_ctl_conf_ptr->fast_schedule);
+ fprintf(out, "HASH_BASE = %u\n", slurm_ctl_conf_ptr->hash_base);
+ fprintf(out, "HEARTBEAT_INTERVAL = %u\n", slurm_ctl_conf_ptr->heartbeat_interval);
+ fprintf(out, "INIT_PROGRAM = %s\n", slurm_ctl_conf_ptr->init_program);
+ fprintf(out, "KILL_WAIT = %u\n", slurm_ctl_conf_ptr->kill_wait);
+ fprintf(out, "PRIORITIZE = %s\n", slurm_ctl_conf_ptr->prioritize);
+ fprintf(out, "PROLOG = %s\n", slurm_ctl_conf_ptr->prolog);
+ fprintf(out, "SERVER_DAEMON = %s\n", slurm_ctl_conf_ptr->server_daemon);
+ fprintf(out, "SERVER_TIMEOUT = %u\n", slurm_ctl_conf_ptr->server_timeout);
+ fprintf(out, "SLURM_CONF = %s\n", slurm_ctl_conf_ptr->slurm_conf);
+ fprintf(out, "TMP_FS = %s\n", slurm_ctl_conf_ptr->tmp_fs);
}
int
-slurm_load_build (time_t update_time, struct build_table **build_table_ptr )
+slurm_load_ctl_conf (time_t update_time, slurm_ctl_conf_t **slurm_ctl_conf_ptr )
{
int msg_size ;
int rc ;
@@ -56,7 +56,7 @@ slurm_load_build (time_t update_time, struct build_table **build_table_ptr )
last_time_msg . last_update = update_time ;
request_msg . msg_type = REQUEST_BUILD_INFO ;
request_msg . data = &last_time_msg ;
-
+
if ( ( rc = slurm_send_controller_msg ( sockfd , & request_msg ) ) == SLURM_SOCKET_ERROR )
return SLURM_SOCKET_ERROR ;
@@ -72,7 +72,7 @@ slurm_load_build (time_t update_time, struct build_table **build_table_ptr )
switch ( response_msg . msg_type )
{
case RESPONSE_BUILD_INFO:
- *build_table_ptr = ( build_info_msg_t * ) response_msg . data ;
+ *slurm_ctl_conf_ptr = ( slurm_ctl_conf_info_msg_t * ) response_msg . data ;
return SLURM_SUCCESS ;
break ;
case RESPONSE_SLURM_RC:
diff --git a/src/api/slurm.h b/src/api/slurm.h
index f92fd5eb9077ce70aaafed2f90b892b87a25d288..4c5e364f8c78a9c0ce4294d471a8b94f4dcce521 100644
--- a/src/api/slurm.h
+++ b/src/api/slurm.h
@@ -87,19 +87,19 @@ extern int slurm_cancel_job (uint32_t job_id);
/***************************
- * build_info.c
+ * slurm_ctl_conf.c
***************************/
/*
- * slurm_free_build_info - free the build information buffer (if allocated)
- * NOTE: buffer is loaded by slurm_load_build.
+ * slurm_free_slurm_ctl_conf - free the build information buffer (if allocated)
+ * NOTE: buffer is loaded by slurm_load_ctl_conf.
*/
-extern void slurm_free_build_info (struct build_table *build_table_ptr);
+extern void slurm_free_ctl_conf ( slurm_ctl_conf_t* slurm_ctl_conf_ptr);
/*
- * slurm_print_build_info - prints the build information buffer (if allocated)
- * NOTE: buffer is loaded by slurm_load_build.
+ * slurm_print_slurm_ctl_conf - prints the build information buffer (if allocated)
+ * NOTE: buffer is loaded by slurm_load_slurm_ctl_conf.
*/
-extern void slurm_print_build_info ( FILE * out, struct build_table * build_table_ptr ) ;
+extern void slurm_print_ctl_conf ( FILE * out, slurm_ctl_conf_t* slurm_ctl_conf ) ;
/*
* slurm_free_job_info - free the job information buffer (if allocated)
@@ -140,7 +140,7 @@ extern void slurm_print_partition_info ( FILE*, partition_info_msg_t * part_info
extern void slurm_print_partition_table ( FILE*, partition_table_t * part_ptr ) ;
/*
- * slurm_load_build - load the slurm build information buffer for use by info
+ * slurm_load_ctl_conf - load the slurm build information buffer for use by info
* gathering APIs if build info has changed since the time specified.
* input: update_time - time of last update
* build_buffer_ptr - place to park build_buffer pointer
@@ -151,8 +151,8 @@ extern void slurm_print_partition_table ( FILE*, partition_table_t * part_ptr )
* ENOMEM if malloc failure
* NOTE: the allocated memory at build_buffer_ptr freed by slurm_free_node_info.
*/
-extern int slurm_load_build (time_t update_time,
- struct build_table **build_table_ptr);
+extern int slurm_load_ctl_conf (time_t update_time,
+ slurm_ctl_conf_t **slurm_ctl_conf_ptr);
/* slurm_load_job - load the supplied job information buffer if changed */
diff --git a/src/common/slurm_protocol_defs.c b/src/common/slurm_protocol_defs.c
index 53a4e80a2b5c3a2cfb494ed49e006a78a92c4679..61fd78d05047af6ca8f032811a50e72bef3dc5ec 100644
--- a/src/common/slurm_protocol_defs.c
+++ b/src/common/slurm_protocol_defs.c
@@ -1,6 +1,6 @@
#include <src/common/slurm_protocol_defs.h>
+#include <src/common/xmalloc.h>
#include <stdlib.h>
-#include <src/slurmctld/slurmctld.h>
/* short messages*/
void slurm_free_last_update_msg ( last_update_msg_t * msg )
{
@@ -20,7 +20,7 @@ void slurm_free_return_code_msg ( return_code_msg_t * msg )
-void slurm_free_build_info ( build_info_msg_t * build_ptr )
+void slurm_free_slurm_ctl_conf ( slurm_ctl_conf_info_msg_t * build_ptr )
{
if ( build_ptr )
{
diff --git a/src/common/slurm_protocol_defs.h b/src/common/slurm_protocol_defs.h
index 1f5c32542e74dc21f6a2350e145538e492672244..0910a457047ccd791dbf6a96355eb3205626c0c8 100644
--- a/src/common/slurm_protocol_defs.h
+++ b/src/common/slurm_protocol_defs.h
@@ -17,6 +17,7 @@
/* true, false */
#define true -1
#define false 0
+#define NO_VAL 0x7f7f7f7f
#include <src/common/slurm_protocol_common.h>
@@ -170,7 +171,7 @@ typedef struct job_desc_msg { /* Job descriptor for submit, allocate, and upd
* to UID by API, can only be set if user is root */
} job_desc_msg_t ;
-struct build_table {
+struct slurm_ctl_conf {
uint32_t last_update; /* last update time of the build parameters*/
uint16_t backup_interval;/* slurmctld save state interval, seconds */
char *backup_location; /* pathname of state save directory */
@@ -192,8 +193,9 @@ struct build_table {
uint16_t server_timeout;/* how long slurmctld waits for setting node DOWN */
char *slurm_conf; /* pathname of slurm config file */
char *tmp_fs; /* pathname of temporary file system */
-};
-typedef struct build_table build_info_msg_t ;
+} ;
+typedef struct slurm_ctl_conf slurm_ctl_conf_t ;
+typedef struct slurm_ctl_conf slurm_ctl_conf_info_msg_t ;
struct job_table {
uint32_t job_id; /* job ID */
@@ -281,7 +283,7 @@ void inline slurm_free_last_update_msg ( last_update_msg_t * msg ) ;
void inline slurm_free_return_code_msg ( return_code_msg_t * msg ) ;
void inline slurm_free_job_id_msg ( job_id_msg_t * msg ) ;
-void inline slurm_free_build_info ( build_info_msg_t * build_ptr ) ;
+void inline slurm_free_slurm_ctl_conf ( slurm_ctl_conf_info_msg_t * build_ptr ) ;
void inline slurm_free_job_desc_msg ( job_desc_msg_t * msg ) ;
void inline slurm_free_node_registration_status_msg ( slurm_node_registration_status_msg_t * msg ) ;
diff --git a/src/common/slurm_protocol_pack.c b/src/common/slurm_protocol_pack.c
index 4647cb1b8847b4bf989a2116e90870fbe7123ba9..1a3f55dffa8e2fa7a982a5f5f7df7371a0ceb9a9 100644
--- a/src/common/slurm_protocol_pack.c
+++ b/src/common/slurm_protocol_pack.c
@@ -6,7 +6,8 @@
#include <src/common/pack.h>
#include <src/common/log.h>
#include <src/common/nodelist.h>
-#include <src/slurmctld/slurmctld.h>
+#include <src/common/xmalloc.h>
+
/* pack_header
* packs a slurm protocol header that proceeds every slurm message
@@ -55,7 +56,7 @@ int pack_msg ( slurm_msg_t const * msg , char ** buffer , uint32_t * buf_len )
pack_last_update ( ( last_update_msg_t * ) msg -> data , ( void ** ) buffer , buf_len ) ;
break;
case RESPONSE_BUILD_INFO:
- pack_build_info ( ( build_info_msg_t * ) msg -> data , (void ** ) buffer , buf_len ) ;
+ pack_slurm_ctl_conf ( ( slurm_ctl_conf_info_msg_t * ) msg -> data , (void ** ) buffer , buf_len ) ;
break ;
case RESPONSE_JOB_INFO:
pack_job_info_msg ( ( slurm_msg_t * ) msg , (void ** ) buffer , buf_len ) ;
@@ -158,7 +159,7 @@ int unpack_msg ( slurm_msg_t * msg , char ** buffer , uint32_t * buf_len )
unpack_last_update ( ( last_update_msg_t **) &(msg -> data) , ( void ** ) buffer , buf_len ) ;
break;
case RESPONSE_BUILD_INFO:
- unpack_build_info ( ( build_info_msg_t ** ) &(msg -> data) , (void ** ) buffer , buf_len ) ;
+ unpack_slurm_ctl_conf ( ( slurm_ctl_conf_info_msg_t ** ) &(msg -> data) , (void ** ) buffer , buf_len ) ;
break;
case RESPONSE_JOB_INFO:
unpack_job_info_msg ( ( job_info_msg_t ** ) &(msg -> data) , (void ** ) buffer , buf_len ) ;
@@ -533,7 +534,7 @@ int unpack_job_table ( job_table_t * job , void ** buf_ptr , int * buffer_size )
return 0 ;
}
-void pack_build_info ( build_info_msg_t * build_ptr, void ** buf_ptr , int * buffer_size )
+void pack_slurm_ctl_conf ( slurm_ctl_conf_info_msg_t * build_ptr, void ** buf_ptr , int * buffer_size )
{
pack32 (build_ptr->last_update, buf_ptr, buffer_size);
pack16 (build_ptr->backup_interval, buf_ptr, buffer_size);
@@ -556,12 +557,12 @@ void pack_build_info ( build_info_msg_t * build_ptr, void ** buf_ptr , int * buf
packstr (build_ptr->tmp_fs, buf_ptr, buffer_size);
}
-int unpack_build_info ( build_info_msg_t **build_buffer_ptr, void ** buffer , int * buffer_size )
+int unpack_slurm_ctl_conf ( slurm_ctl_conf_info_msg_t **build_buffer_ptr, void ** buffer , int * buffer_size )
{
uint16_t uint16_tmp;
- build_info_msg_t * build_ptr ;
+ slurm_ctl_conf_info_msg_t * build_ptr ;
/* alloc memory for structure */
- build_ptr = xmalloc ( sizeof ( struct build_table ) ) ;
+ build_ptr = xmalloc ( sizeof ( slurm_ctl_conf_t ) ) ;
if (build_ptr == NULL)
{
return ENOMEM;
diff --git a/src/common/slurm_protocol_pack.h b/src/common/slurm_protocol_pack.h
index cf726f7bf7dc52cfbe626241c3ca675ec409b58a..e657d67a07853a6f594f1abe0200085436ccf34f 100644
--- a/src/common/slurm_protocol_pack.h
+++ b/src/common/slurm_protocol_pack.h
@@ -40,8 +40,8 @@ int unpack_last_update ( last_update_msg_t ** msg , void ** buffer , uint32_t *
void pack_return_code ( return_code_msg_t * msg , void ** buffer , uint32_t * length );
int unpack_return_code ( return_code_msg_t ** msg , void ** buffer , uint32_t * length );
-void pack_build_info ( build_info_msg_t * build_ptr, void ** buffer , int * buffer_size ) ;
-int unpack_build_info ( build_info_msg_t **build_buffer_ptr, void ** buffer , int * buffer_size ) ;
+void pack_slurm_ctl_conf ( slurm_ctl_conf_info_msg_t * build_ptr, void ** buffer , int * buffer_size ) ;
+int unpack_slurm_ctl_conf ( slurm_ctl_conf_info_msg_t **build_buffer_ptr, void ** buffer , int * buffer_size ) ;
void pack_job_info_msg ( slurm_msg_t * msg , void ** buffer , int * buffer_size ) ;
int unpack_job_info_msg ( job_info_msg_t ** msg , void ** buffer , int * buffer_size ) ;
diff --git a/src/scontrol/scontrol.c b/src/scontrol/scontrol.c
index 4a306950c878fd6efcb98db67993dec2fa13b2d5..b4074fbddc801f46a66aa6cbb9f8398c08ab785b 100644
--- a/src/scontrol/scontrol.c
+++ b/src/scontrol/scontrol.c
@@ -203,91 +203,91 @@ void
print_build (char *build_param)
{
int error_code;
- static build_info_msg_t *old_build_table_ptr = NULL;
- build_info_msg_t *build_table_ptr = NULL;
+ slurm_ctl_conf_info_msg_t *old_slurm_ctl_conf_ptr = NULL;
+ slurm_ctl_conf_info_msg_t *slurm_ctl_conf_ptr = NULL;
- if (old_build_table_ptr) {
- error_code = slurm_load_build (old_build_table_ptr->last_update,
- &build_table_ptr);
+ if (old_slurm_ctl_conf_ptr) {
+ error_code = slurm_load_ctl_conf (old_slurm_ctl_conf_ptr->last_update,
+ &slurm_ctl_conf_ptr);
if (error_code == 0)
- slurm_free_build_info(old_build_table_ptr);
+ slurm_free_ctl_conf(old_slurm_ctl_conf_ptr);
else if (error_code == SLURM_NO_CHANGE_IN_DATA) {
- build_table_ptr = old_build_table_ptr;
+ slurm_ctl_conf_ptr = old_slurm_ctl_conf_ptr;
error_code = 0;
if (quiet_flag == -1)
printf ("slurm_load_build no change in data\n");
}
}
else
- error_code = slurm_load_build ((time_t) NULL, &build_table_ptr);
+ error_code = slurm_load_ctl_conf ((time_t) NULL, &slurm_ctl_conf_ptr);
if (error_code) {
if (quiet_flag != 1)
printf ("slurm_load_build error %d\n", error_code);
return;
}
- old_build_table_ptr = build_table_ptr;
+ old_slurm_ctl_conf_ptr = slurm_ctl_conf_ptr;
if (build_param == NULL ||
strcmp (build_param, "BACKUP_INTERVAL") == 0)
printf ("BACKUP_INTERVAL = %u\n",
- build_table_ptr->backup_interval);
+ slurm_ctl_conf_ptr->backup_interval);
if (build_param == NULL ||
strcmp (build_param, "BACKUP_LOCATION") == 0)
printf ("BACKUP_LOCATION = %s\n",
- build_table_ptr->backup_location);
+ slurm_ctl_conf_ptr->backup_location);
if (build_param == NULL ||
strcmp (build_param, "BACKUP_MACHINE") == 0)
printf ("BACKUP_MACHINE = %s\n",
- build_table_ptr->backup_machine);
+ slurm_ctl_conf_ptr->backup_machine);
if (build_param == NULL ||
strcmp (build_param, "CONTROL_DAEMON") == 0)
printf ("CONTROL_DAEMON = %s\n",
- build_table_ptr->control_daemon);
+ slurm_ctl_conf_ptr->control_daemon);
if (build_param == NULL ||
strcmp (build_param, "CONTROL_MACHINE") == 0)
printf ("CONTROL_MACHINE = %s\n",
- build_table_ptr->control_machine);
+ slurm_ctl_conf_ptr->control_machine);
if (build_param == NULL ||
strcmp (build_param, "EPILOG") == 0)
- printf ("EPILOG = %s\n", build_table_ptr->epilog);
+ printf ("EPILOG = %s\n", slurm_ctl_conf_ptr->epilog);
if (build_param == NULL ||
strcmp (build_param, "FAST_SCHEDULE") == 0)
printf ("FAST_SCHEDULE = %u\n",
- build_table_ptr->fast_schedule);
+ slurm_ctl_conf_ptr->fast_schedule);
if (build_param == NULL ||
strcmp (build_param, "HASH_BASE") == 0)
printf ("HASH_BASE = %u\n",
- build_table_ptr->hash_base);
+ slurm_ctl_conf_ptr->hash_base);
if (build_param == NULL ||
strcmp (build_param, "HEARTBEAT_INTERVAL") == 0)
printf ("HEARTBEAT_INTERVAL = %u\n",
- build_table_ptr->heartbeat_interval);
+ slurm_ctl_conf_ptr->heartbeat_interval);
if (build_param == NULL ||
strcmp (build_param, "INIT_PROGRAM") == 0)
- printf ("INIT_PROGRAM = %s\n", build_table_ptr->init_program);
+ printf ("INIT_PROGRAM = %s\n", slurm_ctl_conf_ptr->init_program);
if (build_param == NULL ||
strcmp (build_param, "KILL_WAIT") == 0)
- printf ("KILL_WAIT = %u\n", build_table_ptr->kill_wait);
+ printf ("KILL_WAIT = %u\n", slurm_ctl_conf_ptr->kill_wait);
if (build_param == NULL ||
strcmp (build_param, "PRIORITIZE") == 0)
- printf ("PRIORITIZE = %s\n", build_table_ptr->prioritize);
+ printf ("PRIORITIZE = %s\n", slurm_ctl_conf_ptr->prioritize);
if (build_param == NULL ||
strcmp (build_param, "PROLOG") == 0)
- printf ("PROLOG = %s\n", build_table_ptr->prolog);
+ printf ("PROLOG = %s\n", slurm_ctl_conf_ptr->prolog);
if (build_param == NULL ||
strcmp (build_param, "SERVER_DAEMON") == 0)
printf ("SERVER_DAEMON = %s\n",
- build_table_ptr->server_daemon);
+ slurm_ctl_conf_ptr->server_daemon);
if (build_param == NULL ||
strcmp (build_param, "SERVER_TIMEOUT") == 0)
printf ("SERVER_TIMEOUT = %u\n",
- build_table_ptr->server_timeout);
+ slurm_ctl_conf_ptr->server_timeout);
if (build_param == NULL ||
strcmp (build_param, "SLURM_CONF") == 0)
- printf ("SLURM_CONF = %s\n", build_table_ptr->slurm_conf);
+ printf ("SLURM_CONF = %s\n", slurm_ctl_conf_ptr->slurm_conf);
if (build_param == NULL ||
strcmp (build_param, "TMP_FS") == 0)
- printf ("TMP_FS = %s\n", build_table_ptr->tmp_fs);
+ printf ("TMP_FS = %s\n", slurm_ctl_conf_ptr->tmp_fs);
}
diff --git a/src/slurmctld/controller.c b/src/slurmctld/controller.c
index 3b3ad8371355f9957bc27516fb472c69f07621f9..13a3bcd23acfd486bcc397c907baa6ce42e948d8 100644
--- a/src/slurmctld/controller.c
+++ b/src/slurmctld/controller.c
@@ -44,10 +44,11 @@
#define BUF_SIZE 1024
time_t init_time;
+slurm_ctl_conf_t slurmctld_conf;
int msg_from_root (void);
void slurmctld_req ( slurm_msg_t * msg );
-void fill_build_table ( struct build_table * build_ptr );
+void fill_build_table ( slurm_ctl_conf_t * build_ptr );
inline static void slurm_rpc_dump_build ( slurm_msg_t * msg ) ;
inline static void slurm_rpc_dump_nodes ( slurm_msg_t * msg ) ;
inline static void slurm_rpc_dump_partitions ( slurm_msg_t * msg ) ;
@@ -182,7 +183,7 @@ slurmctld_req ( slurm_msg_t * msg )
* NOTE: the buffer at *buffer_ptr must be xfreed by the caller
* NOTE: if you make any changes here be sure to increment the value of
* BUILD_STRUCT_VERSION and make the corresponding changes to
- * load_build in api/build_info.c
+ * load_build in api/slurm_ctl_conf.c
*/
void
slurm_rpc_dump_build ( slurm_msg_t * msg )
@@ -190,7 +191,7 @@ slurm_rpc_dump_build ( slurm_msg_t * msg )
clock_t start_time;
slurm_msg_t response_msg ;
last_update_msg_t * last_time_msg = ( last_update_msg_t * ) msg-> data ;
- build_info_msg_t build_tbl ;
+ slurm_ctl_conf_info_msg_t build_tbl ;
start_time = clock ();
@@ -664,7 +665,7 @@ slurm_rpc_register_node_status ( slurm_msg_t * msg )
void
-fill_build_table ( struct build_table * build_ptr )
+fill_build_table ( slurm_ctl_conf_t * build_ptr )
{
build_ptr->last_update = init_time ;
build_ptr->backup_interval = BACKUP_INTERVAL ;
diff --git a/src/slurmctld/job_mgr.c b/src/slurmctld/job_mgr.c
index e6eb5af6c0f8ba9fe1a543573eaad74e4455aee3..ebb26a18567b51ff8e429bd74f53d66884be82de 100644
--- a/src/slurmctld/job_mgr.c
+++ b/src/slurmctld/job_mgr.c
@@ -26,6 +26,18 @@
#define SLURM_CREATE_JOB_FLAG_NO_ALLOCATE_0 0
+/* macros for simple comparisons
+ */
+#define block_or_cycle(in_string) \
+ (strcmp((in_string),"BLOCK")? \
+ (strcmp((in_string),"CYCLE")? \
+ -1 : DIST_CYCLE ) : DIST_BLOCK )
+
+#define yes_or_no(in_string) \
+ (( strcmp ((in_string),"YES"))? \
+ (strcmp((in_string),"NO")? \
+ -1 : 0 ) : 1 )
+
int job_count; /* job's in the system */
List job_list = NULL; /* job_record list */
time_t last_job_update; /* time of last update to job records */
diff --git a/src/slurmctld/slurmctld.h b/src/slurmctld/slurmctld.h
index 172364a26fe8c97dc3ef0798168df79493bed6bd..c19a72f44fcbdc92713e3e0df2daa55172dd36f4 100644
--- a/src/slurmctld/slurmctld.h
+++ b/src/slurmctld/slurmctld.h
@@ -30,6 +30,7 @@
#include "qsw.h"
#endif
#include <src/api/slurm.h>
+#include <src/common/slurm_protocol_defs.h>
#define DEBUG_SYSTEM 1
@@ -53,10 +54,10 @@
extern char *control_machine; /* name of computer acting as slurm controller */
extern char *backup_controller; /* name of computer acting as slurm backup controller */
+extern slurm_ctl_conf_t slurmctld_config;
#define CONFIG_MAGIC 0xc065eded
#define NODE_MAGIC 0x0de575ed
-#define NO_VAL 0x7f7f7f7f
struct config_record {
uint32_t magic; /* magic cookie to test data integrity */
uint32_t cpus; /* count of cpus running on the node */