Commit 22e2c507 authored by Jens Axboe's avatar Jens Axboe Committed by Linus Torvalds

[PATCH] Update cfq io scheduler to time sliced design

This updates the CFQ io scheduler to the new time sliced design (cfq
v3).  It provides full process fairness, while giving excellent
aggregate system throughput even for many competing processes.  It
supports io priorities, either inherited from the cpu nice value or set
directly with the ioprio_get/set syscalls.  The latter closely mimic
set/getpriority.

This import is based on my latest from -mm.
Signed-off-by: default avatarJens Axboe <axboe@suse.de>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent 020f46a3
...@@ -289,3 +289,5 @@ ENTRY(sys_call_table) ...@@ -289,3 +289,5 @@ ENTRY(sys_call_table)
.long sys_add_key .long sys_add_key
.long sys_request_key .long sys_request_key
.long sys_keyctl .long sys_keyctl
.long sys_ioprio_set
.long sys_ioprio_get /* 290 */
...@@ -1577,8 +1577,8 @@ sys_call_table: ...@@ -1577,8 +1577,8 @@ sys_call_table:
data8 sys_add_key data8 sys_add_key
data8 sys_request_key data8 sys_request_key
data8 sys_keyctl data8 sys_keyctl
data8 sys_ni_syscall data8 sys_ioprio_set
data8 sys_ni_syscall // 1275 data8 sys_ioprio_get // 1275
data8 sys_set_zone_reclaim data8 sys_set_zone_reclaim
data8 sys_ni_syscall data8 sys_ni_syscall
data8 sys_ni_syscall data8 sys_ni_syscall
......
...@@ -1449,3 +1449,5 @@ _GLOBAL(sys_call_table) ...@@ -1449,3 +1449,5 @@ _GLOBAL(sys_call_table)
.long sys_request_key /* 270 */ .long sys_request_key /* 270 */
.long sys_keyctl .long sys_keyctl
.long sys_waitid .long sys_waitid
.long sys_ioprio_set
.long sys_ioprio_get
...@@ -1806,7 +1806,8 @@ static void as_put_request(request_queue_t *q, struct request *rq) ...@@ -1806,7 +1806,8 @@ static void as_put_request(request_queue_t *q, struct request *rq)
rq->elevator_private = NULL; rq->elevator_private = NULL;
} }
static int as_set_request(request_queue_t *q, struct request *rq, int gfp_mask) static int as_set_request(request_queue_t *q, struct request *rq,
struct bio *bio, int gfp_mask)
{ {
struct as_data *ad = q->elevator->elevator_data; struct as_data *ad = q->elevator->elevator_data;
struct as_rq *arq = mempool_alloc(ad->arq_pool, gfp_mask); struct as_rq *arq = mempool_alloc(ad->arq_pool, gfp_mask);
...@@ -1827,7 +1828,7 @@ static int as_set_request(request_queue_t *q, struct request *rq, int gfp_mask) ...@@ -1827,7 +1828,7 @@ static int as_set_request(request_queue_t *q, struct request *rq, int gfp_mask)
return 1; return 1;
} }
static int as_may_queue(request_queue_t *q, int rw) static int as_may_queue(request_queue_t *q, int rw, struct bio *bio)
{ {
int ret = ELV_MQUEUE_MAY; int ret = ELV_MQUEUE_MAY;
struct as_data *ad = q->elevator->elevator_data; struct as_data *ad = q->elevator->elevator_data;
......
...@@ -21,22 +21,33 @@ ...@@ -21,22 +21,33 @@
#include <linux/hash.h> #include <linux/hash.h>
#include <linux/rbtree.h> #include <linux/rbtree.h>
#include <linux/mempool.h> #include <linux/mempool.h>
#include <linux/ioprio.h>
static unsigned long max_elapsed_crq; #include <linux/writeback.h>
static unsigned long max_elapsed_dispatch;
/* /*
* tunables * tunables
*/ */
static int cfq_quantum = 4; /* max queue in one round of service */ static int cfq_quantum = 4; /* max queue in one round of service */
static int cfq_queued = 8; /* minimum rq allocate limit per-queue*/ static int cfq_queued = 8; /* minimum rq allocate limit per-queue*/
static int cfq_service = HZ; /* period over which service is avg */ static int cfq_fifo_expire[2] = { HZ / 4, HZ / 8 };
static int cfq_fifo_expire_r = HZ / 2; /* fifo timeout for sync requests */
static int cfq_fifo_expire_w = 5 * HZ; /* fifo timeout for async requests */
static int cfq_fifo_rate = HZ / 8; /* fifo expiry rate */
static int cfq_back_max = 16 * 1024; /* maximum backwards seek, in KiB */ static int cfq_back_max = 16 * 1024; /* maximum backwards seek, in KiB */
static int cfq_back_penalty = 2; /* penalty of a backwards seek */ static int cfq_back_penalty = 2; /* penalty of a backwards seek */
static int cfq_slice_sync = HZ / 10;
static int cfq_slice_async = HZ / 50;
static int cfq_slice_async_rq = 2;
static int cfq_slice_idle = HZ / 50;
#define CFQ_IDLE_GRACE (HZ / 10)
#define CFQ_SLICE_SCALE (5)
#define CFQ_KEY_ASYNC (0)
/*
* disable queueing at the driver/hardware level
*/
static int cfq_max_depth = 1;
/* /*
* for the hash of cfqq inside the cfqd * for the hash of cfqq inside the cfqd
*/ */
...@@ -55,6 +66,7 @@ static int cfq_back_penalty = 2; /* penalty of a backwards seek */ ...@@ -55,6 +66,7 @@ static int cfq_back_penalty = 2; /* penalty of a backwards seek */
#define list_entry_hash(ptr) hlist_entry((ptr), struct cfq_rq, hash) #define list_entry_hash(ptr) hlist_entry((ptr), struct cfq_rq, hash)
#define list_entry_cfqq(ptr) list_entry((ptr), struct cfq_queue, cfq_list) #define list_entry_cfqq(ptr) list_entry((ptr), struct cfq_queue, cfq_list)
#define list_entry_fifo(ptr) list_entry((ptr), struct request, queuelist)
#define RQ_DATA(rq) (rq)->elevator_private #define RQ_DATA(rq) (rq)->elevator_private
...@@ -75,78 +87,101 @@ static int cfq_back_penalty = 2; /* penalty of a backwards seek */ ...@@ -75,78 +87,101 @@ static int cfq_back_penalty = 2; /* penalty of a backwards seek */
#define rb_entry_crq(node) rb_entry((node), struct cfq_rq, rb_node) #define rb_entry_crq(node) rb_entry((node), struct cfq_rq, rb_node)
#define rq_rb_key(rq) (rq)->sector #define rq_rb_key(rq) (rq)->sector
/*
* threshold for switching off non-tag accounting
*/
#define CFQ_MAX_TAG (4)
/*
* sort key types and names
*/
enum {
CFQ_KEY_PGID,
CFQ_KEY_TGID,
CFQ_KEY_UID,
CFQ_KEY_GID,
CFQ_KEY_LAST,
};
static char *cfq_key_types[] = { "pgid", "tgid", "uid", "gid", NULL };
static kmem_cache_t *crq_pool; static kmem_cache_t *crq_pool;
static kmem_cache_t *cfq_pool; static kmem_cache_t *cfq_pool;
static kmem_cache_t *cfq_ioc_pool; static kmem_cache_t *cfq_ioc_pool;
#define CFQ_PRIO_LISTS IOPRIO_BE_NR
#define cfq_class_idle(cfqq) ((cfqq)->ioprio_class == IOPRIO_CLASS_IDLE)
#define cfq_class_be(cfqq) ((cfqq)->ioprio_class == IOPRIO_CLASS_BE)
#define cfq_class_rt(cfqq) ((cfqq)->ioprio_class == IOPRIO_CLASS_RT)
#define cfq_cfqq_sync(cfqq) ((cfqq)->key != CFQ_KEY_ASYNC)
/*
* Per block device queue structure
*/
struct cfq_data { struct cfq_data {
struct list_head rr_list; atomic_t ref;
request_queue_t *queue;
/*
* rr list of queues with requests and the count of them
*/
struct list_head rr_list[CFQ_PRIO_LISTS];
struct list_head busy_rr;
struct list_head cur_rr;
struct list_head idle_rr;
unsigned int busy_queues;
/*
* non-ordered list of empty cfqq's
*/
struct list_head empty_list; struct list_head empty_list;
/*
* cfqq lookup hash
*/
struct hlist_head *cfq_hash; struct hlist_head *cfq_hash;
struct hlist_head *crq_hash;
/* queues on rr_list (ie they have pending requests */ /*
unsigned int busy_queues; * global crq hash for all queues
*/
struct hlist_head *crq_hash;
unsigned int max_queued; unsigned int max_queued;
atomic_t ref; mempool_t *crq_pool;
int key_type; int rq_in_driver;
mempool_t *crq_pool; /*
* schedule slice state info
*/
/*
* idle window management
*/
struct timer_list idle_slice_timer;
struct work_struct unplug_work;
request_queue_t *queue; struct cfq_queue *active_queue;
struct cfq_io_context *active_cic;
int cur_prio, cur_end_prio;
unsigned int dispatch_slice;
struct timer_list idle_class_timer;
sector_t last_sector; sector_t last_sector;
unsigned long last_end_request;
int rq_in_driver; unsigned int rq_starved;
/* /*
* tunables, see top of file * tunables, see top of file
*/ */
unsigned int cfq_quantum; unsigned int cfq_quantum;
unsigned int cfq_queued; unsigned int cfq_queued;
unsigned int cfq_fifo_expire_r; unsigned int cfq_fifo_expire[2];
unsigned int cfq_fifo_expire_w;
unsigned int cfq_fifo_batch_expire;
unsigned int cfq_back_penalty; unsigned int cfq_back_penalty;
unsigned int cfq_back_max; unsigned int cfq_back_max;
unsigned int find_best_crq; unsigned int cfq_slice[2];
unsigned int cfq_slice_async_rq;
unsigned int cfq_tagged; unsigned int cfq_slice_idle;
unsigned int cfq_max_depth;
}; };
/*
* Per process-grouping structure
*/
struct cfq_queue { struct cfq_queue {
/* reference count */ /* reference count */
atomic_t ref; atomic_t ref;
/* parent cfq_data */ /* parent cfq_data */
struct cfq_data *cfqd; struct cfq_data *cfqd;
/* hash of mergeable requests */ /* cfqq lookup hash */
struct hlist_node cfq_hash; struct hlist_node cfq_hash;
/* hash key */ /* hash key */
unsigned long key; unsigned int key;
/* whether queue is on rr (or empty) list */
int on_rr;
/* on either rr or empty list of cfqd */ /* on either rr or empty list of cfqd */
struct list_head cfq_list; struct list_head cfq_list;
/* sorted list of pending requests */ /* sorted list of pending requests */
...@@ -158,21 +193,35 @@ struct cfq_queue { ...@@ -158,21 +193,35 @@ struct cfq_queue {
/* currently allocated requests */ /* currently allocated requests */
int allocated[2]; int allocated[2];
/* fifo list of requests in sort_list */ /* fifo list of requests in sort_list */
struct list_head fifo[2]; struct list_head fifo;
/* last time fifo expired */
unsigned long last_fifo_expire;
int key_type;
unsigned long service_start;
unsigned long service_used;
unsigned int max_rate; unsigned long slice_start;
unsigned long slice_end;
unsigned long slice_left;
unsigned long service_last;
/* number of requests that have been handed to the driver */ /* number of requests that have been handed to the driver */
int in_flight; int in_flight;
/* number of currently allocated requests */
int alloc_limit[2]; /* io prio of this group */
unsigned short ioprio, org_ioprio;
unsigned short ioprio_class, org_ioprio_class;
/* whether queue is on rr (or empty) list */
unsigned on_rr : 1;
/* idle slice, waiting for new request submission */
unsigned wait_request : 1;
/* set when wait_request gets set, reset on first rq alloc */
unsigned must_alloc : 1;
/* only gets one must_alloc per slice */
unsigned must_alloc_slice : 1;
/* idle slice, request added, now waiting to dispatch it */
unsigned must_dispatch : 1;
/* fifo expire per-slice */
unsigned fifo_expire : 1;
unsigned idle_window : 1;
unsigned prio_changed : 1;
}; };
struct cfq_rq { struct cfq_rq {
...@@ -184,42 +233,17 @@ struct cfq_rq { ...@@ -184,42 +233,17 @@ struct cfq_rq {
struct cfq_queue *cfq_queue; struct cfq_queue *cfq_queue;
struct cfq_io_context *io_context; struct cfq_io_context *io_context;
unsigned long service_start; unsigned in_flight : 1;
unsigned long queue_start; unsigned accounted : 1;
unsigned is_sync : 1;
unsigned int in_flight : 1; unsigned requeued : 1;
unsigned int accounted : 1;
unsigned int is_sync : 1;
unsigned int is_write : 1;
}; };
static struct cfq_queue *cfq_find_cfq_hash(struct cfq_data *, unsigned long); static struct cfq_queue *cfq_find_cfq_hash(struct cfq_data *, unsigned int);
static void cfq_dispatch_sort(request_queue_t *, struct cfq_rq *); static void cfq_dispatch_sort(request_queue_t *, struct cfq_rq *);
static void cfq_update_next_crq(struct cfq_rq *);
static void cfq_put_cfqd(struct cfq_data *cfqd); static void cfq_put_cfqd(struct cfq_data *cfqd);
/* #define process_sync(tsk) ((tsk)->flags & PF_SYNCWRITE)
* what the fairness is based on (ie how processes are grouped and
* differentiated)
*/
static inline unsigned long
cfq_hash_key(struct cfq_data *cfqd, struct task_struct *tsk)
{
/*
* optimize this so that ->key_type is the offset into the struct
*/
switch (cfqd->key_type) {
case CFQ_KEY_PGID:
return process_group(tsk);
default:
case CFQ_KEY_TGID:
return tsk->tgid;
case CFQ_KEY_UID:
return tsk->uid;
case CFQ_KEY_GID:
return tsk->gid;
}
}
/* /*
* lots of deadline iosched dupes, can be abstracted later... * lots of deadline iosched dupes, can be abstracted later...
...@@ -235,16 +259,12 @@ static void cfq_remove_merge_hints(request_queue_t *q, struct cfq_rq *crq) ...@@ -235,16 +259,12 @@ static void cfq_remove_merge_hints(request_queue_t *q, struct cfq_rq *crq)
if (q->last_merge == crq->request) if (q->last_merge == crq->request)
q->last_merge = NULL; q->last_merge = NULL;
cfq_update_next_crq(crq);
} }
static inline void cfq_add_crq_hash(struct cfq_data *cfqd, struct cfq_rq *crq) static inline void cfq_add_crq_hash(struct cfq_data *cfqd, struct cfq_rq *crq)
{ {
const int hash_idx = CFQ_MHASH_FN(rq_hash_key(crq->request)); const int hash_idx = CFQ_MHASH_FN(rq_hash_key(crq->request));
BUG_ON(!hlist_unhashed(&crq->hash));
hlist_add_head(&crq->hash, &cfqd->crq_hash[hash_idx]); hlist_add_head(&crq->hash, &cfqd->crq_hash[hash_idx]);
} }
...@@ -257,8 +277,6 @@ static struct request *cfq_find_rq_hash(struct cfq_data *cfqd, sector_t offset) ...@@ -257,8 +277,6 @@ static struct request *cfq_find_rq_hash(struct cfq_data *cfqd, sector_t offset)
struct cfq_rq *crq = list_entry_hash(entry); struct cfq_rq *crq = list_entry_hash(entry);
struct request *__rq = crq->request; struct request *__rq = crq->request;
BUG_ON(hlist_unhashed(&crq->hash));
if (!rq_mergeable(__rq)) { if (!rq_mergeable(__rq)) {
cfq_del_crq_hash(crq); cfq_del_crq_hash(crq);
continue; continue;
...@@ -287,36 +305,16 @@ cfq_choose_req(struct cfq_data *cfqd, struct cfq_rq *crq1, struct cfq_rq *crq2) ...@@ -287,36 +305,16 @@ cfq_choose_req(struct cfq_data *cfqd, struct cfq_rq *crq1, struct cfq_rq *crq2)
return crq2; return crq2;
if (crq2 == NULL) if (crq2 == NULL)
return crq1; return crq1;
if (crq1->requeued)
return crq1;
if (crq2->requeued)
return crq2;
s1 = crq1->request->sector; s1 = crq1->request->sector;
s2 = crq2->request->sector; s2 = crq2->request->sector;
last = cfqd->last_sector; last = cfqd->last_sector;
#if 0
if (!list_empty(&cfqd->queue->queue_head)) {
struct list_head *entry = &cfqd->queue->queue_head;
unsigned long distance = ~0UL;
struct request *rq;
while ((entry = entry->prev) != &cfqd->queue->queue_head) {
rq = list_entry_rq(entry);
if (blk_barrier_rq(rq))
break;
if (distance < abs(s1 - rq->sector + rq->nr_sectors)) {
distance = abs(s1 - rq->sector +rq->nr_sectors);
last = rq->sector + rq->nr_sectors;
}
if (distance < abs(s2 - rq->sector + rq->nr_sectors)) {
distance = abs(s2 - rq->sector +rq->nr_sectors);
last = rq->sector + rq->nr_sectors;
}
}
}
#endif
/* /*
* by definition, 1KiB is 2 sectors * by definition, 1KiB is 2 sectors
*/ */
...@@ -377,11 +375,13 @@ cfq_find_next_crq(struct cfq_data *cfqd, struct cfq_queue *cfqq, ...@@ -377,11 +375,13 @@ cfq_find_next_crq(struct cfq_data *cfqd, struct cfq_queue *cfqq,
struct cfq_rq *crq_next = NULL, *crq_prev = NULL; struct cfq_rq *crq_next = NULL, *crq_prev = NULL;
struct rb_node *rbnext, *rbprev; struct rb_node *rbnext, *rbprev;
if (!ON_RB(&last->rb_node)) if (ON_RB(&last->rb_node))
return NULL; rbnext = rb_next(&last->rb_node);
else {
if ((rbnext = rb_next(&last->rb_node)) == NULL)
rbnext = rb_first(&cfqq->sort_list); rbnext = rb_first(&cfqq->sort_list);
if (rbnext == &last->rb_node)
rbnext = NULL;
}
rbprev = rb_prev(&last->rb_node); rbprev = rb_prev(&last->rb_node);
...@@ -401,67 +401,53 @@ static void cfq_update_next_crq(struct cfq_rq *crq) ...@@ -401,67 +401,53 @@ static void cfq_update_next_crq(struct cfq_rq *crq)
cfqq->next_crq = cfq_find_next_crq(cfqq->cfqd, cfqq, crq); cfqq->next_crq = cfq_find_next_crq(cfqq->cfqd, cfqq, crq);
} }
static int cfq_check_sort_rr_list(struct cfq_queue *cfqq) static void cfq_resort_rr_list(struct cfq_queue *cfqq, int preempted)
{ {
struct list_head *head = &cfqq->cfqd->rr_list; struct cfq_data *cfqd = cfqq->cfqd;
struct list_head *next, *prev; struct list_head *list, *entry;
/*
* list might still be ordered
*/
next = cfqq->cfq_list.next;
if (next != head) {
struct cfq_queue *cnext = list_entry_cfqq(next);
if (cfqq->service_used > cnext->service_used) BUG_ON(!cfqq->on_rr);
return 1;
}
prev = cfqq->cfq_list.prev; list_del(&cfqq->cfq_list);
if (prev != head) {
struct cfq_queue *cprev = list_entry_cfqq(prev);
if (cfqq->service_used < cprev->service_used) if (cfq_class_rt(cfqq))
return 1; list = &cfqd->cur_rr;
else if (cfq_class_idle(cfqq))
list = &cfqd->idle_rr;
else {
/*
* if cfqq has requests in flight, don't allow it to be
* found in cfq_set_active_queue before it has finished them.
* this is done to increase fairness between a process that
* has lots of io pending vs one that only generates one
* sporadically or synchronously
*/
if (cfqq->in_flight)
list = &cfqd->busy_rr;
else
list = &cfqd->rr_list[cfqq->ioprio];
} }
return 0; /*
} * if queue was preempted, just add to front to be fair. busy_rr
* isn't sorted.
static void cfq_sort_rr_list(struct cfq_queue *cfqq, int new_queue) */
{ if (preempted || list == &cfqd->busy_rr) {
struct list_head *entry = &cfqq->cfqd->rr_list; list_add(&cfqq->cfq_list, list);
if (!cfqq->on_rr)
return;
if (!new_queue && !cfq_check_sort_rr_list(cfqq))
return; return;
}
list_del(&cfqq->cfq_list);
/* /*
* sort by our mean service_used, sub-sort by in-flight requests * sort by when queue was last serviced
*/ */
while ((entry = entry->prev) != &cfqq->cfqd->rr_list) { entry = list;
while ((entry = entry->prev) != list) {
struct cfq_queue *__cfqq = list_entry_cfqq(entry); struct cfq_queue *__cfqq = list_entry_cfqq(entry);
if (cfqq->service_used > __cfqq->service_used) if (!__cfqq->service_last)
break;
if (time_before(__cfqq->service_last, cfqq->service_last))
break; break;
else if (cfqq->service_used == __cfqq->service_used) {
struct list_head *prv;
while ((prv = entry->prev) != &cfqq->cfqd->rr_list) {
__cfqq = list_entry_cfqq(prv);
WARN_ON(__cfqq->service_used > cfqq->service_used);
if (cfqq->service_used != __cfqq->service_used)
break;
if (cfqq->in_flight > __cfqq->in_flight)
break;
entry = prv;
}
}
} }
list_add(&cfqq->cfq_list, entry); list_add(&cfqq->cfq_list, entry);
...@@ -469,28 +455,24 @@ static void cfq_sort_rr_list(struct cfq_queue *cfqq, int new_queue) ...@@ -469,28 +455,24 @@ static void cfq_sort_rr_list(struct cfq_queue *cfqq, int new_queue)
/* /*
* add to busy list of queues for service, trying to be fair in ordering * add to busy list of queues for service, trying to be fair in ordering
* the pending list according to requests serviced * the pending list according to last request service
*/ */
static inline void static inline void
cfq_add_cfqq_rr(struct cfq_data *cfqd, struct cfq_queue *cfqq) cfq_add_cfqq_rr(struct cfq_data *cfqd, struct cfq_queue *cfqq, int requeue)
{ {
/* BUG_ON(cfqq->on_rr);
* it's currently on the empty list
*/
cfqq->on_rr = 1; cfqq->on_rr = 1;
cfqd->busy_queues++; cfqd->busy_queues++;
if (time_after(jiffies, cfqq->service_start + cfq_service)) cfq_resort_rr_list(cfqq, requeue);
cfqq->service_used >>= 3;
cfq_sort_rr_list(cfqq, 1);
} }
static inline void static inline void
cfq_del_cfqq_rr(struct cfq_data *cfqd, struct cfq_queue *cfqq) cfq_del_cfqq_rr(struct cfq_data *cfqd, struct cfq_queue *cfqq)
{ {
list_move(&cfqq->cfq_list, &cfqd->empty_list); BUG_ON(!cfqq->on_rr);
cfqq->on_rr = 0; cfqq->on_rr = 0;
list_move(&cfqq->cfq_list, &cfqd->empty_list);
BUG_ON(!cfqd->busy_queues); BUG_ON(!cfqd->busy_queues);
cfqd->busy_queues--; cfqd->busy_queues--;
...@@ -505,16 +487,17 @@ static inline void cfq_del_crq_rb(struct cfq_rq *crq) ...@@ -505,16 +487,17 @@ static inline void cfq_del_crq_rb(struct cfq_rq *crq)
if (ON_RB(&crq->rb_node)) { if (ON_RB(&crq->rb_node)) {
struct cfq_data *cfqd = cfqq->cfqd; struct cfq_data *cfqd = cfqq->cfqd;
const int sync = crq->is_sync;
BUG_ON(!cfqq->queued[crq->is_sync]); BUG_ON(!cfqq->queued[sync]);
cfqq->queued[sync]--;
cfq_update_next_crq(crq); cfq_update_next_crq(crq);
cfqq->queued[crq->is_sync]--;
rb_erase(&crq->rb_node, &cfqq->sort_list); rb_erase(&crq->rb_node, &cfqq->sort_list);
RB_CLEAR_COLOR(&crq->rb_node); RB_CLEAR_COLOR(&crq->rb_node);
if (RB_EMPTY(&cfqq->sort_list) && cfqq->on_rr) if (cfqq->on_rr && RB_EMPTY(&cfqq->sort_list))
cfq_del_cfqq_rr(cfqd, cfqq); cfq_del_cfqq_rr(cfqd, cfqq);
} }
} }
...@@ -562,7 +545,7 @@ static void cfq_add_crq_rb(struct cfq_rq *crq) ...@@ -562,7 +545,7 @@ static void cfq_add_crq_rb(struct cfq_rq *crq)
rb_insert_color(&crq->rb_node, &cfqq->sort_list); rb_insert_color(&crq->rb_node, &cfqq->sort_list);
if (!cfqq->on_rr) if (!cfqq->on_rr)
cfq_add_cfqq_rr(cfqd, cfqq); cfq_add_cfqq_rr(cfqd, cfqq, crq->requeued);
/* /*
* check if this request is a better next-serve candidate * check if this request is a better next-serve candidate
...@@ -581,11 +564,10 @@ cfq_reposition_crq_rb(struct cfq_queue *cfqq, struct cfq_rq *crq) ...@@ -581,11 +564,10 @@ cfq_reposition_crq_rb(struct cfq_queue *cfqq, struct cfq_rq *crq)
cfq_add_crq_rb(crq); cfq_add_crq_rb(crq);
} }
static struct request * static struct request *cfq_find_rq_rb(struct cfq_data *cfqd, sector_t sector)
cfq_find_rq_rb(struct cfq_data *cfqd, sector_t sector)
{ {
const unsigned long key = cfq_hash_key(cfqd, current); struct cfq_queue *cfqq = cfq_find_cfq_hash(cfqd, current->pid);
struct cfq_queue *cfqq = cfq_find_cfq_hash(cfqd, key);
struct rb_node *n; struct rb_node *n;
if (!cfqq) if (!cfqq)
...@@ -609,20 +591,23 @@ cfq_find_rq_rb(struct cfq_data *cfqd, sector_t sector) ...@@ -609,20 +591,23 @@ cfq_find_rq_rb(struct cfq_data *cfqd, sector_t sector)
static void cfq_deactivate_request(request_queue_t *q, struct request *rq) static void cfq_deactivate_request(request_queue_t *q, struct request *rq)
{ {
struct cfq_data *cfqd = q->elevator->elevator_data;
struct cfq_rq *crq = RQ_DATA(rq); struct cfq_rq *crq = RQ_DATA(rq);
if (crq) { if (crq) {
struct cfq_queue *cfqq = crq->cfq_queue; struct cfq_queue *cfqq = crq->cfq_queue;
if (cfqq->cfqd->cfq_tagged) {
cfqq->service_used--;
cfq_sort_rr_list(cfqq, 0);
}
if (crq->accounted) { if (crq->accounted) {
crq->accounted = 0; crq->accounted = 0;
cfqq->cfqd->rq_in_driver--; WARN_ON(!cfqd->rq_in_driver);
cfqd->rq_in_driver--;
} }
if (crq->in_flight) {
crq->in_flight = 0;
WARN_ON(!cfqq->in_flight);
cfqq->in_flight--;
}
crq->requeued = 1;
} }
} }
...@@ -640,11 +625,10 @@ static void cfq_remove_request(request_queue_t *q, struct request *rq) ...@@ -640,11 +625,10 @@ static void cfq_remove_request(request_queue_t *q, struct request *rq)
struct cfq_rq *crq = RQ_DATA(rq); struct cfq_rq *crq = RQ_DATA(rq);
if (crq) { if (crq) {
cfq_remove_merge_hints(q, crq);
list_del_init(&rq->queuelist); list_del_init(&rq->queuelist);
cfq_del_crq_rb(crq);
cfq_remove_merge_hints(q, crq);
if (crq->cfq_queue)
cfq_del_crq_rb(crq);
} }
} }
...@@ -662,21 +646,15 @@ cfq_merge(request_queue_t *q, struct request **req, struct bio *bio) ...@@ -662,21 +646,15 @@ cfq_merge(request_queue_t *q, struct request **req, struct bio *bio)
} }
__rq = cfq_find_rq_hash(cfqd, bio->bi_sector); __rq = cfq_find_rq_hash(cfqd, bio->bi_sector);
if (__rq) { if (__rq && elv_rq_merge_ok(__rq, bio)) {
BUG_ON(__rq->sector + __rq->nr_sectors != bio->bi_sector); ret = ELEVATOR_BACK_MERGE;
goto out;
if (elv_rq_merge_ok(__rq, bio)) {
ret = ELEVATOR_BACK_MERGE;
goto out;
}
} }
__rq = cfq_find_rq_rb(cfqd, bio->bi_sector + bio_sectors(bio)); __rq = cfq_find_rq_rb(cfqd, bio->bi_sector + bio_sectors(bio));
if (__rq) { if (__rq && elv_rq_merge_ok(__rq, bio)) {
if (elv_rq_merge_ok(__rq, bio)) { ret = ELEVATOR_FRONT_MERGE;
ret = ELEVATOR_FRONT_MERGE; goto out;
goto out;
}
} }
return ELEVATOR_NO_MERGE; return ELEVATOR_NO_MERGE;
...@@ -709,20 +687,194 @@ static void ...@@ -709,20 +687,194 @@ static void
cfq_merged_requests(request_queue_t *q, struct request *rq, cfq_merged_requests(request_queue_t *q, struct request *rq,
struct request *next) struct request *next)
{ {
struct cfq_rq *crq = RQ_DATA(rq);
struct cfq_rq *cnext = RQ_DATA(next);
cfq_merged_request(q, rq); cfq_merged_request(q, rq);
if (!list_empty(&rq->queuelist) && !list_empty(&next->queuelist)) { /*
if (time_before(cnext->queue_start, crq->queue_start)) { * reposition in fifo if next is older than rq
list_move(&rq->queuelist, &next->queuelist); */
crq->queue_start = cnext->queue_start; if (!list_empty(&rq->queuelist) && !list_empty(&next->queuelist) &&
time_before(next->start_time, rq->start_time))
list_move(&rq->queuelist, &next->queuelist);
cfq_remove_request(q, next);
}
static inline void
__cfq_set_active_queue(struct cfq_data *cfqd, struct cfq_queue *cfqq)
{
if (cfqq) {
/*
* stop potential idle class queues waiting service
*/
del_timer(&cfqd->idle_class_timer);
cfqq->slice_start = jiffies;
cfqq->slice_end = 0;
cfqq->slice_left = 0;
cfqq->must_alloc_slice = 0;
cfqq->fifo_expire = 0;
}
cfqd->active_queue = cfqq;
}
/*
* 0
* 0,1
* 0,1,2
* 0,1,2,3
* 0,1,2,3,4
* 0,1,2,3,4,5
* 0,1,2,3,4,5,6
* 0,1,2,3,4,5,6,7
*/
static int cfq_get_next_prio_level(struct cfq_data *cfqd)
{
int prio, wrap;
prio = -1;
wrap = 0;
do {
int p;
for (p = cfqd->cur_prio; p <= cfqd->cur_end_prio; p++) {
if (!list_empty(&cfqd->rr_list[p])) {
prio = p;
break;
}
}
if (prio != -1)
break;
cfqd->cur_prio = 0;
if (++cfqd->cur_end_prio == CFQ_PRIO_LISTS) {
cfqd->cur_end_prio = 0;
if (wrap)
break;
wrap = 1;
} }
} while (1);
if (unlikely(prio == -1))
return -1;
BUG_ON(prio >= CFQ_PRIO_LISTS);
list_splice_init(&cfqd->rr_list[prio], &cfqd->cur_rr);
cfqd->cur_prio = prio + 1;
if (cfqd->cur_prio > cfqd->cur_end_prio) {
cfqd->cur_end_prio = cfqd->cur_prio;
cfqd->cur_prio = 0;
}
if (cfqd->cur_end_prio == CFQ_PRIO_LISTS) {
cfqd->cur_prio = 0;
cfqd->cur_end_prio = 0;
} }
cfq_update_next_crq(cnext); return prio;
cfq_remove_request(q, next); }
static void cfq_set_active_queue(struct cfq_data *cfqd)
{
struct cfq_queue *cfqq = NULL;
/*
* if current list is non-empty, grab first entry. if it is empty,
* get next prio level and grab first entry then if any are spliced
*/
if (!list_empty(&cfqd->cur_rr) || cfq_get_next_prio_level(cfqd) != -1)
cfqq = list_entry_cfqq(cfqd->cur_rr.next);
/*
* if we have idle queues and no rt or be queues had pending
* requests, either allow immediate service if the grace period
* has passed or arm the idle grace timer
*/
if (!cfqq && !list_empty(&cfqd->idle_rr)) {
unsigned long end = cfqd->last_end_request + CFQ_IDLE_GRACE;
if (time_after_eq(jiffies, end))
cfqq = list_entry_cfqq(cfqd->idle_rr.next);
else
mod_timer(&cfqd->idle_class_timer, end);
}
__cfq_set_active_queue(cfqd, cfqq);
}
/*
* current cfqq expired its slice (or was too idle), select new one
*/
static inline void cfq_slice_expired(struct cfq_data *cfqd, int preempted)
{
struct cfq_queue *cfqq = cfqd->active_queue;
if (cfqq) {
unsigned long now = jiffies;
if (cfqq->wait_request)
del_timer(&cfqd->idle_slice_timer);
if (!preempted && !cfqq->in_flight)
cfqq->service_last = now;
cfqq->must_dispatch = 0;
cfqq->wait_request = 0;
/*
* store what was left of this slice, if the queue idled out
* or was preempted
*/
if (time_after(now, cfqq->slice_end))
cfqq->slice_left = now - cfqq->slice_end;
else
cfqq->slice_left = 0;
if (cfqq->on_rr)
cfq_resort_rr_list(cfqq, preempted);
cfqd->active_queue = NULL;
if (cfqd->active_cic) {
put_io_context(cfqd->active_cic->ioc);
cfqd->active_cic = NULL;
}
}
cfqd->dispatch_slice = 0;
}
static int cfq_arm_slice_timer(struct cfq_data *cfqd, struct cfq_queue *cfqq)
{
WARN_ON(!RB_EMPTY(&cfqq->sort_list));
WARN_ON(cfqq != cfqd->active_queue);
/*
* idle is disabled, either manually or by past process history
*/
if (!cfqd->cfq_slice_idle)
return 0;
if (!cfqq->idle_window)
return 0;
/*
* task has exited, don't wait
*/
if (cfqd->active_cic && !cfqd->active_cic->ioc->task)
return 0;
cfqq->wait_request = 1;
cfqq->must_alloc = 1;
if (!timer_pending(&cfqd->idle_slice_timer)) {
unsigned long slice_left = cfqq->slice_end - 1;
cfqd->idle_slice_timer.expires = min(jiffies + cfqd->cfq_slice_idle, slice_left);
add_timer(&cfqd->idle_slice_timer);
}
return 1;
} }
/* /*
...@@ -738,31 +890,39 @@ static void cfq_dispatch_sort(request_queue_t *q, struct cfq_rq *crq) ...@@ -738,31 +890,39 @@ static void cfq_dispatch_sort(request_queue_t *q, struct cfq_rq *crq)
struct request *__rq; struct request *__rq;
sector_t last; sector_t last;
cfq_del_crq_rb(crq);
cfq_remove_merge_hints(q, crq);
list_del(&crq->request->queuelist); list_del(&crq->request->queuelist);
last = cfqd->last_sector; last = cfqd->last_sector;
while ((entry = entry->prev) != head) { list_for_each_entry_reverse(__rq, head, queuelist) {
__rq = list_entry_rq(entry); struct cfq_rq *__crq = RQ_DATA(__rq);
if (blk_barrier_rq(crq->request)) if (blk_barrier_rq(__rq))
break;
if (!blk_fs_request(__rq))
break; break;
if (!blk_fs_request(crq->request)) if (__crq->requeued)
break; break;
if (crq->request->sector > __rq->sector) if (__rq->sector <= crq->request->sector)
break; break;
if (__rq->sector > last && crq->request->sector < last) { if (__rq->sector > last && crq->request->sector < last) {
last = crq->request->sector; last = crq->request->sector + crq->request->nr_sectors;
break; break;
} }
entry = &__rq->queuelist;
} }
cfqd->last_sector = last; cfqd->last_sector = last;
cfqq->next_crq = cfq_find_next_crq(cfqd, cfqq, crq);
cfq_del_crq_rb(crq);
cfq_remove_merge_hints(q, crq);
crq->in_flight = 1; crq->in_flight = 1;
crq->requeued = 0;
cfqq->in_flight++; cfqq->in_flight++;
list_add(&crq->request->queuelist, entry); list_add_tail(&crq->request->queuelist, entry);
} }
/* /*
...@@ -771,105 +931,176 @@ static void cfq_dispatch_sort(request_queue_t *q, struct cfq_rq *crq) ...@@ -771,105 +931,176 @@ static void cfq_dispatch_sort(request_queue_t *q, struct cfq_rq *crq)
static inline struct cfq_rq *cfq_check_fifo(struct cfq_queue *cfqq) static inline struct cfq_rq *cfq_check_fifo(struct cfq_queue *cfqq)
{ {
struct cfq_data *cfqd = cfqq->cfqd; struct cfq_data *cfqd = cfqq->cfqd;
const int reads = !list_empty(&cfqq->fifo[0]); struct request *rq;
const int writes = !list_empty(&cfqq->fifo[1]);
unsigned long now = jiffies;
struct cfq_rq *crq; struct cfq_rq *crq;
if (time_before(now, cfqq->last_fifo_expire + cfqd->cfq_fifo_batch_expire)) if (cfqq->fifo_expire)
return NULL; return NULL;
crq = RQ_DATA(list_entry(cfqq->fifo[0].next, struct request, queuelist)); if (!list_empty(&cfqq->fifo)) {
if (reads && time_after(now, crq->queue_start + cfqd->cfq_fifo_expire_r)) { int fifo = cfq_cfqq_sync(cfqq);
cfqq->last_fifo_expire = now;
return crq;
}
crq = RQ_DATA(list_entry(cfqq->fifo[1].next, struct request, queuelist)); crq = RQ_DATA(list_entry_fifo(cfqq->fifo.next));
if (writes && time_after(now, crq->queue_start + cfqd->cfq_fifo_expire_w)) { rq = crq->request;
cfqq->last_fifo_expire = now; if (time_after(jiffies, rq->start_time + cfqd->cfq_fifo_expire[fifo])) {
return crq; cfqq->fifo_expire = 1;
return crq;
}
} }
return NULL; return NULL;
} }
/* /*
* dispatch a single request from given queue * Scale schedule slice based on io priority
*/ */
static inline int
cfq_prio_to_slice(struct cfq_data *cfqd, struct cfq_queue *cfqq)
{
const int base_slice = cfqd->cfq_slice[cfq_cfqq_sync(cfqq)];
WARN_ON(cfqq->ioprio >= IOPRIO_BE_NR);
return base_slice + (base_slice/CFQ_SLICE_SCALE * (4 - cfqq->ioprio));
}
static inline void static inline void
cfq_dispatch_request(request_queue_t *q, struct cfq_data *cfqd, cfq_set_prio_slice(struct cfq_data *cfqd, struct cfq_queue *cfqq)
struct cfq_queue *cfqq)
{ {
struct cfq_rq *crq; cfqq->slice_end = cfq_prio_to_slice(cfqd, cfqq) + jiffies;
}
/* static inline int
* follow expired path, else get first next available cfq_prio_to_maxrq(struct cfq_data *cfqd, struct cfq_queue *cfqq)
*/ {
if ((crq = cfq_check_fifo(cfqq)) == NULL) { const int base_rq = cfqd->cfq_slice_async_rq;
if (cfqd->find_best_crq)
crq = cfqq->next_crq;
else
crq = rb_entry_crq(rb_first(&cfqq->sort_list));
}
cfqd->last_sector = crq->request->sector + crq->request->nr_sectors; WARN_ON(cfqq->ioprio >= IOPRIO_BE_NR);
/* return 2 * (base_rq + base_rq * (CFQ_PRIO_LISTS - 1 - cfqq->ioprio));
* finally, insert request into driver list
*/
cfq_dispatch_sort(q, crq);
} }
static int cfq_dispatch_requests(request_queue_t *q, int max_dispatch) /*
* get next queue for service
*/
static struct cfq_queue *cfq_select_queue(struct cfq_data *cfqd, int force)
{ {
struct cfq_data *cfqd = q->elevator->elevator_data; unsigned long now = jiffies;
struct cfq_queue *cfqq; struct cfq_queue *cfqq;
struct list_head *entry, *tmp;
int queued, busy_queues, first_round;
if (list_empty(&cfqd->rr_list)) cfqq = cfqd->active_queue;
return 0; if (!cfqq)
goto new_queue;
queued = 0; /*
first_round = 1; * slice has expired
restart: */
busy_queues = 0; if (!cfqq->must_dispatch && time_after(jiffies, cfqq->slice_end))
list_for_each_safe(entry, tmp, &cfqd->rr_list) { goto new_queue;
cfqq = list_entry_cfqq(entry);
BUG_ON(RB_EMPTY(&cfqq->sort_list)); /*
* if queue has requests, dispatch one. if not, check if
* enough slice is left to wait for one
*/
if (!RB_EMPTY(&cfqq->sort_list))
goto keep_queue;
else if (!force && cfq_cfqq_sync(cfqq) &&
time_before(now, cfqq->slice_end)) {
if (cfq_arm_slice_timer(cfqd, cfqq))
return NULL;
}
new_queue:
cfq_slice_expired(cfqd, 0);
cfq_set_active_queue(cfqd);
keep_queue:
return cfqd->active_queue;
}
static int
__cfq_dispatch_requests(struct cfq_data *cfqd, struct cfq_queue *cfqq,
int max_dispatch)
{
int dispatched = 0;
BUG_ON(RB_EMPTY(&cfqq->sort_list));
do {
struct cfq_rq *crq;
/* /*
* first round of queueing, only select from queues that * follow expired path, else get first next available
* don't already have io in-flight
*/ */
if (first_round && cfqq->in_flight) if ((crq = cfq_check_fifo(cfqq)) == NULL)
continue; crq = cfqq->next_crq;
/*
* finally, insert request into driver dispatch list
*/
cfq_dispatch_sort(cfqd->queue, crq);
cfq_dispatch_request(q, cfqd, cfqq); cfqd->dispatch_slice++;
dispatched++;
if (!RB_EMPTY(&cfqq->sort_list)) if (!cfqd->active_cic) {
busy_queues++; atomic_inc(&crq->io_context->ioc->refcount);
cfqd->active_cic = crq->io_context;
}
queued++; if (RB_EMPTY(&cfqq->sort_list))
} break;
} while (dispatched < max_dispatch);
/*
* if slice end isn't set yet, set it. if at least one request was
* sync, use the sync time slice value
*/
if (!cfqq->slice_end)
cfq_set_prio_slice(cfqd, cfqq);
/*
* expire an async queue immediately if it has used up its slice. idle
* queue always expire after 1 dispatch round.
*/
if ((!cfq_cfqq_sync(cfqq) &&
cfqd->dispatch_slice >= cfq_prio_to_maxrq(cfqd, cfqq)) ||
cfq_class_idle(cfqq))
cfq_slice_expired(cfqd, 0);
return dispatched;
}
static int
cfq_dispatch_requests(request_queue_t *q, int max_dispatch, int force)
{
struct cfq_data *cfqd = q->elevator->elevator_data;
struct cfq_queue *cfqq;
if (!cfqd->busy_queues)
return 0;
cfqq = cfq_select_queue(cfqd, force);
if (cfqq) {
cfqq->wait_request = 0;
cfqq->must_dispatch = 0;
del_timer(&cfqd->idle_slice_timer);
if (cfq_class_idle(cfqq))
max_dispatch = 1;
if ((queued < max_dispatch) && (busy_queues || first_round)) { return __cfq_dispatch_requests(cfqd, cfqq, max_dispatch);
first_round = 0;
goto restart;
} }
return queued; return 0;
} }
static inline void cfq_account_dispatch(struct cfq_rq *crq) static inline void cfq_account_dispatch(struct cfq_rq *crq)
{ {
struct cfq_queue *cfqq = crq->cfq_queue; struct cfq_queue *cfqq = crq->cfq_queue;
struct cfq_data *cfqd = cfqq->cfqd; struct cfq_data *cfqd = cfqq->cfqd;
unsigned long now, elapsed;
if (!blk_fs_request(crq->request)) if (unlikely(!blk_fs_request(crq->request)))
return; return;
/* /*
...@@ -879,65 +1110,34 @@ static inline void cfq_account_dispatch(struct cfq_rq *crq) ...@@ -879,65 +1110,34 @@ static inline void cfq_account_dispatch(struct cfq_rq *crq)
if (crq->accounted) if (crq->accounted)
return; return;
now = jiffies;
if (cfqq->service_start == ~0UL)
cfqq->service_start = now;
/*
* on drives with tagged command queueing, command turn-around time
* doesn't necessarily reflect the time spent processing this very
* command inside the drive. so do the accounting differently there,
* by just sorting on the number of requests
*/
if (cfqd->cfq_tagged) {
if (time_after(now, cfqq->service_start + cfq_service)) {
cfqq->service_start = now;
cfqq->service_used /= 10;
}
cfqq->service_used++;
cfq_sort_rr_list(cfqq, 0);
}
elapsed = now - crq->queue_start;
if (elapsed > max_elapsed_dispatch)
max_elapsed_dispatch = elapsed;
crq->accounted = 1; crq->accounted = 1;
crq->service_start = now; cfqd->rq_in_driver++;
if (++cfqd->rq_in_driver >= CFQ_MAX_TAG && !cfqd->cfq_tagged) {
cfqq->cfqd->cfq_tagged = 1;
printk("cfq: depth %d reached, tagging now on\n", CFQ_MAX_TAG);
}
} }
static inline void static inline void
cfq_account_completion(struct cfq_queue *cfqq, struct cfq_rq *crq) cfq_account_completion(struct cfq_queue *cfqq, struct cfq_rq *crq)
{ {
struct cfq_data *cfqd = cfqq->cfqd; struct cfq_data *cfqd = cfqq->cfqd;
unsigned long now;
if (!crq->accounted) if (!crq->accounted)
return; return;
now = jiffies;
WARN_ON(!cfqd->rq_in_driver); WARN_ON(!cfqd->rq_in_driver);
cfqd->rq_in_driver--; cfqd->rq_in_driver--;
if (!cfqd->cfq_tagged) { if (!cfq_class_idle(cfqq))
unsigned long now = jiffies; cfqd->last_end_request = now;
unsigned long duration = now - crq->service_start;
if (time_after(now, cfqq->service_start + cfq_service)) { if (!cfqq->in_flight && cfqq->on_rr) {
cfqq->service_start = now; cfqq->service_last = now;
cfqq->service_used >>= 3; cfq_resort_rr_list(cfqq, 0);
}
cfqq->service_used += duration;
cfq_sort_rr_list(cfqq, 0);
if (duration > max_elapsed_crq)
max_elapsed_crq = duration;
} }
if (crq->is_sync)
crq->io_context->last_end_request = now;
} }
static struct request *cfq_next_request(request_queue_t *q) static struct request *cfq_next_request(request_queue_t *q)
...@@ -950,7 +1150,15 @@ static struct request *cfq_next_request(request_queue_t *q) ...@@ -950,7 +1150,15 @@ static struct request *cfq_next_request(request_queue_t *q)
dispatch: dispatch:
rq = list_entry_rq(q->queue_head.next); rq = list_entry_rq(q->queue_head.next);
if ((crq = RQ_DATA(rq)) != NULL) { crq = RQ_DATA(rq);
if (crq) {
/*
* if idle window is disabled, allow queue buildup
*/
if (!crq->in_flight && !crq->cfq_queue->idle_window &&
cfqd->rq_in_driver >= cfqd->cfq_max_depth)
return NULL;
cfq_remove_merge_hints(q, crq); cfq_remove_merge_hints(q, crq);
cfq_account_dispatch(crq); cfq_account_dispatch(crq);
} }
...@@ -958,7 +1166,7 @@ static struct request *cfq_next_request(request_queue_t *q) ...@@ -958,7 +1166,7 @@ static struct request *cfq_next_request(request_queue_t *q)
return rq; return rq;
} }
if (cfq_dispatch_requests(q, cfqd->cfq_quantum)) if (cfq_dispatch_requests(q, cfqd->cfq_quantum, 0))
goto dispatch; goto dispatch;
return NULL; return NULL;
...@@ -972,14 +1180,22 @@ static struct request *cfq_next_request(request_queue_t *q) ...@@ -972,14 +1180,22 @@ static struct request *cfq_next_request(request_queue_t *q)
*/ */
static void cfq_put_queue(struct cfq_queue *cfqq) static void cfq_put_queue(struct cfq_queue *cfqq)
{ {
BUG_ON(!atomic_read(&cfqq->ref)); struct cfq_data *cfqd = cfqq->cfqd;
BUG_ON(atomic_read(&cfqq->ref) <= 0);
if (!atomic_dec_and_test(&cfqq->ref)) if (!atomic_dec_and_test(&cfqq->ref))
return; return;
BUG_ON(rb_first(&cfqq->sort_list)); BUG_ON(rb_first(&cfqq->sort_list));
BUG_ON(cfqq->allocated[READ] + cfqq->allocated[WRITE]);
BUG_ON(cfqq->on_rr); BUG_ON(cfqq->on_rr);
if (unlikely(cfqd->active_queue == cfqq)) {
cfq_slice_expired(cfqd, 0);
kblockd_schedule_work(&cfqd->unplug_work);
}
cfq_put_cfqd(cfqq->cfqd); cfq_put_cfqd(cfqq->cfqd);
/* /*
...@@ -991,7 +1207,7 @@ static void cfq_put_queue(struct cfq_queue *cfqq) ...@@ -991,7 +1207,7 @@ static void cfq_put_queue(struct cfq_queue *cfqq)
} }
static inline struct cfq_queue * static inline struct cfq_queue *
__cfq_find_cfq_hash(struct cfq_data *cfqd, unsigned long key, const int hashval) __cfq_find_cfq_hash(struct cfq_data *cfqd, unsigned int key, const int hashval)
{ {
struct hlist_head *hash_list = &cfqd->cfq_hash[hashval]; struct hlist_head *hash_list = &cfqd->cfq_hash[hashval];
struct hlist_node *entry, *next; struct hlist_node *entry, *next;
...@@ -1007,94 +1223,220 @@ __cfq_find_cfq_hash(struct cfq_data *cfqd, unsigned long key, const int hashval) ...@@ -1007,94 +1223,220 @@ __cfq_find_cfq_hash(struct cfq_data *cfqd, unsigned long key, const int hashval)
} }
static struct cfq_queue * static struct cfq_queue *
cfq_find_cfq_hash(struct cfq_data *cfqd, unsigned long key) cfq_find_cfq_hash(struct cfq_data *cfqd, unsigned int key)
{ {
return __cfq_find_cfq_hash(cfqd, key, hash_long(key, CFQ_QHASH_SHIFT)); return __cfq_find_cfq_hash(cfqd, key, hash_long(key, CFQ_QHASH_SHIFT));
} }
static inline void static void cfq_free_io_context(struct cfq_io_context *cic)
cfq_rehash_cfqq(struct cfq_data *cfqd, struct cfq_queue **cfqq,
struct cfq_io_context *cic)
{ {
unsigned long hashkey = cfq_hash_key(cfqd, current); struct cfq_io_context *__cic;
unsigned long hashval = hash_long(hashkey, CFQ_QHASH_SHIFT); struct list_head *entry, *next;
struct cfq_queue *__cfqq;
unsigned long flags;
spin_lock_irqsave(cfqd->queue->queue_lock, flags); list_for_each_safe(entry, next, &cic->list) {
__cic = list_entry(entry, struct cfq_io_context, list);
hlist_del(&(*cfqq)->cfq_hash); kmem_cache_free(cfq_ioc_pool, __cic);
__cfqq = __cfq_find_cfq_hash(cfqd, hashkey, hashval);
if (!__cfqq || __cfqq == *cfqq) {
__cfqq = *cfqq;
hlist_add_head(&__cfqq->cfq_hash, &cfqd->cfq_hash[hashval]);
__cfqq->key_type = cfqd->key_type;
} else {
atomic_inc(&__cfqq->ref);
cic->cfqq = __cfqq;
cfq_put_queue(*cfqq);
*cfqq = __cfqq;
} }
cic->cfqq = __cfqq; kmem_cache_free(cfq_ioc_pool, cic);
spin_unlock_irqrestore(cfqd->queue->queue_lock, flags);
} }
static void cfq_free_io_context(struct cfq_io_context *cic) /*
* Called with interrupts disabled
*/
static void cfq_exit_single_io_context(struct cfq_io_context *cic)
{ {
kmem_cache_free(cfq_ioc_pool, cic); struct cfq_data *cfqd = cic->cfqq->cfqd;
request_queue_t *q = cfqd->queue;
WARN_ON(!irqs_disabled());
spin_lock(q->queue_lock);
if (unlikely(cic->cfqq == cfqd->active_queue)) {
cfq_slice_expired(cfqd, 0);
kblockd_schedule_work(&cfqd->unplug_work);
}
cfq_put_queue(cic->cfqq);
cic->cfqq = NULL;
spin_unlock(q->queue_lock);
} }
/* /*
* locking hierarchy is: io_context lock -> queue locks * Another task may update the task cic list, if it is doing a queue lookup
* on its behalf. cfq_cic_lock excludes such concurrent updates
*/ */
static void cfq_exit_io_context(struct cfq_io_context *cic) static void cfq_exit_io_context(struct cfq_io_context *cic)
{ {
struct cfq_queue *cfqq = cic->cfqq; struct cfq_io_context *__cic;
struct list_head *entry = &cic->list; struct list_head *entry;
request_queue_t *q;
unsigned long flags; unsigned long flags;
local_irq_save(flags);
/* /*
* put the reference this task is holding to the various queues * put the reference this task is holding to the various queues
*/ */
spin_lock_irqsave(&cic->ioc->lock, flags); list_for_each(entry, &cic->list) {
while ((entry = cic->list.next) != &cic->list) {
struct cfq_io_context *__cic;
__cic = list_entry(entry, struct cfq_io_context, list); __cic = list_entry(entry, struct cfq_io_context, list);
list_del(entry); cfq_exit_single_io_context(__cic);
q = __cic->cfqq->cfqd->queue;
spin_lock(q->queue_lock);
cfq_put_queue(__cic->cfqq);
spin_unlock(q->queue_lock);
} }
q = cfqq->cfqd->queue; cfq_exit_single_io_context(cic);
spin_lock(q->queue_lock); local_irq_restore(flags);
cfq_put_queue(cfqq);
spin_unlock(q->queue_lock);
cic->cfqq = NULL;
spin_unlock_irqrestore(&cic->ioc->lock, flags);
} }
static struct cfq_io_context *cfq_alloc_io_context(int gfp_flags) static struct cfq_io_context *
cfq_alloc_io_context(struct cfq_data *cfqd, int gfp_mask)
{ {
struct cfq_io_context *cic = kmem_cache_alloc(cfq_ioc_pool, gfp_flags); struct cfq_io_context *cic = kmem_cache_alloc(cfq_ioc_pool, gfp_mask);
if (cic) { if (cic) {
cic->dtor = cfq_free_io_context;
cic->exit = cfq_exit_io_context;
INIT_LIST_HEAD(&cic->list); INIT_LIST_HEAD(&cic->list);
cic->cfqq = NULL; cic->cfqq = NULL;
cic->key = NULL;
cic->last_end_request = jiffies;
cic->ttime_total = 0;
cic->ttime_samples = 0;
cic->ttime_mean = 0;
cic->dtor = cfq_free_io_context;
cic->exit = cfq_exit_io_context;
} }
return cic; return cic;
} }
static void cfq_init_prio_data(struct cfq_queue *cfqq)
{
struct task_struct *tsk = current;
int ioprio_class;
if (!cfqq->prio_changed)
return;
ioprio_class = IOPRIO_PRIO_CLASS(tsk->ioprio);
switch (ioprio_class) {
default:
printk(KERN_ERR "cfq: bad prio %x\n", ioprio_class);
case IOPRIO_CLASS_NONE:
/*
* no prio set, place us in the middle of the BE classes
*/
cfqq->ioprio = task_nice_ioprio(tsk);
cfqq->ioprio_class = IOPRIO_CLASS_BE;
break;
case IOPRIO_CLASS_RT:
cfqq->ioprio = task_ioprio(tsk);
cfqq->ioprio_class = IOPRIO_CLASS_RT;
break;
case IOPRIO_CLASS_BE:
cfqq->ioprio = task_ioprio(tsk);
cfqq->ioprio_class = IOPRIO_CLASS_BE;
break;
case IOPRIO_CLASS_IDLE:
cfqq->ioprio_class = IOPRIO_CLASS_IDLE;
cfqq->ioprio = 7;
cfqq->idle_window = 0;
break;
}
/*
* keep track of original prio settings in case we have to temporarily
* elevate the priority of this queue
*/
cfqq->org_ioprio = cfqq->ioprio;
cfqq->org_ioprio_class = cfqq->ioprio_class;
if (cfqq->on_rr)
cfq_resort_rr_list(cfqq, 0);
cfqq->prio_changed = 0;
}
static inline void changed_ioprio(struct cfq_queue *cfqq)
{
if (cfqq) {
struct cfq_data *cfqd = cfqq->cfqd;
spin_lock(cfqd->queue->queue_lock);
cfqq->prio_changed = 1;
cfq_init_prio_data(cfqq);
spin_unlock(cfqd->queue->queue_lock);
}
}
/*
* callback from sys_ioprio_set, irqs are disabled
*/
static int cfq_ioc_set_ioprio(struct io_context *ioc, unsigned int ioprio)
{
struct cfq_io_context *cic = ioc->cic;
changed_ioprio(cic->cfqq);
list_for_each_entry(cic, &cic->list, list)
changed_ioprio(cic->cfqq);
return 0;
}
static struct cfq_queue *
cfq_get_queue(struct cfq_data *cfqd, unsigned int key, int gfp_mask)
{
const int hashval = hash_long(key, CFQ_QHASH_SHIFT);
struct cfq_queue *cfqq, *new_cfqq = NULL;
retry:
cfqq = __cfq_find_cfq_hash(cfqd, key, hashval);
if (!cfqq) {
if (new_cfqq) {
cfqq = new_cfqq;
new_cfqq = NULL;
} else if (gfp_mask & __GFP_WAIT) {
spin_unlock_irq(cfqd->queue->queue_lock);
new_cfqq = kmem_cache_alloc(cfq_pool, gfp_mask);
spin_lock_irq(cfqd->queue->queue_lock);
goto retry;
} else {
cfqq = kmem_cache_alloc(cfq_pool, gfp_mask);
if (!cfqq)
goto out;
}
memset(cfqq, 0, sizeof(*cfqq));
INIT_HLIST_NODE(&cfqq->cfq_hash);
INIT_LIST_HEAD(&cfqq->cfq_list);
RB_CLEAR_ROOT(&cfqq->sort_list);
INIT_LIST_HEAD(&cfqq->fifo);
cfqq->key = key;
hlist_add_head(&cfqq->cfq_hash, &cfqd->cfq_hash[hashval]);
atomic_set(&cfqq->ref, 0);
cfqq->cfqd = cfqd;
atomic_inc(&cfqd->ref);
cfqq->service_last = 0;
/*
* set ->slice_left to allow preemption for a new process
*/
cfqq->slice_left = 2 * cfqd->cfq_slice_idle;
cfqq->idle_window = 1;
cfqq->ioprio = -1;
cfqq->ioprio_class = -1;
cfqq->prio_changed = 1;
}
if (new_cfqq)
kmem_cache_free(cfq_pool, new_cfqq);
atomic_inc(&cfqq->ref);
out:
WARN_ON((gfp_mask & __GFP_WAIT) && !cfqq);
return cfqq;
}
/* /*
* Setup general io context and cfq io context. There can be several cfq * Setup general io context and cfq io context. There can be several cfq
* io contexts per general io context, if this process is doing io to more * io contexts per general io context, if this process is doing io to more
...@@ -1102,39 +1444,39 @@ static struct cfq_io_context *cfq_alloc_io_context(int gfp_flags) ...@@ -1102,39 +1444,39 @@ static struct cfq_io_context *cfq_alloc_io_context(int gfp_flags)
* cfqq, so we don't need to worry about it disappearing * cfqq, so we don't need to worry about it disappearing
*/ */
static struct cfq_io_context * static struct cfq_io_context *
cfq_get_io_context(struct cfq_queue **cfqq, int gfp_flags) cfq_get_io_context(struct cfq_data *cfqd, pid_t pid, int gfp_mask)
{ {
struct cfq_data *cfqd = (*cfqq)->cfqd; struct io_context *ioc = NULL;
struct cfq_queue *__cfqq = *cfqq;
struct cfq_io_context *cic; struct cfq_io_context *cic;
struct io_context *ioc;
might_sleep_if(gfp_flags & __GFP_WAIT); might_sleep_if(gfp_mask & __GFP_WAIT);
ioc = get_io_context(gfp_flags); ioc = get_io_context(gfp_mask);
if (!ioc) if (!ioc)
return NULL; return NULL;
if ((cic = ioc->cic) == NULL) { if ((cic = ioc->cic) == NULL) {
cic = cfq_alloc_io_context(gfp_flags); cic = cfq_alloc_io_context(cfqd, gfp_mask);
if (cic == NULL) if (cic == NULL)
goto err; goto err;
/*
* manually increment generic io_context usage count, it
* cannot go away since we are already holding one ref to it
*/
ioc->cic = cic; ioc->cic = cic;
ioc->set_ioprio = cfq_ioc_set_ioprio;
cic->ioc = ioc; cic->ioc = ioc;
cic->cfqq = __cfqq; cic->key = cfqd;
atomic_inc(&__cfqq->ref); atomic_inc(&cfqd->ref);
} else { } else {
struct cfq_io_context *__cic; struct cfq_io_context *__cic;
unsigned long flags;
/* /*
* since the first cic on the list is actually the head * the first cic on the list is actually the head itself
* itself, need to check this here or we'll duplicate an
* cic per ioc for no reason
*/ */
if (cic->cfqq == __cfqq) if (cic->key == cfqd)
goto out; goto out;
/* /*
...@@ -1142,152 +1484,259 @@ cfq_get_io_context(struct cfq_queue **cfqq, int gfp_flags) ...@@ -1142,152 +1484,259 @@ cfq_get_io_context(struct cfq_queue **cfqq, int gfp_flags)
* should be ok here, the list will usually not be more than * should be ok here, the list will usually not be more than
* 1 or a few entries long * 1 or a few entries long
*/ */
spin_lock_irqsave(&ioc->lock, flags);
list_for_each_entry(__cic, &cic->list, list) { list_for_each_entry(__cic, &cic->list, list) {
/* /*
* this process is already holding a reference to * this process is already holding a reference to
* this queue, so no need to get one more * this queue, so no need to get one more
*/ */
if (__cic->cfqq == __cfqq) { if (__cic->key == cfqd) {
cic = __cic; cic = __cic;
spin_unlock_irqrestore(&ioc->lock, flags);
goto out; goto out;
} }
} }
spin_unlock_irqrestore(&ioc->lock, flags);
/* /*
* nope, process doesn't have a cic assoicated with this * nope, process doesn't have a cic assoicated with this
* cfqq yet. get a new one and add to list * cfqq yet. get a new one and add to list
*/ */
__cic = cfq_alloc_io_context(gfp_flags); __cic = cfq_alloc_io_context(cfqd, gfp_mask);
if (__cic == NULL) if (__cic == NULL)
goto err; goto err;
__cic->ioc = ioc; __cic->ioc = ioc;
__cic->cfqq = __cfqq; __cic->key = cfqd;
atomic_inc(&__cfqq->ref); atomic_inc(&cfqd->ref);
spin_lock_irqsave(&ioc->lock, flags);
list_add(&__cic->list, &cic->list); list_add(&__cic->list, &cic->list);
spin_unlock_irqrestore(&ioc->lock, flags);
cic = __cic; cic = __cic;
*cfqq = __cfqq;
} }
out: out:
/*
* if key_type has been changed on the fly, we lazily rehash
* each queue at lookup time
*/
if ((*cfqq)->key_type != cfqd->key_type)
cfq_rehash_cfqq(cfqd, cfqq, cic);
return cic; return cic;
err: err:
put_io_context(ioc); put_io_context(ioc);
return NULL; return NULL;
} }
static struct cfq_queue * static void
__cfq_get_queue(struct cfq_data *cfqd, unsigned long key, int gfp_mask) cfq_update_io_thinktime(struct cfq_data *cfqd, struct cfq_io_context *cic)
{ {
const int hashval = hash_long(key, CFQ_QHASH_SHIFT); unsigned long elapsed, ttime;
struct cfq_queue *cfqq, *new_cfqq = NULL;
retry: /*
cfqq = __cfq_find_cfq_hash(cfqd, key, hashval); * if this context already has stuff queued, thinktime is from
* last queue not last end
*/
#if 0
if (time_after(cic->last_end_request, cic->last_queue))
elapsed = jiffies - cic->last_end_request;
else
elapsed = jiffies - cic->last_queue;
#else
elapsed = jiffies - cic->last_end_request;
#endif
if (!cfqq) { ttime = min(elapsed, 2UL * cfqd->cfq_slice_idle);
if (new_cfqq) {
cfqq = new_cfqq;
new_cfqq = NULL;
} else {
spin_unlock_irq(cfqd->queue->queue_lock);
new_cfqq = kmem_cache_alloc(cfq_pool, gfp_mask);
spin_lock_irq(cfqd->queue->queue_lock);
if (!new_cfqq && !(gfp_mask & __GFP_WAIT)) cic->ttime_samples = (7*cic->ttime_samples + 256) / 8;
goto out; cic->ttime_total = (7*cic->ttime_total + 256*ttime) / 8;
cic->ttime_mean = (cic->ttime_total + 128) / cic->ttime_samples;
goto retry; }
}
memset(cfqq, 0, sizeof(*cfqq)); #define sample_valid(samples) ((samples) > 80)
INIT_HLIST_NODE(&cfqq->cfq_hash); /*
INIT_LIST_HEAD(&cfqq->cfq_list); * Disable idle window if the process thinks too long or seeks so much that
RB_CLEAR_ROOT(&cfqq->sort_list); * it doesn't matter
INIT_LIST_HEAD(&cfqq->fifo[0]); */
INIT_LIST_HEAD(&cfqq->fifo[1]); static void
cfq_update_idle_window(struct cfq_data *cfqd, struct cfq_queue *cfqq,
struct cfq_io_context *cic)
{
int enable_idle = cfqq->idle_window;
cfqq->key = key; if (!cic->ioc->task || !cfqd->cfq_slice_idle)
hlist_add_head(&cfqq->cfq_hash, &cfqd->cfq_hash[hashval]); enable_idle = 0;
atomic_set(&cfqq->ref, 0); else if (sample_valid(cic->ttime_samples)) {
cfqq->cfqd = cfqd; if (cic->ttime_mean > cfqd->cfq_slice_idle)
atomic_inc(&cfqd->ref); enable_idle = 0;
cfqq->key_type = cfqd->key_type; else
cfqq->service_start = ~0UL; enable_idle = 1;
} }
if (new_cfqq) cfqq->idle_window = enable_idle;
kmem_cache_free(cfq_pool, new_cfqq); }
atomic_inc(&cfqq->ref);
out: /*
WARN_ON((gfp_mask & __GFP_WAIT) && !cfqq); * Check if new_cfqq should preempt the currently active queue. Return 0 for
return cfqq; * no or if we aren't sure, a 1 will cause a preempt.
*/
static int
cfq_should_preempt(struct cfq_data *cfqd, struct cfq_queue *new_cfqq,
struct cfq_rq *crq)
{
struct cfq_queue *cfqq = cfqd->active_queue;
if (cfq_class_idle(new_cfqq))
return 0;
if (!cfqq)
return 1;
if (cfq_class_idle(cfqq))
return 1;
if (!new_cfqq->wait_request)
return 0;
/*
* if it doesn't have slice left, forget it
*/
if (new_cfqq->slice_left < cfqd->cfq_slice_idle)
return 0;
if (crq->is_sync && !cfq_cfqq_sync(cfqq))
return 1;
return 0;
}
/*
* cfqq preempts the active queue. if we allowed preempt with no slice left,
* let it have half of its nominal slice.
*/
static void cfq_preempt_queue(struct cfq_data *cfqd, struct cfq_queue *cfqq)
{
struct cfq_queue *__cfqq, *next;
list_for_each_entry_safe(__cfqq, next, &cfqd->cur_rr, cfq_list)
cfq_resort_rr_list(__cfqq, 1);
if (!cfqq->slice_left)
cfqq->slice_left = cfq_prio_to_slice(cfqd, cfqq) / 2;
cfqq->slice_end = cfqq->slice_left + jiffies;
cfq_slice_expired(cfqd, 1);
__cfq_set_active_queue(cfqd, cfqq);
}
/*
* should really be a ll_rw_blk.c helper
*/
static void cfq_start_queueing(struct cfq_data *cfqd, struct cfq_queue *cfqq)
{
request_queue_t *q = cfqd->queue;
if (!blk_queue_plugged(q))
q->request_fn(q);
else
__generic_unplug_device(q);
}
/*
* Called when a new fs request (crq) is added (to cfqq). Check if there's
* something we should do about it
*/
static void
cfq_crq_enqueued(struct cfq_data *cfqd, struct cfq_queue *cfqq,
struct cfq_rq *crq)
{
const int sync = crq->is_sync;
cfqq->next_crq = cfq_choose_req(cfqd, cfqq->next_crq, crq);
if (sync) {
struct cfq_io_context *cic = crq->io_context;
cfq_update_io_thinktime(cfqd, cic);
cfq_update_idle_window(cfqd, cfqq, cic);
cic->last_queue = jiffies;
}
if (cfqq == cfqd->active_queue) {
/*
* if we are waiting for a request for this queue, let it rip
* immediately and flag that we must not expire this queue
* just now
*/
if (cfqq->wait_request) {
cfqq->must_dispatch = 1;
del_timer(&cfqd->idle_slice_timer);
cfq_start_queueing(cfqd, cfqq);
}
} else if (cfq_should_preempt(cfqd, cfqq, crq)) {
/*
* not the active queue - expire current slice if it is
* idle and has expired it's mean thinktime or this new queue
* has some old slice time left and is of higher priority
*/
cfq_preempt_queue(cfqd, cfqq);
cfqq->must_dispatch = 1;
cfq_start_queueing(cfqd, cfqq);
}
} }
static void cfq_enqueue(struct cfq_data *cfqd, struct cfq_rq *crq) static void cfq_enqueue(struct cfq_data *cfqd, struct request *rq)
{ {
crq->is_sync = 0; struct cfq_rq *crq = RQ_DATA(rq);
if (rq_data_dir(crq->request) == READ || current->flags & PF_SYNCWRITE) struct cfq_queue *cfqq = crq->cfq_queue;
crq->is_sync = 1;
cfq_init_prio_data(cfqq);
cfq_add_crq_rb(crq); cfq_add_crq_rb(crq);
crq->queue_start = jiffies;
list_add_tail(&crq->request->queuelist, &crq->cfq_queue->fifo[crq->is_sync]); list_add_tail(&rq->queuelist, &cfqq->fifo);
if (rq_mergeable(rq)) {
cfq_add_crq_hash(cfqd, crq);
if (!cfqd->queue->last_merge)
cfqd->queue->last_merge = rq;
}
cfq_crq_enqueued(cfqd, cfqq, crq);
} }
static void static void
cfq_insert_request(request_queue_t *q, struct request *rq, int where) cfq_insert_request(request_queue_t *q, struct request *rq, int where)
{ {
struct cfq_data *cfqd = q->elevator->elevator_data; struct cfq_data *cfqd = q->elevator->elevator_data;
struct cfq_rq *crq = RQ_DATA(rq);
switch (where) { switch (where) {
case ELEVATOR_INSERT_BACK: case ELEVATOR_INSERT_BACK:
while (cfq_dispatch_requests(q, cfqd->cfq_quantum)) while (cfq_dispatch_requests(q, INT_MAX, 1))
; ;
list_add_tail(&rq->queuelist, &q->queue_head); list_add_tail(&rq->queuelist, &q->queue_head);
/*
* If we were idling with pending requests on
* inactive cfqqs, force dispatching will
* remove the idle timer and the queue won't
* be kicked by __make_request() afterward.
* Kick it here.
*/
kblockd_schedule_work(&cfqd->unplug_work);
break; break;
case ELEVATOR_INSERT_FRONT: case ELEVATOR_INSERT_FRONT:
list_add(&rq->queuelist, &q->queue_head); list_add(&rq->queuelist, &q->queue_head);
break; break;
case ELEVATOR_INSERT_SORT: case ELEVATOR_INSERT_SORT:
BUG_ON(!blk_fs_request(rq)); BUG_ON(!blk_fs_request(rq));
cfq_enqueue(cfqd, crq); cfq_enqueue(cfqd, rq);
break; break;
default: default:
printk("%s: bad insert point %d\n", __FUNCTION__,where); printk("%s: bad insert point %d\n", __FUNCTION__,where);
return; return;
} }
}
if (rq_mergeable(rq)) { static inline int cfq_pending_requests(struct cfq_data *cfqd)
cfq_add_crq_hash(cfqd, crq); {
return !list_empty(&cfqd->queue->queue_head) || cfqd->busy_queues;
if (!q->last_merge)
q->last_merge = rq;
}
} }
static int cfq_queue_empty(request_queue_t *q) static int cfq_queue_empty(request_queue_t *q)
{ {
struct cfq_data *cfqd = q->elevator->elevator_data; struct cfq_data *cfqd = q->elevator->elevator_data;
return list_empty(&q->queue_head) && list_empty(&cfqd->rr_list); return !cfq_pending_requests(cfqd);
} }
static void cfq_completed_request(request_queue_t *q, struct request *rq) static void cfq_completed_request(request_queue_t *q, struct request *rq)
...@@ -1332,51 +1781,132 @@ cfq_latter_request(request_queue_t *q, struct request *rq) ...@@ -1332,51 +1781,132 @@ cfq_latter_request(request_queue_t *q, struct request *rq)
return NULL; return NULL;
} }
static int cfq_may_queue(request_queue_t *q, int rw) /*
* we temporarily boost lower priority queues if they are holding fs exclusive
* resources. they are boosted to normal prio (CLASS_BE/4)
*/
static void cfq_prio_boost(struct cfq_queue *cfqq)
{ {
struct cfq_data *cfqd = q->elevator->elevator_data; const int ioprio_class = cfqq->ioprio_class;
struct cfq_queue *cfqq; const int ioprio = cfqq->ioprio;
int ret = ELV_MQUEUE_MAY;
if (current->flags & PF_MEMALLOC) if (has_fs_excl()) {
return ELV_MQUEUE_MAY; /*
* boost idle prio on transactions that would lock out other
* users of the filesystem
*/
if (cfq_class_idle(cfqq))
cfqq->ioprio_class = IOPRIO_CLASS_BE;
if (cfqq->ioprio > IOPRIO_NORM)
cfqq->ioprio = IOPRIO_NORM;
} else {
/*
* check if we need to unboost the queue
*/
if (cfqq->ioprio_class != cfqq->org_ioprio_class)
cfqq->ioprio_class = cfqq->org_ioprio_class;
if (cfqq->ioprio != cfqq->org_ioprio)
cfqq->ioprio = cfqq->org_ioprio;
}
cfqq = cfq_find_cfq_hash(cfqd, cfq_hash_key(cfqd, current)); /*
if (cfqq) { * refile between round-robin lists if we moved the priority class
int limit = cfqd->max_queued; */
if ((ioprio_class != cfqq->ioprio_class || ioprio != cfqq->ioprio) &&
cfqq->on_rr)
cfq_resort_rr_list(cfqq, 0);
}
if (cfqq->allocated[rw] < cfqd->cfq_queued) static inline pid_t cfq_queue_pid(struct task_struct *task, int rw)
return ELV_MQUEUE_MUST; {
if (rw == READ || process_sync(task))
return task->pid;
if (cfqd->busy_queues) return CFQ_KEY_ASYNC;
limit = q->nr_requests / cfqd->busy_queues; }
if (limit < cfqd->cfq_queued) static inline int
limit = cfqd->cfq_queued; __cfq_may_queue(struct cfq_data *cfqd, struct cfq_queue *cfqq,
else if (limit > cfqd->max_queued) struct task_struct *task, int rw)
limit = cfqd->max_queued; {
if (cfqq->wait_request && cfqq->must_alloc)
return ELV_MQUEUE_MUST;
if (cfqq->allocated[rw] >= limit) { return ELV_MQUEUE_MAY;
if (limit > cfqq->alloc_limit[rw]) #if 0
cfqq->alloc_limit[rw] = limit; if (!cfqq || task->flags & PF_MEMALLOC)
return ELV_MQUEUE_MAY;
if (!cfqq->allocated[rw] || cfqq->must_alloc) {
if (cfqq->wait_request)
return ELV_MQUEUE_MUST;
ret = ELV_MQUEUE_NO; /*
* only allow 1 ELV_MQUEUE_MUST per slice, otherwise we
* can quickly flood the queue with writes from a single task
*/
if (rw == READ || !cfqq->must_alloc_slice) {
cfqq->must_alloc_slice = 1;
return ELV_MQUEUE_MUST;
} }
return ELV_MQUEUE_MAY;
} }
if (cfq_class_idle(cfqq))
return ELV_MQUEUE_NO;
if (cfqq->allocated[rw] >= cfqd->max_queued) {
struct io_context *ioc = get_io_context(GFP_ATOMIC);
int ret = ELV_MQUEUE_NO;
return ret; if (ioc && ioc->nr_batch_requests)
ret = ELV_MQUEUE_MAY;
put_io_context(ioc);
return ret;
}
return ELV_MQUEUE_MAY;
#endif
}
static int cfq_may_queue(request_queue_t *q, int rw, struct bio *bio)
{
struct cfq_data *cfqd = q->elevator->elevator_data;
struct task_struct *tsk = current;
struct cfq_queue *cfqq;
/*
* don't force setup of a queue from here, as a call to may_queue
* does not necessarily imply that a request actually will be queued.
* so just lookup a possibly existing queue, or return 'may queue'
* if that fails
*/
cfqq = cfq_find_cfq_hash(cfqd, cfq_queue_pid(tsk, rw));
if (cfqq) {
cfq_init_prio_data(cfqq);
cfq_prio_boost(cfqq);
return __cfq_may_queue(cfqd, cfqq, tsk, rw);
}
return ELV_MQUEUE_MAY;
} }
static void cfq_check_waiters(request_queue_t *q, struct cfq_queue *cfqq) static void cfq_check_waiters(request_queue_t *q, struct cfq_queue *cfqq)
{ {
struct cfq_data *cfqd = q->elevator->elevator_data;
struct request_list *rl = &q->rq; struct request_list *rl = &q->rq;
const int write = waitqueue_active(&rl->wait[WRITE]);
const int read = waitqueue_active(&rl->wait[READ]);
if (read && cfqq->allocated[READ] < cfqq->alloc_limit[READ]) if (cfqq->allocated[READ] <= cfqd->max_queued || cfqd->rq_starved) {
wake_up(&rl->wait[READ]); smp_mb();
if (write && cfqq->allocated[WRITE] < cfqq->alloc_limit[WRITE]) if (waitqueue_active(&rl->wait[READ]))
wake_up(&rl->wait[WRITE]); wake_up(&rl->wait[READ]);
}
if (cfqq->allocated[WRITE] <= cfqd->max_queued || cfqd->rq_starved) {
smp_mb();
if (waitqueue_active(&rl->wait[WRITE]))
wake_up(&rl->wait[WRITE]);
}
} }
/* /*
...@@ -1389,69 +1919,59 @@ static void cfq_put_request(request_queue_t *q, struct request *rq) ...@@ -1389,69 +1919,59 @@ static void cfq_put_request(request_queue_t *q, struct request *rq)
if (crq) { if (crq) {
struct cfq_queue *cfqq = crq->cfq_queue; struct cfq_queue *cfqq = crq->cfq_queue;
const int rw = rq_data_dir(rq);
BUG_ON(q->last_merge == rq); BUG_ON(!cfqq->allocated[rw]);
BUG_ON(!hlist_unhashed(&crq->hash)); cfqq->allocated[rw]--;
if (crq->io_context)
put_io_context(crq->io_context->ioc);
BUG_ON(!cfqq->allocated[crq->is_write]); put_io_context(crq->io_context->ioc);
cfqq->allocated[crq->is_write]--;
mempool_free(crq, cfqd->crq_pool); mempool_free(crq, cfqd->crq_pool);
rq->elevator_private = NULL; rq->elevator_private = NULL;
smp_mb();
cfq_check_waiters(q, cfqq); cfq_check_waiters(q, cfqq);
cfq_put_queue(cfqq); cfq_put_queue(cfqq);
} }
} }
/* /*
* Allocate cfq data structures associated with this request. A queue and * Allocate cfq data structures associated with this request.
*/ */
static int cfq_set_request(request_queue_t *q, struct request *rq, int gfp_mask) static int
cfq_set_request(request_queue_t *q, struct request *rq, struct bio *bio,
int gfp_mask)
{ {
struct cfq_data *cfqd = q->elevator->elevator_data; struct cfq_data *cfqd = q->elevator->elevator_data;
struct cfq_io_context *cic; struct cfq_io_context *cic;
const int rw = rq_data_dir(rq); const int rw = rq_data_dir(rq);
struct cfq_queue *cfqq, *saved_cfqq; struct cfq_queue *cfqq;
struct cfq_rq *crq; struct cfq_rq *crq;
unsigned long flags; unsigned long flags;
might_sleep_if(gfp_mask & __GFP_WAIT); might_sleep_if(gfp_mask & __GFP_WAIT);
cic = cfq_get_io_context(cfqd, cfq_queue_pid(current, rw), gfp_mask);
spin_lock_irqsave(q->queue_lock, flags); spin_lock_irqsave(q->queue_lock, flags);
cfqq = __cfq_get_queue(cfqd, cfq_hash_key(cfqd, current), gfp_mask); if (!cic)
if (!cfqq) goto queue_fail;
goto out_lock;
if (!cic->cfqq) {
cfqq = cfq_get_queue(cfqd, current->pid, gfp_mask);
if (!cfqq)
goto queue_fail;
repeat: cic->cfqq = cfqq;
if (cfqq->allocated[rw] >= cfqd->max_queued) } else
goto out_lock; cfqq = cic->cfqq;
cfqq->allocated[rw]++; cfqq->allocated[rw]++;
cfqq->must_alloc = 0;
cfqd->rq_starved = 0;
atomic_inc(&cfqq->ref);
spin_unlock_irqrestore(q->queue_lock, flags); spin_unlock_irqrestore(q->queue_lock, flags);
/*
* if hashing type has changed, the cfq_queue might change here.
*/
saved_cfqq = cfqq;
cic = cfq_get_io_context(&cfqq, gfp_mask);
if (!cic)
goto err;
/*
* repeat allocation checks on queue change
*/
if (unlikely(saved_cfqq != cfqq)) {
spin_lock_irqsave(q->queue_lock, flags);
saved_cfqq->allocated[rw]--;
goto repeat;
}
crq = mempool_alloc(cfqd->crq_pool, gfp_mask); crq = mempool_alloc(cfqd->crq_pool, gfp_mask);
if (crq) { if (crq) {
RB_CLEAR(&crq->rb_node); RB_CLEAR(&crq->rb_node);
...@@ -1460,24 +1980,130 @@ static int cfq_set_request(request_queue_t *q, struct request *rq, int gfp_mask) ...@@ -1460,24 +1980,130 @@ static int cfq_set_request(request_queue_t *q, struct request *rq, int gfp_mask)
INIT_HLIST_NODE(&crq->hash); INIT_HLIST_NODE(&crq->hash);
crq->cfq_queue = cfqq; crq->cfq_queue = cfqq;
crq->io_context = cic; crq->io_context = cic;
crq->service_start = crq->queue_start = 0; crq->in_flight = crq->accounted = 0;
crq->in_flight = crq->accounted = crq->is_sync = 0; crq->is_sync = (rw == READ || process_sync(current));
crq->is_write = rw; crq->requeued = 0;
rq->elevator_private = crq; rq->elevator_private = crq;
cfqq->alloc_limit[rw] = 0;
return 0; return 0;
} }
put_io_context(cic->ioc);
err:
spin_lock_irqsave(q->queue_lock, flags); spin_lock_irqsave(q->queue_lock, flags);
cfqq->allocated[rw]--; cfqq->allocated[rw]--;
if (!(cfqq->allocated[0] + cfqq->allocated[1]))
cfqq->must_alloc = 1;
cfq_put_queue(cfqq); cfq_put_queue(cfqq);
out_lock: queue_fail:
if (cic)
put_io_context(cic->ioc);
/*
* mark us rq allocation starved. we need to kickstart the process
* ourselves if there are no pending requests that can do it for us.
* that would be an extremely rare OOM situation
*/
cfqd->rq_starved = 1;
kblockd_schedule_work(&cfqd->unplug_work);
spin_unlock_irqrestore(q->queue_lock, flags); spin_unlock_irqrestore(q->queue_lock, flags);
return 1; return 1;
} }
static void cfq_kick_queue(void *data)
{
request_queue_t *q = data;
struct cfq_data *cfqd = q->elevator->elevator_data;
unsigned long flags;
spin_lock_irqsave(q->queue_lock, flags);
if (cfqd->rq_starved) {
struct request_list *rl = &q->rq;
/*
* we aren't guaranteed to get a request after this, but we
* have to be opportunistic
*/
smp_mb();
if (waitqueue_active(&rl->wait[READ]))
wake_up(&rl->wait[READ]);
if (waitqueue_active(&rl->wait[WRITE]))
wake_up(&rl->wait[WRITE]);
}
blk_remove_plug(q);
q->request_fn(q);
spin_unlock_irqrestore(q->queue_lock, flags);
}
/*
* Timer running if the active_queue is currently idling inside its time slice
*/
static void cfq_idle_slice_timer(unsigned long data)
{
struct cfq_data *cfqd = (struct cfq_data *) data;
struct cfq_queue *cfqq;
unsigned long flags;
spin_lock_irqsave(cfqd->queue->queue_lock, flags);
if ((cfqq = cfqd->active_queue) != NULL) {
unsigned long now = jiffies;
/*
* expired
*/
if (time_after(now, cfqq->slice_end))
goto expire;
/*
* only expire and reinvoke request handler, if there are
* other queues with pending requests
*/
if (!cfq_pending_requests(cfqd)) {
cfqd->idle_slice_timer.expires = min(now + cfqd->cfq_slice_idle, cfqq->slice_end);
add_timer(&cfqd->idle_slice_timer);
goto out_cont;
}
/*
* not expired and it has a request pending, let it dispatch
*/
if (!RB_EMPTY(&cfqq->sort_list)) {
cfqq->must_dispatch = 1;
goto out_kick;
}
}
expire:
cfq_slice_expired(cfqd, 0);
out_kick:
if (cfq_pending_requests(cfqd))
kblockd_schedule_work(&cfqd->unplug_work);
out_cont:
spin_unlock_irqrestore(cfqd->queue->queue_lock, flags);
}
/*
* Timer running if an idle class queue is waiting for service
*/
static void cfq_idle_class_timer(unsigned long data)
{
struct cfq_data *cfqd = (struct cfq_data *) data;
unsigned long flags, end;
spin_lock_irqsave(cfqd->queue->queue_lock, flags);
/*
* race with a non-idle queue, reset timer
*/
end = cfqd->last_end_request + CFQ_IDLE_GRACE;
if (!time_after_eq(jiffies, end)) {
cfqd->idle_class_timer.expires = end;
add_timer(&cfqd->idle_class_timer);
} else
kblockd_schedule_work(&cfqd->unplug_work);
spin_unlock_irqrestore(cfqd->queue->queue_lock, flags);
}
static void cfq_put_cfqd(struct cfq_data *cfqd) static void cfq_put_cfqd(struct cfq_data *cfqd)
{ {
request_queue_t *q = cfqd->queue; request_queue_t *q = cfqd->queue;
...@@ -1485,6 +2111,8 @@ static void cfq_put_cfqd(struct cfq_data *cfqd) ...@@ -1485,6 +2111,8 @@ static void cfq_put_cfqd(struct cfq_data *cfqd)
if (!atomic_dec_and_test(&cfqd->ref)) if (!atomic_dec_and_test(&cfqd->ref))
return; return;
blk_sync_queue(q);
blk_put_queue(q); blk_put_queue(q);
mempool_destroy(cfqd->crq_pool); mempool_destroy(cfqd->crq_pool);
...@@ -1495,7 +2123,11 @@ static void cfq_put_cfqd(struct cfq_data *cfqd) ...@@ -1495,7 +2123,11 @@ static void cfq_put_cfqd(struct cfq_data *cfqd)
static void cfq_exit_queue(elevator_t *e) static void cfq_exit_queue(elevator_t *e)
{ {
cfq_put_cfqd(e->elevator_data); struct cfq_data *cfqd = e->elevator_data;
del_timer_sync(&cfqd->idle_slice_timer);
del_timer_sync(&cfqd->idle_class_timer);
cfq_put_cfqd(cfqd);
} }
static int cfq_init_queue(request_queue_t *q, elevator_t *e) static int cfq_init_queue(request_queue_t *q, elevator_t *e)
...@@ -1508,7 +2140,13 @@ static int cfq_init_queue(request_queue_t *q, elevator_t *e) ...@@ -1508,7 +2140,13 @@ static int cfq_init_queue(request_queue_t *q, elevator_t *e)
return -ENOMEM; return -ENOMEM;
memset(cfqd, 0, sizeof(*cfqd)); memset(cfqd, 0, sizeof(*cfqd));
INIT_LIST_HEAD(&cfqd->rr_list);
for (i = 0; i < CFQ_PRIO_LISTS; i++)
INIT_LIST_HEAD(&cfqd->rr_list[i]);
INIT_LIST_HEAD(&cfqd->busy_rr);
INIT_LIST_HEAD(&cfqd->cur_rr);
INIT_LIST_HEAD(&cfqd->idle_rr);
INIT_LIST_HEAD(&cfqd->empty_list); INIT_LIST_HEAD(&cfqd->empty_list);
cfqd->crq_hash = kmalloc(sizeof(struct hlist_head) * CFQ_MHASH_ENTRIES, GFP_KERNEL); cfqd->crq_hash = kmalloc(sizeof(struct hlist_head) * CFQ_MHASH_ENTRIES, GFP_KERNEL);
...@@ -1533,25 +2171,32 @@ static int cfq_init_queue(request_queue_t *q, elevator_t *e) ...@@ -1533,25 +2171,32 @@ static int cfq_init_queue(request_queue_t *q, elevator_t *e)
cfqd->queue = q; cfqd->queue = q;
atomic_inc(&q->refcnt); atomic_inc(&q->refcnt);
/* cfqd->max_queued = q->nr_requests / 4;
* just set it to some high value, we want anyone to be able to queue
* some requests. fairness is handled differently
*/
q->nr_requests = 1024;
cfqd->max_queued = q->nr_requests / 16;
q->nr_batching = cfq_queued; q->nr_batching = cfq_queued;
cfqd->key_type = CFQ_KEY_TGID;
cfqd->find_best_crq = 1; init_timer(&cfqd->idle_slice_timer);
cfqd->idle_slice_timer.function = cfq_idle_slice_timer;
cfqd->idle_slice_timer.data = (unsigned long) cfqd;
init_timer(&cfqd->idle_class_timer);
cfqd->idle_class_timer.function = cfq_idle_class_timer;
cfqd->idle_class_timer.data = (unsigned long) cfqd;
INIT_WORK(&cfqd->unplug_work, cfq_kick_queue, q);
atomic_set(&cfqd->ref, 1); atomic_set(&cfqd->ref, 1);
cfqd->cfq_queued = cfq_queued; cfqd->cfq_queued = cfq_queued;
cfqd->cfq_quantum = cfq_quantum; cfqd->cfq_quantum = cfq_quantum;
cfqd->cfq_fifo_expire_r = cfq_fifo_expire_r; cfqd->cfq_fifo_expire[0] = cfq_fifo_expire[0];
cfqd->cfq_fifo_expire_w = cfq_fifo_expire_w; cfqd->cfq_fifo_expire[1] = cfq_fifo_expire[1];
cfqd->cfq_fifo_batch_expire = cfq_fifo_rate;
cfqd->cfq_back_max = cfq_back_max; cfqd->cfq_back_max = cfq_back_max;
cfqd->cfq_back_penalty = cfq_back_penalty; cfqd->cfq_back_penalty = cfq_back_penalty;
cfqd->cfq_slice[0] = cfq_slice_async;
cfqd->cfq_slice[1] = cfq_slice_sync;
cfqd->cfq_slice_async_rq = cfq_slice_async_rq;
cfqd->cfq_slice_idle = cfq_slice_idle;
cfqd->cfq_max_depth = cfq_max_depth;
return 0; return 0;
out_crqpool: out_crqpool:
kfree(cfqd->cfq_hash); kfree(cfqd->cfq_hash);
...@@ -1595,7 +2240,6 @@ static int __init cfq_slab_setup(void) ...@@ -1595,7 +2240,6 @@ static int __init cfq_slab_setup(void)
return -ENOMEM; return -ENOMEM;
} }
/* /*
* sysfs parts below --> * sysfs parts below -->
*/ */
...@@ -1620,45 +2264,6 @@ cfq_var_store(unsigned int *var, const char *page, size_t count) ...@@ -1620,45 +2264,6 @@ cfq_var_store(unsigned int *var, const char *page, size_t count)
return count; return count;
} }
static ssize_t
cfq_clear_elapsed(struct cfq_data *cfqd, const char *page, size_t count)
{
max_elapsed_dispatch = max_elapsed_crq = 0;
return count;
}
static ssize_t
cfq_set_key_type(struct cfq_data *cfqd, const char *page, size_t count)
{
spin_lock_irq(cfqd->queue->queue_lock);
if (!strncmp(page, "pgid", 4))
cfqd->key_type = CFQ_KEY_PGID;
else if (!strncmp(page, "tgid", 4))
cfqd->key_type = CFQ_KEY_TGID;
else if (!strncmp(page, "uid", 3))
cfqd->key_type = CFQ_KEY_UID;
else if (!strncmp(page, "gid", 3))
cfqd->key_type = CFQ_KEY_GID;
spin_unlock_irq(cfqd->queue->queue_lock);
return count;
}
static ssize_t
cfq_read_key_type(struct cfq_data *cfqd, char *page)
{
ssize_t len = 0;
int i;
for (i = CFQ_KEY_PGID; i < CFQ_KEY_LAST; i++) {
if (cfqd->key_type == i)
len += sprintf(page+len, "[%s] ", cfq_key_types[i]);
else
len += sprintf(page+len, "%s ", cfq_key_types[i]);
}
len += sprintf(page+len, "\n");
return len;
}
#define SHOW_FUNCTION(__FUNC, __VAR, __CONV) \ #define SHOW_FUNCTION(__FUNC, __VAR, __CONV) \
static ssize_t __FUNC(struct cfq_data *cfqd, char *page) \ static ssize_t __FUNC(struct cfq_data *cfqd, char *page) \
{ \ { \
...@@ -1669,12 +2274,15 @@ static ssize_t __FUNC(struct cfq_data *cfqd, char *page) \ ...@@ -1669,12 +2274,15 @@ static ssize_t __FUNC(struct cfq_data *cfqd, char *page) \
} }
SHOW_FUNCTION(cfq_quantum_show, cfqd->cfq_quantum, 0); SHOW_FUNCTION(cfq_quantum_show, cfqd->cfq_quantum, 0);
SHOW_FUNCTION(cfq_queued_show, cfqd->cfq_queued, 0); SHOW_FUNCTION(cfq_queued_show, cfqd->cfq_queued, 0);
SHOW_FUNCTION(cfq_fifo_expire_r_show, cfqd->cfq_fifo_expire_r, 1); SHOW_FUNCTION(cfq_fifo_expire_sync_show, cfqd->cfq_fifo_expire[1], 1);
SHOW_FUNCTION(cfq_fifo_expire_w_show, cfqd->cfq_fifo_expire_w, 1); SHOW_FUNCTION(cfq_fifo_expire_async_show, cfqd->cfq_fifo_expire[0], 1);
SHOW_FUNCTION(cfq_fifo_batch_expire_show, cfqd->cfq_fifo_batch_expire, 1);
SHOW_FUNCTION(cfq_find_best_show, cfqd->find_best_crq, 0);
SHOW_FUNCTION(cfq_back_max_show, cfqd->cfq_back_max, 0); SHOW_FUNCTION(cfq_back_max_show, cfqd->cfq_back_max, 0);
SHOW_FUNCTION(cfq_back_penalty_show, cfqd->cfq_back_penalty, 0); SHOW_FUNCTION(cfq_back_penalty_show, cfqd->cfq_back_penalty, 0);
SHOW_FUNCTION(cfq_slice_idle_show, cfqd->cfq_slice_idle, 1);
SHOW_FUNCTION(cfq_slice_sync_show, cfqd->cfq_slice[1], 1);
SHOW_FUNCTION(cfq_slice_async_show, cfqd->cfq_slice[0], 1);
SHOW_FUNCTION(cfq_slice_async_rq_show, cfqd->cfq_slice_async_rq, 0);
SHOW_FUNCTION(cfq_max_depth_show, cfqd->cfq_max_depth, 0);
#undef SHOW_FUNCTION #undef SHOW_FUNCTION
#define STORE_FUNCTION(__FUNC, __PTR, MIN, MAX, __CONV) \ #define STORE_FUNCTION(__FUNC, __PTR, MIN, MAX, __CONV) \
...@@ -1694,12 +2302,15 @@ static ssize_t __FUNC(struct cfq_data *cfqd, const char *page, size_t count) \ ...@@ -1694,12 +2302,15 @@ static ssize_t __FUNC(struct cfq_data *cfqd, const char *page, size_t count) \
} }
STORE_FUNCTION(cfq_quantum_store, &cfqd->cfq_quantum, 1, UINT_MAX, 0); STORE_FUNCTION(cfq_quantum_store, &cfqd->cfq_quantum, 1, UINT_MAX, 0);
STORE_FUNCTION(cfq_queued_store, &cfqd->cfq_queued, 1, UINT_MAX, 0); STORE_FUNCTION(cfq_queued_store, &cfqd->cfq_queued, 1, UINT_MAX, 0);
STORE_FUNCTION(cfq_fifo_expire_r_store, &cfqd->cfq_fifo_expire_r, 1, UINT_MAX, 1); STORE_FUNCTION(cfq_fifo_expire_sync_store, &cfqd->cfq_fifo_expire[1], 1, UINT_MAX, 1);
STORE_FUNCTION(cfq_fifo_expire_w_store, &cfqd->cfq_fifo_expire_w, 1, UINT_MAX, 1); STORE_FUNCTION(cfq_fifo_expire_async_store, &cfqd->cfq_fifo_expire[0], 1, UINT_MAX, 1);
STORE_FUNCTION(cfq_fifo_batch_expire_store, &cfqd->cfq_fifo_batch_expire, 0, UINT_MAX, 1);
STORE_FUNCTION(cfq_find_best_store, &cfqd->find_best_crq, 0, 1, 0);
STORE_FUNCTION(cfq_back_max_store, &cfqd->cfq_back_max, 0, UINT_MAX, 0); STORE_FUNCTION(cfq_back_max_store, &cfqd->cfq_back_max, 0, UINT_MAX, 0);
STORE_FUNCTION(cfq_back_penalty_store, &cfqd->cfq_back_penalty, 1, UINT_MAX, 0); STORE_FUNCTION(cfq_back_penalty_store, &cfqd->cfq_back_penalty, 1, UINT_MAX, 0);
STORE_FUNCTION(cfq_slice_idle_store, &cfqd->cfq_slice_idle, 0, UINT_MAX, 1);
STORE_FUNCTION(cfq_slice_sync_store, &cfqd->cfq_slice[1], 1, UINT_MAX, 1);
STORE_FUNCTION(cfq_slice_async_store, &cfqd->cfq_slice[0], 1, UINT_MAX, 1);
STORE_FUNCTION(cfq_slice_async_rq_store, &cfqd->cfq_slice_async_rq, 1, UINT_MAX, 0);
STORE_FUNCTION(cfq_max_depth_store, &cfqd->cfq_max_depth, 1, UINT_MAX, 0);
#undef STORE_FUNCTION #undef STORE_FUNCTION
static struct cfq_fs_entry cfq_quantum_entry = { static struct cfq_fs_entry cfq_quantum_entry = {
...@@ -1712,25 +2323,15 @@ static struct cfq_fs_entry cfq_queued_entry = { ...@@ -1712,25 +2323,15 @@ static struct cfq_fs_entry cfq_queued_entry = {
.show = cfq_queued_show, .show = cfq_queued_show,
.store = cfq_queued_store, .store = cfq_queued_store,
}; };
static struct cfq_fs_entry cfq_fifo_expire_r_entry = { static struct cfq_fs_entry cfq_fifo_expire_sync_entry = {
.attr = {.name = "fifo_expire_sync", .mode = S_IRUGO | S_IWUSR }, .attr = {.name = "fifo_expire_sync", .mode = S_IRUGO | S_IWUSR },
.show = cfq_fifo_expire_r_show, .show = cfq_fifo_expire_sync_show,
.store = cfq_fifo_expire_r_store, .store = cfq_fifo_expire_sync_store,
}; };
static struct cfq_fs_entry cfq_fifo_expire_w_entry = { static struct cfq_fs_entry cfq_fifo_expire_async_entry = {
.attr = {.name = "fifo_expire_async", .mode = S_IRUGO | S_IWUSR }, .attr = {.name = "fifo_expire_async", .mode = S_IRUGO | S_IWUSR },
.show = cfq_fifo_expire_w_show, .show = cfq_fifo_expire_async_show,
.store = cfq_fifo_expire_w_store, .store = cfq_fifo_expire_async_store,
};
static struct cfq_fs_entry cfq_fifo_batch_expire_entry = {
.attr = {.name = "fifo_batch_expire", .mode = S_IRUGO | S_IWUSR },
.show = cfq_fifo_batch_expire_show,
.store = cfq_fifo_batch_expire_store,
};
static struct cfq_fs_entry cfq_find_best_entry = {
.attr = {.name = "find_best_crq", .mode = S_IRUGO | S_IWUSR },
.show = cfq_find_best_show,
.store = cfq_find_best_store,
}; };
static struct cfq_fs_entry cfq_back_max_entry = { static struct cfq_fs_entry cfq_back_max_entry = {
.attr = {.name = "back_seek_max", .mode = S_IRUGO | S_IWUSR }, .attr = {.name = "back_seek_max", .mode = S_IRUGO | S_IWUSR },
...@@ -1742,27 +2343,43 @@ static struct cfq_fs_entry cfq_back_penalty_entry = { ...@@ -1742,27 +2343,43 @@ static struct cfq_fs_entry cfq_back_penalty_entry = {
.show = cfq_back_penalty_show, .show = cfq_back_penalty_show,
.store = cfq_back_penalty_store, .store = cfq_back_penalty_store,
}; };
static struct cfq_fs_entry cfq_clear_elapsed_entry = { static struct cfq_fs_entry cfq_slice_sync_entry = {
.attr = {.name = "clear_elapsed", .mode = S_IWUSR }, .attr = {.name = "slice_sync", .mode = S_IRUGO | S_IWUSR },
.store = cfq_clear_elapsed, .show = cfq_slice_sync_show,
.store = cfq_slice_sync_store,
}; };
static struct cfq_fs_entry cfq_key_type_entry = { static struct cfq_fs_entry cfq_slice_async_entry = {
.attr = {.name = "key_type", .mode = S_IRUGO | S_IWUSR }, .attr = {.name = "slice_async", .mode = S_IRUGO | S_IWUSR },
.show = cfq_read_key_type, .show = cfq_slice_async_show,
.store = cfq_set_key_type, .store = cfq_slice_async_store,
};
static struct cfq_fs_entry cfq_slice_async_rq_entry = {
.attr = {.name = "slice_async_rq", .mode = S_IRUGO | S_IWUSR },
.show = cfq_slice_async_rq_show,
.store = cfq_slice_async_rq_store,
};
static struct cfq_fs_entry cfq_slice_idle_entry = {
.attr = {.name = "slice_idle", .mode = S_IRUGO | S_IWUSR },
.show = cfq_slice_idle_show,
.store = cfq_slice_idle_store,
};
static struct cfq_fs_entry cfq_max_depth_entry = {
.attr = {.name = "max_depth", .mode = S_IRUGO | S_IWUSR },
.show = cfq_max_depth_show,
.store = cfq_max_depth_store,
}; };
static struct attribute *default_attrs[] = { static struct attribute *default_attrs[] = {
&cfq_quantum_entry.attr, &cfq_quantum_entry.attr,
&cfq_queued_entry.attr, &cfq_queued_entry.attr,
&cfq_fifo_expire_r_entry.attr, &cfq_fifo_expire_sync_entry.attr,
&cfq_fifo_expire_w_entry.attr, &cfq_fifo_expire_async_entry.attr,
&cfq_fifo_batch_expire_entry.attr,
&cfq_key_type_entry.attr,
&cfq_find_best_entry.attr,
&cfq_back_max_entry.attr, &cfq_back_max_entry.attr,
&cfq_back_penalty_entry.attr, &cfq_back_penalty_entry.attr,
&cfq_clear_elapsed_entry.attr, &cfq_slice_sync_entry.attr,
&cfq_slice_async_entry.attr,
&cfq_slice_async_rq_entry.attr,
&cfq_slice_idle_entry.attr,
&cfq_max_depth_entry.attr,
NULL, NULL,
}; };
...@@ -1832,21 +2449,46 @@ static int __init cfq_init(void) ...@@ -1832,21 +2449,46 @@ static int __init cfq_init(void)
{ {
int ret; int ret;
/*
* could be 0 on HZ < 1000 setups
*/
if (!cfq_slice_async)
cfq_slice_async = 1;
if (!cfq_slice_idle)
cfq_slice_idle = 1;
if (cfq_slab_setup()) if (cfq_slab_setup())
return -ENOMEM; return -ENOMEM;
ret = elv_register(&iosched_cfq); ret = elv_register(&iosched_cfq);
if (!ret) { if (ret)
__module_get(THIS_MODULE); cfq_slab_kill();
return 0;
}
cfq_slab_kill();
return ret; return ret;
} }
static void __exit cfq_exit(void) static void __exit cfq_exit(void)
{ {
struct task_struct *g, *p;
unsigned long flags;
read_lock_irqsave(&tasklist_lock, flags);
/*
* iterate each process in the system, removing our io_context
*/
do_each_thread(g, p) {
struct io_context *ioc = p->io_context;
if (ioc && ioc->cic) {
ioc->cic->exit(ioc->cic);
cfq_free_io_context(ioc->cic);
ioc->cic = NULL;
}
} while_each_thread(g, p);
read_unlock_irqrestore(&tasklist_lock, flags);
cfq_slab_kill(); cfq_slab_kill();
elv_unregister(&iosched_cfq); elv_unregister(&iosched_cfq);
} }
......
...@@ -760,7 +760,8 @@ static void deadline_put_request(request_queue_t *q, struct request *rq) ...@@ -760,7 +760,8 @@ static void deadline_put_request(request_queue_t *q, struct request *rq)
} }
static int static int
deadline_set_request(request_queue_t *q, struct request *rq, int gfp_mask) deadline_set_request(request_queue_t *q, struct request *rq, struct bio *bio,
int gfp_mask)
{ {
struct deadline_data *dd = q->elevator->elevator_data; struct deadline_data *dd = q->elevator->elevator_data;
struct deadline_rq *drq; struct deadline_rq *drq;
......
...@@ -486,12 +486,13 @@ struct request *elv_former_request(request_queue_t *q, struct request *rq) ...@@ -486,12 +486,13 @@ struct request *elv_former_request(request_queue_t *q, struct request *rq)
return NULL; return NULL;
} }
int elv_set_request(request_queue_t *q, struct request *rq, int gfp_mask) int elv_set_request(request_queue_t *q, struct request *rq, struct bio *bio,
int gfp_mask)
{ {
elevator_t *e = q->elevator; elevator_t *e = q->elevator;
if (e->ops->elevator_set_req_fn) if (e->ops->elevator_set_req_fn)
return e->ops->elevator_set_req_fn(q, rq, gfp_mask); return e->ops->elevator_set_req_fn(q, rq, bio, gfp_mask);
rq->elevator_private = NULL; rq->elevator_private = NULL;
return 0; return 0;
...@@ -505,12 +506,12 @@ void elv_put_request(request_queue_t *q, struct request *rq) ...@@ -505,12 +506,12 @@ void elv_put_request(request_queue_t *q, struct request *rq)
e->ops->elevator_put_req_fn(q, rq); e->ops->elevator_put_req_fn(q, rq);
} }
int elv_may_queue(request_queue_t *q, int rw) int elv_may_queue(request_queue_t *q, int rw, struct bio *bio)
{ {
elevator_t *e = q->elevator; elevator_t *e = q->elevator;
if (e->ops->elevator_may_queue_fn) if (e->ops->elevator_may_queue_fn)
return e->ops->elevator_may_queue_fn(q, rw); return e->ops->elevator_may_queue_fn(q, rw, bio);
return ELV_MQUEUE_MAY; return ELV_MQUEUE_MAY;
} }
......
...@@ -276,6 +276,7 @@ static inline void rq_init(request_queue_t *q, struct request *rq) ...@@ -276,6 +276,7 @@ static inline void rq_init(request_queue_t *q, struct request *rq)
rq->errors = 0; rq->errors = 0;
rq->rq_status = RQ_ACTIVE; rq->rq_status = RQ_ACTIVE;
rq->bio = rq->biotail = NULL; rq->bio = rq->biotail = NULL;
rq->ioprio = 0;
rq->buffer = NULL; rq->buffer = NULL;
rq->ref_count = 1; rq->ref_count = 1;
rq->q = q; rq->q = q;
...@@ -1442,11 +1443,7 @@ void __generic_unplug_device(request_queue_t *q) ...@@ -1442,11 +1443,7 @@ void __generic_unplug_device(request_queue_t *q)
if (!blk_remove_plug(q)) if (!blk_remove_plug(q))
return; return;
/* q->request_fn(q);
* was plugged, fire request_fn if queue has stuff to do
*/
if (elv_next_request(q))
q->request_fn(q);
} }
EXPORT_SYMBOL(__generic_unplug_device); EXPORT_SYMBOL(__generic_unplug_device);
...@@ -1776,8 +1773,8 @@ static inline void blk_free_request(request_queue_t *q, struct request *rq) ...@@ -1776,8 +1773,8 @@ static inline void blk_free_request(request_queue_t *q, struct request *rq)
mempool_free(rq, q->rq.rq_pool); mempool_free(rq, q->rq.rq_pool);
} }
static inline struct request *blk_alloc_request(request_queue_t *q, int rw, static inline struct request *
int gfp_mask) blk_alloc_request(request_queue_t *q, int rw, struct bio *bio, int gfp_mask)
{ {
struct request *rq = mempool_alloc(q->rq.rq_pool, gfp_mask); struct request *rq = mempool_alloc(q->rq.rq_pool, gfp_mask);
...@@ -1790,7 +1787,7 @@ static inline struct request *blk_alloc_request(request_queue_t *q, int rw, ...@@ -1790,7 +1787,7 @@ static inline struct request *blk_alloc_request(request_queue_t *q, int rw,
*/ */
rq->flags = rw; rq->flags = rw;
if (!elv_set_request(q, rq, gfp_mask)) if (!elv_set_request(q, rq, bio, gfp_mask))
return rq; return rq;
mempool_free(rq, q->rq.rq_pool); mempool_free(rq, q->rq.rq_pool);
...@@ -1872,7 +1869,8 @@ static void freed_request(request_queue_t *q, int rw) ...@@ -1872,7 +1869,8 @@ static void freed_request(request_queue_t *q, int rw)
/* /*
* Get a free request, queue_lock must not be held * Get a free request, queue_lock must not be held
*/ */
static struct request *get_request(request_queue_t *q, int rw, int gfp_mask) static struct request *get_request(request_queue_t *q, int rw, struct bio *bio,
int gfp_mask)
{ {
struct request *rq = NULL; struct request *rq = NULL;
struct request_list *rl = &q->rq; struct request_list *rl = &q->rq;
...@@ -1895,7 +1893,7 @@ static struct request *get_request(request_queue_t *q, int rw, int gfp_mask) ...@@ -1895,7 +1893,7 @@ static struct request *get_request(request_queue_t *q, int rw, int gfp_mask)
} }
} }
switch (elv_may_queue(q, rw)) { switch (elv_may_queue(q, rw, bio)) {
case ELV_MQUEUE_NO: case ELV_MQUEUE_NO:
goto rq_starved; goto rq_starved;
case ELV_MQUEUE_MAY: case ELV_MQUEUE_MAY:
...@@ -1920,7 +1918,7 @@ static struct request *get_request(request_queue_t *q, int rw, int gfp_mask) ...@@ -1920,7 +1918,7 @@ static struct request *get_request(request_queue_t *q, int rw, int gfp_mask)
set_queue_congested(q, rw); set_queue_congested(q, rw);
spin_unlock_irq(q->queue_lock); spin_unlock_irq(q->queue_lock);
rq = blk_alloc_request(q, rw, gfp_mask); rq = blk_alloc_request(q, rw, bio, gfp_mask);
if (!rq) { if (!rq) {
/* /*
* Allocation failed presumably due to memory. Undo anything * Allocation failed presumably due to memory. Undo anything
...@@ -1961,7 +1959,8 @@ static struct request *get_request(request_queue_t *q, int rw, int gfp_mask) ...@@ -1961,7 +1959,8 @@ static struct request *get_request(request_queue_t *q, int rw, int gfp_mask)
* No available requests for this queue, unplug the device and wait for some * No available requests for this queue, unplug the device and wait for some
* requests to become available. * requests to become available.
*/ */
static struct request *get_request_wait(request_queue_t *q, int rw) static struct request *get_request_wait(request_queue_t *q, int rw,
struct bio *bio)
{ {
DEFINE_WAIT(wait); DEFINE_WAIT(wait);
struct request *rq; struct request *rq;
...@@ -1972,7 +1971,7 @@ static struct request *get_request_wait(request_queue_t *q, int rw) ...@@ -1972,7 +1971,7 @@ static struct request *get_request_wait(request_queue_t *q, int rw)
prepare_to_wait_exclusive(&rl->wait[rw], &wait, prepare_to_wait_exclusive(&rl->wait[rw], &wait,
TASK_UNINTERRUPTIBLE); TASK_UNINTERRUPTIBLE);
rq = get_request(q, rw, GFP_NOIO); rq = get_request(q, rw, bio, GFP_NOIO);
if (!rq) { if (!rq) {
struct io_context *ioc; struct io_context *ioc;
...@@ -2003,9 +2002,9 @@ struct request *blk_get_request(request_queue_t *q, int rw, int gfp_mask) ...@@ -2003,9 +2002,9 @@ struct request *blk_get_request(request_queue_t *q, int rw, int gfp_mask)
BUG_ON(rw != READ && rw != WRITE); BUG_ON(rw != READ && rw != WRITE);
if (gfp_mask & __GFP_WAIT) if (gfp_mask & __GFP_WAIT)
rq = get_request_wait(q, rw); rq = get_request_wait(q, rw, NULL);
else else
rq = get_request(q, rw, gfp_mask); rq = get_request(q, rw, NULL, gfp_mask);
return rq; return rq;
} }
...@@ -2333,7 +2332,6 @@ static void __blk_put_request(request_queue_t *q, struct request *req) ...@@ -2333,7 +2332,6 @@ static void __blk_put_request(request_queue_t *q, struct request *req)
return; return;
req->rq_status = RQ_INACTIVE; req->rq_status = RQ_INACTIVE;
req->q = NULL;
req->rl = NULL; req->rl = NULL;
/* /*
...@@ -2462,6 +2460,8 @@ static int attempt_merge(request_queue_t *q, struct request *req, ...@@ -2462,6 +2460,8 @@ static int attempt_merge(request_queue_t *q, struct request *req,
req->rq_disk->in_flight--; req->rq_disk->in_flight--;
} }
req->ioprio = ioprio_best(req->ioprio, next->ioprio);
__blk_put_request(q, next); __blk_put_request(q, next);
return 1; return 1;
} }
...@@ -2514,11 +2514,13 @@ static int __make_request(request_queue_t *q, struct bio *bio) ...@@ -2514,11 +2514,13 @@ static int __make_request(request_queue_t *q, struct bio *bio)
{ {
struct request *req, *freereq = NULL; struct request *req, *freereq = NULL;
int el_ret, rw, nr_sectors, cur_nr_sectors, barrier, err, sync; int el_ret, rw, nr_sectors, cur_nr_sectors, barrier, err, sync;
unsigned short prio;
sector_t sector; sector_t sector;
sector = bio->bi_sector; sector = bio->bi_sector;
nr_sectors = bio_sectors(bio); nr_sectors = bio_sectors(bio);
cur_nr_sectors = bio_cur_sectors(bio); cur_nr_sectors = bio_cur_sectors(bio);
prio = bio_prio(bio);
rw = bio_data_dir(bio); rw = bio_data_dir(bio);
sync = bio_sync(bio); sync = bio_sync(bio);
...@@ -2559,6 +2561,7 @@ static int __make_request(request_queue_t *q, struct bio *bio) ...@@ -2559,6 +2561,7 @@ static int __make_request(request_queue_t *q, struct bio *bio)
req->biotail->bi_next = bio; req->biotail->bi_next = bio;
req->biotail = bio; req->biotail = bio;
req->nr_sectors = req->hard_nr_sectors += nr_sectors; req->nr_sectors = req->hard_nr_sectors += nr_sectors;
req->ioprio = ioprio_best(req->ioprio, prio);
drive_stat_acct(req, nr_sectors, 0); drive_stat_acct(req, nr_sectors, 0);
if (!attempt_back_merge(q, req)) if (!attempt_back_merge(q, req))
elv_merged_request(q, req); elv_merged_request(q, req);
...@@ -2583,6 +2586,7 @@ static int __make_request(request_queue_t *q, struct bio *bio) ...@@ -2583,6 +2586,7 @@ static int __make_request(request_queue_t *q, struct bio *bio)
req->hard_cur_sectors = cur_nr_sectors; req->hard_cur_sectors = cur_nr_sectors;
req->sector = req->hard_sector = sector; req->sector = req->hard_sector = sector;
req->nr_sectors = req->hard_nr_sectors += nr_sectors; req->nr_sectors = req->hard_nr_sectors += nr_sectors;
req->ioprio = ioprio_best(req->ioprio, prio);
drive_stat_acct(req, nr_sectors, 0); drive_stat_acct(req, nr_sectors, 0);
if (!attempt_front_merge(q, req)) if (!attempt_front_merge(q, req))
elv_merged_request(q, req); elv_merged_request(q, req);
...@@ -2610,7 +2614,7 @@ static int __make_request(request_queue_t *q, struct bio *bio) ...@@ -2610,7 +2614,7 @@ static int __make_request(request_queue_t *q, struct bio *bio)
freereq = NULL; freereq = NULL;
} else { } else {
spin_unlock_irq(q->queue_lock); spin_unlock_irq(q->queue_lock);
if ((freereq = get_request(q, rw, GFP_ATOMIC)) == NULL) { if ((freereq = get_request(q, rw, bio, GFP_ATOMIC)) == NULL) {
/* /*
* READA bit set * READA bit set
*/ */
...@@ -2618,7 +2622,7 @@ static int __make_request(request_queue_t *q, struct bio *bio) ...@@ -2618,7 +2622,7 @@ static int __make_request(request_queue_t *q, struct bio *bio)
if (bio_rw_ahead(bio)) if (bio_rw_ahead(bio))
goto end_io; goto end_io;
freereq = get_request_wait(q, rw); freereq = get_request_wait(q, rw, bio);
} }
goto again; goto again;
} }
...@@ -2646,6 +2650,7 @@ static int __make_request(request_queue_t *q, struct bio *bio) ...@@ -2646,6 +2650,7 @@ static int __make_request(request_queue_t *q, struct bio *bio)
req->buffer = bio_data(bio); /* see ->buffer comment above */ req->buffer = bio_data(bio); /* see ->buffer comment above */
req->waiting = NULL; req->waiting = NULL;
req->bio = req->biotail = bio; req->bio = req->biotail = bio;
req->ioprio = prio;
req->rq_disk = bio->bi_bdev->bd_disk; req->rq_disk = bio->bi_bdev->bd_disk;
req->start_time = jiffies; req->start_time = jiffies;
...@@ -2674,7 +2679,7 @@ static inline void blk_partition_remap(struct bio *bio) ...@@ -2674,7 +2679,7 @@ static inline void blk_partition_remap(struct bio *bio)
if (bdev != bdev->bd_contains) { if (bdev != bdev->bd_contains) {
struct hd_struct *p = bdev->bd_part; struct hd_struct *p = bdev->bd_part;
switch (bio->bi_rw) { switch (bio_data_dir(bio)) {
case READ: case READ:
p->read_sectors += bio_sectors(bio); p->read_sectors += bio_sectors(bio);
p->reads++; p->reads++;
...@@ -2693,6 +2698,7 @@ void blk_finish_queue_drain(request_queue_t *q) ...@@ -2693,6 +2698,7 @@ void blk_finish_queue_drain(request_queue_t *q)
{ {
struct request_list *rl = &q->rq; struct request_list *rl = &q->rq;
struct request *rq; struct request *rq;
int requeued = 0;
spin_lock_irq(q->queue_lock); spin_lock_irq(q->queue_lock);
clear_bit(QUEUE_FLAG_DRAIN, &q->queue_flags); clear_bit(QUEUE_FLAG_DRAIN, &q->queue_flags);
...@@ -2701,9 +2707,13 @@ void blk_finish_queue_drain(request_queue_t *q) ...@@ -2701,9 +2707,13 @@ void blk_finish_queue_drain(request_queue_t *q)
rq = list_entry_rq(q->drain_list.next); rq = list_entry_rq(q->drain_list.next);
list_del_init(&rq->queuelist); list_del_init(&rq->queuelist);
__elv_add_request(q, rq, ELEVATOR_INSERT_BACK, 1); elv_requeue_request(q, rq);
requeued++;
} }
if (requeued)
q->request_fn(q);
spin_unlock_irq(q->queue_lock); spin_unlock_irq(q->queue_lock);
wake_up(&rl->wait[0]); wake_up(&rl->wait[0]);
...@@ -2900,7 +2910,7 @@ void submit_bio(int rw, struct bio *bio) ...@@ -2900,7 +2910,7 @@ void submit_bio(int rw, struct bio *bio)
BIO_BUG_ON(!bio->bi_size); BIO_BUG_ON(!bio->bi_size);
BIO_BUG_ON(!bio->bi_io_vec); BIO_BUG_ON(!bio->bi_io_vec);
bio->bi_rw = rw; bio->bi_rw |= rw;
if (rw & WRITE) if (rw & WRITE)
mod_page_state(pgpgout, count); mod_page_state(pgpgout, count);
else else
...@@ -3257,8 +3267,11 @@ void exit_io_context(void) ...@@ -3257,8 +3267,11 @@ void exit_io_context(void)
struct io_context *ioc; struct io_context *ioc;
local_irq_save(flags); local_irq_save(flags);
task_lock(current);
ioc = current->io_context; ioc = current->io_context;
current->io_context = NULL; current->io_context = NULL;
ioc->task = NULL;
task_unlock(current);
local_irq_restore(flags); local_irq_restore(flags);
if (ioc->aic && ioc->aic->exit) if (ioc->aic && ioc->aic->exit)
...@@ -3293,12 +3306,12 @@ struct io_context *get_io_context(int gfp_flags) ...@@ -3293,12 +3306,12 @@ struct io_context *get_io_context(int gfp_flags)
ret = kmem_cache_alloc(iocontext_cachep, gfp_flags); ret = kmem_cache_alloc(iocontext_cachep, gfp_flags);
if (ret) { if (ret) {
atomic_set(&ret->refcount, 1); atomic_set(&ret->refcount, 1);
ret->pid = tsk->pid; ret->task = current;
ret->set_ioprio = NULL;
ret->last_waited = jiffies; /* doesn't matter... */ ret->last_waited = jiffies; /* doesn't matter... */
ret->nr_batch_requests = 0; /* because this is 0 */ ret->nr_batch_requests = 0; /* because this is 0 */
ret->aic = NULL; ret->aic = NULL;
ret->cic = NULL; ret->cic = NULL;
spin_lock_init(&ret->lock);
local_irq_save(flags); local_irq_save(flags);
......
...@@ -10,6 +10,7 @@ obj-y := open.o read_write.o file_table.o buffer.o bio.o super.o \ ...@@ -10,6 +10,7 @@ obj-y := open.o read_write.o file_table.o buffer.o bio.o super.o \
ioctl.o readdir.o select.o fifo.o locks.o dcache.o inode.o \ ioctl.o readdir.o select.o fifo.o locks.o dcache.o inode.o \
attr.o bad_inode.o file.o filesystems.o namespace.o aio.o \ attr.o bad_inode.o file.o filesystems.o namespace.o aio.o \
seq_file.o xattr.o libfs.o fs-writeback.o mpage.o direct-io.o \ seq_file.o xattr.o libfs.o fs-writeback.o mpage.o direct-io.o \
ioprio.o
obj-$(CONFIG_EPOLL) += eventpoll.o obj-$(CONFIG_EPOLL) += eventpoll.o
obj-$(CONFIG_COMPAT) += compat.o obj-$(CONFIG_COMPAT) += compat.o
......
/*
* fs/ioprio.c
*
* Copyright (C) 2004 Jens Axboe <axboe@suse.de>
*
* Helper functions for setting/querying io priorities of processes. The
* system calls closely mimmick getpriority/setpriority, see the man page for
* those. The prio argument is a composite of prio class and prio data, where
* the data argument has meaning within that class. The standard scheduling
* classes have 8 distinct prio levels, with 0 being the highest prio and 7
* being the lowest.
*
* IOW, setting BE scheduling class with prio 2 is done ala:
*
* unsigned int prio = (IOPRIO_CLASS_BE << IOPRIO_CLASS_SHIFT) | 2;
*
* ioprio_set(PRIO_PROCESS, pid, prio);
*
* See also Documentation/block/ioprio.txt
*
*/
#include <linux/kernel.h>
#include <linux/ioprio.h>
#include <linux/blkdev.h>
static int set_task_ioprio(struct task_struct *task, int ioprio)
{
struct io_context *ioc;
if (task->uid != current->euid &&
task->uid != current->uid && !capable(CAP_SYS_NICE))
return -EPERM;
task_lock(task);
task->ioprio = ioprio;
ioc = task->io_context;
if (ioc && ioc->set_ioprio)
ioc->set_ioprio(ioc, ioprio);
task_unlock(task);
return 0;
}
asmlinkage int sys_ioprio_set(int which, int who, int ioprio)
{
int class = IOPRIO_PRIO_CLASS(ioprio);
int data = IOPRIO_PRIO_DATA(ioprio);
struct task_struct *p, *g;
struct user_struct *user;
int ret;
switch (class) {
case IOPRIO_CLASS_RT:
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
/* fall through, rt has prio field too */
case IOPRIO_CLASS_BE:
if (data >= IOPRIO_BE_NR || data < 0)
return -EINVAL;
break;
case IOPRIO_CLASS_IDLE:
break;
default:
return -EINVAL;
}
ret = -ESRCH;
read_lock_irq(&tasklist_lock);
switch (which) {
case IOPRIO_WHO_PROCESS:
if (!who)
p = current;
else
p = find_task_by_pid(who);
if (p)
ret = set_task_ioprio(p, ioprio);
break;
case IOPRIO_WHO_PGRP:
if (!who)
who = process_group(current);
do_each_task_pid(who, PIDTYPE_PGID, p) {
ret = set_task_ioprio(p, ioprio);
if (ret)
break;
} while_each_task_pid(who, PIDTYPE_PGID, p);
break;
case IOPRIO_WHO_USER:
if (!who)
user = current->user;
else
user = find_user(who);
if (!user)
break;
do_each_thread(g, p) {
if (p->uid != who)
continue;
ret = set_task_ioprio(p, ioprio);
if (ret)
break;
} while_each_thread(g, p);
if (who)
free_uid(user);
break;
default:
ret = -EINVAL;
}
read_unlock_irq(&tasklist_lock);
return ret;
}
asmlinkage int sys_ioprio_get(int which, int who)
{
struct task_struct *g, *p;
struct user_struct *user;
int ret = -ESRCH;
read_lock_irq(&tasklist_lock);
switch (which) {
case IOPRIO_WHO_PROCESS:
if (!who)
p = current;
else
p = find_task_by_pid(who);
if (p)
ret = p->ioprio;
break;
case IOPRIO_WHO_PGRP:
if (!who)
who = process_group(current);
do_each_task_pid(who, PIDTYPE_PGID, p) {
if (ret == -ESRCH)
ret = p->ioprio;
else
ret = ioprio_best(ret, p->ioprio);
} while_each_task_pid(who, PIDTYPE_PGID, p);
break;
case IOPRIO_WHO_USER:
if (!who)
user = current->user;
else
user = find_user(who);
if (!user)
break;
do_each_thread(g, p) {
if (p->uid != user->uid)
continue;
if (ret == -ESRCH)
ret = p->ioprio;
else
ret = ioprio_best(ret, p->ioprio);
} while_each_thread(g, p);
if (who)
free_uid(user);
break;
default:
ret = -EINVAL;
}
read_unlock_irq(&tasklist_lock);
return ret;
}
...@@ -645,18 +645,22 @@ struct buffer_chunk { ...@@ -645,18 +645,22 @@ struct buffer_chunk {
static void write_chunk(struct buffer_chunk *chunk) { static void write_chunk(struct buffer_chunk *chunk) {
int i; int i;
get_fs_excl();
for (i = 0; i < chunk->nr ; i++) { for (i = 0; i < chunk->nr ; i++) {
submit_logged_buffer(chunk->bh[i]) ; submit_logged_buffer(chunk->bh[i]) ;
} }
chunk->nr = 0; chunk->nr = 0;
put_fs_excl();
} }
static void write_ordered_chunk(struct buffer_chunk *chunk) { static void write_ordered_chunk(struct buffer_chunk *chunk) {
int i; int i;
get_fs_excl();
for (i = 0; i < chunk->nr ; i++) { for (i = 0; i < chunk->nr ; i++) {
submit_ordered_buffer(chunk->bh[i]) ; submit_ordered_buffer(chunk->bh[i]) ;
} }
chunk->nr = 0; chunk->nr = 0;
put_fs_excl();
} }
static int add_to_chunk(struct buffer_chunk *chunk, struct buffer_head *bh, static int add_to_chunk(struct buffer_chunk *chunk, struct buffer_head *bh,
...@@ -918,6 +922,8 @@ static int flush_commit_list(struct super_block *s, struct reiserfs_journal_list ...@@ -918,6 +922,8 @@ static int flush_commit_list(struct super_block *s, struct reiserfs_journal_list
return 0 ; return 0 ;
} }
get_fs_excl();
/* before we can put our commit blocks on disk, we have to make sure everyone older than /* before we can put our commit blocks on disk, we have to make sure everyone older than
** us is on disk too ** us is on disk too
*/ */
...@@ -1055,6 +1061,7 @@ static int flush_commit_list(struct super_block *s, struct reiserfs_journal_list ...@@ -1055,6 +1061,7 @@ static int flush_commit_list(struct super_block *s, struct reiserfs_journal_list
if (retval) if (retval)
reiserfs_abort (s, retval, "Journal write error in %s", __FUNCTION__); reiserfs_abort (s, retval, "Journal write error in %s", __FUNCTION__);
put_fs_excl();
return retval; return retval;
} }
...@@ -1251,6 +1258,8 @@ static int flush_journal_list(struct super_block *s, ...@@ -1251,6 +1258,8 @@ static int flush_journal_list(struct super_block *s,
return 0 ; return 0 ;
} }
get_fs_excl();
/* if all the work is already done, get out of here */ /* if all the work is already done, get out of here */
if (atomic_read(&(jl->j_nonzerolen)) <= 0 && if (atomic_read(&(jl->j_nonzerolen)) <= 0 &&
atomic_read(&(jl->j_commit_left)) <= 0) { atomic_read(&(jl->j_commit_left)) <= 0) {
...@@ -1450,6 +1459,7 @@ static int flush_journal_list(struct super_block *s, ...@@ -1450,6 +1459,7 @@ static int flush_journal_list(struct super_block *s,
put_journal_list(s, jl); put_journal_list(s, jl);
if (flushall) if (flushall)
up(&journal->j_flush_sem); up(&journal->j_flush_sem);
put_fs_excl();
return err ; return err ;
} }
...@@ -2719,6 +2729,7 @@ static int do_journal_begin_r(struct reiserfs_transaction_handle *th, struct sup ...@@ -2719,6 +2729,7 @@ static int do_journal_begin_r(struct reiserfs_transaction_handle *th, struct sup
th->t_trans_id = journal->j_trans_id ; th->t_trans_id = journal->j_trans_id ;
unlock_journal(p_s_sb) ; unlock_journal(p_s_sb) ;
INIT_LIST_HEAD (&th->t_list); INIT_LIST_HEAD (&th->t_list);
get_fs_excl();
return 0 ; return 0 ;
out_fail: out_fail:
...@@ -3526,6 +3537,7 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, struct super_b ...@@ -3526,6 +3537,7 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, struct super_b
BUG_ON (th->t_refcount > 1); BUG_ON (th->t_refcount > 1);
BUG_ON (!th->t_trans_id); BUG_ON (!th->t_trans_id);
put_fs_excl();
current->journal_info = th->t_handle_save; current->journal_info = th->t_handle_save;
reiserfs_check_lock_depth(p_s_sb, "journal end"); reiserfs_check_lock_depth(p_s_sb, "journal end");
if (journal->j_len == 0) { if (journal->j_len == 0) {
......
...@@ -294,8 +294,10 @@ ...@@ -294,8 +294,10 @@
#define __NR_add_key 286 #define __NR_add_key 286
#define __NR_request_key 287 #define __NR_request_key 287
#define __NR_keyctl 288 #define __NR_keyctl 288
#define __NR_ioprio_set 289
#define __NR_ioprio_get 290
#define NR_syscalls 289 #define NR_syscalls 291
/* /*
* user-visible error numbers are in the range -1 - -128: see * user-visible error numbers are in the range -1 - -128: see
......
...@@ -263,6 +263,8 @@ ...@@ -263,6 +263,8 @@
#define __NR_add_key 1271 #define __NR_add_key 1271
#define __NR_request_key 1272 #define __NR_request_key 1272
#define __NR_keyctl 1273 #define __NR_keyctl 1273
#define __NR_ioprio_set 1274
#define __NR_ioprio_get 1275
#define __NR_set_zone_reclaim 1276 #define __NR_set_zone_reclaim 1276
#ifdef __KERNEL__ #ifdef __KERNEL__
......
...@@ -277,8 +277,10 @@ ...@@ -277,8 +277,10 @@
#define __NR_request_key 270 #define __NR_request_key 270
#define __NR_keyctl 271 #define __NR_keyctl 271
#define __NR_waitid 272 #define __NR_waitid 272
#define __NR_ioprio_set 273
#define __NR_ioprio_get 274
#define __NR_syscalls 273 #define __NR_syscalls 275
#define __NR(n) #n #define __NR(n) #n
......
...@@ -561,8 +561,12 @@ __SYSCALL(__NR_add_key, sys_add_key) ...@@ -561,8 +561,12 @@ __SYSCALL(__NR_add_key, sys_add_key)
__SYSCALL(__NR_request_key, sys_request_key) __SYSCALL(__NR_request_key, sys_request_key)
#define __NR_keyctl 250 #define __NR_keyctl 250
__SYSCALL(__NR_keyctl, sys_keyctl) __SYSCALL(__NR_keyctl, sys_keyctl)
#define __NR_ioprio_set 251
__SYSCALL(__NR_ioprio_set, sys_ioprio_set)
#define __NR_ioprio_get 252
__SYSCALL(__NR_ioprio_get, sys_ioprio_get)
#define __NR_syscall_max __NR_keyctl #define __NR_syscall_max __NR_ioprio_get
#ifndef __NO_STUBS #ifndef __NO_STUBS
/* user-visible error numbers are in the range -1 - -4095 */ /* user-visible error numbers are in the range -1 - -4095 */
......
...@@ -22,6 +22,7 @@ ...@@ -22,6 +22,7 @@
#include <linux/highmem.h> #include <linux/highmem.h>
#include <linux/mempool.h> #include <linux/mempool.h>
#include <linux/ioprio.h>
/* Platforms may set this to teach the BIO layer about IOMMU hardware. */ /* Platforms may set this to teach the BIO layer about IOMMU hardware. */
#include <asm/io.h> #include <asm/io.h>
...@@ -149,6 +150,19 @@ struct bio { ...@@ -149,6 +150,19 @@ struct bio {
#define BIO_RW_FAILFAST 3 #define BIO_RW_FAILFAST 3
#define BIO_RW_SYNC 4 #define BIO_RW_SYNC 4
/*
* upper 16 bits of bi_rw define the io priority of this bio
*/
#define BIO_PRIO_SHIFT (8 * sizeof(unsigned long) - IOPRIO_BITS)
#define bio_prio(bio) ((bio)->bi_rw >> BIO_PRIO_SHIFT)
#define bio_prio_valid(bio) ioprio_valid(bio_prio(bio))
#define bio_set_prio(bio, prio) do { \
WARN_ON(prio >= (1 << IOPRIO_BITS)); \
(bio)->bi_rw &= ((1UL << BIO_PRIO_SHIFT) - 1); \
(bio)->bi_rw |= ((unsigned long) (prio) << BIO_PRIO_SHIFT); \
} while (0)
/* /*
* various member access, note that bio_data should of course not be used * various member access, note that bio_data should of course not be used
* on highmem page vectors * on highmem page vectors
......
...@@ -54,16 +54,23 @@ struct as_io_context { ...@@ -54,16 +54,23 @@ struct as_io_context {
struct cfq_queue; struct cfq_queue;
struct cfq_io_context { struct cfq_io_context {
void (*dtor)(struct cfq_io_context *);
void (*exit)(struct cfq_io_context *);
struct io_context *ioc;
/* /*
* circular list of cfq_io_contexts belonging to a process io context * circular list of cfq_io_contexts belonging to a process io context
*/ */
struct list_head list; struct list_head list;
struct cfq_queue *cfqq; struct cfq_queue *cfqq;
void *key;
struct io_context *ioc;
unsigned long last_end_request;
unsigned long last_queue;
unsigned long ttime_total;
unsigned long ttime_samples;
unsigned long ttime_mean;
void (*dtor)(struct cfq_io_context *);
void (*exit)(struct cfq_io_context *);
}; };
/* /*
...@@ -73,7 +80,9 @@ struct cfq_io_context { ...@@ -73,7 +80,9 @@ struct cfq_io_context {
*/ */
struct io_context { struct io_context {
atomic_t refcount; atomic_t refcount;
pid_t pid; struct task_struct *task;
int (*set_ioprio)(struct io_context *, unsigned int);
/* /*
* For request batching * For request batching
...@@ -81,8 +90,6 @@ struct io_context { ...@@ -81,8 +90,6 @@ struct io_context {
unsigned long last_waited; /* Time last woken after wait for request */ unsigned long last_waited; /* Time last woken after wait for request */
int nr_batch_requests; /* Number of requests left in the batch */ int nr_batch_requests; /* Number of requests left in the batch */
spinlock_t lock;
struct as_io_context *aic; struct as_io_context *aic;
struct cfq_io_context *cic; struct cfq_io_context *cic;
}; };
...@@ -134,6 +141,8 @@ struct request { ...@@ -134,6 +141,8 @@ struct request {
void *elevator_private; void *elevator_private;
unsigned short ioprio;
int rq_status; /* should split this into a few status bits */ int rq_status; /* should split this into a few status bits */
struct gendisk *rq_disk; struct gendisk *rq_disk;
int errors; int errors;
......
...@@ -16,9 +16,9 @@ typedef void (elevator_remove_req_fn) (request_queue_t *, struct request *); ...@@ -16,9 +16,9 @@ typedef void (elevator_remove_req_fn) (request_queue_t *, struct request *);
typedef void (elevator_requeue_req_fn) (request_queue_t *, struct request *); typedef void (elevator_requeue_req_fn) (request_queue_t *, struct request *);
typedef struct request *(elevator_request_list_fn) (request_queue_t *, struct request *); typedef struct request *(elevator_request_list_fn) (request_queue_t *, struct request *);
typedef void (elevator_completed_req_fn) (request_queue_t *, struct request *); typedef void (elevator_completed_req_fn) (request_queue_t *, struct request *);
typedef int (elevator_may_queue_fn) (request_queue_t *, int); typedef int (elevator_may_queue_fn) (request_queue_t *, int, struct bio *);
typedef int (elevator_set_req_fn) (request_queue_t *, struct request *, int); typedef int (elevator_set_req_fn) (request_queue_t *, struct request *, struct bio *, int);
typedef void (elevator_put_req_fn) (request_queue_t *, struct request *); typedef void (elevator_put_req_fn) (request_queue_t *, struct request *);
typedef void (elevator_deactivate_req_fn) (request_queue_t *, struct request *); typedef void (elevator_deactivate_req_fn) (request_queue_t *, struct request *);
...@@ -96,9 +96,9 @@ extern struct request *elv_former_request(request_queue_t *, struct request *); ...@@ -96,9 +96,9 @@ extern struct request *elv_former_request(request_queue_t *, struct request *);
extern struct request *elv_latter_request(request_queue_t *, struct request *); extern struct request *elv_latter_request(request_queue_t *, struct request *);
extern int elv_register_queue(request_queue_t *q); extern int elv_register_queue(request_queue_t *q);
extern void elv_unregister_queue(request_queue_t *q); extern void elv_unregister_queue(request_queue_t *q);
extern int elv_may_queue(request_queue_t *, int); extern int elv_may_queue(request_queue_t *, int, struct bio *);
extern void elv_completed_request(request_queue_t *, struct request *); extern void elv_completed_request(request_queue_t *, struct request *);
extern int elv_set_request(request_queue_t *, struct request *, int); extern int elv_set_request(request_queue_t *, struct request *, struct bio *, int);
extern void elv_put_request(request_queue_t *, struct request *); extern void elv_put_request(request_queue_t *, struct request *);
/* /*
......
...@@ -213,6 +213,7 @@ extern int dir_notify_enable; ...@@ -213,6 +213,7 @@ extern int dir_notify_enable;
#include <linux/radix-tree.h> #include <linux/radix-tree.h>
#include <linux/prio_tree.h> #include <linux/prio_tree.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/sched.h>
#include <asm/atomic.h> #include <asm/atomic.h>
#include <asm/semaphore.h> #include <asm/semaphore.h>
...@@ -822,16 +823,34 @@ enum { ...@@ -822,16 +823,34 @@ enum {
#define vfs_check_frozen(sb, level) \ #define vfs_check_frozen(sb, level) \
wait_event((sb)->s_wait_unfrozen, ((sb)->s_frozen < (level))) wait_event((sb)->s_wait_unfrozen, ((sb)->s_frozen < (level)))
static inline void get_fs_excl(void)
{
atomic_inc(&current->fs_excl);
}
static inline void put_fs_excl(void)
{
atomic_dec(&current->fs_excl);
}
static inline int has_fs_excl(void)
{
return atomic_read(&current->fs_excl);
}
/* /*
* Superblock locking. * Superblock locking.
*/ */
static inline void lock_super(struct super_block * sb) static inline void lock_super(struct super_block * sb)
{ {
get_fs_excl();
down(&sb->s_lock); down(&sb->s_lock);
} }
static inline void unlock_super(struct super_block * sb) static inline void unlock_super(struct super_block * sb)
{ {
put_fs_excl();
up(&sb->s_lock); up(&sb->s_lock);
} }
......
...@@ -81,6 +81,7 @@ extern struct group_info init_groups; ...@@ -81,6 +81,7 @@ extern struct group_info init_groups;
.mm = NULL, \ .mm = NULL, \
.active_mm = &init_mm, \ .active_mm = &init_mm, \
.run_list = LIST_HEAD_INIT(tsk.run_list), \ .run_list = LIST_HEAD_INIT(tsk.run_list), \
.ioprio = 0, \
.time_slice = HZ, \ .time_slice = HZ, \
.tasks = LIST_HEAD_INIT(tsk.tasks), \ .tasks = LIST_HEAD_INIT(tsk.tasks), \
.ptrace_children= LIST_HEAD_INIT(tsk.ptrace_children), \ .ptrace_children= LIST_HEAD_INIT(tsk.ptrace_children), \
...@@ -110,6 +111,7 @@ extern struct group_info init_groups; ...@@ -110,6 +111,7 @@ extern struct group_info init_groups;
.proc_lock = SPIN_LOCK_UNLOCKED, \ .proc_lock = SPIN_LOCK_UNLOCKED, \
.journal_info = NULL, \ .journal_info = NULL, \
.cpu_timers = INIT_CPU_TIMERS(tsk.cpu_timers), \ .cpu_timers = INIT_CPU_TIMERS(tsk.cpu_timers), \
.fs_excl = ATOMIC_INIT(0), \
} }
......
#ifndef IOPRIO_H
#define IOPRIO_H
#include <linux/sched.h>
/*
* Gives us 8 prio classes with 13-bits of data for each class
*/
#define IOPRIO_BITS (16)
#define IOPRIO_CLASS_SHIFT (13)
#define IOPRIO_PRIO_MASK ((1UL << IOPRIO_CLASS_SHIFT) - 1)
#define IOPRIO_PRIO_CLASS(mask) ((mask) >> IOPRIO_CLASS_SHIFT)
#define IOPRIO_PRIO_DATA(mask) ((mask) & IOPRIO_PRIO_MASK)
#define ioprio_valid(mask) (IOPRIO_PRIO_CLASS((mask)) != IOPRIO_CLASS_NONE)
/*
* These are the io priority groups as implemented by CFQ. RT is the realtime
* class, it always gets premium service. BE is the best-effort scheduling
* class, the default for any process. IDLE is the idle scheduling class, it
* is only served when no one else is using the disk.
*/
enum {
IOPRIO_CLASS_NONE,
IOPRIO_CLASS_RT,
IOPRIO_CLASS_BE,
IOPRIO_CLASS_IDLE,
};
/*
* 8 best effort priority levels are supported
*/
#define IOPRIO_BE_NR (8)
asmlinkage int sys_ioprio_set(int, int, int);
asmlinkage int sys_ioprio_get(int, int);
enum {
IOPRIO_WHO_PROCESS = 1,
IOPRIO_WHO_PGRP,
IOPRIO_WHO_USER,
};
/*
* if process has set io priority explicitly, use that. if not, convert
* the cpu scheduler nice value to an io priority
*/
#define IOPRIO_NORM (4)
static inline int task_ioprio(struct task_struct *task)
{
WARN_ON(!ioprio_valid(task->ioprio));
return IOPRIO_PRIO_DATA(task->ioprio);
}
static inline int task_nice_ioprio(struct task_struct *task)
{
return (task_nice(task) + 20) / 5;
}
/*
* For inheritance, return the highest of the two given priorities
*/
static inline int ioprio_best(unsigned short aprio, unsigned short bprio)
{
unsigned short aclass = IOPRIO_PRIO_CLASS(aprio);
unsigned short bclass = IOPRIO_PRIO_CLASS(bprio);
if (!ioprio_valid(aprio))
return bprio;
if (!ioprio_valid(bprio))
return aprio;
if (aclass == IOPRIO_CLASS_NONE)
aclass = IOPRIO_CLASS_BE;
if (bclass == IOPRIO_CLASS_NONE)
bclass = IOPRIO_CLASS_BE;
if (aclass == bclass)
return min(aprio, bprio);
if (aclass > bclass)
return bprio;
else
return aprio;
}
#endif
...@@ -608,6 +608,8 @@ struct task_struct { ...@@ -608,6 +608,8 @@ struct task_struct {
struct list_head run_list; struct list_head run_list;
prio_array_t *array; prio_array_t *array;
unsigned short ioprio;
unsigned long sleep_avg; unsigned long sleep_avg;
unsigned long long timestamp, last_ran; unsigned long long timestamp, last_ran;
unsigned long long sched_time; /* sched_clock time spent running */ unsigned long long sched_time; /* sched_clock time spent running */
...@@ -763,6 +765,7 @@ struct task_struct { ...@@ -763,6 +765,7 @@ struct task_struct {
nodemask_t mems_allowed; nodemask_t mems_allowed;
int cpuset_mems_generation; int cpuset_mems_generation;
#endif #endif
atomic_t fs_excl; /* holding fs exclusive resources */
}; };
static inline pid_t process_group(struct task_struct *tsk) static inline pid_t process_group(struct task_struct *tsk)
...@@ -1112,7 +1115,8 @@ extern void unhash_process(struct task_struct *p); ...@@ -1112,7 +1115,8 @@ extern void unhash_process(struct task_struct *p);
/* /*
* Protects ->fs, ->files, ->mm, ->ptrace, ->group_info, ->comm, keyring * Protects ->fs, ->files, ->mm, ->ptrace, ->group_info, ->comm, keyring
* subscriptions and synchronises with wait4(). Also used in procfs. * subscriptions and synchronises with wait4(). Also used in procfs. Also
* pins the final release of task.io_context.
* *
* Nests both inside and outside of read_lock(&tasklist_lock). * Nests both inside and outside of read_lock(&tasklist_lock).
* It must not be nested with write_lock_irq(&tasklist_lock), * It must not be nested with write_lock_irq(&tasklist_lock),
......
...@@ -14,11 +14,13 @@ extern struct list_head inode_unused; ...@@ -14,11 +14,13 @@ extern struct list_head inode_unused;
* Yes, writeback.h requires sched.h * Yes, writeback.h requires sched.h
* No, sched.h is not included from here. * No, sched.h is not included from here.
*/ */
static inline int current_is_pdflush(void) static inline int task_is_pdflush(struct task_struct *task)
{ {
return current->flags & PF_FLUSHER; return task->flags & PF_FLUSHER;
} }
#define current_is_pdflush() task_is_pdflush(current)
/* /*
* fs/fs-writeback.c * fs/fs-writeback.c
*/ */
......
...@@ -784,6 +784,8 @@ fastcall NORET_TYPE void do_exit(long code) ...@@ -784,6 +784,8 @@ fastcall NORET_TYPE void do_exit(long code)
profile_task_exit(tsk); profile_task_exit(tsk);
WARN_ON(atomic_read(&tsk->fs_excl));
if (unlikely(in_interrupt())) if (unlikely(in_interrupt()))
panic("Aiee, killing interrupt handler!"); panic("Aiee, killing interrupt handler!");
if (unlikely(!tsk->pid)) if (unlikely(!tsk->pid))
......
...@@ -1090,6 +1090,11 @@ static task_t *copy_process(unsigned long clone_flags, ...@@ -1090,6 +1090,11 @@ static task_t *copy_process(unsigned long clone_flags,
spin_unlock(&current->sighand->siglock); spin_unlock(&current->sighand->siglock);
} }
/*
* inherit ioprio
*/
p->ioprio = current->ioprio;
SET_LINKS(p); SET_LINKS(p);
if (unlikely(p->ptrace & PT_PTRACED)) if (unlikely(p->ptrace & PT_PTRACED))
__ptrace_link(p, current->parent); __ptrace_link(p, current->parent);
......
...@@ -3448,15 +3448,7 @@ int task_nice(const task_t *p) ...@@ -3448,15 +3448,7 @@ int task_nice(const task_t *p)
{ {
return TASK_NICE(p); return TASK_NICE(p);
} }
/*
* The only users of task_nice are binfmt_elf and binfmt_elf32.
* binfmt_elf is no longer modular, but binfmt_elf32 still is.
* Therefore, task_nice is needed if there is a compat_mode.
*/
#ifdef CONFIG_COMPAT
EXPORT_SYMBOL_GPL(task_nice); EXPORT_SYMBOL_GPL(task_nice);
#endif
/** /**
* idle_cpu - is a given cpu idle currently? * idle_cpu - is a given cpu idle currently?
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment