Logo Search packages:      
Sourcecode: slurm-llnl version File versions  Download package

scontrol.c

/*****************************************************************************\
 *  scontrol.c - administration tool for slurm. 
 *    provides interface to read, write, update, and configurations.
 *****************************************************************************
 *  Copyright (C) 2002-2007 The Regents of the University of California.
 *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
 *  Written by Morris Jette <jette1@llnl.gov>
 *  UCRL-CODE-226842.
 *  
 *  This file is part of SLURM, a resource management program.
 *  For details, see <http://www.llnl.gov/linux/slurm/>.
 *  
 *  SLURM is free software; you can redistribute it and/or modify it under
 *  the terms of the GNU General Public License as published by the Free
 *  Software Foundation; either version 2 of the License, or (at your option)
 *  any later version.
 *
 *  In addition, as a special exception, the copyright holders give permission 
 *  to link the code of portions of this program with the OpenSSL library under
 *  certain conditions as described in each individual source file, and 
 *  distribute linked combinations including the two. You must obey the GNU 
 *  General Public License in all respects for all of the code used other than 
 *  OpenSSL. If you modify file(s) with this exception, you may extend this 
 *  exception to your version of the file(s), but you are not obligated to do 
 *  so. If you do not wish to do so, delete this exception statement from your
 *  version.  If you delete this exception statement from all source files in 
 *  the program, then also delete it here.
 *  
 *  SLURM is distributed in the hope that it will be useful, but WITHOUT ANY
 *  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 *  FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 *  details.
 *  
 *  You should have received a copy of the GNU General Public License along
 *  with SLURM; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA.
\*****************************************************************************/

#include "scontrol.h"

#define OPT_LONG_HIDE   0x102

char *command_name;
int all_flag;           /* display even hidden partitions */
int exit_code;          /* scontrol's exit code, =1 on any error at any time */
int exit_flag;          /* program to terminate if =1 */
int input_words;  /* number of words of input permitted */
int one_liner;          /* one record per line if =1 */
int quiet_flag;         /* quiet=1, verbose=-1, normal=0 */

static void _delete_it (int argc, char *argv[]);
static int  _get_command (int *argc, char *argv[]);
static void     _ping_slurmctld(char *control_machine, char *backup_controller);
static void _print_config (char *config_param);
static void     _print_daemons (void);
static void _print_ping (void);
static void _print_slurmd(char *hostlist);
static void     _print_version( void );
static int  _process_command (int argc, char *argv[]);
static void _update_it (int argc, char *argv[]);
static int  _update_bluegene_block (int argc, char *argv[]);
static int      _update_bluegene_subbp (int argc, char *argv[]);
static void _usage ();

int 
main (int argc, char *argv[]) 
{
      int error_code = SLURM_SUCCESS, i, opt_char, input_field_count;
      char **input_fields;
      log_options_t opts = LOG_OPTS_STDERR_ONLY ;

      int option_index;
      static struct option long_options[] = {
            {"all",      0, 0, 'a'},
            {"help",     0, 0, 'h'},
            {"hide",     0, 0, OPT_LONG_HIDE},
            {"oneliner", 0, 0, 'o'},
            {"quiet",    0, 0, 'q'},
            {"usage",    0, 0, 'h'},
            {"verbose",  0, 0, 'v'},
            {"version",  0, 0, 'V'},
            {NULL,       0, 0, 0}
      };

      command_name      = argv[0];
      all_flag          = 0;
      exit_code         = 0;
      exit_flag         = 0;
      input_field_count = 0;
      quiet_flag        = 0;
      log_init("scontrol", opts, SYSLOG_FACILITY_DAEMON, NULL);

      if (getenv ("SCONTROL_ALL"))
            all_flag= 1;

      while((opt_char = getopt_long(argc, argv, "ahoqvV",
                  long_options, &option_index)) != -1) {
            switch (opt_char) {
            case (int)'?':
                  fprintf(stderr, "Try \"scontrol --help\" for more information\n");
                  exit(1);
                  break;
            case (int)'a':
                  all_flag = 1;
                  break;
            case (int)'h':
                  _usage ();
                  exit(exit_code);
                  break;
            case OPT_LONG_HIDE:
                  all_flag = 0;
                  break;
            case (int)'o':
                  one_liner = 1;
                  break;
            case (int)'q':
                  quiet_flag = 1;
                  break;
            case (int)'v':
                  quiet_flag = -1;
                  break;
            case (int)'V':
                  _print_version();
                  exit(exit_code);
                  break;
            default:
                  exit_code = 1;
                  fprintf(stderr, "getopt error, returned %c\n", opt_char);
                  exit(exit_code);
            }
      }

      if (argc > MAX_INPUT_FIELDS)  /* bogus input, but continue anyway */
            input_words = argc;
      else
            input_words = 128;
      input_fields = (char **) xmalloc (sizeof (char *) * input_words);
      if (optind < argc) {
            for (i = optind; i < argc; i++) {
                  input_fields[input_field_count++] = argv[i];
            }     
      }

      if (input_field_count)
            exit_flag = 1;
      else
            error_code = _get_command (&input_field_count, input_fields);

      while (error_code == SLURM_SUCCESS) {
            error_code = _process_command (input_field_count, 
                                     input_fields);
            if (error_code || exit_flag)
                  break;
            error_code = _get_command (&input_field_count, input_fields);
      }                 

      exit(exit_code);
}

