util-linux/taskset.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * taskset - retrieve or set a processes' CPU affinity
   4  * Copyright (c) 2006 Bernhard Reutner-Fischer
   5  *
   6  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
   7  */
   8
   9 //config:config TASKSET
  10 //config:       bool "taskset (4.1 kb)"
  11 //config:       default y
  12 //config:       help
  13 //config:       Retrieve or set a processes's CPU affinity.
  14 //config:       This requires sched_{g,s}etaffinity support in your libc.
  15 //config:
  16 //config:config FEATURE_TASKSET_FANCY
  17 //config:       bool "Fancy output"
  18 //config:       default y
  19 //config:       depends on TASKSET
  20 //config:       help
  21 //config:       Needed for machines with more than 32-64 CPUs:
  22 //config:       affinity parameter 0xHHHHHHHHHHHHHHHHHHHH can be arbitrarily long
  23 //config:       in this case. Otherwise, it is limited to sizeof(long).
  24
  25 //applet:IF_TASKSET(APPLET_NOEXEC(taskset, taskset, BB_DIR_USR_BIN, BB_SUID_DROP, taskset))
  26 //kbuild:lib-$(CONFIG_TASKSET) += taskset.o
  27
  28 //usage:#define taskset_trivial_usage
  29 //usage:       "[-p] [HEXMASK] PID | PROG ARGS"
  30 //usage:#define taskset_full_usage "\n\n"
  31 //usage:       "Set or get CPU affinity\n"
  32 //usage:     "\n        -p      Operate on an existing PID"
  33 //usage:
  34 //usage:#define taskset_example_usage
  35 //usage:       "$ taskset 0x7 ./dgemm_test&\n"
  36 //usage:       "$ taskset -p 0x1 $!\n"
  37 //usage:       "pid 4790's current affinity mask: 7\n"
  38 //usage:       "pid 4790's new affinity mask: 1\n"
  39 //usage:       "$ taskset 0x7 /bin/sh -c './taskset -p 0x1 $$'\n"
  40 //usage:       "pid 6671's current affinity mask: 1\n"
  41 //usage:       "pid 6671's new affinity mask: 1\n"
  42 //usage:       "$ taskset -p 1\n"
  43 //usage:       "pid 1's current affinity mask: 3\n"
  44 /*
  45  * Not yet implemented:
  46  * -a/--all-tasks (affect all threads)
  47  *      needs to get TIDs from /proc/PID/task/ and use _them_ as "pid" in sched_setaffinity(pid)
  48  * -c/--cpu-list  (specify CPUs via "1,3,5-7")
  49  */
  50
  51 #include <sched.h>
  52 #include "libbb.h"
  53
  54 typedef unsigned long ul;
  55 #define SZOF_UL (unsigned)(sizeof(ul))
  56 #define BITS_UL (unsigned)(sizeof(ul)*8)
  57 #define MASK_UL (unsigned)(sizeof(ul)*8 - 1)
  58
  59 #if ENABLE_FEATURE_TASKSET_FANCY
  60 #define TASKSET_PRINTF_MASK "%s"
  61 /* craft a string from the mask */
  62 static char *from_mask(const ul *mask, unsigned sz_in_bytes)
  63 {
  64         char *str = xzalloc((sz_in_bytes+1) * 2); /* we will leak it */
  65         char *p = str;
  66         for (;;) {
  67                 ul v = *mask++;
  68                 if (SZOF_UL == 4)
  69                         p += sprintf(p, "%08lx", v);
  70                 if (SZOF_UL == 8)
  71                         p += sprintf(p, "%016lx", v);
  72                 if (SZOF_UL == 16)
  73                         p += sprintf(p, "%032lx", v); /* :) */
  74                 sz_in_bytes -= SZOF_UL;
  75                 if ((int)sz_in_bytes <= 0)
  76                         break;
  77         }
  78         while (str[0] == '0' && str[1])
  79                 str++;
  80         return str;
  81 }
  82 #else
  83 #define TASKSET_PRINTF_MASK "%lx"
  84 static unsigned long long from_mask(ul *mask, unsigned sz_in_bytes UNUSED_PARAM)
  85 {
  86         return *mask;
  87 }
  88 #endif
  89
  90 static unsigned long *get_aff(int pid, unsigned *sz)
  91 {
  92         int r;
  93         unsigned long *mask = NULL;
  94         unsigned sz_in_bytes = *sz;
  95
  96         for (;;) {
  97                 mask = xrealloc(mask, sz_in_bytes);
  98                 r = sched_getaffinity(pid, sz_in_bytes, (void*)mask);
  99                 if (r == 0)
 100                         break;
 101                 sz_in_bytes *= 2;
 102                 if (errno == EINVAL && (int)sz_in_bytes > 0)
 103                         continue;
 104                 bb_perror_msg_and_die("can't %cet pid %d's affinity", 'g', pid);
 105         }
 106         //bb_error_msg("get mask[0]:%lx sz_in_bytes:%d", mask[0], sz_in_bytes);
 107         *sz = sz_in_bytes;
 108         return mask;
 109 }
 110
 111 int taskset_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 112 int taskset_main(int argc UNUSED_PARAM, char **argv)
 113 {
 114         ul *mask;
 115         unsigned mask_size_in_bytes;
 116         pid_t pid = 0;
 117         unsigned opt_p;
 118         const char *current_new;
 119         char *aff;
 120
 121         /* NB: we mimic util-linux's taskset: -p does not take
 122          * an argument, i.e., "-pN" is NOT valid, only "-p N"!
 123          * Indeed, util-linux-2.13-pre7 uses:
 124          * getopt_long(argc, argv, "+pchV", ...), not "...p:..." */
 125
 126         opt_p = getopt32(argv, "^+" "p" "\0" "-1" /* at least 1 arg */);
 127         argv += optind;
 128
 129         aff = *argv++;
 130         if (opt_p) {
 131                 char *pid_str = aff;
 132                 if (*argv) { /* "-p <aff> <pid> ...rest.is.ignored..." */
 133                         pid_str = *argv; /* NB: *argv != NULL in this case */
 134                 }
 135                 /* else it was just "-p <pid>", and *argv == NULL */
 136                 pid = xatoul_range(pid_str, 1, ((unsigned)(pid_t)ULONG_MAX) >> 1);
 137         } else {
 138                 /* <aff> <cmd...> */
 139                 if (!*argv)
 140                         bb_show_usage();
 141         }
 142
 143         mask_size_in_bytes = SZOF_UL;
 144         current_new = "current";
 145  print_aff:
 146         mask = get_aff(pid, &mask_size_in_bytes);
 147         if (opt_p) {
 148                 printf("pid %d's %s affinity mask: "TASKSET_PRINTF_MASK"\n",
 149                                 pid, current_new, from_mask(mask, mask_size_in_bytes));
 150                 if (*argv == NULL) {
 151                         /* Either it was just "-p <pid>",
 152                          * or it was "-p <aff> <pid>" and we came here
 153                          * for the second time (see goto below) */
 154                         return EXIT_SUCCESS;
 155                 }
 156                 *argv = NULL;
 157                 current_new = "new";
 158         }
 159         memset(mask, 0, mask_size_in_bytes);
 160
 161         /* Affinity was specified, translate it into mask */
 162         /* it is always in hex, skip "0x" if it exists */
 163         if (aff[0] == '0' && (aff[1]|0x20) == 'x')
 164                 aff += 2;
 165
 166         if (!ENABLE_FEATURE_TASKSET_FANCY) {
 167                 mask[0] = xstrtoul(aff, 16);
 168         } else {
 169                 unsigned i;
 170                 char *last_char;
 171
 172                 i = 0; /* bit pos in mask[] */
 173
 174                 /* aff is ASCII hex string, accept very long masks in this form.
 175                  * Process hex string AABBCCDD... to ulong mask[]
 176                  * from the rightmost nibble, which is least-significant.
 177                  * Bits not fitting into mask[] are ignored: (example: 1234
 178                  * in 12340000000000000000000000000000000000000ff)
 179                  */
 180                 last_char = strchrnul(aff, '\0');
 181                 while (last_char > aff) {
 182                         char c;
 183                         ul val;
 184
 185                         last_char--;
 186                         c = *last_char;
 187                         if (isdigit(c))
 188                                 val = c - '0';
 189                         else if ((c|0x20) >= 'a' && (c|0x20) <= 'f')
 190                                 val = (c|0x20) - ('a' - 10);
 191                         else
 192                                 bb_error_msg_and_die("bad affinity '%s'", aff);
 193
 194                         if (i < mask_size_in_bytes * 8) {
 195                                 mask[i / BITS_UL] |= val << (i & MASK_UL);
 196                                 //bb_error_msg("bit %d set", i);
 197                         }
 198                         /* else:
 199                          * We can error out here, but we don't.
 200                          * For one, kernel itself ignores bits in mask[]
 201                          * which do not map to any CPUs:
 202                          * if mask[] has one 32-bit long element,
 203                          * but you have only 8 CPUs, all bits beyond first 8
 204                          * are ignored, silently.
 205                          * No point in making bits past 31th to be errors.
 206                          */
 207                         i += 4;
 208                 }
 209         }
 210
 211         /* Set pid's or our own (pid==0) affinity */
 212         if (sched_setaffinity(pid, mask_size_in_bytes, (void*)mask))
 213                 bb_perror_msg_and_die("can't %cet pid %d's affinity", 's', pid);
 214         //bb_error_msg("set mask[0]:%lx", mask[0]);
 215
 216         if (!argv[0]) /* "-p <aff> <pid> [...ignored...]" */
 217                 goto print_aff; /* print new affinity and exit */
 218
 219         BB_EXECVP_or_die(argv);
 220 }