Documentation/block/ioprio.txt

   1 Block io priorities
   2 ===================
   3
   4
   5 Intro
   6 -----
   7
   8 With the introduction of cfq v3 (aka cfq-ts or time sliced cfq), basic io
   9 priorities are supported for reads on files.  This enables users to io nice
  10 processes or process groups, similar to what has been possible with cpu
  11 scheduling for ages.  This document mainly details the current possibilities
  12 with cfq; other io schedulers do not support io priorities thus far.
  13
  14 Scheduling classes
  15 ------------------
  16
  17 CFQ implements three generic scheduling classes that determine how io is
  18 served for a process.
  19
  20 IOPRIO_CLASS_RT: This is the realtime io class. This scheduling class is given
  21 higher priority than any other in the system, processes from this class are
  22 given first access to the disk every time. Thus it needs to be used with some
  23 care, one io RT process can starve the entire system. Within the RT class,
  24 there are 8 levels of class data that determine exactly how much time this
  25 process needs the disk for on each service. In the future this might change
  26 to be more directly mappable to performance, by passing in a wanted data
  27 rate instead.
  28
  29 IOPRIO_CLASS_BE: This is the best-effort scheduling class, which is the default
  30 for any process that hasn't set a specific io priority. The class data
  31 determines how much io bandwidth the process will get, it's directly mappable
  32 to the cpu nice levels just more coarsely implemented. 0 is the highest
  33 BE prio level, 7 is the lowest. The mapping between cpu nice level and io
  34 nice level is determined as: io_nice = (cpu_nice + 20) / 5.
  35
  36 IOPRIO_CLASS_IDLE: This is the idle scheduling class, processes running at this
  37 level only get io time when no one else needs the disk. The idle class has no
  38 class data, since it doesn't really apply here.
  39
  40 Tools
  41 -----
  42
  43 See below for a sample ionice tool. Usage:
  44
  45 # ionice -c<class> -n<level> -p<pid>
  46
  47 If pid isn't given, the current process is assumed. IO priority settings
  48 are inherited on fork, so you can use ionice to start the process at a given
  49 level:
  50
  51 # ionice -c2 -n0 /bin/ls
  52
  53 will run ls at the best-effort scheduling class at the highest priority.
  54 For a running process, you can give the pid instead:
  55
  56 # ionice -c1 -n2 -p100
  57
  58 will change pid 100 to run at the realtime scheduling class, at priority 2.
  59
  60 ---> snip ionice.c tool <---
  61
  62 #include <stdio.h>
  63 #include <stdlib.h>
  64 #include <errno.h>
  65 #include <getopt.h>
  66 #include <unistd.h>
  67 #include <sys/ptrace.h>
  68 #include <asm/unistd.h>
  69
  70 extern int sys_ioprio_set(int, int, int);
  71 extern int sys_ioprio_get(int, int);
  72
  73 #if defined(__i386__)
  74 #define __NR_ioprio_set         289
  75 #define __NR_ioprio_get         290
  76 #elif defined(__ppc__)
  77 #define __NR_ioprio_set         273
  78 #define __NR_ioprio_get         274
  79 #elif defined(__x86_64__)
  80 #define __NR_ioprio_set         251
  81 #define __NR_ioprio_get         252
  82 #elif defined(__ia64__)
  83 #define __NR_ioprio_set         1274
  84 #define __NR_ioprio_get         1275
  85 #else
  86 #error "Unsupported arch"
  87 #endif
  88
  89 _syscall3(int, ioprio_set, int, which, int, who, int, ioprio);
  90 _syscall2(int, ioprio_get, int, which, int, who);
  91
  92 enum {
  93         IOPRIO_CLASS_NONE,
  94         IOPRIO_CLASS_RT,
  95         IOPRIO_CLASS_BE,
  96         IOPRIO_CLASS_IDLE,
  97 };
  98
  99 enum {
 100         IOPRIO_WHO_PROCESS = 1,
 101         IOPRIO_WHO_PGRP,
 102         IOPRIO_WHO_USER,
 103 };
 104
 105 #define IOPRIO_CLASS_SHIFT      13
 106
 107 const char *to_prio[] = { "none", "realtime", "best-effort", "idle", };
 108
 109 int main(int argc, char *argv[])
 110 {
 111         int ioprio = 4, set = 0, ioprio_class = IOPRIO_CLASS_BE;
 112         int c, pid = 0;
 113
 114         while ((c = getopt(argc, argv, "+n:c:p:")) != EOF) {
 115                 switch (c) {
 116                 case 'n':
 117                         ioprio = strtol(optarg, NULL, 10);
 118                         set = 1;
 119                         break;
 120                 case 'c':
 121                         ioprio_class = strtol(optarg, NULL, 10);
 122                         set = 1;
 123                         break;
 124                 case 'p':
 125                         pid = strtol(optarg, NULL, 10);
 126                         break;
 127                 }
 128         }
 129
 130         switch (ioprio_class) {
 131                 case IOPRIO_CLASS_NONE:
 132                         ioprio_class = IOPRIO_CLASS_BE;
 133                         break;
 134                 case IOPRIO_CLASS_RT:
 135                 case IOPRIO_CLASS_BE:
 136                         break;
 137                 case IOPRIO_CLASS_IDLE:
 138                         ioprio = 7;
 139                         break;
 140                 default:
 141                         printf("bad prio class %d\n", ioprio_class);
 142                         return 1;
 143         }
 144
 145         if (!set) {
 146                 if (!pid && argv[optind])
 147                         pid = strtol(argv[optind], NULL, 10);
 148
 149                 ioprio = ioprio_get(IOPRIO_WHO_PROCESS, pid);
 150
 151                 printf("pid=%d, %d\n", pid, ioprio);
 152
 153                 if (ioprio == -1)
 154                         perror("ioprio_get");
 155                 else {
 156                         ioprio_class = ioprio >> IOPRIO_CLASS_SHIFT;
 157                         ioprio = ioprio & 0xff;
 158                         printf("%s: prio %d\n", to_prio[ioprio_class], ioprio);
 159                 }
 160         } else {
 161                 if (ioprio_set(IOPRIO_WHO_PROCESS, pid, ioprio | ioprio_class << IOPRIO_CLASS_SHIFT) == -1) {
 162                         perror("ioprio_set");
 163                         return 1;
 164                 }
 165
 166                 if (argv[optind])
 167                         execvp(argv[optind], &argv[optind]);
 168         }
 169
 170         return 0;
 171 }
 172
 173 ---> snip ionice.c tool <---
 174
 175
 176 March 11 2005, Jens Axboe <axboe@suse.de>