static void _print_version(void)
{
      printf("%s %s\n", PACKAGE, SLURM_VERSION);
      if (quiet_flag == -1) {
            long version = slurm_api_version();
            printf("slurm_api_version: %ld, %ld.%ld.%ld\n", version,
                  SLURM_VERSION_MAJOR(version), 
                  SLURM_VERSION_MINOR(version),
                  SLURM_VERSION_MICRO(version));
      }
}


#if !HAVE_READLINE
/*
 * Alternative to readline if readline is not available
 */
static char *
getline(const char *prompt)
{
      char buf[4096];
      char *line;
      int len;

      printf("%s", prompt);

      fgets(buf, 4096, stdin);
      len = strlen(buf);
      if ((len > 0) && (buf[len-1] == '\n'))
            buf[len-1] = '\0';
      else
            len++;
      line = malloc (len * sizeof(char));
      return strncpy(line, buf, len);
}
#endif

/*
 * _get_command - get a command from the user
 * OUT argc - location to store count of arguments
 * OUT argv - location to store the argument list
 */
static int 
_get_command (int *argc, char **argv) 
{
      char *in_line;
      static char *last_in_line = NULL;
      int i, in_line_size;
      static int last_in_line_size = 0;

      *argc = 0;

#if HAVE_READLINE
      in_line = readline ("scontrol: ");
#else
      in_line = getline("scontrol: ");
#endif
      if (in_line == NULL)
            return 0;
      else if (strcmp (in_line, "!!") == 0) {
            free (in_line);
            in_line = last_in_line;
            in_line_size = last_in_line_size;
      } else {
            if (last_in_line)
                  free (last_in_line);
            last_in_line = in_line;
            last_in_line_size = in_line_size = strlen (in_line);
      }

#if HAVE_READLINE
      add_history(in_line);
#endif

      /* break in_line into tokens */
      for (i = 0; i < in_line_size; i++) {
            bool double_quote = false, single_quote = false;
            if (in_line[i] == '\0')
                  break;
            if (isspace ((int) in_line[i]))
                  continue;
            if (((*argc) + 1) > MAX_INPUT_FIELDS) {   /* bogus input line */
                  exit_code = 1;
                  fprintf (stderr, 
                         "%s: can not process over %d words\n",
                         command_name, input_words);
                  return E2BIG;
            }           
            argv[(*argc)++] = &in_line[i];
            for (i++; i < in_line_size; i++) {
                  if (in_line[i] == '\042') {
                        double_quote = !double_quote;
                        continue;
                  }
                  if (in_line[i] == '\047') {
                        single_quote = !single_quote;
                        continue;
                  }
                  if (in_line[i] == '\0')
                        break;
                  if (double_quote || single_quote)
                        continue;
                  if (isspace ((int) in_line[i])) {
                        in_line[i] = '\0';
                        break;
                  }
            }           
      }
      return 0;         
}

/* 
 * _print_config - print the specified configuration parameter and value 
 * IN config_param - NULL to print all parameters and values
 */
