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-04-17 04:57:25 +08:00
|
|
|
static struct blkcg_policy blkcg_policy_throtl;
|
2012-03-06 05:15:14 +08:00
|
|
|
|
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)
|
|
|
|
|
|
2012-04-02 05:38:44 +08:00
|
|
|
/* Per-cpu group stats */
|
|
|
|
|
struct tg_stats_cpu {
|
|
|
|
|
/* total bytes transferred */
|
|
|
|
|
struct blkg_rwstat service_bytes;
|
|
|
|
|
/* total IOs serviced, post merge */
|
|
|
|
|
struct blkg_rwstat serviced;
|
|
|
|
|
};
|
|
|
|
|
|
2010-09-16 05:06:35 +08:00
|
|
|
struct throtl_grp {
|
2012-04-17 04:57:26 +08:00
|
|
|
/* must be the first member */
|
|
|
|
|
struct blkg_policy_data pd;
|
|
|
|
|
|
2010-09-16 05:06:35 +08:00
|
|
|
/* 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;
|
2012-04-02 05:38:44 +08:00
|
|
|
|
|
|
|
|
/* Per cpu stats pointer */
|
|
|
|
|
struct tg_stats_cpu __percpu *stats_cpu;
|
|
|
|
|
|
|
|
|
|
/* List of tgs waiting for per cpu stats memory to be allocated */
|
|
|
|
|
struct list_head stats_alloc_node;
|
2010-09-16 05:06:35 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct throtl_data
|
|
|
|
|
{
|
|
|
|
|
/* service tree for active throtl groups */
|
|
|
|
|
struct throtl_rb_root tg_service_tree;
|
|
|
|
|
|
|
|
|
|
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-04-02 05:38:44 +08:00
|
|
|
/* list and work item to allocate percpu group stats */
|
|
|
|
|
static DEFINE_SPINLOCK(tg_stats_alloc_lock);
|
|
|
|
|
static LIST_HEAD(tg_stats_alloc_list);
|
|
|
|
|
|
|
|
|
|
static void tg_stats_alloc_fn(struct work_struct *);
|
|
|
|
|
static DECLARE_DELAYED_WORK(tg_stats_alloc_work, tg_stats_alloc_fn);
|
|
|
|
|
|
2012-04-17 04:57:26 +08:00
|
|
|
static inline struct throtl_grp *pd_to_tg(struct blkg_policy_data *pd)
|
|
|
|
|
{
|
|
|
|
|
return pd ? container_of(pd, struct throtl_grp, pd) : NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-17 04:57:25 +08:00
|
|
|
static inline struct throtl_grp *blkg_to_tg(struct blkcg_gq *blkg)
|
2012-03-06 05:15:14 +08:00
|
|
|
{
|
2012-04-17 04:57:26 +08:00
|
|
|
return pd_to_tg(blkg_to_pd(blkg, &blkcg_policy_throtl));
|
2012-03-06 05:15:14 +08:00
|
|
|
}
|
|
|
|
|
|
2012-04-17 04:57:25 +08:00
|
|
|
static inline struct blkcg_gq *tg_to_blkg(struct throtl_grp *tg)
|
2012-03-06 05:15:14 +08:00
|
|
|
{
|
2012-04-17 04:57:26 +08:00
|
|
|
return pd_to_blkg(&tg->pd);
|
2012-03-06 05:15:14 +08:00
|
|
|
}
|
|
|
|
|
|
2012-04-14 04:11:32 +08:00
|
|
|
static inline struct throtl_grp *td_root_tg(struct throtl_data *td)
|
|
|
|
|
{
|
|
|
|
|
return blkg_to_tg(td->queue->root_blkg);
|
|
|
|
|
}
|
|
|
|
|
|
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);
|
|
|
|
|
|
2012-04-17 04:57:23 +08:00
|
|
|
#define throtl_log_tg(td, tg, fmt, args...) do { \
|
|
|
|
|
char __pbuf[128]; \
|
|
|
|
|
\
|
|
|
|
|
blkg_path(tg_to_blkg(tg), __pbuf, sizeof(__pbuf)); \
|
|
|
|
|
blk_add_trace_msg((td)->queue, "throtl %s " fmt, __pbuf, ##args); \
|
|
|
|
|
} while (0)
|
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-04-02 05:38:44 +08:00
|
|
|
/*
|
|
|
|
|
* Worker for allocating per cpu stat for tgs. This is scheduled on the
|
|
|
|
|
* system_nrt_wq once there are some groups on the alloc_list waiting for
|
|
|
|
|
* allocation.
|
|
|
|
|
*/
|
|
|
|
|
static void tg_stats_alloc_fn(struct work_struct *work)
|
|
|
|
|
{
|
|
|
|
|
static struct tg_stats_cpu *stats_cpu; /* this fn is non-reentrant */
|
|
|
|
|
struct delayed_work *dwork = to_delayed_work(work);
|
|
|
|
|
bool empty = false;
|
|
|
|
|
|
|
|
|
|
alloc_stats:
|
|
|
|
|
if (!stats_cpu) {
|
|
|
|
|
stats_cpu = alloc_percpu(struct tg_stats_cpu);
|
|
|
|
|
if (!stats_cpu) {
|
|
|
|
|
/* allocation failed, try again after some time */
|
|
|
|
|
queue_delayed_work(system_nrt_wq, dwork,
|
|
|
|
|
msecs_to_jiffies(10));
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
spin_lock_irq(&tg_stats_alloc_lock);
|
|
|
|
|
|
|
|
|
|
if (!list_empty(&tg_stats_alloc_list)) {
|
|
|
|
|
struct throtl_grp *tg = list_first_entry(&tg_stats_alloc_list,
|
|
|
|
|
struct throtl_grp,
|
|
|
|
|
stats_alloc_node);
|
|
|
|
|
swap(tg->stats_cpu, stats_cpu);
|
|
|
|
|
list_del_init(&tg->stats_alloc_node);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
empty = list_empty(&tg_stats_alloc_list);
|
|
|
|
|
spin_unlock_irq(&tg_stats_alloc_lock);
|
|
|
|
|
if (!empty)
|
|
|
|
|
goto alloc_stats;
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-17 04:57:25 +08:00
|
|
|
static void throtl_pd_init(struct blkcg_gq *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-05-23 18:16:21 +08:00
|
|
|
unsigned long flags;
|
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;
|
2012-04-02 05:38:44 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Ugh... We need to perform per-cpu allocation for tg->stats_cpu
|
|
|
|
|
* but percpu allocator can't be called from IO path. Queue tg on
|
|
|
|
|
* tg_stats_alloc_list and allocate from work item.
|
|
|
|
|
*/
|
2012-05-23 18:16:21 +08:00
|
|
|
spin_lock_irqsave(&tg_stats_alloc_lock, flags);
|
2012-04-02 05:38:44 +08:00
|
|
|
list_add(&tg->stats_alloc_node, &tg_stats_alloc_list);
|
|
|
|
|
queue_delayed_work(system_nrt_wq, &tg_stats_alloc_work, 0);
|
2012-05-23 18:16:21 +08:00
|
|
|
spin_unlock_irqrestore(&tg_stats_alloc_lock, flags);
|
2012-04-02 05:38:44 +08:00
|
|
|
}
|
|
|
|
|
|
2012-04-17 04:57:25 +08:00
|
|
|
static void throtl_pd_exit(struct blkcg_gq *blkg)
|
2012-04-02 05:38:44 +08:00
|
|
|
{
|
|
|
|
|
struct throtl_grp *tg = blkg_to_tg(blkg);
|
2012-05-23 18:16:21 +08:00
|
|
|
unsigned long flags;
|
2012-04-02 05:38:44 +08:00
|
|
|
|
2012-05-23 18:16:21 +08:00
|
|
|
spin_lock_irqsave(&tg_stats_alloc_lock, flags);
|
2012-04-02 05:38:44 +08:00
|
|
|
list_del_init(&tg->stats_alloc_node);
|
2012-05-23 18:16:21 +08:00
|
|
|
spin_unlock_irqrestore(&tg_stats_alloc_lock, flags);
|
2012-04-02 05:38:44 +08:00
|
|
|
|
|
|
|
|
free_percpu(tg->stats_cpu);
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-17 04:57:25 +08:00
|
|
|
static void throtl_pd_reset_stats(struct blkcg_gq *blkg)
|
2012-04-02 05:38:44 +08:00
|
|
|
{
|
|
|
|
|
struct throtl_grp *tg = blkg_to_tg(blkg);
|
|
|
|
|
int cpu;
|
|
|
|
|
|
|
|
|
|
if (tg->stats_cpu == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
for_each_possible_cpu(cpu) {
|
|
|
|
|
struct tg_stats_cpu *sc = per_cpu_ptr(tg->stats_cpu, cpu);
|
|
|
|
|
|
|
|
|
|
blkg_rwstat_reset(&sc->service_bytes);
|
|
|
|
|
blkg_rwstat_reset(&sc->serviced);
|
|
|
|
|
}
|
2011-05-20 03:38:19 +08:00
|
|
|
}
|
|
|
|
|
|
2012-04-17 04:57:25 +08:00
|
|
|
static struct throtl_grp *throtl_lookup_tg(struct throtl_data *td,
|
|
|
|
|
struct blkcg *blkcg)
|
2010-09-16 05:06:35 +08:00
|
|
|
{
|
2011-01-19 23:25:02 +08:00
|
|
|
/*
|
2012-04-17 04:57:25 +08:00
|
|
|
* This is the common case when there are no blkcgs. Avoid lookup
|
|
|
|
|
* in this case
|
2012-03-06 05:15:06 +08:00
|
|
|
*/
|
2012-04-17 04:57:25 +08:00
|
|
|
if (blkcg == &blkcg_root)
|
2012-04-14 04:11:32 +08:00
|
|
|
return td_root_tg(td);
|
2010-09-16 05:06:35 +08:00
|
|
|
|
2012-03-06 05:15:20 +08:00
|
|
|
return blkg_to_tg(blkg_lookup(blkcg, td->queue));
|
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,
|
2012-04-17 04:57:25 +08:00
|
|
|
struct blkcg *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-04-17 04:57:25 +08:00
|
|
|
* This is the common case when there are no blkcgs. Avoid lookup
|
|
|
|
|
* in this case
|
2011-05-20 03:38:23 +08:00
|
|
|
*/
|
2012-04-17 04:57:25 +08:00
|
|
|
if (blkcg == &blkcg_root) {
|
2012-04-14 04:11:32 +08:00
|
|
|
tg = td_root_tg(td);
|
2012-03-06 05:15:06 +08:00
|
|
|
} else {
|
2012-04-17 04:57:25 +08:00
|
|
|
struct blkcg_gq *blkg;
|
2011-05-20 03:38:23 +08:00
|
|
|
|
2012-04-14 04:11:34 +08:00
|
|
|
blkg = blkg_lookup_create(blkcg, q);
|
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))
|
2012-04-14 04:11:32 +08:00
|
|
|
tg = td_root_tg(td);
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-17 04:57:25 +08:00
|
|
|
static void throtl_update_dispatch_stats(struct blkcg_gq *blkg, u64 bytes,
|
2012-04-02 05:38:44 +08:00
|
|
|
int rw)
|
|
|
|
|
{
|
2012-04-02 05:38:44 +08:00
|
|
|
struct throtl_grp *tg = blkg_to_tg(blkg);
|
|
|
|
|
struct tg_stats_cpu *stats_cpu;
|
2012-04-02 05:38:44 +08:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
|
|
/* If per cpu stats are not allocated yet, don't do any accounting. */
|
2012-04-02 05:38:44 +08:00
|
|
|
if (tg->stats_cpu == NULL)
|
2012-04-02 05:38:44 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Disabling interrupts to provide mutual exclusion between two
|
|
|
|
|
* writes on same cpu. It probably is not needed for 64bit. Not
|
|
|
|
|
* optimizing that case yet.
|
|
|
|
|
*/
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
|
|
2012-04-02 05:38:44 +08:00
|
|
|
stats_cpu = this_cpu_ptr(tg->stats_cpu);
|
2012-04-02 05:38:44 +08:00
|
|
|
|
|
|
|
|
blkg_rwstat_add(&stats_cpu->serviced, rw, 1);
|
|
|
|
|
blkg_rwstat_add(&stats_cpu->service_bytes, rw, bytes);
|
|
|
|
|
|
|
|
|
|
local_irq_restore(flags);
|
|
|
|
|
}
|
|
|
|
|
|
2010-09-16 05:06:35 +08:00
|
|
|
static void throtl_charge_bio(struct throtl_grp *tg, struct bio *bio)
|
|
|
|
|
{
|
|
|
|
|
bool rw = bio_data_dir(bio);
|
|
|
|
|
|
|
|
|
|
/* 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-04-02 05:38:44 +08:00
|
|
|
throtl_update_dispatch_stats(tg_to_blkg(tg), bio->bi_size, bio->bi_rw);
|
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;
|
2012-04-17 04:57:25 +08:00
|
|
|
struct blkcg_gq *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:20 +08:00
|
|
|
list_for_each_entry_safe(blkg, n, &q->blkg_list, q_node) {
|
2012-03-06 05:15:18 +08:00
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-17 04:57:26 +08:00
|
|
|
static u64 tg_prfill_cpu_rwstat(struct seq_file *sf,
|
|
|
|
|
struct blkg_policy_data *pd, int off)
|
2012-04-02 05:38:44 +08:00
|
|
|
{
|
2012-04-17 04:57:26 +08:00
|
|
|
struct throtl_grp *tg = pd_to_tg(pd);
|
2012-04-02 05:38:44 +08:00
|
|
|
struct blkg_rwstat rwstat = { }, tmp;
|
|
|
|
|
int i, cpu;
|
|
|
|
|
|
|
|
|
|
for_each_possible_cpu(cpu) {
|
2012-04-02 05:38:44 +08:00
|
|
|
struct tg_stats_cpu *sc = per_cpu_ptr(tg->stats_cpu, cpu);
|
2012-04-02 05:38:44 +08:00
|
|
|
|
|
|
|
|
tmp = blkg_rwstat_read((void *)sc + off);
|
|
|
|
|
for (i = 0; i < BLKG_RWSTAT_NR; i++)
|
|
|
|
|
rwstat.cnt[i] += tmp.cnt[i];
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-17 04:57:26 +08:00
|
|
|
return __blkg_prfill_rwstat(sf, pd, &rwstat);
|
2012-04-02 05:38:44 +08:00
|
|
|
}
|
|
|
|
|
|
2012-04-02 05:38:44 +08:00
|
|
|
static int tg_print_cpu_rwstat(struct cgroup *cgrp, struct cftype *cft,
|
|
|
|
|
struct seq_file *sf)
|
2012-04-02 05:38:44 +08:00
|
|
|
{
|
2012-04-17 04:57:25 +08:00
|
|
|
struct blkcg *blkcg = cgroup_to_blkcg(cgrp);
|
2012-04-02 05:38:44 +08:00
|
|
|
|
2012-04-17 04:57:25 +08:00
|
|
|
blkcg_print_blkgs(sf, blkcg, tg_prfill_cpu_rwstat, &blkcg_policy_throtl,
|
2012-04-02 05:38:45 +08:00
|
|
|
cft->private, true);
|
2012-04-02 05:38:44 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-17 04:57:26 +08:00
|
|
|
static u64 tg_prfill_conf_u64(struct seq_file *sf, struct blkg_policy_data *pd,
|
|
|
|
|
int off)
|
2012-04-02 05:38:43 +08:00
|
|
|
{
|
2012-04-17 04:57:26 +08:00
|
|
|
struct throtl_grp *tg = pd_to_tg(pd);
|
|
|
|
|
u64 v = *(u64 *)((void *)tg + off);
|
2012-04-02 05:38:43 +08:00
|
|
|
|
2012-04-02 05:38:44 +08:00
|
|
|
if (v == -1)
|
2012-04-02 05:38:43 +08:00
|
|
|
return 0;
|
2012-04-17 04:57:26 +08:00
|
|
|
return __blkg_prfill_u64(sf, pd, v);
|
2012-04-02 05:38:43 +08:00
|
|
|
}
|
|
|
|
|
|
2012-04-17 04:57:26 +08:00
|
|
|
static u64 tg_prfill_conf_uint(struct seq_file *sf, struct blkg_policy_data *pd,
|
|
|
|
|
int off)
|
2010-09-16 05:06:35 +08:00
|
|
|
{
|
2012-04-17 04:57:26 +08:00
|
|
|
struct throtl_grp *tg = pd_to_tg(pd);
|
|
|
|
|
unsigned int v = *(unsigned int *)((void *)tg + off);
|
2010-10-01 20:49:49 +08:00
|
|
|
|
2012-04-02 05:38:44 +08:00
|
|
|
if (v == -1)
|
|
|
|
|
return 0;
|
2012-04-17 04:57:26 +08:00
|
|
|
return __blkg_prfill_u64(sf, pd, v);
|
2010-09-16 05:06:35 +08:00
|
|
|
}
|
|
|
|
|
|
2012-04-02 05:38:44 +08:00
|
|
|
static int tg_print_conf_u64(struct cgroup *cgrp, struct cftype *cft,
|
|
|
|
|
struct seq_file *sf)
|
2010-09-16 05:06:37 +08:00
|
|
|
{
|
2012-04-17 04:57:25 +08:00
|
|
|
blkcg_print_blkgs(sf, cgroup_to_blkcg(cgrp), tg_prfill_conf_u64,
|
|
|
|
|
&blkcg_policy_throtl, cft->private, false);
|
2012-04-02 05:38:44 +08:00
|
|
|
return 0;
|
2010-09-16 05:06:37 +08:00
|
|
|
}
|
|
|
|
|
|
2012-04-02 05:38:44 +08:00
|
|
|
static int tg_print_conf_uint(struct cgroup *cgrp, struct cftype *cft,
|
|
|
|
|
struct seq_file *sf)
|
2010-09-16 05:06:37 +08:00
|
|
|
{
|
2012-04-17 04:57:25 +08:00
|
|
|
blkcg_print_blkgs(sf, cgroup_to_blkcg(cgrp), tg_prfill_conf_uint,
|
|
|
|
|
&blkcg_policy_throtl, cft->private, false);
|
2012-04-02 05:38:44 +08:00
|
|
|
return 0;
|
2012-04-02 05:38:43 +08:00
|
|
|
}
|
|
|
|
|
|
2012-04-02 05:38:44 +08:00
|
|
|
static int tg_set_conf(struct cgroup *cgrp, struct cftype *cft, const char *buf,
|
|
|
|
|
bool is_u64)
|
2012-04-02 05:38:43 +08:00
|
|
|
{
|
2012-04-17 04:57:25 +08:00
|
|
|
struct blkcg *blkcg = cgroup_to_blkcg(cgrp);
|
2012-04-02 05:38:43 +08:00
|
|
|
struct blkg_conf_ctx ctx;
|
2012-04-02 05:38:44 +08:00
|
|
|
struct throtl_grp *tg;
|
2012-04-14 04:11:33 +08:00
|
|
|
struct throtl_data *td;
|
2012-04-02 05:38:43 +08:00
|
|
|
int ret;
|
|
|
|
|
|
2012-04-17 04:57:25 +08:00
|
|
|
ret = blkg_conf_prep(blkcg, &blkcg_policy_throtl, buf, &ctx);
|
2012-04-02 05:38:43 +08:00
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
2012-04-02 05:38:44 +08:00
|
|
|
tg = blkg_to_tg(ctx.blkg);
|
2012-04-14 04:11:33 +08:00
|
|
|
td = ctx.blkg->q->td;
|
2012-04-02 05:38:44 +08:00
|
|
|
|
2012-04-14 04:11:33 +08:00
|
|
|
if (!ctx.v)
|
|
|
|
|
ctx.v = -1;
|
2012-04-02 05:38:44 +08:00
|
|
|
|
2012-04-14 04:11:33 +08:00
|
|
|
if (is_u64)
|
|
|
|
|
*(u64 *)((void *)tg + cft->private) = ctx.v;
|
|
|
|
|
else
|
|
|
|
|
*(unsigned int *)((void *)tg + cft->private) = ctx.v;
|
2012-04-02 05:38:44 +08:00
|
|
|
|
2012-04-14 04:11:33 +08:00
|
|
|
/* XXX: we don't need the following deferred processing */
|
|
|
|
|
xchg(&tg->limits_changed, true);
|
|
|
|
|
xchg(&td->limits_changed, true);
|
|
|
|
|
throtl_schedule_delayed_work(td, 0);
|
2012-04-02 05:38:43 +08:00
|
|
|
|
|
|
|
|
blkg_conf_finish(&ctx);
|
2012-04-14 04:11:33 +08:00
|
|
|
return 0;
|
2010-09-16 05:06:37 +08:00
|
|
|
}
|
|
|
|
|
|
2012-04-02 05:38:44 +08:00
|
|
|
static int tg_set_conf_u64(struct cgroup *cgrp, struct cftype *cft,
|
|
|
|
|
const char *buf)
|
2012-04-02 05:38:43 +08:00
|
|
|
{
|
2012-04-02 05:38:44 +08:00
|
|
|
return tg_set_conf(cgrp, cft, buf, true);
|
2012-04-02 05:38:43 +08:00
|
|
|
}
|
|
|
|
|
|
2012-04-02 05:38:44 +08:00
|
|
|
static int tg_set_conf_uint(struct cgroup *cgrp, struct cftype *cft,
|
|
|
|
|
const char *buf)
|
2012-04-02 05:38:43 +08:00
|
|
|
{
|
2012-04-02 05:38:44 +08:00
|
|
|
return tg_set_conf(cgrp, cft, buf, false);
|
2012-04-02 05:38:43 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct cftype throtl_files[] = {
|
|
|
|
|
{
|
|
|
|
|
.name = "throttle.read_bps_device",
|
2012-04-02 05:38:44 +08:00
|
|
|
.private = offsetof(struct throtl_grp, bps[READ]),
|
|
|
|
|
.read_seq_string = tg_print_conf_u64,
|
|
|
|
|
.write_string = tg_set_conf_u64,
|
2012-04-02 05:38:43 +08:00
|
|
|
.max_write_len = 256,
|
|
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
.name = "throttle.write_bps_device",
|
2012-04-02 05:38:44 +08:00
|
|
|
.private = offsetof(struct throtl_grp, bps[WRITE]),
|
|
|
|
|
.read_seq_string = tg_print_conf_u64,
|
|
|
|
|
.write_string = tg_set_conf_u64,
|
2012-04-02 05:38:43 +08:00
|
|
|
.max_write_len = 256,
|
|
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
.name = "throttle.read_iops_device",
|
2012-04-02 05:38:44 +08:00
|
|
|
.private = offsetof(struct throtl_grp, iops[READ]),
|
|
|
|
|
.read_seq_string = tg_print_conf_uint,
|
|
|
|
|
.write_string = tg_set_conf_uint,
|
2012-04-02 05:38:43 +08:00
|
|
|
.max_write_len = 256,
|
|
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
.name = "throttle.write_iops_device",
|
2012-04-02 05:38:44 +08:00
|
|
|
.private = offsetof(struct throtl_grp, iops[WRITE]),
|
|
|
|
|
.read_seq_string = tg_print_conf_uint,
|
|
|
|
|
.write_string = tg_set_conf_uint,
|
2012-04-02 05:38:43 +08:00
|
|
|
.max_write_len = 256,
|
|
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
.name = "throttle.io_service_bytes",
|
2012-04-02 05:38:45 +08:00
|
|
|
.private = offsetof(struct tg_stats_cpu, service_bytes),
|
2012-04-02 05:38:44 +08:00
|
|
|
.read_seq_string = tg_print_cpu_rwstat,
|
2012-04-02 05:38:43 +08:00
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
.name = "throttle.io_serviced",
|
2012-04-02 05:38:45 +08:00
|
|
|
.private = offsetof(struct tg_stats_cpu, serviced),
|
2012-04-02 05:38:44 +08:00
|
|
|
.read_seq_string = tg_print_cpu_rwstat,
|
2012-04-02 05:38:43 +08:00
|
|
|
},
|
|
|
|
|
{ } /* terminate */
|
|
|
|
|
};
|
|
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-17 04:57:25 +08:00
|
|
|
static struct blkcg_policy blkcg_policy_throtl = {
|
2012-04-17 04:57:27 +08:00
|
|
|
.pd_size = sizeof(struct throtl_grp),
|
|
|
|
|
.cftypes = throtl_files,
|
|
|
|
|
|
|
|
|
|
.pd_init_fn = throtl_pd_init,
|
|
|
|
|
.pd_exit_fn = throtl_pd_exit,
|
|
|
|
|
.pd_reset_stats_fn = throtl_pd_reset_stats,
|
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;
|
2012-04-17 04:57:25 +08:00
|
|
|
struct blkcg *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();
|
2012-04-17 04:57:25 +08:00
|
|
|
blkcg = bio_blkcg(bio);
|
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-04-02 05:38:44 +08:00
|
|
|
throtl_update_dispatch_stats(tg_to_blkg(tg),
|
|
|
|
|
bio->bi_size, 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]);
|
|
|
|
|
|
2012-03-06 05:15:29 +08:00
|
|
|
bio_associate_current(bio);
|
2010-09-16 05:06:35 +08:00
|
|
|
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;
|
|
|
|
|
|
2012-03-30 18:33:28 +08:00
|
|
|
queue_lockdep_assert_held(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-04-14 04:11:33 +08:00
|
|
|
int ret;
|
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-04-14 04:11:33 +08:00
|
|
|
/* activate policy */
|
2012-04-17 04:57:25 +08:00
|
|
|
ret = blkcg_activate_policy(q, &blkcg_policy_throtl);
|
2012-04-14 04:11:33 +08:00
|
|
|
if (ret)
|
2012-03-06 05:15:05 +08:00
|
|
|
kfree(td);
|
2012-04-14 04:11:33 +08:00
|
|
|
return ret;
|
2010-09-16 05:06:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void blk_throtl_exit(struct request_queue *q)
|
|
|
|
|
{
|
2012-03-06 05:15:22 +08:00
|
|
|
BUG_ON(!q->td);
|
2011-03-03 08:05:33 +08:00
|
|
|
throtl_shutdown_wq(q);
|
2012-04-17 04:57:25 +08:00
|
|
|
blkcg_deactivate_policy(q, &blkcg_policy_throtl);
|
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");
|
|
|
|
|
|
2012-04-17 04:57:25 +08:00
|
|
|
return blkcg_policy_register(&blkcg_policy_throtl);
|
2010-09-16 05:06:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
module_init(throtl_init);
|