sbin/usched/usched.c

   1 /*
   2  * Copyright (c) 2012 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@backplane.com> and Thomas Nikolajsen
   6  * <thomas.nikolajsen@mail.dk>
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in
  16  *    the documentation and/or other materials provided with the
  17  *    distribution.
  18  * 3. Neither the name of The DragonFly Project nor the names of its
  19  *    contributors may be used to endorse or promote products derived
  20  *    from this software without specific, prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  25  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  26  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  27  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  28  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  30  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  31  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  32  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35
  36 #include <sys/types.h>
  37 #include <sys/usched.h>
  38 #include <sys/cpumask.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <unistd.h>
  42 #include <string.h>
  43
  44 static void usage(void);
  45
  46 int DebugOpt;
  47
  48 int
  49 main(int ac, char **av)
  50 {
  51         int ch;
  52         int res;
  53         char *sched = NULL;
  54         char *cpustr = NULL;
  55         char *sched_cpustr = NULL;
  56         char *p = NULL;
  57         cpumask_t cpumask;
  58         int cpuid;
  59         pid_t pid = getpid();  /* See usched_set(2) - BUGS */
  60
  61         CPUMASK_ASSZERO(cpumask);
  62
  63         while ((ch = getopt(ac, av, "d")) != -1) {
  64                 switch (ch) {
  65                 case 'd':
  66                         DebugOpt = 1;
  67                         break;
  68                 default:
  69                         usage();
  70                         /* NOTREACHED */
  71                 }
  72         }
  73         ac -= optind;
  74         av += optind;
  75
  76         if (ac < 2) {
  77                 usage();
  78                 /* NOTREACHED */
  79         }
  80         sched_cpustr = strdup(av[0]);
  81         sched = strsep(&sched_cpustr, ":");
  82         if (strcmp(sched, "default") == 0)
  83                 fprintf(stderr,
  84                         "Ignoring scheduler == \"default\": "
  85                         "not implemented\n");
  86         cpustr = strsep(&sched_cpustr, "");
  87         if (strlen(sched) == 0 && cpustr == NULL) {
  88                 usage();
  89                 /* NOTREACHED */
  90         }
  91
  92         /*
  93          * XXX needs expanded support for > 64 cpus
  94          */
  95         if (cpustr != NULL) {
  96                 uint64_t v;
  97                 int baseid;
  98                 char *ptr = cpustr;
  99
 100                 baseid = 0;
 101                 for (;;) {
 102                         if (baseid >= CPU_SETSIZE) {
 103                                 fprintf(stderr, "cpumask too large\n");
 104                                 usage();
 105                         }
 106                         v = (uint64_t)strtoull(ptr, &ptr, 0);
 107                         for (cpuid = 0; cpuid < (int)sizeof(v) * 8; ++cpuid) {
 108                                 if (v & (1LU << cpuid))
 109                                         CPUMASK_ORBIT(cpumask, baseid + cpuid);
 110                         }
 111                         if (*ptr == 0)
 112                                 break;
 113                         if (*ptr != ',') {
 114                                 fprintf(stderr, "cpumask format error\n");
 115                                 usage();
 116                         }
 117                         ++ptr;
 118                         baseid += (int)sizeof(v) * 8;
 119                 }
 120         }
 121
 122         if (strlen(sched) != 0) {
 123                 if (DebugOpt) {
 124                         fprintf(stderr,
 125                                 "DEBUG: USCHED_SET_SCHEDULER: scheduler: %s\n",
 126                                 sched);
 127                 }
 128                 res = usched_set(pid, USCHED_SET_SCHEDULER,
 129                                  sched, strlen(sched));
 130                 if (res != 0) {
 131                         asprintf(&p,
 132                                 "usched_set(%d, USCHED_SET_SCHEDULER, "
 133                                 "\"%s\", %d)",
 134                                 pid, sched, (int)strlen(sched));
 135                         perror(p);
 136                         exit(1);
 137                 }
 138         }
 139         if (CPUMASK_TESTNZERO(cpumask)) {
 140                 for (cpuid = 0; cpuid < CPU_SETSIZE; ++cpuid) {
 141                         if (CPUMASK_TESTBIT(cpumask, cpuid))
 142                                 break;
 143                 }
 144                 if (DebugOpt) {
 145                         fprintf(stderr, "DEBUG: USCHED_SET_CPU: cpuid: %d\n",
 146                                 cpuid);
 147                 }
 148                 res = usched_set(pid, USCHED_SET_CPU, &cpuid, sizeof(int));
 149                 if (res != 0) {
 150                         asprintf(&p, "usched_set(%d, USCHED_SET_CPU, &%d, %d)",
 151                                 pid, cpuid, (int)sizeof(int));
 152                         perror(p);
 153                         exit(1);
 154                 }
 155                 CPUMASK_NANDBIT(cpumask, cpuid);
 156                 while (CPUMASK_TESTNZERO(cpumask)) {
 157                         ++cpuid;
 158                         if (CPUMASK_TESTBIT(cpumask, cpuid) == 0)
 159                                 continue;
 160                         CPUMASK_NANDBIT(cpumask, cpuid);
 161                         if (DebugOpt) {
 162                                 fprintf(stderr,
 163                                         "DEBUG: USCHED_ADD_CPU: cpuid: %d\n",
 164                                         cpuid);
 165                         }
 166                         res = usched_set(pid, USCHED_ADD_CPU,
 167                                          &cpuid, sizeof(int));
 168                         if (res != 0) {
 169                                 asprintf(&p,
 170                                         "usched_set(%d, USCHED_ADD_CPU, "
 171                                         "&%d, %d)",
 172                                         pid, cpuid, (int)sizeof(int));
 173                                 perror(p);
 174                                 exit(1);
 175                         }
 176                 }
 177         }
 178         execvp(av[1], av + 1);
 179         exit(1);
 180 }
 181
 182 static
 183 void
 184 usage(void)
 185 {
 186         fprintf(stderr,
 187                 "usage: usched [-d] {scheduler[:cpumask] | :cpumask} "
 188                 "program [argument ...]\n");
 189         fprintf(stderr,
 190                 "cpumask format: val[,val[,val[,val]]] in 64-bit chunks, "
 191                 "lsb chunk first\n");
 192         exit(1);
 193 }