static void 
_print_config (char *config_param)
{
      int error_code;
      static 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_slurm_ctl_conf_ptr) {
            error_code = slurm_load_ctl_conf (
                        old_slurm_ctl_conf_ptr->last_update,
                   &slurm_ctl_conf_ptr);
            if (error_code == SLURM_SUCCESS)
                  slurm_free_ctl_conf(old_slurm_ctl_conf_ptr);
            else if (slurm_get_errno () == SLURM_NO_CHANGE_IN_DATA) {
                  slurm_ctl_conf_ptr = old_slurm_ctl_conf_ptr;
                  error_code = SLURM_SUCCESS;
                  if (quiet_flag == -1)
                        printf ("slurm_load_ctl_conf no change in data\n");
            }
      }
      else
            error_code = slurm_load_ctl_conf ((time_t) NULL, 
                                      &slurm_ctl_conf_ptr);

      if (error_code) {
            exit_code = 1;
            if (quiet_flag != 1)
                  slurm_perror ("slurm_load_ctl_conf error");
      }
      else
            old_slurm_ctl_conf_ptr = slurm_ctl_conf_ptr;


      if (error_code == SLURM_SUCCESS) {
            slurm_print_ctl_conf (stdout, slurm_ctl_conf_ptr) ;
            fprintf(stdout, "\n"); 
      }
      if (slurm_ctl_conf_ptr)
            _ping_slurmctld (slurm_ctl_conf_ptr->control_machine,
                         slurm_ctl_conf_ptr->backup_controller);
}

/* Print slurmd status on localhost. 
 * Parse hostlist in the future */
static void _print_slurmd(char *hostlist)
{
      slurmd_status_t *slurmd_status;

      if (slurm_load_slurmd_status(&slurmd_status)) {
            exit_code = 1;
            if (quiet_flag != 1)
                  slurm_perror("slurm_load_slurmd_status");
      } else {
            slurm_print_slurmd_status(stdout, slurmd_status);
            slurm_free_slurmd_status(slurmd_status);
      }
}

/* Print state of controllers only */
static void
_print_ping (void)
{
      slurm_ctl_conf_info_msg_t *conf;
      char *primary, *secondary;

      slurm_conf_init(NULL);

      conf = slurm_conf_lock();
      primary = xstrdup(conf->control_machine);
      secondary = xstrdup(conf->backup_controller);
      slurm_conf_unlock();

      _ping_slurmctld (primary, secondary);

      xfree(primary);
      xfree(secondary);
}

/* Report if slurmctld daemons are responding */
static void 
_ping_slurmctld(char *control_machine, char *backup_controller)
{
      static char *state[2] = { "UP", "DOWN" };
      int primary = 1, secondary = 1;
      int down_msg = 0;

      if (slurm_ping(1) == SLURM_SUCCESS)
            primary = 0;
      if (slurm_ping(2) == SLURM_SUCCESS)
            secondary = 0;
      fprintf(stdout, "Slurmctld(primary/backup) ");
      if (control_machine || backup_controller) {
            fprintf(stdout, "at ");
            if (control_machine) {
                  fprintf(stdout, "%s/", control_machine);
                  if (primary)
                        down_msg = 1;
            } else
                  fprintf(stdout, "(NULL)/");
            if (backup_controller) {
                  fprintf(stdout, "%s ", backup_controller);
                  if (secondary)
                        down_msg = 1;
            } else
                  fprintf(stdout, "(NULL) ");
      }
      fprintf(stdout, "are %s/%s\n", 
            state[primary], state[secondary]);

      if (down_msg && (getuid() == 0)) {
            fprintf(stdout, "*****************************************\n");
            fprintf(stdout, "** RESTORE SLURMCTLD DAEMON TO SERVICE **\n");
            fprintf(stdout, "*****************************************\n");
      }
}

/*
 * _print_daemons - report what daemons should be running on this node
 */
static void
_print_daemons (void)
{
      slurm_ctl_conf_info_msg_t *conf;
      char me[MAX_SLURM_NAME], *b, *c, *n;
      int actld = 0, ctld = 0, d = 0;
      char daemon_list[] = "slurmctld slurmd";

      slurm_conf_init(NULL);
      conf = slurm_conf_lock();

      gethostname_short(me, MAX_SLURM_NAME);
      if ((b = conf->backup_controller)) {
            if ((strcmp(b, me) == 0) ||
                (strcasecmp(b, "localhost") == 0))
                  ctld = 1;
      }
      if ((c = conf->control_machine)) {
            actld = 1;
            if ((strcmp(c, me) == 0) ||
                (strcasecmp(c, "localhost") == 0))
                  ctld = 1;
      }
      slurm_conf_unlock();

      if ((n = slurm_conf_get_nodename(me))) {
            d = 1;
            xfree(n);
      } else if ((n = slurm_conf_get_nodename("localhost"))) {
            d = 1;
            xfree(n);
      }

      strcpy(daemon_list, "");
      if (actld && ctld)
            strcat(daemon_list, "slurmctld ");
      if (actld && d)
            strcat(daemon_list, "slurmd");
      fprintf (stdout, "%s\n", daemon_list) ;
}

