diff --git a/src/slurmctld/Makefile.am b/src/slurmctld/Makefile.am
index 9f9877af169baf23c684b8d16e14148ba002dbdc..457ef8ed6f73959193fa1182628bc6a4e7add736 100644
--- a/src/slurmctld/Makefile.am
+++ b/src/slurmctld/Makefile.am
@@ -25,7 +25,6 @@ LDADD = $(top_srcdir)/src/common/libcommon.la
slurmctld_SOURCES = \
slurmctld.h \
- parse_spec.c \
controller.c \
job_mgr.c \
job_scheduler.c \
diff --git a/src/slurmctld/controller.c b/src/slurmctld/controller.c
index 819cbca6056d243d8683c59eca97fecc4bf98c3e..b5ed4d3472fcbd6dce952e8372d79888eef016ca 100644
--- a/src/slurmctld/controller.c
+++ b/src/slurmctld/controller.c
@@ -50,6 +50,7 @@ slurm_ctl_conf_t slurmctld_conf;
int msg_from_root (void);
void slurmctld_req ( slurm_msg_t * msg );
void fill_ctld_conf ( slurm_ctl_conf_t * build_ptr );
+void init_ctld_conf ( slurm_ctl_conf_t * build_ptr );
void parse_commandline( int argc, char* argv[], slurm_ctl_conf_t * );
inline static void slurm_rpc_dump_build ( slurm_msg_t * msg ) ;
inline static void slurm_rpc_dump_nodes ( slurm_msg_t * msg ) ;
@@ -83,22 +84,25 @@ main (int argc, char *argv[])
init_time = time (NULL);
log_init(argv[0], opts, SYSLOG_FACILITY_DAEMON, NULL);
- fill_ctld_conf ( &slurmctld_conf );
+ init_ctld_conf ( &slurmctld_conf );
parse_commandline ( argc, argv, &slurmctld_conf );
if ( ( error_code = init_slurm_conf () ) )
fatal ("slurmctld: init_slurm_conf error %d", error_code);
- if ( ( error_code = read_slurm_conf ( slurmctld_conf.slurm_conf )) )
- fatal ("slurmctld: error %d from read_slurm_conf reading %s", error_code, SLURM_CONF);
+ if ( ( error_code = read_slurm_conf ()) )
+ fatal ("slurmctld: error %d from read_slurm_conf reading %s", error_code, SLURM_CONFIG_FILE);
if ( ( error_code = gethostname (node_name, MAX_NAME_LEN) ) )
fatal ("slurmctld: errno %d from gethostname", errno);
if ( strcmp (node_name, slurmctld_conf.control_machine) &&
- strcmp (node_name, slurmctld_conf.backup_machine) )
+ strcmp (node_name, slurmctld_conf.backup_controller) &&
+ strcmp ("localhost", slurmctld_conf.control_machine) &&
+ strcmp ("localhost", slurmctld_conf.backup_controller) )
fatal ("slurmctld: this machine (%s) is not the primary (%s) or backup (%s) controller",
- node_name, slurmctld_conf.control_machine, slurmctld_conf.backup_machine);
+ node_name, slurmctld_conf.control_machine, slurmctld_conf.backup_controller);
- if ( ( sockfd = slurm_init_msg_engine_port ( SLURM_PORT ) ) == SLURM_SOCKET_ERROR )
+ if ( ( sockfd = slurm_init_msg_engine_port ( slurmctld_conf . slurmctld_port ) )
+ == SLURM_SOCKET_ERROR )
fatal ("slurmctld: error starting message engine \n", errno);
while (1)
@@ -642,7 +646,7 @@ slurm_rpc_reconfigure_controller ( slurm_msg_t * msg )
/* do RPC call */
error_code = init_slurm_conf ();
if (error_code == 0)
- error_code = read_slurm_conf (SLURM_CONF);
+ error_code = read_slurm_conf ( );
reset_job_bitmaps ();
/* return result */
@@ -754,47 +758,42 @@ slurm_rpc_node_registration ( slurm_msg_t * msg )
void
init_ctld_conf ( slurm_ctl_conf_t * conf_ptr )
{
- conf_ptr->last_update = init_time ;
- conf_ptr->backup_interval = 0 ;
- conf_ptr->backup_location = NULL ;
- conf_ptr->backup_machine = NULL ;
- conf_ptr->control_daemon = NULL ;
- conf_ptr->control_machine = NULL ;
- conf_ptr->controller_timeout = 0 ;
+ conf_ptr->last_update = init_time ;
+ conf_ptr->backup_controller = NULL ;
+ conf_ptr->control_machine = NULL ;
conf_ptr->epilog = NULL ;
- conf_ptr->fast_schedule = 0 ;
- conf_ptr->hash_base = 0 ;
- conf_ptr->heartbeat_interval = 0;
- conf_ptr->kill_wait = 0 ;
+ conf_ptr->fast_schedule = 1 ;
+ conf_ptr->hash_base = 10 ;
+ conf_ptr->heartbeat_interval = 30;
+ conf_ptr->kill_wait = 30 ;
conf_ptr->prioritize = NULL ;
conf_ptr->prolog = NULL ;
- conf_ptr->server_daemon = NULL ;
- conf_ptr->server_timeout = 0 ;
- conf_ptr->slurm_conf = NULL ;
+ conf_ptr->slurmctld_timeout = 300 ;
+ conf_ptr->slurmd_timeout = 300 ;
+ conf_ptr->slurm_conf = SLURM_CONFIG_FILE ;
+ conf_ptr->state_save_location = NULL ;
conf_ptr->tmp_fs = NULL ;
}
+
void
fill_ctld_conf ( slurm_ctl_conf_t * conf_ptr )
{
conf_ptr->last_update = init_time ;
- conf_ptr->backup_interval = BACKUP_INTERVAL ;
- conf_ptr->backup_location = BACKUP_LOCATION ;
- conf_ptr->backup_machine = slurmctld_conf.backup_machine ;
- conf_ptr->control_daemon = CONTROL_DAEMON ;
+ conf_ptr->backup_controller = slurmctld_conf.backup_controller ;
conf_ptr->control_machine = slurmctld_conf.control_machine ;
- conf_ptr->controller_timeout = CONTROLLER_TIMEOUT ;
- conf_ptr->epilog = EPILOG ;
- conf_ptr->fast_schedule = FAST_SCHEDULE ;
- conf_ptr->hash_base = HASH_BASE ;
- conf_ptr->heartbeat_interval = HEARTBEAT_INTERVAL;
- conf_ptr->kill_wait = KILL_WAIT ;
- conf_ptr->prioritize = PRIORITIZE ;
- conf_ptr->prolog = PROLOG ;
- conf_ptr->server_daemon = SERVER_DAEMON ;
- conf_ptr->server_timeout = SERVER_TIMEOUT ;
- conf_ptr->slurm_conf = SLURM_CONF ;
- conf_ptr->tmp_fs = TMP_FS ;
+ conf_ptr->epilog = slurmctld_conf.epilog ;
+ conf_ptr->fast_schedule = slurmctld_conf.fast_schedule ;
+ conf_ptr->hash_base = slurmctld_conf.hash_base ;
+ conf_ptr->heartbeat_interval = slurmctld_conf.heartbeat_interval;
+ conf_ptr->kill_wait = slurmctld_conf.kill_wait ;
+ conf_ptr->prioritize = slurmctld_conf.prioritize ;
+ conf_ptr->prolog = slurmctld_conf.prolog ;
+ conf_ptr->slurmctld_timeout = slurmctld_conf.slurmctld_timeout ;
+ conf_ptr->slurmd_timeout = slurmctld_conf.slurmd_timeout ;
+ conf_ptr->slurm_conf = SLURM_CONFIG_FILE ;
+ conf_ptr->state_save_location = slurmctld_conf.state_save_location ;
+ conf_ptr->tmp_fs = slurmctld_conf.tmp_fs ;
}
@@ -812,8 +811,8 @@ parse_commandline( int argc, char* argv[], slurm_ctl_conf_t * conf_ptr )
switch (c)
{
case 'b':
- conf_ptr->backup_machine = optarg;
- printf("backup_machine = %s\n", conf_ptr->backup_machine );
+ conf_ptr->backup_controller = optarg;
+ printf("backup_controller = %s\n", conf_ptr->backup_controller );
break;
case 'c':
conf_ptr->control_machine = optarg;
diff --git a/src/slurmctld/job_mgr.c b/src/slurmctld/job_mgr.c
index b6226d14b01e4dcb9a5c22902ddc06d6a69b2bf0..0adf96ea6c383f44bef11cc75875b818f949a345 100644
--- a/src/slurmctld/job_mgr.c
+++ b/src/slurmctld/job_mgr.c
@@ -1124,9 +1124,12 @@ reset_job_bitmaps ()
void
set_job_id (struct job_record *job_ptr)
{
- static uint32_t id_sequence = FIRST_JOB_ID;
+ static long id_sequence = -1;
uint32_t new_id;
+ if (id_sequence < 0)
+ id_sequence = slurmctld_conf . first_job_id;
+
if ((job_ptr == NULL) ||
(job_ptr->magic != JOB_MAGIC))
fatal ("set_job_id: invalid job_ptr");
diff --git a/src/slurmctld/node_mgr.c b/src/slurmctld/node_mgr.c
index e85c224f0ecb00525d34681b3f235cb4ccc19c5f..da521073c2cbd487accff3b3957bc0a4de3169b5 100644
--- a/src/slurmctld/node_mgr.c
+++ b/src/slurmctld/node_mgr.c
@@ -865,7 +865,7 @@ pack_node (struct node_record *dump_node_ptr, void **buf_ptr, int *buf_len)
{
packstr (dump_node_ptr->name, buf_ptr, buf_len);
pack16 (dump_node_ptr->node_state, buf_ptr, buf_len);
- if (FAST_SCHEDULE) { /* Only data from config_record used for scheduling */
+ if (slurmctld_conf.fast_schedule) { /* Only data from config_record used for scheduling */
pack32 (dump_node_ptr->config_ptr->cpus, buf_ptr, buf_len);
pack32 (dump_node_ptr->config_ptr->real_memory, buf_ptr, buf_len);
pack32 (dump_node_ptr->config_ptr->tmp_disk, buf_ptr, buf_len);
diff --git a/src/slurmctld/node_scheduler.c b/src/slurmctld/node_scheduler.c
index 7dcf0bc7e239e3f0a0b0087eb71eb324158a18be..9aed6a6e1813a224db6482d24a932f7e6ed79cb3 100644
--- a/src/slurmctld/node_scheduler.c
+++ b/src/slurmctld/node_scheduler.c
@@ -744,7 +744,7 @@ select_nodes (struct job_record *job_ptr, int test_only)
if ((job_ptr->details->min_procs > config_record_point->cpus) ||
(job_ptr->details->min_memory > config_record_point->real_memory) ||
(job_ptr->details->min_tmp_disk > config_record_point->tmp_disk)) {
- if (FAST_SCHEDULE) /* don't bother checking each node */
+ if (slurmctld_conf.fast_schedule) /* don't bother checking each node */
continue;
check_node_config = 1;
}
diff --git a/src/slurmctld/read_config.c b/src/slurmctld/read_config.c
index 7e2fd96be30e62daa548cb2f3aff9d44e74e917a..e539b5023fe4e40919b77f83e5481710776c6d6a 100644
--- a/src/slurmctld/read_config.c
+++ b/src/slurmctld/read_config.c
@@ -2,10 +2,6 @@
* read_config.c - read the overall slurm configuration file
* see slurm.h for documentation on external functions and data structures
*
- * NOTE: DEBUG_MODULE mode test with execution line
- * read_config ../../etc/slurm.conf1
- * read_config ../../etc/slurm.conf1 1000
- *
* author: moe jette, jette@llnl.gov
*/
@@ -32,14 +28,9 @@ int parse_part_spec (char *in_line);
int node_record_count = 0;
-#if DEBUG_MODULE
-slurm_ctl_conf_t slurmctld_conf;
-#else
-extern slurm_ctl_conf_t slurmctld_conf;
-#endif
-
#if DEBUG_MODULE
/* main is used here for module testing purposes only */
+slurm_ctl_conf_t slurmctld_conf;
#include <sys/resource.h>
int
main (int argc, char *argv[]) {
@@ -62,11 +53,7 @@ main (int argc, char *argv[]) {
printf ("ERROR %d from init_slurm_conf\n", error_code);
exit (error_code);
}
-
- if (argc >= 2)
- error_code = read_slurm_conf (argv[1]);
- else
- error_code = read_slurm_conf (SLURM_CONF);
+ error_code = read_slurm_conf ( );
if (error_code) {
printf ("ERROR %d from read_slurm_conf\n", error_code);
@@ -150,7 +137,7 @@ main (int argc, char *argv[]) {
exit (error_code);
}
- error_code = read_slurm_conf (argv[1]);
+ error_code = read_slurm_conf ( );
if (error_code) {
printf ("ERROR %d from read_slurm_conf\n",
error_code);
@@ -327,8 +314,6 @@ build_bitmaps () {
* init_slurm_conf - initialize or re-initialize the slurm configuration
* values. this should be called before calling read_slurm_conf.
* output: return value - 0 if no error, otherwise an error code
- * globals: control_machine - name of primary slurmctld machine
- * backup_controller - name of backup slurmctld machine
*/
int
init_slurm_conf () {
@@ -676,41 +661,41 @@ parse_part_spec (char *in_line) {
/*
- * read_slurm_conf - load the slurm configuration from the specified file.
+ * read_slurm_conf - load the slurm configuration from the configured file.
* read_slurm_conf can be called more than once if so desired.
- * input: file_name - name of the file containing overall slurm configuration information
* output: return - 0 if no error, otherwise an error code
- * global: control_machine - primary machine on which slurmctld runs
- * backup_controller - backup machine on which slurmctld runs
- * default_part_loc - pointer to default partition
* NOTE: call init_slurm_conf before ever calling read_slurm_conf.
*/
int
-read_slurm_conf (char *file_name) {
+read_slurm_conf ( ) {
+ clock_t start_time;
FILE *slurm_spec_file; /* pointer to input data file */
int line_num; /* line number in input file */
char in_line[BUF_SIZE]; /* input line */
int i, j, error_code;
+ char *backup_controller = NULL, *control_machine = NULL, *epilog = NULL;
+ char *prioritize = NULL, *prolog = NULL, *state_save_location = NULL, *tmp_fs = NULL;
+ int fast_schedule = 0, hash_base = 0, heartbeat_interval = 0, kill_wait = 0;
+ int slurmctld_port = 0, slurmctld_timeout = 0, slurmd_port = 0;
+ int slurmd_timeout = 0;
+ long first_job_id = 0;
/* initialization */
- slurm_spec_file = fopen (file_name, "r");
- if (slurm_spec_file == NULL) {
- fatal ("read_slurm_conf error %d opening file %s", errno, file_name);
- return errno;
- }
+ start_time = clock ();
+ slurm_spec_file = fopen (SLURM_CONFIG_FILE, "r");
+ if (slurm_spec_file == NULL)
+ fatal ("read_slurm_conf error %d opening file %s", errno, SLURM_CONFIG_FILE);
- info ("read_slurm_conf: loading configuration from %s", file_name);
+ info ("read_slurm_conf: loading configuration from %s", SLURM_CONFIG_FILE);
/* process the data file */
line_num = 0;
while (fgets (in_line, BUF_SIZE, slurm_spec_file) != NULL) {
- char* control_machine = NULL;
- char* backup_machine = NULL;
line_num++;
if (strlen (in_line) >= (BUF_SIZE - 1)) {
error ("read_slurm_conf line %d, of input file %s too long\n",
- line_num, file_name);
+ line_num, SLURM_CONFIG_FILE);
fclose (slurm_spec_file);
return E2BIG;
break;
@@ -736,19 +721,101 @@ read_slurm_conf (char *file_name) {
/* parse what is left */
/* overall slurm configuration parameters */
error_code = slurm_parser(in_line,
+ "BackupController=", 's', &backup_controller,
"ControlMachine=", 's', &control_machine,
- "BackupController=", 's', &backup_machine,
+ "Epilog=", 's', &epilog,
+ "FastSchedule=", 'd', &fast_schedule,
+ "FirstJobId=", 'l', &first_job_id,
+ "HashBase=", 'd', &hash_base,
+ "HeartbeatInterval=", 'd', &heartbeat_interval,
+ "KillWait=", 'd', &kill_wait,
+ "Prioritize=", 's', &prioritize,
+ "Prolog=", 's', &prolog,
+ "SlurmctldPort=", 'd', &slurmctld_port,
+ "SlurmctldTimeout=", 'd', &slurmctld_timeout,
+ "SlurmdPort=", 'd', &slurmd_port,
+ "SlurmdTimeout=", 'd', &slurmd_timeout,
+ "StateSaveLocation=", 's', &state_save_location,
+ "TmpFS=", 's', &tmp_fs,
"END");
if (error_code) {
fclose (slurm_spec_file);
return error_code;
}
- if ( slurmctld_conf.control_machine == NULL ) {
+ if ( backup_controller ) {
+ if ( slurmctld_conf.backup_controller )
+ xfree (slurmctld_conf.backup_controller);
+ slurmctld_conf.backup_controller = backup_controller;
+ backup_controller = NULL;
+ }
+ if ( control_machine ) {
+ if ( slurmctld_conf.control_machine )
+ xfree (slurmctld_conf.control_machine);
slurmctld_conf.control_machine = control_machine;
+ control_machine = NULL;
+ }
+ if ( epilog ) {
+ if ( slurmctld_conf.epilog )
+ xfree (slurmctld_conf.epilog);
+ slurmctld_conf.epilog = epilog;
+ epilog = NULL;
+ }
+ if ( fast_schedule ) {
+ slurmctld_conf.fast_schedule = fast_schedule;
+ fast_schedule = 0;
+ }
+ if ( first_job_id ) {
+ slurmctld_conf.first_job_id = first_job_id;
+ first_job_id = 0;
}
- if ( slurmctld_conf.backup_machine == NULL ) {
- slurmctld_conf.backup_machine = backup_machine;
+ if ( hash_base ) {
+ slurmctld_conf.hash_base = hash_base;
+ hash_base = 0;
+ }
+ if ( kill_wait ) {
+ slurmctld_conf.kill_wait = kill_wait;
+ kill_wait = 0;
+ }
+ if ( prioritize ) {
+ if ( slurmctld_conf.prioritize )
+ xfree (slurmctld_conf.prioritize);
+ slurmctld_conf.prioritize = prioritize;
+ prioritize = NULL;
+ }
+ if ( prolog ) {
+ if ( slurmctld_conf.prolog )
+ xfree (slurmctld_conf.prolog);
+ slurmctld_conf.prolog = prolog;
+ prolog = NULL;
+ }
+ if ( slurmctld_port ) {
+ slurmctld_conf.slurmctld_port = slurmctld_port;
+ slurmctld_port = 0;
+ }
+ if ( slurmctld_timeout ) {
+ slurmctld_conf.slurmctld_timeout = slurmctld_timeout;
+ slurmctld_timeout = 0;
+ }
+ if ( slurmd_port ) {
+ slurmctld_conf.slurmd_port = slurmd_port;
+ slurmd_port = 0;
+ }
+ if ( slurmd_timeout ) {
+ slurmctld_conf.slurmd_timeout = slurmd_timeout;
+ slurmd_timeout = 0;
+ }
+ if ( state_save_location ) {
+ if ( slurmctld_conf.state_save_location )
+ xfree (slurmctld_conf.state_save_location);
+ slurmctld_conf.state_save_location = state_save_location;
+ state_save_location = NULL;
+ }
+ if ( tmp_fs ) {
+ if ( slurmctld_conf.tmp_fs )
+ xfree (slurmctld_conf.tmp_fs);
+ slurmctld_conf.tmp_fs = tmp_fs;
+ tmp_fs = NULL;
}
/* node configuration parameters */
@@ -769,7 +836,7 @@ read_slurm_conf (char *file_name) {
fclose (slurm_spec_file);
/* if values not set in configuration file, set defaults */
- if (slurmctld_conf.backup_machine == NULL)
+ if (slurmctld_conf.backup_controller == NULL)
info ("read_slurm_conf: backup_controller value not specified.");
if (slurmctld_conf.control_machine == NULL) {
@@ -786,7 +853,10 @@ read_slurm_conf (char *file_name) {
return error_code;
list_sort (config_list, &list_compare_config);
- info ("read_slurm_conf: finished loading configuration");
+ info ("read_slurm_conf: finished loading configuration, time =%ld",
+ (long) (clock () - start_time));
- return 0;
+ return SLURM_SUCCESS
+
+;
}
diff --git a/src/slurmctld/slurmctld.h b/src/slurmctld/slurmctld.h
index db3610835bcdc2c60588f05cf62024a3fa9d28c0..f18664c2e520f547088150b4010b00f2e2aa1cfc 100644
--- a/src/slurmctld/slurmctld.h
+++ b/src/slurmctld/slurmctld.h
@@ -42,37 +42,10 @@
#include <src/common/log.h>
#include <src/common/macros.h>
#include <src/common/pack.h>
-#include <src/common/slurm_protocol_defs.h>
+#include <src/common/slurm_protocol_api.h>
#include <src/common/xmalloc.h>
-#if DEBUG_MODULE
-slurm_ctl_conf_t slurmctld_conf;
-#else
extern slurm_ctl_conf_t slurmctld_conf;
-#endif
-
-#define BACKUP_INTERVAL 60
-#define BACKUP_LOCATION "/usr/local/slurm/slurm.state"
-#define CONTROL_DAEMON "/usr/local/slurm/slurmd.control"
-#define CONTROLLER_TIMEOUT 300
-#define EPILOG ""
-#define FAST_SCHEDULE 1
-#define HASH_BASE 10
-#define HEARTBEAT_INTERVAL 60
-#define INIT_PROGRAM ""
-#define FIRST_JOB_ID (1 << 16)
-#define KILL_WAIT 30
-#define PRIORITIZE ""
-#define PROLOG ""
-#define SERVER_DAEMON "/usr/local/slurm/slurmd.server"
-#define SERVER_TIMEOUT 300
-#define SLURM_CONF "../../etc/slurm.conf2"
-#define TMP_FS "/tmp"
-
-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
@@ -380,8 +353,6 @@ extern int init_part_conf ();
* init_slurm_conf - initialize or re-initialize the slurm configuration
* values. this should be called before calling read_slurm_conf.
* output: return value - 0 if no error, otherwise an error code
- * globals: control_machine - name of primary slurmctld machine
- * backup_controller - name of backup slurmctld machine
*/
extern int init_slurm_conf ();
@@ -584,16 +555,12 @@ extern void part_unlock ();
void purge_old_job (void);
/*
- * read_slurm_conf - load the slurm configuration from the specified file.
+ * read_slurm_conf - load the slurm configuration from the configured file.
* read_slurm_conf can be called more than once if so desired.
- * input: file_name - name of the file containing overall slurm configuration information
* output: return - 0 if no error, otherwise an error code
- * global: control_machine - primary machine on which slurmctld runs
- * backup_controller - backup machine on which slurmctld runs
- * default_part_loc - pointer to default partition
* NOTE: call init_slurm_conf before ever calling read_slurm_conf.
*/
-extern int read_slurm_conf (char *file_name);
+extern int read_slurm_conf ( );
/*
* rehash - build a hash table of the node_record entries. this is a large hash table
diff --git a/src/slurmd/slurmd.c b/src/slurmd/slurmd.c
index a7fe3b7e5ebebd5e3f0b69010e397fe0814acfcd..b7ced7509226d668bcce7475677cbf0001014d06 100644
--- a/src/slurmd/slurmd.c
+++ b/src/slurmd/slurmd.c
@@ -1,5 +1,5 @@
/*****************************************************************************\
- * controller.c - main control machine daemon for slurm
+ * slurmd.c - main server machine daemon for slurm
*****************************************************************************
* Copyright (C) 2002 The Regents of the University of California.
* Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
@@ -52,6 +52,7 @@
time_t init_time;
slurmd_shmem_t * shmem_seg ;
+static slurm_ctl_conf_t slurmctld_conf;
/* function prototypes */
void * request_thread ( void * arg ) ;
@@ -73,8 +74,8 @@ int main (int argc, char *argv[])
/*
if ( ( error_code = init_slurm_conf () ) )
fatal ("slurmd: init_slurm_conf error %d", error_code);
- if ( ( error_code = read_slurm_conf (SLURM_CONF) ) )
- fatal ("slurmd: error %d from read_slurm_conf reading %s", error_code, SLURM_CONF);
+ if ( ( error_code = read_slurm_conf ( ) ) )
+ fatal ("slurmd: error %d from read_slurm_conf reading %s", error_code, SLURM_CONFIG_FILE);
*/
/* shared memory init */
@@ -146,8 +147,12 @@ int slurmd_msg_engine ( void * args )
pthread_t request_thread_id ;
pthread_attr_t thread_attr ;
- if ( ( sockfd = slurm_init_msg_engine_port ( SLURM_PORT+1 ) ) == SLURM_SOCKET_ERROR )
- fatal ("slurmctld: error starting message engine \n", errno);
+ if ( ( error_code = read_slurm_port_config ( ) ) )
+ fatal ("slurmd: error reading configuration file \n", error_code);
+
+ if ( ( sockfd = slurm_init_msg_engine_port ( slurmctld_conf.slurmd_port ) )
+ == SLURM_SOCKET_ERROR )
+ fatal ("slurmd: error starting message engine \n", errno);
#ifdef PTHREAD_IMPL
if ( ( error_code = pthread_attr_init ( & thread_attr ) ) )
{
diff --git a/src/test/slurm_protocol_message_server_daemon.c b/src/test/slurm_protocol_message_server_daemon.c
index d5579725ad237e8386d511b99ab9765ff0930590..868a6a7bef7742ea85b196105317f3cf1c21f35e 100644
--- a/src/test/slurm_protocol_message_server_daemon.c
+++ b/src/test/slurm_protocol_message_server_daemon.c
@@ -1,5 +1,5 @@
/*****************************************************************************\
- * controller.c - main control machine daemon for slurm
+ * slurm_protocol_message_server_daemon.c -
*****************************************************************************
* Copyright (C) 2002 The Regents of the University of California.
* Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
@@ -67,13 +67,14 @@ main (int argc, char *argv[])
if ( ( error_code = init_slurm_conf () ) )
fatal ("slurmd: init_slurm_conf error %d", error_code);
- if ( ( error_code = read_slurm_conf (SLURM_CONF) ) )
- fatal ("slurmd: error %d from read_slurm_conf reading %s", error_code, SLURM_CONF);
+ if ( ( error_code = read_slurm_conf ( ) ) )
+ fatal ("slurmd: error %d from read_slurm_conf reading %s", error_code, SLURM_CONFIG_FILE);
if ( ( error_code = gethostname (node_name, MAX_NAME_LEN) ) )
fatal ("slurmd: errno %d from gethostname", errno);
- if ( ( sockfd = slurm_init_msg_engine_port ( SLURM_PORT ) ) == SLURM_SOCKET_ERROR )
+ if ( ( sockfd = slurm_init_msg_engine_port ( SLURM_PROTOCOL_DEFAULT_SLURMCTLD_PORT ) )
+ == SLURM_SOCKET_ERROR )
fatal ("slurmctld: error starting message engine \n", errno);
while (1)
@@ -171,7 +172,7 @@ slurm_rpc_ex_example ( slurm_msg_t * msg )
/* do RPC call */
/*error_code = init_slurm_conf ();
if (error_code == 0)
- error_code = read_slurm_conf (SLURM_CONF);
+ error_code = read_slurm_conf ( );
reset_job_bitmaps ();
*/
/* return result */