usr.sbin/schedctl/schedctl.c

   1 /*      $NetBSD: schedctl.c,v 1.13 2009/01/18 10:18:32 lukem Exp $      */
   2
   3 /*
   4  * Copyright (c) 2008, Mindaugas Rasiukevicius <rmind at NetBSD org>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 /*
  30  * schedctl(8) - a program to control scheduling of processes and threads.
  31  */
  32
  33 #include <sys/cdefs.h>
  34
  35 #ifndef lint
  36 __RCSID("$NetBSD: schedctl.c,v 1.13 2009/01/18 10:18:32 lukem Exp $");
  37 #endif
  38
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42
  43 #include <err.h>
  44 #include <fcntl.h>
  45 #include <kvm.h>
  46 #include <unistd.h>
  47
  48 #include <sys/pset.h>
  49 #include <sys/sched.h>
  50 #include <sys/sysctl.h>
  51 #include <sys/types.h>
  52
  53 static const char *class_str[] = {
  54         "SCHED_OTHER",
  55         "SCHED_FIFO",
  56         "SCHED_RR",
  57         NULL
  58 };
  59
  60 static void     sched_set(pid_t, lwpid_t, int, struct sched_param *, cpuset_t *);
  61 static void     thread_info(pid_t, lwpid_t);
  62 static cpuset_t *makecpuset(char *);
  63 static char     *showcpuset(cpuset_t *);
  64 static void     usage(void);
  65
  66 static u_int    ncpu;
  67
  68 int
  69 main(int argc, char **argv)
  70 {
  71         kvm_t *kd;
  72         struct kinfo_lwp *lwp_list, *lwp;
  73         struct sched_param *sp;
  74         cpuset_t *cpuset;
  75         int i, count, ch, policy;
  76         pid_t pid;
  77         lwpid_t lid;
  78         bool set;
  79
  80         ncpu = sysconf(_SC_NPROCESSORS_CONF);
  81
  82         pid = lid = 0;
  83         cpuset = NULL;
  84         set = false;
  85
  86         sp = calloc(1, sizeof(struct sched_param));
  87         if (sp == NULL)
  88                 err(EXIT_FAILURE, "calloc");
  89
  90         sp->sched_priority = PRI_NONE;
  91         policy = SCHED_NONE;
  92
  93         while ((ch = getopt(argc, argv, "A:C:P:p:t:")) != -1) {
  94                 switch (ch) {
  95                 case 'p':
  96                         /* PID */
  97                         pid = atoi(optarg);
  98                         break;
  99                 case 't':
 100                         /* Thread (LWP) ID */
 101                         lid = atoi(optarg);
 102                         break;
 103                 case 'A':
 104                         /* Affinity */
 105                         cpuset = makecpuset(optarg);
 106                         if (cpuset == NULL) {
 107                                 fprintf(stderr, "%s: invalid CPU value\n",
 108                                     getprogname());
 109                                 exit(EXIT_FAILURE);
 110                         }
 111                         break;
 112                 case 'C':
 113                         /* Scheduling class */
 114                         for (policy = 0; class_str[policy] != NULL; policy++) {
 115                                 if (strcasecmp(optarg, class_str[policy]) == 0)
 116                                         break;
 117                         }
 118                         if (class_str[policy] == NULL)
 119                                 policy = atoi(optarg);
 120                         if (policy < SCHED_OTHER || policy > SCHED_RR) {
 121                                 fprintf(stderr,
 122                                     "%s: invalid scheduling class\n",
 123                                     getprogname());
 124                                 exit(EXIT_FAILURE);
 125                         }
 126                         set = true;
 127                         break;
 128                 case 'P':
 129                         /* Priority */
 130                         sp->sched_priority = atoi(optarg);
 131                         if (sp->sched_priority < sysconf(_SC_SCHED_PRI_MIN) ||
 132                             sp->sched_priority > sysconf(_SC_SCHED_PRI_MAX)) {
 133                                 fprintf(stderr, "%s: invalid priority\n",
 134                                     getprogname());
 135                                 exit(EXIT_FAILURE);
 136                         }
 137                         set = true;
 138                         break;
 139                 default:
 140                         usage();
 141                 }
 142         }
 143
 144         /* At least PID must be specified */
 145         if (pid == 0) {
 146                 if (argv[optind] == NULL || lid != 0)
 147                         usage();
 148                 pid = getpid();
 149         } else {
 150                 if (argv[optind] != NULL)
 151                         usage();
 152         }
 153
 154         /* Set the scheduling information for thread/process */
 155         sched_set(pid, lid, policy, set ? sp : NULL, cpuset);
 156
 157         /* Show information about each thread */
 158         if (pid != getpid()) {
 159                 kd = kvm_open(NULL, NULL, NULL, KVM_NO_FILES, "kvm_open");
 160                 if (kd == NULL)
 161                         err(EXIT_FAILURE, "kvm_open");
 162                 lwp_list = kvm_getlwps(kd, pid, 0, sizeof(struct kinfo_lwp), &count);
 163                 if (lwp_list == NULL)
 164                         err(EXIT_FAILURE, "kvm_getlwps");
 165                 for (lwp = lwp_list, i = 0; i < count; lwp++, i++) {
 166                         if (lid && lid != lwp->l_lid)
 167                                 continue;
 168                         if (lwp->l_stat == LSIDL || lwp->l_stat == LSZOMB)
 169                                 continue;
 170                         thread_info(pid, lwp->l_lid);
 171                 }
 172                 kvm_close(kd);
 173                 free(sp);
 174                 cpuset_destroy(cpuset);
 175                 return 0;
 176         }
 177
 178         (void)execvp(argv[optind], argv + optind);
 179         err(EXIT_FAILURE, "execvp");
 180 }
 181
 182 static void
 183 sched_set(pid_t pid, lwpid_t lid, int policy,
 184     struct sched_param *sp, cpuset_t *cpuset)
 185 {
 186         int error;
 187
 188         if (sp) {
 189                 /* Set the scheduling parameters for the thread */
 190                 error = _sched_setparam(pid, lid, policy, sp);
 191                 if (error < 0)
 192                         err(EXIT_FAILURE, "_sched_setparam");
 193         }
 194         if (cpuset) {
 195                 /* Set the CPU-set for affinity */
 196                 error = _sched_setaffinity(pid, lid,
 197                     cpuset_size(cpuset), cpuset);
 198                 if (error < 0)
 199                         err(EXIT_FAILURE, "_sched_setaffinity");
 200         }
 201 }
 202
 203 static void
 204 thread_info(pid_t pid, lwpid_t lid)
 205 {
 206         struct sched_param sp;
 207         cpuset_t *cpuset;
 208         char *cpus;
 209         int error, policy;
 210
 211         cpuset = cpuset_create();
 212         if (cpuset == NULL)
 213                 err(EXIT_FAILURE, "cpuset_create");
 214
 215         error = _sched_getparam(pid, lid, &policy, &sp);
 216         if (error < 0)
 217                 err(EXIT_FAILURE, "_sched_getparam");
 218
 219         error = _sched_getaffinity(pid, lid, cpuset_size(cpuset), cpuset);
 220         if (error < 0)
 221                 err(EXIT_FAILURE, "_sched_getaffinity");
 222
 223         printf("  LID:              %d\n", lid);
 224         printf("  Priority:         %d\n", sp.sched_priority);
 225         printf("  Class:            %s\n", class_str[policy]);
 226
 227         cpus = showcpuset(cpuset);
 228         printf("  Affinity (CPUs):  %s\n", cpus);
 229         free(cpus);
 230
 231         cpuset_destroy(cpuset);
 232 }
 233
 234 static cpuset_t *
 235 makecpuset(char *str)
 236 {
 237         cpuset_t *cpuset;
 238         char *cpustr, *s;
 239
 240         if (str == NULL)
 241                 return NULL;
 242
 243         cpuset = cpuset_create();
 244         if (cpuset == NULL)
 245                 err(EXIT_FAILURE, "cpuset_create");
 246         cpuset_zero(cpuset);
 247
 248         cpustr = strdup(str);
 249         if (cpustr == NULL)
 250                 err(EXIT_FAILURE, "strdup");
 251         s = cpustr;
 252
 253         while (s != NULL) {
 254                 char *p;
 255                 int i;
 256
 257                 /* Get the CPU number and validate the range */
 258                 p = strsep(&s, ",");
 259                 if (p == NULL) {
 260                         cpuset_destroy(cpuset);
 261                         cpuset = NULL;
 262                         break;
 263                 }
 264                 i = atoi(p);
 265                 if (i == -1) {
 266                         cpuset_zero(cpuset);
 267                         break;
 268                 }
 269                 if ((unsigned int)i >= ncpu) {
 270                         cpuset_destroy(cpuset);
 271                         cpuset = NULL;
 272                         break;
 273                 }
 274
 275                 /* Set the bit */
 276                 cpuset_set(i, cpuset);
 277         }
 278
 279         free(cpustr);
 280         return cpuset;
 281 }
 282
 283 static char *
 284 showcpuset(cpuset_t *cpuset)
 285 {
 286         char *buf;
 287         size_t size;
 288         unsigned int i;
 289
 290         size = 3 * ncpu;        /* XXX */
 291         buf = malloc(size + 1);
 292         if (buf == NULL)
 293                 err(EXIT_FAILURE, "malloc");
 294         memset(buf, '\0', size + 1);
 295
 296         for (i = 0; i < ncpu; i++)
 297                 if (cpuset_isset(i, cpuset))
 298                         snprintf(buf, size, "%s%d,", buf, i);
 299
 300         i = strlen(buf);
 301         if (i != 0) {
 302                 buf[i - 1] = '\0';
 303         } else {
 304                 strncpy(buf, "<none>", size);
 305         }
 306
 307         return buf;
 308 }
 309
 310 static void
 311 usage(void)
 312 {
 313
 314         fprintf(stderr, "usage: %s [-A processor] [-C class] "
 315             "[-P priority] [-t lid] {-p pid|command}\n", getprogname());
 316         exit(EXIT_FAILURE);
 317 }