/*
 * _process_command - process the user's command
 * IN argc - count of arguments
 * IN argv - the arguments
 * RET 0 or errno (only for errors fatal to scontrol)
 */
static int
_process_command (int argc, char *argv[]) 
{
      int error_code;

      if (argc < 1) {
            exit_code = 1;
            if (quiet_flag == -1)
                  fprintf(stderr, "no input");
      }
      else if (strncasecmp (argv[0], "abort", 5) == 0) {
            /* require full command name */
            if (argc > 2) {
                  exit_code = 1;
                  fprintf (stderr,
                         "too many arguments for keyword:%s\n", 
                         argv[0]);
            }
            error_code = slurm_shutdown (1);
            if (error_code) {
                  exit_code = 1;
                  if (quiet_flag != 1)
                        slurm_perror ("slurm_shutdown error");
            }
      }
      else if (strncasecmp (argv[0], "all", 3) == 0)
            all_flag = 1;
      else if (strncasecmp (argv[0], "completing", 3) == 0) {
            if (argc > 1) {
                  exit_code = 1;
                  fprintf (stderr, 
                         "too many arguments for keyword:%s\n", 
                         argv[0]);
            }
            scontrol_print_completing();
      }
      else if (strncasecmp (argv[0], "exit", 1) == 0) {
            if (argc > 1) {
                  exit_code = 1;
                  fprintf (stderr, 
                         "too many arguments for keyword:%s\n", 
                         argv[0]);
            }
            exit_flag = 1;
      }
      else if (strncasecmp (argv[0], "help", 2) == 0) {
            if (argc > 1) {
                  exit_code = 1;
                  fprintf (stderr, 
                         "too many arguments for keyword:%s\n",
                         argv[0]);
            }
            _usage ();
      }
      else if (strncasecmp (argv[0], "hide", 2) == 0)
            all_flag = 0;
      else if (strncasecmp (argv[0], "oneliner", 1) == 0) {
            if (argc > 1) {
                  exit_code = 1;
                  fprintf (stderr, 
                         "too many arguments for keyword:%s\n",
                         argv[0]);
            }
            one_liner = 1;
      }
      else if (strncasecmp (argv[0], "pidinfo", 3) == 0) {
            if (argc > 2) {
                  exit_code = 1;
                  fprintf (stderr, 
                         "too many arguments for keyword:%s\n", 
                         argv[0]);
            } else if (argc < 2) {
                  exit_code = 1;
                  fprintf (stderr, 
                         "missing argument for keyword:%s\n", 
                         argv[0]);
            } else
                  scontrol_pid_info ((pid_t) atol (argv[1]) );
      }
      else if (strncasecmp (argv[0], "ping", 3) == 0) {
            if (argc > 1) {
                  exit_code = 1;
                  fprintf (stderr, 
                         "too many arguments for keyword:%s\n",
                         argv[0]);
            }
            _print_ping ();
      }
      else if (strncasecmp (argv[0], "quiet", 4) == 0) {
            if (argc > 1) {
                  exit_code = 1;
                  fprintf (stderr, "too many arguments for keyword:%s\n",
                         argv[0]);
            }
            quiet_flag = 1;
      }
      else if (strncasecmp (argv[0], "quit", 4) == 0) {
            if (argc > 1) {
                  exit_code = 1;
                  fprintf (stderr, 
                         "too many arguments for keyword:%s\n", 
                         argv[0]);
            }
            exit_flag = 1;
      }
      else if (strncasecmp (argv[0], "reconfigure", 3) == 0) {
            if (argc > 2) {
                  exit_code = 1;
                  fprintf (stderr, "too many arguments for keyword:%s\n",
                           argv[0]);
            }
            error_code = slurm_reconfigure ();
            if (error_code) {
                  exit_code = 1;
                  if (quiet_flag != 1)
                        slurm_perror ("slurm_reconfigure error");
            }
      }
      else if (strncasecmp (argv[0], "checkpoint", 5) == 0) {
            if (argc > 3) {
                  exit_code = 1;
                  if (quiet_flag != 1)
                        fprintf(stderr, 
                                "too many arguments for keyword:%s\n", 
                                argv[0]);
            }
            else if (argc < 3) {
                  exit_code = 1;
                  if (quiet_flag != 1)
                        fprintf(stderr, 
                                "too few arguments for keyword:%s\n", 
                                argv[0]);
            }
            else {
                  error_code =scontrol_checkpoint(argv[1], argv[2]);
                  if (error_code) {
                        exit_code = 1;
                        if (quiet_flag != 1)
                              slurm_perror ("slurm_checkpoint error");
                  }
            }
      }
      else if (strncasecmp (argv[0], "requeue", 3) == 0) {
            if (argc > 2) {
                  exit_code = 1;
                  if (quiet_flag != 1)
                        fprintf(stderr,
                              "too many arguments for keyword:%s\n",
                              argv[0]);
            } else if (argc < 2) {
                  exit_code = 1;
                  if (quiet_flag != 1)
                        fprintf(stderr,
                              "too few arguments for keyword:%s\n",
                              argv[0]);
            } else {
                  error_code =scontrol_requeue(argv[1]);
                  if (error_code) {
                        exit_code = 1;
                        if (quiet_flag != 1)
                              slurm_perror ("slurm_requeue error");
                  }
            }
                        
      }
      else if ((strncasecmp (argv[0], "suspend", 3) == 0)
      ||       (strncasecmp (argv[0], "resume", 3) == 0)) {
            if (argc > 2) {
                  exit_code = 1;
                  if (quiet_flag != 1)
                        fprintf(stderr,
                              "too many arguments for keyword:%s\n",
                              argv[0]);
            }
            else if (argc < 2) {
                  exit_code = 1;
                  if (quiet_flag != 1)
                        fprintf(stderr,
                              "too few arguments for keyword:%s\n",
                              argv[0]);
            } else {
                  error_code =scontrol_suspend(argv[0], argv[1]);
                  if (error_code) {
                        exit_code = 1;
                        if (quiet_flag != 1)
                              slurm_perror ("slurm_suspend error");
                  }
            }
      }
      else if (strncasecmp (argv[0], "show", 3) == 0) {
            if (argc > 3) {
                  exit_code = 1;
                  if (quiet_flag != 1)
                        fprintf(stderr, 
                                "too many arguments for keyword:%s\n", 
                                argv[0]);
            }
            else if (argc < 2) {
                  exit_code = 1;
                  if (quiet_flag != 1)
                        fprintf(stderr, 
                                "too few arguments for keyword:%s\n", 
                                argv[0]);
            }
            else if (strncasecmp (argv[1], "config", 3) == 0) {
                  if (argc > 2)
                        _print_config (argv[2]);
                  else
                        _print_config (NULL);
            }
            else if (strncasecmp (argv[1], "daemons", 3) == 0) {
                  if (argc > 2) {
                        exit_code = 1;
                        if (quiet_flag != 1)
                              fprintf(stderr,
                                      "too many arguments for keyword:%s\n", 
                                      argv[0]);
                  }
                  _print_daemons ();
            }
            else if (strncasecmp (argv[1], "jobs", 3) == 0) {
                  if (argc > 2)
                        scontrol_print_job (argv[2]);
                  else
                        scontrol_print_job (NULL);
            }
            else if (strncasecmp (argv[1], "hostnames", 5) == 0) {
                  if (argc > 2)
                        scontrol_print_hosts(argv[2]);
                  else
                        scontrol_print_hosts(getenv("SLURM_NODELIST"));
            }
            else if (strncasecmp (argv[1], "hostlist", 5) == 0) {
                  if (argc != 3) {
                        exit_code = 1;
                        fprintf(stderr, "invalid encode argument\n");
                        _usage();
                  } else if (scontrol_encode_hostlist(argv[2]))
                        exit_code = 1;
            }
            else if (strncasecmp (argv[1], "nodes", 3) == 0) {
                  if (argc > 2)
                        scontrol_print_node_list (argv[2]);
                  else
                        scontrol_print_node_list (NULL);
            }
            else if (strncasecmp (argv[1], "partitions", 3) == 0) {
                  if (argc > 2)
                        scontrol_print_part (argv[2]);
                  else
                        scontrol_print_part (NULL);
            }
            else if (strncasecmp (argv[1], "slurmd", 6) == 0) {
                  if (argc > 2)
                        _print_slurmd(argv[2]);
                  else
                        _print_slurmd(NULL);
            }
            else if (strncasecmp (argv[1], "steps", 3) == 0) {
                  if (argc > 2)
                        scontrol_print_step (argv[2]);
                  else
                        scontrol_print_step (NULL);
            }
            else {
                  exit_code = 1;
                  if (quiet_flag != 1)
                        fprintf (stderr,
                               "invalid entity:%s for keyword:%s \n",
                               argv[1], argv[0]);
            }           

      }
      else if (strncasecmp (argv[0], "shutdown", 8) == 0) {
            /* require full command name */
            if (argc > 2) {
                  exit_code = 1;
                  fprintf (stderr,
                         "too many arguments for keyword:%s\n", 
                         argv[0]);
            }
            error_code = slurm_shutdown (0);
            if (error_code) {
                  exit_code = 1;
                  if (quiet_flag != 1)
                        slurm_perror ("slurm_shutdown error");
            }
      }
      else if (strncasecmp (argv[0], "update", 1) == 0) {
            if (argc < 2) {
                  exit_code = 1;
                  fprintf (stderr, "too few arguments for %s keyword\n",
                         argv[0]);
                  return 0;
            }           
            _update_it ((argc - 1), &argv[1]);
      }
      else if (strncasecmp (argv[0], "delete", 3) == 0) {
            if (argc < 2) {
                  exit_code = 1;
                  fprintf (stderr, "too few arguments for %s keyword\n",
                         argv[0]);
                  return 0;
            }
            _delete_it ((argc - 1), &argv[1]);
      }
      else if (strncasecmp (argv[0], "verbose", 4) == 0) {
            if (argc > 1) {
                  exit_code = 1;
                  fprintf (stderr,
                         "too many arguments for %s keyword\n",
                         argv[0]);
            }           
            quiet_flag = -1;
      }
      else if (strncasecmp (argv[0], "version", 4) == 0) {
            if (argc > 1) {
                  exit_code = 1;
                  fprintf (stderr,
                         "too many arguments for %s keyword\n",
                         argv[0]);
            }           
            _print_version();
      }
      else if (strncasecmp (argv[0], "listpids", 8) == 0) {
            if (argc > 3) {
                  exit_code = 1;
                  fprintf (stderr, 
                         "too many arguments for keyword:%s\n", 
                         argv[0]);
            } else {
                  scontrol_list_pids (argc == 1 ? NULL : argv[1],
                                  argc <= 2 ? NULL : argv[2]);
            }
      }
      else {
            exit_code = 1;
            fprintf (stderr, "invalid keyword: %s\n", argv[0]);
      }

      return 0;
}

