2010-09-16 05:06:35 +08:00
|
|
|
/*
|
|
|
|
|
* Interface for controlling IO bandwidth on a request queue
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 2010 Vivek Goyal <vgoyal@redhat.com>
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
|
#include <linux/slab.h>
|
|
|
|
|
#include <linux/blkdev.h>
|
|
|
|
|
#include <linux/bio.h>
|
|
|
|
|
#include <linux/blktrace_api.h>
|
|
|
|
|
#include "blk-cgroup.h"
|
2011-10-19 20:31:18 +08:00
|
|
|
#include "blk.h"
|
2010-09-16 05:06:35 +08:00
|
|
|
|
|
|
|
|
/* Max dispatch from a group in 1 round */
|
|
|
|
|
static int throtl_grp_quantum = 8;
|
|
|
|
|
|
|
|
|
|
/* Total max dispatch from all groups in one round */
|
|
|
|
|
static int throtl_quantum = 32;
|
|
|
|
|
|
|
|
|
|
/* Throttling is performed over 100ms slice and after that slice is renewed */
|
|
|
|
|
static unsigned long throtl_slice = HZ/10; /* 100 ms */
|
|
|
|
|
|
2012-03-06 05:15:14 +08:00
|
|
|
static struct blkio_policy_type blkio_policy_throtl;
|
|
|
|
|
|
2011-03-02 02:40:54 +08:00
|
|
|
/* A workqueue to queue throttle related work */
|
|
|
|
|
static struct workqueue_struct *kthrotld_workqueue;
|
|
|
|
|
static void throtl_schedule_delayed_work(struct throtl_data *td,
|
|
|
|
|
unsigned long delay);
|
|
|
|
|
|
2010-09-16 05:06:35 +08:00
|
|
|
struct throtl_rb_root {
|
|
|
|
|
struct rb_root rb;
|
|
|
|
|
struct rb_node *left;
|
|
|
|
|
unsigned int count;
|
|
|
|
|
unsigned long min_disptime;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define THROTL_RB_ROOT (struct throtl_rb_root) { .rb = RB_ROOT, .left = NULL, \
|
|
|
|
|
.count = 0, .min_disptime = 0}
|
|
|
|
|
|
|
|
|
|
#define rb_entry_tg(node) rb_entry((node), struct throtl_grp, rb_node)
|
|
|
|
|
|
|
|
|
|
struct throtl_grp {
|
|
|
|
|
/* active throtl group service_tree member */
|
|
|
|
|
struct rb_node rb_node;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Dispatch time in jiffies. This is the estimated time when group
|
|
|
|
|
* will unthrottle and is ready to dispatch more bio. It is used as
|
|
|
|
|
* key to sort active groups in service tree.
|
|
|
|
|
*/
|
|
|
|
|
unsigned long disptime;
|
|
|
|
|
|
|
|
|
|
unsigned int flags;
|
|
|
|
|
|
|
|
|
|
/* Two lists for READ and WRITE */
|
|
|
|
|
struct bio_list bio_lists[2];
|
|
|
|
|
|
|
|
|
|
/* Number of queued bios on READ and WRITE lists */
|
|
|
|
|
unsigned int nr_queued[2];
|
|
|
|
|
|
|
|
|
|
/* bytes per second rate limits */
|
|
|
|
|
uint64_t bps[2];
|
|
|
|
|
|
2010-09-16 05:06:37 +08:00
|
|
|
/* IOPS limits */
|
|
|
|
|
unsigned int iops[2];
|
|
|
|
|
|
2010-09-16 05:06:35 +08:00
|
|
|
/* Number of bytes disptached in current slice */
|
|
|
|
|
uint64_t bytes_disp[2];
|
2010-09-16 05:06:37 +08:00
|
|
|
/* Number of bio's dispatched in current slice */
|
|
|
|
|
unsigned int io_disp[2];
|
2010-09-16 05:06:35 +08:00
|
|
|
|
|
|
|
|
/* When did we start a new slice */
|
|
|
|
|
unsigned long slice_start[2];
|
|
|
|
|
unsigned long slice_end[2];
|
2010-10-01 20:49:49 +08:00
|
|
|
|
|
|
|
|
/* Some throttle limits got updated for the group */
|
2011-03-30 18:21:56 +08:00
|
|
|
int limits_changed;
|
2010-09-16 05:06:35 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct throtl_data
|
|
|
|
|
{
|
|
|
|
|
/* service tree for active throtl groups */
|
|
|
|
|
struct throtl_rb_root tg_service_tree;
|
|
|
|
|
|
2011-05-20 03:38:24 +08:00
|
|
|
struct throtl_grp *root_tg;
|
2010-09-16 05:06:35 +08:00
|
|
|
struct request_queue *queue;
|
|
|
|
|
|
|
|
|
|
/* Total Number of queued bios on READ and WRITE lists */
|
|
|
|
|
unsigned int nr_queued[2];
|
|
|
|
|
|
|
|
|
|
/*
|
2010-10-01 20:49:48 +08:00
|
|
|
* number of total undestroyed groups
|
2010-09-16 05:06:35 +08:00
|
|
|
*/
|
|
|
|
|
unsigned int nr_undestroyed_grps;
|
|
|
|
|
|
|
|
|
|
/* Work for dispatching throttled bios */
|
|
|
|
|
struct delayed_work throtl_work;
|
2010-10-01 20:49:49 +08:00
|
|
|
|
2011-03-30 18:21:56 +08:00
|
|
|
int limits_changed;
|
2010-09-16 05:06:35 +08:00
|
|
|
};
|
|
|
|
|
|
2012-03-06 05:15:14 +08:00
|
|
|
static inline struct throtl_grp *blkg_to_tg(struct blkio_group *blkg)
|
|
|
|
|
{
|
|
|
|
|
return blkg_to_pdata(blkg, &blkio_policy_throtl);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline struct blkio_group *tg_to_blkg(struct throtl_grp *tg)
|
|
|
|
|
{
|
|
|
|
|
return pdata_to_blkg(tg, &blkio_policy_throtl);
|
|
|
|
|
}
|
|
|
|
|
|
2010-09-16 05:06:35 +08:00
|
|
|
enum tg_state_flags {
|
|
|
|
|
THROTL_TG_FLAG_on_rr = 0, /* on round-robin busy list */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define THROTL_TG_FNS(name) \
|
|
|
|
|
static inline void throtl_mark_tg_##name(struct throtl_grp *tg) \
|
|
|
|
|
{ \
|
|
|
|
|
(tg)->flags |= (1 << THROTL_TG_FLAG_##name); \
|
|
|
|
|
} \
|
|
|
|
|
static inline void throtl_clear_tg_##name(struct throtl_grp *tg) \
|
|
|
|
|
{ \
|
|
|
|
|
(tg)->flags &= ~(1 << THROTL_TG_FLAG_##name); \
|
|
|
|
|
} \
|
|
|
|
|
static inline int throtl_tg_##name(const struct throtl_grp *tg) \
|
|
|
|
|
{ \
|
|
|
|
|
return ((tg)->flags & (1 << THROTL_TG_FLAG_##name)) != 0; \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
THROTL_TG_FNS(on_rr);
|
|
|
|
|
|
|
|
|
|
#define throtl_log_tg(td, tg, fmt, args...) \
|
|
|
|
|
blk_add_trace_msg((td)->queue, "throtl %s " fmt, \
|
2012-03-06 05:15:14 +08:00
|
|
|
blkg_path(tg_to_blkg(tg)), ##args); \
|
2010-09-16 05:06:35 +08:00
|
|
|
|
|
|
|
|
#define throtl_log(td, fmt, args...) \
|
|
|
|
|
blk_add_trace_msg((td)->queue, "throtl " fmt, ##args)
|
|
|
|
|
|
2011-06-14 02:19:27 +08:00
|
|
|
static inline unsigned int total_nr_queued(struct throtl_data *td)
|
2010-09-16 05:06:35 +08:00
|
|
|
{
|
2011-06-14 02:19:27 +08:00
|
|
|
return td->nr_queued[0] + td->nr_queued[1];
|
2010-09-16 05:06:35 +08:00
|
|
|
}
|
|
|
|
|
|
2012-03-06 05:15:14 +08:00
|
|
|
static void throtl_init_blkio_group(struct blkio_group *blkg)
|
2011-05-20 03:38:19 +08:00
|
|
|
{
|
2012-03-06 05:15:14 +08:00
|
|
|
struct throtl_grp *tg = blkg_to_tg(blkg);
|
2012-03-06 05:15:06 +08:00
|
|
|
|
2011-05-20 03:38:19 +08:00
|
|
|
RB_CLEAR_NODE(&tg->rb_node);
|
|
|
|
|
bio_list_init(&tg->bio_lists[0]);
|
|
|
|
|
bio_list_init(&tg->bio_lists[1]);
|
|
|
|
|
tg->limits_changed = false;
|
|
|
|
|
|
2012-03-06 05:15:07 +08:00
|
|
|
tg->bps[READ] = -1;
|
|
|
|
|
tg->bps[WRITE] = -1;
|
|
|
|
|
tg->iops[READ] = -1;
|
|
|
|
|
tg->iops[WRITE] = -1;
|
2011-05-20 03:38:19 +08:00
|
|
|
}
|
|
|
|
|
|
2011-05-20 03:38:23 +08:00
|
|
|
static struct
|
2012-03-06 05:15:06 +08:00
|
|
|
throtl_grp *throtl_lookup_tg(struct throtl_data *td, struct blkio_cgroup *blkcg)
|
2010-09-16 05:06:35 +08:00
|
|
|
{
|
2011-01-19 23:25:02 +08:00
|
|
|
/*
|
|
|
|
|
* This is the common case when there are no blkio cgroups.
|
2012-03-06 05:15:06 +08:00
|
|
|
* Avoid lookup in this case
|
|
|
|
|
*/
|
2011-01-19 23:25:02 +08:00
|
|
|
if (blkcg == &blkio_root_cgroup)
|
2012-03-06 05:15:09 +08:00
|
|
|
return td->root_tg;
|
2010-09-16 05:06:35 +08:00
|
|
|
|
2012-03-06 05:15:14 +08:00
|
|
|
return blkg_to_tg(blkg_lookup(blkcg, td->queue, BLKIO_POLICY_THROTL));
|
2010-09-16 05:06:35 +08:00
|
|
|
}
|
|
|
|
|
|
2012-03-06 05:15:06 +08:00
|
|
|
static struct throtl_grp *throtl_lookup_create_tg(struct throtl_data *td,
|
|
|
|
|
struct blkio_cgroup *blkcg)
|
2010-09-16 05:06:35 +08:00
|
|
|
{
|
2011-05-20 03:38:23 +08:00
|
|
|
struct request_queue *q = td->queue;
|
2012-03-06 05:15:06 +08:00
|
|
|
struct throtl_grp *tg = NULL;
|
2011-10-19 20:33:01 +08:00
|
|
|
|
2011-05-20 03:38:23 +08:00
|
|
|
/*
|
2012-03-06 05:15:06 +08:00
|
|
|
* This is the common case when there are no blkio cgroups.
|
|
|
|
|
* Avoid lookup in this case
|
2011-05-20 03:38:23 +08:00
|
|
|
*/
|
2012-03-06 05:15:06 +08:00
|
|
|
if (blkcg == &blkio_root_cgroup) {
|
|
|
|
|
tg = td->root_tg;
|
|
|
|
|
} else {
|
|
|
|
|
struct blkio_group *blkg;
|
2011-05-20 03:38:23 +08:00
|
|
|
|
2012-03-06 05:15:06 +08:00
|
|
|
blkg = blkg_lookup_create(blkcg, q, BLKIO_POLICY_THROTL, false);
|
2011-05-20 03:38:23 +08:00
|
|
|
|
2012-03-06 05:15:06 +08:00
|
|
|
/* if %NULL and @q is alive, fall back to root_tg */
|
|
|
|
|
if (!IS_ERR(blkg))
|
2012-03-06 05:15:14 +08:00
|
|
|
tg = blkg_to_tg(blkg);
|
2012-03-06 05:15:06 +08:00
|
|
|
else if (!blk_queue_dead(q))
|
|
|
|
|
tg = td->root_tg;
|
2011-05-20 03:38:23 +08:00
|
|
|
}
|
|
|
|
|
|
2010-09-16 05:06:35 +08:00
|
|
|
return tg;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct throtl_grp *throtl_rb_first(struct throtl_rb_root *root)
|
|
|
|
|
{
|
|
|
|
|
/* Service tree is empty */
|
|
|
|
|
if (!root->count)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
if (!root->left)
|
|
|
|
|
root->left = rb_first(&root->rb);
|
|
|
|
|
|
|
|
|
|
if (root->left)
|
|
|
|
|
return rb_entry_tg(root->left);
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void rb_erase_init(struct rb_node *n, struct rb_root *root)
|
|
|
|
|
{
|
|
|
|
|
rb_erase(n, root);
|
|
|
|
|
RB_CLEAR_NODE(n);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void throtl_rb_erase(struct rb_node *n, struct throtl_rb_root *root)
|
|
|
|
|
{
|
|
|
|
|
if (root->left == n)
|
|
|
|
|
root->left = NULL;
|
|
|
|
|
rb_erase_init(n, &root->rb);
|
|
|
|
|
--root->count;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void update_min_dispatch_time(struct throtl_rb_root *st)
|
|
|
|
|
{
|
|
|
|
|
struct throtl_grp *tg;
|
|
|
|
|
|
|
|
|
|
tg = throtl_rb_first(st);
|
|
|
|
|
if (!tg)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
st->min_disptime = tg->disptime;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
tg_service_tree_add(struct throtl_rb_root *st, struct throtl_grp *tg)
|
|
|
|
|
{
|
|
|
|
|
struct rb_node **node = &st->rb.rb_node;
|
|
|
|
|
struct rb_node *parent = NULL;
|
|
|
|
|
struct throtl_grp *__tg;
|
|
|
|
|
unsigned long key = tg->disptime;
|
|
|
|
|
int left = 1;
|
|
|
|
|
|
|
|
|
|
while (*node != NULL) {
|
|
|
|
|
parent = *node;
|
|
|
|
|
__tg = rb_entry_tg(parent);
|
|
|
|
|
|
|
|
|
|
if (time_before(key, __tg->disptime))
|
|
|
|
|
node = &parent->rb_left;
|
|
|
|
|
else {
|
|
|
|
|
node = &parent->rb_right;
|
|
|
|
|
left = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (left)
|
|
|
|
|
st->left = &tg->rb_node;
|
|
|
|
|
|
|
|
|
|
rb_link_node(&tg->rb_node, parent, node);
|
|
|
|
|
rb_insert_color(&tg->rb_node, &st->rb);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __throtl_enqueue_tg(struct throtl_data *td, struct throtl_grp *tg)
|
|
|
|
|
{
|
|
|
|
|
struct throtl_rb_root *st = &td->tg_service_tree;
|
|
|
|
|
|
|
|
|
|
tg_service_tree_add(st, tg);
|
|
|
|
|
throtl_mark_tg_on_rr(tg);
|
|
|
|
|
st->count++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void throtl_enqueue_tg(struct throtl_data *td, struct throtl_grp *tg)
|
|
|
|
|
{
|
|
|
|
|
if (!throtl_tg_on_rr(tg))
|
|
|
|
|
__throtl_enqueue_tg(td, tg);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __throtl_dequeue_tg(struct throtl_data *td, struct throtl_grp *tg)
|
|
|
|
|
{
|
|
|
|
|
throtl_rb_erase(&tg->rb_node, &td->tg_service_tree);
|
|
|
|
|
throtl_clear_tg_on_rr(tg);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void throtl_dequeue_tg(struct throtl_data *td, struct throtl_grp *tg)
|
|
|
|
|
{
|
|
|
|
|
if (throtl_tg_on_rr(tg))
|
|
|
|
|
__throtl_dequeue_tg(td, tg);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void throtl_schedule_next_dispatch(struct throtl_data *td)
|
|
|
|
|
{
|
|
|
|
|
struct throtl_rb_root *st = &td->tg_service_tree;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If there are more bios pending, schedule more work.
|
|
|
|
|
*/
|
|
|
|
|
if (!total_nr_queued(td))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
BUG_ON(!st->count);
|
|
|
|
|
|
|
|
|
|
update_min_dispatch_time(st);
|
|
|
|
|
|
|
|
|
|
if (time_before_eq(st->min_disptime, jiffies))
|
2011-03-02 02:40:54 +08:00
|
|
|
throtl_schedule_delayed_work(td, 0);
|
2010-09-16 05:06:35 +08:00
|
|
|
else
|
2011-03-02 02:40:54 +08:00
|
|
|
throtl_schedule_delayed_work(td, (st->min_disptime - jiffies));
|
2010-09-16 05:06:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
|
throtl_start_new_slice(struct throtl_data *td, struct throtl_grp *tg, bool rw)
|
|
|
|
|
{
|
|
|
|
|
tg->bytes_disp[rw] = 0;
|
2010-09-16 05:06:37 +08:00
|
|
|
tg->io_disp[rw] = 0;
|
2010-09-16 05:06:35 +08:00
|
|
|
tg->slice_start[rw] = jiffies;
|
|
|
|
|
tg->slice_end[rw] = jiffies + throtl_slice;
|
|
|
|
|
throtl_log_tg(td, tg, "[%c] new slice start=%lu end=%lu jiffies=%lu",
|
|
|
|
|
rw == READ ? 'R' : 'W', tg->slice_start[rw],
|
|
|
|
|
tg->slice_end[rw], jiffies);
|
|
|
|
|
}
|
|
|
|
|
|
2010-12-02 02:34:46 +08:00
|
|
|
static inline void throtl_set_slice_end(struct throtl_data *td,
|
|
|
|
|
struct throtl_grp *tg, bool rw, unsigned long jiffy_end)
|
|
|
|
|
{
|
|
|
|
|
tg->slice_end[rw] = roundup(jiffy_end, throtl_slice);
|
|
|
|
|
}
|
|
|
|
|
|
2010-09-16 05:06:35 +08:00
|
|
|
static inline void throtl_extend_slice(struct throtl_data *td,
|
|
|
|
|
struct throtl_grp *tg, bool rw, unsigned long jiffy_end)
|
|
|
|
|
{
|
|
|
|
|
tg->slice_end[rw] = roundup(jiffy_end, throtl_slice);
|
|
|
|
|
throtl_log_tg(td, tg, "[%c] extend slice start=%lu end=%lu jiffies=%lu",
|
|
|
|
|
rw == READ ? 'R' : 'W', tg->slice_start[rw],
|
|
|
|
|
tg->slice_end[rw], jiffies);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Determine if previously allocated or extended slice is complete or not */
|
|
|
|
|
static bool
|
|
|
|
|
throtl_slice_used(struct throtl_data *td, struct throtl_grp *tg, bool rw)
|
|
|
|
|
{
|
|
|
|
|
if (time_in_range(jiffies, tg->slice_start[rw], tg->slice_end[rw]))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Trim the used slices and adjust slice start accordingly */
|
|
|
|
|
static inline void
|
|
|
|
|
throtl_trim_slice(struct throtl_data *td, struct throtl_grp *tg, bool rw)
|
|
|
|
|
{
|
2010-10-01 20:51:14 +08:00
|
|
|
unsigned long nr_slices, time_elapsed, io_trim;
|
|
|
|
|
u64 bytes_trim, tmp;
|
2010-09-16 05:06:35 +08:00
|
|
|
|
|
|
|
|
BUG_ON(time_before(tg->slice_end[rw], tg->slice_start[rw]));
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If bps are unlimited (-1), then time slice don't get
|
|
|
|
|
* renewed. Don't try to trim the slice if slice is used. A new
|
|
|
|
|
* slice will start when appropriate.
|
|
|
|
|
*/
|
|
|
|
|
if (throtl_slice_used(td, tg, rw))
|
|
|
|
|
return;
|
|
|
|
|
|
2010-12-02 02:34:46 +08:00
|
|
|
/*
|
|
|
|
|
* A bio has been dispatched. Also adjust slice_end. It might happen
|
|
|
|
|
* that initially cgroup limit was very low resulting in high
|
|
|
|
|
* slice_end, but later limit was bumped up and bio was dispached
|
|
|
|
|
* sooner, then we need to reduce slice_end. A high bogus slice_end
|
|
|
|
|
* is bad because it does not allow new slice to start.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
throtl_set_slice_end(td, tg, rw, jiffies + throtl_slice);
|
|
|
|
|
|
2010-09-16 05:06:35 +08:00
|
|
|
time_elapsed = jiffies - tg->slice_start[rw];
|
|
|
|
|
|
|
|
|
|
nr_slices = time_elapsed / throtl_slice;
|
|
|
|
|
|
|
|
|
|
if (!nr_slices)
|
|
|
|
|
return;
|
2010-10-01 20:51:14 +08:00
|
|
|
tmp = tg->bps[rw] * throtl_slice * nr_slices;
|
|
|
|
|
do_div(tmp, HZ);
|
|
|
|
|
bytes_trim = tmp;
|
2010-09-16 05:06:35 +08:00
|
|
|
|
2010-09-16 05:06:37 +08:00
|
|
|
io_trim = (tg->iops[rw] * throtl_slice * nr_slices)/HZ;
|
2010-09-16 05:06:35 +08:00
|
|
|
|
2010-09-16 05:06:37 +08:00
|
|
|
if (!bytes_trim && !io_trim)
|
2010-09-16 05:06:35 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (tg->bytes_disp[rw] >= bytes_trim)
|
|
|
|
|
tg->bytes_disp[rw] -= bytes_trim;
|
|
|
|
|
else
|
|
|
|
|
tg->bytes_disp[rw] = 0;
|
|
|
|
|
|
2010-09-16 05:06:37 +08:00
|
|
|
if (tg->io_disp[rw] >= io_trim)
|
|
|
|
|
tg->io_disp[rw] -= io_trim;
|
|
|
|
|
else
|
|
|
|
|
tg->io_disp[rw] = 0;
|
|
|
|
|
|
2010-09-16 05:06:35 +08:00
|
|
|
tg->slice_start[rw] += nr_slices * throtl_slice;
|
|
|
|
|
|
2010-10-01 20:51:14 +08:00
|
|
|
throtl_log_tg(td, tg, "[%c] trim slice nr=%lu bytes=%llu io=%lu"
|
2010-09-16 05:06:35 +08:00
|
|
|
" start=%lu end=%lu jiffies=%lu",
|
2010-09-16 05:06:37 +08:00
|
|
|
rw == READ ? 'R' : 'W', nr_slices, bytes_trim, io_trim,
|
2010-09-16 05:06:35 +08:00
|
|
|
tg->slice_start[rw], tg->slice_end[rw], jiffies);
|
|
|
|
|
}
|
|
|
|
|
|
2010-09-16 05:06:37 +08:00
|
|
|
static bool tg_with_in_iops_limit(struct throtl_data *td, struct throtl_grp *tg,
|
|
|
|
|
struct bio *bio, unsigned long *wait)
|
2010-09-16 05:06:35 +08:00
|
|
|
{
|
|
|
|
|
bool rw = bio_data_dir(bio);
|
2010-09-16 05:06:37 +08:00
|
|
|
unsigned int io_allowed;
|
2010-09-16 05:06:35 +08:00
|
|
|
unsigned long jiffy_elapsed, jiffy_wait, jiffy_elapsed_rnd;
|
2010-10-02 03:16:42 +08:00
|
|
|
u64 tmp;
|
2010-09-16 05:06:35 +08:00
|
|
|
|
2010-09-16 05:06:37 +08:00
|
|
|
jiffy_elapsed = jiffy_elapsed_rnd = jiffies - tg->slice_start[rw];
|
2010-09-16 05:06:35 +08:00
|
|
|
|
2010-09-16 05:06:37 +08:00
|
|
|
/* Slice has just started. Consider one slice interval */
|
|
|
|
|
if (!jiffy_elapsed)
|
|
|
|
|
jiffy_elapsed_rnd = throtl_slice;
|
|
|
|
|
|
|
|
|
|
jiffy_elapsed_rnd = roundup(jiffy_elapsed_rnd, throtl_slice);
|
|
|
|
|
|
2010-10-02 03:16:42 +08:00
|
|
|
/*
|
|
|
|
|
* jiffy_elapsed_rnd should not be a big value as minimum iops can be
|
|
|
|
|
* 1 then at max jiffy elapsed should be equivalent of 1 second as we
|
|
|
|
|
* will allow dispatch after 1 second and after that slice should
|
|
|
|
|
* have been trimmed.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
tmp = (u64)tg->iops[rw] * jiffy_elapsed_rnd;
|
|
|
|
|
do_div(tmp, HZ);
|
|
|
|
|
|
|
|
|
|
if (tmp > UINT_MAX)
|
|
|
|
|
io_allowed = UINT_MAX;
|
|
|
|
|
else
|
|
|
|
|
io_allowed = tmp;
|
2010-09-16 05:06:37 +08:00
|
|
|
|
|
|
|
|
if (tg->io_disp[rw] + 1 <= io_allowed) {
|
2010-09-16 05:06:35 +08:00
|
|
|
if (wait)
|
|
|
|
|
*wait = 0;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2010-09-16 05:06:37 +08:00
|
|
|
/* Calc approx time to dispatch */
|
|
|
|
|
jiffy_wait = ((tg->io_disp[rw] + 1) * HZ)/tg->iops[rw] + 1;
|
|
|
|
|
|
|
|
|
|
if (jiffy_wait > jiffy_elapsed)
|
|
|
|
|
jiffy_wait = jiffy_wait - jiffy_elapsed;
|
|
|
|
|
else
|
|
|
|
|
jiffy_wait = 1;
|
|
|
|
|
|
|
|
|
|
if (wait)
|
|
|
|
|
*wait = jiffy_wait;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static bool tg_with_in_bps_limit(struct throtl_data *td, struct throtl_grp *tg,
|
|
|
|
|
struct bio *bio, unsigned long *wait)
|
|
|
|
|
{
|
|
|
|
|
bool rw = bio_data_dir(bio);
|
2010-10-01 20:51:14 +08:00
|
|
|
u64 bytes_allowed, extra_bytes, tmp;
|
2010-09-16 05:06:37 +08:00
|
|
|
unsigned long jiffy_elapsed, jiffy_wait, jiffy_elapsed_rnd;
|
2010-09-16 05:06:35 +08:00
|
|
|
|
|
|
|
|
jiffy_elapsed = jiffy_elapsed_rnd = jiffies - tg->slice_start[rw];
|
|
|
|
|
|
|
|
|
|
/* Slice has just started. Consider one slice interval */
|
|
|
|
|
if (!jiffy_elapsed)
|
|
|
|
|
jiffy_elapsed_rnd = throtl_slice;
|
|
|
|
|
|
|
|
|
|
jiffy_elapsed_rnd = roundup(jiffy_elapsed_rnd, throtl_slice);
|
|
|
|
|
|
2010-10-02 03:16:38 +08:00
|
|
|
tmp = tg->bps[rw] * jiffy_elapsed_rnd;
|
|
|
|
|
do_div(tmp, HZ);
|
2010-10-01 20:51:14 +08:00
|
|
|
bytes_allowed = tmp;
|
2010-09-16 05:06:35 +08:00
|
|
|
|
|
|
|
|
if (tg->bytes_disp[rw] + bio->bi_size <= bytes_allowed) {
|
|
|
|
|
if (wait)
|
|
|
|
|
*wait = 0;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Calc approx time to dispatch */
|
|
|
|
|
extra_bytes = tg->bytes_disp[rw] + bio->bi_size - bytes_allowed;
|
|
|
|
|
jiffy_wait = div64_u64(extra_bytes * HZ, tg->bps[rw]);
|
|
|
|
|
|
|
|
|
|
if (!jiffy_wait)
|
|
|
|
|
jiffy_wait = 1;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This wait time is without taking into consideration the rounding
|
|
|
|
|
* up we did. Add that time also.
|
|
|
|
|
*/
|
|
|
|
|
jiffy_wait = jiffy_wait + (jiffy_elapsed_rnd - jiffy_elapsed);
|
|
|
|
|
if (wait)
|
|
|
|
|
*wait = jiffy_wait;
|
2010-09-16 05:06:37 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-20 03:38:31 +08:00
|
|
|
static bool tg_no_rule_group(struct throtl_grp *tg, bool rw) {
|
|
|
|
|
if (tg->bps[rw] == -1 && tg->iops[rw] == -1)
|
|
|
|
|
return 1;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2010-09-16 05:06:37 +08:00
|
|
|
/*
|
|
|
|
|
* Returns whether one can dispatch a bio or not. Also returns approx number
|
|
|
|
|
* of jiffies to wait before this bio is with-in IO rate and can be dispatched
|
|
|
|
|
*/
|
|
|
|
|
static bool tg_may_dispatch(struct throtl_data *td, struct throtl_grp *tg,
|
|
|
|
|
struct bio *bio, unsigned long *wait)
|
|
|
|
|
{
|
|
|
|
|
bool rw = bio_data_dir(bio);
|
|
|
|
|
unsigned long bps_wait = 0, iops_wait = 0, max_wait = 0;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Currently whole state machine of group depends on first bio
|
|
|
|
|
* queued in the group bio list. So one should not be calling
|
|
|
|
|
* this function with a different bio if there are other bios
|
|
|
|
|
* queued.
|
|
|
|
|
*/
|
|
|
|
|
BUG_ON(tg->nr_queued[rw] && bio != bio_list_peek(&tg->bio_lists[rw]));
|
2010-09-16 05:06:35 +08:00
|
|
|
|
2010-09-16 05:06:37 +08:00
|
|
|
/* If tg->bps = -1, then BW is unlimited */
|
|
|
|
|
if (tg->bps[rw] == -1 && tg->iops[rw] == -1) {
|
|
|
|
|
if (wait)
|
|
|
|
|
*wait = 0;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If previous slice expired, start a new one otherwise renew/extend
|
|
|
|
|
* existing slice to make sure it is at least throtl_slice interval
|
|
|
|
|
* long since now.
|
|
|
|
|
*/
|
|
|
|
|
if (throtl_slice_used(td, tg, rw))
|
|
|
|
|
throtl_start_new_slice(td, tg, rw);
|
|
|
|
|
else {
|
|
|
|
|
if (time_before(tg->slice_end[rw], jiffies + throtl_slice))
|
|
|
|
|
throtl_extend_slice(td, tg, rw, jiffies + throtl_slice);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (tg_with_in_bps_limit(td, tg, bio, &bps_wait)
|
|
|
|
|
&& tg_with_in_iops_limit(td, tg, bio, &iops_wait)) {
|
|
|
|
|
if (wait)
|
|
|
|
|
*wait = 0;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
max_wait = max(bps_wait, iops_wait);
|
|
|
|
|
|
|
|
|
|
if (wait)
|
|
|
|
|
*wait = max_wait;
|
|
|
|
|
|
|
|
|
|
if (time_before(tg->slice_end[rw], jiffies + max_wait))
|
|
|
|
|
throtl_extend_slice(td, tg, rw, jiffies + max_wait);
|
2010-09-16 05:06:35 +08:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void throtl_charge_bio(struct throtl_grp *tg, struct bio *bio)
|
|
|
|
|
{
|
|
|
|
|
bool rw = bio_data_dir(bio);
|
2011-08-01 16:31:06 +08:00
|
|
|
bool sync = rw_is_sync(bio->bi_rw);
|
2010-09-16 05:06:35 +08:00
|
|
|
|
|
|
|
|
/* Charge the bio to the group */
|
|
|
|
|
tg->bytes_disp[rw] += bio->bi_size;
|
2010-09-16 05:06:37 +08:00
|
|
|
tg->io_disp[rw]++;
|
2010-09-16 05:06:35 +08:00
|
|
|
|
2012-03-06 05:15:17 +08:00
|
|
|
blkiocg_update_dispatch_stats(tg_to_blkg(tg), &blkio_policy_throtl,
|
|
|
|
|
bio->bi_size, rw, sync);
|
2010-09-16 05:06:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void throtl_add_bio_tg(struct throtl_data *td, struct throtl_grp *tg,
|
|
|
|
|
struct bio *bio)
|
|
|
|
|
{
|
|
|
|
|
bool rw = bio_data_dir(bio);
|
|
|
|
|
|
|
|
|
|
bio_list_add(&tg->bio_lists[rw], bio);
|
|
|
|
|
/* Take a bio reference on tg */
|
2012-03-06 05:15:15 +08:00
|
|
|
blkg_get(tg_to_blkg(tg));
|
2010-09-16 05:06:35 +08:00
|
|
|
tg->nr_queued[rw]++;
|
|
|
|
|
td->nr_queued[rw]++;
|
|
|
|
|
throtl_enqueue_tg(td, tg);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void tg_update_disptime(struct throtl_data *td, struct throtl_grp *tg)
|
|
|
|
|
{
|
|
|
|
|
unsigned long read_wait = -1, write_wait = -1, min_wait = -1, disptime;
|
|
|
|
|
struct bio *bio;
|
|
|
|
|
|
|
|
|
|
if ((bio = bio_list_peek(&tg->bio_lists[READ])))
|
|
|
|
|
tg_may_dispatch(td, tg, bio, &read_wait);
|
|
|
|
|
|
|
|
|
|
if ((bio = bio_list_peek(&tg->bio_lists[WRITE])))
|
|
|
|
|
tg_may_dispatch(td, tg, bio, &write_wait);
|
|
|
|
|
|
|
|
|
|
min_wait = min(read_wait, write_wait);
|
|
|
|
|
disptime = jiffies + min_wait;
|
|
|
|
|
|
|
|
|
|
/* Update dispatch time */
|
|
|
|
|
throtl_dequeue_tg(td, tg);
|
|
|
|
|
tg->disptime = disptime;
|
|
|
|
|
throtl_enqueue_tg(td, tg);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void tg_dispatch_one_bio(struct throtl_data *td, struct throtl_grp *tg,
|
|
|
|
|
bool rw, struct bio_list *bl)
|
|
|
|
|
{
|
|
|
|
|
struct bio *bio;
|
|
|
|
|
|
|
|
|
|
bio = bio_list_pop(&tg->bio_lists[rw]);
|
|
|
|
|
tg->nr_queued[rw]--;
|
2012-03-06 05:15:15 +08:00
|
|
|
/* Drop bio reference on blkg */
|
|
|
|
|
blkg_put(tg_to_blkg(tg));
|
2010-09-16 05:06:35 +08:00
|
|
|
|
|
|
|
|
BUG_ON(td->nr_queued[rw] <= 0);
|
|
|
|
|
td->nr_queued[rw]--;
|
|
|
|
|
|
|
|
|
|
throtl_charge_bio(tg, bio);
|
|
|
|
|
bio_list_add(bl, bio);
|
|
|
|
|
bio->bi_rw |= REQ_THROTTLED;
|
|
|
|
|
|
|
|
|
|
throtl_trim_slice(td, tg, rw);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int throtl_dispatch_tg(struct throtl_data *td, struct throtl_grp *tg,
|
|
|
|
|
struct bio_list *bl)
|
|
|
|
|
{
|
|
|
|
|
unsigned int nr_reads = 0, nr_writes = 0;
|
|
|
|
|
unsigned int max_nr_reads = throtl_grp_quantum*3/4;
|
2010-11-16 02:32:42 +08:00
|
|
|
unsigned int max_nr_writes = throtl_grp_quantum - max_nr_reads;
|
2010-09-16 05:06:35 +08:00
|
|
|
struct bio *bio;
|
|
|
|
|
|
|
|
|
|
/* Try to dispatch 75% READS and 25% WRITES */
|
|
|
|
|
|
|
|
|
|
while ((bio = bio_list_peek(&tg->bio_lists[READ]))
|
|
|
|
|
&& tg_may_dispatch(td, tg, bio, NULL)) {
|
|
|
|
|
|
|
|
|
|
tg_dispatch_one_bio(td, tg, bio_data_dir(bio), bl);
|
|
|
|
|
nr_reads++;
|
|
|
|
|
|
|
|
|
|
if (nr_reads >= max_nr_reads)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
while ((bio = bio_list_peek(&tg->bio_lists[WRITE]))
|
|
|
|
|
&& tg_may_dispatch(td, tg, bio, NULL)) {
|
|
|
|
|
|
|
|
|
|
tg_dispatch_one_bio(td, tg, bio_data_dir(bio), bl);
|
|
|
|
|
nr_writes++;
|
|
|
|
|
|
|
|
|
|
if (nr_writes >= max_nr_writes)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return nr_reads + nr_writes;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int throtl_select_dispatch(struct throtl_data *td, struct bio_list *bl)
|
|
|
|
|
{
|
|
|
|
|
unsigned int nr_disp = 0;
|
|
|
|
|
struct throtl_grp *tg;
|
|
|
|
|
struct throtl_rb_root *st = &td->tg_service_tree;
|
|
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
|
tg = throtl_rb_first(st);
|
|
|
|
|
|
|
|
|
|
if (!tg)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
if (time_before(jiffies, tg->disptime))
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
throtl_dequeue_tg(td, tg);
|
|
|
|
|
|
|
|
|
|
nr_disp += throtl_dispatch_tg(td, tg, bl);
|
|
|
|
|
|
|
|
|
|
if (tg->nr_queued[0] || tg->nr_queued[1]) {
|
|
|
|
|
tg_update_disptime(td, tg);
|
|
|
|
|
throtl_enqueue_tg(td, tg);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (nr_disp >= throtl_quantum)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return nr_disp;
|
|
|
|
|
}
|
|
|
|
|
|
2010-10-01 20:49:49 +08:00
|
|
|
static void throtl_process_limit_change(struct throtl_data *td)
|
|
|
|
|
{
|
2012-03-06 05:15:18 +08:00
|
|
|
struct request_queue *q = td->queue;
|
|
|
|
|
struct blkio_group *blkg, *n;
|
2010-10-01 20:49:49 +08:00
|
|
|
|
2011-03-08 04:09:32 +08:00
|
|
|
if (!td->limits_changed)
|
2010-10-01 20:49:49 +08:00
|
|
|
return;
|
|
|
|
|
|
2011-03-08 04:09:32 +08:00
|
|
|
xchg(&td->limits_changed, false);
|
2010-10-01 20:49:49 +08:00
|
|
|
|
2011-03-08 04:09:32 +08:00
|
|
|
throtl_log(td, "limits changed");
|
2010-10-01 20:49:49 +08:00
|
|
|
|
2012-03-06 05:15:18 +08:00
|
|
|
list_for_each_entry_safe(blkg, n, &q->blkg_list[BLKIO_POLICY_THROTL],
|
|
|
|
|
q_node[BLKIO_POLICY_THROTL]) {
|
|
|
|
|
struct throtl_grp *tg = blkg_to_tg(blkg);
|
|
|
|
|
|
2011-03-08 04:09:32 +08:00
|
|
|
if (!tg->limits_changed)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if (!xchg(&tg->limits_changed, false))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
throtl_log_tg(td, tg, "limit change rbps=%llu wbps=%llu"
|
|
|
|
|
" riops=%u wiops=%u", tg->bps[READ], tg->bps[WRITE],
|
|
|
|
|
tg->iops[READ], tg->iops[WRITE]);
|
|
|
|
|
|
2011-03-23 04:54:29 +08:00
|
|
|
/*
|
|
|
|
|
* Restart the slices for both READ and WRITES. It
|
|
|
|
|
* might happen that a group's limit are dropped
|
|
|
|
|
* suddenly and we don't want to account recently
|
|
|
|
|
* dispatched IO with new low rate
|
|
|
|
|
*/
|
|
|
|
|
throtl_start_new_slice(td, tg, 0);
|
|
|
|
|
throtl_start_new_slice(td, tg, 1);
|
|
|
|
|
|
2011-03-08 04:09:32 +08:00
|
|
|
if (throtl_tg_on_rr(tg))
|
2010-10-01 20:49:49 +08:00
|
|
|
tg_update_disptime(td, tg);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2010-09-16 05:06:35 +08:00
|
|
|
/* Dispatch throttled bios. Should be called without queue lock held. */
|
|
|
|
|
static int throtl_dispatch(struct request_queue *q)
|
|
|
|
|
{
|
|
|
|
|
struct throtl_data *td = q->td;
|
|
|
|
|
unsigned int nr_disp = 0;
|
|
|
|
|
struct bio_list bio_list_on_stack;
|
|
|
|
|
struct bio *bio;
|
2011-03-09 15:27:37 +08:00
|
|
|
struct blk_plug plug;
|
2010-09-16 05:06:35 +08:00
|
|
|
|
|
|
|
|
spin_lock_irq(q->queue_lock);
|
|
|
|
|
|
2010-10-01 20:49:49 +08:00
|
|
|
throtl_process_limit_change(td);
|
|
|
|
|
|
2010-09-16 05:06:35 +08:00
|
|
|
if (!total_nr_queued(td))
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
bio_list_init(&bio_list_on_stack);
|
|
|
|
|
|
2011-06-14 02:19:27 +08:00
|
|
|
throtl_log(td, "dispatch nr_queued=%u read=%u write=%u",
|
2010-09-16 05:06:35 +08:00
|
|
|
total_nr_queued(td), td->nr_queued[READ],
|
|
|
|
|
td->nr_queued[WRITE]);
|
|
|
|
|
|
|
|
|
|
nr_disp = throtl_select_dispatch(td, &bio_list_on_stack);
|
|
|
|
|
|
|
|
|
|
if (nr_disp)
|
|
|
|
|
throtl_log(td, "bios disp=%u", nr_disp);
|
|
|
|
|
|
|
|
|
|
throtl_schedule_next_dispatch(td);
|
|
|
|
|
out:
|
|
|
|
|
spin_unlock_irq(q->queue_lock);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If we dispatched some requests, unplug the queue to make sure
|
|
|
|
|
* immediate dispatch
|
|
|
|
|
*/
|
|
|
|
|
if (nr_disp) {
|
2011-03-09 15:27:37 +08:00
|
|
|
blk_start_plug(&plug);
|
2010-09-16 05:06:35 +08:00
|
|
|
while((bio = bio_list_pop(&bio_list_on_stack)))
|
|
|
|
|
generic_make_request(bio);
|
2011-03-09 15:27:37 +08:00
|
|
|
blk_finish_plug(&plug);
|
2010-09-16 05:06:35 +08:00
|
|
|
}
|
|
|
|
|
return nr_disp;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void blk_throtl_work(struct work_struct *work)
|
|
|
|
|
{
|
|
|
|
|
struct throtl_data *td = container_of(work, struct throtl_data,
|
|
|
|
|
throtl_work.work);
|
|
|
|
|
struct request_queue *q = td->queue;
|
|
|
|
|
|
|
|
|
|
throtl_dispatch(q);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Call with queue lock held */
|
2011-03-02 02:40:54 +08:00
|
|
|
static void
|
|
|
|
|
throtl_schedule_delayed_work(struct throtl_data *td, unsigned long delay)
|
2010-09-16 05:06:35 +08:00
|
|
|
{
|
|
|
|
|
|
|
|
|
|
struct delayed_work *dwork = &td->throtl_work;
|
|
|
|
|
|
2011-03-23 04:54:29 +08:00
|
|
|
/* schedule work if limits changed even if no bio is queued */
|
2011-06-14 02:19:27 +08:00
|
|
|
if (total_nr_queued(td) || td->limits_changed) {
|
2010-09-16 05:06:35 +08:00
|
|
|
/*
|
|
|
|
|
* We might have a work scheduled to be executed in future.
|
|
|
|
|
* Cancel that and schedule a new one.
|
|
|
|
|
*/
|
|
|
|
|
__cancel_delayed_work(dwork);
|
2011-03-02 02:40:54 +08:00
|
|
|
queue_delayed_work(kthrotld_workqueue, dwork, delay);
|
2010-09-16 05:06:35 +08:00
|
|
|
throtl_log(td, "schedule work. delay=%lu jiffies=%lu",
|
|
|
|
|
delay, jiffies);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2011-03-08 04:09:32 +08:00
|
|
|
static void throtl_update_blkio_group_common(struct throtl_data *td,
|
|
|
|
|
struct throtl_grp *tg)
|
|
|
|
|
{
|
|
|
|
|
xchg(&tg->limits_changed, true);
|
|
|
|
|
xchg(&td->limits_changed, true);
|
|
|
|
|
/* Schedule a work now to process the limit change */
|
|
|
|
|
throtl_schedule_delayed_work(td, 0);
|
|
|
|
|
}
|
|
|
|
|
|
2010-10-01 20:49:49 +08:00
|
|
|
/*
|
2012-03-06 05:15:03 +08:00
|
|
|
* For all update functions, @q should be a valid pointer because these
|
2010-10-01 20:49:49 +08:00
|
|
|
* update functions are called under blkcg_lock, that means, blkg is
|
2012-03-06 05:15:03 +08:00
|
|
|
* valid and in turn @q is valid. queue exit path can not race because
|
2010-10-01 20:49:49 +08:00
|
|
|
* of blkcg_lock
|
|
|
|
|
*
|
|
|
|
|
* Can not take queue lock in update functions as queue lock under blkcg_lock
|
|
|
|
|
* is not allowed. Under other paths we take blkcg_lock under queue_lock.
|
|
|
|
|
*/
|
2012-03-06 05:15:03 +08:00
|
|
|
static void throtl_update_blkio_group_read_bps(struct request_queue *q,
|
2010-10-01 20:49:49 +08:00
|
|
|
struct blkio_group *blkg, u64 read_bps)
|
2010-09-16 05:06:35 +08:00
|
|
|
{
|
2012-03-06 05:15:14 +08:00
|
|
|
struct throtl_grp *tg = blkg_to_tg(blkg);
|
2010-10-01 20:49:49 +08:00
|
|
|
|
2011-03-08 04:09:32 +08:00
|
|
|
tg->bps[READ] = read_bps;
|
2012-03-06 05:15:03 +08:00
|
|
|
throtl_update_blkio_group_common(q->td, tg);
|
2010-09-16 05:06:35 +08:00
|
|
|
}
|
|
|
|
|
|
2012-03-06 05:15:03 +08:00
|
|
|
static void throtl_update_blkio_group_write_bps(struct request_queue *q,
|
2010-10-01 20:49:49 +08:00
|
|
|
struct blkio_group *blkg, u64 write_bps)
|
2010-09-16 05:06:35 +08:00
|
|
|
{
|
2012-03-06 05:15:14 +08:00
|
|
|
struct throtl_grp *tg = blkg_to_tg(blkg);
|
2010-10-01 20:49:49 +08:00
|
|
|
|
2011-03-08 04:09:32 +08:00
|
|
|
tg->bps[WRITE] = write_bps;
|
2012-03-06 05:15:03 +08:00
|
|
|
throtl_update_blkio_group_common(q->td, tg);
|
2010-09-16 05:06:35 +08:00
|
|
|
}
|
|
|
|
|
|
2012-03-06 05:15:03 +08:00
|
|
|
static void throtl_update_blkio_group_read_iops(struct request_queue *q,
|
2010-10-01 20:49:49 +08:00
|
|
|
struct blkio_group *blkg, unsigned int read_iops)
|
2010-09-16 05:06:37 +08:00
|
|
|
{
|
2012-03-06 05:15:14 +08:00
|
|
|
struct throtl_grp *tg = blkg_to_tg(blkg);
|
2010-10-01 20:49:49 +08:00
|
|
|
|
2011-03-08 04:09:32 +08:00
|
|
|
tg->iops[READ] = read_iops;
|
2012-03-06 05:15:03 +08:00
|
|
|
throtl_update_blkio_group_common(q->td, tg);
|
2010-09-16 05:06:37 +08:00
|
|
|
}
|
|
|
|
|
|
2012-03-06 05:15:03 +08:00
|
|
|
static void throtl_update_blkio_group_write_iops(struct request_queue *q,
|
2010-10-01 20:49:49 +08:00
|
|
|
struct blkio_group *blkg, unsigned int write_iops)
|
2010-09-16 05:06:37 +08:00
|
|
|
{
|
2012-03-06 05:15:14 +08:00
|
|
|
struct throtl_grp *tg = blkg_to_tg(blkg);
|
2010-10-01 20:49:49 +08:00
|
|
|
|
2011-03-08 04:09:32 +08:00
|
|
|
tg->iops[WRITE] = write_iops;
|
2012-03-06 05:15:03 +08:00
|
|
|
throtl_update_blkio_group_common(q->td, tg);
|
2010-09-16 05:06:37 +08:00
|
|
|
}
|
|
|
|
|
|
2011-03-03 08:05:33 +08:00
|
|
|
static void throtl_shutdown_wq(struct request_queue *q)
|
2010-09-16 05:06:35 +08:00
|
|
|
{
|
|
|
|
|
struct throtl_data *td = q->td;
|
|
|
|
|
|
|
|
|
|
cancel_delayed_work_sync(&td->throtl_work);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct blkio_policy_type blkio_policy_throtl = {
|
|
|
|
|
.ops = {
|
2012-03-06 05:15:14 +08:00
|
|
|
.blkio_init_group_fn = throtl_init_blkio_group,
|
2010-09-16 05:06:35 +08:00
|
|
|
.blkio_update_group_read_bps_fn =
|
|
|
|
|
throtl_update_blkio_group_read_bps,
|
|
|
|
|
.blkio_update_group_write_bps_fn =
|
|
|
|
|
throtl_update_blkio_group_write_bps,
|
2010-09-16 05:06:37 +08:00
|
|
|
.blkio_update_group_read_iops_fn =
|
|
|
|
|
throtl_update_blkio_group_read_iops,
|
|
|
|
|
.blkio_update_group_write_iops_fn =
|
|
|
|
|
throtl_update_blkio_group_write_iops,
|
2010-09-16 05:06:35 +08:00
|
|
|
},
|
2010-09-16 05:06:37 +08:00
|
|
|
.plid = BLKIO_POLICY_THROTL,
|
2012-03-06 05:15:14 +08:00
|
|
|
.pdata_size = sizeof(struct throtl_grp),
|
2010-09-16 05:06:35 +08:00
|
|
|
};
|
|
|
|
|
|
2011-10-19 20:33:01 +08:00
|
|
|
bool blk_throtl_bio(struct request_queue *q, struct bio *bio)
|
2010-09-16 05:06:35 +08:00
|
|
|
{
|
|
|
|
|
struct throtl_data *td = q->td;
|
|
|
|
|
struct throtl_grp *tg;
|
|
|
|
|
bool rw = bio_data_dir(bio), update_disptime = true;
|
2011-05-20 03:38:31 +08:00
|
|
|
struct blkio_cgroup *blkcg;
|
2011-10-19 20:33:01 +08:00
|
|
|
bool throttled = false;
|
2010-09-16 05:06:35 +08:00
|
|
|
|
|
|
|
|
if (bio->bi_rw & REQ_THROTTLED) {
|
|
|
|
|
bio->bi_rw &= ~REQ_THROTTLED;
|
2011-10-19 20:33:01 +08:00
|
|
|
goto out;
|
2010-09-16 05:06:35 +08:00
|
|
|
}
|
|
|
|
|
|
2011-05-20 03:38:31 +08:00
|
|
|
/*
|
|
|
|
|
* A throtl_grp pointer retrieved under rcu can be used to access
|
|
|
|
|
* basic fields like stats and io rates. If a group has no rules,
|
|
|
|
|
* just update the dispatch stats in lockless manner and return.
|
|
|
|
|
*/
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
blkcg = task_blkio_cgroup(current);
|
2012-03-06 05:15:06 +08:00
|
|
|
tg = throtl_lookup_tg(td, blkcg);
|
2011-05-20 03:38:31 +08:00
|
|
|
if (tg) {
|
|
|
|
|
if (tg_no_rule_group(tg, rw)) {
|
2012-03-06 05:15:14 +08:00
|
|
|
blkiocg_update_dispatch_stats(tg_to_blkg(tg),
|
2012-03-06 05:15:17 +08:00
|
|
|
&blkio_policy_throtl,
|
2012-03-06 05:15:14 +08:00
|
|
|
bio->bi_size, rw,
|
|
|
|
|
rw_is_sync(bio->bi_rw));
|
2012-03-06 05:15:01 +08:00
|
|
|
goto out_unlock_rcu;
|
2011-05-20 03:38:31 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Either group has not been allocated yet or it is not an unlimited
|
|
|
|
|
* IO group
|
|
|
|
|
*/
|
2010-09-16 05:06:35 +08:00
|
|
|
spin_lock_irq(q->queue_lock);
|
2012-03-06 05:15:06 +08:00
|
|
|
tg = throtl_lookup_create_tg(td, blkcg);
|
2011-10-19 20:33:01 +08:00
|
|
|
if (unlikely(!tg))
|
|
|
|
|
goto out_unlock;
|
2011-05-20 03:38:23 +08:00
|
|
|
|
2010-09-16 05:06:35 +08:00
|
|
|
if (tg->nr_queued[rw]) {
|
|
|
|
|
/*
|
|
|
|
|
* There is already another bio queued in same dir. No
|
|
|
|
|
* need to update dispatch time.
|
|
|
|
|
*/
|
2011-03-08 04:05:14 +08:00
|
|
|
update_disptime = false;
|
2010-09-16 05:06:35 +08:00
|
|
|
goto queue_bio;
|
2011-03-08 04:09:32 +08:00
|
|
|
|
2010-09-16 05:06:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Bio is with-in rate limit of group */
|
|
|
|
|
if (tg_may_dispatch(td, tg, bio, NULL)) {
|
|
|
|
|
throtl_charge_bio(tg, bio);
|
2011-03-23 04:54:29 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We need to trim slice even when bios are not being queued
|
|
|
|
|
* otherwise it might happen that a bio is not queued for
|
|
|
|
|
* a long time and slice keeps on extending and trim is not
|
|
|
|
|
* called for a long time. Now if limits are reduced suddenly
|
|
|
|
|
* we take into account all the IO dispatched so far at new
|
|
|
|
|
* low rate and * newly queued IO gets a really long dispatch
|
|
|
|
|
* time.
|
|
|
|
|
*
|
|
|
|
|
* So keep on trimming slice even if bio is not queued.
|
|
|
|
|
*/
|
|
|
|
|
throtl_trim_slice(td, tg, rw);
|
2011-10-19 20:33:01 +08:00
|
|
|
goto out_unlock;
|
2010-09-16 05:06:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
queue_bio:
|
2011-06-13 16:42:49 +08:00
|
|
|
throtl_log_tg(td, tg, "[%c] bio. bdisp=%llu sz=%u bps=%llu"
|
2010-09-16 05:06:37 +08:00
|
|
|
" iodisp=%u iops=%u queued=%d/%d",
|
|
|
|
|
rw == READ ? 'R' : 'W',
|
2010-09-16 05:06:35 +08:00
|
|
|
tg->bytes_disp[rw], bio->bi_size, tg->bps[rw],
|
2010-09-16 05:06:37 +08:00
|
|
|
tg->io_disp[rw], tg->iops[rw],
|
2010-09-16 05:06:35 +08:00
|
|
|
tg->nr_queued[READ], tg->nr_queued[WRITE]);
|
|
|
|
|
|
|
|
|
|
throtl_add_bio_tg(q->td, tg, bio);
|
2011-10-19 20:33:01 +08:00
|
|
|
throttled = true;
|
2010-09-16 05:06:35 +08:00
|
|
|
|
|
|
|
|
if (update_disptime) {
|
|
|
|
|
tg_update_disptime(td, tg);
|
|
|
|
|
throtl_schedule_next_dispatch(td);
|
|
|
|
|
}
|
|
|
|
|
|
2011-10-19 20:33:01 +08:00
|
|
|
out_unlock:
|
2010-09-16 05:06:35 +08:00
|
|
|
spin_unlock_irq(q->queue_lock);
|
2012-03-06 05:15:01 +08:00
|
|
|
out_unlock_rcu:
|
|
|
|
|
rcu_read_unlock();
|
2011-10-19 20:33:01 +08:00
|
|
|
out:
|
|
|
|
|
return throttled;
|
2010-09-16 05:06:35 +08:00
|
|
|
}
|
|
|
|
|
|
block: fix request_queue lifetime handling by making blk_queue_cleanup() properly shutdown
request_queue is refcounted but actually depdends on lifetime
management from the queue owner - on blk_cleanup_queue(), block layer
expects that there's no request passing through request_queue and no
new one will.
This is fundamentally broken. The queue owner (e.g. SCSI layer)
doesn't have a way to know whether there are other active users before
calling blk_cleanup_queue() and other users (e.g. bsg) don't have any
guarantee that the queue is and would stay valid while it's holding a
reference.
With delay added in blk_queue_bio() before queue_lock is grabbed, the
following oops can be easily triggered when a device is removed with
in-flight IOs.
sd 0:0:1:0: [sdb] Stopping disk
ata1.01: disabled
general protection fault: 0000 [#1] PREEMPT SMP
CPU 2
Modules linked in:
Pid: 648, comm: test_rawio Not tainted 3.1.0-rc3-work+ #56 Bochs Bochs
RIP: 0010:[<ffffffff8137d651>] [<ffffffff8137d651>] elv_rqhash_find+0x61/0x100
...
Process test_rawio (pid: 648, threadinfo ffff880019efa000, task ffff880019ef8a80)
...
Call Trace:
[<ffffffff8137d774>] elv_merge+0x84/0xe0
[<ffffffff81385b54>] blk_queue_bio+0xf4/0x400
[<ffffffff813838ea>] generic_make_request+0xca/0x100
[<ffffffff81383994>] submit_bio+0x74/0x100
[<ffffffff811c53ec>] dio_bio_submit+0xbc/0xc0
[<ffffffff811c610e>] __blockdev_direct_IO+0x92e/0xb40
[<ffffffff811c39f7>] blkdev_direct_IO+0x57/0x60
[<ffffffff8113b1c5>] generic_file_aio_read+0x6d5/0x760
[<ffffffff8118c1ca>] do_sync_read+0xda/0x120
[<ffffffff8118ce55>] vfs_read+0xc5/0x180
[<ffffffff8118cfaa>] sys_pread64+0x9a/0xb0
[<ffffffff81afaf6b>] system_call_fastpath+0x16/0x1b
This happens because blk_queue_cleanup() destroys the queue and
elevator whether IOs are in progress or not and DEAD tests are
sprinkled in the request processing path without proper
synchronization.
Similar problem exists for blk-throtl. On queue cleanup, blk-throtl
is shutdown whether it has requests in it or not. Depending on
timing, it either oopses or throttled bios are lost putting tasks
which are waiting for bio completion into eternal D state.
The way it should work is having the usual clear distinction between
shutdown and release. Shutdown drains all currently pending requests,
marks the queue dead, and performs partial teardown of the now
unnecessary part of the queue. Even after shutdown is complete,
reference holders are still allowed to issue requests to the queue
although they will be immmediately failed. The rest of teardown
happens on release.
This patch makes the following changes to make blk_queue_cleanup()
behave as proper shutdown.
* QUEUE_FLAG_DEAD is now set while holding both q->exit_mutex and
queue_lock.
* Unsynchronized DEAD check in generic_make_request_checks() removed.
This couldn't make any meaningful difference as the queue could die
after the check.
* blk_drain_queue() updated such that it can drain all requests and is
now called during cleanup.
* blk_throtl updated such that it checks DEAD on grabbing queue_lock,
drains all throttled bios during cleanup and free td when queue is
released.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Vivek Goyal <vgoyal@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2011-10-19 20:42:16 +08:00
|
|
|
/**
|
|
|
|
|
* blk_throtl_drain - drain throttled bios
|
|
|
|
|
* @q: request_queue to drain throttled bios for
|
|
|
|
|
*
|
|
|
|
|
* Dispatch all currently throttled bios on @q through ->make_request_fn().
|
|
|
|
|
*/
|
|
|
|
|
void blk_throtl_drain(struct request_queue *q)
|
|
|
|
|
__releases(q->queue_lock) __acquires(q->queue_lock)
|
|
|
|
|
{
|
|
|
|
|
struct throtl_data *td = q->td;
|
|
|
|
|
struct throtl_rb_root *st = &td->tg_service_tree;
|
|
|
|
|
struct throtl_grp *tg;
|
|
|
|
|
struct bio_list bl;
|
|
|
|
|
struct bio *bio;
|
|
|
|
|
|
2011-10-25 21:51:48 +08:00
|
|
|
WARN_ON_ONCE(!queue_is_locked(q));
|
block: fix request_queue lifetime handling by making blk_queue_cleanup() properly shutdown
request_queue is refcounted but actually depdends on lifetime
management from the queue owner - on blk_cleanup_queue(), block layer
expects that there's no request passing through request_queue and no
new one will.
This is fundamentally broken. The queue owner (e.g. SCSI layer)
doesn't have a way to know whether there are other active users before
calling blk_cleanup_queue() and other users (e.g. bsg) don't have any
guarantee that the queue is and would stay valid while it's holding a
reference.
With delay added in blk_queue_bio() before queue_lock is grabbed, the
following oops can be easily triggered when a device is removed with
in-flight IOs.
sd 0:0:1:0: [sdb] Stopping disk
ata1.01: disabled
general protection fault: 0000 [#1] PREEMPT SMP
CPU 2
Modules linked in:
Pid: 648, comm: test_rawio Not tainted 3.1.0-rc3-work+ #56 Bochs Bochs
RIP: 0010:[<ffffffff8137d651>] [<ffffffff8137d651>] elv_rqhash_find+0x61/0x100
...
Process test_rawio (pid: 648, threadinfo ffff880019efa000, task ffff880019ef8a80)
...
Call Trace:
[<ffffffff8137d774>] elv_merge+0x84/0xe0
[<ffffffff81385b54>] blk_queue_bio+0xf4/0x400
[<ffffffff813838ea>] generic_make_request+0xca/0x100
[<ffffffff81383994>] submit_bio+0x74/0x100
[<ffffffff811c53ec>] dio_bio_submit+0xbc/0xc0
[<ffffffff811c610e>] __blockdev_direct_IO+0x92e/0xb40
[<ffffffff811c39f7>] blkdev_direct_IO+0x57/0x60
[<ffffffff8113b1c5>] generic_file_aio_read+0x6d5/0x760
[<ffffffff8118c1ca>] do_sync_read+0xda/0x120
[<ffffffff8118ce55>] vfs_read+0xc5/0x180
[<ffffffff8118cfaa>] sys_pread64+0x9a/0xb0
[<ffffffff81afaf6b>] system_call_fastpath+0x16/0x1b
This happens because blk_queue_cleanup() destroys the queue and
elevator whether IOs are in progress or not and DEAD tests are
sprinkled in the request processing path without proper
synchronization.
Similar problem exists for blk-throtl. On queue cleanup, blk-throtl
is shutdown whether it has requests in it or not. Depending on
timing, it either oopses or throttled bios are lost putting tasks
which are waiting for bio completion into eternal D state.
The way it should work is having the usual clear distinction between
shutdown and release. Shutdown drains all currently pending requests,
marks the queue dead, and performs partial teardown of the now
unnecessary part of the queue. Even after shutdown is complete,
reference holders are still allowed to issue requests to the queue
although they will be immmediately failed. The rest of teardown
happens on release.
This patch makes the following changes to make blk_queue_cleanup()
behave as proper shutdown.
* QUEUE_FLAG_DEAD is now set while holding both q->exit_mutex and
queue_lock.
* Unsynchronized DEAD check in generic_make_request_checks() removed.
This couldn't make any meaningful difference as the queue could die
after the check.
* blk_drain_queue() updated such that it can drain all requests and is
now called during cleanup.
* blk_throtl updated such that it checks DEAD on grabbing queue_lock,
drains all throttled bios during cleanup and free td when queue is
released.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Vivek Goyal <vgoyal@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2011-10-19 20:42:16 +08:00
|
|
|
|
|
|
|
|
bio_list_init(&bl);
|
|
|
|
|
|
|
|
|
|
while ((tg = throtl_rb_first(st))) {
|
|
|
|
|
throtl_dequeue_tg(td, tg);
|
|
|
|
|
|
|
|
|
|
while ((bio = bio_list_peek(&tg->bio_lists[READ])))
|
|
|
|
|
tg_dispatch_one_bio(td, tg, bio_data_dir(bio), &bl);
|
|
|
|
|
while ((bio = bio_list_peek(&tg->bio_lists[WRITE])))
|
|
|
|
|
tg_dispatch_one_bio(td, tg, bio_data_dir(bio), &bl);
|
|
|
|
|
}
|
|
|
|
|
spin_unlock_irq(q->queue_lock);
|
|
|
|
|
|
|
|
|
|
while ((bio = bio_list_pop(&bl)))
|
|
|
|
|
generic_make_request(bio);
|
|
|
|
|
|
|
|
|
|
spin_lock_irq(q->queue_lock);
|
|
|
|
|
}
|
|
|
|
|
|
2010-09-16 05:06:35 +08:00
|
|
|
int blk_throtl_init(struct request_queue *q)
|
|
|
|
|
{
|
|
|
|
|
struct throtl_data *td;
|
2012-03-06 05:15:06 +08:00
|
|
|
struct blkio_group *blkg;
|
2010-09-16 05:06:35 +08:00
|
|
|
|
|
|
|
|
td = kzalloc_node(sizeof(*td), GFP_KERNEL, q->node);
|
|
|
|
|
if (!td)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
td->tg_service_tree = THROTL_RB_ROOT;
|
2011-03-08 04:09:32 +08:00
|
|
|
td->limits_changed = false;
|
2011-05-20 03:38:19 +08:00
|
|
|
INIT_DELAYED_WORK(&td->throtl_work, blk_throtl_work);
|
2010-09-16 05:06:35 +08:00
|
|
|
|
2012-03-06 05:15:06 +08:00
|
|
|
q->td = td;
|
2011-05-20 03:38:24 +08:00
|
|
|
td->queue = q;
|
2010-10-01 20:49:48 +08:00
|
|
|
|
2012-03-06 05:15:06 +08:00
|
|
|
/* alloc and init root group. */
|
2012-03-06 05:15:05 +08:00
|
|
|
rcu_read_lock();
|
|
|
|
|
spin_lock_irq(q->queue_lock);
|
2011-05-20 03:38:24 +08:00
|
|
|
|
2012-03-06 05:15:06 +08:00
|
|
|
blkg = blkg_lookup_create(&blkio_root_cgroup, q, BLKIO_POLICY_THROTL,
|
|
|
|
|
true);
|
|
|
|
|
if (!IS_ERR(blkg))
|
2012-03-06 05:15:14 +08:00
|
|
|
td->root_tg = blkg_to_tg(blkg);
|
2010-09-16 05:06:35 +08:00
|
|
|
|
2012-03-06 05:15:05 +08:00
|
|
|
spin_unlock_irq(q->queue_lock);
|
2010-09-16 05:06:35 +08:00
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
2012-03-06 05:15:05 +08:00
|
|
|
if (!td->root_tg) {
|
|
|
|
|
kfree(td);
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
}
|
2010-09-16 05:06:35 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void blk_throtl_exit(struct request_queue *q)
|
|
|
|
|
{
|
|
|
|
|
struct throtl_data *td = q->td;
|
2012-03-06 05:15:18 +08:00
|
|
|
bool wait;
|
2010-09-16 05:06:35 +08:00
|
|
|
|
|
|
|
|
BUG_ON(!td);
|
|
|
|
|
|
2011-03-03 08:05:33 +08:00
|
|
|
throtl_shutdown_wq(q);
|
2010-09-16 05:06:35 +08:00
|
|
|
|
2012-03-06 05:15:19 +08:00
|
|
|
blkg_destroy_all(q, BLKIO_POLICY_THROTL, true);
|
2010-09-16 05:06:35 +08:00
|
|
|
|
|
|
|
|
/* If there are other groups */
|
2012-03-06 05:15:19 +08:00
|
|
|
spin_lock_irq(q->queue_lock);
|
2012-03-06 05:15:18 +08:00
|
|
|
wait = q->nr_blkgs[BLKIO_POLICY_THROTL];
|
2010-09-16 05:06:35 +08:00
|
|
|
spin_unlock_irq(q->queue_lock);
|
|
|
|
|
|
|
|
|
|
/*
|
2012-03-06 05:15:14 +08:00
|
|
|
* Wait for tg_to_blkg(tg)->q accessors to exit their grace periods.
|
2010-09-16 05:06:35 +08:00
|
|
|
* Do this wait only if there are other undestroyed groups out
|
|
|
|
|
* there (other than root group). This can happen if cgroup deletion
|
|
|
|
|
* path claimed the responsibility of cleaning up a group before
|
|
|
|
|
* queue cleanup code get to the group.
|
|
|
|
|
*
|
|
|
|
|
* Do not call synchronize_rcu() unconditionally as there are drivers
|
|
|
|
|
* which create/delete request queue hundreds of times during scan/boot
|
|
|
|
|
* and synchronize_rcu() can take significant time and slow down boot.
|
|
|
|
|
*/
|
|
|
|
|
if (wait)
|
|
|
|
|
synchronize_rcu();
|
2010-10-01 20:49:49 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Just being safe to make sure after previous flush if some body did
|
|
|
|
|
* update limits through cgroup and another work got queued, cancel
|
|
|
|
|
* it.
|
|
|
|
|
*/
|
2011-03-03 08:05:33 +08:00
|
|
|
throtl_shutdown_wq(q);
|
block: fix request_queue lifetime handling by making blk_queue_cleanup() properly shutdown
request_queue is refcounted but actually depdends on lifetime
management from the queue owner - on blk_cleanup_queue(), block layer
expects that there's no request passing through request_queue and no
new one will.
This is fundamentally broken. The queue owner (e.g. SCSI layer)
doesn't have a way to know whether there are other active users before
calling blk_cleanup_queue() and other users (e.g. bsg) don't have any
guarantee that the queue is and would stay valid while it's holding a
reference.
With delay added in blk_queue_bio() before queue_lock is grabbed, the
following oops can be easily triggered when a device is removed with
in-flight IOs.
sd 0:0:1:0: [sdb] Stopping disk
ata1.01: disabled
general protection fault: 0000 [#1] PREEMPT SMP
CPU 2
Modules linked in:
Pid: 648, comm: test_rawio Not tainted 3.1.0-rc3-work+ #56 Bochs Bochs
RIP: 0010:[<ffffffff8137d651>] [<ffffffff8137d651>] elv_rqhash_find+0x61/0x100
...
Process test_rawio (pid: 648, threadinfo ffff880019efa000, task ffff880019ef8a80)
...
Call Trace:
[<ffffffff8137d774>] elv_merge+0x84/0xe0
[<ffffffff81385b54>] blk_queue_bio+0xf4/0x400
[<ffffffff813838ea>] generic_make_request+0xca/0x100
[<ffffffff81383994>] submit_bio+0x74/0x100
[<ffffffff811c53ec>] dio_bio_submit+0xbc/0xc0
[<ffffffff811c610e>] __blockdev_direct_IO+0x92e/0xb40
[<ffffffff811c39f7>] blkdev_direct_IO+0x57/0x60
[<ffffffff8113b1c5>] generic_file_aio_read+0x6d5/0x760
[<ffffffff8118c1ca>] do_sync_read+0xda/0x120
[<ffffffff8118ce55>] vfs_read+0xc5/0x180
[<ffffffff8118cfaa>] sys_pread64+0x9a/0xb0
[<ffffffff81afaf6b>] system_call_fastpath+0x16/0x1b
This happens because blk_queue_cleanup() destroys the queue and
elevator whether IOs are in progress or not and DEAD tests are
sprinkled in the request processing path without proper
synchronization.
Similar problem exists for blk-throtl. On queue cleanup, blk-throtl
is shutdown whether it has requests in it or not. Depending on
timing, it either oopses or throttled bios are lost putting tasks
which are waiting for bio completion into eternal D state.
The way it should work is having the usual clear distinction between
shutdown and release. Shutdown drains all currently pending requests,
marks the queue dead, and performs partial teardown of the now
unnecessary part of the queue. Even after shutdown is complete,
reference holders are still allowed to issue requests to the queue
although they will be immmediately failed. The rest of teardown
happens on release.
This patch makes the following changes to make blk_queue_cleanup()
behave as proper shutdown.
* QUEUE_FLAG_DEAD is now set while holding both q->exit_mutex and
queue_lock.
* Unsynchronized DEAD check in generic_make_request_checks() removed.
This couldn't make any meaningful difference as the queue could die
after the check.
* blk_drain_queue() updated such that it can drain all requests and is
now called during cleanup.
* blk_throtl updated such that it checks DEAD on grabbing queue_lock,
drains all throttled bios during cleanup and free td when queue is
released.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Vivek Goyal <vgoyal@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2011-10-19 20:42:16 +08:00
|
|
|
|
|
|
|
|
kfree(q->td);
|
2010-09-16 05:06:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int __init throtl_init(void)
|
|
|
|
|
{
|
2011-03-02 02:40:54 +08:00
|
|
|
kthrotld_workqueue = alloc_workqueue("kthrotld", WQ_MEM_RECLAIM, 0);
|
|
|
|
|
if (!kthrotld_workqueue)
|
|
|
|
|
panic("Failed to create kthrotld\n");
|
|
|
|
|
|
2010-09-16 05:06:35 +08:00
|
|
|
blkio_policy_register(&blkio_policy_throtl);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
module_init(throtl_init);
|
