blob: cadc37841744ddb1ed0b481e97f82319ee47aefc [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * CFQ, or complete fairness queueing, disk scheduler.
3 *
4 * Based on ideas from a previously unfinished io
5 * scheduler (round robin per-process disk scheduling) and Andrea Arcangeli.
6 *
Jens Axboe0fe23472006-09-04 15:41:16 +02007 * Copyright (C) 2003 Jens Axboe <axboe@kernel.dk>
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090010#include <linux/slab.h>
Al Viro1cc9be62006-03-18 12:29:52 -050011#include <linux/blkdev.h>
12#include <linux/elevator.h>
Randy Dunlapad5ebd22009-11-11 13:47:45 +010013#include <linux/jiffies.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/rbtree.h>
Jens Axboe22e2c502005-06-27 10:55:12 +020015#include <linux/ioprio.h>
Jens Axboe7b679132008-05-30 12:23:07 +020016#include <linux/blktrace_api.h>
Tejun Heo6e736be2011-12-14 00:33:38 +010017#include "blk.h"
Tejun Heo629ed0b2012-04-01 14:38:44 -070018#include "blk-cgroup.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070019
20/*
21 * tunables
22 */
Jens Axboefe094d92008-01-31 13:08:54 +010023/* max queue in one round of service */
Shaohua Liabc3c742010-03-01 09:20:54 +010024static const int cfq_quantum = 8;
Arjan van de Ven64100092006-01-06 09:46:02 +010025static const int cfq_fifo_expire[2] = { HZ / 4, HZ / 8 };
Jens Axboefe094d92008-01-31 13:08:54 +010026/* maximum backwards seek, in KiB */
27static const int cfq_back_max = 16 * 1024;
28/* penalty of a backwards seek */
29static const int cfq_back_penalty = 2;
Arjan van de Ven64100092006-01-06 09:46:02 +010030static const int cfq_slice_sync = HZ / 10;
Jens Axboe3b181522005-06-27 10:56:24 +020031static int cfq_slice_async = HZ / 25;
Arjan van de Ven64100092006-01-06 09:46:02 +010032static const int cfq_slice_async_rq = 2;
Jens Axboecaaa5f92006-06-16 11:23:00 +020033static int cfq_slice_idle = HZ / 125;
Vivek Goyal80bdf0c2010-08-23 12:24:26 +020034static int cfq_group_idle = HZ / 125;
Corrado Zoccolo5db5d642009-10-26 22:44:04 +010035static const int cfq_target_latency = HZ * 3/10; /* 300 ms */
36static const int cfq_hist_divisor = 4;
Jens Axboe22e2c502005-06-27 10:55:12 +020037
Jens Axboed9e76202007-04-20 14:27:50 +020038/*
Jens Axboe08717142008-01-28 11:38:15 +010039 * offset from end of service tree
Jens Axboed9e76202007-04-20 14:27:50 +020040 */
Jens Axboe08717142008-01-28 11:38:15 +010041#define CFQ_IDLE_DELAY (HZ / 5)
Jens Axboed9e76202007-04-20 14:27:50 +020042
43/*
44 * below this threshold, we consider thinktime immediate
45 */
46#define CFQ_MIN_TT (2)
47
Jens Axboe22e2c502005-06-27 10:55:12 +020048#define CFQ_SLICE_SCALE (5)
Aaron Carroll45333d52008-08-26 15:52:36 +020049#define CFQ_HW_QUEUE_MIN (5)
Vivek Goyal25bc6b02009-12-03 12:59:43 -050050#define CFQ_SERVICE_SHIFT 12
Jens Axboe22e2c502005-06-27 10:55:12 +020051
Corrado Zoccolo3dde36d2010-02-27 19:45:39 +010052#define CFQQ_SEEK_THR (sector_t)(8 * 100)
Shaohua Lie9ce3352010-03-19 08:03:04 +010053#define CFQQ_CLOSE_THR (sector_t)(8 * 1024)
Corrado Zoccolo41647e72010-02-27 19:45:40 +010054#define CFQQ_SECT_THR_NONROT (sector_t)(2 * 32)
Corrado Zoccolo3dde36d2010-02-27 19:45:39 +010055#define CFQQ_SEEKY(cfqq) (hweight32(cfqq->seek_history) > 32/8)
Shaohua Liae54abe2010-02-05 13:11:45 +010056
Tejun Heoa612fdd2011-12-14 00:33:41 +010057#define RQ_CIC(rq) icq_to_cic((rq)->elv.icq)
58#define RQ_CFQQ(rq) (struct cfq_queue *) ((rq)->elv.priv[0])
59#define RQ_CFQG(rq) (struct cfq_group *) ((rq)->elv.priv[1])
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
Christoph Lametere18b8902006-12-06 20:33:20 -080061static struct kmem_cache *cfq_pool;
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
Jens Axboe22e2c502005-06-27 10:55:12 +020063#define CFQ_PRIO_LISTS IOPRIO_BE_NR
64#define cfq_class_idle(cfqq) ((cfqq)->ioprio_class == IOPRIO_CLASS_IDLE)
Jens Axboe22e2c502005-06-27 10:55:12 +020065#define cfq_class_rt(cfqq) ((cfqq)->ioprio_class == IOPRIO_CLASS_RT)
66
Jens Axboe206dc692006-03-28 13:03:44 +020067#define sample_valid(samples) ((samples) > 80)
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -050068#define rb_entry_cfqg(node) rb_entry((node), struct cfq_group, rb_node)
Jens Axboe206dc692006-03-28 13:03:44 +020069
Tejun Heoc5869802011-12-14 00:33:41 +010070struct cfq_ttime {
71 unsigned long last_end_request;
72
73 unsigned long ttime_total;
74 unsigned long ttime_samples;
75 unsigned long ttime_mean;
76};
77
Jens Axboe22e2c502005-06-27 10:55:12 +020078/*
Jens Axboecc09e292007-04-26 12:53:50 +020079 * Most of our rbtree usage is for sorting with min extraction, so
80 * if we cache the leftmost node we don't have to walk down the tree
81 * to find it. Idea borrowed from Ingo Molnars CFS scheduler. We should
82 * move this into the elevator for the rq sorting as well.
83 */
84struct cfq_rb_root {
85 struct rb_root rb;
86 struct rb_node *left;
Corrado Zoccoloaa6f6a32009-10-26 22:44:33 +010087 unsigned count;
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -050088 u64 min_vdisktime;
Shaohua Lif5f2b6c2011-07-12 14:24:55 +020089 struct cfq_ttime ttime;
Jens Axboecc09e292007-04-26 12:53:50 +020090};
Shaohua Lif5f2b6c2011-07-12 14:24:55 +020091#define CFQ_RB_ROOT (struct cfq_rb_root) { .rb = RB_ROOT, \
92 .ttime = {.last_end_request = jiffies,},}
Jens Axboecc09e292007-04-26 12:53:50 +020093
94/*
Jens Axboe6118b702009-06-30 09:34:12 +020095 * Per process-grouping structure
96 */
97struct cfq_queue {
98 /* reference count */
Shaohua Li30d7b942011-01-07 08:46:59 +010099 int ref;
Jens Axboe6118b702009-06-30 09:34:12 +0200100 /* various state flags, see below */
101 unsigned int flags;
102 /* parent cfq_data */
103 struct cfq_data *cfqd;
104 /* service_tree member */
105 struct rb_node rb_node;
106 /* service_tree key */
107 unsigned long rb_key;
108 /* prio tree member */
109 struct rb_node p_node;
110 /* prio tree root we belong to, if any */
111 struct rb_root *p_root;
112 /* sorted list of pending requests */
113 struct rb_root sort_list;
114 /* if fifo isn't expired, next request to serve */
115 struct request *next_rq;
116 /* requests queued in sort_list */
117 int queued[2];
118 /* currently allocated requests */
119 int allocated[2];
120 /* fifo list of requests in sort_list */
121 struct list_head fifo;
122
Vivek Goyaldae739e2009-12-03 12:59:45 -0500123 /* time when queue got scheduled in to dispatch first request. */
124 unsigned long dispatch_start;
Vivek Goyalf75edf22009-12-03 12:59:53 -0500125 unsigned int allocated_slice;
Richard Kennedyc4081ba2010-02-22 13:49:24 +0100126 unsigned int slice_dispatch;
Vivek Goyaldae739e2009-12-03 12:59:45 -0500127 /* time when first request from queue completed and slice started. */
128 unsigned long slice_start;
Jens Axboe6118b702009-06-30 09:34:12 +0200129 unsigned long slice_end;
130 long slice_resid;
Jens Axboe6118b702009-06-30 09:34:12 +0200131
Christoph Hellwig65299a32011-08-23 14:50:29 +0200132 /* pending priority requests */
133 int prio_pending;
Jens Axboe6118b702009-06-30 09:34:12 +0200134 /* number of requests that are on the dispatch list or inside driver */
135 int dispatched;
136
137 /* io prio of this group */
138 unsigned short ioprio, org_ioprio;
Justin TerAvest4aede842011-07-12 08:31:45 +0200139 unsigned short ioprio_class;
Jens Axboe6118b702009-06-30 09:34:12 +0200140
Richard Kennedyc4081ba2010-02-22 13:49:24 +0100141 pid_t pid;
142
Corrado Zoccolo3dde36d2010-02-27 19:45:39 +0100143 u32 seek_history;
Jeff Moyerb2c18e12009-10-23 17:14:49 -0400144 sector_t last_request_pos;
145
Corrado Zoccoloaa6f6a32009-10-26 22:44:33 +0100146 struct cfq_rb_root *service_tree;
Jeff Moyerdf5fe3e2009-10-23 17:14:50 -0400147 struct cfq_queue *new_cfqq;
Vivek Goyalcdb16e82009-12-03 12:59:38 -0500148 struct cfq_group *cfqg;
Vivek Goyalc4e78932010-08-23 12:25:03 +0200149 /* Number of sectors dispatched from queue in single dispatch round */
150 unsigned long nr_sectors;
Jens Axboe6118b702009-06-30 09:34:12 +0200151};
152
153/*
Corrado Zoccolo718eee02009-10-26 22:45:29 +0100154 * First index in the service_trees.
Corrado Zoccoloc0324a02009-10-27 19:16:03 +0100155 * IDLE is handled separately, so it has negative index
156 */
Vivek Goyal3bf10fe2012-10-03 16:56:56 -0400157enum wl_class_t {
Corrado Zoccoloc0324a02009-10-27 19:16:03 +0100158 BE_WORKLOAD = 0,
Vivek Goyal615f0252009-12-03 12:59:39 -0500159 RT_WORKLOAD = 1,
160 IDLE_WORKLOAD = 2,
Vivek Goyalb4627322010-10-22 09:48:43 +0200161 CFQ_PRIO_NR,
Corrado Zoccoloc0324a02009-10-27 19:16:03 +0100162};
163
164/*
Corrado Zoccolo718eee02009-10-26 22:45:29 +0100165 * Second index in the service_trees.
166 */
167enum wl_type_t {
168 ASYNC_WORKLOAD = 0,
169 SYNC_NOIDLE_WORKLOAD = 1,
170 SYNC_WORKLOAD = 2
171};
172
Tejun Heo155fead2012-04-01 14:38:44 -0700173struct cfqg_stats {
174#ifdef CONFIG_CFQ_GROUP_IOSCHED
175 /* total bytes transferred */
176 struct blkg_rwstat service_bytes;
177 /* total IOs serviced, post merge */
178 struct blkg_rwstat serviced;
179 /* number of ios merged */
180 struct blkg_rwstat merged;
181 /* total time spent on device in ns, may not be accurate w/ queueing */
182 struct blkg_rwstat service_time;
183 /* total time spent waiting in scheduler queue in ns */
184 struct blkg_rwstat wait_time;
185 /* number of IOs queued up */
186 struct blkg_rwstat queued;
187 /* total sectors transferred */
188 struct blkg_stat sectors;
189 /* total disk time and nr sectors dispatched by this group */
190 struct blkg_stat time;
191#ifdef CONFIG_DEBUG_BLK_CGROUP
192 /* time not charged to this cgroup */
193 struct blkg_stat unaccounted_time;
194 /* sum of number of ios queued across all samples */
195 struct blkg_stat avg_queue_size_sum;
196 /* count of samples taken for average */
197 struct blkg_stat avg_queue_size_samples;
198 /* how many times this group has been removed from service tree */
199 struct blkg_stat dequeue;
200 /* total time spent waiting for it to be assigned a timeslice. */
201 struct blkg_stat group_wait_time;
Tejun Heo3c798392012-04-16 13:57:25 -0700202 /* time spent idling for this blkcg_gq */
Tejun Heo155fead2012-04-01 14:38:44 -0700203 struct blkg_stat idle_time;
204 /* total time with empty current active q with other requests queued */
205 struct blkg_stat empty_time;
206 /* fields after this shouldn't be cleared on stat reset */
207 uint64_t start_group_wait_time;
208 uint64_t start_idle_time;
209 uint64_t start_empty_time;
210 uint16_t flags;
211#endif /* CONFIG_DEBUG_BLK_CGROUP */
212#endif /* CONFIG_CFQ_GROUP_IOSCHED */
213};
214
Vivek Goyalcdb16e82009-12-03 12:59:38 -0500215/* This is per cgroup per device grouping structure */
216struct cfq_group {
Tejun Heof95a04a2012-04-16 13:57:26 -0700217 /* must be the first member */
218 struct blkg_policy_data pd;
219
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -0500220 /* group service_tree member */
221 struct rb_node rb_node;
222
223 /* group service_tree key */
224 u64 vdisktime;
Tejun Heoe71357e2013-01-09 08:05:10 -0800225
226 /*
Tejun Heo7918ffb2013-01-09 08:05:11 -0800227 * The number of active cfqgs and sum of their weights under this
228 * cfqg. This covers this cfqg's leaf_weight and all children's
229 * weights, but does not cover weights of further descendants.
230 *
231 * If a cfqg is on the service tree, it's active. An active cfqg
232 * also activates its parent and contributes to the children_weight
233 * of the parent.
234 */
235 int nr_active;
236 unsigned int children_weight;
237
238 /*
Tejun Heo1d3650f2013-01-09 08:05:11 -0800239 * vfraction is the fraction of vdisktime that the tasks in this
240 * cfqg are entitled to. This is determined by compounding the
241 * ratios walking up from this cfqg to the root.
242 *
243 * It is in fixed point w/ CFQ_SERVICE_SHIFT and the sum of all
244 * vfractions on a service tree is approximately 1. The sum may
245 * deviate a bit due to rounding errors and fluctuations caused by
246 * cfqgs entering and leaving the service tree.
247 */
248 unsigned int vfraction;
249
250 /*
Tejun Heoe71357e2013-01-09 08:05:10 -0800251 * There are two weights - (internal) weight is the weight of this
252 * cfqg against the sibling cfqgs. leaf_weight is the wight of
253 * this cfqg against the child cfqgs. For the root cfqg, both
254 * weights are kept in sync for backward compatibility.
255 */
Vivek Goyal25bc6b02009-12-03 12:59:43 -0500256 unsigned int weight;
Justin TerAvest8184f932011-03-17 16:12:36 +0100257 unsigned int new_weight;
Tejun Heo3381cb82012-04-01 14:38:44 -0700258 unsigned int dev_weight;
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -0500259
Tejun Heoe71357e2013-01-09 08:05:10 -0800260 unsigned int leaf_weight;
261 unsigned int new_leaf_weight;
262 unsigned int dev_leaf_weight;
263
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -0500264 /* number of cfqq currently on this group */
265 int nr_cfqq;
266
Jens Axboe22e2c502005-06-27 10:55:12 +0200267 /*
Kyungmin Park4495a7d2011-05-31 10:04:09 +0200268 * Per group busy queues average. Useful for workload slice calc. We
Vivek Goyalb4627322010-10-22 09:48:43 +0200269 * create the array for each prio class but at run time it is used
270 * only for RT and BE class and slot for IDLE class remains unused.
271 * This is primarily done to avoid confusion and a gcc warning.
272 */
273 unsigned int busy_queues_avg[CFQ_PRIO_NR];
274 /*
275 * rr lists of queues with requests. We maintain service trees for
276 * RT and BE classes. These trees are subdivided in subclasses
277 * of SYNC, SYNC_NOIDLE and ASYNC based on workload type. For IDLE
278 * class there is no subclassification and all the cfq queues go on
279 * a single tree service_tree_idle.
Corrado Zoccoloc0324a02009-10-27 19:16:03 +0100280 * Counts are embedded in the cfq_rb_root
Jens Axboe22e2c502005-06-27 10:55:12 +0200281 */
Corrado Zoccolo718eee02009-10-26 22:45:29 +0100282 struct cfq_rb_root service_trees[2][3];
Corrado Zoccoloc0324a02009-10-27 19:16:03 +0100283 struct cfq_rb_root service_tree_idle;
Vivek Goyaldae739e2009-12-03 12:59:45 -0500284
Vivek Goyal4d2ceea2012-10-03 16:56:57 -0400285 unsigned long saved_wl_slice;
286 enum wl_type_t saved_wl_type;
287 enum wl_class_t saved_wl_class;
Tejun Heo4eef3042012-03-05 13:15:18 -0800288
Vivek Goyal80bdf0c2010-08-23 12:24:26 +0200289 /* number of requests that are on the dispatch list or inside driver */
290 int dispatched;
Shaohua Li7700fc42011-07-12 14:24:56 +0200291 struct cfq_ttime ttime;
Tejun Heo0b399202013-01-09 08:05:13 -0800292 struct cfqg_stats stats; /* stats for this cfqg */
293 struct cfqg_stats dead_stats; /* stats pushed from dead children */
Vivek Goyalcdb16e82009-12-03 12:59:38 -0500294};
295
Tejun Heoc5869802011-12-14 00:33:41 +0100296struct cfq_io_cq {
297 struct io_cq icq; /* must be the first member */
298 struct cfq_queue *cfqq[2];
299 struct cfq_ttime ttime;
Tejun Heo598971b2012-03-19 15:10:58 -0700300 int ioprio; /* the current ioprio */
301#ifdef CONFIG_CFQ_GROUP_IOSCHED
302 uint64_t blkcg_id; /* the current blkcg ID */
303#endif
Tejun Heoc5869802011-12-14 00:33:41 +0100304};
305
Vivek Goyalcdb16e82009-12-03 12:59:38 -0500306/*
307 * Per block device queue structure
308 */
309struct cfq_data {
310 struct request_queue *queue;
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -0500311 /* Root service tree for cfq_groups */
312 struct cfq_rb_root grp_service_tree;
Tejun Heof51b8022012-03-05 13:15:05 -0800313 struct cfq_group *root_group;
Vivek Goyalcdb16e82009-12-03 12:59:38 -0500314
Corrado Zoccoloc0324a02009-10-27 19:16:03 +0100315 /*
316 * The priority currently being served
317 */
Vivek Goyal4d2ceea2012-10-03 16:56:57 -0400318 enum wl_class_t serving_wl_class;
319 enum wl_type_t serving_wl_type;
Corrado Zoccolo718eee02009-10-26 22:45:29 +0100320 unsigned long workload_expires;
Vivek Goyalcdb16e82009-12-03 12:59:38 -0500321 struct cfq_group *serving_group;
Jens Axboea36e71f2009-04-15 12:15:11 +0200322
323 /*
324 * Each priority tree is sorted by next_request position. These
325 * trees are used when determining if two or more queues are
326 * interleaving requests (see cfq_close_cooperator).
327 */
328 struct rb_root prio_trees[CFQ_PRIO_LISTS];
329
Jens Axboe22e2c502005-06-27 10:55:12 +0200330 unsigned int busy_queues;
Shaohua Lief8a41d2011-03-07 09:26:29 +0100331 unsigned int busy_sync_queues;
Jens Axboe22e2c502005-06-27 10:55:12 +0200332
Corrado Zoccolo53c583d2010-02-28 19:45:05 +0100333 int rq_in_driver;
334 int rq_in_flight[2];
Aaron Carroll45333d52008-08-26 15:52:36 +0200335
336 /*
337 * queue-depth detection
338 */
339 int rq_queued;
Jens Axboe25776e32006-06-01 10:12:26 +0200340 int hw_tag;
Corrado Zoccoloe459dd02009-11-26 10:02:57 +0100341 /*
342 * hw_tag can be
343 * -1 => indeterminate, (cfq will behave as if NCQ is present, to allow better detection)
344 * 1 => NCQ is present (hw_tag_est_depth is the estimated max depth)
345 * 0 => no NCQ
346 */
347 int hw_tag_est_depth;
348 unsigned int hw_tag_samples;
Jens Axboe22e2c502005-06-27 10:55:12 +0200349
350 /*
Jens Axboe22e2c502005-06-27 10:55:12 +0200351 * idle window management
352 */
353 struct timer_list idle_slice_timer;
Jens Axboe23e018a2009-10-05 08:52:35 +0200354 struct work_struct unplug_work;
Jens Axboe22e2c502005-06-27 10:55:12 +0200355
356 struct cfq_queue *active_queue;
Tejun Heoc5869802011-12-14 00:33:41 +0100357 struct cfq_io_cq *active_cic;
Jens Axboe22e2c502005-06-27 10:55:12 +0200358
Vasily Tarasovc2dea2d2007-07-20 10:06:38 +0200359 /*
360 * async queue for each priority case
361 */
362 struct cfq_queue *async_cfqq[2][IOPRIO_BE_NR];
363 struct cfq_queue *async_idle_cfqq;
Jens Axboe15c31be2007-07-10 13:43:25 +0200364
Jens Axboe6d048f52007-04-25 12:44:27 +0200365 sector_t last_position;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 /*
368 * tunables, see top of file
369 */
370 unsigned int cfq_quantum;
Jens Axboe22e2c502005-06-27 10:55:12 +0200371 unsigned int cfq_fifo_expire[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 unsigned int cfq_back_penalty;
373 unsigned int cfq_back_max;
Jens Axboe22e2c502005-06-27 10:55:12 +0200374 unsigned int cfq_slice[2];
375 unsigned int cfq_slice_async_rq;
376 unsigned int cfq_slice_idle;
Vivek Goyal80bdf0c2010-08-23 12:24:26 +0200377 unsigned int cfq_group_idle;
Jens Axboe963b72f2009-10-03 19:42:18 +0200378 unsigned int cfq_latency;
Tao Ma5bf14c02012-04-01 14:33:39 -0700379 unsigned int cfq_target_latency;
Al Virod9ff4182006-03-18 13:51:22 -0500380
Jens Axboe6118b702009-06-30 09:34:12 +0200381 /*
382 * Fallback dummy cfqq for extreme OOM conditions
383 */
384 struct cfq_queue oom_cfqq;
Vivek Goyal365722b2009-10-03 15:21:27 +0200385
Corrado Zoccolo573412b2009-12-06 11:48:52 +0100386 unsigned long last_delayed_sync;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387};
388
Vivek Goyal25fb5162009-12-03 12:59:46 -0500389static struct cfq_group *cfq_get_next_cfqg(struct cfq_data *cfqd);
390
Vivek Goyal34b98d02012-10-03 16:56:58 -0400391static struct cfq_rb_root *st_for(struct cfq_group *cfqg,
Vivek Goyal3bf10fe2012-10-03 16:56:56 -0400392 enum wl_class_t class,
Vivek Goyal65b32a52009-12-16 17:52:59 -0500393 enum wl_type_t type)
Corrado Zoccoloc0324a02009-10-27 19:16:03 +0100394{
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -0500395 if (!cfqg)
396 return NULL;
397
Vivek Goyal3bf10fe2012-10-03 16:56:56 -0400398 if (class == IDLE_WORKLOAD)
Vivek Goyalcdb16e82009-12-03 12:59:38 -0500399 return &cfqg->service_tree_idle;
Corrado Zoccoloc0324a02009-10-27 19:16:03 +0100400
Vivek Goyal3bf10fe2012-10-03 16:56:56 -0400401 return &cfqg->service_trees[class][type];
Corrado Zoccoloc0324a02009-10-27 19:16:03 +0100402}
403
Jens Axboe3b181522005-06-27 10:56:24 +0200404enum cfqq_state_flags {
Jens Axboeb0b8d7492007-01-19 11:35:30 +1100405 CFQ_CFQQ_FLAG_on_rr = 0, /* on round-robin busy list */
406 CFQ_CFQQ_FLAG_wait_request, /* waiting for a request */
Jens Axboeb0291952009-04-07 11:38:31 +0200407 CFQ_CFQQ_FLAG_must_dispatch, /* must be allowed a dispatch */
Jens Axboeb0b8d7492007-01-19 11:35:30 +1100408 CFQ_CFQQ_FLAG_must_alloc_slice, /* per-slice must_alloc flag */
Jens Axboeb0b8d7492007-01-19 11:35:30 +1100409 CFQ_CFQQ_FLAG_fifo_expire, /* FIFO checked in this slice */
410 CFQ_CFQQ_FLAG_idle_window, /* slice idling enabled */
411 CFQ_CFQQ_FLAG_prio_changed, /* task priority has changed */
Jens Axboe44f7c162007-01-19 11:51:58 +1100412 CFQ_CFQQ_FLAG_slice_new, /* no requests dispatched in slice */
Vasily Tarasov91fac312007-04-25 12:29:51 +0200413 CFQ_CFQQ_FLAG_sync, /* synchronous queue */
Jeff Moyerb3b6d042009-10-23 17:14:51 -0400414 CFQ_CFQQ_FLAG_coop, /* cfqq is shared */
Shaohua Liae54abe2010-02-05 13:11:45 +0100415 CFQ_CFQQ_FLAG_split_coop, /* shared cfqq will be splitted */
Corrado Zoccolo76280af2009-11-26 10:02:58 +0100416 CFQ_CFQQ_FLAG_deep, /* sync cfqq experienced large depth */
Vivek Goyalf75edf22009-12-03 12:59:53 -0500417 CFQ_CFQQ_FLAG_wait_busy, /* Waiting for next request */
Jens Axboe3b181522005-06-27 10:56:24 +0200418};
419
420#define CFQ_CFQQ_FNS(name) \
421static inline void cfq_mark_cfqq_##name(struct cfq_queue *cfqq) \
422{ \
Jens Axboefe094d92008-01-31 13:08:54 +0100423 (cfqq)->flags |= (1 << CFQ_CFQQ_FLAG_##name); \
Jens Axboe3b181522005-06-27 10:56:24 +0200424} \
425static inline void cfq_clear_cfqq_##name(struct cfq_queue *cfqq) \
426{ \
Jens Axboefe094d92008-01-31 13:08:54 +0100427 (cfqq)->flags &= ~(1 << CFQ_CFQQ_FLAG_##name); \
Jens Axboe3b181522005-06-27 10:56:24 +0200428} \
429static inline int cfq_cfqq_##name(const struct cfq_queue *cfqq) \
430{ \
Jens Axboefe094d92008-01-31 13:08:54 +0100431 return ((cfqq)->flags & (1 << CFQ_CFQQ_FLAG_##name)) != 0; \
Jens Axboe3b181522005-06-27 10:56:24 +0200432}
433
434CFQ_CFQQ_FNS(on_rr);
435CFQ_CFQQ_FNS(wait_request);
Jens Axboeb0291952009-04-07 11:38:31 +0200436CFQ_CFQQ_FNS(must_dispatch);
Jens Axboe3b181522005-06-27 10:56:24 +0200437CFQ_CFQQ_FNS(must_alloc_slice);
Jens Axboe3b181522005-06-27 10:56:24 +0200438CFQ_CFQQ_FNS(fifo_expire);
439CFQ_CFQQ_FNS(idle_window);
440CFQ_CFQQ_FNS(prio_changed);
Jens Axboe44f7c162007-01-19 11:51:58 +1100441CFQ_CFQQ_FNS(slice_new);
Vasily Tarasov91fac312007-04-25 12:29:51 +0200442CFQ_CFQQ_FNS(sync);
Jens Axboea36e71f2009-04-15 12:15:11 +0200443CFQ_CFQQ_FNS(coop);
Shaohua Liae54abe2010-02-05 13:11:45 +0100444CFQ_CFQQ_FNS(split_coop);
Corrado Zoccolo76280af2009-11-26 10:02:58 +0100445CFQ_CFQQ_FNS(deep);
Vivek Goyalf75edf22009-12-03 12:59:53 -0500446CFQ_CFQQ_FNS(wait_busy);
Jens Axboe3b181522005-06-27 10:56:24 +0200447#undef CFQ_CFQQ_FNS
448
Tejun Heof95a04a2012-04-16 13:57:26 -0700449static inline struct cfq_group *pd_to_cfqg(struct blkg_policy_data *pd)
450{
451 return pd ? container_of(pd, struct cfq_group, pd) : NULL;
452}
453
Tejun Heof95a04a2012-04-16 13:57:26 -0700454static inline struct blkcg_gq *cfqg_to_blkg(struct cfq_group *cfqg)
455{
456 return pd_to_blkg(&cfqg->pd);
457}
458
Tejun Heo629ed0b2012-04-01 14:38:44 -0700459#if defined(CONFIG_CFQ_GROUP_IOSCHED) && defined(CONFIG_DEBUG_BLK_CGROUP)
Tejun Heo2ce4d502012-04-01 14:38:43 -0700460
Tejun Heo155fead2012-04-01 14:38:44 -0700461/* cfqg stats flags */
462enum cfqg_stats_flags {
463 CFQG_stats_waiting = 0,
464 CFQG_stats_idling,
465 CFQG_stats_empty,
Tejun Heo629ed0b2012-04-01 14:38:44 -0700466};
467
Tejun Heo155fead2012-04-01 14:38:44 -0700468#define CFQG_FLAG_FNS(name) \
469static inline void cfqg_stats_mark_##name(struct cfqg_stats *stats) \
Tejun Heo629ed0b2012-04-01 14:38:44 -0700470{ \
Tejun Heo155fead2012-04-01 14:38:44 -0700471 stats->flags |= (1 << CFQG_stats_##name); \
Tejun Heo629ed0b2012-04-01 14:38:44 -0700472} \
Tejun Heo155fead2012-04-01 14:38:44 -0700473static inline void cfqg_stats_clear_##name(struct cfqg_stats *stats) \
Tejun Heo629ed0b2012-04-01 14:38:44 -0700474{ \
Tejun Heo155fead2012-04-01 14:38:44 -0700475 stats->flags &= ~(1 << CFQG_stats_##name); \
Tejun Heo629ed0b2012-04-01 14:38:44 -0700476} \
Tejun Heo155fead2012-04-01 14:38:44 -0700477static inline int cfqg_stats_##name(struct cfqg_stats *stats) \
Tejun Heo629ed0b2012-04-01 14:38:44 -0700478{ \
Tejun Heo155fead2012-04-01 14:38:44 -0700479 return (stats->flags & (1 << CFQG_stats_##name)) != 0; \
Tejun Heo629ed0b2012-04-01 14:38:44 -0700480} \
481
Tejun Heo155fead2012-04-01 14:38:44 -0700482CFQG_FLAG_FNS(waiting)
483CFQG_FLAG_FNS(idling)
484CFQG_FLAG_FNS(empty)
485#undef CFQG_FLAG_FNS
Tejun Heo629ed0b2012-04-01 14:38:44 -0700486
487/* This should be called with the queue_lock held. */
Tejun Heo155fead2012-04-01 14:38:44 -0700488static void cfqg_stats_update_group_wait_time(struct cfqg_stats *stats)
Tejun Heo629ed0b2012-04-01 14:38:44 -0700489{
490 unsigned long long now;
491
Tejun Heo155fead2012-04-01 14:38:44 -0700492 if (!cfqg_stats_waiting(stats))
Tejun Heo629ed0b2012-04-01 14:38:44 -0700493 return;
494
495 now = sched_clock();
496 if (time_after64(now, stats->start_group_wait_time))
497 blkg_stat_add(&stats->group_wait_time,
498 now - stats->start_group_wait_time);
Tejun Heo155fead2012-04-01 14:38:44 -0700499 cfqg_stats_clear_waiting(stats);
Tejun Heo629ed0b2012-04-01 14:38:44 -0700500}
501
502/* This should be called with the queue_lock held. */
Tejun Heo155fead2012-04-01 14:38:44 -0700503static void cfqg_stats_set_start_group_wait_time(struct cfq_group *cfqg,
504 struct cfq_group *curr_cfqg)
Tejun Heo629ed0b2012-04-01 14:38:44 -0700505{
Tejun Heo155fead2012-04-01 14:38:44 -0700506 struct cfqg_stats *stats = &cfqg->stats;
Tejun Heo629ed0b2012-04-01 14:38:44 -0700507
Tejun Heo155fead2012-04-01 14:38:44 -0700508 if (cfqg_stats_waiting(stats))
Tejun Heo629ed0b2012-04-01 14:38:44 -0700509 return;
Tejun Heo155fead2012-04-01 14:38:44 -0700510 if (cfqg == curr_cfqg)
Tejun Heo629ed0b2012-04-01 14:38:44 -0700511 return;
Tejun Heo155fead2012-04-01 14:38:44 -0700512 stats->start_group_wait_time = sched_clock();
513 cfqg_stats_mark_waiting(stats);
Tejun Heo629ed0b2012-04-01 14:38:44 -0700514}
515
516/* This should be called with the queue_lock held. */
Tejun Heo155fead2012-04-01 14:38:44 -0700517static void cfqg_stats_end_empty_time(struct cfqg_stats *stats)
Tejun Heo629ed0b2012-04-01 14:38:44 -0700518{
519 unsigned long long now;
520
Tejun Heo155fead2012-04-01 14:38:44 -0700521 if (!cfqg_stats_empty(stats))
Tejun Heo629ed0b2012-04-01 14:38:44 -0700522 return;
523
524 now = sched_clock();
525 if (time_after64(now, stats->start_empty_time))
526 blkg_stat_add(&stats->empty_time,
527 now - stats->start_empty_time);
Tejun Heo155fead2012-04-01 14:38:44 -0700528 cfqg_stats_clear_empty(stats);
Tejun Heo629ed0b2012-04-01 14:38:44 -0700529}
530
Tejun Heo155fead2012-04-01 14:38:44 -0700531static void cfqg_stats_update_dequeue(struct cfq_group *cfqg)
Tejun Heo629ed0b2012-04-01 14:38:44 -0700532{
Tejun Heo155fead2012-04-01 14:38:44 -0700533 blkg_stat_add(&cfqg->stats.dequeue, 1);
Tejun Heo629ed0b2012-04-01 14:38:44 -0700534}
535
Tejun Heo155fead2012-04-01 14:38:44 -0700536static void cfqg_stats_set_start_empty_time(struct cfq_group *cfqg)
Tejun Heo629ed0b2012-04-01 14:38:44 -0700537{
Tejun Heo155fead2012-04-01 14:38:44 -0700538 struct cfqg_stats *stats = &cfqg->stats;
Tejun Heo629ed0b2012-04-01 14:38:44 -0700539
Tejun Heo4d5e80a2013-01-09 08:05:12 -0800540 if (blkg_rwstat_total(&stats->queued))
Tejun Heo629ed0b2012-04-01 14:38:44 -0700541 return;
542
543 /*
544 * group is already marked empty. This can happen if cfqq got new
545 * request in parent group and moved to this group while being added
546 * to service tree. Just ignore the event and move on.
547 */
Tejun Heo155fead2012-04-01 14:38:44 -0700548 if (cfqg_stats_empty(stats))
Tejun Heo629ed0b2012-04-01 14:38:44 -0700549 return;
550
551 stats->start_empty_time = sched_clock();
Tejun Heo155fead2012-04-01 14:38:44 -0700552 cfqg_stats_mark_empty(stats);
Tejun Heo629ed0b2012-04-01 14:38:44 -0700553}
554
Tejun Heo155fead2012-04-01 14:38:44 -0700555static void cfqg_stats_update_idle_time(struct cfq_group *cfqg)
Tejun Heo629ed0b2012-04-01 14:38:44 -0700556{
Tejun Heo155fead2012-04-01 14:38:44 -0700557 struct cfqg_stats *stats = &cfqg->stats;
Tejun Heo629ed0b2012-04-01 14:38:44 -0700558
Tejun Heo155fead2012-04-01 14:38:44 -0700559 if (cfqg_stats_idling(stats)) {
Tejun Heo629ed0b2012-04-01 14:38:44 -0700560 unsigned long long now = sched_clock();
561
562 if (time_after64(now, stats->start_idle_time))
563 blkg_stat_add(&stats->idle_time,
564 now - stats->start_idle_time);
Tejun Heo155fead2012-04-01 14:38:44 -0700565 cfqg_stats_clear_idling(stats);
Tejun Heo629ed0b2012-04-01 14:38:44 -0700566 }
567}
568
Tejun Heo155fead2012-04-01 14:38:44 -0700569static void cfqg_stats_set_start_idle_time(struct cfq_group *cfqg)
Tejun Heo629ed0b2012-04-01 14:38:44 -0700570{
Tejun Heo155fead2012-04-01 14:38:44 -0700571 struct cfqg_stats *stats = &cfqg->stats;
Tejun Heo629ed0b2012-04-01 14:38:44 -0700572
Tejun Heo155fead2012-04-01 14:38:44 -0700573 BUG_ON(cfqg_stats_idling(stats));
Tejun Heo629ed0b2012-04-01 14:38:44 -0700574
575 stats->start_idle_time = sched_clock();
Tejun Heo155fead2012-04-01 14:38:44 -0700576 cfqg_stats_mark_idling(stats);
Tejun Heo629ed0b2012-04-01 14:38:44 -0700577}
578
Tejun Heo155fead2012-04-01 14:38:44 -0700579static void cfqg_stats_update_avg_queue_size(struct cfq_group *cfqg)
Tejun Heo629ed0b2012-04-01 14:38:44 -0700580{
Tejun Heo155fead2012-04-01 14:38:44 -0700581 struct cfqg_stats *stats = &cfqg->stats;
Tejun Heo629ed0b2012-04-01 14:38:44 -0700582
583 blkg_stat_add(&stats->avg_queue_size_sum,
Tejun Heo4d5e80a2013-01-09 08:05:12 -0800584 blkg_rwstat_total(&stats->queued));
Tejun Heo629ed0b2012-04-01 14:38:44 -0700585 blkg_stat_add(&stats->avg_queue_size_samples, 1);
Tejun Heo155fead2012-04-01 14:38:44 -0700586 cfqg_stats_update_group_wait_time(stats);
Tejun Heo629ed0b2012-04-01 14:38:44 -0700587}
588
589#else /* CONFIG_CFQ_GROUP_IOSCHED && CONFIG_DEBUG_BLK_CGROUP */
590
Tejun Heof48ec1d2012-04-13 13:11:25 -0700591static inline void cfqg_stats_set_start_group_wait_time(struct cfq_group *cfqg, struct cfq_group *curr_cfqg) { }
592static inline void cfqg_stats_end_empty_time(struct cfqg_stats *stats) { }
593static inline void cfqg_stats_update_dequeue(struct cfq_group *cfqg) { }
594static inline void cfqg_stats_set_start_empty_time(struct cfq_group *cfqg) { }
595static inline void cfqg_stats_update_idle_time(struct cfq_group *cfqg) { }
596static inline void cfqg_stats_set_start_idle_time(struct cfq_group *cfqg) { }
597static inline void cfqg_stats_update_avg_queue_size(struct cfq_group *cfqg) { }
Tejun Heo629ed0b2012-04-01 14:38:44 -0700598
599#endif /* CONFIG_CFQ_GROUP_IOSCHED && CONFIG_DEBUG_BLK_CGROUP */
600
601#ifdef CONFIG_CFQ_GROUP_IOSCHED
Tejun Heo2ce4d502012-04-01 14:38:43 -0700602
Tejun Heoffea73f2012-06-04 10:02:29 +0200603static struct blkcg_policy blkcg_policy_cfq;
604
605static inline struct cfq_group *blkg_to_cfqg(struct blkcg_gq *blkg)
606{
607 return pd_to_cfqg(blkg_to_pd(blkg, &blkcg_policy_cfq));
608}
609
Tejun Heod02f7aa2013-01-09 08:05:11 -0800610static inline struct cfq_group *cfqg_parent(struct cfq_group *cfqg)
Tejun Heo7918ffb2013-01-09 08:05:11 -0800611{
Tejun Heod02f7aa2013-01-09 08:05:11 -0800612 struct blkcg_gq *pblkg = cfqg_to_blkg(cfqg)->parent;
Tejun Heo7918ffb2013-01-09 08:05:11 -0800613
Tejun Heod02f7aa2013-01-09 08:05:11 -0800614 return pblkg ? blkg_to_cfqg(pblkg) : NULL;
Tejun Heo7918ffb2013-01-09 08:05:11 -0800615}
616
Tejun Heoeb7d8c072012-03-23 14:02:53 +0100617static inline void cfqg_get(struct cfq_group *cfqg)
618{
619 return blkg_get(cfqg_to_blkg(cfqg));
620}
621
622static inline void cfqg_put(struct cfq_group *cfqg)
623{
624 return blkg_put(cfqg_to_blkg(cfqg));
625}
626
Tejun Heo54e7ed12012-04-16 13:57:23 -0700627#define cfq_log_cfqq(cfqd, cfqq, fmt, args...) do { \
628 char __pbuf[128]; \
629 \
630 blkg_path(cfqg_to_blkg((cfqq)->cfqg), __pbuf, sizeof(__pbuf)); \
Vivek Goyalb226e5c2012-10-03 16:57:01 -0400631 blk_add_trace_msg((cfqd)->queue, "cfq%d%c%c %s " fmt, (cfqq)->pid, \
632 cfq_cfqq_sync((cfqq)) ? 'S' : 'A', \
633 cfqq_type((cfqq)) == SYNC_NOIDLE_WORKLOAD ? 'N' : ' ',\
Tejun Heo54e7ed12012-04-16 13:57:23 -0700634 __pbuf, ##args); \
635} while (0)
Vivek Goyal2868ef72009-12-03 12:59:48 -0500636
Tejun Heo54e7ed12012-04-16 13:57:23 -0700637#define cfq_log_cfqg(cfqd, cfqg, fmt, args...) do { \
638 char __pbuf[128]; \
639 \
640 blkg_path(cfqg_to_blkg(cfqg), __pbuf, sizeof(__pbuf)); \
641 blk_add_trace_msg((cfqd)->queue, "%s " fmt, __pbuf, ##args); \
642} while (0)
Vivek Goyal2868ef72009-12-03 12:59:48 -0500643
Tejun Heo155fead2012-04-01 14:38:44 -0700644static inline void cfqg_stats_update_io_add(struct cfq_group *cfqg,
645 struct cfq_group *curr_cfqg, int rw)
Tejun Heo2ce4d502012-04-01 14:38:43 -0700646{
Tejun Heo155fead2012-04-01 14:38:44 -0700647 blkg_rwstat_add(&cfqg->stats.queued, rw, 1);
648 cfqg_stats_end_empty_time(&cfqg->stats);
649 cfqg_stats_set_start_group_wait_time(cfqg, curr_cfqg);
Tejun Heo2ce4d502012-04-01 14:38:43 -0700650}
651
Tejun Heo155fead2012-04-01 14:38:44 -0700652static inline void cfqg_stats_update_timeslice_used(struct cfq_group *cfqg,
653 unsigned long time, unsigned long unaccounted_time)
Tejun Heo2ce4d502012-04-01 14:38:43 -0700654{
Tejun Heo155fead2012-04-01 14:38:44 -0700655 blkg_stat_add(&cfqg->stats.time, time);
Tejun Heo629ed0b2012-04-01 14:38:44 -0700656#ifdef CONFIG_DEBUG_BLK_CGROUP
Tejun Heo155fead2012-04-01 14:38:44 -0700657 blkg_stat_add(&cfqg->stats.unaccounted_time, unaccounted_time);
Tejun Heo629ed0b2012-04-01 14:38:44 -0700658#endif
Tejun Heo2ce4d502012-04-01 14:38:43 -0700659}
660
Tejun Heo155fead2012-04-01 14:38:44 -0700661static inline void cfqg_stats_update_io_remove(struct cfq_group *cfqg, int rw)
Tejun Heo2ce4d502012-04-01 14:38:43 -0700662{
Tejun Heo155fead2012-04-01 14:38:44 -0700663 blkg_rwstat_add(&cfqg->stats.queued, rw, -1);
Tejun Heo2ce4d502012-04-01 14:38:43 -0700664}
665
Tejun Heo155fead2012-04-01 14:38:44 -0700666static inline void cfqg_stats_update_io_merged(struct cfq_group *cfqg, int rw)
Tejun Heo2ce4d502012-04-01 14:38:43 -0700667{
Tejun Heo155fead2012-04-01 14:38:44 -0700668 blkg_rwstat_add(&cfqg->stats.merged, rw, 1);
Tejun Heo2ce4d502012-04-01 14:38:43 -0700669}
670
Tejun Heo155fead2012-04-01 14:38:44 -0700671static inline void cfqg_stats_update_dispatch(struct cfq_group *cfqg,
672 uint64_t bytes, int rw)
Tejun Heo2ce4d502012-04-01 14:38:43 -0700673{
Tejun Heo155fead2012-04-01 14:38:44 -0700674 blkg_stat_add(&cfqg->stats.sectors, bytes >> 9);
675 blkg_rwstat_add(&cfqg->stats.serviced, rw, 1);
676 blkg_rwstat_add(&cfqg->stats.service_bytes, rw, bytes);
Tejun Heo2ce4d502012-04-01 14:38:43 -0700677}
678
Tejun Heo155fead2012-04-01 14:38:44 -0700679static inline void cfqg_stats_update_completion(struct cfq_group *cfqg,
680 uint64_t start_time, uint64_t io_start_time, int rw)
Tejun Heo2ce4d502012-04-01 14:38:43 -0700681{
Tejun Heo155fead2012-04-01 14:38:44 -0700682 struct cfqg_stats *stats = &cfqg->stats;
Tejun Heo629ed0b2012-04-01 14:38:44 -0700683 unsigned long long now = sched_clock();
Tejun Heo629ed0b2012-04-01 14:38:44 -0700684
685 if (time_after64(now, io_start_time))
686 blkg_rwstat_add(&stats->service_time, rw, now - io_start_time);
687 if (time_after64(io_start_time, start_time))
688 blkg_rwstat_add(&stats->wait_time, rw,
689 io_start_time - start_time);
Tejun Heo2ce4d502012-04-01 14:38:43 -0700690}
691
Tejun Heo689665a2013-01-09 08:05:13 -0800692/* @stats = 0 */
693static void cfqg_stats_reset(struct cfqg_stats *stats)
Tejun Heo155fead2012-04-01 14:38:44 -0700694{
Tejun Heo155fead2012-04-01 14:38:44 -0700695 /* queued stats shouldn't be cleared */
696 blkg_rwstat_reset(&stats->service_bytes);
697 blkg_rwstat_reset(&stats->serviced);
698 blkg_rwstat_reset(&stats->merged);
699 blkg_rwstat_reset(&stats->service_time);
700 blkg_rwstat_reset(&stats->wait_time);
701 blkg_stat_reset(&stats->time);
702#ifdef CONFIG_DEBUG_BLK_CGROUP
703 blkg_stat_reset(&stats->unaccounted_time);
704 blkg_stat_reset(&stats->avg_queue_size_sum);
705 blkg_stat_reset(&stats->avg_queue_size_samples);
706 blkg_stat_reset(&stats->dequeue);
707 blkg_stat_reset(&stats->group_wait_time);
708 blkg_stat_reset(&stats->idle_time);
709 blkg_stat_reset(&stats->empty_time);
710#endif
711}
712
Tejun Heo0b399202013-01-09 08:05:13 -0800713/* @to += @from */
714static void cfqg_stats_merge(struct cfqg_stats *to, struct cfqg_stats *from)
715{
716 /* queued stats shouldn't be cleared */
717 blkg_rwstat_merge(&to->service_bytes, &from->service_bytes);
718 blkg_rwstat_merge(&to->serviced, &from->serviced);
719 blkg_rwstat_merge(&to->merged, &from->merged);
720 blkg_rwstat_merge(&to->service_time, &from->service_time);
721 blkg_rwstat_merge(&to->wait_time, &from->wait_time);
722 blkg_stat_merge(&from->time, &from->time);
723#ifdef CONFIG_DEBUG_BLK_CGROUP
724 blkg_stat_merge(&to->unaccounted_time, &from->unaccounted_time);
725 blkg_stat_merge(&to->avg_queue_size_sum, &from->avg_queue_size_sum);
726 blkg_stat_merge(&to->avg_queue_size_samples, &from->avg_queue_size_samples);
727 blkg_stat_merge(&to->dequeue, &from->dequeue);
728 blkg_stat_merge(&to->group_wait_time, &from->group_wait_time);
729 blkg_stat_merge(&to->idle_time, &from->idle_time);
730 blkg_stat_merge(&to->empty_time, &from->empty_time);
731#endif
732}
733
734/*
735 * Transfer @cfqg's stats to its parent's dead_stats so that the ancestors'
736 * recursive stats can still account for the amount used by this cfqg after
737 * it's gone.
738 */
739static void cfqg_stats_xfer_dead(struct cfq_group *cfqg)
740{
741 struct cfq_group *parent = cfqg_parent(cfqg);
742
743 lockdep_assert_held(cfqg_to_blkg(cfqg)->q->queue_lock);
744
745 if (unlikely(!parent))
746 return;
747
748 cfqg_stats_merge(&parent->dead_stats, &cfqg->stats);
749 cfqg_stats_merge(&parent->dead_stats, &cfqg->dead_stats);
750 cfqg_stats_reset(&cfqg->stats);
751 cfqg_stats_reset(&cfqg->dead_stats);
752}
753
Tejun Heoeb7d8c072012-03-23 14:02:53 +0100754#else /* CONFIG_CFQ_GROUP_IOSCHED */
755
Tejun Heod02f7aa2013-01-09 08:05:11 -0800756static inline struct cfq_group *cfqg_parent(struct cfq_group *cfqg) { return NULL; }
Tejun Heoeb7d8c072012-03-23 14:02:53 +0100757static inline void cfqg_get(struct cfq_group *cfqg) { }
758static inline void cfqg_put(struct cfq_group *cfqg) { }
759
Jens Axboe7b679132008-05-30 12:23:07 +0200760#define cfq_log_cfqq(cfqd, cfqq, fmt, args...) \
Vivek Goyalb226e5c2012-10-03 16:57:01 -0400761 blk_add_trace_msg((cfqd)->queue, "cfq%d%c%c " fmt, (cfqq)->pid, \
762 cfq_cfqq_sync((cfqq)) ? 'S' : 'A', \
763 cfqq_type((cfqq)) == SYNC_NOIDLE_WORKLOAD ? 'N' : ' ',\
764 ##args)
Kyungmin Park4495a7d2011-05-31 10:04:09 +0200765#define cfq_log_cfqg(cfqd, cfqg, fmt, args...) do {} while (0)
Tejun Heoeb7d8c072012-03-23 14:02:53 +0100766
Tejun Heo155fead2012-04-01 14:38:44 -0700767static inline void cfqg_stats_update_io_add(struct cfq_group *cfqg,
768 struct cfq_group *curr_cfqg, int rw) { }
769static inline void cfqg_stats_update_timeslice_used(struct cfq_group *cfqg,
770 unsigned long time, unsigned long unaccounted_time) { }
771static inline void cfqg_stats_update_io_remove(struct cfq_group *cfqg, int rw) { }
772static inline void cfqg_stats_update_io_merged(struct cfq_group *cfqg, int rw) { }
773static inline void cfqg_stats_update_dispatch(struct cfq_group *cfqg,
774 uint64_t bytes, int rw) { }
775static inline void cfqg_stats_update_completion(struct cfq_group *cfqg,
776 uint64_t start_time, uint64_t io_start_time, int rw) { }
Tejun Heo2ce4d502012-04-01 14:38:43 -0700777
Tejun Heoeb7d8c072012-03-23 14:02:53 +0100778#endif /* CONFIG_CFQ_GROUP_IOSCHED */
779
Jens Axboe7b679132008-05-30 12:23:07 +0200780#define cfq_log(cfqd, fmt, args...) \
781 blk_add_trace_msg((cfqd)->queue, "cfq " fmt, ##args)
782
Vivek Goyal615f0252009-12-03 12:59:39 -0500783/* Traverses through cfq group service trees */
784#define for_each_cfqg_st(cfqg, i, j, st) \
785 for (i = 0; i <= IDLE_WORKLOAD; i++) \
786 for (j = 0, st = i < IDLE_WORKLOAD ? &cfqg->service_trees[i][j]\
787 : &cfqg->service_tree_idle; \
788 (i < IDLE_WORKLOAD && j <= SYNC_WORKLOAD) || \
789 (i == IDLE_WORKLOAD && j == 0); \
790 j++, st = i < IDLE_WORKLOAD ? \
791 &cfqg->service_trees[i][j]: NULL) \
792
Shaohua Lif5f2b6c2011-07-12 14:24:55 +0200793static inline bool cfq_io_thinktime_big(struct cfq_data *cfqd,
794 struct cfq_ttime *ttime, bool group_idle)
795{
796 unsigned long slice;
797 if (!sample_valid(ttime->ttime_samples))
798 return false;
799 if (group_idle)
800 slice = cfqd->cfq_group_idle;
801 else
802 slice = cfqd->cfq_slice_idle;
803 return ttime->ttime_mean > slice;
804}
Vivek Goyal615f0252009-12-03 12:59:39 -0500805
Vivek Goyal02b35082010-08-23 12:23:53 +0200806static inline bool iops_mode(struct cfq_data *cfqd)
807{
808 /*
809 * If we are not idling on queues and it is a NCQ drive, parallel
810 * execution of requests is on and measuring time is not possible
811 * in most of the cases until and unless we drive shallower queue
812 * depths and that becomes a performance bottleneck. In such cases
813 * switch to start providing fairness in terms of number of IOs.
814 */
815 if (!cfqd->cfq_slice_idle && cfqd->hw_tag)
816 return true;
817 else
818 return false;
819}
820
Vivek Goyal3bf10fe2012-10-03 16:56:56 -0400821static inline enum wl_class_t cfqq_class(struct cfq_queue *cfqq)
Corrado Zoccoloc0324a02009-10-27 19:16:03 +0100822{
823 if (cfq_class_idle(cfqq))
824 return IDLE_WORKLOAD;
825 if (cfq_class_rt(cfqq))
826 return RT_WORKLOAD;
827 return BE_WORKLOAD;
828}
829
Corrado Zoccolo718eee02009-10-26 22:45:29 +0100830
831static enum wl_type_t cfqq_type(struct cfq_queue *cfqq)
832{
833 if (!cfq_cfqq_sync(cfqq))
834 return ASYNC_WORKLOAD;
835 if (!cfq_cfqq_idle_window(cfqq))
836 return SYNC_NOIDLE_WORKLOAD;
837 return SYNC_WORKLOAD;
838}
839
Vivek Goyal3bf10fe2012-10-03 16:56:56 -0400840static inline int cfq_group_busy_queues_wl(enum wl_class_t wl_class,
Vivek Goyal58ff82f2009-12-03 12:59:44 -0500841 struct cfq_data *cfqd,
842 struct cfq_group *cfqg)
Corrado Zoccoloc0324a02009-10-27 19:16:03 +0100843{
Vivek Goyal3bf10fe2012-10-03 16:56:56 -0400844 if (wl_class == IDLE_WORKLOAD)
Vivek Goyalcdb16e82009-12-03 12:59:38 -0500845 return cfqg->service_tree_idle.count;
846
Vivek Goyal34b98d02012-10-03 16:56:58 -0400847 return cfqg->service_trees[wl_class][ASYNC_WORKLOAD].count +
848 cfqg->service_trees[wl_class][SYNC_NOIDLE_WORKLOAD].count +
849 cfqg->service_trees[wl_class][SYNC_WORKLOAD].count;
Corrado Zoccoloc0324a02009-10-27 19:16:03 +0100850}
851
Vivek Goyalf26bd1f2009-12-03 12:59:54 -0500852static inline int cfqg_busy_async_queues(struct cfq_data *cfqd,
853 struct cfq_group *cfqg)
854{
Vivek Goyal34b98d02012-10-03 16:56:58 -0400855 return cfqg->service_trees[RT_WORKLOAD][ASYNC_WORKLOAD].count +
856 cfqg->service_trees[BE_WORKLOAD][ASYNC_WORKLOAD].count;
Vivek Goyalf26bd1f2009-12-03 12:59:54 -0500857}
858
Jens Axboe165125e2007-07-24 09:28:11 +0200859static void cfq_dispatch_insert(struct request_queue *, struct request *);
Tejun Heo4f85cb92012-03-05 13:15:28 -0800860static struct cfq_queue *cfq_get_queue(struct cfq_data *cfqd, bool is_sync,
Tejun Heoabede6d2012-03-19 15:10:57 -0700861 struct cfq_io_cq *cic, struct bio *bio,
Tejun Heo4f85cb92012-03-05 13:15:28 -0800862 gfp_t gfp_mask);
Vasily Tarasov91fac312007-04-25 12:29:51 +0200863
Tejun Heoc5869802011-12-14 00:33:41 +0100864static inline struct cfq_io_cq *icq_to_cic(struct io_cq *icq)
865{
866 /* cic->icq is the first member, %NULL will convert to %NULL */
867 return container_of(icq, struct cfq_io_cq, icq);
868}
869
Tejun Heo47fdd4c2011-12-14 00:33:42 +0100870static inline struct cfq_io_cq *cfq_cic_lookup(struct cfq_data *cfqd,
871 struct io_context *ioc)
872{
873 if (ioc)
874 return icq_to_cic(ioc_lookup_icq(ioc, cfqd->queue));
875 return NULL;
876}
877
Tejun Heoc5869802011-12-14 00:33:41 +0100878static inline struct cfq_queue *cic_to_cfqq(struct cfq_io_cq *cic, bool is_sync)
Vasily Tarasov91fac312007-04-25 12:29:51 +0200879{
Jens Axboea6151c32009-10-07 20:02:57 +0200880 return cic->cfqq[is_sync];
Vasily Tarasov91fac312007-04-25 12:29:51 +0200881}
882
Tejun Heoc5869802011-12-14 00:33:41 +0100883static inline void cic_set_cfqq(struct cfq_io_cq *cic, struct cfq_queue *cfqq,
884 bool is_sync)
Vasily Tarasov91fac312007-04-25 12:29:51 +0200885{
Jens Axboea6151c32009-10-07 20:02:57 +0200886 cic->cfqq[is_sync] = cfqq;
Vasily Tarasov91fac312007-04-25 12:29:51 +0200887}
888
Tejun Heoc5869802011-12-14 00:33:41 +0100889static inline struct cfq_data *cic_to_cfqd(struct cfq_io_cq *cic)
Konstantin Khlebnikovbca4b912010-05-20 23:21:34 +0400890{
Tejun Heoc5869802011-12-14 00:33:41 +0100891 return cic->icq.q->elevator->elevator_data;
Konstantin Khlebnikovbca4b912010-05-20 23:21:34 +0400892}
893
Vasily Tarasov91fac312007-04-25 12:29:51 +0200894/*
895 * We regard a request as SYNC, if it's either a read or has the SYNC bit
896 * set (in which case it could also be direct WRITE).
897 */
Jens Axboea6151c32009-10-07 20:02:57 +0200898static inline bool cfq_bio_sync(struct bio *bio)
Vasily Tarasov91fac312007-04-25 12:29:51 +0200899{
Christoph Hellwig7b6d91d2010-08-07 18:20:39 +0200900 return bio_data_dir(bio) == READ || (bio->bi_rw & REQ_SYNC);
Vasily Tarasov91fac312007-04-25 12:29:51 +0200901}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903/*
Andrew Morton99f95e52005-06-27 20:14:05 -0700904 * scheduler run of queue, if there are requests pending and no one in the
905 * driver that will restart queueing
906 */
Jens Axboe23e018a2009-10-05 08:52:35 +0200907static inline void cfq_schedule_dispatch(struct cfq_data *cfqd)
Andrew Morton99f95e52005-06-27 20:14:05 -0700908{
Jens Axboe7b679132008-05-30 12:23:07 +0200909 if (cfqd->busy_queues) {
910 cfq_log(cfqd, "schedule dispatch");
Jens Axboe59c3d452014-04-08 09:15:35 -0600911 kblockd_schedule_work(&cfqd->unplug_work);
Jens Axboe7b679132008-05-30 12:23:07 +0200912 }
Andrew Morton99f95e52005-06-27 20:14:05 -0700913}
914
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915/*
Jens Axboe44f7c162007-01-19 11:51:58 +1100916 * Scale schedule slice based on io priority. Use the sync time slice only
917 * if a queue is marked sync and has sync io queued. A sync queue with async
918 * io only, should not get full sync slice length.
919 */
Jens Axboea6151c32009-10-07 20:02:57 +0200920static inline int cfq_prio_slice(struct cfq_data *cfqd, bool sync,
Jens Axboed9e76202007-04-20 14:27:50 +0200921 unsigned short prio)
922{
923 const int base_slice = cfqd->cfq_slice[sync];
924
925 WARN_ON(prio >= IOPRIO_BE_NR);
926
927 return base_slice + (base_slice/CFQ_SLICE_SCALE * (4 - prio));
928}
929
Jens Axboe44f7c162007-01-19 11:51:58 +1100930static inline int
931cfq_prio_to_slice(struct cfq_data *cfqd, struct cfq_queue *cfqq)
932{
Jens Axboed9e76202007-04-20 14:27:50 +0200933 return cfq_prio_slice(cfqd, cfq_cfqq_sync(cfqq), cfqq->ioprio);
Jens Axboe44f7c162007-01-19 11:51:58 +1100934}
935
Tejun Heo1d3650f2013-01-09 08:05:11 -0800936/**
937 * cfqg_scale_charge - scale disk time charge according to cfqg weight
938 * @charge: disk time being charged
939 * @vfraction: vfraction of the cfqg, fixed point w/ CFQ_SERVICE_SHIFT
940 *
941 * Scale @charge according to @vfraction, which is in range (0, 1]. The
942 * scaling is inversely proportional.
943 *
944 * scaled = charge / vfraction
945 *
946 * The result is also in fixed point w/ CFQ_SERVICE_SHIFT.
947 */
948static inline u64 cfqg_scale_charge(unsigned long charge,
949 unsigned int vfraction)
Vivek Goyal25bc6b02009-12-03 12:59:43 -0500950{
Tejun Heo1d3650f2013-01-09 08:05:11 -0800951 u64 c = charge << CFQ_SERVICE_SHIFT; /* make it fixed point */
Vivek Goyal25bc6b02009-12-03 12:59:43 -0500952
Tejun Heo1d3650f2013-01-09 08:05:11 -0800953 /* charge / vfraction */
954 c <<= CFQ_SERVICE_SHIFT;
955 do_div(c, vfraction);
956 return c;
Vivek Goyal25bc6b02009-12-03 12:59:43 -0500957}
958
959static inline u64 max_vdisktime(u64 min_vdisktime, u64 vdisktime)
960{
961 s64 delta = (s64)(vdisktime - min_vdisktime);
962 if (delta > 0)
963 min_vdisktime = vdisktime;
964
965 return min_vdisktime;
966}
967
968static inline u64 min_vdisktime(u64 min_vdisktime, u64 vdisktime)
969{
970 s64 delta = (s64)(vdisktime - min_vdisktime);
971 if (delta < 0)
972 min_vdisktime = vdisktime;
973
974 return min_vdisktime;
975}
976
977static void update_min_vdisktime(struct cfq_rb_root *st)
978{
Vivek Goyal25bc6b02009-12-03 12:59:43 -0500979 struct cfq_group *cfqg;
980
Vivek Goyal25bc6b02009-12-03 12:59:43 -0500981 if (st->left) {
982 cfqg = rb_entry_cfqg(st->left);
Gui Jianfenga6032712011-03-07 09:28:09 +0100983 st->min_vdisktime = max_vdisktime(st->min_vdisktime,
984 cfqg->vdisktime);
Vivek Goyal25bc6b02009-12-03 12:59:43 -0500985 }
Vivek Goyal25bc6b02009-12-03 12:59:43 -0500986}
987
Corrado Zoccolo5db5d642009-10-26 22:44:04 +0100988/*
989 * get averaged number of queues of RT/BE priority.
990 * average is updated, with a formula that gives more weight to higher numbers,
991 * to quickly follows sudden increases and decrease slowly
992 */
993
Vivek Goyal58ff82f2009-12-03 12:59:44 -0500994static inline unsigned cfq_group_get_avg_queues(struct cfq_data *cfqd,
995 struct cfq_group *cfqg, bool rt)
Jens Axboe5869619c2009-10-28 09:27:07 +0100996{
Corrado Zoccolo5db5d642009-10-26 22:44:04 +0100997 unsigned min_q, max_q;
998 unsigned mult = cfq_hist_divisor - 1;
999 unsigned round = cfq_hist_divisor / 2;
Vivek Goyal58ff82f2009-12-03 12:59:44 -05001000 unsigned busy = cfq_group_busy_queues_wl(rt, cfqd, cfqg);
Corrado Zoccolo5db5d642009-10-26 22:44:04 +01001001
Vivek Goyal58ff82f2009-12-03 12:59:44 -05001002 min_q = min(cfqg->busy_queues_avg[rt], busy);
1003 max_q = max(cfqg->busy_queues_avg[rt], busy);
1004 cfqg->busy_queues_avg[rt] = (mult * max_q + min_q + round) /
Corrado Zoccolo5db5d642009-10-26 22:44:04 +01001005 cfq_hist_divisor;
Vivek Goyal58ff82f2009-12-03 12:59:44 -05001006 return cfqg->busy_queues_avg[rt];
1007}
1008
1009static inline unsigned
1010cfq_group_slice(struct cfq_data *cfqd, struct cfq_group *cfqg)
1011{
Tejun Heo41cad6a2013-01-09 08:05:11 -08001012 return cfqd->cfq_target_latency * cfqg->vfraction >> CFQ_SERVICE_SHIFT;
Corrado Zoccolo5db5d642009-10-26 22:44:04 +01001013}
1014
Shaohua Lic553f8e2011-01-14 08:41:03 +01001015static inline unsigned
Vivek Goyalba5bd522011-01-19 08:25:02 -07001016cfq_scaled_cfqq_slice(struct cfq_data *cfqd, struct cfq_queue *cfqq)
Jens Axboe44f7c162007-01-19 11:51:58 +11001017{
Corrado Zoccolo5db5d642009-10-26 22:44:04 +01001018 unsigned slice = cfq_prio_to_slice(cfqd, cfqq);
1019 if (cfqd->cfq_latency) {
Vivek Goyal58ff82f2009-12-03 12:59:44 -05001020 /*
1021 * interested queues (we consider only the ones with the same
1022 * priority class in the cfq group)
1023 */
1024 unsigned iq = cfq_group_get_avg_queues(cfqd, cfqq->cfqg,
1025 cfq_class_rt(cfqq));
Corrado Zoccolo5db5d642009-10-26 22:44:04 +01001026 unsigned sync_slice = cfqd->cfq_slice[1];
1027 unsigned expect_latency = sync_slice * iq;
Vivek Goyal58ff82f2009-12-03 12:59:44 -05001028 unsigned group_slice = cfq_group_slice(cfqd, cfqq->cfqg);
1029
1030 if (expect_latency > group_slice) {
Corrado Zoccolo5db5d642009-10-26 22:44:04 +01001031 unsigned base_low_slice = 2 * cfqd->cfq_slice_idle;
1032 /* scale low_slice according to IO priority
1033 * and sync vs async */
1034 unsigned low_slice =
1035 min(slice, base_low_slice * slice / sync_slice);
1036 /* the adapted slice value is scaled to fit all iqs
1037 * into the target latency */
Vivek Goyal58ff82f2009-12-03 12:59:44 -05001038 slice = max(slice * group_slice / expect_latency,
Corrado Zoccolo5db5d642009-10-26 22:44:04 +01001039 low_slice);
1040 }
1041 }
Shaohua Lic553f8e2011-01-14 08:41:03 +01001042 return slice;
1043}
1044
1045static inline void
1046cfq_set_prio_slice(struct cfq_data *cfqd, struct cfq_queue *cfqq)
1047{
Vivek Goyalba5bd522011-01-19 08:25:02 -07001048 unsigned slice = cfq_scaled_cfqq_slice(cfqd, cfqq);
Shaohua Lic553f8e2011-01-14 08:41:03 +01001049
Vivek Goyaldae739e2009-12-03 12:59:45 -05001050 cfqq->slice_start = jiffies;
Corrado Zoccolo5db5d642009-10-26 22:44:04 +01001051 cfqq->slice_end = jiffies + slice;
Vivek Goyalf75edf22009-12-03 12:59:53 -05001052 cfqq->allocated_slice = slice;
Jens Axboe7b679132008-05-30 12:23:07 +02001053 cfq_log_cfqq(cfqd, cfqq, "set_slice=%lu", cfqq->slice_end - jiffies);
Jens Axboe44f7c162007-01-19 11:51:58 +11001054}
1055
1056/*
1057 * We need to wrap this check in cfq_cfqq_slice_new(), since ->slice_end
1058 * isn't valid until the first request from the dispatch is activated
1059 * and the slice time set.
1060 */
Jens Axboea6151c32009-10-07 20:02:57 +02001061static inline bool cfq_slice_used(struct cfq_queue *cfqq)
Jens Axboe44f7c162007-01-19 11:51:58 +11001062{
1063 if (cfq_cfqq_slice_new(cfqq))
Shaohua Lic1e44752010-11-08 15:01:02 +01001064 return false;
Jens Axboe44f7c162007-01-19 11:51:58 +11001065 if (time_before(jiffies, cfqq->slice_end))
Shaohua Lic1e44752010-11-08 15:01:02 +01001066 return false;
Jens Axboe44f7c162007-01-19 11:51:58 +11001067
Shaohua Lic1e44752010-11-08 15:01:02 +01001068 return true;
Jens Axboe44f7c162007-01-19 11:51:58 +11001069}
1070
1071/*
Jens Axboe5e705372006-07-13 12:39:25 +02001072 * Lifted from AS - choose which of rq1 and rq2 that is best served now.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 * We choose the request that is closest to the head right now. Distance
Andreas Mohre8a99052006-03-28 08:59:49 +02001074 * behind the head is penalized and only allowed to a certain extent.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 */
Jens Axboe5e705372006-07-13 12:39:25 +02001076static struct request *
Corrado Zoccolocf7c25c2009-11-08 17:16:46 +01001077cfq_choose_req(struct cfq_data *cfqd, struct request *rq1, struct request *rq2, sector_t last)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078{
Corrado Zoccolocf7c25c2009-11-08 17:16:46 +01001079 sector_t s1, s2, d1 = 0, d2 = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 unsigned long back_max;
Andreas Mohre8a99052006-03-28 08:59:49 +02001081#define CFQ_RQ1_WRAP 0x01 /* request 1 wraps */
1082#define CFQ_RQ2_WRAP 0x02 /* request 2 wraps */
1083 unsigned wrap = 0; /* bit mask: requests behind the disk head? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084
Jens Axboe5e705372006-07-13 12:39:25 +02001085 if (rq1 == NULL || rq1 == rq2)
1086 return rq2;
1087 if (rq2 == NULL)
1088 return rq1;
Jens Axboe9c2c38a2005-08-24 14:57:54 +02001089
Namhyung Kim229836b2011-05-24 10:23:21 +02001090 if (rq_is_sync(rq1) != rq_is_sync(rq2))
1091 return rq_is_sync(rq1) ? rq1 : rq2;
1092
Christoph Hellwig65299a32011-08-23 14:50:29 +02001093 if ((rq1->cmd_flags ^ rq2->cmd_flags) & REQ_PRIO)
1094 return rq1->cmd_flags & REQ_PRIO ? rq1 : rq2;
Jens Axboeb53d1ed2011-08-19 08:34:48 +02001095
Tejun Heo83096eb2009-05-07 22:24:39 +09001096 s1 = blk_rq_pos(rq1);
1097 s2 = blk_rq_pos(rq2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 /*
1100 * by definition, 1KiB is 2 sectors
1101 */
1102 back_max = cfqd->cfq_back_max * 2;
1103
1104 /*
1105 * Strict one way elevator _except_ in the case where we allow
1106 * short backward seeks which are biased as twice the cost of a
1107 * similar forward seek.
1108 */
1109 if (s1 >= last)
1110 d1 = s1 - last;
1111 else if (s1 + back_max >= last)
1112 d1 = (last - s1) * cfqd->cfq_back_penalty;
1113 else
Andreas Mohre8a99052006-03-28 08:59:49 +02001114 wrap |= CFQ_RQ1_WRAP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115
1116 if (s2 >= last)
1117 d2 = s2 - last;
1118 else if (s2 + back_max >= last)
1119 d2 = (last - s2) * cfqd->cfq_back_penalty;
1120 else
Andreas Mohre8a99052006-03-28 08:59:49 +02001121 wrap |= CFQ_RQ2_WRAP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122
1123 /* Found required data */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124
Andreas Mohre8a99052006-03-28 08:59:49 +02001125 /*
1126 * By doing switch() on the bit mask "wrap" we avoid having to
1127 * check two variables for all permutations: --> faster!
1128 */
1129 switch (wrap) {
Jens Axboe5e705372006-07-13 12:39:25 +02001130 case 0: /* common case for CFQ: rq1 and rq2 not wrapped */
Andreas Mohre8a99052006-03-28 08:59:49 +02001131 if (d1 < d2)
Jens Axboe5e705372006-07-13 12:39:25 +02001132 return rq1;
Andreas Mohre8a99052006-03-28 08:59:49 +02001133 else if (d2 < d1)
Jens Axboe5e705372006-07-13 12:39:25 +02001134 return rq2;
Andreas Mohre8a99052006-03-28 08:59:49 +02001135 else {
1136 if (s1 >= s2)
Jens Axboe5e705372006-07-13 12:39:25 +02001137 return rq1;
Andreas Mohre8a99052006-03-28 08:59:49 +02001138 else
Jens Axboe5e705372006-07-13 12:39:25 +02001139 return rq2;
Andreas Mohre8a99052006-03-28 08:59:49 +02001140 }
1141
1142 case CFQ_RQ2_WRAP:
Jens Axboe5e705372006-07-13 12:39:25 +02001143 return rq1;
Andreas Mohre8a99052006-03-28 08:59:49 +02001144 case CFQ_RQ1_WRAP:
Jens Axboe5e705372006-07-13 12:39:25 +02001145 return rq2;
1146 case (CFQ_RQ1_WRAP|CFQ_RQ2_WRAP): /* both rqs wrapped */
Andreas Mohre8a99052006-03-28 08:59:49 +02001147 default:
1148 /*
1149 * Since both rqs are wrapped,
1150 * start with the one that's further behind head
1151 * (--> only *one* back seek required),
1152 * since back seek takes more time than forward.
1153 */
1154 if (s1 <= s2)
Jens Axboe5e705372006-07-13 12:39:25 +02001155 return rq1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 else
Jens Axboe5e705372006-07-13 12:39:25 +02001157 return rq2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 }
1159}
1160
Jens Axboe498d3aa22007-04-26 12:54:48 +02001161/*
1162 * The below is leftmost cache rbtree addon
1163 */
Jens Axboe08717142008-01-28 11:38:15 +01001164static struct cfq_queue *cfq_rb_first(struct cfq_rb_root *root)
Jens Axboecc09e292007-04-26 12:53:50 +02001165{
Vivek Goyal615f0252009-12-03 12:59:39 -05001166 /* Service tree is empty */
1167 if (!root->count)
1168 return NULL;
1169
Jens Axboecc09e292007-04-26 12:53:50 +02001170 if (!root->left)
1171 root->left = rb_first(&root->rb);
1172
Jens Axboe08717142008-01-28 11:38:15 +01001173 if (root->left)
1174 return rb_entry(root->left, struct cfq_queue, rb_node);
1175
1176 return NULL;
Jens Axboecc09e292007-04-26 12:53:50 +02001177}
1178
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -05001179static struct cfq_group *cfq_rb_first_group(struct cfq_rb_root *root)
1180{
1181 if (!root->left)
1182 root->left = rb_first(&root->rb);
1183
1184 if (root->left)
1185 return rb_entry_cfqg(root->left);
1186
1187 return NULL;
1188}
1189
Jens Axboea36e71f2009-04-15 12:15:11 +02001190static void rb_erase_init(struct rb_node *n, struct rb_root *root)
1191{
1192 rb_erase(n, root);
1193 RB_CLEAR_NODE(n);
1194}
1195
Jens Axboecc09e292007-04-26 12:53:50 +02001196static void cfq_rb_erase(struct rb_node *n, struct cfq_rb_root *root)
1197{
1198 if (root->left == n)
1199 root->left = NULL;
Jens Axboea36e71f2009-04-15 12:15:11 +02001200 rb_erase_init(n, &root->rb);
Corrado Zoccoloaa6f6a32009-10-26 22:44:33 +01001201 --root->count;
Jens Axboecc09e292007-04-26 12:53:50 +02001202}
1203
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204/*
1205 * would be nice to take fifo expire time into account as well
1206 */
Jens Axboe5e705372006-07-13 12:39:25 +02001207static struct request *
1208cfq_find_next_rq(struct cfq_data *cfqd, struct cfq_queue *cfqq,
1209 struct request *last)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210{
Jens Axboe21183b02006-07-13 12:33:14 +02001211 struct rb_node *rbnext = rb_next(&last->rb_node);
1212 struct rb_node *rbprev = rb_prev(&last->rb_node);
Jens Axboe5e705372006-07-13 12:39:25 +02001213 struct request *next = NULL, *prev = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214
Jens Axboe21183b02006-07-13 12:33:14 +02001215 BUG_ON(RB_EMPTY_NODE(&last->rb_node));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216
1217 if (rbprev)
Jens Axboe5e705372006-07-13 12:39:25 +02001218 prev = rb_entry_rq(rbprev);
Jens Axboe21183b02006-07-13 12:33:14 +02001219
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220 if (rbnext)
Jens Axboe5e705372006-07-13 12:39:25 +02001221 next = rb_entry_rq(rbnext);
Jens Axboe21183b02006-07-13 12:33:14 +02001222 else {
1223 rbnext = rb_first(&cfqq->sort_list);
1224 if (rbnext && rbnext != &last->rb_node)
Jens Axboe5e705372006-07-13 12:39:25 +02001225 next = rb_entry_rq(rbnext);
Jens Axboe21183b02006-07-13 12:33:14 +02001226 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227
Corrado Zoccolocf7c25c2009-11-08 17:16:46 +01001228 return cfq_choose_req(cfqd, next, prev, blk_rq_pos(last));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229}
1230
Jens Axboed9e76202007-04-20 14:27:50 +02001231static unsigned long cfq_slice_offset(struct cfq_data *cfqd,
1232 struct cfq_queue *cfqq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233{
Jens Axboed9e76202007-04-20 14:27:50 +02001234 /*
1235 * just an approximation, should be ok.
1236 */
Vivek Goyalcdb16e82009-12-03 12:59:38 -05001237 return (cfqq->cfqg->nr_cfqq - 1) * (cfq_prio_slice(cfqd, 1, 0) -
Jens Axboe464191c2009-11-30 09:38:13 +01001238 cfq_prio_slice(cfqd, cfq_cfqq_sync(cfqq), cfqq->ioprio));
Jens Axboed9e76202007-04-20 14:27:50 +02001239}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -05001241static inline s64
1242cfqg_key(struct cfq_rb_root *st, struct cfq_group *cfqg)
1243{
1244 return cfqg->vdisktime - st->min_vdisktime;
1245}
1246
1247static void
1248__cfq_group_service_tree_add(struct cfq_rb_root *st, struct cfq_group *cfqg)
1249{
1250 struct rb_node **node = &st->rb.rb_node;
1251 struct rb_node *parent = NULL;
1252 struct cfq_group *__cfqg;
1253 s64 key = cfqg_key(st, cfqg);
1254 int left = 1;
1255
1256 while (*node != NULL) {
1257 parent = *node;
1258 __cfqg = rb_entry_cfqg(parent);
1259
1260 if (key < cfqg_key(st, __cfqg))
1261 node = &parent->rb_left;
1262 else {
1263 node = &parent->rb_right;
1264 left = 0;
1265 }
1266 }
1267
1268 if (left)
1269 st->left = &cfqg->rb_node;
1270
1271 rb_link_node(&cfqg->rb_node, parent, node);
1272 rb_insert_color(&cfqg->rb_node, &st->rb);
1273}
1274
1275static void
Justin TerAvest8184f932011-03-17 16:12:36 +01001276cfq_update_group_weight(struct cfq_group *cfqg)
1277{
1278 BUG_ON(!RB_EMPTY_NODE(&cfqg->rb_node));
Tejun Heoe71357e2013-01-09 08:05:10 -08001279
Tejun Heo3381cb82012-04-01 14:38:44 -07001280 if (cfqg->new_weight) {
Justin TerAvest8184f932011-03-17 16:12:36 +01001281 cfqg->weight = cfqg->new_weight;
Tejun Heo3381cb82012-04-01 14:38:44 -07001282 cfqg->new_weight = 0;
Justin TerAvest8184f932011-03-17 16:12:36 +01001283 }
Tejun Heoe71357e2013-01-09 08:05:10 -08001284
1285 if (cfqg->new_leaf_weight) {
1286 cfqg->leaf_weight = cfqg->new_leaf_weight;
1287 cfqg->new_leaf_weight = 0;
1288 }
Justin TerAvest8184f932011-03-17 16:12:36 +01001289}
1290
1291static void
1292cfq_group_service_tree_add(struct cfq_rb_root *st, struct cfq_group *cfqg)
1293{
Tejun Heo1d3650f2013-01-09 08:05:11 -08001294 unsigned int vfr = 1 << CFQ_SERVICE_SHIFT; /* start with 1 */
Tejun Heo7918ffb2013-01-09 08:05:11 -08001295 struct cfq_group *pos = cfqg;
Tejun Heo1d3650f2013-01-09 08:05:11 -08001296 struct cfq_group *parent;
Tejun Heo7918ffb2013-01-09 08:05:11 -08001297 bool propagate;
1298
1299 /* add to the service tree */
Justin TerAvest8184f932011-03-17 16:12:36 +01001300 BUG_ON(!RB_EMPTY_NODE(&cfqg->rb_node));
1301
1302 cfq_update_group_weight(cfqg);
1303 __cfq_group_service_tree_add(st, cfqg);
Tejun Heo7918ffb2013-01-09 08:05:11 -08001304
1305 /*
Tejun Heo1d3650f2013-01-09 08:05:11 -08001306 * Activate @cfqg and calculate the portion of vfraction @cfqg is
1307 * entitled to. vfraction is calculated by walking the tree
1308 * towards the root calculating the fraction it has at each level.
1309 * The compounded ratio is how much vfraction @cfqg owns.
1310 *
1311 * Start with the proportion tasks in this cfqg has against active
1312 * children cfqgs - its leaf_weight against children_weight.
Tejun Heo7918ffb2013-01-09 08:05:11 -08001313 */
1314 propagate = !pos->nr_active++;
1315 pos->children_weight += pos->leaf_weight;
Tejun Heo1d3650f2013-01-09 08:05:11 -08001316 vfr = vfr * pos->leaf_weight / pos->children_weight;
Tejun Heo7918ffb2013-01-09 08:05:11 -08001317
Tejun Heo1d3650f2013-01-09 08:05:11 -08001318 /*
1319 * Compound ->weight walking up the tree. Both activation and
1320 * vfraction calculation are done in the same loop. Propagation
1321 * stops once an already activated node is met. vfraction
1322 * calculation should always continue to the root.
1323 */
Tejun Heod02f7aa2013-01-09 08:05:11 -08001324 while ((parent = cfqg_parent(pos))) {
Tejun Heo1d3650f2013-01-09 08:05:11 -08001325 if (propagate) {
1326 propagate = !parent->nr_active++;
1327 parent->children_weight += pos->weight;
1328 }
1329 vfr = vfr * pos->weight / parent->children_weight;
Tejun Heo7918ffb2013-01-09 08:05:11 -08001330 pos = parent;
1331 }
Tejun Heo1d3650f2013-01-09 08:05:11 -08001332
1333 cfqg->vfraction = max_t(unsigned, vfr, 1);
Justin TerAvest8184f932011-03-17 16:12:36 +01001334}
1335
1336static void
1337cfq_group_notify_queue_add(struct cfq_data *cfqd, struct cfq_group *cfqg)
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -05001338{
1339 struct cfq_rb_root *st = &cfqd->grp_service_tree;
1340 struct cfq_group *__cfqg;
1341 struct rb_node *n;
1342
1343 cfqg->nr_cfqq++;
Gui Jianfeng760701b2010-11-30 20:52:47 +01001344 if (!RB_EMPTY_NODE(&cfqg->rb_node))
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -05001345 return;
1346
1347 /*
1348 * Currently put the group at the end. Later implement something
1349 * so that groups get lesser vtime based on their weights, so that
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001350 * if group does not loose all if it was not continuously backlogged.
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -05001351 */
1352 n = rb_last(&st->rb);
1353 if (n) {
1354 __cfqg = rb_entry_cfqg(n);
1355 cfqg->vdisktime = __cfqg->vdisktime + CFQ_IDLE_DELAY;
1356 } else
1357 cfqg->vdisktime = st->min_vdisktime;
Justin TerAvest8184f932011-03-17 16:12:36 +01001358 cfq_group_service_tree_add(st, cfqg);
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -05001359}
1360
1361static void
Justin TerAvest8184f932011-03-17 16:12:36 +01001362cfq_group_service_tree_del(struct cfq_rb_root *st, struct cfq_group *cfqg)
1363{
Tejun Heo7918ffb2013-01-09 08:05:11 -08001364 struct cfq_group *pos = cfqg;
1365 bool propagate;
1366
1367 /*
1368 * Undo activation from cfq_group_service_tree_add(). Deactivate
1369 * @cfqg and propagate deactivation upwards.
1370 */
1371 propagate = !--pos->nr_active;
1372 pos->children_weight -= pos->leaf_weight;
1373
1374 while (propagate) {
Tejun Heod02f7aa2013-01-09 08:05:11 -08001375 struct cfq_group *parent = cfqg_parent(pos);
Tejun Heo7918ffb2013-01-09 08:05:11 -08001376
1377 /* @pos has 0 nr_active at this point */
1378 WARN_ON_ONCE(pos->children_weight);
Tejun Heo1d3650f2013-01-09 08:05:11 -08001379 pos->vfraction = 0;
Tejun Heo7918ffb2013-01-09 08:05:11 -08001380
1381 if (!parent)
1382 break;
1383
1384 propagate = !--parent->nr_active;
1385 parent->children_weight -= pos->weight;
1386 pos = parent;
1387 }
1388
1389 /* remove from the service tree */
Justin TerAvest8184f932011-03-17 16:12:36 +01001390 if (!RB_EMPTY_NODE(&cfqg->rb_node))
1391 cfq_rb_erase(&cfqg->rb_node, st);
1392}
1393
1394static void
1395cfq_group_notify_queue_del(struct cfq_data *cfqd, struct cfq_group *cfqg)
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -05001396{
1397 struct cfq_rb_root *st = &cfqd->grp_service_tree;
1398
1399 BUG_ON(cfqg->nr_cfqq < 1);
1400 cfqg->nr_cfqq--;
Vivek Goyal25bc6b02009-12-03 12:59:43 -05001401
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -05001402 /* If there are other cfq queues under this group, don't delete it */
1403 if (cfqg->nr_cfqq)
1404 return;
1405
Vivek Goyal2868ef72009-12-03 12:59:48 -05001406 cfq_log_cfqg(cfqd, cfqg, "del_from_rr group");
Justin TerAvest8184f932011-03-17 16:12:36 +01001407 cfq_group_service_tree_del(st, cfqg);
Vivek Goyal4d2ceea2012-10-03 16:56:57 -04001408 cfqg->saved_wl_slice = 0;
Tejun Heo155fead2012-04-01 14:38:44 -07001409 cfqg_stats_update_dequeue(cfqg);
Vivek Goyaldae739e2009-12-03 12:59:45 -05001410}
1411
Justin TerAvest167400d2011-03-12 16:54:00 +01001412static inline unsigned int cfq_cfqq_slice_usage(struct cfq_queue *cfqq,
1413 unsigned int *unaccounted_time)
Vivek Goyaldae739e2009-12-03 12:59:45 -05001414{
Vivek Goyalf75edf22009-12-03 12:59:53 -05001415 unsigned int slice_used;
Vivek Goyaldae739e2009-12-03 12:59:45 -05001416
1417 /*
1418 * Queue got expired before even a single request completed or
1419 * got expired immediately after first request completion.
1420 */
1421 if (!cfqq->slice_start || cfqq->slice_start == jiffies) {
1422 /*
1423 * Also charge the seek time incurred to the group, otherwise
1424 * if there are mutiple queues in the group, each can dispatch
1425 * a single request on seeky media and cause lots of seek time
1426 * and group will never know it.
1427 */
1428 slice_used = max_t(unsigned, (jiffies - cfqq->dispatch_start),
1429 1);
1430 } else {
1431 slice_used = jiffies - cfqq->slice_start;
Justin TerAvest167400d2011-03-12 16:54:00 +01001432 if (slice_used > cfqq->allocated_slice) {
1433 *unaccounted_time = slice_used - cfqq->allocated_slice;
Vivek Goyalf75edf22009-12-03 12:59:53 -05001434 slice_used = cfqq->allocated_slice;
Justin TerAvest167400d2011-03-12 16:54:00 +01001435 }
1436 if (time_after(cfqq->slice_start, cfqq->dispatch_start))
1437 *unaccounted_time += cfqq->slice_start -
1438 cfqq->dispatch_start;
Vivek Goyaldae739e2009-12-03 12:59:45 -05001439 }
1440
Vivek Goyaldae739e2009-12-03 12:59:45 -05001441 return slice_used;
1442}
1443
1444static void cfq_group_served(struct cfq_data *cfqd, struct cfq_group *cfqg,
Vivek Goyale5ff0822010-04-26 19:25:11 +02001445 struct cfq_queue *cfqq)
Vivek Goyaldae739e2009-12-03 12:59:45 -05001446{
1447 struct cfq_rb_root *st = &cfqd->grp_service_tree;
Justin TerAvest167400d2011-03-12 16:54:00 +01001448 unsigned int used_sl, charge, unaccounted_sl = 0;
Vivek Goyalf26bd1f2009-12-03 12:59:54 -05001449 int nr_sync = cfqg->nr_cfqq - cfqg_busy_async_queues(cfqd, cfqg)
1450 - cfqg->service_tree_idle.count;
Tejun Heo1d3650f2013-01-09 08:05:11 -08001451 unsigned int vfr;
Vivek Goyaldae739e2009-12-03 12:59:45 -05001452
Vivek Goyalf26bd1f2009-12-03 12:59:54 -05001453 BUG_ON(nr_sync < 0);
Justin TerAvest167400d2011-03-12 16:54:00 +01001454 used_sl = charge = cfq_cfqq_slice_usage(cfqq, &unaccounted_sl);
Vivek Goyalf26bd1f2009-12-03 12:59:54 -05001455
Vivek Goyal02b35082010-08-23 12:23:53 +02001456 if (iops_mode(cfqd))
1457 charge = cfqq->slice_dispatch;
1458 else if (!cfq_cfqq_sync(cfqq) && !nr_sync)
1459 charge = cfqq->allocated_slice;
Vivek Goyaldae739e2009-12-03 12:59:45 -05001460
Tejun Heo1d3650f2013-01-09 08:05:11 -08001461 /*
1462 * Can't update vdisktime while on service tree and cfqg->vfraction
1463 * is valid only while on it. Cache vfr, leave the service tree,
1464 * update vdisktime and go back on. The re-addition to the tree
1465 * will also update the weights as necessary.
1466 */
1467 vfr = cfqg->vfraction;
Justin TerAvest8184f932011-03-17 16:12:36 +01001468 cfq_group_service_tree_del(st, cfqg);
Tejun Heo1d3650f2013-01-09 08:05:11 -08001469 cfqg->vdisktime += cfqg_scale_charge(charge, vfr);
Justin TerAvest8184f932011-03-17 16:12:36 +01001470 cfq_group_service_tree_add(st, cfqg);
Vivek Goyaldae739e2009-12-03 12:59:45 -05001471
1472 /* This group is being expired. Save the context */
1473 if (time_after(cfqd->workload_expires, jiffies)) {
Vivek Goyal4d2ceea2012-10-03 16:56:57 -04001474 cfqg->saved_wl_slice = cfqd->workload_expires
Vivek Goyaldae739e2009-12-03 12:59:45 -05001475 - jiffies;
Vivek Goyal4d2ceea2012-10-03 16:56:57 -04001476 cfqg->saved_wl_type = cfqd->serving_wl_type;
1477 cfqg->saved_wl_class = cfqd->serving_wl_class;
Vivek Goyaldae739e2009-12-03 12:59:45 -05001478 } else
Vivek Goyal4d2ceea2012-10-03 16:56:57 -04001479 cfqg->saved_wl_slice = 0;
Vivek Goyal2868ef72009-12-03 12:59:48 -05001480
1481 cfq_log_cfqg(cfqd, cfqg, "served: vt=%llu min_vt=%llu", cfqg->vdisktime,
1482 st->min_vdisktime);
Joe Perchesfd16d262011-06-13 10:42:49 +02001483 cfq_log_cfqq(cfqq->cfqd, cfqq,
1484 "sl_used=%u disp=%u charge=%u iops=%u sect=%lu",
1485 used_sl, cfqq->slice_dispatch, charge,
1486 iops_mode(cfqd), cfqq->nr_sectors);
Tejun Heo155fead2012-04-01 14:38:44 -07001487 cfqg_stats_update_timeslice_used(cfqg, used_sl, unaccounted_sl);
1488 cfqg_stats_set_start_empty_time(cfqg);
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -05001489}
1490
Tejun Heof51b8022012-03-05 13:15:05 -08001491/**
1492 * cfq_init_cfqg_base - initialize base part of a cfq_group
1493 * @cfqg: cfq_group to initialize
1494 *
1495 * Initialize the base part which is used whether %CONFIG_CFQ_GROUP_IOSCHED
1496 * is enabled or not.
1497 */
1498static void cfq_init_cfqg_base(struct cfq_group *cfqg)
1499{
1500 struct cfq_rb_root *st;
1501 int i, j;
1502
1503 for_each_cfqg_st(cfqg, i, j, st)
1504 *st = CFQ_RB_ROOT;
1505 RB_CLEAR_NODE(&cfqg->rb_node);
1506
1507 cfqg->ttime.last_end_request = jiffies;
1508}
1509
Vivek Goyal25fb5162009-12-03 12:59:46 -05001510#ifdef CONFIG_CFQ_GROUP_IOSCHED
Peter Zijlstra90d38392013-11-12 19:42:14 -08001511static void cfqg_stats_init(struct cfqg_stats *stats)
1512{
1513 blkg_rwstat_init(&stats->service_bytes);
1514 blkg_rwstat_init(&stats->serviced);
1515 blkg_rwstat_init(&stats->merged);
1516 blkg_rwstat_init(&stats->service_time);
1517 blkg_rwstat_init(&stats->wait_time);
1518 blkg_rwstat_init(&stats->queued);
1519
1520 blkg_stat_init(&stats->sectors);
1521 blkg_stat_init(&stats->time);
1522
1523#ifdef CONFIG_DEBUG_BLK_CGROUP
1524 blkg_stat_init(&stats->unaccounted_time);
1525 blkg_stat_init(&stats->avg_queue_size_sum);
1526 blkg_stat_init(&stats->avg_queue_size_samples);
1527 blkg_stat_init(&stats->dequeue);
1528 blkg_stat_init(&stats->group_wait_time);
1529 blkg_stat_init(&stats->idle_time);
1530 blkg_stat_init(&stats->empty_time);
1531#endif
1532}
1533
Tejun Heo3c798392012-04-16 13:57:25 -07001534static void cfq_pd_init(struct blkcg_gq *blkg)
Vivek Goyalf469a7b2011-05-19 15:38:23 -04001535{
Tejun Heo03814112012-03-05 13:15:14 -08001536 struct cfq_group *cfqg = blkg_to_cfqg(blkg);
Vivek Goyal25fb5162009-12-03 12:59:46 -05001537
Tejun Heof51b8022012-03-05 13:15:05 -08001538 cfq_init_cfqg_base(cfqg);
Tejun Heo3381cb82012-04-01 14:38:44 -07001539 cfqg->weight = blkg->blkcg->cfq_weight;
Tejun Heoe71357e2013-01-09 08:05:10 -08001540 cfqg->leaf_weight = blkg->blkcg->cfq_leaf_weight;
Peter Zijlstra90d38392013-11-12 19:42:14 -08001541 cfqg_stats_init(&cfqg->stats);
1542 cfqg_stats_init(&cfqg->dead_stats);
Vivek Goyal25fb5162009-12-03 12:59:46 -05001543}
1544
Tejun Heo0b399202013-01-09 08:05:13 -08001545static void cfq_pd_offline(struct blkcg_gq *blkg)
1546{
1547 /*
1548 * @blkg is going offline and will be ignored by
1549 * blkg_[rw]stat_recursive_sum(). Transfer stats to the parent so
1550 * that they don't get lost. If IOs complete after this point, the
1551 * stats for them will be lost. Oh well...
1552 */
1553 cfqg_stats_xfer_dead(blkg_to_cfqg(blkg));
1554}
1555
Tejun Heo43114012013-01-09 08:05:13 -08001556/* offset delta from cfqg->stats to cfqg->dead_stats */
1557static const int dead_stats_off_delta = offsetof(struct cfq_group, dead_stats) -
1558 offsetof(struct cfq_group, stats);
1559
1560/* to be used by recursive prfill, sums live and dead stats recursively */
1561static u64 cfqg_stat_pd_recursive_sum(struct blkg_policy_data *pd, int off)
1562{
1563 u64 sum = 0;
1564
1565 sum += blkg_stat_recursive_sum(pd, off);
1566 sum += blkg_stat_recursive_sum(pd, off + dead_stats_off_delta);
1567 return sum;
1568}
1569
1570/* to be used by recursive prfill, sums live and dead rwstats recursively */
1571static struct blkg_rwstat cfqg_rwstat_pd_recursive_sum(struct blkg_policy_data *pd,
1572 int off)
1573{
1574 struct blkg_rwstat a, b;
1575
1576 a = blkg_rwstat_recursive_sum(pd, off);
1577 b = blkg_rwstat_recursive_sum(pd, off + dead_stats_off_delta);
1578 blkg_rwstat_merge(&a, &b);
1579 return a;
1580}
1581
Tejun Heo689665a2013-01-09 08:05:13 -08001582static void cfq_pd_reset_stats(struct blkcg_gq *blkg)
1583{
1584 struct cfq_group *cfqg = blkg_to_cfqg(blkg);
1585
1586 cfqg_stats_reset(&cfqg->stats);
Tejun Heo0b399202013-01-09 08:05:13 -08001587 cfqg_stats_reset(&cfqg->dead_stats);
Vivek Goyal25fb5162009-12-03 12:59:46 -05001588}
1589
1590/*
Vivek Goyal3e59cf92011-05-19 15:38:21 -04001591 * Search for the cfq group current task belongs to. request_queue lock must
1592 * be held.
Vivek Goyal25fb5162009-12-03 12:59:46 -05001593 */
Tejun Heocd1604f2012-03-05 13:15:06 -08001594static struct cfq_group *cfq_lookup_create_cfqg(struct cfq_data *cfqd,
Tejun Heo3c798392012-04-16 13:57:25 -07001595 struct blkcg *blkcg)
Vivek Goyal25fb5162009-12-03 12:59:46 -05001596{
Vivek Goyalf469a7b2011-05-19 15:38:23 -04001597 struct request_queue *q = cfqd->queue;
Tejun Heocd1604f2012-03-05 13:15:06 -08001598 struct cfq_group *cfqg = NULL;
Vivek Goyal25fb5162009-12-03 12:59:46 -05001599
Tejun Heo3c798392012-04-16 13:57:25 -07001600 /* avoid lookup for the common case where there's no blkcg */
1601 if (blkcg == &blkcg_root) {
Tejun Heocd1604f2012-03-05 13:15:06 -08001602 cfqg = cfqd->root_group;
1603 } else {
Tejun Heo3c798392012-04-16 13:57:25 -07001604 struct blkcg_gq *blkg;
Vivek Goyalf469a7b2011-05-19 15:38:23 -04001605
Tejun Heo3c96cb32012-04-13 13:11:34 -07001606 blkg = blkg_lookup_create(blkcg, q);
Tejun Heocd1604f2012-03-05 13:15:06 -08001607 if (!IS_ERR(blkg))
Tejun Heo03814112012-03-05 13:15:14 -08001608 cfqg = blkg_to_cfqg(blkg);
Vivek Goyalf469a7b2011-05-19 15:38:23 -04001609 }
1610
Vivek Goyal25fb5162009-12-03 12:59:46 -05001611 return cfqg;
1612}
1613
1614static void cfq_link_cfqq_cfqg(struct cfq_queue *cfqq, struct cfq_group *cfqg)
1615{
1616 /* Currently, all async queues are mapped to root group */
1617 if (!cfq_cfqq_sync(cfqq))
Tejun Heof51b8022012-03-05 13:15:05 -08001618 cfqg = cfqq->cfqd->root_group;
Vivek Goyal25fb5162009-12-03 12:59:46 -05001619
1620 cfqq->cfqg = cfqg;
Vivek Goyalb1c35762009-12-03 12:59:47 -05001621 /* cfqq reference on cfqg */
Tejun Heoeb7d8c072012-03-23 14:02:53 +01001622 cfqg_get(cfqg);
Vivek Goyalb1c35762009-12-03 12:59:47 -05001623}
1624
Tejun Heof95a04a2012-04-16 13:57:26 -07001625static u64 cfqg_prfill_weight_device(struct seq_file *sf,
1626 struct blkg_policy_data *pd, int off)
Tejun Heo60c2bc22012-04-01 14:38:43 -07001627{
Tejun Heof95a04a2012-04-16 13:57:26 -07001628 struct cfq_group *cfqg = pd_to_cfqg(pd);
Tejun Heo3381cb82012-04-01 14:38:44 -07001629
1630 if (!cfqg->dev_weight)
Tejun Heo60c2bc22012-04-01 14:38:43 -07001631 return 0;
Tejun Heof95a04a2012-04-16 13:57:26 -07001632 return __blkg_prfill_u64(sf, pd, cfqg->dev_weight);
Tejun Heo60c2bc22012-04-01 14:38:43 -07001633}
1634
Tejun Heo2da8ca82013-12-05 12:28:04 -05001635static int cfqg_print_weight_device(struct seq_file *sf, void *v)
Tejun Heo60c2bc22012-04-01 14:38:43 -07001636{
Tejun Heo2da8ca82013-12-05 12:28:04 -05001637 blkcg_print_blkgs(sf, css_to_blkcg(seq_css(sf)),
1638 cfqg_prfill_weight_device, &blkcg_policy_cfq,
1639 0, false);
Tejun Heo60c2bc22012-04-01 14:38:43 -07001640 return 0;
1641}
1642
Tejun Heoe71357e2013-01-09 08:05:10 -08001643static u64 cfqg_prfill_leaf_weight_device(struct seq_file *sf,
1644 struct blkg_policy_data *pd, int off)
1645{
1646 struct cfq_group *cfqg = pd_to_cfqg(pd);
1647
1648 if (!cfqg->dev_leaf_weight)
1649 return 0;
1650 return __blkg_prfill_u64(sf, pd, cfqg->dev_leaf_weight);
1651}
1652
Tejun Heo2da8ca82013-12-05 12:28:04 -05001653static int cfqg_print_leaf_weight_device(struct seq_file *sf, void *v)
Tejun Heoe71357e2013-01-09 08:05:10 -08001654{
Tejun Heo2da8ca82013-12-05 12:28:04 -05001655 blkcg_print_blkgs(sf, css_to_blkcg(seq_css(sf)),
1656 cfqg_prfill_leaf_weight_device, &blkcg_policy_cfq,
1657 0, false);
Tejun Heoe71357e2013-01-09 08:05:10 -08001658 return 0;
1659}
1660
Tejun Heo2da8ca82013-12-05 12:28:04 -05001661static int cfq_print_weight(struct seq_file *sf, void *v)
Tejun Heo60c2bc22012-04-01 14:38:43 -07001662{
Tejun Heo2da8ca82013-12-05 12:28:04 -05001663 seq_printf(sf, "%u\n", css_to_blkcg(seq_css(sf))->cfq_weight);
Tejun Heo60c2bc22012-04-01 14:38:43 -07001664 return 0;
1665}
1666
Tejun Heo2da8ca82013-12-05 12:28:04 -05001667static int cfq_print_leaf_weight(struct seq_file *sf, void *v)
Tejun Heoe71357e2013-01-09 08:05:10 -08001668{
Tejun Heo2da8ca82013-12-05 12:28:04 -05001669 seq_printf(sf, "%u\n", css_to_blkcg(seq_css(sf))->cfq_leaf_weight);
Tejun Heoe71357e2013-01-09 08:05:10 -08001670 return 0;
1671}
1672
Tejun Heo451af502014-05-13 12:16:21 -04001673static ssize_t __cfqg_set_weight_device(struct kernfs_open_file *of,
1674 char *buf, size_t nbytes, loff_t off,
1675 bool is_leaf_weight)
Tejun Heo60c2bc22012-04-01 14:38:43 -07001676{
Tejun Heo451af502014-05-13 12:16:21 -04001677 struct blkcg *blkcg = css_to_blkcg(of_css(of));
Tejun Heo60c2bc22012-04-01 14:38:43 -07001678 struct blkg_conf_ctx ctx;
Tejun Heo3381cb82012-04-01 14:38:44 -07001679 struct cfq_group *cfqg;
Tejun Heo60c2bc22012-04-01 14:38:43 -07001680 int ret;
1681
Tejun Heo3c798392012-04-16 13:57:25 -07001682 ret = blkg_conf_prep(blkcg, &blkcg_policy_cfq, buf, &ctx);
Tejun Heo60c2bc22012-04-01 14:38:43 -07001683 if (ret)
1684 return ret;
1685
1686 ret = -EINVAL;
Tejun Heo3381cb82012-04-01 14:38:44 -07001687 cfqg = blkg_to_cfqg(ctx.blkg);
Tejun Heoa2b16932012-04-13 13:11:33 -07001688 if (!ctx.v || (ctx.v >= CFQ_WEIGHT_MIN && ctx.v <= CFQ_WEIGHT_MAX)) {
Tejun Heoe71357e2013-01-09 08:05:10 -08001689 if (!is_leaf_weight) {
1690 cfqg->dev_weight = ctx.v;
1691 cfqg->new_weight = ctx.v ?: blkcg->cfq_weight;
1692 } else {
1693 cfqg->dev_leaf_weight = ctx.v;
1694 cfqg->new_leaf_weight = ctx.v ?: blkcg->cfq_leaf_weight;
1695 }
Tejun Heo60c2bc22012-04-01 14:38:43 -07001696 ret = 0;
1697 }
1698
1699 blkg_conf_finish(&ctx);
Tejun Heo451af502014-05-13 12:16:21 -04001700 return ret ?: nbytes;
Tejun Heo60c2bc22012-04-01 14:38:43 -07001701}
1702
Tejun Heo451af502014-05-13 12:16:21 -04001703static ssize_t cfqg_set_weight_device(struct kernfs_open_file *of,
1704 char *buf, size_t nbytes, loff_t off)
Tejun Heoe71357e2013-01-09 08:05:10 -08001705{
Tejun Heo451af502014-05-13 12:16:21 -04001706 return __cfqg_set_weight_device(of, buf, nbytes, off, false);
Tejun Heoe71357e2013-01-09 08:05:10 -08001707}
1708
Tejun Heo451af502014-05-13 12:16:21 -04001709static ssize_t cfqg_set_leaf_weight_device(struct kernfs_open_file *of,
1710 char *buf, size_t nbytes, loff_t off)
Tejun Heoe71357e2013-01-09 08:05:10 -08001711{
Tejun Heo451af502014-05-13 12:16:21 -04001712 return __cfqg_set_weight_device(of, buf, nbytes, off, true);
Tejun Heoe71357e2013-01-09 08:05:10 -08001713}
1714
Tejun Heo182446d2013-08-08 20:11:24 -04001715static int __cfq_set_weight(struct cgroup_subsys_state *css, struct cftype *cft,
1716 u64 val, bool is_leaf_weight)
Tejun Heo60c2bc22012-04-01 14:38:43 -07001717{
Tejun Heo182446d2013-08-08 20:11:24 -04001718 struct blkcg *blkcg = css_to_blkcg(css);
Tejun Heo3c798392012-04-16 13:57:25 -07001719 struct blkcg_gq *blkg;
Tejun Heo60c2bc22012-04-01 14:38:43 -07001720
Tejun Heo3381cb82012-04-01 14:38:44 -07001721 if (val < CFQ_WEIGHT_MIN || val > CFQ_WEIGHT_MAX)
Tejun Heo60c2bc22012-04-01 14:38:43 -07001722 return -EINVAL;
1723
1724 spin_lock_irq(&blkcg->lock);
Tejun Heoe71357e2013-01-09 08:05:10 -08001725
1726 if (!is_leaf_weight)
1727 blkcg->cfq_weight = val;
1728 else
1729 blkcg->cfq_leaf_weight = val;
Tejun Heo60c2bc22012-04-01 14:38:43 -07001730
Sasha Levinb67bfe02013-02-27 17:06:00 -08001731 hlist_for_each_entry(blkg, &blkcg->blkg_list, blkcg_node) {
Tejun Heo3381cb82012-04-01 14:38:44 -07001732 struct cfq_group *cfqg = blkg_to_cfqg(blkg);
Tejun Heo60c2bc22012-04-01 14:38:43 -07001733
Tejun Heoe71357e2013-01-09 08:05:10 -08001734 if (!cfqg)
1735 continue;
1736
1737 if (!is_leaf_weight) {
1738 if (!cfqg->dev_weight)
1739 cfqg->new_weight = blkcg->cfq_weight;
1740 } else {
1741 if (!cfqg->dev_leaf_weight)
1742 cfqg->new_leaf_weight = blkcg->cfq_leaf_weight;
1743 }
Tejun Heo60c2bc22012-04-01 14:38:43 -07001744 }
1745
1746 spin_unlock_irq(&blkcg->lock);
1747 return 0;
1748}
1749
Tejun Heo182446d2013-08-08 20:11:24 -04001750static int cfq_set_weight(struct cgroup_subsys_state *css, struct cftype *cft,
1751 u64 val)
Tejun Heoe71357e2013-01-09 08:05:10 -08001752{
Tejun Heo182446d2013-08-08 20:11:24 -04001753 return __cfq_set_weight(css, cft, val, false);
Tejun Heoe71357e2013-01-09 08:05:10 -08001754}
1755
Tejun Heo182446d2013-08-08 20:11:24 -04001756static int cfq_set_leaf_weight(struct cgroup_subsys_state *css,
1757 struct cftype *cft, u64 val)
Tejun Heoe71357e2013-01-09 08:05:10 -08001758{
Tejun Heo182446d2013-08-08 20:11:24 -04001759 return __cfq_set_weight(css, cft, val, true);
Tejun Heoe71357e2013-01-09 08:05:10 -08001760}
1761
Tejun Heo2da8ca82013-12-05 12:28:04 -05001762static int cfqg_print_stat(struct seq_file *sf, void *v)
Tejun Heo5bc4afb12012-04-01 14:38:45 -07001763{
Tejun Heo2da8ca82013-12-05 12:28:04 -05001764 blkcg_print_blkgs(sf, css_to_blkcg(seq_css(sf)), blkg_prfill_stat,
1765 &blkcg_policy_cfq, seq_cft(sf)->private, false);
Tejun Heo5bc4afb12012-04-01 14:38:45 -07001766 return 0;
1767}
1768
Tejun Heo2da8ca82013-12-05 12:28:04 -05001769static int cfqg_print_rwstat(struct seq_file *sf, void *v)
Tejun Heo5bc4afb12012-04-01 14:38:45 -07001770{
Tejun Heo2da8ca82013-12-05 12:28:04 -05001771 blkcg_print_blkgs(sf, css_to_blkcg(seq_css(sf)), blkg_prfill_rwstat,
1772 &blkcg_policy_cfq, seq_cft(sf)->private, true);
Tejun Heo5bc4afb12012-04-01 14:38:45 -07001773 return 0;
1774}
1775
Tejun Heo43114012013-01-09 08:05:13 -08001776static u64 cfqg_prfill_stat_recursive(struct seq_file *sf,
1777 struct blkg_policy_data *pd, int off)
1778{
1779 u64 sum = cfqg_stat_pd_recursive_sum(pd, off);
1780
1781 return __blkg_prfill_u64(sf, pd, sum);
1782}
1783
1784static u64 cfqg_prfill_rwstat_recursive(struct seq_file *sf,
1785 struct blkg_policy_data *pd, int off)
1786{
1787 struct blkg_rwstat sum = cfqg_rwstat_pd_recursive_sum(pd, off);
1788
1789 return __blkg_prfill_rwstat(sf, pd, &sum);
1790}
1791
Tejun Heo2da8ca82013-12-05 12:28:04 -05001792static int cfqg_print_stat_recursive(struct seq_file *sf, void *v)
Tejun Heo43114012013-01-09 08:05:13 -08001793{
Tejun Heo2da8ca82013-12-05 12:28:04 -05001794 blkcg_print_blkgs(sf, css_to_blkcg(seq_css(sf)),
1795 cfqg_prfill_stat_recursive, &blkcg_policy_cfq,
1796 seq_cft(sf)->private, false);
Tejun Heo43114012013-01-09 08:05:13 -08001797 return 0;
1798}
1799
Tejun Heo2da8ca82013-12-05 12:28:04 -05001800static int cfqg_print_rwstat_recursive(struct seq_file *sf, void *v)
Tejun Heo43114012013-01-09 08:05:13 -08001801{
Tejun Heo2da8ca82013-12-05 12:28:04 -05001802 blkcg_print_blkgs(sf, css_to_blkcg(seq_css(sf)),
1803 cfqg_prfill_rwstat_recursive, &blkcg_policy_cfq,
1804 seq_cft(sf)->private, true);
Tejun Heo43114012013-01-09 08:05:13 -08001805 return 0;
1806}
1807
Tejun Heo60c2bc22012-04-01 14:38:43 -07001808#ifdef CONFIG_DEBUG_BLK_CGROUP
Tejun Heof95a04a2012-04-16 13:57:26 -07001809static u64 cfqg_prfill_avg_queue_size(struct seq_file *sf,
1810 struct blkg_policy_data *pd, int off)
Tejun Heo60c2bc22012-04-01 14:38:43 -07001811{
Tejun Heof95a04a2012-04-16 13:57:26 -07001812 struct cfq_group *cfqg = pd_to_cfqg(pd);
Tejun Heo155fead2012-04-01 14:38:44 -07001813 u64 samples = blkg_stat_read(&cfqg->stats.avg_queue_size_samples);
Tejun Heo60c2bc22012-04-01 14:38:43 -07001814 u64 v = 0;
1815
1816 if (samples) {
Tejun Heo155fead2012-04-01 14:38:44 -07001817 v = blkg_stat_read(&cfqg->stats.avg_queue_size_sum);
Anatol Pomozovf3cff252013-09-22 12:43:47 -06001818 v = div64_u64(v, samples);
Tejun Heo60c2bc22012-04-01 14:38:43 -07001819 }
Tejun Heof95a04a2012-04-16 13:57:26 -07001820 __blkg_prfill_u64(sf, pd, v);
Tejun Heo60c2bc22012-04-01 14:38:43 -07001821 return 0;
1822}
1823
1824/* print avg_queue_size */
Tejun Heo2da8ca82013-12-05 12:28:04 -05001825static int cfqg_print_avg_queue_size(struct seq_file *sf, void *v)
Tejun Heo60c2bc22012-04-01 14:38:43 -07001826{
Tejun Heo2da8ca82013-12-05 12:28:04 -05001827 blkcg_print_blkgs(sf, css_to_blkcg(seq_css(sf)),
1828 cfqg_prfill_avg_queue_size, &blkcg_policy_cfq,
1829 0, false);
Tejun Heo60c2bc22012-04-01 14:38:43 -07001830 return 0;
1831}
1832#endif /* CONFIG_DEBUG_BLK_CGROUP */
1833
1834static struct cftype cfq_blkcg_files[] = {
Tejun Heo1d3650f2013-01-09 08:05:11 -08001835 /* on root, weight is mapped to leaf_weight */
Tejun Heo60c2bc22012-04-01 14:38:43 -07001836 {
1837 .name = "weight_device",
Tejun Heo1d3650f2013-01-09 08:05:11 -08001838 .flags = CFTYPE_ONLY_ON_ROOT,
Tejun Heo2da8ca82013-12-05 12:28:04 -05001839 .seq_show = cfqg_print_leaf_weight_device,
Tejun Heo451af502014-05-13 12:16:21 -04001840 .write = cfqg_set_leaf_weight_device,
Tejun Heo1d3650f2013-01-09 08:05:11 -08001841 },
1842 {
1843 .name = "weight",
1844 .flags = CFTYPE_ONLY_ON_ROOT,
Tejun Heo2da8ca82013-12-05 12:28:04 -05001845 .seq_show = cfq_print_leaf_weight,
Tejun Heo1d3650f2013-01-09 08:05:11 -08001846 .write_u64 = cfq_set_leaf_weight,
1847 },
1848
1849 /* no such mapping necessary for !roots */
1850 {
1851 .name = "weight_device",
1852 .flags = CFTYPE_NOT_ON_ROOT,
Tejun Heo2da8ca82013-12-05 12:28:04 -05001853 .seq_show = cfqg_print_weight_device,
Tejun Heo451af502014-05-13 12:16:21 -04001854 .write = cfqg_set_weight_device,
Tejun Heo60c2bc22012-04-01 14:38:43 -07001855 },
1856 {
1857 .name = "weight",
Tejun Heoe71357e2013-01-09 08:05:10 -08001858 .flags = CFTYPE_NOT_ON_ROOT,
Tejun Heo2da8ca82013-12-05 12:28:04 -05001859 .seq_show = cfq_print_weight,
Tejun Heo3381cb82012-04-01 14:38:44 -07001860 .write_u64 = cfq_set_weight,
Tejun Heo60c2bc22012-04-01 14:38:43 -07001861 },
Tejun Heo1d3650f2013-01-09 08:05:11 -08001862
1863 {
1864 .name = "leaf_weight_device",
Tejun Heo2da8ca82013-12-05 12:28:04 -05001865 .seq_show = cfqg_print_leaf_weight_device,
Tejun Heo451af502014-05-13 12:16:21 -04001866 .write = cfqg_set_leaf_weight_device,
Tejun Heoe71357e2013-01-09 08:05:10 -08001867 },
1868 {
1869 .name = "leaf_weight",
Tejun Heo2da8ca82013-12-05 12:28:04 -05001870 .seq_show = cfq_print_leaf_weight,
Tejun Heoe71357e2013-01-09 08:05:10 -08001871 .write_u64 = cfq_set_leaf_weight,
1872 },
1873
Tejun Heo43114012013-01-09 08:05:13 -08001874 /* statistics, covers only the tasks in the cfqg */
Tejun Heo60c2bc22012-04-01 14:38:43 -07001875 {
1876 .name = "time",
Tejun Heo5bc4afb12012-04-01 14:38:45 -07001877 .private = offsetof(struct cfq_group, stats.time),
Tejun Heo2da8ca82013-12-05 12:28:04 -05001878 .seq_show = cfqg_print_stat,
Tejun Heo60c2bc22012-04-01 14:38:43 -07001879 },
1880 {
1881 .name = "sectors",
Tejun Heo5bc4afb12012-04-01 14:38:45 -07001882 .private = offsetof(struct cfq_group, stats.sectors),
Tejun Heo2da8ca82013-12-05 12:28:04 -05001883 .seq_show = cfqg_print_stat,
Tejun Heo60c2bc22012-04-01 14:38:43 -07001884 },
1885 {
1886 .name = "io_service_bytes",
Tejun Heo5bc4afb12012-04-01 14:38:45 -07001887 .private = offsetof(struct cfq_group, stats.service_bytes),
Tejun Heo2da8ca82013-12-05 12:28:04 -05001888 .seq_show = cfqg_print_rwstat,
Tejun Heo60c2bc22012-04-01 14:38:43 -07001889 },
1890 {
1891 .name = "io_serviced",
Tejun Heo5bc4afb12012-04-01 14:38:45 -07001892 .private = offsetof(struct cfq_group, stats.serviced),
Tejun Heo2da8ca82013-12-05 12:28:04 -05001893 .seq_show = cfqg_print_rwstat,
Tejun Heo60c2bc22012-04-01 14:38:43 -07001894 },
1895 {
1896 .name = "io_service_time",
Tejun Heo5bc4afb12012-04-01 14:38:45 -07001897 .private = offsetof(struct cfq_group, stats.service_time),
Tejun Heo2da8ca82013-12-05 12:28:04 -05001898 .seq_show = cfqg_print_rwstat,
Tejun Heo60c2bc22012-04-01 14:38:43 -07001899 },
1900 {
1901 .name = "io_wait_time",
Tejun Heo5bc4afb12012-04-01 14:38:45 -07001902 .private = offsetof(struct cfq_group, stats.wait_time),
Tejun Heo2da8ca82013-12-05 12:28:04 -05001903 .seq_show = cfqg_print_rwstat,
Tejun Heo60c2bc22012-04-01 14:38:43 -07001904 },
1905 {
1906 .name = "io_merged",
Tejun Heo5bc4afb12012-04-01 14:38:45 -07001907 .private = offsetof(struct cfq_group, stats.merged),
Tejun Heo2da8ca82013-12-05 12:28:04 -05001908 .seq_show = cfqg_print_rwstat,
Tejun Heo60c2bc22012-04-01 14:38:43 -07001909 },
1910 {
1911 .name = "io_queued",
Tejun Heo5bc4afb12012-04-01 14:38:45 -07001912 .private = offsetof(struct cfq_group, stats.queued),
Tejun Heo2da8ca82013-12-05 12:28:04 -05001913 .seq_show = cfqg_print_rwstat,
Tejun Heo60c2bc22012-04-01 14:38:43 -07001914 },
Tejun Heo43114012013-01-09 08:05:13 -08001915
1916 /* the same statictics which cover the cfqg and its descendants */
1917 {
1918 .name = "time_recursive",
1919 .private = offsetof(struct cfq_group, stats.time),
Tejun Heo2da8ca82013-12-05 12:28:04 -05001920 .seq_show = cfqg_print_stat_recursive,
Tejun Heo43114012013-01-09 08:05:13 -08001921 },
1922 {
1923 .name = "sectors_recursive",
1924 .private = offsetof(struct cfq_group, stats.sectors),
Tejun Heo2da8ca82013-12-05 12:28:04 -05001925 .seq_show = cfqg_print_stat_recursive,
Tejun Heo43114012013-01-09 08:05:13 -08001926 },
1927 {
1928 .name = "io_service_bytes_recursive",
1929 .private = offsetof(struct cfq_group, stats.service_bytes),
Tejun Heo2da8ca82013-12-05 12:28:04 -05001930 .seq_show = cfqg_print_rwstat_recursive,
Tejun Heo43114012013-01-09 08:05:13 -08001931 },
1932 {
1933 .name = "io_serviced_recursive",
1934 .private = offsetof(struct cfq_group, stats.serviced),
Tejun Heo2da8ca82013-12-05 12:28:04 -05001935 .seq_show = cfqg_print_rwstat_recursive,
Tejun Heo43114012013-01-09 08:05:13 -08001936 },
1937 {
1938 .name = "io_service_time_recursive",
1939 .private = offsetof(struct cfq_group, stats.service_time),
Tejun Heo2da8ca82013-12-05 12:28:04 -05001940 .seq_show = cfqg_print_rwstat_recursive,
Tejun Heo43114012013-01-09 08:05:13 -08001941 },
1942 {
1943 .name = "io_wait_time_recursive",
1944 .private = offsetof(struct cfq_group, stats.wait_time),
Tejun Heo2da8ca82013-12-05 12:28:04 -05001945 .seq_show = cfqg_print_rwstat_recursive,
Tejun Heo43114012013-01-09 08:05:13 -08001946 },
1947 {
1948 .name = "io_merged_recursive",
1949 .private = offsetof(struct cfq_group, stats.merged),
Tejun Heo2da8ca82013-12-05 12:28:04 -05001950 .seq_show = cfqg_print_rwstat_recursive,
Tejun Heo43114012013-01-09 08:05:13 -08001951 },
1952 {
1953 .name = "io_queued_recursive",
1954 .private = offsetof(struct cfq_group, stats.queued),
Tejun Heo2da8ca82013-12-05 12:28:04 -05001955 .seq_show = cfqg_print_rwstat_recursive,
Tejun Heo43114012013-01-09 08:05:13 -08001956 },
Tejun Heo60c2bc22012-04-01 14:38:43 -07001957#ifdef CONFIG_DEBUG_BLK_CGROUP
1958 {
1959 .name = "avg_queue_size",
Tejun Heo2da8ca82013-12-05 12:28:04 -05001960 .seq_show = cfqg_print_avg_queue_size,
Tejun Heo60c2bc22012-04-01 14:38:43 -07001961 },
1962 {
1963 .name = "group_wait_time",
Tejun Heo5bc4afb12012-04-01 14:38:45 -07001964 .private = offsetof(struct cfq_group, stats.group_wait_time),
Tejun Heo2da8ca82013-12-05 12:28:04 -05001965 .seq_show = cfqg_print_stat,
Tejun Heo60c2bc22012-04-01 14:38:43 -07001966 },
1967 {
1968 .name = "idle_time",
Tejun Heo5bc4afb12012-04-01 14:38:45 -07001969 .private = offsetof(struct cfq_group, stats.idle_time),
Tejun Heo2da8ca82013-12-05 12:28:04 -05001970 .seq_show = cfqg_print_stat,
Tejun Heo60c2bc22012-04-01 14:38:43 -07001971 },
1972 {
1973 .name = "empty_time",
Tejun Heo5bc4afb12012-04-01 14:38:45 -07001974 .private = offsetof(struct cfq_group, stats.empty_time),
Tejun Heo2da8ca82013-12-05 12:28:04 -05001975 .seq_show = cfqg_print_stat,
Tejun Heo60c2bc22012-04-01 14:38:43 -07001976 },
1977 {
1978 .name = "dequeue",
Tejun Heo5bc4afb12012-04-01 14:38:45 -07001979 .private = offsetof(struct cfq_group, stats.dequeue),
Tejun Heo2da8ca82013-12-05 12:28:04 -05001980 .seq_show = cfqg_print_stat,
Tejun Heo60c2bc22012-04-01 14:38:43 -07001981 },
1982 {
1983 .name = "unaccounted_time",
Tejun Heo5bc4afb12012-04-01 14:38:45 -07001984 .private = offsetof(struct cfq_group, stats.unaccounted_time),
Tejun Heo2da8ca82013-12-05 12:28:04 -05001985 .seq_show = cfqg_print_stat,
Tejun Heo60c2bc22012-04-01 14:38:43 -07001986 },
1987#endif /* CONFIG_DEBUG_BLK_CGROUP */
1988 { } /* terminate */
1989};
Vivek Goyal25fb5162009-12-03 12:59:46 -05001990#else /* GROUP_IOSCHED */
Tejun Heocd1604f2012-03-05 13:15:06 -08001991static struct cfq_group *cfq_lookup_create_cfqg(struct cfq_data *cfqd,
Tejun Heo3c798392012-04-16 13:57:25 -07001992 struct blkcg *blkcg)
Vivek Goyal25fb5162009-12-03 12:59:46 -05001993{
Tejun Heof51b8022012-03-05 13:15:05 -08001994 return cfqd->root_group;
Vivek Goyal25fb5162009-12-03 12:59:46 -05001995}
Vivek Goyal7f1dc8a2010-04-21 17:44:16 +02001996
Vivek Goyal25fb5162009-12-03 12:59:46 -05001997static inline void
1998cfq_link_cfqq_cfqg(struct cfq_queue *cfqq, struct cfq_group *cfqg) {
1999 cfqq->cfqg = cfqg;
2000}
2001
2002#endif /* GROUP_IOSCHED */
2003
Jens Axboe498d3aa22007-04-26 12:54:48 +02002004/*
Corrado Zoccoloc0324a02009-10-27 19:16:03 +01002005 * The cfqd->service_trees holds all pending cfq_queue's that have
Jens Axboe498d3aa22007-04-26 12:54:48 +02002006 * requests waiting to be processed. It is sorted in the order that
2007 * we will service the queues.
2008 */
Jens Axboea36e71f2009-04-15 12:15:11 +02002009static void cfq_service_tree_add(struct cfq_data *cfqd, struct cfq_queue *cfqq,
Jens Axboea6151c32009-10-07 20:02:57 +02002010 bool add_front)
Jens Axboed9e76202007-04-20 14:27:50 +02002011{
Jens Axboe08717142008-01-28 11:38:15 +01002012 struct rb_node **p, *parent;
2013 struct cfq_queue *__cfqq;
Jens Axboed9e76202007-04-20 14:27:50 +02002014 unsigned long rb_key;
Vivek Goyal34b98d02012-10-03 16:56:58 -04002015 struct cfq_rb_root *st;
Jens Axboe498d3aa22007-04-26 12:54:48 +02002016 int left;
Vivek Goyaldae739e2009-12-03 12:59:45 -05002017 int new_cfqq = 1;
Vivek Goyalae30c282009-12-03 12:59:55 -05002018
Vivek Goyal34b98d02012-10-03 16:56:58 -04002019 st = st_for(cfqq->cfqg, cfqq_class(cfqq), cfqq_type(cfqq));
Jens Axboe08717142008-01-28 11:38:15 +01002020 if (cfq_class_idle(cfqq)) {
2021 rb_key = CFQ_IDLE_DELAY;
Vivek Goyal34b98d02012-10-03 16:56:58 -04002022 parent = rb_last(&st->rb);
Jens Axboe08717142008-01-28 11:38:15 +01002023 if (parent && parent != &cfqq->rb_node) {
2024 __cfqq = rb_entry(parent, struct cfq_queue, rb_node);
2025 rb_key += __cfqq->rb_key;
2026 } else
2027 rb_key += jiffies;
2028 } else if (!add_front) {
Jens Axboeb9c89462009-10-06 20:53:44 +02002029 /*
2030 * Get our rb key offset. Subtract any residual slice
2031 * value carried from last service. A negative resid
2032 * count indicates slice overrun, and this should position
2033 * the next service time further away in the tree.
2034 */
Jens Axboeedd75ff2007-04-19 12:03:34 +02002035 rb_key = cfq_slice_offset(cfqd, cfqq) + jiffies;
Jens Axboeb9c89462009-10-06 20:53:44 +02002036 rb_key -= cfqq->slice_resid;
Jens Axboeedd75ff2007-04-19 12:03:34 +02002037 cfqq->slice_resid = 0;
Corrado Zoccolo48e025e2009-10-05 08:49:23 +02002038 } else {
2039 rb_key = -HZ;
Vivek Goyal34b98d02012-10-03 16:56:58 -04002040 __cfqq = cfq_rb_first(st);
Corrado Zoccolo48e025e2009-10-05 08:49:23 +02002041 rb_key += __cfqq ? __cfqq->rb_key : jiffies;
2042 }
Jens Axboed9e76202007-04-20 14:27:50 +02002043
2044 if (!RB_EMPTY_NODE(&cfqq->rb_node)) {
Vivek Goyaldae739e2009-12-03 12:59:45 -05002045 new_cfqq = 0;
Jens Axboe99f96282007-02-05 11:56:25 +01002046 /*
Jens Axboed9e76202007-04-20 14:27:50 +02002047 * same position, nothing more to do
Jens Axboe99f96282007-02-05 11:56:25 +01002048 */
Vivek Goyal34b98d02012-10-03 16:56:58 -04002049 if (rb_key == cfqq->rb_key && cfqq->service_tree == st)
Jens Axboed9e76202007-04-20 14:27:50 +02002050 return;
Jens Axboe53b037442006-07-28 09:48:51 +02002051
Corrado Zoccoloaa6f6a32009-10-26 22:44:33 +01002052 cfq_rb_erase(&cfqq->rb_node, cfqq->service_tree);
2053 cfqq->service_tree = NULL;
Jens Axboe22e2c502005-06-27 10:55:12 +02002054 }
Jens Axboed9e76202007-04-20 14:27:50 +02002055
Jens Axboe498d3aa22007-04-26 12:54:48 +02002056 left = 1;
Jens Axboe08717142008-01-28 11:38:15 +01002057 parent = NULL;
Vivek Goyal34b98d02012-10-03 16:56:58 -04002058 cfqq->service_tree = st;
2059 p = &st->rb.rb_node;
Jens Axboed9e76202007-04-20 14:27:50 +02002060 while (*p) {
2061 parent = *p;
2062 __cfqq = rb_entry(parent, struct cfq_queue, rb_node);
2063
Jens Axboe0c534e02007-04-18 20:01:57 +02002064 /*
Corrado Zoccoloc0324a02009-10-27 19:16:03 +01002065 * sort by key, that represents service time.
Jens Axboe0c534e02007-04-18 20:01:57 +02002066 */
Corrado Zoccoloc0324a02009-10-27 19:16:03 +01002067 if (time_before(rb_key, __cfqq->rb_key))
Vivek Goyal1f23f122012-10-03 16:57:00 -04002068 p = &parent->rb_left;
Corrado Zoccoloc0324a02009-10-27 19:16:03 +01002069 else {
Vivek Goyal1f23f122012-10-03 16:57:00 -04002070 p = &parent->rb_right;
Jens Axboecc09e292007-04-26 12:53:50 +02002071 left = 0;
Corrado Zoccoloc0324a02009-10-27 19:16:03 +01002072 }
Jens Axboed9e76202007-04-20 14:27:50 +02002073 }
2074
Jens Axboecc09e292007-04-26 12:53:50 +02002075 if (left)
Vivek Goyal34b98d02012-10-03 16:56:58 -04002076 st->left = &cfqq->rb_node;
Jens Axboecc09e292007-04-26 12:53:50 +02002077
Jens Axboed9e76202007-04-20 14:27:50 +02002078 cfqq->rb_key = rb_key;
2079 rb_link_node(&cfqq->rb_node, parent, p);
Vivek Goyal34b98d02012-10-03 16:56:58 -04002080 rb_insert_color(&cfqq->rb_node, &st->rb);
2081 st->count++;
Namhyung Kim20359f22011-05-24 10:23:22 +02002082 if (add_front || !new_cfqq)
Vivek Goyaldae739e2009-12-03 12:59:45 -05002083 return;
Justin TerAvest8184f932011-03-17 16:12:36 +01002084 cfq_group_notify_queue_add(cfqd, cfqq->cfqg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085}
2086
Jens Axboea36e71f2009-04-15 12:15:11 +02002087static struct cfq_queue *
Jens Axboef2d1f0a2009-04-23 12:19:38 +02002088cfq_prio_tree_lookup(struct cfq_data *cfqd, struct rb_root *root,
2089 sector_t sector, struct rb_node **ret_parent,
2090 struct rb_node ***rb_link)
Jens Axboea36e71f2009-04-15 12:15:11 +02002091{
Jens Axboea36e71f2009-04-15 12:15:11 +02002092 struct rb_node **p, *parent;
2093 struct cfq_queue *cfqq = NULL;
2094
2095 parent = NULL;
2096 p = &root->rb_node;
2097 while (*p) {
2098 struct rb_node **n;
2099
2100 parent = *p;
2101 cfqq = rb_entry(parent, struct cfq_queue, p_node);
2102
2103 /*
2104 * Sort strictly based on sector. Smallest to the left,
2105 * largest to the right.
2106 */
Tejun Heo2e46e8b2009-05-07 22:24:41 +09002107 if (sector > blk_rq_pos(cfqq->next_rq))
Jens Axboea36e71f2009-04-15 12:15:11 +02002108 n = &(*p)->rb_right;
Tejun Heo2e46e8b2009-05-07 22:24:41 +09002109 else if (sector < blk_rq_pos(cfqq->next_rq))
Jens Axboea36e71f2009-04-15 12:15:11 +02002110 n = &(*p)->rb_left;
2111 else
2112 break;
2113 p = n;
Jens Axboe3ac6c9f2009-04-23 12:14:56 +02002114 cfqq = NULL;
Jens Axboea36e71f2009-04-15 12:15:11 +02002115 }
2116
2117 *ret_parent = parent;
2118 if (rb_link)
2119 *rb_link = p;
Jens Axboe3ac6c9f2009-04-23 12:14:56 +02002120 return cfqq;
Jens Axboea36e71f2009-04-15 12:15:11 +02002121}
2122
2123static void cfq_prio_tree_add(struct cfq_data *cfqd, struct cfq_queue *cfqq)
2124{
Jens Axboea36e71f2009-04-15 12:15:11 +02002125 struct rb_node **p, *parent;
2126 struct cfq_queue *__cfqq;
2127
Jens Axboef2d1f0a2009-04-23 12:19:38 +02002128 if (cfqq->p_root) {
2129 rb_erase(&cfqq->p_node, cfqq->p_root);
2130 cfqq->p_root = NULL;
2131 }
Jens Axboea36e71f2009-04-15 12:15:11 +02002132
2133 if (cfq_class_idle(cfqq))
2134 return;
2135 if (!cfqq->next_rq)
2136 return;
2137
Jens Axboef2d1f0a2009-04-23 12:19:38 +02002138 cfqq->p_root = &cfqd->prio_trees[cfqq->org_ioprio];
Tejun Heo2e46e8b2009-05-07 22:24:41 +09002139 __cfqq = cfq_prio_tree_lookup(cfqd, cfqq->p_root,
2140 blk_rq_pos(cfqq->next_rq), &parent, &p);
Jens Axboe3ac6c9f2009-04-23 12:14:56 +02002141 if (!__cfqq) {
2142 rb_link_node(&cfqq->p_node, parent, p);
Jens Axboef2d1f0a2009-04-23 12:19:38 +02002143 rb_insert_color(&cfqq->p_node, cfqq->p_root);
2144 } else
2145 cfqq->p_root = NULL;
Jens Axboea36e71f2009-04-15 12:15:11 +02002146}
2147
Jens Axboe498d3aa22007-04-26 12:54:48 +02002148/*
2149 * Update cfqq's position in the service tree.
2150 */
Jens Axboeedd75ff2007-04-19 12:03:34 +02002151static void cfq_resort_rr_list(struct cfq_data *cfqd, struct cfq_queue *cfqq)
Jens Axboe6d048f52007-04-25 12:44:27 +02002152{
Jens Axboe6d048f52007-04-25 12:44:27 +02002153 /*
2154 * Resorting requires the cfqq to be on the RR list already.
2155 */
Jens Axboea36e71f2009-04-15 12:15:11 +02002156 if (cfq_cfqq_on_rr(cfqq)) {
Jens Axboeedd75ff2007-04-19 12:03:34 +02002157 cfq_service_tree_add(cfqd, cfqq, 0);
Jens Axboea36e71f2009-04-15 12:15:11 +02002158 cfq_prio_tree_add(cfqd, cfqq);
2159 }
Jens Axboe6d048f52007-04-25 12:44:27 +02002160}
2161
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162/*
2163 * add to busy list of queues for service, trying to be fair in ordering
Jens Axboe22e2c502005-06-27 10:55:12 +02002164 * the pending list according to last request service
Linus Torvalds1da177e2005-04-16 15:20:36 -07002165 */
Jens Axboefebffd62008-01-28 13:19:43 +01002166static void cfq_add_cfqq_rr(struct cfq_data *cfqd, struct cfq_queue *cfqq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002167{
Jens Axboe7b679132008-05-30 12:23:07 +02002168 cfq_log_cfqq(cfqd, cfqq, "add_to_rr");
Jens Axboe3b181522005-06-27 10:56:24 +02002169 BUG_ON(cfq_cfqq_on_rr(cfqq));
2170 cfq_mark_cfqq_on_rr(cfqq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002171 cfqd->busy_queues++;
Shaohua Lief8a41d2011-03-07 09:26:29 +01002172 if (cfq_cfqq_sync(cfqq))
2173 cfqd->busy_sync_queues++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174
Jens Axboeedd75ff2007-04-19 12:03:34 +02002175 cfq_resort_rr_list(cfqd, cfqq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002176}
2177
Jens Axboe498d3aa22007-04-26 12:54:48 +02002178/*
2179 * Called when the cfqq no longer has requests pending, remove it from
2180 * the service tree.
2181 */
Jens Axboefebffd62008-01-28 13:19:43 +01002182static void cfq_del_cfqq_rr(struct cfq_data *cfqd, struct cfq_queue *cfqq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183{
Jens Axboe7b679132008-05-30 12:23:07 +02002184 cfq_log_cfqq(cfqd, cfqq, "del_from_rr");
Jens Axboe3b181522005-06-27 10:56:24 +02002185 BUG_ON(!cfq_cfqq_on_rr(cfqq));
2186 cfq_clear_cfqq_on_rr(cfqq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187
Corrado Zoccoloaa6f6a32009-10-26 22:44:33 +01002188 if (!RB_EMPTY_NODE(&cfqq->rb_node)) {
2189 cfq_rb_erase(&cfqq->rb_node, cfqq->service_tree);
2190 cfqq->service_tree = NULL;
2191 }
Jens Axboef2d1f0a2009-04-23 12:19:38 +02002192 if (cfqq->p_root) {
2193 rb_erase(&cfqq->p_node, cfqq->p_root);
2194 cfqq->p_root = NULL;
2195 }
Jens Axboed9e76202007-04-20 14:27:50 +02002196
Justin TerAvest8184f932011-03-17 16:12:36 +01002197 cfq_group_notify_queue_del(cfqd, cfqq->cfqg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002198 BUG_ON(!cfqd->busy_queues);
2199 cfqd->busy_queues--;
Shaohua Lief8a41d2011-03-07 09:26:29 +01002200 if (cfq_cfqq_sync(cfqq))
2201 cfqd->busy_sync_queues--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202}
2203
2204/*
2205 * rb tree support functions
2206 */
Jens Axboefebffd62008-01-28 13:19:43 +01002207static void cfq_del_rq_rb(struct request *rq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208{
Jens Axboe5e705372006-07-13 12:39:25 +02002209 struct cfq_queue *cfqq = RQ_CFQQ(rq);
Jens Axboe5e705372006-07-13 12:39:25 +02002210 const int sync = rq_is_sync(rq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002211
Jens Axboeb4878f22005-10-20 16:42:29 +02002212 BUG_ON(!cfqq->queued[sync]);
2213 cfqq->queued[sync]--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002214
Jens Axboe5e705372006-07-13 12:39:25 +02002215 elv_rb_del(&cfqq->sort_list, rq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216
Vivek Goyalf04a6422009-12-03 12:59:40 -05002217 if (cfq_cfqq_on_rr(cfqq) && RB_EMPTY_ROOT(&cfqq->sort_list)) {
2218 /*
2219 * Queue will be deleted from service tree when we actually
2220 * expire it later. Right now just remove it from prio tree
2221 * as it is empty.
2222 */
2223 if (cfqq->p_root) {
2224 rb_erase(&cfqq->p_node, cfqq->p_root);
2225 cfqq->p_root = NULL;
2226 }
2227 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228}
2229
Jens Axboe5e705372006-07-13 12:39:25 +02002230static void cfq_add_rq_rb(struct request *rq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231{
Jens Axboe5e705372006-07-13 12:39:25 +02002232 struct cfq_queue *cfqq = RQ_CFQQ(rq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233 struct cfq_data *cfqd = cfqq->cfqd;
Jeff Moyer796d5112011-06-02 21:19:05 +02002234 struct request *prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235
Jens Axboe5380a102006-07-13 12:37:56 +02002236 cfqq->queued[rq_is_sync(rq)]++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002237
Jeff Moyer796d5112011-06-02 21:19:05 +02002238 elv_rb_add(&cfqq->sort_list, rq);
Jens Axboe5fccbf62006-10-31 14:21:55 +01002239
2240 if (!cfq_cfqq_on_rr(cfqq))
2241 cfq_add_cfqq_rr(cfqd, cfqq);
Jens Axboe5044eed2007-04-25 11:53:48 +02002242
2243 /*
2244 * check if this request is a better next-serve candidate
2245 */
Jens Axboea36e71f2009-04-15 12:15:11 +02002246 prev = cfqq->next_rq;
Corrado Zoccolocf7c25c2009-11-08 17:16:46 +01002247 cfqq->next_rq = cfq_choose_req(cfqd, cfqq->next_rq, rq, cfqd->last_position);
Jens Axboea36e71f2009-04-15 12:15:11 +02002248
2249 /*
2250 * adjust priority tree position, if ->next_rq changes
2251 */
2252 if (prev != cfqq->next_rq)
2253 cfq_prio_tree_add(cfqd, cfqq);
2254
Jens Axboe5044eed2007-04-25 11:53:48 +02002255 BUG_ON(!cfqq->next_rq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256}
2257
Jens Axboefebffd62008-01-28 13:19:43 +01002258static void cfq_reposition_rq_rb(struct cfq_queue *cfqq, struct request *rq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259{
Jens Axboe5380a102006-07-13 12:37:56 +02002260 elv_rb_del(&cfqq->sort_list, rq);
2261 cfqq->queued[rq_is_sync(rq)]--;
Tejun Heo155fead2012-04-01 14:38:44 -07002262 cfqg_stats_update_io_remove(RQ_CFQG(rq), rq->cmd_flags);
Jens Axboe5e705372006-07-13 12:39:25 +02002263 cfq_add_rq_rb(rq);
Tejun Heo155fead2012-04-01 14:38:44 -07002264 cfqg_stats_update_io_add(RQ_CFQG(rq), cfqq->cfqd->serving_group,
2265 rq->cmd_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266}
2267
Jens Axboe206dc692006-03-28 13:03:44 +02002268static struct request *
2269cfq_find_rq_fmerge(struct cfq_data *cfqd, struct bio *bio)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270{
Jens Axboe206dc692006-03-28 13:03:44 +02002271 struct task_struct *tsk = current;
Tejun Heoc5869802011-12-14 00:33:41 +01002272 struct cfq_io_cq *cic;
Jens Axboe206dc692006-03-28 13:03:44 +02002273 struct cfq_queue *cfqq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274
Jens Axboe4ac845a2008-01-24 08:44:49 +01002275 cic = cfq_cic_lookup(cfqd, tsk->io_context);
Vasily Tarasov91fac312007-04-25 12:29:51 +02002276 if (!cic)
2277 return NULL;
2278
2279 cfqq = cic_to_cfqq(cic, cfq_bio_sync(bio));
Kent Overstreetf73a1c72012-09-25 15:05:12 -07002280 if (cfqq)
2281 return elv_rb_find(&cfqq->sort_list, bio_end_sector(bio));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283 return NULL;
2284}
2285
Jens Axboe165125e2007-07-24 09:28:11 +02002286static void cfq_activate_request(struct request_queue *q, struct request *rq)
Jens Axboeb4878f22005-10-20 16:42:29 +02002287{
2288 struct cfq_data *cfqd = q->elevator->elevator_data;
2289
Corrado Zoccolo53c583d2010-02-28 19:45:05 +01002290 cfqd->rq_in_driver++;
Jens Axboe7b679132008-05-30 12:23:07 +02002291 cfq_log_cfqq(cfqd, RQ_CFQQ(rq), "activate rq, drv=%d",
Corrado Zoccolo53c583d2010-02-28 19:45:05 +01002292 cfqd->rq_in_driver);
Jens Axboe25776e32006-06-01 10:12:26 +02002293
Tejun Heo5b936292009-05-07 22:24:38 +09002294 cfqd->last_position = blk_rq_pos(rq) + blk_rq_sectors(rq);
Jens Axboeb4878f22005-10-20 16:42:29 +02002295}
2296
Jens Axboe165125e2007-07-24 09:28:11 +02002297static void cfq_deactivate_request(struct request_queue *q, struct request *rq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298{
Jens Axboe22e2c502005-06-27 10:55:12 +02002299 struct cfq_data *cfqd = q->elevator->elevator_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002300
Corrado Zoccolo53c583d2010-02-28 19:45:05 +01002301 WARN_ON(!cfqd->rq_in_driver);
2302 cfqd->rq_in_driver--;
Jens Axboe7b679132008-05-30 12:23:07 +02002303 cfq_log_cfqq(cfqd, RQ_CFQQ(rq), "deactivate rq, drv=%d",
Corrado Zoccolo53c583d2010-02-28 19:45:05 +01002304 cfqd->rq_in_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305}
2306
Jens Axboeb4878f22005-10-20 16:42:29 +02002307static void cfq_remove_request(struct request *rq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002308{
Jens Axboe5e705372006-07-13 12:39:25 +02002309 struct cfq_queue *cfqq = RQ_CFQQ(rq);
Jens Axboe21183b02006-07-13 12:33:14 +02002310
Jens Axboe5e705372006-07-13 12:39:25 +02002311 if (cfqq->next_rq == rq)
2312 cfqq->next_rq = cfq_find_next_rq(cfqq->cfqd, cfqq, rq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313
Jens Axboeb4878f22005-10-20 16:42:29 +02002314 list_del_init(&rq->queuelist);
Jens Axboe5e705372006-07-13 12:39:25 +02002315 cfq_del_rq_rb(rq);
Jens Axboe374f84a2006-07-23 01:42:19 +02002316
Aaron Carroll45333d52008-08-26 15:52:36 +02002317 cfqq->cfqd->rq_queued--;
Tejun Heo155fead2012-04-01 14:38:44 -07002318 cfqg_stats_update_io_remove(RQ_CFQG(rq), rq->cmd_flags);
Christoph Hellwig65299a32011-08-23 14:50:29 +02002319 if (rq->cmd_flags & REQ_PRIO) {
2320 WARN_ON(!cfqq->prio_pending);
2321 cfqq->prio_pending--;
Jens Axboeb53d1ed2011-08-19 08:34:48 +02002322 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002323}
2324
Jens Axboe165125e2007-07-24 09:28:11 +02002325static int cfq_merge(struct request_queue *q, struct request **req,
2326 struct bio *bio)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327{
2328 struct cfq_data *cfqd = q->elevator->elevator_data;
2329 struct request *__rq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330
Jens Axboe206dc692006-03-28 13:03:44 +02002331 __rq = cfq_find_rq_fmerge(cfqd, bio);
Jens Axboe22e2c502005-06-27 10:55:12 +02002332 if (__rq && elv_rq_merge_ok(__rq, bio)) {
Jens Axboe98170642006-07-28 09:23:08 +02002333 *req = __rq;
2334 return ELEVATOR_FRONT_MERGE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335 }
2336
2337 return ELEVATOR_NO_MERGE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002338}
2339
Jens Axboe165125e2007-07-24 09:28:11 +02002340static void cfq_merged_request(struct request_queue *q, struct request *req,
Jens Axboe21183b02006-07-13 12:33:14 +02002341 int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002342{
Jens Axboe21183b02006-07-13 12:33:14 +02002343 if (type == ELEVATOR_FRONT_MERGE) {
Jens Axboe5e705372006-07-13 12:39:25 +02002344 struct cfq_queue *cfqq = RQ_CFQQ(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002345
Jens Axboe5e705372006-07-13 12:39:25 +02002346 cfq_reposition_rq_rb(cfqq, req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002347 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348}
2349
Divyesh Shah812d4022010-04-08 21:14:23 -07002350static void cfq_bio_merged(struct request_queue *q, struct request *req,
2351 struct bio *bio)
2352{
Tejun Heo155fead2012-04-01 14:38:44 -07002353 cfqg_stats_update_io_merged(RQ_CFQG(req), bio->bi_rw);
Divyesh Shah812d4022010-04-08 21:14:23 -07002354}
2355
Linus Torvalds1da177e2005-04-16 15:20:36 -07002356static void
Jens Axboe165125e2007-07-24 09:28:11 +02002357cfq_merged_requests(struct request_queue *q, struct request *rq,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002358 struct request *next)
2359{
Corrado Zoccolocf7c25c2009-11-08 17:16:46 +01002360 struct cfq_queue *cfqq = RQ_CFQQ(rq);
Shaohua Li4a0b75c2011-12-16 14:00:22 +01002361 struct cfq_data *cfqd = q->elevator->elevator_data;
2362
Jens Axboe22e2c502005-06-27 10:55:12 +02002363 /*
2364 * reposition in fifo if next is older than rq
2365 */
2366 if (!list_empty(&rq->queuelist) && !list_empty(&next->queuelist) &&
Jan Kara8b4922d2014-02-24 16:39:52 +01002367 time_before(next->fifo_time, rq->fifo_time) &&
Shaohua Li3d106fba2012-11-06 12:39:51 +01002368 cfqq == RQ_CFQQ(next)) {
Jens Axboe22e2c502005-06-27 10:55:12 +02002369 list_move(&rq->queuelist, &next->queuelist);
Jan Kara8b4922d2014-02-24 16:39:52 +01002370 rq->fifo_time = next->fifo_time;
Jens Axboe30996f42009-10-05 11:03:39 +02002371 }
Jens Axboe22e2c502005-06-27 10:55:12 +02002372
Corrado Zoccolocf7c25c2009-11-08 17:16:46 +01002373 if (cfqq->next_rq == next)
2374 cfqq->next_rq = rq;
Jens Axboeb4878f22005-10-20 16:42:29 +02002375 cfq_remove_request(next);
Tejun Heo155fead2012-04-01 14:38:44 -07002376 cfqg_stats_update_io_merged(RQ_CFQG(rq), next->cmd_flags);
Shaohua Li4a0b75c2011-12-16 14:00:22 +01002377
2378 cfqq = RQ_CFQQ(next);
2379 /*
2380 * all requests of this queue are merged to other queues, delete it
2381 * from the service tree. If it's the active_queue,
2382 * cfq_dispatch_requests() will choose to expire it or do idle
2383 */
2384 if (cfq_cfqq_on_rr(cfqq) && RB_EMPTY_ROOT(&cfqq->sort_list) &&
2385 cfqq != cfqd->active_queue)
2386 cfq_del_cfqq_rr(cfqd, cfqq);
Jens Axboe22e2c502005-06-27 10:55:12 +02002387}
2388
Jens Axboe165125e2007-07-24 09:28:11 +02002389static int cfq_allow_merge(struct request_queue *q, struct request *rq,
Jens Axboeda775262006-12-20 11:04:12 +01002390 struct bio *bio)
2391{
2392 struct cfq_data *cfqd = q->elevator->elevator_data;
Tejun Heoc5869802011-12-14 00:33:41 +01002393 struct cfq_io_cq *cic;
Jens Axboeda775262006-12-20 11:04:12 +01002394 struct cfq_queue *cfqq;
Jens Axboeda775262006-12-20 11:04:12 +01002395
2396 /*
Jens Axboeec8acb62007-01-02 18:32:11 +01002397 * Disallow merge of a sync bio into an async request.
Jens Axboeda775262006-12-20 11:04:12 +01002398 */
Vasily Tarasov91fac312007-04-25 12:29:51 +02002399 if (cfq_bio_sync(bio) && !rq_is_sync(rq))
Jens Axboea6151c32009-10-07 20:02:57 +02002400 return false;
Jens Axboeda775262006-12-20 11:04:12 +01002401
2402 /*
Tejun Heof1a4f4d2011-12-14 00:33:39 +01002403 * Lookup the cfqq that this bio will be queued with and allow
Tejun Heo07c2bd32012-02-08 09:19:42 +01002404 * merge only if rq is queued there.
Jens Axboeda775262006-12-20 11:04:12 +01002405 */
Tejun Heo07c2bd32012-02-08 09:19:42 +01002406 cic = cfq_cic_lookup(cfqd, current->io_context);
2407 if (!cic)
2408 return false;
Jens Axboe719d3402006-12-22 09:38:53 +01002409
Vasily Tarasov91fac312007-04-25 12:29:51 +02002410 cfqq = cic_to_cfqq(cic, cfq_bio_sync(bio));
Jens Axboea6151c32009-10-07 20:02:57 +02002411 return cfqq == RQ_CFQQ(rq);
Jens Axboeda775262006-12-20 11:04:12 +01002412}
2413
Divyesh Shah812df482010-04-08 21:15:35 -07002414static inline void cfq_del_timer(struct cfq_data *cfqd, struct cfq_queue *cfqq)
2415{
2416 del_timer(&cfqd->idle_slice_timer);
Tejun Heo155fead2012-04-01 14:38:44 -07002417 cfqg_stats_update_idle_time(cfqq->cfqg);
Divyesh Shah812df482010-04-08 21:15:35 -07002418}
2419
Jens Axboefebffd62008-01-28 13:19:43 +01002420static void __cfq_set_active_queue(struct cfq_data *cfqd,
2421 struct cfq_queue *cfqq)
Jens Axboe22e2c502005-06-27 10:55:12 +02002422{
2423 if (cfqq) {
Vivek Goyal3bf10fe2012-10-03 16:56:56 -04002424 cfq_log_cfqq(cfqd, cfqq, "set_active wl_class:%d wl_type:%d",
Vivek Goyal4d2ceea2012-10-03 16:56:57 -04002425 cfqd->serving_wl_class, cfqd->serving_wl_type);
Tejun Heo155fead2012-04-01 14:38:44 -07002426 cfqg_stats_update_avg_queue_size(cfqq->cfqg);
Justin TerAvest62a37f62011-03-23 08:25:44 +01002427 cfqq->slice_start = 0;
2428 cfqq->dispatch_start = jiffies;
2429 cfqq->allocated_slice = 0;
2430 cfqq->slice_end = 0;
2431 cfqq->slice_dispatch = 0;
2432 cfqq->nr_sectors = 0;
2433
2434 cfq_clear_cfqq_wait_request(cfqq);
2435 cfq_clear_cfqq_must_dispatch(cfqq);
2436 cfq_clear_cfqq_must_alloc_slice(cfqq);
2437 cfq_clear_cfqq_fifo_expire(cfqq);
2438 cfq_mark_cfqq_slice_new(cfqq);
2439
2440 cfq_del_timer(cfqd, cfqq);
Jens Axboe22e2c502005-06-27 10:55:12 +02002441 }
2442
2443 cfqd->active_queue = cfqq;
2444}
2445
2446/*
Jens Axboe7b14e3b2006-02-28 09:35:11 +01002447 * current cfqq expired its slice (or was too idle), select new one
2448 */
2449static void
2450__cfq_slice_expired(struct cfq_data *cfqd, struct cfq_queue *cfqq,
Vivek Goyale5ff0822010-04-26 19:25:11 +02002451 bool timed_out)
Jens Axboe7b14e3b2006-02-28 09:35:11 +01002452{
Jens Axboe7b679132008-05-30 12:23:07 +02002453 cfq_log_cfqq(cfqd, cfqq, "slice expired t=%d", timed_out);
2454
Jens Axboe7b14e3b2006-02-28 09:35:11 +01002455 if (cfq_cfqq_wait_request(cfqq))
Divyesh Shah812df482010-04-08 21:15:35 -07002456 cfq_del_timer(cfqd, cfqq);
Jens Axboe7b14e3b2006-02-28 09:35:11 +01002457
Jens Axboe7b14e3b2006-02-28 09:35:11 +01002458 cfq_clear_cfqq_wait_request(cfqq);
Vivek Goyalf75edf22009-12-03 12:59:53 -05002459 cfq_clear_cfqq_wait_busy(cfqq);
Jens Axboe7b14e3b2006-02-28 09:35:11 +01002460
2461 /*
Shaohua Liae54abe2010-02-05 13:11:45 +01002462 * If this cfqq is shared between multiple processes, check to
2463 * make sure that those processes are still issuing I/Os within
2464 * the mean seek distance. If not, it may be time to break the
2465 * queues apart again.
2466 */
2467 if (cfq_cfqq_coop(cfqq) && CFQQ_SEEKY(cfqq))
2468 cfq_mark_cfqq_split_coop(cfqq);
2469
2470 /*
Jens Axboe6084cdd2007-04-23 08:25:00 +02002471 * store what was left of this slice, if the queue idled/timed out
Jens Axboe7b14e3b2006-02-28 09:35:11 +01002472 */
Shaohua Lic553f8e2011-01-14 08:41:03 +01002473 if (timed_out) {
2474 if (cfq_cfqq_slice_new(cfqq))
Vivek Goyalba5bd522011-01-19 08:25:02 -07002475 cfqq->slice_resid = cfq_scaled_cfqq_slice(cfqd, cfqq);
Shaohua Lic553f8e2011-01-14 08:41:03 +01002476 else
2477 cfqq->slice_resid = cfqq->slice_end - jiffies;
Jens Axboe7b679132008-05-30 12:23:07 +02002478 cfq_log_cfqq(cfqd, cfqq, "resid=%ld", cfqq->slice_resid);
2479 }
Jens Axboe7b14e3b2006-02-28 09:35:11 +01002480
Vivek Goyale5ff0822010-04-26 19:25:11 +02002481 cfq_group_served(cfqd, cfqq->cfqg, cfqq);
Vivek Goyaldae739e2009-12-03 12:59:45 -05002482
Vivek Goyalf04a6422009-12-03 12:59:40 -05002483 if (cfq_cfqq_on_rr(cfqq) && RB_EMPTY_ROOT(&cfqq->sort_list))
2484 cfq_del_cfqq_rr(cfqd, cfqq);
2485
Jens Axboeedd75ff2007-04-19 12:03:34 +02002486 cfq_resort_rr_list(cfqd, cfqq);
Jens Axboe7b14e3b2006-02-28 09:35:11 +01002487
2488 if (cfqq == cfqd->active_queue)
2489 cfqd->active_queue = NULL;
2490
2491 if (cfqd->active_cic) {
Tejun Heo11a31222012-02-07 07:51:30 +01002492 put_io_context(cfqd->active_cic->icq.ioc);
Jens Axboe7b14e3b2006-02-28 09:35:11 +01002493 cfqd->active_cic = NULL;
2494 }
Jens Axboe7b14e3b2006-02-28 09:35:11 +01002495}
2496
Vivek Goyale5ff0822010-04-26 19:25:11 +02002497static inline void cfq_slice_expired(struct cfq_data *cfqd, bool timed_out)
Jens Axboe7b14e3b2006-02-28 09:35:11 +01002498{
2499 struct cfq_queue *cfqq = cfqd->active_queue;
2500
2501 if (cfqq)
Vivek Goyale5ff0822010-04-26 19:25:11 +02002502 __cfq_slice_expired(cfqd, cfqq, timed_out);
Jens Axboe7b14e3b2006-02-28 09:35:11 +01002503}
2504
Jens Axboe498d3aa22007-04-26 12:54:48 +02002505/*
2506 * Get next queue for service. Unless we have a queue preemption,
2507 * we'll simply select the first cfqq in the service tree.
2508 */
Jens Axboe6d048f52007-04-25 12:44:27 +02002509static struct cfq_queue *cfq_get_next_queue(struct cfq_data *cfqd)
Jens Axboe22e2c502005-06-27 10:55:12 +02002510{
Vivek Goyal34b98d02012-10-03 16:56:58 -04002511 struct cfq_rb_root *st = st_for(cfqd->serving_group,
2512 cfqd->serving_wl_class, cfqd->serving_wl_type);
Jens Axboeedd75ff2007-04-19 12:03:34 +02002513
Vivek Goyalf04a6422009-12-03 12:59:40 -05002514 if (!cfqd->rq_queued)
2515 return NULL;
2516
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -05002517 /* There is nothing to dispatch */
Vivek Goyal34b98d02012-10-03 16:56:58 -04002518 if (!st)
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -05002519 return NULL;
Vivek Goyal34b98d02012-10-03 16:56:58 -04002520 if (RB_EMPTY_ROOT(&st->rb))
Corrado Zoccoloc0324a02009-10-27 19:16:03 +01002521 return NULL;
Vivek Goyal34b98d02012-10-03 16:56:58 -04002522 return cfq_rb_first(st);
Jens Axboe6d048f52007-04-25 12:44:27 +02002523}
2524
Vivek Goyalf04a6422009-12-03 12:59:40 -05002525static struct cfq_queue *cfq_get_next_queue_forced(struct cfq_data *cfqd)
2526{
Vivek Goyal25fb5162009-12-03 12:59:46 -05002527 struct cfq_group *cfqg;
Vivek Goyalf04a6422009-12-03 12:59:40 -05002528 struct cfq_queue *cfqq;
2529 int i, j;
2530 struct cfq_rb_root *st;
2531
2532 if (!cfqd->rq_queued)
2533 return NULL;
2534
Vivek Goyal25fb5162009-12-03 12:59:46 -05002535 cfqg = cfq_get_next_cfqg(cfqd);
2536 if (!cfqg)
2537 return NULL;
2538
Vivek Goyalf04a6422009-12-03 12:59:40 -05002539 for_each_cfqg_st(cfqg, i, j, st)
2540 if ((cfqq = cfq_rb_first(st)) != NULL)
2541 return cfqq;
2542 return NULL;
2543}
2544
Jens Axboe498d3aa22007-04-26 12:54:48 +02002545/*
2546 * Get and set a new active queue for service.
2547 */
Jens Axboea36e71f2009-04-15 12:15:11 +02002548static struct cfq_queue *cfq_set_active_queue(struct cfq_data *cfqd,
2549 struct cfq_queue *cfqq)
Jens Axboe6d048f52007-04-25 12:44:27 +02002550{
Jens Axboee00ef792009-11-04 08:54:55 +01002551 if (!cfqq)
Jens Axboea36e71f2009-04-15 12:15:11 +02002552 cfqq = cfq_get_next_queue(cfqd);
Jens Axboe6d048f52007-04-25 12:44:27 +02002553
Jens Axboe22e2c502005-06-27 10:55:12 +02002554 __cfq_set_active_queue(cfqd, cfqq);
Jens Axboe3b181522005-06-27 10:56:24 +02002555 return cfqq;
Jens Axboe22e2c502005-06-27 10:55:12 +02002556}
2557
Jens Axboed9e76202007-04-20 14:27:50 +02002558static inline sector_t cfq_dist_from_last(struct cfq_data *cfqd,
2559 struct request *rq)
2560{
Tejun Heo83096eb2009-05-07 22:24:39 +09002561 if (blk_rq_pos(rq) >= cfqd->last_position)
2562 return blk_rq_pos(rq) - cfqd->last_position;
Jens Axboed9e76202007-04-20 14:27:50 +02002563 else
Tejun Heo83096eb2009-05-07 22:24:39 +09002564 return cfqd->last_position - blk_rq_pos(rq);
Jens Axboed9e76202007-04-20 14:27:50 +02002565}
2566
Jeff Moyerb2c18e12009-10-23 17:14:49 -04002567static inline int cfq_rq_close(struct cfq_data *cfqd, struct cfq_queue *cfqq,
Shaohua Lie9ce3352010-03-19 08:03:04 +01002568 struct request *rq)
Jens Axboe6d048f52007-04-25 12:44:27 +02002569{
Shaohua Lie9ce3352010-03-19 08:03:04 +01002570 return cfq_dist_from_last(cfqd, rq) <= CFQQ_CLOSE_THR;
Jens Axboe6d048f52007-04-25 12:44:27 +02002571}
2572
Jens Axboea36e71f2009-04-15 12:15:11 +02002573static struct cfq_queue *cfqq_close(struct cfq_data *cfqd,
2574 struct cfq_queue *cur_cfqq)
Jens Axboe6d048f52007-04-25 12:44:27 +02002575{
Jens Axboef2d1f0a2009-04-23 12:19:38 +02002576 struct rb_root *root = &cfqd->prio_trees[cur_cfqq->org_ioprio];
Jens Axboea36e71f2009-04-15 12:15:11 +02002577 struct rb_node *parent, *node;
2578 struct cfq_queue *__cfqq;
2579 sector_t sector = cfqd->last_position;
2580
2581 if (RB_EMPTY_ROOT(root))
2582 return NULL;
2583
2584 /*
2585 * First, if we find a request starting at the end of the last
2586 * request, choose it.
2587 */
Jens Axboef2d1f0a2009-04-23 12:19:38 +02002588 __cfqq = cfq_prio_tree_lookup(cfqd, root, sector, &parent, NULL);
Jens Axboea36e71f2009-04-15 12:15:11 +02002589 if (__cfqq)
2590 return __cfqq;
2591
2592 /*
2593 * If the exact sector wasn't found, the parent of the NULL leaf
2594 * will contain the closest sector.
2595 */
2596 __cfqq = rb_entry(parent, struct cfq_queue, p_node);
Shaohua Lie9ce3352010-03-19 08:03:04 +01002597 if (cfq_rq_close(cfqd, cur_cfqq, __cfqq->next_rq))
Jens Axboea36e71f2009-04-15 12:15:11 +02002598 return __cfqq;
2599
Tejun Heo2e46e8b2009-05-07 22:24:41 +09002600 if (blk_rq_pos(__cfqq->next_rq) < sector)
Jens Axboea36e71f2009-04-15 12:15:11 +02002601 node = rb_next(&__cfqq->p_node);
2602 else
2603 node = rb_prev(&__cfqq->p_node);
2604 if (!node)
2605 return NULL;
2606
2607 __cfqq = rb_entry(node, struct cfq_queue, p_node);
Shaohua Lie9ce3352010-03-19 08:03:04 +01002608 if (cfq_rq_close(cfqd, cur_cfqq, __cfqq->next_rq))
Jens Axboea36e71f2009-04-15 12:15:11 +02002609 return __cfqq;
2610
2611 return NULL;
2612}
2613
2614/*
2615 * cfqd - obvious
2616 * cur_cfqq - passed in so that we don't decide that the current queue is
2617 * closely cooperating with itself.
2618 *
2619 * So, basically we're assuming that that cur_cfqq has dispatched at least
2620 * one request, and that cfqd->last_position reflects a position on the disk
2621 * associated with the I/O issued by cur_cfqq. I'm not sure this is a valid
2622 * assumption.
2623 */
2624static struct cfq_queue *cfq_close_cooperator(struct cfq_data *cfqd,
Jeff Moyerb3b6d042009-10-23 17:14:51 -04002625 struct cfq_queue *cur_cfqq)
Jens Axboea36e71f2009-04-15 12:15:11 +02002626{
2627 struct cfq_queue *cfqq;
2628
Divyesh Shah39c01b22010-03-25 15:45:57 +01002629 if (cfq_class_idle(cur_cfqq))
2630 return NULL;
Jeff Moyere6c5bc72009-10-23 17:14:52 -04002631 if (!cfq_cfqq_sync(cur_cfqq))
2632 return NULL;
2633 if (CFQQ_SEEKY(cur_cfqq))
2634 return NULL;
2635
Jens Axboea36e71f2009-04-15 12:15:11 +02002636 /*
Gui Jianfengb9d8f4c2009-12-08 08:54:17 +01002637 * Don't search priority tree if it's the only queue in the group.
2638 */
2639 if (cur_cfqq->cfqg->nr_cfqq == 1)
2640 return NULL;
2641
2642 /*
Jens Axboed9e76202007-04-20 14:27:50 +02002643 * We should notice if some of the queues are cooperating, eg
2644 * working closely on the same area of the disk. In that case,
2645 * we can group them together and don't waste time idling.
Jens Axboe6d048f52007-04-25 12:44:27 +02002646 */
Jens Axboea36e71f2009-04-15 12:15:11 +02002647 cfqq = cfqq_close(cfqd, cur_cfqq);
2648 if (!cfqq)
2649 return NULL;
2650
Vivek Goyal8682e1f2009-12-03 12:59:50 -05002651 /* If new queue belongs to different cfq_group, don't choose it */
2652 if (cur_cfqq->cfqg != cfqq->cfqg)
2653 return NULL;
2654
Jeff Moyerdf5fe3e2009-10-23 17:14:50 -04002655 /*
2656 * It only makes sense to merge sync queues.
2657 */
2658 if (!cfq_cfqq_sync(cfqq))
2659 return NULL;
Jeff Moyere6c5bc72009-10-23 17:14:52 -04002660 if (CFQQ_SEEKY(cfqq))
2661 return NULL;
Jeff Moyerdf5fe3e2009-10-23 17:14:50 -04002662
Corrado Zoccoloc0324a02009-10-27 19:16:03 +01002663 /*
2664 * Do not merge queues of different priority classes
2665 */
2666 if (cfq_class_rt(cfqq) != cfq_class_rt(cur_cfqq))
2667 return NULL;
2668
Jens Axboea36e71f2009-04-15 12:15:11 +02002669 return cfqq;
Jens Axboe6d048f52007-04-25 12:44:27 +02002670}
2671
Corrado Zoccoloa6d44e92009-10-26 22:45:11 +01002672/*
2673 * Determine whether we should enforce idle window for this queue.
2674 */
2675
2676static bool cfq_should_idle(struct cfq_data *cfqd, struct cfq_queue *cfqq)
2677{
Vivek Goyal3bf10fe2012-10-03 16:56:56 -04002678 enum wl_class_t wl_class = cfqq_class(cfqq);
Vivek Goyal34b98d02012-10-03 16:56:58 -04002679 struct cfq_rb_root *st = cfqq->service_tree;
Corrado Zoccoloa6d44e92009-10-26 22:45:11 +01002680
Vivek Goyal34b98d02012-10-03 16:56:58 -04002681 BUG_ON(!st);
2682 BUG_ON(!st->count);
Vivek Goyalf04a6422009-12-03 12:59:40 -05002683
Vivek Goyalb6508c12010-08-23 12:23:33 +02002684 if (!cfqd->cfq_slice_idle)
2685 return false;
2686
Corrado Zoccoloa6d44e92009-10-26 22:45:11 +01002687 /* We never do for idle class queues. */
Vivek Goyal3bf10fe2012-10-03 16:56:56 -04002688 if (wl_class == IDLE_WORKLOAD)
Corrado Zoccoloa6d44e92009-10-26 22:45:11 +01002689 return false;
2690
2691 /* We do for queues that were marked with idle window flag. */
Shaohua Li3c764b72009-12-04 13:12:06 +01002692 if (cfq_cfqq_idle_window(cfqq) &&
2693 !(blk_queue_nonrot(cfqd->queue) && cfqd->hw_tag))
Corrado Zoccoloa6d44e92009-10-26 22:45:11 +01002694 return true;
2695
2696 /*
2697 * Otherwise, we do only if they are the last ones
2698 * in their service tree.
2699 */
Vivek Goyal34b98d02012-10-03 16:56:58 -04002700 if (st->count == 1 && cfq_cfqq_sync(cfqq) &&
2701 !cfq_io_thinktime_big(cfqd, &st->ttime, false))
Shaohua Lic1e44752010-11-08 15:01:02 +01002702 return true;
Vivek Goyal34b98d02012-10-03 16:56:58 -04002703 cfq_log_cfqq(cfqd, cfqq, "Not idling. st->count:%d", st->count);
Shaohua Lic1e44752010-11-08 15:01:02 +01002704 return false;
Corrado Zoccoloa6d44e92009-10-26 22:45:11 +01002705}
2706
Jens Axboe6d048f52007-04-25 12:44:27 +02002707static void cfq_arm_slice_timer(struct cfq_data *cfqd)
Jens Axboe22e2c502005-06-27 10:55:12 +02002708{
Jens Axboe17926692007-01-19 11:59:30 +11002709 struct cfq_queue *cfqq = cfqd->active_queue;
Tejun Heoc5869802011-12-14 00:33:41 +01002710 struct cfq_io_cq *cic;
Vivek Goyal80bdf0c2010-08-23 12:24:26 +02002711 unsigned long sl, group_idle = 0;
Jens Axboe7b14e3b2006-02-28 09:35:11 +01002712
Jens Axboea68bbdd2008-09-24 13:03:33 +02002713 /*
Jens Axboef7d7b7a2008-09-25 11:37:50 +02002714 * SSD device without seek penalty, disable idling. But only do so
2715 * for devices that support queuing, otherwise we still have a problem
2716 * with sync vs async workloads.
Jens Axboea68bbdd2008-09-24 13:03:33 +02002717 */
Jens Axboef7d7b7a2008-09-25 11:37:50 +02002718 if (blk_queue_nonrot(cfqd->queue) && cfqd->hw_tag)
Jens Axboea68bbdd2008-09-24 13:03:33 +02002719 return;
2720
Jens Axboedd67d052006-06-21 09:36:18 +02002721 WARN_ON(!RB_EMPTY_ROOT(&cfqq->sort_list));
Jens Axboe6d048f52007-04-25 12:44:27 +02002722 WARN_ON(cfq_cfqq_slice_new(cfqq));
Jens Axboe22e2c502005-06-27 10:55:12 +02002723
2724 /*
2725 * idle is disabled, either manually or by past process history
2726 */
Vivek Goyal80bdf0c2010-08-23 12:24:26 +02002727 if (!cfq_should_idle(cfqd, cfqq)) {
2728 /* no queue idling. Check for group idling */
2729 if (cfqd->cfq_group_idle)
2730 group_idle = cfqd->cfq_group_idle;
2731 else
2732 return;
2733 }
Jens Axboe6d048f52007-04-25 12:44:27 +02002734
Jens Axboe22e2c502005-06-27 10:55:12 +02002735 /*
Corrado Zoccolo8e550632009-11-26 10:02:58 +01002736 * still active requests from this queue, don't idle
Jens Axboe7b679132008-05-30 12:23:07 +02002737 */
Corrado Zoccolo8e550632009-11-26 10:02:58 +01002738 if (cfqq->dispatched)
Jens Axboe7b679132008-05-30 12:23:07 +02002739 return;
2740
2741 /*
Jens Axboe22e2c502005-06-27 10:55:12 +02002742 * task has exited, don't wait
2743 */
Jens Axboe206dc692006-03-28 13:03:44 +02002744 cic = cfqd->active_cic;
Tejun Heof6e8d012012-03-05 13:15:26 -08002745 if (!cic || !atomic_read(&cic->icq.ioc->active_ref))
Jens Axboe6d048f52007-04-25 12:44:27 +02002746 return;
2747
Corrado Zoccolo355b6592009-10-08 08:43:32 +02002748 /*
2749 * If our average think time is larger than the remaining time
2750 * slice, then don't idle. This avoids overrunning the allotted
2751 * time slice.
2752 */
Shaohua Li383cd722011-07-12 14:24:35 +02002753 if (sample_valid(cic->ttime.ttime_samples) &&
2754 (cfqq->slice_end - jiffies < cic->ttime.ttime_mean)) {
Joe Perchesfd16d262011-06-13 10:42:49 +02002755 cfq_log_cfqq(cfqd, cfqq, "Not idling. think_time:%lu",
Shaohua Li383cd722011-07-12 14:24:35 +02002756 cic->ttime.ttime_mean);
Corrado Zoccolo355b6592009-10-08 08:43:32 +02002757 return;
Divyesh Shahb1ffe732010-03-25 15:45:03 +01002758 }
Corrado Zoccolo355b6592009-10-08 08:43:32 +02002759
Vivek Goyal80bdf0c2010-08-23 12:24:26 +02002760 /* There are other queues in the group, don't do group idle */
2761 if (group_idle && cfqq->cfqg->nr_cfqq > 1)
2762 return;
2763
Jens Axboe3b181522005-06-27 10:56:24 +02002764 cfq_mark_cfqq_wait_request(cfqq);
Jens Axboe22e2c502005-06-27 10:55:12 +02002765
Vivek Goyal80bdf0c2010-08-23 12:24:26 +02002766 if (group_idle)
2767 sl = cfqd->cfq_group_idle;
2768 else
2769 sl = cfqd->cfq_slice_idle;
Jens Axboe206dc692006-03-28 13:03:44 +02002770
Jens Axboe7b14e3b2006-02-28 09:35:11 +01002771 mod_timer(&cfqd->idle_slice_timer, jiffies + sl);
Tejun Heo155fead2012-04-01 14:38:44 -07002772 cfqg_stats_set_start_idle_time(cfqq->cfqg);
Vivek Goyal80bdf0c2010-08-23 12:24:26 +02002773 cfq_log_cfqq(cfqd, cfqq, "arm_idle: %lu group_idle: %d", sl,
2774 group_idle ? 1 : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002775}
2776
Jens Axboe498d3aa22007-04-26 12:54:48 +02002777/*
2778 * Move request from internal lists to the request queue dispatch list.
2779 */
Jens Axboe165125e2007-07-24 09:28:11 +02002780static void cfq_dispatch_insert(struct request_queue *q, struct request *rq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002781{
Jens Axboe3ed9a292007-04-23 08:33:33 +02002782 struct cfq_data *cfqd = q->elevator->elevator_data;
Jens Axboe5e705372006-07-13 12:39:25 +02002783 struct cfq_queue *cfqq = RQ_CFQQ(rq);
Jens Axboe22e2c502005-06-27 10:55:12 +02002784
Jens Axboe7b679132008-05-30 12:23:07 +02002785 cfq_log_cfqq(cfqd, cfqq, "dispatch_insert");
2786
Jeff Moyer06d21882009-09-11 17:08:59 +02002787 cfqq->next_rq = cfq_find_next_rq(cfqd, cfqq, rq);
Jens Axboe5380a102006-07-13 12:37:56 +02002788 cfq_remove_request(rq);
Jens Axboe6d048f52007-04-25 12:44:27 +02002789 cfqq->dispatched++;
Vivek Goyal80bdf0c2010-08-23 12:24:26 +02002790 (RQ_CFQG(rq))->dispatched++;
Jens Axboe5380a102006-07-13 12:37:56 +02002791 elv_dispatch_sort(q, rq);
Jens Axboe3ed9a292007-04-23 08:33:33 +02002792
Corrado Zoccolo53c583d2010-02-28 19:45:05 +01002793 cfqd->rq_in_flight[cfq_cfqq_sync(cfqq)]++;
Vivek Goyalc4e78932010-08-23 12:25:03 +02002794 cfqq->nr_sectors += blk_rq_sectors(rq);
Tejun Heo155fead2012-04-01 14:38:44 -07002795 cfqg_stats_update_dispatch(cfqq->cfqg, blk_rq_bytes(rq), rq->cmd_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002796}
2797
2798/*
2799 * return expired entry, or NULL to just start from scratch in rbtree
2800 */
Jens Axboefebffd62008-01-28 13:19:43 +01002801static struct request *cfq_check_fifo(struct cfq_queue *cfqq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002802{
Jens Axboe30996f42009-10-05 11:03:39 +02002803 struct request *rq = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002804
Jens Axboe3b181522005-06-27 10:56:24 +02002805 if (cfq_cfqq_fifo_expire(cfqq))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002806 return NULL;
Jens Axboecb887412007-01-19 12:01:16 +11002807
2808 cfq_mark_cfqq_fifo_expire(cfqq);
2809
Jens Axboe89850f72006-07-22 16:48:31 +02002810 if (list_empty(&cfqq->fifo))
2811 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002812
Jens Axboe89850f72006-07-22 16:48:31 +02002813 rq = rq_entry_fifo(cfqq->fifo.next);
Jan Kara8b4922d2014-02-24 16:39:52 +01002814 if (time_before(jiffies, rq->fifo_time))
Jens Axboe7b679132008-05-30 12:23:07 +02002815 rq = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002816
Jens Axboe30996f42009-10-05 11:03:39 +02002817 cfq_log_cfqq(cfqq->cfqd, cfqq, "fifo=%p", rq);
Jens Axboe6d048f52007-04-25 12:44:27 +02002818 return rq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002819}
2820
Jens Axboe22e2c502005-06-27 10:55:12 +02002821static inline int
2822cfq_prio_to_maxrq(struct cfq_data *cfqd, struct cfq_queue *cfqq)
2823{
2824 const int base_rq = cfqd->cfq_slice_async_rq;
2825
2826 WARN_ON(cfqq->ioprio >= IOPRIO_BE_NR);
2827
Namhyung Kimb9f8ce02011-05-24 10:23:21 +02002828 return 2 * base_rq * (IOPRIO_BE_NR - cfqq->ioprio);
Jens Axboe22e2c502005-06-27 10:55:12 +02002829}
2830
2831/*
Jeff Moyerdf5fe3e2009-10-23 17:14:50 -04002832 * Must be called with the queue_lock held.
2833 */
2834static int cfqq_process_refs(struct cfq_queue *cfqq)
2835{
2836 int process_refs, io_refs;
2837
2838 io_refs = cfqq->allocated[READ] + cfqq->allocated[WRITE];
Shaohua Li30d7b942011-01-07 08:46:59 +01002839 process_refs = cfqq->ref - io_refs;
Jeff Moyerdf5fe3e2009-10-23 17:14:50 -04002840 BUG_ON(process_refs < 0);
2841 return process_refs;
2842}
2843
2844static void cfq_setup_merge(struct cfq_queue *cfqq, struct cfq_queue *new_cfqq)
2845{
Jeff Moyere6c5bc72009-10-23 17:14:52 -04002846 int process_refs, new_process_refs;
Jeff Moyerdf5fe3e2009-10-23 17:14:50 -04002847 struct cfq_queue *__cfqq;
2848
Jeff Moyerc10b61f2010-06-17 10:19:11 -04002849 /*
2850 * If there are no process references on the new_cfqq, then it is
2851 * unsafe to follow the ->new_cfqq chain as other cfqq's in the
2852 * chain may have dropped their last reference (not just their
2853 * last process reference).
2854 */
2855 if (!cfqq_process_refs(new_cfqq))
2856 return;
2857
Jeff Moyerdf5fe3e2009-10-23 17:14:50 -04002858 /* Avoid a circular list and skip interim queue merges */
2859 while ((__cfqq = new_cfqq->new_cfqq)) {
2860 if (__cfqq == cfqq)
2861 return;
2862 new_cfqq = __cfqq;
2863 }
2864
2865 process_refs = cfqq_process_refs(cfqq);
Jeff Moyerc10b61f2010-06-17 10:19:11 -04002866 new_process_refs = cfqq_process_refs(new_cfqq);
Jeff Moyerdf5fe3e2009-10-23 17:14:50 -04002867 /*
2868 * If the process for the cfqq has gone away, there is no
2869 * sense in merging the queues.
2870 */
Jeff Moyerc10b61f2010-06-17 10:19:11 -04002871 if (process_refs == 0 || new_process_refs == 0)
Jeff Moyerdf5fe3e2009-10-23 17:14:50 -04002872 return;
2873
Jeff Moyere6c5bc72009-10-23 17:14:52 -04002874 /*
2875 * Merge in the direction of the lesser amount of work.
2876 */
Jeff Moyere6c5bc72009-10-23 17:14:52 -04002877 if (new_process_refs >= process_refs) {
2878 cfqq->new_cfqq = new_cfqq;
Shaohua Li30d7b942011-01-07 08:46:59 +01002879 new_cfqq->ref += process_refs;
Jeff Moyere6c5bc72009-10-23 17:14:52 -04002880 } else {
2881 new_cfqq->new_cfqq = cfqq;
Shaohua Li30d7b942011-01-07 08:46:59 +01002882 cfqq->ref += new_process_refs;
Jeff Moyere6c5bc72009-10-23 17:14:52 -04002883 }
Jeff Moyerdf5fe3e2009-10-23 17:14:50 -04002884}
2885
Vivek Goyal6d816ec2012-10-03 16:56:59 -04002886static enum wl_type_t cfq_choose_wl_type(struct cfq_data *cfqd,
Vivek Goyal3bf10fe2012-10-03 16:56:56 -04002887 struct cfq_group *cfqg, enum wl_class_t wl_class)
Corrado Zoccolo718eee02009-10-26 22:45:29 +01002888{
2889 struct cfq_queue *queue;
2890 int i;
2891 bool key_valid = false;
2892 unsigned long lowest_key = 0;
2893 enum wl_type_t cur_best = SYNC_NOIDLE_WORKLOAD;
2894
Vivek Goyal65b32a52009-12-16 17:52:59 -05002895 for (i = 0; i <= SYNC_WORKLOAD; ++i) {
2896 /* select the one with lowest rb_key */
Vivek Goyal34b98d02012-10-03 16:56:58 -04002897 queue = cfq_rb_first(st_for(cfqg, wl_class, i));
Corrado Zoccolo718eee02009-10-26 22:45:29 +01002898 if (queue &&
2899 (!key_valid || time_before(queue->rb_key, lowest_key))) {
2900 lowest_key = queue->rb_key;
2901 cur_best = i;
2902 key_valid = true;
2903 }
2904 }
2905
2906 return cur_best;
2907}
2908
Vivek Goyal6d816ec2012-10-03 16:56:59 -04002909static void
2910choose_wl_class_and_type(struct cfq_data *cfqd, struct cfq_group *cfqg)
Corrado Zoccolo718eee02009-10-26 22:45:29 +01002911{
Corrado Zoccolo718eee02009-10-26 22:45:29 +01002912 unsigned slice;
2913 unsigned count;
Vivek Goyalcdb16e82009-12-03 12:59:38 -05002914 struct cfq_rb_root *st;
Vivek Goyal58ff82f2009-12-03 12:59:44 -05002915 unsigned group_slice;
Vivek Goyal4d2ceea2012-10-03 16:56:57 -04002916 enum wl_class_t original_class = cfqd->serving_wl_class;
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -05002917
Corrado Zoccolo718eee02009-10-26 22:45:29 +01002918 /* Choose next priority. RT > BE > IDLE */
Vivek Goyal58ff82f2009-12-03 12:59:44 -05002919 if (cfq_group_busy_queues_wl(RT_WORKLOAD, cfqd, cfqg))
Vivek Goyal4d2ceea2012-10-03 16:56:57 -04002920 cfqd->serving_wl_class = RT_WORKLOAD;
Vivek Goyal58ff82f2009-12-03 12:59:44 -05002921 else if (cfq_group_busy_queues_wl(BE_WORKLOAD, cfqd, cfqg))
Vivek Goyal4d2ceea2012-10-03 16:56:57 -04002922 cfqd->serving_wl_class = BE_WORKLOAD;
Corrado Zoccolo718eee02009-10-26 22:45:29 +01002923 else {
Vivek Goyal4d2ceea2012-10-03 16:56:57 -04002924 cfqd->serving_wl_class = IDLE_WORKLOAD;
Corrado Zoccolo718eee02009-10-26 22:45:29 +01002925 cfqd->workload_expires = jiffies + 1;
2926 return;
2927 }
2928
Vivek Goyal4d2ceea2012-10-03 16:56:57 -04002929 if (original_class != cfqd->serving_wl_class)
Shaohua Li writese4ea0c12010-12-13 14:32:22 +01002930 goto new_workload;
2931
Corrado Zoccolo718eee02009-10-26 22:45:29 +01002932 /*
2933 * For RT and BE, we have to choose also the type
2934 * (SYNC, SYNC_NOIDLE, ASYNC), and to compute a workload
2935 * expiration time
2936 */
Vivek Goyal34b98d02012-10-03 16:56:58 -04002937 st = st_for(cfqg, cfqd->serving_wl_class, cfqd->serving_wl_type);
Vivek Goyalcdb16e82009-12-03 12:59:38 -05002938 count = st->count;
Corrado Zoccolo718eee02009-10-26 22:45:29 +01002939
2940 /*
Vivek Goyal65b32a52009-12-16 17:52:59 -05002941 * check workload expiration, and that we still have other queues ready
Corrado Zoccolo718eee02009-10-26 22:45:29 +01002942 */
Vivek Goyal65b32a52009-12-16 17:52:59 -05002943 if (count && !time_after(jiffies, cfqd->workload_expires))
Corrado Zoccolo718eee02009-10-26 22:45:29 +01002944 return;
2945
Shaohua Li writese4ea0c12010-12-13 14:32:22 +01002946new_workload:
Corrado Zoccolo718eee02009-10-26 22:45:29 +01002947 /* otherwise select new workload type */
Vivek Goyal6d816ec2012-10-03 16:56:59 -04002948 cfqd->serving_wl_type = cfq_choose_wl_type(cfqd, cfqg,
Vivek Goyal4d2ceea2012-10-03 16:56:57 -04002949 cfqd->serving_wl_class);
Vivek Goyal34b98d02012-10-03 16:56:58 -04002950 st = st_for(cfqg, cfqd->serving_wl_class, cfqd->serving_wl_type);
Vivek Goyalcdb16e82009-12-03 12:59:38 -05002951 count = st->count;
Corrado Zoccolo718eee02009-10-26 22:45:29 +01002952
2953 /*
2954 * the workload slice is computed as a fraction of target latency
2955 * proportional to the number of queues in that workload, over
2956 * all the queues in the same priority class
2957 */
Vivek Goyal58ff82f2009-12-03 12:59:44 -05002958 group_slice = cfq_group_slice(cfqd, cfqg);
2959
2960 slice = group_slice * count /
Vivek Goyal4d2ceea2012-10-03 16:56:57 -04002961 max_t(unsigned, cfqg->busy_queues_avg[cfqd->serving_wl_class],
2962 cfq_group_busy_queues_wl(cfqd->serving_wl_class, cfqd,
Vivek Goyal3bf10fe2012-10-03 16:56:56 -04002963 cfqg));
Corrado Zoccolo718eee02009-10-26 22:45:29 +01002964
Vivek Goyal4d2ceea2012-10-03 16:56:57 -04002965 if (cfqd->serving_wl_type == ASYNC_WORKLOAD) {
Vivek Goyalf26bd1f2009-12-03 12:59:54 -05002966 unsigned int tmp;
2967
2968 /*
2969 * Async queues are currently system wide. Just taking
2970 * proportion of queues with-in same group will lead to higher
2971 * async ratio system wide as generally root group is going
2972 * to have higher weight. A more accurate thing would be to
2973 * calculate system wide asnc/sync ratio.
2974 */
Tao Ma5bf14c02012-04-01 14:33:39 -07002975 tmp = cfqd->cfq_target_latency *
2976 cfqg_busy_async_queues(cfqd, cfqg);
Vivek Goyalf26bd1f2009-12-03 12:59:54 -05002977 tmp = tmp/cfqd->busy_queues;
2978 slice = min_t(unsigned, slice, tmp);
2979
Corrado Zoccolo718eee02009-10-26 22:45:29 +01002980 /* async workload slice is scaled down according to
2981 * the sync/async slice ratio. */
2982 slice = slice * cfqd->cfq_slice[0] / cfqd->cfq_slice[1];
Vivek Goyalf26bd1f2009-12-03 12:59:54 -05002983 } else
Corrado Zoccolo718eee02009-10-26 22:45:29 +01002984 /* sync workload slice is at least 2 * cfq_slice_idle */
2985 slice = max(slice, 2 * cfqd->cfq_slice_idle);
2986
2987 slice = max_t(unsigned, slice, CFQ_MIN_TT);
Divyesh Shahb1ffe732010-03-25 15:45:03 +01002988 cfq_log(cfqd, "workload slice:%d", slice);
Corrado Zoccolo718eee02009-10-26 22:45:29 +01002989 cfqd->workload_expires = jiffies + slice;
2990}
2991
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -05002992static struct cfq_group *cfq_get_next_cfqg(struct cfq_data *cfqd)
2993{
2994 struct cfq_rb_root *st = &cfqd->grp_service_tree;
Vivek Goyal25bc6b02009-12-03 12:59:43 -05002995 struct cfq_group *cfqg;
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -05002996
2997 if (RB_EMPTY_ROOT(&st->rb))
2998 return NULL;
Vivek Goyal25bc6b02009-12-03 12:59:43 -05002999 cfqg = cfq_rb_first_group(st);
Vivek Goyal25bc6b02009-12-03 12:59:43 -05003000 update_min_vdisktime(st);
3001 return cfqg;
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -05003002}
3003
Vivek Goyalcdb16e82009-12-03 12:59:38 -05003004static void cfq_choose_cfqg(struct cfq_data *cfqd)
3005{
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -05003006 struct cfq_group *cfqg = cfq_get_next_cfqg(cfqd);
3007
3008 cfqd->serving_group = cfqg;
Vivek Goyaldae739e2009-12-03 12:59:45 -05003009
3010 /* Restore the workload type data */
Vivek Goyal4d2ceea2012-10-03 16:56:57 -04003011 if (cfqg->saved_wl_slice) {
3012 cfqd->workload_expires = jiffies + cfqg->saved_wl_slice;
3013 cfqd->serving_wl_type = cfqg->saved_wl_type;
3014 cfqd->serving_wl_class = cfqg->saved_wl_class;
Gui Jianfeng66ae2912009-12-15 10:08:45 +01003015 } else
3016 cfqd->workload_expires = jiffies - 1;
3017
Vivek Goyal6d816ec2012-10-03 16:56:59 -04003018 choose_wl_class_and_type(cfqd, cfqg);
Vivek Goyalcdb16e82009-12-03 12:59:38 -05003019}
3020
Jeff Moyerdf5fe3e2009-10-23 17:14:50 -04003021/*
Jens Axboe498d3aa22007-04-26 12:54:48 +02003022 * Select a queue for service. If we have a current active queue,
3023 * check whether to continue servicing it, or retrieve and set a new one.
Jens Axboe22e2c502005-06-27 10:55:12 +02003024 */
Tejun Heo1b5ed5e12005-11-10 08:49:19 +01003025static struct cfq_queue *cfq_select_queue(struct cfq_data *cfqd)
Jens Axboe22e2c502005-06-27 10:55:12 +02003026{
Jens Axboea36e71f2009-04-15 12:15:11 +02003027 struct cfq_queue *cfqq, *new_cfqq = NULL;
Jens Axboe22e2c502005-06-27 10:55:12 +02003028
3029 cfqq = cfqd->active_queue;
3030 if (!cfqq)
3031 goto new_queue;
3032
Vivek Goyalf04a6422009-12-03 12:59:40 -05003033 if (!cfqd->rq_queued)
3034 return NULL;
Vivek Goyalc244bb52009-12-08 17:52:57 -05003035
3036 /*
3037 * We were waiting for group to get backlogged. Expire the queue
3038 */
3039 if (cfq_cfqq_wait_busy(cfqq) && !RB_EMPTY_ROOT(&cfqq->sort_list))
3040 goto expire;
3041
Jens Axboe22e2c502005-06-27 10:55:12 +02003042 /*
Jens Axboe6d048f52007-04-25 12:44:27 +02003043 * The active queue has run out of time, expire it and select new.
Jens Axboe22e2c502005-06-27 10:55:12 +02003044 */
Vivek Goyal7667aa02009-12-08 17:52:58 -05003045 if (cfq_slice_used(cfqq) && !cfq_cfqq_must_dispatch(cfqq)) {
3046 /*
3047 * If slice had not expired at the completion of last request
3048 * we might not have turned on wait_busy flag. Don't expire
3049 * the queue yet. Allow the group to get backlogged.
3050 *
3051 * The very fact that we have used the slice, that means we
3052 * have been idling all along on this queue and it should be
3053 * ok to wait for this request to complete.
3054 */
Vivek Goyal82bbbf22009-12-10 19:25:41 +01003055 if (cfqq->cfqg->nr_cfqq == 1 && RB_EMPTY_ROOT(&cfqq->sort_list)
3056 && cfqq->dispatched && cfq_should_idle(cfqd, cfqq)) {
3057 cfqq = NULL;
Vivek Goyal7667aa02009-12-08 17:52:58 -05003058 goto keep_queue;
Vivek Goyal82bbbf22009-12-10 19:25:41 +01003059 } else
Vivek Goyal80bdf0c2010-08-23 12:24:26 +02003060 goto check_group_idle;
Vivek Goyal7667aa02009-12-08 17:52:58 -05003061 }
Jens Axboe22e2c502005-06-27 10:55:12 +02003062
3063 /*
Jens Axboe6d048f52007-04-25 12:44:27 +02003064 * The active queue has requests and isn't expired, allow it to
3065 * dispatch.
Jens Axboe22e2c502005-06-27 10:55:12 +02003066 */
Jens Axboedd67d052006-06-21 09:36:18 +02003067 if (!RB_EMPTY_ROOT(&cfqq->sort_list))
Jens Axboe22e2c502005-06-27 10:55:12 +02003068 goto keep_queue;
Jens Axboe6d048f52007-04-25 12:44:27 +02003069
3070 /*
Jens Axboea36e71f2009-04-15 12:15:11 +02003071 * If another queue has a request waiting within our mean seek
3072 * distance, let it run. The expire code will check for close
3073 * cooperators and put the close queue at the front of the service
Jeff Moyerdf5fe3e2009-10-23 17:14:50 -04003074 * tree. If possible, merge the expiring queue with the new cfqq.
Jens Axboea36e71f2009-04-15 12:15:11 +02003075 */
Jeff Moyerb3b6d042009-10-23 17:14:51 -04003076 new_cfqq = cfq_close_cooperator(cfqd, cfqq);
Jeff Moyerdf5fe3e2009-10-23 17:14:50 -04003077 if (new_cfqq) {
3078 if (!cfqq->new_cfqq)
3079 cfq_setup_merge(cfqq, new_cfqq);
Jens Axboea36e71f2009-04-15 12:15:11 +02003080 goto expire;
Jeff Moyerdf5fe3e2009-10-23 17:14:50 -04003081 }
Jens Axboea36e71f2009-04-15 12:15:11 +02003082
3083 /*
Jens Axboe6d048f52007-04-25 12:44:27 +02003084 * No requests pending. If the active queue still has requests in
3085 * flight or is idling for a new request, allow either of these
3086 * conditions to happen (or time out) before selecting a new queue.
3087 */
Vivek Goyal80bdf0c2010-08-23 12:24:26 +02003088 if (timer_pending(&cfqd->idle_slice_timer)) {
3089 cfqq = NULL;
3090 goto keep_queue;
3091 }
3092
Shaohua Li8e1ac662010-11-08 15:01:04 +01003093 /*
3094 * This is a deep seek queue, but the device is much faster than
3095 * the queue can deliver, don't idle
3096 **/
3097 if (CFQQ_SEEKY(cfqq) && cfq_cfqq_idle_window(cfqq) &&
3098 (cfq_cfqq_slice_new(cfqq) ||
3099 (cfqq->slice_end - jiffies > jiffies - cfqq->slice_start))) {
3100 cfq_clear_cfqq_deep(cfqq);
3101 cfq_clear_cfqq_idle_window(cfqq);
3102 }
3103
Vivek Goyal80bdf0c2010-08-23 12:24:26 +02003104 if (cfqq->dispatched && cfq_should_idle(cfqd, cfqq)) {
3105 cfqq = NULL;
3106 goto keep_queue;
3107 }
3108
3109 /*
3110 * If group idle is enabled and there are requests dispatched from
3111 * this group, wait for requests to complete.
3112 */
3113check_group_idle:
Shaohua Li7700fc42011-07-12 14:24:56 +02003114 if (cfqd->cfq_group_idle && cfqq->cfqg->nr_cfqq == 1 &&
3115 cfqq->cfqg->dispatched &&
3116 !cfq_io_thinktime_big(cfqd, &cfqq->cfqg->ttime, true)) {
Jens Axboecaaa5f92006-06-16 11:23:00 +02003117 cfqq = NULL;
3118 goto keep_queue;
Jens Axboe22e2c502005-06-27 10:55:12 +02003119 }
3120
Jens Axboe3b181522005-06-27 10:56:24 +02003121expire:
Vivek Goyale5ff0822010-04-26 19:25:11 +02003122 cfq_slice_expired(cfqd, 0);
Jens Axboe3b181522005-06-27 10:56:24 +02003123new_queue:
Corrado Zoccolo718eee02009-10-26 22:45:29 +01003124 /*
3125 * Current queue expired. Check if we have to switch to a new
3126 * service tree
3127 */
3128 if (!new_cfqq)
Vivek Goyalcdb16e82009-12-03 12:59:38 -05003129 cfq_choose_cfqg(cfqd);
Corrado Zoccolo718eee02009-10-26 22:45:29 +01003130
Jens Axboea36e71f2009-04-15 12:15:11 +02003131 cfqq = cfq_set_active_queue(cfqd, new_cfqq);
Jens Axboe22e2c502005-06-27 10:55:12 +02003132keep_queue:
Jens Axboe3b181522005-06-27 10:56:24 +02003133 return cfqq;
Jens Axboe22e2c502005-06-27 10:55:12 +02003134}
3135
Jens Axboefebffd62008-01-28 13:19:43 +01003136static int __cfq_forced_dispatch_cfqq(struct cfq_queue *cfqq)
Jens Axboed9e76202007-04-20 14:27:50 +02003137{
3138 int dispatched = 0;
3139
3140 while (cfqq->next_rq) {
3141 cfq_dispatch_insert(cfqq->cfqd->queue, cfqq->next_rq);
3142 dispatched++;
3143 }
3144
3145 BUG_ON(!list_empty(&cfqq->fifo));
Vivek Goyalf04a6422009-12-03 12:59:40 -05003146
3147 /* By default cfqq is not expired if it is empty. Do it explicitly */
Vivek Goyale5ff0822010-04-26 19:25:11 +02003148 __cfq_slice_expired(cfqq->cfqd, cfqq, 0);
Jens Axboed9e76202007-04-20 14:27:50 +02003149 return dispatched;
3150}
3151
Jens Axboe498d3aa22007-04-26 12:54:48 +02003152/*
3153 * Drain our current requests. Used for barriers and when switching
3154 * io schedulers on-the-fly.
3155 */
Jens Axboed9e76202007-04-20 14:27:50 +02003156static int cfq_forced_dispatch(struct cfq_data *cfqd)
Tejun Heo1b5ed5e12005-11-10 08:49:19 +01003157{
Jens Axboe08717142008-01-28 11:38:15 +01003158 struct cfq_queue *cfqq;
Jens Axboed9e76202007-04-20 14:27:50 +02003159 int dispatched = 0;
Vivek Goyalcdb16e82009-12-03 12:59:38 -05003160
Divyesh Shah3440c492010-04-09 09:29:57 +02003161 /* Expire the timeslice of the current active queue first */
Vivek Goyale5ff0822010-04-26 19:25:11 +02003162 cfq_slice_expired(cfqd, 0);
Divyesh Shah3440c492010-04-09 09:29:57 +02003163 while ((cfqq = cfq_get_next_queue_forced(cfqd)) != NULL) {
3164 __cfq_set_active_queue(cfqd, cfqq);
Vivek Goyalf04a6422009-12-03 12:59:40 -05003165 dispatched += __cfq_forced_dispatch_cfqq(cfqq);
Divyesh Shah3440c492010-04-09 09:29:57 +02003166 }
Tejun Heo1b5ed5e12005-11-10 08:49:19 +01003167
Tejun Heo1b5ed5e12005-11-10 08:49:19 +01003168 BUG_ON(cfqd->busy_queues);
3169
Jeff Moyer69237152009-06-12 15:29:30 +02003170 cfq_log(cfqd, "forced_dispatch=%d", dispatched);
Tejun Heo1b5ed5e12005-11-10 08:49:19 +01003171 return dispatched;
3172}
3173
Shaohua Liabc3c742010-03-01 09:20:54 +01003174static inline bool cfq_slice_used_soon(struct cfq_data *cfqd,
3175 struct cfq_queue *cfqq)
3176{
3177 /* the queue hasn't finished any request, can't estimate */
3178 if (cfq_cfqq_slice_new(cfqq))
Shaohua Lic1e44752010-11-08 15:01:02 +01003179 return true;
Shaohua Liabc3c742010-03-01 09:20:54 +01003180 if (time_after(jiffies + cfqd->cfq_slice_idle * cfqq->dispatched,
3181 cfqq->slice_end))
Shaohua Lic1e44752010-11-08 15:01:02 +01003182 return true;
Shaohua Liabc3c742010-03-01 09:20:54 +01003183
Shaohua Lic1e44752010-11-08 15:01:02 +01003184 return false;
Shaohua Liabc3c742010-03-01 09:20:54 +01003185}
3186
Jens Axboe0b182d62009-10-06 20:49:37 +02003187static bool cfq_may_dispatch(struct cfq_data *cfqd, struct cfq_queue *cfqq)
Jens Axboe2f5cb732009-04-07 08:51:19 +02003188{
Jens Axboe2f5cb732009-04-07 08:51:19 +02003189 unsigned int max_dispatch;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003190
Jens Axboe2f5cb732009-04-07 08:51:19 +02003191 /*
Jens Axboe5ad531d2009-07-03 12:57:48 +02003192 * Drain async requests before we start sync IO
3193 */
Corrado Zoccolo53c583d2010-02-28 19:45:05 +01003194 if (cfq_should_idle(cfqd, cfqq) && cfqd->rq_in_flight[BLK_RW_ASYNC])
Jens Axboe0b182d62009-10-06 20:49:37 +02003195 return false;
Jens Axboe5ad531d2009-07-03 12:57:48 +02003196
3197 /*
Jens Axboe2f5cb732009-04-07 08:51:19 +02003198 * If this is an async queue and we have sync IO in flight, let it wait
3199 */
Corrado Zoccolo53c583d2010-02-28 19:45:05 +01003200 if (cfqd->rq_in_flight[BLK_RW_SYNC] && !cfq_cfqq_sync(cfqq))
Jens Axboe0b182d62009-10-06 20:49:37 +02003201 return false;
Jens Axboe2f5cb732009-04-07 08:51:19 +02003202
Shaohua Liabc3c742010-03-01 09:20:54 +01003203 max_dispatch = max_t(unsigned int, cfqd->cfq_quantum / 2, 1);
Jens Axboe2f5cb732009-04-07 08:51:19 +02003204 if (cfq_class_idle(cfqq))
3205 max_dispatch = 1;
3206
3207 /*
3208 * Does this cfqq already have too much IO in flight?
3209 */
3210 if (cfqq->dispatched >= max_dispatch) {
Shaohua Lief8a41d2011-03-07 09:26:29 +01003211 bool promote_sync = false;
Jens Axboe2f5cb732009-04-07 08:51:19 +02003212 /*
3213 * idle queue must always only have a single IO in flight
3214 */
Jens Axboe3ed9a292007-04-23 08:33:33 +02003215 if (cfq_class_idle(cfqq))
Jens Axboe0b182d62009-10-06 20:49:37 +02003216 return false;
Jens Axboe3ed9a292007-04-23 08:33:33 +02003217
Jens Axboe2f5cb732009-04-07 08:51:19 +02003218 /*
Li, Shaohuac4ade942011-03-23 08:30:34 +01003219 * If there is only one sync queue
3220 * we can ignore async queue here and give the sync
Shaohua Lief8a41d2011-03-07 09:26:29 +01003221 * queue no dispatch limit. The reason is a sync queue can
3222 * preempt async queue, limiting the sync queue doesn't make
3223 * sense. This is useful for aiostress test.
3224 */
Li, Shaohuac4ade942011-03-23 08:30:34 +01003225 if (cfq_cfqq_sync(cfqq) && cfqd->busy_sync_queues == 1)
3226 promote_sync = true;
Shaohua Lief8a41d2011-03-07 09:26:29 +01003227
3228 /*
Jens Axboe2f5cb732009-04-07 08:51:19 +02003229 * We have other queues, don't allow more IO from this one
3230 */
Shaohua Lief8a41d2011-03-07 09:26:29 +01003231 if (cfqd->busy_queues > 1 && cfq_slice_used_soon(cfqd, cfqq) &&
3232 !promote_sync)
Jens Axboe0b182d62009-10-06 20:49:37 +02003233 return false;
Jens Axboe9ede2092007-01-19 12:11:44 +11003234
Jens Axboe2f5cb732009-04-07 08:51:19 +02003235 /*
Shaohua Li474b18c2009-12-03 12:58:05 +01003236 * Sole queue user, no limit
Vivek Goyal365722b2009-10-03 15:21:27 +02003237 */
Shaohua Lief8a41d2011-03-07 09:26:29 +01003238 if (cfqd->busy_queues == 1 || promote_sync)
Shaohua Liabc3c742010-03-01 09:20:54 +01003239 max_dispatch = -1;
3240 else
3241 /*
3242 * Normally we start throttling cfqq when cfq_quantum/2
3243 * requests have been dispatched. But we can drive
3244 * deeper queue depths at the beginning of slice
3245 * subjected to upper limit of cfq_quantum.
3246 * */
3247 max_dispatch = cfqd->cfq_quantum;
Jens Axboe8e296752009-10-03 16:26:03 +02003248 }
3249
3250 /*
3251 * Async queues must wait a bit before being allowed dispatch.
3252 * We also ramp up the dispatch depth gradually for async IO,
3253 * based on the last sync IO we serviced
3254 */
Jens Axboe963b72f2009-10-03 19:42:18 +02003255 if (!cfq_cfqq_sync(cfqq) && cfqd->cfq_latency) {
Corrado Zoccolo573412b2009-12-06 11:48:52 +01003256 unsigned long last_sync = jiffies - cfqd->last_delayed_sync;
Jens Axboe8e296752009-10-03 16:26:03 +02003257 unsigned int depth;
Vivek Goyal365722b2009-10-03 15:21:27 +02003258
Jens Axboe61f0c1d2009-10-03 19:46:03 +02003259 depth = last_sync / cfqd->cfq_slice[1];
Jens Axboee00c54c2009-10-04 20:36:19 +02003260 if (!depth && !cfqq->dispatched)
3261 depth = 1;
Jens Axboe8e296752009-10-03 16:26:03 +02003262 if (depth < max_dispatch)
3263 max_dispatch = depth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003264 }
3265
Jens Axboe0b182d62009-10-06 20:49:37 +02003266 /*
3267 * If we're below the current max, allow a dispatch
3268 */
3269 return cfqq->dispatched < max_dispatch;
3270}
3271
3272/*
3273 * Dispatch a request from cfqq, moving them to the request queue
3274 * dispatch list.
3275 */
3276static bool cfq_dispatch_request(struct cfq_data *cfqd, struct cfq_queue *cfqq)
3277{
3278 struct request *rq;
3279
3280 BUG_ON(RB_EMPTY_ROOT(&cfqq->sort_list));
3281
3282 if (!cfq_may_dispatch(cfqd, cfqq))
3283 return false;
3284
3285 /*
3286 * follow expired path, else get first next available
3287 */
3288 rq = cfq_check_fifo(cfqq);
3289 if (!rq)
3290 rq = cfqq->next_rq;
3291
3292 /*
3293 * insert request into driver dispatch list
3294 */
3295 cfq_dispatch_insert(cfqd->queue, rq);
3296
3297 if (!cfqd->active_cic) {
Tejun Heoc5869802011-12-14 00:33:41 +01003298 struct cfq_io_cq *cic = RQ_CIC(rq);
Jens Axboe0b182d62009-10-06 20:49:37 +02003299
Tejun Heoc5869802011-12-14 00:33:41 +01003300 atomic_long_inc(&cic->icq.ioc->refcount);
Jens Axboe0b182d62009-10-06 20:49:37 +02003301 cfqd->active_cic = cic;
3302 }
3303
3304 return true;
3305}
3306
3307/*
3308 * Find the cfqq that we need to service and move a request from that to the
3309 * dispatch list
3310 */
3311static int cfq_dispatch_requests(struct request_queue *q, int force)
3312{
3313 struct cfq_data *cfqd = q->elevator->elevator_data;
3314 struct cfq_queue *cfqq;
3315
3316 if (!cfqd->busy_queues)
3317 return 0;
3318
3319 if (unlikely(force))
3320 return cfq_forced_dispatch(cfqd);
3321
3322 cfqq = cfq_select_queue(cfqd);
3323 if (!cfqq)
Jens Axboe8e296752009-10-03 16:26:03 +02003324 return 0;
3325
Jens Axboe2f5cb732009-04-07 08:51:19 +02003326 /*
Jens Axboe0b182d62009-10-06 20:49:37 +02003327 * Dispatch a request from this cfqq, if it is allowed
Jens Axboe2f5cb732009-04-07 08:51:19 +02003328 */
Jens Axboe0b182d62009-10-06 20:49:37 +02003329 if (!cfq_dispatch_request(cfqd, cfqq))
3330 return 0;
3331
Jens Axboe2f5cb732009-04-07 08:51:19 +02003332 cfqq->slice_dispatch++;
Jens Axboeb0291952009-04-07 11:38:31 +02003333 cfq_clear_cfqq_must_dispatch(cfqq);
Jens Axboe2f5cb732009-04-07 08:51:19 +02003334
3335 /*
3336 * expire an async queue immediately if it has used up its slice. idle
3337 * queue always expire after 1 dispatch round.
3338 */
3339 if (cfqd->busy_queues > 1 && ((!cfq_cfqq_sync(cfqq) &&
3340 cfqq->slice_dispatch >= cfq_prio_to_maxrq(cfqd, cfqq)) ||
3341 cfq_class_idle(cfqq))) {
3342 cfqq->slice_end = jiffies + 1;
Vivek Goyale5ff0822010-04-26 19:25:11 +02003343 cfq_slice_expired(cfqd, 0);
Jens Axboe2f5cb732009-04-07 08:51:19 +02003344 }
3345
Shan Weib217a902009-09-01 10:06:42 +02003346 cfq_log_cfqq(cfqd, cfqq, "dispatched a request");
Jens Axboe2f5cb732009-04-07 08:51:19 +02003347 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003348}
3349
Linus Torvalds1da177e2005-04-16 15:20:36 -07003350/*
Jens Axboe5e705372006-07-13 12:39:25 +02003351 * task holds one reference to the queue, dropped when task exits. each rq
3352 * in-flight on this queue also holds a reference, dropped when rq is freed.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003353 *
Vivek Goyalb1c35762009-12-03 12:59:47 -05003354 * Each cfq queue took a reference on the parent group. Drop it now.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003355 * queue lock must be held here.
3356 */
3357static void cfq_put_queue(struct cfq_queue *cfqq)
3358{
Jens Axboe22e2c502005-06-27 10:55:12 +02003359 struct cfq_data *cfqd = cfqq->cfqd;
Justin TerAvest0bbfeb82011-03-01 15:05:08 -05003360 struct cfq_group *cfqg;
Jens Axboe22e2c502005-06-27 10:55:12 +02003361
Shaohua Li30d7b942011-01-07 08:46:59 +01003362 BUG_ON(cfqq->ref <= 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003363
Shaohua Li30d7b942011-01-07 08:46:59 +01003364 cfqq->ref--;
3365 if (cfqq->ref)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003366 return;
3367
Jens Axboe7b679132008-05-30 12:23:07 +02003368 cfq_log_cfqq(cfqd, cfqq, "put_queue");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003369 BUG_ON(rb_first(&cfqq->sort_list));
Jens Axboe22e2c502005-06-27 10:55:12 +02003370 BUG_ON(cfqq->allocated[READ] + cfqq->allocated[WRITE]);
Vivek Goyalb1c35762009-12-03 12:59:47 -05003371 cfqg = cfqq->cfqg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003372
Jens Axboe28f95cbc2007-01-19 12:09:53 +11003373 if (unlikely(cfqd->active_queue == cfqq)) {
Vivek Goyale5ff0822010-04-26 19:25:11 +02003374 __cfq_slice_expired(cfqd, cfqq, 0);
Jens Axboe23e018a2009-10-05 08:52:35 +02003375 cfq_schedule_dispatch(cfqd);
Jens Axboe28f95cbc2007-01-19 12:09:53 +11003376 }
Jens Axboe22e2c502005-06-27 10:55:12 +02003377
Vivek Goyalf04a6422009-12-03 12:59:40 -05003378 BUG_ON(cfq_cfqq_on_rr(cfqq));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003379 kmem_cache_free(cfq_pool, cfqq);
Tejun Heoeb7d8c072012-03-23 14:02:53 +01003380 cfqg_put(cfqg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003381}
3382
Shaohua Lid02a2c02010-05-25 10:16:53 +02003383static void cfq_put_cooperator(struct cfq_queue *cfqq)
Jens Axboe89850f72006-07-22 16:48:31 +02003384{
Jeff Moyerdf5fe3e2009-10-23 17:14:50 -04003385 struct cfq_queue *__cfqq, *next;
3386
Jeff Moyerdf5fe3e2009-10-23 17:14:50 -04003387 /*
3388 * If this queue was scheduled to merge with another queue, be
3389 * sure to drop the reference taken on that queue (and others in
3390 * the merge chain). See cfq_setup_merge and cfq_merge_cfqqs.
3391 */
3392 __cfqq = cfqq->new_cfqq;
3393 while (__cfqq) {
3394 if (__cfqq == cfqq) {
3395 WARN(1, "cfqq->new_cfqq loop detected\n");
3396 break;
3397 }
3398 next = __cfqq->new_cfqq;
3399 cfq_put_queue(__cfqq);
3400 __cfqq = next;
3401 }
Shaohua Lid02a2c02010-05-25 10:16:53 +02003402}
3403
3404static void cfq_exit_cfqq(struct cfq_data *cfqd, struct cfq_queue *cfqq)
3405{
3406 if (unlikely(cfqq == cfqd->active_queue)) {
3407 __cfq_slice_expired(cfqd, cfqq, 0);
3408 cfq_schedule_dispatch(cfqd);
3409 }
3410
3411 cfq_put_cooperator(cfqq);
Jeff Moyerdf5fe3e2009-10-23 17:14:50 -04003412
Jens Axboe89850f72006-07-22 16:48:31 +02003413 cfq_put_queue(cfqq);
3414}
3415
Tejun Heo9b84cac2011-12-14 00:33:42 +01003416static void cfq_init_icq(struct io_cq *icq)
3417{
3418 struct cfq_io_cq *cic = icq_to_cic(icq);
3419
3420 cic->ttime.last_end_request = jiffies;
3421}
3422
Tejun Heoc5869802011-12-14 00:33:41 +01003423static void cfq_exit_icq(struct io_cq *icq)
Jens Axboe89850f72006-07-22 16:48:31 +02003424{
Tejun Heoc5869802011-12-14 00:33:41 +01003425 struct cfq_io_cq *cic = icq_to_cic(icq);
Tejun Heo283287a2011-12-14 00:33:38 +01003426 struct cfq_data *cfqd = cic_to_cfqd(cic);
Fabio Checconi4faa3c82008-04-10 08:28:01 +02003427
Jens Axboeff6657c2009-04-08 10:58:57 +02003428 if (cic->cfqq[BLK_RW_ASYNC]) {
3429 cfq_exit_cfqq(cfqd, cic->cfqq[BLK_RW_ASYNC]);
3430 cic->cfqq[BLK_RW_ASYNC] = NULL;
Jens Axboe89850f72006-07-22 16:48:31 +02003431 }
3432
Jens Axboeff6657c2009-04-08 10:58:57 +02003433 if (cic->cfqq[BLK_RW_SYNC]) {
3434 cfq_exit_cfqq(cfqd, cic->cfqq[BLK_RW_SYNC]);
3435 cic->cfqq[BLK_RW_SYNC] = NULL;
Jens Axboe89850f72006-07-22 16:48:31 +02003436 }
Jens Axboe89850f72006-07-22 16:48:31 +02003437}
3438
Tejun Heoabede6d2012-03-19 15:10:57 -07003439static void cfq_init_prio_data(struct cfq_queue *cfqq, struct cfq_io_cq *cic)
Jens Axboe22e2c502005-06-27 10:55:12 +02003440{
3441 struct task_struct *tsk = current;
3442 int ioprio_class;
3443
Jens Axboe3b181522005-06-27 10:56:24 +02003444 if (!cfq_cfqq_prio_changed(cfqq))
Jens Axboe22e2c502005-06-27 10:55:12 +02003445 return;
3446
Tejun Heo598971b2012-03-19 15:10:58 -07003447 ioprio_class = IOPRIO_PRIO_CLASS(cic->ioprio);
Jens Axboe22e2c502005-06-27 10:55:12 +02003448 switch (ioprio_class) {
Jens Axboefe094d92008-01-31 13:08:54 +01003449 default:
3450 printk(KERN_ERR "cfq: bad prio %x\n", ioprio_class);
3451 case IOPRIO_CLASS_NONE:
3452 /*
Jens Axboe6d63c272008-05-07 09:51:23 +02003453 * no prio set, inherit CPU scheduling settings
Jens Axboefe094d92008-01-31 13:08:54 +01003454 */
3455 cfqq->ioprio = task_nice_ioprio(tsk);
Jens Axboe6d63c272008-05-07 09:51:23 +02003456 cfqq->ioprio_class = task_nice_ioclass(tsk);
Jens Axboefe094d92008-01-31 13:08:54 +01003457 break;
3458 case IOPRIO_CLASS_RT:
Tejun Heo598971b2012-03-19 15:10:58 -07003459 cfqq->ioprio = IOPRIO_PRIO_DATA(cic->ioprio);
Jens Axboefe094d92008-01-31 13:08:54 +01003460 cfqq->ioprio_class = IOPRIO_CLASS_RT;
3461 break;
3462 case IOPRIO_CLASS_BE:
Tejun Heo598971b2012-03-19 15:10:58 -07003463 cfqq->ioprio = IOPRIO_PRIO_DATA(cic->ioprio);
Jens Axboefe094d92008-01-31 13:08:54 +01003464 cfqq->ioprio_class = IOPRIO_CLASS_BE;
3465 break;
3466 case IOPRIO_CLASS_IDLE:
3467 cfqq->ioprio_class = IOPRIO_CLASS_IDLE;
3468 cfqq->ioprio = 7;
3469 cfq_clear_cfqq_idle_window(cfqq);
3470 break;
Jens Axboe22e2c502005-06-27 10:55:12 +02003471 }
3472
3473 /*
3474 * keep track of original prio settings in case we have to temporarily
3475 * elevate the priority of this queue
3476 */
3477 cfqq->org_ioprio = cfqq->ioprio;
Jens Axboe3b181522005-06-27 10:56:24 +02003478 cfq_clear_cfqq_prio_changed(cfqq);
Jens Axboe22e2c502005-06-27 10:55:12 +02003479}
3480
Tejun Heo598971b2012-03-19 15:10:58 -07003481static void check_ioprio_changed(struct cfq_io_cq *cic, struct bio *bio)
Jens Axboe22e2c502005-06-27 10:55:12 +02003482{
Tejun Heo598971b2012-03-19 15:10:58 -07003483 int ioprio = cic->icq.ioc->ioprio;
Konstantin Khlebnikovbca4b912010-05-20 23:21:34 +04003484 struct cfq_data *cfqd = cic_to_cfqd(cic);
Al Viro478a82b2006-03-18 13:25:24 -05003485 struct cfq_queue *cfqq;
Jens Axboe35e60772006-06-14 09:10:45 +02003486
Tejun Heo598971b2012-03-19 15:10:58 -07003487 /*
3488 * Check whether ioprio has changed. The condition may trigger
3489 * spuriously on a newly created cic but there's no harm.
3490 */
3491 if (unlikely(!cfqd) || likely(cic->ioprio == ioprio))
Jens Axboecaaa5f92006-06-16 11:23:00 +02003492 return;
3493
Jens Axboeff6657c2009-04-08 10:58:57 +02003494 cfqq = cic->cfqq[BLK_RW_ASYNC];
Jens Axboecaaa5f92006-06-16 11:23:00 +02003495 if (cfqq) {
3496 struct cfq_queue *new_cfqq;
Tejun Heoabede6d2012-03-19 15:10:57 -07003497 new_cfqq = cfq_get_queue(cfqd, BLK_RW_ASYNC, cic, bio,
3498 GFP_ATOMIC);
Jens Axboecaaa5f92006-06-16 11:23:00 +02003499 if (new_cfqq) {
Jens Axboeff6657c2009-04-08 10:58:57 +02003500 cic->cfqq[BLK_RW_ASYNC] = new_cfqq;
Jens Axboecaaa5f92006-06-16 11:23:00 +02003501 cfq_put_queue(cfqq);
3502 }
Jens Axboe22e2c502005-06-27 10:55:12 +02003503 }
Jens Axboecaaa5f92006-06-16 11:23:00 +02003504
Jens Axboeff6657c2009-04-08 10:58:57 +02003505 cfqq = cic->cfqq[BLK_RW_SYNC];
Jens Axboecaaa5f92006-06-16 11:23:00 +02003506 if (cfqq)
3507 cfq_mark_cfqq_prio_changed(cfqq);
Tejun Heo598971b2012-03-19 15:10:58 -07003508
3509 cic->ioprio = ioprio;
Jens Axboe22e2c502005-06-27 10:55:12 +02003510}
3511
Jens Axboed5036d72009-06-26 10:44:34 +02003512static void cfq_init_cfqq(struct cfq_data *cfqd, struct cfq_queue *cfqq,
Jens Axboea6151c32009-10-07 20:02:57 +02003513 pid_t pid, bool is_sync)
Jens Axboed5036d72009-06-26 10:44:34 +02003514{
3515 RB_CLEAR_NODE(&cfqq->rb_node);
3516 RB_CLEAR_NODE(&cfqq->p_node);
3517 INIT_LIST_HEAD(&cfqq->fifo);
3518
Shaohua Li30d7b942011-01-07 08:46:59 +01003519 cfqq->ref = 0;
Jens Axboed5036d72009-06-26 10:44:34 +02003520 cfqq->cfqd = cfqd;
3521
3522 cfq_mark_cfqq_prio_changed(cfqq);
3523
3524 if (is_sync) {
3525 if (!cfq_class_idle(cfqq))
3526 cfq_mark_cfqq_idle_window(cfqq);
3527 cfq_mark_cfqq_sync(cfqq);
3528 }
3529 cfqq->pid = pid;
3530}
3531
Vivek Goyal246103332009-12-03 12:59:51 -05003532#ifdef CONFIG_CFQ_GROUP_IOSCHED
Tejun Heo598971b2012-03-19 15:10:58 -07003533static void check_blkcg_changed(struct cfq_io_cq *cic, struct bio *bio)
Vivek Goyal246103332009-12-03 12:59:51 -05003534{
Konstantin Khlebnikovbca4b912010-05-20 23:21:34 +04003535 struct cfq_data *cfqd = cic_to_cfqd(cic);
Tejun Heo598971b2012-03-19 15:10:58 -07003536 struct cfq_queue *sync_cfqq;
3537 uint64_t id;
Vivek Goyal246103332009-12-03 12:59:51 -05003538
Tejun Heo598971b2012-03-19 15:10:58 -07003539 rcu_read_lock();
Tejun Heo3c798392012-04-16 13:57:25 -07003540 id = bio_blkcg(bio)->id;
Tejun Heo598971b2012-03-19 15:10:58 -07003541 rcu_read_unlock();
3542
3543 /*
3544 * Check whether blkcg has changed. The condition may trigger
3545 * spuriously on a newly created cic but there's no harm.
3546 */
3547 if (unlikely(!cfqd) || likely(cic->blkcg_id == id))
Vivek Goyal246103332009-12-03 12:59:51 -05003548 return;
3549
Tejun Heo598971b2012-03-19 15:10:58 -07003550 sync_cfqq = cic_to_cfqq(cic, 1);
Vivek Goyal246103332009-12-03 12:59:51 -05003551 if (sync_cfqq) {
3552 /*
3553 * Drop reference to sync queue. A new sync queue will be
3554 * assigned in new group upon arrival of a fresh request.
3555 */
3556 cfq_log_cfqq(cfqd, sync_cfqq, "changed cgroup");
3557 cic_set_cfqq(cic, NULL, 1);
3558 cfq_put_queue(sync_cfqq);
3559 }
Tejun Heo598971b2012-03-19 15:10:58 -07003560
3561 cic->blkcg_id = id;
Vivek Goyal246103332009-12-03 12:59:51 -05003562}
Tejun Heo598971b2012-03-19 15:10:58 -07003563#else
3564static inline void check_blkcg_changed(struct cfq_io_cq *cic, struct bio *bio) { }
Vivek Goyal246103332009-12-03 12:59:51 -05003565#endif /* CONFIG_CFQ_GROUP_IOSCHED */
3566
Linus Torvalds1da177e2005-04-16 15:20:36 -07003567static struct cfq_queue *
Tejun Heoabede6d2012-03-19 15:10:57 -07003568cfq_find_alloc_queue(struct cfq_data *cfqd, bool is_sync, struct cfq_io_cq *cic,
3569 struct bio *bio, gfp_t gfp_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003570{
Tejun Heo3c798392012-04-16 13:57:25 -07003571 struct blkcg *blkcg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003572 struct cfq_queue *cfqq, *new_cfqq = NULL;
Vivek Goyalcdb16e82009-12-03 12:59:38 -05003573 struct cfq_group *cfqg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003574
3575retry:
Tejun Heo2a7f1242012-03-05 13:15:01 -08003576 rcu_read_lock();
3577
Tejun Heo3c798392012-04-16 13:57:25 -07003578 blkcg = bio_blkcg(bio);
Tejun Heocd1604f2012-03-05 13:15:06 -08003579 cfqg = cfq_lookup_create_cfqg(cfqd, blkcg);
Vasily Tarasov91fac312007-04-25 12:29:51 +02003580 cfqq = cic_to_cfqq(cic, is_sync);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003581
Jens Axboe6118b702009-06-30 09:34:12 +02003582 /*
3583 * Always try a new alloc if we fell back to the OOM cfqq
3584 * originally, since it should just be a temporary situation.
3585 */
3586 if (!cfqq || cfqq == &cfqd->oom_cfqq) {
3587 cfqq = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003588 if (new_cfqq) {
3589 cfqq = new_cfqq;
3590 new_cfqq = NULL;
Jens Axboe22e2c502005-06-27 10:55:12 +02003591 } else if (gfp_mask & __GFP_WAIT) {
Tejun Heo2a7f1242012-03-05 13:15:01 -08003592 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003593 spin_unlock_irq(cfqd->queue->queue_lock);
Christoph Lameter94f60302007-07-17 04:03:29 -07003594 new_cfqq = kmem_cache_alloc_node(cfq_pool,
Jens Axboe6118b702009-06-30 09:34:12 +02003595 gfp_mask | __GFP_ZERO,
Christoph Lameter94f60302007-07-17 04:03:29 -07003596 cfqd->queue->node);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003597 spin_lock_irq(cfqd->queue->queue_lock);
Jens Axboe6118b702009-06-30 09:34:12 +02003598 if (new_cfqq)
3599 goto retry;
Glauber Costaa3cc86c2013-02-21 15:16:41 -08003600 else
3601 return &cfqd->oom_cfqq;
Jens Axboe22e2c502005-06-27 10:55:12 +02003602 } else {
Christoph Lameter94f60302007-07-17 04:03:29 -07003603 cfqq = kmem_cache_alloc_node(cfq_pool,
3604 gfp_mask | __GFP_ZERO,
3605 cfqd->queue->node);
Kiyoshi Ueda db3b5842005-06-17 16:15:10 +02003606 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003607
Jens Axboe6118b702009-06-30 09:34:12 +02003608 if (cfqq) {
3609 cfq_init_cfqq(cfqd, cfqq, current->pid, is_sync);
Tejun Heoabede6d2012-03-19 15:10:57 -07003610 cfq_init_prio_data(cfqq, cic);
Vivek Goyalcdb16e82009-12-03 12:59:38 -05003611 cfq_link_cfqq_cfqg(cfqq, cfqg);
Jens Axboe6118b702009-06-30 09:34:12 +02003612 cfq_log_cfqq(cfqd, cfqq, "alloced");
3613 } else
3614 cfqq = &cfqd->oom_cfqq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003615 }
3616
3617 if (new_cfqq)
3618 kmem_cache_free(cfq_pool, new_cfqq);
3619
Tejun Heo2a7f1242012-03-05 13:15:01 -08003620 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003621 return cfqq;
3622}
3623
Vasily Tarasovc2dea2d2007-07-20 10:06:38 +02003624static struct cfq_queue **
3625cfq_async_queue_prio(struct cfq_data *cfqd, int ioprio_class, int ioprio)
3626{
Jens Axboefe094d92008-01-31 13:08:54 +01003627 switch (ioprio_class) {
Vasily Tarasovc2dea2d2007-07-20 10:06:38 +02003628 case IOPRIO_CLASS_RT:
3629 return &cfqd->async_cfqq[0][ioprio];
Tejun Heo598971b2012-03-19 15:10:58 -07003630 case IOPRIO_CLASS_NONE:
3631 ioprio = IOPRIO_NORM;
3632 /* fall through */
Vasily Tarasovc2dea2d2007-07-20 10:06:38 +02003633 case IOPRIO_CLASS_BE:
3634 return &cfqd->async_cfqq[1][ioprio];
3635 case IOPRIO_CLASS_IDLE:
3636 return &cfqd->async_idle_cfqq;
3637 default:
3638 BUG();
3639 }
3640}
3641
Jens Axboe15c31be2007-07-10 13:43:25 +02003642static struct cfq_queue *
Tejun Heoabede6d2012-03-19 15:10:57 -07003643cfq_get_queue(struct cfq_data *cfqd, bool is_sync, struct cfq_io_cq *cic,
Tejun Heo4f85cb92012-03-05 13:15:28 -08003644 struct bio *bio, gfp_t gfp_mask)
Jens Axboe15c31be2007-07-10 13:43:25 +02003645{
Tejun Heo598971b2012-03-19 15:10:58 -07003646 const int ioprio_class = IOPRIO_PRIO_CLASS(cic->ioprio);
3647 const int ioprio = IOPRIO_PRIO_DATA(cic->ioprio);
Vasily Tarasovc2dea2d2007-07-20 10:06:38 +02003648 struct cfq_queue **async_cfqq = NULL;
Jens Axboe15c31be2007-07-10 13:43:25 +02003649 struct cfq_queue *cfqq = NULL;
3650
Vasily Tarasovc2dea2d2007-07-20 10:06:38 +02003651 if (!is_sync) {
3652 async_cfqq = cfq_async_queue_prio(cfqd, ioprio_class, ioprio);
3653 cfqq = *async_cfqq;
3654 }
3655
Jens Axboe6118b702009-06-30 09:34:12 +02003656 if (!cfqq)
Tejun Heoabede6d2012-03-19 15:10:57 -07003657 cfqq = cfq_find_alloc_queue(cfqd, is_sync, cic, bio, gfp_mask);
Jens Axboe15c31be2007-07-10 13:43:25 +02003658
3659 /*
3660 * pin the queue now that it's allocated, scheduler exit will prune it
3661 */
Vasily Tarasovc2dea2d2007-07-20 10:06:38 +02003662 if (!is_sync && !(*async_cfqq)) {
Shaohua Li30d7b942011-01-07 08:46:59 +01003663 cfqq->ref++;
Vasily Tarasovc2dea2d2007-07-20 10:06:38 +02003664 *async_cfqq = cfqq;
Jens Axboe15c31be2007-07-10 13:43:25 +02003665 }
3666
Shaohua Li30d7b942011-01-07 08:46:59 +01003667 cfqq->ref++;
Jens Axboe15c31be2007-07-10 13:43:25 +02003668 return cfqq;
3669}
3670
Jens Axboe22e2c502005-06-27 10:55:12 +02003671static void
Shaohua Li383cd722011-07-12 14:24:35 +02003672__cfq_update_io_thinktime(struct cfq_ttime *ttime, unsigned long slice_idle)
Jens Axboe22e2c502005-06-27 10:55:12 +02003673{
Shaohua Li383cd722011-07-12 14:24:35 +02003674 unsigned long elapsed = jiffies - ttime->last_end_request;
3675 elapsed = min(elapsed, 2UL * slice_idle);
Jens Axboe22e2c502005-06-27 10:55:12 +02003676
Shaohua Li383cd722011-07-12 14:24:35 +02003677 ttime->ttime_samples = (7*ttime->ttime_samples + 256) / 8;
3678 ttime->ttime_total = (7*ttime->ttime_total + 256*elapsed) / 8;
3679 ttime->ttime_mean = (ttime->ttime_total + 128) / ttime->ttime_samples;
3680}
3681
3682static void
3683cfq_update_io_thinktime(struct cfq_data *cfqd, struct cfq_queue *cfqq,
Tejun Heoc5869802011-12-14 00:33:41 +01003684 struct cfq_io_cq *cic)
Shaohua Li383cd722011-07-12 14:24:35 +02003685{
Shaohua Lif5f2b6c2011-07-12 14:24:55 +02003686 if (cfq_cfqq_sync(cfqq)) {
Shaohua Li383cd722011-07-12 14:24:35 +02003687 __cfq_update_io_thinktime(&cic->ttime, cfqd->cfq_slice_idle);
Shaohua Lif5f2b6c2011-07-12 14:24:55 +02003688 __cfq_update_io_thinktime(&cfqq->service_tree->ttime,
3689 cfqd->cfq_slice_idle);
3690 }
Shaohua Li7700fc42011-07-12 14:24:56 +02003691#ifdef CONFIG_CFQ_GROUP_IOSCHED
3692 __cfq_update_io_thinktime(&cfqq->cfqg->ttime, cfqd->cfq_group_idle);
3693#endif
Jens Axboe22e2c502005-06-27 10:55:12 +02003694}
3695
Jens Axboe206dc692006-03-28 13:03:44 +02003696static void
Jeff Moyerb2c18e12009-10-23 17:14:49 -04003697cfq_update_io_seektime(struct cfq_data *cfqd, struct cfq_queue *cfqq,
Jens Axboe6d048f52007-04-25 12:44:27 +02003698 struct request *rq)
Jens Axboe206dc692006-03-28 13:03:44 +02003699{
Corrado Zoccolo3dde36d2010-02-27 19:45:39 +01003700 sector_t sdist = 0;
Corrado Zoccolo41647e72010-02-27 19:45:40 +01003701 sector_t n_sec = blk_rq_sectors(rq);
Corrado Zoccolo3dde36d2010-02-27 19:45:39 +01003702 if (cfqq->last_request_pos) {
3703 if (cfqq->last_request_pos < blk_rq_pos(rq))
3704 sdist = blk_rq_pos(rq) - cfqq->last_request_pos;
3705 else
3706 sdist = cfqq->last_request_pos - blk_rq_pos(rq);
3707 }
Jens Axboe206dc692006-03-28 13:03:44 +02003708
Corrado Zoccolo3dde36d2010-02-27 19:45:39 +01003709 cfqq->seek_history <<= 1;
Corrado Zoccolo41647e72010-02-27 19:45:40 +01003710 if (blk_queue_nonrot(cfqd->queue))
3711 cfqq->seek_history |= (n_sec < CFQQ_SECT_THR_NONROT);
3712 else
3713 cfqq->seek_history |= (sdist > CFQQ_SEEK_THR);
Jens Axboe206dc692006-03-28 13:03:44 +02003714}
Jens Axboe22e2c502005-06-27 10:55:12 +02003715
3716/*
3717 * Disable idle window if the process thinks too long or seeks so much that
3718 * it doesn't matter
3719 */
3720static void
3721cfq_update_idle_window(struct cfq_data *cfqd, struct cfq_queue *cfqq,
Tejun Heoc5869802011-12-14 00:33:41 +01003722 struct cfq_io_cq *cic)
Jens Axboe22e2c502005-06-27 10:55:12 +02003723{
Jens Axboe7b679132008-05-30 12:23:07 +02003724 int old_idle, enable_idle;
Jens Axboe1be92f22007-04-19 14:32:26 +02003725
Jens Axboe08717142008-01-28 11:38:15 +01003726 /*
3727 * Don't idle for async or idle io prio class
3728 */
3729 if (!cfq_cfqq_sync(cfqq) || cfq_class_idle(cfqq))
Jens Axboe1be92f22007-04-19 14:32:26 +02003730 return;
3731
Jens Axboec265a7f2008-06-26 13:49:33 +02003732 enable_idle = old_idle = cfq_cfqq_idle_window(cfqq);
Jens Axboe22e2c502005-06-27 10:55:12 +02003733
Corrado Zoccolo76280af2009-11-26 10:02:58 +01003734 if (cfqq->queued[0] + cfqq->queued[1] >= 4)
3735 cfq_mark_cfqq_deep(cfqq);
3736
Corrado Zoccolo749ef9f2010-09-20 15:24:50 +02003737 if (cfqq->next_rq && (cfqq->next_rq->cmd_flags & REQ_NOIDLE))
3738 enable_idle = 0;
Tejun Heof6e8d012012-03-05 13:15:26 -08003739 else if (!atomic_read(&cic->icq.ioc->active_ref) ||
Tejun Heoc5869802011-12-14 00:33:41 +01003740 !cfqd->cfq_slice_idle ||
3741 (!cfq_cfqq_deep(cfqq) && CFQQ_SEEKY(cfqq)))
Jens Axboe22e2c502005-06-27 10:55:12 +02003742 enable_idle = 0;
Shaohua Li383cd722011-07-12 14:24:35 +02003743 else if (sample_valid(cic->ttime.ttime_samples)) {
3744 if (cic->ttime.ttime_mean > cfqd->cfq_slice_idle)
Jens Axboe22e2c502005-06-27 10:55:12 +02003745 enable_idle = 0;
3746 else
3747 enable_idle = 1;
3748 }
3749
Jens Axboe7b679132008-05-30 12:23:07 +02003750 if (old_idle != enable_idle) {
3751 cfq_log_cfqq(cfqd, cfqq, "idle=%d", enable_idle);
3752 if (enable_idle)
3753 cfq_mark_cfqq_idle_window(cfqq);
3754 else
3755 cfq_clear_cfqq_idle_window(cfqq);
3756 }
Jens Axboe22e2c502005-06-27 10:55:12 +02003757}
3758
Jens Axboe22e2c502005-06-27 10:55:12 +02003759/*
3760 * Check if new_cfqq should preempt the currently active queue. Return 0 for
3761 * no or if we aren't sure, a 1 will cause a preempt.
3762 */
Jens Axboea6151c32009-10-07 20:02:57 +02003763static bool
Jens Axboe22e2c502005-06-27 10:55:12 +02003764cfq_should_preempt(struct cfq_data *cfqd, struct cfq_queue *new_cfqq,
Jens Axboe5e705372006-07-13 12:39:25 +02003765 struct request *rq)
Jens Axboe22e2c502005-06-27 10:55:12 +02003766{
Jens Axboe6d048f52007-04-25 12:44:27 +02003767 struct cfq_queue *cfqq;
Jens Axboe22e2c502005-06-27 10:55:12 +02003768
Jens Axboe6d048f52007-04-25 12:44:27 +02003769 cfqq = cfqd->active_queue;
3770 if (!cfqq)
Jens Axboea6151c32009-10-07 20:02:57 +02003771 return false;
Jens Axboe22e2c502005-06-27 10:55:12 +02003772
Jens Axboe6d048f52007-04-25 12:44:27 +02003773 if (cfq_class_idle(new_cfqq))
Jens Axboea6151c32009-10-07 20:02:57 +02003774 return false;
Jens Axboe22e2c502005-06-27 10:55:12 +02003775
3776 if (cfq_class_idle(cfqq))
Jens Axboea6151c32009-10-07 20:02:57 +02003777 return true;
Jens Axboe1e3335d2007-02-14 19:59:49 +01003778
Jens Axboe22e2c502005-06-27 10:55:12 +02003779 /*
Divyesh Shah875feb62010-01-06 18:58:20 -08003780 * Don't allow a non-RT request to preempt an ongoing RT cfqq timeslice.
3781 */
3782 if (cfq_class_rt(cfqq) && !cfq_class_rt(new_cfqq))
3783 return false;
3784
3785 /*
Jens Axboe374f84a2006-07-23 01:42:19 +02003786 * if the new request is sync, but the currently running queue is
3787 * not, let the sync request have priority.
3788 */
Jens Axboe5e705372006-07-13 12:39:25 +02003789 if (rq_is_sync(rq) && !cfq_cfqq_sync(cfqq))
Jens Axboea6151c32009-10-07 20:02:57 +02003790 return true;
Jens Axboe1e3335d2007-02-14 19:59:49 +01003791
Vivek Goyal8682e1f2009-12-03 12:59:50 -05003792 if (new_cfqq->cfqg != cfqq->cfqg)
3793 return false;
3794
3795 if (cfq_slice_used(cfqq))
3796 return true;
3797
3798 /* Allow preemption only if we are idling on sync-noidle tree */
Vivek Goyal4d2ceea2012-10-03 16:56:57 -04003799 if (cfqd->serving_wl_type == SYNC_NOIDLE_WORKLOAD &&
Vivek Goyal8682e1f2009-12-03 12:59:50 -05003800 cfqq_type(new_cfqq) == SYNC_NOIDLE_WORKLOAD &&
3801 new_cfqq->service_tree->count == 2 &&
3802 RB_EMPTY_ROOT(&cfqq->sort_list))
3803 return true;
3804
Jens Axboe374f84a2006-07-23 01:42:19 +02003805 /*
Jens Axboeb53d1ed2011-08-19 08:34:48 +02003806 * So both queues are sync. Let the new request get disk time if
3807 * it's a metadata request and the current queue is doing regular IO.
3808 */
Christoph Hellwig65299a32011-08-23 14:50:29 +02003809 if ((rq->cmd_flags & REQ_PRIO) && !cfqq->prio_pending)
Jens Axboeb53d1ed2011-08-19 08:34:48 +02003810 return true;
3811
3812 /*
Divyesh Shah3a9a3f62009-01-30 12:46:41 +01003813 * Allow an RT request to pre-empt an ongoing non-RT cfqq timeslice.
3814 */
3815 if (cfq_class_rt(new_cfqq) && !cfq_class_rt(cfqq))
Jens Axboea6151c32009-10-07 20:02:57 +02003816 return true;
Divyesh Shah3a9a3f62009-01-30 12:46:41 +01003817
Shaohua Lid2d59e12010-11-08 15:01:03 +01003818 /* An idle queue should not be idle now for some reason */
3819 if (RB_EMPTY_ROOT(&cfqq->sort_list) && !cfq_should_idle(cfqd, cfqq))
3820 return true;
3821
Jens Axboe1e3335d2007-02-14 19:59:49 +01003822 if (!cfqd->active_cic || !cfq_cfqq_wait_request(cfqq))
Jens Axboea6151c32009-10-07 20:02:57 +02003823 return false;
Jens Axboe1e3335d2007-02-14 19:59:49 +01003824
3825 /*
3826 * if this request is as-good as one we would expect from the
3827 * current cfqq, let it preempt
3828 */
Shaohua Lie9ce3352010-03-19 08:03:04 +01003829 if (cfq_rq_close(cfqd, cfqq, rq))
Jens Axboea6151c32009-10-07 20:02:57 +02003830 return true;
Jens Axboe1e3335d2007-02-14 19:59:49 +01003831
Jens Axboea6151c32009-10-07 20:02:57 +02003832 return false;
Jens Axboe22e2c502005-06-27 10:55:12 +02003833}
3834
3835/*
3836 * cfqq preempts the active queue. if we allowed preempt with no slice left,
3837 * let it have half of its nominal slice.
3838 */
3839static void cfq_preempt_queue(struct cfq_data *cfqd, struct cfq_queue *cfqq)
3840{
Shaohua Lidf0793a2012-01-19 09:20:09 +01003841 enum wl_type_t old_type = cfqq_type(cfqd->active_queue);
3842
Jens Axboe7b679132008-05-30 12:23:07 +02003843 cfq_log_cfqq(cfqd, cfqq, "preempt");
Shaohua Lidf0793a2012-01-19 09:20:09 +01003844 cfq_slice_expired(cfqd, 1);
Jens Axboe22e2c502005-06-27 10:55:12 +02003845
Jens Axboebf572252006-07-19 20:29:12 +02003846 /*
Shaohua Lif8ae6e32011-01-14 08:41:02 +01003847 * workload type is changed, don't save slice, otherwise preempt
3848 * doesn't happen
3849 */
Shaohua Lidf0793a2012-01-19 09:20:09 +01003850 if (old_type != cfqq_type(cfqq))
Vivek Goyal4d2ceea2012-10-03 16:56:57 -04003851 cfqq->cfqg->saved_wl_slice = 0;
Shaohua Lif8ae6e32011-01-14 08:41:02 +01003852
3853 /*
Jens Axboebf572252006-07-19 20:29:12 +02003854 * Put the new queue at the front of the of the current list,
3855 * so we know that it will be selected next.
3856 */
3857 BUG_ON(!cfq_cfqq_on_rr(cfqq));
Jens Axboeedd75ff2007-04-19 12:03:34 +02003858
3859 cfq_service_tree_add(cfqd, cfqq, 1);
Justin TerAvesteda5e0c2011-03-22 21:26:49 +01003860
Justin TerAvest62a37f62011-03-23 08:25:44 +01003861 cfqq->slice_end = 0;
3862 cfq_mark_cfqq_slice_new(cfqq);
Jens Axboe22e2c502005-06-27 10:55:12 +02003863}
3864
3865/*
Jens Axboe5e705372006-07-13 12:39:25 +02003866 * Called when a new fs request (rq) is added (to cfqq). Check if there's
Jens Axboe22e2c502005-06-27 10:55:12 +02003867 * something we should do about it
3868 */
3869static void
Jens Axboe5e705372006-07-13 12:39:25 +02003870cfq_rq_enqueued(struct cfq_data *cfqd, struct cfq_queue *cfqq,
3871 struct request *rq)
Jens Axboe22e2c502005-06-27 10:55:12 +02003872{
Tejun Heoc5869802011-12-14 00:33:41 +01003873 struct cfq_io_cq *cic = RQ_CIC(rq);
Jens Axboe12e9fdd2006-06-01 10:09:56 +02003874
Aaron Carroll45333d52008-08-26 15:52:36 +02003875 cfqd->rq_queued++;
Christoph Hellwig65299a32011-08-23 14:50:29 +02003876 if (rq->cmd_flags & REQ_PRIO)
3877 cfqq->prio_pending++;
Jens Axboe374f84a2006-07-23 01:42:19 +02003878
Shaohua Li383cd722011-07-12 14:24:35 +02003879 cfq_update_io_thinktime(cfqd, cfqq, cic);
Jeff Moyerb2c18e12009-10-23 17:14:49 -04003880 cfq_update_io_seektime(cfqd, cfqq, rq);
Jens Axboe9c2c38a2005-08-24 14:57:54 +02003881 cfq_update_idle_window(cfqd, cfqq, cic);
3882
Jeff Moyerb2c18e12009-10-23 17:14:49 -04003883 cfqq->last_request_pos = blk_rq_pos(rq) + blk_rq_sectors(rq);
Jens Axboe22e2c502005-06-27 10:55:12 +02003884
3885 if (cfqq == cfqd->active_queue) {
3886 /*
Jens Axboeb0291952009-04-07 11:38:31 +02003887 * Remember that we saw a request from this process, but
3888 * don't start queuing just yet. Otherwise we risk seeing lots
3889 * of tiny requests, because we disrupt the normal plugging
Jens Axboed6ceb252009-04-14 14:18:16 +02003890 * and merging. If the request is already larger than a single
3891 * page, let it rip immediately. For that case we assume that
Jens Axboe2d870722009-04-15 12:12:46 +02003892 * merging is already done. Ditto for a busy system that
3893 * has other work pending, don't risk delaying until the
3894 * idle timer unplug to continue working.
Jens Axboe22e2c502005-06-27 10:55:12 +02003895 */
Jens Axboed6ceb252009-04-14 14:18:16 +02003896 if (cfq_cfqq_wait_request(cfqq)) {
Jens Axboe2d870722009-04-15 12:12:46 +02003897 if (blk_rq_bytes(rq) > PAGE_CACHE_SIZE ||
3898 cfqd->busy_queues > 1) {
Divyesh Shah812df482010-04-08 21:15:35 -07003899 cfq_del_timer(cfqd, cfqq);
Gui Jianfeng554554f2009-12-10 09:38:39 +01003900 cfq_clear_cfqq_wait_request(cfqq);
Christoph Hellwig24ecfbe2011-04-18 11:41:33 +02003901 __blk_run_queue(cfqd->queue);
Divyesh Shaha11cdaa2010-04-13 19:59:17 +02003902 } else {
Tejun Heo155fead2012-04-01 14:38:44 -07003903 cfqg_stats_update_idle_time(cfqq->cfqg);
Vivek Goyalbf7919372009-12-03 12:59:37 -05003904 cfq_mark_cfqq_must_dispatch(cfqq);
Divyesh Shaha11cdaa2010-04-13 19:59:17 +02003905 }
Jens Axboed6ceb252009-04-14 14:18:16 +02003906 }
Jens Axboe5e705372006-07-13 12:39:25 +02003907 } else if (cfq_should_preempt(cfqd, cfqq, rq)) {
Jens Axboe22e2c502005-06-27 10:55:12 +02003908 /*
3909 * not the active queue - expire current slice if it is
3910 * idle and has expired it's mean thinktime or this new queue
Divyesh Shah3a9a3f62009-01-30 12:46:41 +01003911 * has some old slice time left and is of higher priority or
3912 * this new queue is RT and the current one is BE
Jens Axboe22e2c502005-06-27 10:55:12 +02003913 */
3914 cfq_preempt_queue(cfqd, cfqq);
Christoph Hellwig24ecfbe2011-04-18 11:41:33 +02003915 __blk_run_queue(cfqd->queue);
Jens Axboe22e2c502005-06-27 10:55:12 +02003916 }
3917}
3918
Jens Axboe165125e2007-07-24 09:28:11 +02003919static void cfq_insert_request(struct request_queue *q, struct request *rq)
Jens Axboe22e2c502005-06-27 10:55:12 +02003920{
Jens Axboeb4878f22005-10-20 16:42:29 +02003921 struct cfq_data *cfqd = q->elevator->elevator_data;
Jens Axboe5e705372006-07-13 12:39:25 +02003922 struct cfq_queue *cfqq = RQ_CFQQ(rq);
Jens Axboe22e2c502005-06-27 10:55:12 +02003923
Jens Axboe7b679132008-05-30 12:23:07 +02003924 cfq_log_cfqq(cfqd, cfqq, "insert_request");
Tejun Heoabede6d2012-03-19 15:10:57 -07003925 cfq_init_prio_data(cfqq, RQ_CIC(rq));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003926
Jan Kara8b4922d2014-02-24 16:39:52 +01003927 rq->fifo_time = jiffies + cfqd->cfq_fifo_expire[rq_is_sync(rq)];
Jens Axboe22e2c502005-06-27 10:55:12 +02003928 list_add_tail(&rq->queuelist, &cfqq->fifo);
Corrado Zoccoloaa6f6a32009-10-26 22:44:33 +01003929 cfq_add_rq_rb(rq);
Tejun Heo155fead2012-04-01 14:38:44 -07003930 cfqg_stats_update_io_add(RQ_CFQG(rq), cfqd->serving_group,
3931 rq->cmd_flags);
Jens Axboe5e705372006-07-13 12:39:25 +02003932 cfq_rq_enqueued(cfqd, cfqq, rq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003933}
3934
Aaron Carroll45333d52008-08-26 15:52:36 +02003935/*
3936 * Update hw_tag based on peak queue depth over 50 samples under
3937 * sufficient load.
3938 */
3939static void cfq_update_hw_tag(struct cfq_data *cfqd)
3940{
Shaohua Li1a1238a2009-10-27 08:46:23 +01003941 struct cfq_queue *cfqq = cfqd->active_queue;
3942
Corrado Zoccolo53c583d2010-02-28 19:45:05 +01003943 if (cfqd->rq_in_driver > cfqd->hw_tag_est_depth)
3944 cfqd->hw_tag_est_depth = cfqd->rq_in_driver;
Corrado Zoccoloe459dd02009-11-26 10:02:57 +01003945
3946 if (cfqd->hw_tag == 1)
3947 return;
Aaron Carroll45333d52008-08-26 15:52:36 +02003948
3949 if (cfqd->rq_queued <= CFQ_HW_QUEUE_MIN &&
Corrado Zoccolo53c583d2010-02-28 19:45:05 +01003950 cfqd->rq_in_driver <= CFQ_HW_QUEUE_MIN)
Aaron Carroll45333d52008-08-26 15:52:36 +02003951 return;
3952
Shaohua Li1a1238a2009-10-27 08:46:23 +01003953 /*
3954 * If active queue hasn't enough requests and can idle, cfq might not
3955 * dispatch sufficient requests to hardware. Don't zero hw_tag in this
3956 * case
3957 */
3958 if (cfqq && cfq_cfqq_idle_window(cfqq) &&
3959 cfqq->dispatched + cfqq->queued[0] + cfqq->queued[1] <
Corrado Zoccolo53c583d2010-02-28 19:45:05 +01003960 CFQ_HW_QUEUE_MIN && cfqd->rq_in_driver < CFQ_HW_QUEUE_MIN)
Shaohua Li1a1238a2009-10-27 08:46:23 +01003961 return;
3962
Aaron Carroll45333d52008-08-26 15:52:36 +02003963 if (cfqd->hw_tag_samples++ < 50)
3964 return;
3965
Corrado Zoccoloe459dd02009-11-26 10:02:57 +01003966 if (cfqd->hw_tag_est_depth >= CFQ_HW_QUEUE_MIN)
Aaron Carroll45333d52008-08-26 15:52:36 +02003967 cfqd->hw_tag = 1;
3968 else
3969 cfqd->hw_tag = 0;
Aaron Carroll45333d52008-08-26 15:52:36 +02003970}
3971
Vivek Goyal7667aa02009-12-08 17:52:58 -05003972static bool cfq_should_wait_busy(struct cfq_data *cfqd, struct cfq_queue *cfqq)
3973{
Tejun Heoc5869802011-12-14 00:33:41 +01003974 struct cfq_io_cq *cic = cfqd->active_cic;
Vivek Goyal7667aa02009-12-08 17:52:58 -05003975
Justin TerAvest02a8f012011-02-09 14:20:03 +01003976 /* If the queue already has requests, don't wait */
3977 if (!RB_EMPTY_ROOT(&cfqq->sort_list))
3978 return false;
3979
Vivek Goyal7667aa02009-12-08 17:52:58 -05003980 /* If there are other queues in the group, don't wait */
3981 if (cfqq->cfqg->nr_cfqq > 1)
3982 return false;
3983
Shaohua Li7700fc42011-07-12 14:24:56 +02003984 /* the only queue in the group, but think time is big */
3985 if (cfq_io_thinktime_big(cfqd, &cfqq->cfqg->ttime, true))
3986 return false;
3987
Vivek Goyal7667aa02009-12-08 17:52:58 -05003988 if (cfq_slice_used(cfqq))
3989 return true;
3990
3991 /* if slice left is less than think time, wait busy */
Shaohua Li383cd722011-07-12 14:24:35 +02003992 if (cic && sample_valid(cic->ttime.ttime_samples)
3993 && (cfqq->slice_end - jiffies < cic->ttime.ttime_mean))
Vivek Goyal7667aa02009-12-08 17:52:58 -05003994 return true;
3995
3996 /*
3997 * If think times is less than a jiffy than ttime_mean=0 and above
3998 * will not be true. It might happen that slice has not expired yet
3999 * but will expire soon (4-5 ns) during select_queue(). To cover the
4000 * case where think time is less than a jiffy, mark the queue wait
4001 * busy if only 1 jiffy is left in the slice.
4002 */
4003 if (cfqq->slice_end - jiffies == 1)
4004 return true;
4005
4006 return false;
4007}
4008
Jens Axboe165125e2007-07-24 09:28:11 +02004009static void cfq_completed_request(struct request_queue *q, struct request *rq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004010{
Jens Axboe5e705372006-07-13 12:39:25 +02004011 struct cfq_queue *cfqq = RQ_CFQQ(rq);
Jens Axboeb4878f22005-10-20 16:42:29 +02004012 struct cfq_data *cfqd = cfqq->cfqd;
Jens Axboe5380a102006-07-13 12:37:56 +02004013 const int sync = rq_is_sync(rq);
Jens Axboeb4878f22005-10-20 16:42:29 +02004014 unsigned long now;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004015
Jens Axboeb4878f22005-10-20 16:42:29 +02004016 now = jiffies;
Christoph Hellwig33659eb2010-08-07 18:17:56 +02004017 cfq_log_cfqq(cfqd, cfqq, "complete rqnoidle %d",
4018 !!(rq->cmd_flags & REQ_NOIDLE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004019
Aaron Carroll45333d52008-08-26 15:52:36 +02004020 cfq_update_hw_tag(cfqd);
4021
Corrado Zoccolo53c583d2010-02-28 19:45:05 +01004022 WARN_ON(!cfqd->rq_in_driver);
Jens Axboe6d048f52007-04-25 12:44:27 +02004023 WARN_ON(!cfqq->dispatched);
Corrado Zoccolo53c583d2010-02-28 19:45:05 +01004024 cfqd->rq_in_driver--;
Jens Axboe6d048f52007-04-25 12:44:27 +02004025 cfqq->dispatched--;
Vivek Goyal80bdf0c2010-08-23 12:24:26 +02004026 (RQ_CFQG(rq))->dispatched--;
Tejun Heo155fead2012-04-01 14:38:44 -07004027 cfqg_stats_update_completion(cfqq->cfqg, rq_start_time_ns(rq),
4028 rq_io_start_time_ns(rq), rq->cmd_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004029
Corrado Zoccolo53c583d2010-02-28 19:45:05 +01004030 cfqd->rq_in_flight[cfq_cfqq_sync(cfqq)]--;
Jens Axboe3ed9a292007-04-23 08:33:33 +02004031
Vivek Goyal365722b2009-10-03 15:21:27 +02004032 if (sync) {
Vivek Goyal34b98d02012-10-03 16:56:58 -04004033 struct cfq_rb_root *st;
Shaohua Lif5f2b6c2011-07-12 14:24:55 +02004034
Shaohua Li383cd722011-07-12 14:24:35 +02004035 RQ_CIC(rq)->ttime.last_end_request = now;
Shaohua Lif5f2b6c2011-07-12 14:24:55 +02004036
4037 if (cfq_cfqq_on_rr(cfqq))
Vivek Goyal34b98d02012-10-03 16:56:58 -04004038 st = cfqq->service_tree;
Shaohua Lif5f2b6c2011-07-12 14:24:55 +02004039 else
Vivek Goyal34b98d02012-10-03 16:56:58 -04004040 st = st_for(cfqq->cfqg, cfqq_class(cfqq),
4041 cfqq_type(cfqq));
4042
4043 st->ttime.last_end_request = now;
Corrado Zoccolo573412b2009-12-06 11:48:52 +01004044 if (!time_after(rq->start_time + cfqd->cfq_fifo_expire[1], now))
4045 cfqd->last_delayed_sync = now;
Vivek Goyal365722b2009-10-03 15:21:27 +02004046 }
Jens Axboecaaa5f92006-06-16 11:23:00 +02004047
Shaohua Li7700fc42011-07-12 14:24:56 +02004048#ifdef CONFIG_CFQ_GROUP_IOSCHED
4049 cfqq->cfqg->ttime.last_end_request = now;
4050#endif
4051
Jens Axboecaaa5f92006-06-16 11:23:00 +02004052 /*
4053 * If this is the active queue, check if it needs to be expired,
4054 * or if we want to idle in case it has no pending requests.
4055 */
4056 if (cfqd->active_queue == cfqq) {
Jens Axboea36e71f2009-04-15 12:15:11 +02004057 const bool cfqq_empty = RB_EMPTY_ROOT(&cfqq->sort_list);
4058
Jens Axboe44f7c162007-01-19 11:51:58 +11004059 if (cfq_cfqq_slice_new(cfqq)) {
4060 cfq_set_prio_slice(cfqd, cfqq);
4061 cfq_clear_cfqq_slice_new(cfqq);
4062 }
Vivek Goyalf75edf22009-12-03 12:59:53 -05004063
4064 /*
Vivek Goyal7667aa02009-12-08 17:52:58 -05004065 * Should we wait for next request to come in before we expire
4066 * the queue.
Vivek Goyalf75edf22009-12-03 12:59:53 -05004067 */
Vivek Goyal7667aa02009-12-08 17:52:58 -05004068 if (cfq_should_wait_busy(cfqd, cfqq)) {
Vivek Goyal80bdf0c2010-08-23 12:24:26 +02004069 unsigned long extend_sl = cfqd->cfq_slice_idle;
4070 if (!cfqd->cfq_slice_idle)
4071 extend_sl = cfqd->cfq_group_idle;
4072 cfqq->slice_end = jiffies + extend_sl;
Vivek Goyalf75edf22009-12-03 12:59:53 -05004073 cfq_mark_cfqq_wait_busy(cfqq);
Divyesh Shahb1ffe732010-03-25 15:45:03 +01004074 cfq_log_cfqq(cfqd, cfqq, "will busy wait");
Vivek Goyalf75edf22009-12-03 12:59:53 -05004075 }
4076
Jens Axboea36e71f2009-04-15 12:15:11 +02004077 /*
Corrado Zoccolo8e550632009-11-26 10:02:58 +01004078 * Idling is not enabled on:
4079 * - expired queues
4080 * - idle-priority queues
4081 * - async queues
4082 * - queues with still some requests queued
4083 * - when there is a close cooperator
Jens Axboea36e71f2009-04-15 12:15:11 +02004084 */
Jens Axboe08717142008-01-28 11:38:15 +01004085 if (cfq_slice_used(cfqq) || cfq_class_idle(cfqq))
Vivek Goyale5ff0822010-04-26 19:25:11 +02004086 cfq_slice_expired(cfqd, 1);
Corrado Zoccolo8e550632009-11-26 10:02:58 +01004087 else if (sync && cfqq_empty &&
4088 !cfq_close_cooperator(cfqd, cfqq)) {
Corrado Zoccolo749ef9f2010-09-20 15:24:50 +02004089 cfq_arm_slice_timer(cfqd);
Corrado Zoccolo8e550632009-11-26 10:02:58 +01004090 }
Jens Axboecaaa5f92006-06-16 11:23:00 +02004091 }
Jens Axboe6d048f52007-04-25 12:44:27 +02004092
Corrado Zoccolo53c583d2010-02-28 19:45:05 +01004093 if (!cfqd->rq_in_driver)
Jens Axboe23e018a2009-10-05 08:52:35 +02004094 cfq_schedule_dispatch(cfqd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004095}
4096
Jens Axboe89850f72006-07-22 16:48:31 +02004097static inline int __cfq_may_queue(struct cfq_queue *cfqq)
Jens Axboe22e2c502005-06-27 10:55:12 +02004098{
Jens Axboe1b379d82009-08-11 08:26:11 +02004099 if (cfq_cfqq_wait_request(cfqq) && !cfq_cfqq_must_alloc_slice(cfqq)) {
Jens Axboe3b181522005-06-27 10:56:24 +02004100 cfq_mark_cfqq_must_alloc_slice(cfqq);
Jens Axboe22e2c502005-06-27 10:55:12 +02004101 return ELV_MQUEUE_MUST;
Jens Axboe3b181522005-06-27 10:56:24 +02004102 }
Jens Axboe22e2c502005-06-27 10:55:12 +02004103
4104 return ELV_MQUEUE_MAY;
Jens Axboe22e2c502005-06-27 10:55:12 +02004105}
4106
Jens Axboe165125e2007-07-24 09:28:11 +02004107static int cfq_may_queue(struct request_queue *q, int rw)
Jens Axboe22e2c502005-06-27 10:55:12 +02004108{
4109 struct cfq_data *cfqd = q->elevator->elevator_data;
4110 struct task_struct *tsk = current;
Tejun Heoc5869802011-12-14 00:33:41 +01004111 struct cfq_io_cq *cic;
Jens Axboe22e2c502005-06-27 10:55:12 +02004112 struct cfq_queue *cfqq;
4113
4114 /*
4115 * don't force setup of a queue from here, as a call to may_queue
4116 * does not necessarily imply that a request actually will be queued.
4117 * so just lookup a possibly existing queue, or return 'may queue'
4118 * if that fails
4119 */
Jens Axboe4ac845a2008-01-24 08:44:49 +01004120 cic = cfq_cic_lookup(cfqd, tsk->io_context);
Vasily Tarasov91fac312007-04-25 12:29:51 +02004121 if (!cic)
4122 return ELV_MQUEUE_MAY;
4123
Jens Axboeb0b78f82009-04-08 10:56:08 +02004124 cfqq = cic_to_cfqq(cic, rw_is_sync(rw));
Jens Axboe22e2c502005-06-27 10:55:12 +02004125 if (cfqq) {
Tejun Heoabede6d2012-03-19 15:10:57 -07004126 cfq_init_prio_data(cfqq, cic);
Jens Axboe22e2c502005-06-27 10:55:12 +02004127
Jens Axboe89850f72006-07-22 16:48:31 +02004128 return __cfq_may_queue(cfqq);
Jens Axboe22e2c502005-06-27 10:55:12 +02004129 }
4130
4131 return ELV_MQUEUE_MAY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004132}
4133
Linus Torvalds1da177e2005-04-16 15:20:36 -07004134/*
4135 * queue lock held here
4136 */
Jens Axboebb37b942006-12-01 10:42:33 +01004137static void cfq_put_request(struct request *rq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004138{
Jens Axboe5e705372006-07-13 12:39:25 +02004139 struct cfq_queue *cfqq = RQ_CFQQ(rq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004140
Jens Axboe5e705372006-07-13 12:39:25 +02004141 if (cfqq) {
Jens Axboe22e2c502005-06-27 10:55:12 +02004142 const int rw = rq_data_dir(rq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004143
Jens Axboe22e2c502005-06-27 10:55:12 +02004144 BUG_ON(!cfqq->allocated[rw]);
4145 cfqq->allocated[rw]--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004146
Vivek Goyal7f1dc8a2010-04-21 17:44:16 +02004147 /* Put down rq reference on cfqg */
Tejun Heoeb7d8c072012-03-23 14:02:53 +01004148 cfqg_put(RQ_CFQG(rq));
Tejun Heoa612fdd2011-12-14 00:33:41 +01004149 rq->elv.priv[0] = NULL;
4150 rq->elv.priv[1] = NULL;
Vivek Goyal7f1dc8a2010-04-21 17:44:16 +02004151
Linus Torvalds1da177e2005-04-16 15:20:36 -07004152 cfq_put_queue(cfqq);
4153 }
4154}
4155
Jeff Moyerdf5fe3e2009-10-23 17:14:50 -04004156static struct cfq_queue *
Tejun Heoc5869802011-12-14 00:33:41 +01004157cfq_merge_cfqqs(struct cfq_data *cfqd, struct cfq_io_cq *cic,
Jeff Moyerdf5fe3e2009-10-23 17:14:50 -04004158 struct cfq_queue *cfqq)
4159{
4160 cfq_log_cfqq(cfqd, cfqq, "merging with queue %p", cfqq->new_cfqq);
4161 cic_set_cfqq(cic, cfqq->new_cfqq, 1);
Jeff Moyerb3b6d042009-10-23 17:14:51 -04004162 cfq_mark_cfqq_coop(cfqq->new_cfqq);
Jeff Moyerdf5fe3e2009-10-23 17:14:50 -04004163 cfq_put_queue(cfqq);
4164 return cic_to_cfqq(cic, 1);
4165}
4166
Jeff Moyere6c5bc72009-10-23 17:14:52 -04004167/*
4168 * Returns NULL if a new cfqq should be allocated, or the old cfqq if this
4169 * was the last process referring to said cfqq.
4170 */
4171static struct cfq_queue *
Tejun Heoc5869802011-12-14 00:33:41 +01004172split_cfqq(struct cfq_io_cq *cic, struct cfq_queue *cfqq)
Jeff Moyere6c5bc72009-10-23 17:14:52 -04004173{
4174 if (cfqq_process_refs(cfqq) == 1) {
Jeff Moyere6c5bc72009-10-23 17:14:52 -04004175 cfqq->pid = current->pid;
4176 cfq_clear_cfqq_coop(cfqq);
Shaohua Liae54abe2010-02-05 13:11:45 +01004177 cfq_clear_cfqq_split_coop(cfqq);
Jeff Moyere6c5bc72009-10-23 17:14:52 -04004178 return cfqq;
4179 }
4180
4181 cic_set_cfqq(cic, NULL, 1);
Shaohua Lid02a2c02010-05-25 10:16:53 +02004182
4183 cfq_put_cooperator(cfqq);
4184
Jeff Moyere6c5bc72009-10-23 17:14:52 -04004185 cfq_put_queue(cfqq);
4186 return NULL;
4187}
Linus Torvalds1da177e2005-04-16 15:20:36 -07004188/*
Jens Axboe22e2c502005-06-27 10:55:12 +02004189 * Allocate cfq data structures associated with this request.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004190 */
Jens Axboe22e2c502005-06-27 10:55:12 +02004191static int
Tejun Heo852c7882012-03-05 13:15:27 -08004192cfq_set_request(struct request_queue *q, struct request *rq, struct bio *bio,
4193 gfp_t gfp_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004194{
4195 struct cfq_data *cfqd = q->elevator->elevator_data;
Tejun Heof1f8cc92011-12-14 00:33:42 +01004196 struct cfq_io_cq *cic = icq_to_cic(rq->elv.icq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004197 const int rw = rq_data_dir(rq);
Jens Axboea6151c32009-10-07 20:02:57 +02004198 const bool is_sync = rq_is_sync(rq);
Jens Axboe22e2c502005-06-27 10:55:12 +02004199 struct cfq_queue *cfqq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004200
4201 might_sleep_if(gfp_mask & __GFP_WAIT);
4202
Tejun Heo216284c2011-12-14 00:33:38 +01004203 spin_lock_irq(q->queue_lock);
Tejun Heof1f8cc92011-12-14 00:33:42 +01004204
Tejun Heo598971b2012-03-19 15:10:58 -07004205 check_ioprio_changed(cic, bio);
4206 check_blkcg_changed(cic, bio);
Jeff Moyere6c5bc72009-10-23 17:14:52 -04004207new_queue:
Vasily Tarasov91fac312007-04-25 12:29:51 +02004208 cfqq = cic_to_cfqq(cic, is_sync);
Vivek Goyal32f2e802009-07-09 22:13:16 +02004209 if (!cfqq || cfqq == &cfqd->oom_cfqq) {
Tejun Heoabede6d2012-03-19 15:10:57 -07004210 cfqq = cfq_get_queue(cfqd, is_sync, cic, bio, gfp_mask);
Vasily Tarasov91fac312007-04-25 12:29:51 +02004211 cic_set_cfqq(cic, cfqq, is_sync);
Jeff Moyerdf5fe3e2009-10-23 17:14:50 -04004212 } else {
4213 /*
Jeff Moyere6c5bc72009-10-23 17:14:52 -04004214 * If the queue was seeky for too long, break it apart.
4215 */
Shaohua Liae54abe2010-02-05 13:11:45 +01004216 if (cfq_cfqq_coop(cfqq) && cfq_cfqq_split_coop(cfqq)) {
Jeff Moyere6c5bc72009-10-23 17:14:52 -04004217 cfq_log_cfqq(cfqd, cfqq, "breaking apart cfqq");
4218 cfqq = split_cfqq(cic, cfqq);
4219 if (!cfqq)
4220 goto new_queue;
4221 }
4222
4223 /*
Jeff Moyerdf5fe3e2009-10-23 17:14:50 -04004224 * Check to see if this queue is scheduled to merge with
4225 * another, closely cooperating queue. The merging of
4226 * queues happens here as it must be done in process context.
4227 * The reference on new_cfqq was taken in merge_cfqqs.
4228 */
4229 if (cfqq->new_cfqq)
4230 cfqq = cfq_merge_cfqqs(cfqd, cic, cfqq);
Vasily Tarasov91fac312007-04-25 12:29:51 +02004231 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004232
4233 cfqq->allocated[rw]++;
Jens Axboe5e705372006-07-13 12:39:25 +02004234
Jens Axboe6fae9c22011-03-01 15:04:39 -05004235 cfqq->ref++;
Tejun Heoeb7d8c072012-03-23 14:02:53 +01004236 cfqg_get(cfqq->cfqg);
Tejun Heoa612fdd2011-12-14 00:33:41 +01004237 rq->elv.priv[0] = cfqq;
Tejun Heo1adaf3d2012-03-05 13:15:15 -08004238 rq->elv.priv[1] = cfqq->cfqg;
Tejun Heo216284c2011-12-14 00:33:38 +01004239 spin_unlock_irq(q->queue_lock);
Jens Axboe5e705372006-07-13 12:39:25 +02004240 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004241}
4242
David Howells65f27f32006-11-22 14:55:48 +00004243static void cfq_kick_queue(struct work_struct *work)
Jens Axboe22e2c502005-06-27 10:55:12 +02004244{
David Howells65f27f32006-11-22 14:55:48 +00004245 struct cfq_data *cfqd =
Jens Axboe23e018a2009-10-05 08:52:35 +02004246 container_of(work, struct cfq_data, unplug_work);
Jens Axboe165125e2007-07-24 09:28:11 +02004247 struct request_queue *q = cfqd->queue;
Jens Axboe22e2c502005-06-27 10:55:12 +02004248
Jens Axboe40bb54d2009-04-15 12:11:10 +02004249 spin_lock_irq(q->queue_lock);
Christoph Hellwig24ecfbe2011-04-18 11:41:33 +02004250 __blk_run_queue(cfqd->queue);
Jens Axboe40bb54d2009-04-15 12:11:10 +02004251 spin_unlock_irq(q->queue_lock);
Jens Axboe22e2c502005-06-27 10:55:12 +02004252}
4253
4254/*
4255 * Timer running if the active_queue is currently idling inside its time slice
4256 */
4257static void cfq_idle_slice_timer(unsigned long data)
4258{
4259 struct cfq_data *cfqd = (struct cfq_data *) data;
4260 struct cfq_queue *cfqq;
4261 unsigned long flags;
Jens Axboe3c6bd2f2007-01-19 12:06:33 +11004262 int timed_out = 1;
Jens Axboe22e2c502005-06-27 10:55:12 +02004263
Jens Axboe7b679132008-05-30 12:23:07 +02004264 cfq_log(cfqd, "idle timer fired");
4265
Jens Axboe22e2c502005-06-27 10:55:12 +02004266 spin_lock_irqsave(cfqd->queue->queue_lock, flags);
4267
Jens Axboefe094d92008-01-31 13:08:54 +01004268 cfqq = cfqd->active_queue;
4269 if (cfqq) {
Jens Axboe3c6bd2f2007-01-19 12:06:33 +11004270 timed_out = 0;
4271
Jens Axboe22e2c502005-06-27 10:55:12 +02004272 /*
Jens Axboeb0291952009-04-07 11:38:31 +02004273 * We saw a request before the queue expired, let it through
4274 */
4275 if (cfq_cfqq_must_dispatch(cfqq))
4276 goto out_kick;
4277
4278 /*
Jens Axboe22e2c502005-06-27 10:55:12 +02004279 * expired
4280 */
Jens Axboe44f7c162007-01-19 11:51:58 +11004281 if (cfq_slice_used(cfqq))
Jens Axboe22e2c502005-06-27 10:55:12 +02004282 goto expire;
4283
4284 /*
4285 * only expire and reinvoke request handler, if there are
4286 * other queues with pending requests
4287 */
Jens Axboecaaa5f92006-06-16 11:23:00 +02004288 if (!cfqd->busy_queues)
Jens Axboe22e2c502005-06-27 10:55:12 +02004289 goto out_cont;
Jens Axboe22e2c502005-06-27 10:55:12 +02004290
4291 /*
4292 * not expired and it has a request pending, let it dispatch
4293 */
Jens Axboe75e50982009-04-07 08:56:14 +02004294 if (!RB_EMPTY_ROOT(&cfqq->sort_list))
Jens Axboe22e2c502005-06-27 10:55:12 +02004295 goto out_kick;
Corrado Zoccolo76280af2009-11-26 10:02:58 +01004296
4297 /*
4298 * Queue depth flag is reset only when the idle didn't succeed
4299 */
4300 cfq_clear_cfqq_deep(cfqq);
Jens Axboe22e2c502005-06-27 10:55:12 +02004301 }
4302expire:
Vivek Goyale5ff0822010-04-26 19:25:11 +02004303 cfq_slice_expired(cfqd, timed_out);
Jens Axboe22e2c502005-06-27 10:55:12 +02004304out_kick:
Jens Axboe23e018a2009-10-05 08:52:35 +02004305 cfq_schedule_dispatch(cfqd);
Jens Axboe22e2c502005-06-27 10:55:12 +02004306out_cont:
4307 spin_unlock_irqrestore(cfqd->queue->queue_lock, flags);
4308}
4309
Jens Axboe3b181522005-06-27 10:56:24 +02004310static void cfq_shutdown_timer_wq(struct cfq_data *cfqd)
4311{
4312 del_timer_sync(&cfqd->idle_slice_timer);
Jens Axboe23e018a2009-10-05 08:52:35 +02004313 cancel_work_sync(&cfqd->unplug_work);
Jens Axboe3b181522005-06-27 10:56:24 +02004314}
Jens Axboe22e2c502005-06-27 10:55:12 +02004315
Vasily Tarasovc2dea2d2007-07-20 10:06:38 +02004316static void cfq_put_async_queues(struct cfq_data *cfqd)
4317{
4318 int i;
4319
4320 for (i = 0; i < IOPRIO_BE_NR; i++) {
4321 if (cfqd->async_cfqq[0][i])
4322 cfq_put_queue(cfqd->async_cfqq[0][i]);
4323 if (cfqd->async_cfqq[1][i])
4324 cfq_put_queue(cfqd->async_cfqq[1][i]);
Vasily Tarasovc2dea2d2007-07-20 10:06:38 +02004325 }
Oleg Nesterov2389d1e2007-11-05 08:58:05 +01004326
4327 if (cfqd->async_idle_cfqq)
4328 cfq_put_queue(cfqd->async_idle_cfqq);
Vasily Tarasovc2dea2d2007-07-20 10:06:38 +02004329}
4330
Jens Axboeb374d182008-10-31 10:05:07 +01004331static void cfq_exit_queue(struct elevator_queue *e)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004332{
Jens Axboe22e2c502005-06-27 10:55:12 +02004333 struct cfq_data *cfqd = e->elevator_data;
Jens Axboe165125e2007-07-24 09:28:11 +02004334 struct request_queue *q = cfqd->queue;
Jens Axboe22e2c502005-06-27 10:55:12 +02004335
Jens Axboe3b181522005-06-27 10:56:24 +02004336 cfq_shutdown_timer_wq(cfqd);
Jens Axboee2d74ac2006-03-28 08:59:01 +02004337
Al Virod9ff4182006-03-18 13:51:22 -05004338 spin_lock_irq(q->queue_lock);
Jens Axboee2d74ac2006-03-28 08:59:01 +02004339
Al Virod9ff4182006-03-18 13:51:22 -05004340 if (cfqd->active_queue)
Vivek Goyale5ff0822010-04-26 19:25:11 +02004341 __cfq_slice_expired(cfqd, cfqd->active_queue, 0);
Jens Axboee2d74ac2006-03-28 08:59:01 +02004342
Vasily Tarasovc2dea2d2007-07-20 10:06:38 +02004343 cfq_put_async_queues(cfqd);
Tejun Heo03aa2642012-03-05 13:15:19 -08004344
4345 spin_unlock_irq(q->queue_lock);
4346
Al Viroa90d7422006-03-18 12:05:37 -05004347 cfq_shutdown_timer_wq(cfqd);
4348
Tejun Heoffea73f2012-06-04 10:02:29 +02004349#ifdef CONFIG_CFQ_GROUP_IOSCHED
4350 blkcg_deactivate_policy(q, &blkcg_policy_cfq);
4351#else
Tejun Heof51b8022012-03-05 13:15:05 -08004352 kfree(cfqd->root_group);
Vivek Goyal2abae552011-05-23 10:02:19 +02004353#endif
Vivek Goyal56edf7d2011-05-19 15:38:22 -04004354 kfree(cfqd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004355}
4356
Jianpeng Mad50235b2013-07-03 13:25:24 +02004357static int cfq_init_queue(struct request_queue *q, struct elevator_type *e)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004358{
4359 struct cfq_data *cfqd;
Tejun Heo3c798392012-04-16 13:57:25 -07004360 struct blkcg_gq *blkg __maybe_unused;
Tejun Heoa2b16932012-04-13 13:11:33 -07004361 int i, ret;
Jianpeng Mad50235b2013-07-03 13:25:24 +02004362 struct elevator_queue *eq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004363
Jianpeng Mad50235b2013-07-03 13:25:24 +02004364 eq = elevator_alloc(q, e);
4365 if (!eq)
Tejun Heob2fab5a2012-03-05 13:14:57 -08004366 return -ENOMEM;
Konstantin Khlebnikov80b15c72010-05-20 23:21:41 +04004367
Joe Perchesc1b511e2013-08-29 15:21:42 -07004368 cfqd = kzalloc_node(sizeof(*cfqd), GFP_KERNEL, q->node);
Jianpeng Mad50235b2013-07-03 13:25:24 +02004369 if (!cfqd) {
4370 kobject_put(&eq->kobj);
4371 return -ENOMEM;
4372 }
4373 eq->elevator_data = cfqd;
4374
Tejun Heof51b8022012-03-05 13:15:05 -08004375 cfqd->queue = q;
Jianpeng Mad50235b2013-07-03 13:25:24 +02004376 spin_lock_irq(q->queue_lock);
4377 q->elevator = eq;
4378 spin_unlock_irq(q->queue_lock);
Tejun Heof51b8022012-03-05 13:15:05 -08004379
Vivek Goyal1fa8f6d2009-12-03 12:59:41 -05004380 /* Init root service tree */
4381 cfqd->grp_service_tree = CFQ_RB_ROOT;
4382
Tejun Heof51b8022012-03-05 13:15:05 -08004383 /* Init root group and prefer root group over other groups by default */
Vivek Goyal25fb5162009-12-03 12:59:46 -05004384#ifdef CONFIG_CFQ_GROUP_IOSCHED
Tejun Heo3c798392012-04-16 13:57:25 -07004385 ret = blkcg_activate_policy(q, &blkcg_policy_cfq);
Tejun Heoa2b16932012-04-13 13:11:33 -07004386 if (ret)
4387 goto out_free;
Vivek Goyal5624a4e2011-05-19 15:38:28 -04004388
Tejun Heoa2b16932012-04-13 13:11:33 -07004389 cfqd->root_group = blkg_to_cfqg(q->root_blkg);
Tejun Heof51b8022012-03-05 13:15:05 -08004390#else
Tejun Heoa2b16932012-04-13 13:11:33 -07004391 ret = -ENOMEM;
Tejun Heof51b8022012-03-05 13:15:05 -08004392 cfqd->root_group = kzalloc_node(sizeof(*cfqd->root_group),
4393 GFP_KERNEL, cfqd->queue->node);
Tejun Heoa2b16932012-04-13 13:11:33 -07004394 if (!cfqd->root_group)
4395 goto out_free;
Vivek Goyal5624a4e2011-05-19 15:38:28 -04004396
Tejun Heoa2b16932012-04-13 13:11:33 -07004397 cfq_init_cfqg_base(cfqd->root_group);
4398#endif
Tejun Heo3381cb82012-04-01 14:38:44 -07004399 cfqd->root_group->weight = 2 * CFQ_WEIGHT_DEFAULT;
Tejun Heoe71357e2013-01-09 08:05:10 -08004400 cfqd->root_group->leaf_weight = 2 * CFQ_WEIGHT_DEFAULT;
Vivek Goyal5624a4e2011-05-19 15:38:28 -04004401
Jens Axboe26a2ac02009-04-23 12:13:27 +02004402 /*
4403 * Not strictly needed (since RB_ROOT just clears the node and we
4404 * zeroed cfqd on alloc), but better be safe in case someone decides
4405 * to add magic to the rb code
4406 */
4407 for (i = 0; i < CFQ_PRIO_LISTS; i++)
4408 cfqd->prio_trees[i] = RB_ROOT;
4409
Jens Axboe6118b702009-06-30 09:34:12 +02004410 /*
4411 * Our fallback cfqq if cfq_find_alloc_queue() runs into OOM issues.
4412 * Grab a permanent reference to it, so that the normal code flow
Tejun Heof51b8022012-03-05 13:15:05 -08004413 * will not attempt to free it. oom_cfqq is linked to root_group
4414 * but shouldn't hold a reference as it'll never be unlinked. Lose
4415 * the reference from linking right away.
Jens Axboe6118b702009-06-30 09:34:12 +02004416 */
4417 cfq_init_cfqq(cfqd, &cfqd->oom_cfqq, 1, 0);
Shaohua Li30d7b942011-01-07 08:46:59 +01004418 cfqd->oom_cfqq.ref++;
Tejun Heo1adaf3d2012-03-05 13:15:15 -08004419
4420 spin_lock_irq(q->queue_lock);
Tejun Heof51b8022012-03-05 13:15:05 -08004421 cfq_link_cfqq_cfqg(&cfqd->oom_cfqq, cfqd->root_group);
Tejun Heoeb7d8c072012-03-23 14:02:53 +01004422 cfqg_put(cfqd->root_group);
Tejun Heo1adaf3d2012-03-05 13:15:15 -08004423 spin_unlock_irq(q->queue_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004424
Jens Axboe22e2c502005-06-27 10:55:12 +02004425 init_timer(&cfqd->idle_slice_timer);
4426 cfqd->idle_slice_timer.function = cfq_idle_slice_timer;
4427 cfqd->idle_slice_timer.data = (unsigned long) cfqd;
4428
Jens Axboe23e018a2009-10-05 08:52:35 +02004429 INIT_WORK(&cfqd->unplug_work, cfq_kick_queue);
Jens Axboe22e2c502005-06-27 10:55:12 +02004430
Linus Torvalds1da177e2005-04-16 15:20:36 -07004431 cfqd->cfq_quantum = cfq_quantum;
Jens Axboe22e2c502005-06-27 10:55:12 +02004432 cfqd->cfq_fifo_expire[0] = cfq_fifo_expire[0];
4433 cfqd->cfq_fifo_expire[1] = cfq_fifo_expire[1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07004434 cfqd->cfq_back_max = cfq_back_max;
4435 cfqd->cfq_back_penalty = cfq_back_penalty;
Jens Axboe22e2c502005-06-27 10:55:12 +02004436 cfqd->cfq_slice[0] = cfq_slice_async;
4437 cfqd->cfq_slice[1] = cfq_slice_sync;
Tao Ma5bf14c02012-04-01 14:33:39 -07004438 cfqd->cfq_target_latency = cfq_target_latency;
Jens Axboe22e2c502005-06-27 10:55:12 +02004439 cfqd->cfq_slice_async_rq = cfq_slice_async_rq;
4440 cfqd->cfq_slice_idle = cfq_slice_idle;
Vivek Goyal80bdf0c2010-08-23 12:24:26 +02004441 cfqd->cfq_group_idle = cfq_group_idle;
Jens Axboe963b72f2009-10-03 19:42:18 +02004442 cfqd->cfq_latency = 1;
Corrado Zoccoloe459dd02009-11-26 10:02:57 +01004443 cfqd->hw_tag = -1;
Corrado Zoccoloedc71132009-12-09 20:56:04 +01004444 /*
4445 * we optimistically start assuming sync ops weren't delayed in last
4446 * second, in order to have larger depth for async operations.
4447 */
Corrado Zoccolo573412b2009-12-06 11:48:52 +01004448 cfqd->last_delayed_sync = jiffies - HZ;
Tejun Heob2fab5a2012-03-05 13:14:57 -08004449 return 0;
Tejun Heoa2b16932012-04-13 13:11:33 -07004450
4451out_free:
4452 kfree(cfqd);
Jianpeng Mad50235b2013-07-03 13:25:24 +02004453 kobject_put(&eq->kobj);
Tejun Heoa2b16932012-04-13 13:11:33 -07004454 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004455}
4456
Linus Torvalds1da177e2005-04-16 15:20:36 -07004457/*
4458 * sysfs parts below -->
4459 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004460static ssize_t
4461cfq_var_show(unsigned int var, char *page)
4462{
Masanari Iida176167a2014-04-28 12:38:34 +09004463 return sprintf(page, "%u\n", var);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004464}
4465
4466static ssize_t
4467cfq_var_store(unsigned int *var, const char *page, size_t count)
4468{
4469 char *p = (char *) page;
4470
4471 *var = simple_strtoul(p, &p, 10);
4472 return count;
4473}
4474
Linus Torvalds1da177e2005-04-16 15:20:36 -07004475#define SHOW_FUNCTION(__FUNC, __VAR, __CONV) \
Jens Axboeb374d182008-10-31 10:05:07 +01004476static ssize_t __FUNC(struct elevator_queue *e, char *page) \
Linus Torvalds1da177e2005-04-16 15:20:36 -07004477{ \
Al Viro3d1ab402006-03-18 18:35:43 -05004478 struct cfq_data *cfqd = e->elevator_data; \
Linus Torvalds1da177e2005-04-16 15:20:36 -07004479 unsigned int __data = __VAR; \
4480 if (__CONV) \
4481 __data = jiffies_to_msecs(__data); \
4482 return cfq_var_show(__data, (page)); \
4483}
4484SHOW_FUNCTION(cfq_quantum_show, cfqd->cfq_quantum, 0);
Jens Axboe22e2c502005-06-27 10:55:12 +02004485SHOW_FUNCTION(cfq_fifo_expire_sync_show, cfqd->cfq_fifo_expire[1], 1);
4486SHOW_FUNCTION(cfq_fifo_expire_async_show, cfqd->cfq_fifo_expire[0], 1);
Al Viroe572ec72006-03-18 22:27:18 -05004487SHOW_FUNCTION(cfq_back_seek_max_show, cfqd->cfq_back_max, 0);
4488SHOW_FUNCTION(cfq_back_seek_penalty_show, cfqd->cfq_back_penalty, 0);
Jens Axboe22e2c502005-06-27 10:55:12 +02004489SHOW_FUNCTION(cfq_slice_idle_show, cfqd->cfq_slice_idle, 1);
Vivek Goyal80bdf0c2010-08-23 12:24:26 +02004490SHOW_FUNCTION(cfq_group_idle_show, cfqd->cfq_group_idle, 1);
Jens Axboe22e2c502005-06-27 10:55:12 +02004491SHOW_FUNCTION(cfq_slice_sync_show, cfqd->cfq_slice[1], 1);
4492SHOW_FUNCTION(cfq_slice_async_show, cfqd->cfq_slice[0], 1);
4493SHOW_FUNCTION(cfq_slice_async_rq_show, cfqd->cfq_slice_async_rq, 0);
Jens Axboe963b72f2009-10-03 19:42:18 +02004494SHOW_FUNCTION(cfq_low_latency_show, cfqd->cfq_latency, 0);
Tao Ma5bf14c02012-04-01 14:33:39 -07004495SHOW_FUNCTION(cfq_target_latency_show, cfqd->cfq_target_latency, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004496#undef SHOW_FUNCTION
4497
4498#define STORE_FUNCTION(__FUNC, __PTR, MIN, MAX, __CONV) \
Jens Axboeb374d182008-10-31 10:05:07 +01004499static ssize_t __FUNC(struct elevator_queue *e, const char *page, size_t count) \
Linus Torvalds1da177e2005-04-16 15:20:36 -07004500{ \
Al Viro3d1ab402006-03-18 18:35:43 -05004501 struct cfq_data *cfqd = e->elevator_data; \
Linus Torvalds1da177e2005-04-16 15:20:36 -07004502 unsigned int __data; \
4503 int ret = cfq_var_store(&__data, (page), count); \
4504 if (__data < (MIN)) \
4505 __data = (MIN); \
4506 else if (__data > (MAX)) \
4507 __data = (MAX); \
4508 if (__CONV) \
4509 *(__PTR) = msecs_to_jiffies(__data); \
4510 else \
4511 *(__PTR) = __data; \
4512 return ret; \
4513}
4514STORE_FUNCTION(cfq_quantum_store, &cfqd->cfq_quantum, 1, UINT_MAX, 0);
Jens Axboefe094d92008-01-31 13:08:54 +01004515STORE_FUNCTION(cfq_fifo_expire_sync_store, &cfqd->cfq_fifo_expire[1], 1,
4516 UINT_MAX, 1);
4517STORE_FUNCTION(cfq_fifo_expire_async_store, &cfqd->cfq_fifo_expire[0], 1,
4518 UINT_MAX, 1);
Al Viroe572ec72006-03-18 22:27:18 -05004519STORE_FUNCTION(cfq_back_seek_max_store, &cfqd->cfq_back_max, 0, UINT_MAX, 0);
Jens Axboefe094d92008-01-31 13:08:54 +01004520STORE_FUNCTION(cfq_back_seek_penalty_store, &cfqd->cfq_back_penalty, 1,
4521 UINT_MAX, 0);
Jens Axboe22e2c502005-06-27 10:55:12 +02004522STORE_FUNCTION(cfq_slice_idle_store, &cfqd->cfq_slice_idle, 0, UINT_MAX, 1);
Vivek Goyal80bdf0c2010-08-23 12:24:26 +02004523STORE_FUNCTION(cfq_group_idle_store, &cfqd->cfq_group_idle, 0, UINT_MAX, 1);
Jens Axboe22e2c502005-06-27 10:55:12 +02004524STORE_FUNCTION(cfq_slice_sync_store, &cfqd->cfq_slice[1], 1, UINT_MAX, 1);
4525STORE_FUNCTION(cfq_slice_async_store, &cfqd->cfq_slice[0], 1, UINT_MAX, 1);
Jens Axboefe094d92008-01-31 13:08:54 +01004526STORE_FUNCTION(cfq_slice_async_rq_store, &cfqd->cfq_slice_async_rq, 1,
4527 UINT_MAX, 0);
Jens Axboe963b72f2009-10-03 19:42:18 +02004528STORE_FUNCTION(cfq_low_latency_store, &cfqd->cfq_latency, 0, 1, 0);
Tao Ma5bf14c02012-04-01 14:33:39 -07004529STORE_FUNCTION(cfq_target_latency_store, &cfqd->cfq_target_latency, 1, UINT_MAX, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004530#undef STORE_FUNCTION
4531
Al Viroe572ec72006-03-18 22:27:18 -05004532#define CFQ_ATTR(name) \
4533 __ATTR(name, S_IRUGO|S_IWUSR, cfq_##name##_show, cfq_##name##_store)
Jens Axboe3b181522005-06-27 10:56:24 +02004534
Al Viroe572ec72006-03-18 22:27:18 -05004535static struct elv_fs_entry cfq_attrs[] = {
4536 CFQ_ATTR(quantum),
Al Viroe572ec72006-03-18 22:27:18 -05004537 CFQ_ATTR(fifo_expire_sync),
4538 CFQ_ATTR(fifo_expire_async),
4539 CFQ_ATTR(back_seek_max),
4540 CFQ_ATTR(back_seek_penalty),
4541 CFQ_ATTR(slice_sync),
4542 CFQ_ATTR(slice_async),
4543 CFQ_ATTR(slice_async_rq),
4544 CFQ_ATTR(slice_idle),
Vivek Goyal80bdf0c2010-08-23 12:24:26 +02004545 CFQ_ATTR(group_idle),
Jens Axboe963b72f2009-10-03 19:42:18 +02004546 CFQ_ATTR(low_latency),
Tao Ma5bf14c02012-04-01 14:33:39 -07004547 CFQ_ATTR(target_latency),
Al Viroe572ec72006-03-18 22:27:18 -05004548 __ATTR_NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -07004549};
4550
Linus Torvalds1da177e2005-04-16 15:20:36 -07004551static struct elevator_type iosched_cfq = {
4552 .ops = {
4553 .elevator_merge_fn = cfq_merge,
4554 .elevator_merged_fn = cfq_merged_request,
4555 .elevator_merge_req_fn = cfq_merged_requests,
Jens Axboeda775262006-12-20 11:04:12 +01004556 .elevator_allow_merge_fn = cfq_allow_merge,
Divyesh Shah812d4022010-04-08 21:14:23 -07004557 .elevator_bio_merged_fn = cfq_bio_merged,
Jens Axboeb4878f22005-10-20 16:42:29 +02004558 .elevator_dispatch_fn = cfq_dispatch_requests,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004559 .elevator_add_req_fn = cfq_insert_request,
Jens Axboeb4878f22005-10-20 16:42:29 +02004560 .elevator_activate_req_fn = cfq_activate_request,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004561 .elevator_deactivate_req_fn = cfq_deactivate_request,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004562 .elevator_completed_req_fn = cfq_completed_request,
Jens Axboe21183b02006-07-13 12:33:14 +02004563 .elevator_former_req_fn = elv_rb_former_request,
4564 .elevator_latter_req_fn = elv_rb_latter_request,
Tejun Heo9b84cac2011-12-14 00:33:42 +01004565 .elevator_init_icq_fn = cfq_init_icq,
Tejun Heo7e5a8792011-12-14 00:33:42 +01004566 .elevator_exit_icq_fn = cfq_exit_icq,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004567 .elevator_set_req_fn = cfq_set_request,
4568 .elevator_put_req_fn = cfq_put_request,
4569 .elevator_may_queue_fn = cfq_may_queue,
4570 .elevator_init_fn = cfq_init_queue,
4571 .elevator_exit_fn = cfq_exit_queue,
4572 },
Tejun Heo3d3c2372011-12-14 00:33:42 +01004573 .icq_size = sizeof(struct cfq_io_cq),
4574 .icq_align = __alignof__(struct cfq_io_cq),
Al Viro3d1ab402006-03-18 18:35:43 -05004575 .elevator_attrs = cfq_attrs,
Tejun Heo3d3c2372011-12-14 00:33:42 +01004576 .elevator_name = "cfq",
Linus Torvalds1da177e2005-04-16 15:20:36 -07004577 .elevator_owner = THIS_MODULE,
4578};
4579
Vivek Goyal3e252062009-12-04 10:36:42 -05004580#ifdef CONFIG_CFQ_GROUP_IOSCHED
Tejun Heo3c798392012-04-16 13:57:25 -07004581static struct blkcg_policy blkcg_policy_cfq = {
Tejun Heof9fcc2d2012-04-16 13:57:27 -07004582 .pd_size = sizeof(struct cfq_group),
4583 .cftypes = cfq_blkcg_files,
4584
4585 .pd_init_fn = cfq_pd_init,
Tejun Heo0b399202013-01-09 08:05:13 -08004586 .pd_offline_fn = cfq_pd_offline,
Tejun Heof9fcc2d2012-04-16 13:57:27 -07004587 .pd_reset_stats_fn = cfq_pd_reset_stats,
Vivek Goyal3e252062009-12-04 10:36:42 -05004588};
Vivek Goyal3e252062009-12-04 10:36:42 -05004589#endif
4590
Linus Torvalds1da177e2005-04-16 15:20:36 -07004591static int __init cfq_init(void)
4592{
Tejun Heo3d3c2372011-12-14 00:33:42 +01004593 int ret;
4594
Jens Axboe22e2c502005-06-27 10:55:12 +02004595 /*
4596 * could be 0 on HZ < 1000 setups
4597 */
4598 if (!cfq_slice_async)
4599 cfq_slice_async = 1;
4600 if (!cfq_slice_idle)
4601 cfq_slice_idle = 1;
4602
Vivek Goyal80bdf0c2010-08-23 12:24:26 +02004603#ifdef CONFIG_CFQ_GROUP_IOSCHED
4604 if (!cfq_group_idle)
4605 cfq_group_idle = 1;
Tejun Heo8bd435b2012-04-13 13:11:28 -07004606
Tejun Heo3c798392012-04-16 13:57:25 -07004607 ret = blkcg_policy_register(&blkcg_policy_cfq);
Tejun Heo8bd435b2012-04-13 13:11:28 -07004608 if (ret)
4609 return ret;
Tejun Heoffea73f2012-06-04 10:02:29 +02004610#else
4611 cfq_group_idle = 0;
4612#endif
Tejun Heo8bd435b2012-04-13 13:11:28 -07004613
Tejun Heofd794952012-06-04 10:01:38 +02004614 ret = -ENOMEM;
Tejun Heo3d3c2372011-12-14 00:33:42 +01004615 cfq_pool = KMEM_CACHE(cfq_queue, 0);
4616 if (!cfq_pool)
Tejun Heo8bd435b2012-04-13 13:11:28 -07004617 goto err_pol_unreg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004618
Tejun Heo3d3c2372011-12-14 00:33:42 +01004619 ret = elv_register(&iosched_cfq);
Tejun Heo8bd435b2012-04-13 13:11:28 -07004620 if (ret)
4621 goto err_free_pool;
Tejun Heo3d3c2372011-12-14 00:33:42 +01004622
Adrian Bunk2fdd82b2007-12-12 18:51:56 +01004623 return 0;
Tejun Heo8bd435b2012-04-13 13:11:28 -07004624
4625err_free_pool:
4626 kmem_cache_destroy(cfq_pool);
4627err_pol_unreg:
Tejun Heoffea73f2012-06-04 10:02:29 +02004628#ifdef CONFIG_CFQ_GROUP_IOSCHED
Tejun Heo3c798392012-04-16 13:57:25 -07004629 blkcg_policy_unregister(&blkcg_policy_cfq);
Tejun Heoffea73f2012-06-04 10:02:29 +02004630#endif
Tejun Heo8bd435b2012-04-13 13:11:28 -07004631 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004632}
4633
4634static void __exit cfq_exit(void)
4635{
Tejun Heoffea73f2012-06-04 10:02:29 +02004636#ifdef CONFIG_CFQ_GROUP_IOSCHED
Tejun Heo3c798392012-04-16 13:57:25 -07004637 blkcg_policy_unregister(&blkcg_policy_cfq);
Tejun Heoffea73f2012-06-04 10:02:29 +02004638#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07004639 elv_unregister(&iosched_cfq);
Tejun Heo3d3c2372011-12-14 00:33:42 +01004640 kmem_cache_destroy(cfq_pool);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004641}
4642
4643module_init(cfq_init);
4644module_exit(cfq_exit);
4645
4646MODULE_AUTHOR("Jens Axboe");
4647MODULE_LICENSE("GPL");
4648MODULE_DESCRIPTION("Completely Fair Queueing IO scheduler");