/* 
 * _delete_it - delete the slurm the specified slurm entity 
 * IN argc - count of arguments
 * IN argv - list of arguments
 */
static void
_delete_it (int argc, char *argv[]) 
{
      delete_part_msg_t part_msg;

      /* First identify the entity type to delete */
      if (strncasecmp (argv[0], "PartitionName=", 14) == 0) {
            part_msg.name = argv[0] + 14;
            if (slurm_delete_partition(&part_msg)) {
                  char errmsg[64];
                  snprintf(errmsg, 64, "delete_partition %s", argv[0]);
                  slurm_perror(errmsg);
            }
      } else {
            exit_code = 1;
            fprintf(stderr, "Invalid deletion entity: %s\n", argv[1]);
      }
}


/* 
 * _update_it - update the slurm configuration per the supplied arguments 
 * IN argc - count of arguments
 * IN argv - list of arguments
 */
static void
_update_it (int argc, char *argv[]) 
{
      int i, error_code = SLURM_SUCCESS;

      /* First identify the entity to update */
      for (i=0; i<argc; i++) {
            if (strncasecmp (argv[i], "NodeName=", 9) == 0) {
                  error_code = scontrol_update_node (argc, argv);
                  break;
            } else if (strncasecmp (argv[i], "PartitionName=", 14) == 0) {
                  error_code = scontrol_update_part (argc, argv);
                  break;
            } else if (strncasecmp (argv[i], "JobId=", 6) == 0) {
                  error_code = scontrol_update_job (argc, argv);
                  break;
            } else if (strncasecmp (argv[i], "BlockName=", 10) == 0) {
                  error_code = _update_bluegene_block (argc, argv);
                  break;
            } else if (strncasecmp (argv[i], "SubBPName=", 10) == 0) {
                  error_code = _update_bluegene_subbp (argc, argv);
                  break;
            }
            
      }
      
      if (i >= argc) {
            exit_code = 1;
            fprintf(stderr, "No valid entity in update command\n");
            fprintf(stderr, "Input line must include \"NodeName\", ");
#ifdef HAVE_BG
            fprintf(stderr, "\"BlockName\", \"SubBPName\" "
                  "(i.e. bgl000[0-3]),");
#endif
            fprintf(stderr, "\"PartitionName\", or \"JobId\"\n");
      }
      else if (error_code) {
            exit_code = 1;
            slurm_perror ("slurm_update error");
      }
}

