Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net
[linux-2.6.git] / 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 static inline int ioprio_set(int which, int who, int ioprio)
90 {
91         return syscall(__NR_ioprio_set, which, who, ioprio);
92 }
93
94 static inline int ioprio_get(int which, int who)
95 {
96         return syscall(__NR_ioprio_get, which, who);
97 }
98
99 enum {
100         IOPRIO_CLASS_NONE,
101         IOPRIO_CLASS_RT,
102         IOPRIO_CLASS_BE,
103         IOPRIO_CLASS_IDLE,
104 };
105
106 enum {
107         IOPRIO_WHO_PROCESS = 1,
108         IOPRIO_WHO_PGRP,
109         IOPRIO_WHO_USER,
110 };
111
112 #define IOPRIO_CLASS_SHIFT      13
113
114 const char *to_prio[] = { "none", "realtime", "best-effort", "idle", };
115
116 int main(int argc, char *argv[])
117 {
118         int ioprio = 4, set = 0, ioprio_class = IOPRIO_CLASS_BE;
119         int c, pid = 0;
120
121         while ((c = getopt(argc, argv, "+n:c:p:")) != EOF) {
122                 switch (c) {
123                 case 'n':
124                         ioprio = strtol(optarg, NULL, 10);
125                         set = 1;
126                         break;
127                 case 'c':
128                         ioprio_class = strtol(optarg, NULL, 10);
129                         set = 1;
130                         break;
131                 case 'p':
132                         pid = strtol(optarg, NULL, 10);
133                         break;
134                 }
135         }
136
137         switch (ioprio_class) {
138                 case IOPRIO_CLASS_NONE:
139                         ioprio_class = IOPRIO_CLASS_BE;
140                         break;
141                 case IOPRIO_CLASS_RT:
142                 case IOPRIO_CLASS_BE:
143                         break;
144                 case IOPRIO_CLASS_IDLE:
145                         ioprio = 7;
146                         break;
147                 default:
148                         printf("bad prio class %d\n", ioprio_class);
149                         return 1;
150         }
151
152         if (!set) {
153                 if (!pid && argv[optind])
154                         pid = strtol(argv[optind], NULL, 10);
155
156                 ioprio = ioprio_get(IOPRIO_WHO_PROCESS, pid);
157
158                 printf("pid=%d, %d\n", pid, ioprio);
159
160                 if (ioprio == -1)
161                         perror("ioprio_get");
162                 else {
163                         ioprio_class = ioprio >> IOPRIO_CLASS_SHIFT;
164                         ioprio = ioprio & 0xff;
165                         printf("%s: prio %d\n", to_prio[ioprio_class], ioprio);
166                 }
167         } else {
168                 if (ioprio_set(IOPRIO_WHO_PROCESS, pid, ioprio | ioprio_class << IOPRIO_CLASS_SHIFT) == -1) {
169                         perror("ioprio_set");
170                         return 1;
171                 }
172
173                 if (argv[optind])
174                         execvp(argv[optind], &argv[optind]);
175         }
176
177         return 0;
178 }
179
180 ---> snip ionice.c tool <---
181
182
183 March 11 2005, Jens Axboe <jens.axboe@oracle.com>