usr.sbin/schedctl/schedctl.c

   1 /*      $NetBSD: schedctl.c,v 1.12 2008/10/18 03:40:18 rmind 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.12 2008/10/18 03:40:18 rmind 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                         thread_info(pid, lwp->l_lid);
 169                 }
 170                 kvm_close(kd);
 171                 free(sp);
 172                 cpuset_destroy(cpuset);
 173                 return 0;
 174         }
 175
 176         (void)execvp(argv[optind], argv + optind);
 177         err(EXIT_FAILURE, "execvp");
 178 }
 179
 180 static void
 181 sched_set(pid_t pid, lwpid_t lid, int policy,
 182     struct sched_param *sp, cpuset_t *cpuset)
 183 {
 184         int error;
 185
 186         if (sp) {
 187                 /* Set the scheduling parameters for the thread */
 188                 error = _sched_setparam(pid, lid, policy, sp);
 189                 if (error < 0)
 190                         err(EXIT_FAILURE, "_sched_setparam");
 191         }
 192         if (cpuset) {
 193                 /* Set the CPU-set for affinity */
 194                 error = _sched_setaffinity(pid, lid,
 195                     cpuset_size(cpuset), cpuset);
 196                 if (error < 0)
 197                         err(EXIT_FAILURE, "_sched_setaffinity");
 198         }
 199 }
 200
 201 static void
 202 thread_info(pid_t pid, lwpid_t lid)
 203 {
 204         struct sched_param sp;
 205         cpuset_t *cpuset;
 206         char *cpus;
 207         int error, policy;
 208
 209         cpuset = cpuset_create();
 210         if (cpuset == NULL)
 211                 err(EXIT_FAILURE, "cpuset_create");
 212
 213         error = _sched_getparam(pid, lid, &policy, &sp);
 214         if (error < 0)
 215                 err(EXIT_FAILURE, "_sched_getparam");
 216
 217         error = _sched_getaffinity(pid, lid, cpuset_size(cpuset), cpuset);
 218         if (error < 0)
 219                 err(EXIT_FAILURE, "_sched_getaffinity");
 220
 221         printf("  LID:              %d\n", lid);
 222         printf("  Priority:         %d\n", sp.sched_priority);
 223         printf("  Class:            %s\n", class_str[policy]);
 224
 225         cpus = showcpuset(cpuset);
 226         printf("  Affinity (CPUs):  %s\n", cpus);
 227         free(cpus);
 228
 229         cpuset_destroy(cpuset);
 230 }
 231
 232 static cpuset_t *
 233 makecpuset(char *str)
 234 {
 235         cpuset_t *cpuset;
 236         char *cpustr, *s;
 237
 238         if (str == NULL)
 239                 return NULL;
 240
 241         cpuset = cpuset_create();
 242         if (cpuset == NULL)
 243                 err(EXIT_FAILURE, "cpuset_create");
 244         cpuset_zero(cpuset);
 245
 246         cpustr = strdup(str);
 247         if (cpustr == NULL)
 248                 err(EXIT_FAILURE, "strdup");
 249         s = cpustr;
 250
 251         while (s != NULL) {
 252                 char *p;
 253                 int i;
 254
 255                 /* Get the CPU number and validate the range */
 256                 p = strsep(&s, ",");
 257                 if (p == NULL) {
 258                         cpuset_destroy(cpuset);
 259                         cpuset = NULL;
 260                         break;
 261                 }
 262                 i = atoi(p);
 263                 if (i == -1) {
 264                         cpuset_zero(cpuset);
 265                         break;
 266                 }
 267                 if ((unsigned int)i >= ncpu) {
 268                         cpuset_destroy(cpuset);
 269                         cpuset = NULL;
 270                         break;
 271                 }
 272
 273                 /* Set the bit */
 274                 cpuset_set(i, cpuset);
 275         }
 276
 277         free(cpustr);
 278         return cpuset;
 279 }
 280
 281 static char *
 282 showcpuset(cpuset_t *cpuset)
 283 {
 284         char *buf;
 285         size_t size;
 286         unsigned int i;
 287
 288         size = 3 * ncpu;        /* XXX */
 289         buf = malloc(size + 1);
 290         if (buf == NULL)
 291                 err(EXIT_FAILURE, "malloc");
 292         memset(buf, '\0', size + 1);
 293
 294         for (i = 0; i < ncpu; i++)
 295                 if (cpuset_isset(i, cpuset))
 296                         snprintf(buf, size, "%s%d,", buf, i);
 297
 298         i = strlen(buf);
 299         if (i != 0) {
 300                 buf[i - 1] = '\0';
 301         } else {
 302                 strncpy(buf, "<none>", size);
 303         }
 304
 305         return buf;
 306 }
 307
 308 static void
 309 usage(void)
 310 {
 311
 312         fprintf(stderr, "usage: %s [-A processor] [-C class] "
 313             "[-P priority] [-t lid] {-p pid|command}\n", getprogname());
 314         exit(EXIT_FAILURE);
 315 }