/* 
 * _update_bluegene_block - update the bluegene block per the 
 *    supplied arguments 
 * IN argc - count of arguments
 * IN argv - list of arguments
 * RET 0 if no slurm error, errno otherwise. parsing error prints 
 *                error message and returns 0
 */
static int
_update_bluegene_block (int argc, char *argv[]) 
{
#ifdef HAVE_BG
      int i, update_cnt = 0;
      update_part_msg_t part_msg;

      slurm_init_part_desc_msg ( &part_msg );
      /* means this is for bluegene and altering a block */
      part_msg.hidden = (uint16_t)INFINITE;

      for (i=0; i<argc; i++) {
            if (strncasecmp(argv[i], "BlockName=", 10) == 0)
                  part_msg.name = &argv[i][10];
            else if (strncasecmp(argv[i], "State=", 6) == 0) {
                  if (strcasecmp(&argv[i][6], "ERROR") == 0)
                        part_msg.state_up = 0;
                  else if (strcasecmp(&argv[i][6], "FREE") == 0)
                        part_msg.state_up = 1;
                  else {
                        exit_code = 1;
                        fprintf (stderr, "Invalid input: %s\n", 
                               argv[i]);
                        fprintf (stderr, "Acceptable State values "
                              "are FREE and ERROR\n");
                        return 0;
                  }
                  update_cnt++;
            }
      }
      if(!part_msg.name) {
            error("You didn't supply a name.");
            return 0;
      }
      if (slurm_update_partition(&part_msg)) {
            exit_code = 1;
            return slurm_get_errno ();
      } else
            return 0;
#else
      printf("This only works on a bluegene system.\n");
      return 0;
#endif
}

