schedutils/ionice.c

   1 /*
   2  * ionice: set or get process io scheduling class and priority
   3  *
   4  * Copyright (C) 2005 Jens Axboe <jens@axboe.dk>
   5  *
   6  * Released under the terms of the GNU General Public License version 2
   7  *
   8  */
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <errno.h>
  12 #include <getopt.h>
  13 #include <unistd.h>
  14 #ifdef HAVE_SYS_SYSCALL_H
  15 #include <sys/syscall.h>
  16 #endif
  17 #include <ctype.h>
  18
  19 #include "nls.h"
  20 #include "strutils.h"
  21 #include "c.h"
  22 #include "closestream.h"
  23
  24 static int tolerant;
  25
  26 static inline int ioprio_set(int which, int who, int ioprio)
  27 {
  28         return syscall(SYS_ioprio_set, which, who, ioprio);
  29 }
  30
  31 static inline int ioprio_get(int which, int who)
  32 {
  33         return syscall(SYS_ioprio_get, which, who);
  34 }
  35
  36 enum {
  37         IOPRIO_CLASS_NONE,
  38         IOPRIO_CLASS_RT,
  39         IOPRIO_CLASS_BE,
  40         IOPRIO_CLASS_IDLE,
  41 };
  42
  43 enum {
  44         IOPRIO_WHO_PROCESS = 1,
  45         IOPRIO_WHO_PGRP,
  46         IOPRIO_WHO_USER,
  47 };
  48
  49 #define IOPRIO_CLASS_SHIFT      (13)
  50 #define IOPRIO_PRIO_MASK        ((1UL << IOPRIO_CLASS_SHIFT) - 1)
  51
  52 #define IOPRIO_PRIO_CLASS(mask) ((mask) >> IOPRIO_CLASS_SHIFT)
  53 #define IOPRIO_PRIO_DATA(mask)  ((mask) & IOPRIO_PRIO_MASK)
  54 #define IOPRIO_PRIO_VALUE(class, data)  (((class) << IOPRIO_CLASS_SHIFT) | data)
  55
  56 static const char *to_prio[] = {
  57         [IOPRIO_CLASS_NONE] = "none",
  58         [IOPRIO_CLASS_RT]   = "realtime",
  59         [IOPRIO_CLASS_BE]   = "best-effort",
  60         [IOPRIO_CLASS_IDLE] = "idle"
  61 };
  62
  63 static int parse_ioclass(const char *str)
  64 {
  65         size_t i;
  66
  67         for (i = 0; i < ARRAY_SIZE(to_prio); i++)
  68                 if (!strcasecmp(str, to_prio[i]))
  69                         return i;
  70         return -1;
  71 }
  72
  73 static void ioprio_print(int pid, int who)
  74 {
  75         int ioprio = ioprio_get(who, pid);
  76
  77         if (ioprio == -1)
  78                 err(EXIT_FAILURE, _("ioprio_get failed"));
  79         else {
  80                 int ioclass = IOPRIO_PRIO_CLASS(ioprio);
  81                 const char *name = _("unknown");
  82
  83                 if (ioclass >= 0 && (size_t) ioclass < ARRAY_SIZE(to_prio))
  84                         name = to_prio[ioclass];
  85
  86                 if (ioclass != IOPRIO_CLASS_IDLE)
  87                         printf(_("%s: prio %lu\n"), name,
  88                                IOPRIO_PRIO_DATA(ioprio));
  89                 else
  90                         printf("%s\n", name);
  91         }
  92 }
  93
  94 static void ioprio_setid(int which, int ioclass, int data, int who)
  95 {
  96         int rc = ioprio_set(who, which,
  97                             IOPRIO_PRIO_VALUE(ioclass, data));
  98
  99         if (rc == -1 && !tolerant)
 100                 err(EXIT_FAILURE, _("ioprio_set failed"));
 101 }
 102
 103 static void __attribute__((__noreturn__)) usage(void)
 104 {
 105         FILE *out = stdout;
 106         fputs(USAGE_HEADER, out);
 107         fprintf(out,  _(" %1$s [options] -p <pid>...\n"
 108                         " %1$s [options] -P <pgid>...\n"
 109                         " %1$s [options] -u <uid>...\n"
 110                         " %1$s [options] <command>\n"), program_invocation_short_name);
 111
 112         fputs(USAGE_SEPARATOR, out);
 113         fputs(_("Show or change the I/O-scheduling class and priority of a process.\n"), out);
 114
 115         fputs(USAGE_OPTIONS, out);
 116         fputs(_(" -c, --class <class>    name or number of scheduling class,\n"
 117                 "                          0: none, 1: realtime, 2: best-effort, 3: idle\n"), out);
 118         fputs(_(" -n, --classdata <num>  priority (0..7) in the specified scheduling class,\n"
 119                 "                          only for the realtime and best-effort classes\n"), out);
 120         fputs(_(" -p, --pid <pid>...     act on these already running processes\n"), out);
 121         fputs(_(" -P, --pgid <pgrp>...   act on already running processes in these groups\n"), out);
 122         fputs(_(" -t, --ignore           ignore failures\n"), out);
 123         fputs(_(" -u, --uid <uid>...     act on already running processes owned by these users\n"), out);
 124
 125         fputs(USAGE_SEPARATOR, out);
 126         printf(USAGE_HELP_OPTIONS(24));
 127
 128         printf(USAGE_MAN_TAIL("ionice(1)"));
 129
 130         exit(EXIT_SUCCESS);
 131 }
 132
 133 int main(int argc, char **argv)
 134 {
 135         int data = 4, set = 0, ioclass = IOPRIO_CLASS_BE, c;
 136         int which = 0, who = 0;
 137         const char *invalid_msg = NULL;
 138
 139         static const struct option longopts[] = {
 140                 { "classdata", required_argument, NULL, 'n' },
 141                 { "class",     required_argument, NULL, 'c' },
 142                 { "help",      no_argument,       NULL, 'h' },
 143                 { "ignore",    no_argument,       NULL, 't' },
 144                 { "pid",       required_argument, NULL, 'p' },
 145                 { "pgid",      required_argument, NULL, 'P' },
 146                 { "uid",       required_argument, NULL, 'u' },
 147                 { "version",   no_argument,       NULL, 'V' },
 148                 { NULL, 0, NULL, 0 }
 149         };
 150
 151         setlocale(LC_ALL, "");
 152         bindtextdomain(PACKAGE, LOCALEDIR);
 153         textdomain(PACKAGE);
 154         close_stdout_atexit();
 155
 156         while ((c = getopt_long(argc, argv, "+n:c:p:P:u:tVh", longopts, NULL)) != EOF)
 157                 switch (c) {
 158                 case 'n':
 159                         data = strtos32_or_err(optarg, _("invalid class data argument"));
 160                         set |= 1;
 161                         break;
 162                 case 'c':
 163                         if (isdigit(*optarg))
 164                                 ioclass = strtos32_or_err(optarg,
 165                                                 _("invalid class argument"));
 166                         else {
 167                                 ioclass = parse_ioclass(optarg);
 168                                 if (ioclass < 0)
 169                                         errx(EXIT_FAILURE,
 170                                                 _("unknown scheduling class: '%s'"),
 171                                                 optarg);
 172                         }
 173                         set |= 2;
 174                         break;
 175                 case 'p':
 176                         if (who)
 177                                 errx(EXIT_FAILURE,
 178                                      _("can handle only one of pid, pgid or uid at once"));
 179                         invalid_msg = _("invalid PID argument");
 180                         which = strtos32_or_err(optarg, invalid_msg);
 181                         who = IOPRIO_WHO_PROCESS;
 182                         break;
 183                 case 'P':
 184                         if (who)
 185                                 errx(EXIT_FAILURE,
 186                                      _("can handle only one of pid, pgid or uid at once"));
 187                         invalid_msg = _("invalid PGID argument");
 188                         which = strtos32_or_err(optarg, invalid_msg);
 189                         who = IOPRIO_WHO_PGRP;
 190                         break;
 191                 case 'u':
 192                         if (who)
 193                                 errx(EXIT_FAILURE,
 194                                      _("can handle only one of pid, pgid or uid at once"));
 195                         invalid_msg = _("invalid UID argument");
 196                         which = strtos32_or_err(optarg, invalid_msg);
 197                         who = IOPRIO_WHO_USER;
 198                         break;
 199                 case 't':
 200                         tolerant = 1;
 201                         break;
 202
 203                 case 'V':
 204                         print_version(EXIT_SUCCESS);
 205                 case 'h':
 206                         usage();
 207                 default:
 208                         errtryhelp(EXIT_FAILURE);
 209                 }
 210
 211         switch (ioclass) {
 212                 case IOPRIO_CLASS_NONE:
 213                         if ((set & 1) && !tolerant)
 214                                 warnx(_("ignoring given class data for none class"));
 215                         data = 0;
 216                         break;
 217                 case IOPRIO_CLASS_RT:
 218                 case IOPRIO_CLASS_BE:
 219                         break;
 220                 case IOPRIO_CLASS_IDLE:
 221                         if ((set & 1) && !tolerant)
 222                                 warnx(_("ignoring given class data for idle class"));
 223                         data = 7;
 224                         break;
 225                 default:
 226                         if (!tolerant)
 227                                 warnx(_("unknown prio class %d"), ioclass);
 228                         break;
 229         }
 230
 231         if (!set && !which && optind == argc)
 232                 /*
 233                  * ionice without options, print the current ioprio
 234                  */
 235                 ioprio_print(0, IOPRIO_WHO_PROCESS);
 236         else if (!set && who) {
 237                 /*
 238                  * ionice -p|-P|-u ID [ID ...]
 239                  */
 240                 ioprio_print(which, who);
 241
 242                 for(; argv[optind]; ++optind) {
 243                         which = strtos32_or_err(argv[optind], invalid_msg);
 244                         ioprio_print(which, who);
 245                 }
 246         } else if (set && who) {
 247                 /*
 248                  * ionice -c CLASS -p|-P|-u ID [ID ...]
 249                  */
 250                 ioprio_setid(which, ioclass, data, who);
 251
 252                 for(; argv[optind]; ++optind) {
 253                         which = strtos32_or_err(argv[optind], invalid_msg);
 254                         ioprio_setid(which, ioclass, data, who);
 255                 }
 256         } else if (argv[optind]) {
 257                 /*
 258                  * ionice [-c CLASS] COMMAND
 259                  */
 260                 ioprio_setid(0, ioclass, data, IOPRIO_WHO_PROCESS);
 261                 execvp(argv[optind], &argv[optind]);
 262                 errexec(argv[optind]);
 263         } else {
 264                 warnx(_("bad usage"));
 265                 errtryhelp(EXIT_FAILURE);
 266         }
 267
 268         return EXIT_SUCCESS;
 269 }