/* 
 * _update_bluegene_subbp - update the bluegene nodecards per the 
 *    supplied arguments 
 * IN argc - count of arguments
 * IN argv - list of arguments
 * RET 0 if no slurm error, errno otherwise. parsing error prints 
 *                error message and returns 0
 */
static int
_update_bluegene_subbp (int argc, char *argv[]) 
{
#ifdef HAVE_BG
      int i, update_cnt = 0;
      update_part_msg_t part_msg;

      slurm_init_part_desc_msg ( &part_msg );
      /* means this is for bluegene and altering a sub node */
      part_msg.root_only = (uint16_t)INFINITE;

      for (i=0; i<argc; i++) {
            if (strncasecmp(argv[i], "SubBPName=", 10) == 0)
                  part_msg.name = &argv[i][10];
            else if (strncasecmp(argv[i], "State=", 6) == 0) {
                  if (strcasecmp(&argv[i][6], "ERROR") == 0)
                        part_msg.state_up = 0;
                  else if (strcasecmp(&argv[i][6], "FREE") == 0)
                        part_msg.state_up = 1;
                  else {
                        exit_code = 1;
                        fprintf (stderr, "Invalid input: %s\n", 
                               argv[i]);
                        fprintf (stderr, "Acceptable State values "
                              "are FREE and ERROR\n");
                        return 0;
                  }
                  update_cnt++;
            }
      }
      if(!part_msg.name) {
            error("You didn't supply a name.");
            return 0;
      }
      if (slurm_update_partition(&part_msg)) {
            exit_code = 1;
            return slurm_get_errno ();
      } else
            return 0;
#else
      printf("This only works on a bluegene system.\n");
      return 0;
#endif
}

/* _usage - show the valid scontrol commands */
void
_usage () {
      printf ("\
scontrol [<OPTION>] [<COMMAND>]                                            \n\
    Valid <OPTION> values are:                                             \n\
     -a or --all: equivalent to \"all\" command                            \n\
     -h or --help: equivalent to \"help\" command                          \n\
     --hide: equivalent to \"hide\" command                                \n\
     -o or --oneliner: equivalent to \"oneliner\" command                  \n\
     -q or --quiet: equivalent to \"quiet\" command                        \n\
     -v or --verbose: equivalent to \"verbose\" command                    \n\
     -V or --version: equivalent to \"version\" command                    \n\
                                                                           \n\
  <keyword> may be omitted from the execute line and scontrol will execute \n\
  in interactive mode. It will process commands as entered until explicitly\n\
  terminated.                                                              \n\
                                                                           \n\
    Valid <COMMAND> values are:                                            \n\
     abort                    shutdown slurm controller immediately        \n\
                              generating a core file.                      \n\
     all                      display information about all partitions,    \n\
                              including hidden partitions.                 \n\
     checkpoint <CH_OP><step> perform a checkpoint operation on identified \n\
                              job step \n\
     completing               display jobs in completing state along with  \n\
                              their completing or down nodes               \n\
     delete <SPECIFICATIONS>  delete the specified partition, kill its jobs\n\
     exit                     terminate scontrol                           \n\
     help                     print this description of use.               \n\
     hide                     do not display information about hidden partitions.\n\
     listpids <job_id<.step>> List pids associated with the given jobid, or\n\
                              all jobs if no id is given (This will only   \n\
                              display the processes on the node which the  \n\
                              scontrol is ran on, and only for those       \n\
                              processes spawned by SLURM and their         \n\
                              descendants)                                 \n\
     oneliner                 report output one record per line.           \n\
     pidinfo <pid>            return slurm job information for given pid.  \n\
     ping                     print status of slurmctld daemons.           \n\
     quiet                    print no messages other than error messages. \n\
     quit                     terminate this command.                      \n\
     reconfigure              re-read configuration files.                 \n\
     requeue <job_id>         re-queue a batch job                         \n\
     show <ENTITY> [<ID>]     display state of identified entity, default  \n\
                              is all records.                              \n\
     shutdown                 shutdown slurm controller.                   \n\
     suspend <job_id>         susend specified job                         \n\
     resume <job_id>          resume previously suspended job              \n\
     update <SPECIFICATIONS>  update job, node, partition, or bluegene     \n\
                              block/subbp configuration                    \n\
     verbose                  enable detailed logging.                     \n\
     version                  display tool version number.                 \n\
     !!                       Repeat the last command entered.             \n\
                                                                           \n\
  <ENTITY> may be \"config\", \"daemons\", \"job\", \"node\", \"partition\"\n\
           \"hostlist\", \"hostnames\", \"slurmd\",                        \n\
           (for BlueGene only: \"block\", \"subbp\" or \"step\").          \n\
                                                                           \n\
  <ID> may be a configuration parameter name, job id, node name, partition \n\
       name, job step id, or hostlist or pathname to a list of host names. \n\
                                                                           \n\
  <HOSTLIST> may either be a comma separated list of host names or the     \n\
       absolute pathname of a file (with leading '/' containing host names \n\
       either separated by commas or new-lines                             \n\
                                                                           \n\
  Node names may be specified using simple range expressions,              \n\
  (e.g. \"lx[10-20]\" corresponsds to lx10, lx11, lx12, ...)               \n\
  The job step id is the job id followed by a period and the step id.      \n\
                                                                           \n\
  <SPECIFICATIONS> are specified in the same format as the configuration   \n\
  file. You may wish to use the \"show\" keyword then use its output as    \n\
  input for the update keyword, editing as needed.  Bluegene blocks/subbps \n\
  are only able to be set to an error or free state.                       \n\
  (Bluegene systems only)                                                  \n\
                                                                           \n\
  <CH_OP> identify checkpoint operations and may be \"able\", \"disable\", \n\
  \"enable\", \"create\", \"vacate\", \"restart\", or \"error\".           \n\
                                                                           \n\
  All commands and options are case-insensitive, although node names and   \n\
  partition names tests are case-sensitive (node names \"LX\" and \"lx\"   \n\
  are distinct).                                                       \n\n");

}

Generated by  Doxygen 1.6.0   Back to index