2010-09-16 01:06:35 +04: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>
2015-05-23 00:13:17 +03:00
# include <linux/blk-cgroup.h>
2011-10-19 16:31:18 +04:00
# include "blk.h"
2010-09-16 01:06:35 +04: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 00:57:25 +04:00
static struct blkcg_policy blkcg_policy_throtl ;
2012-03-06 01:15:14 +04:00
2011-03-01 21:40:54 +03:00
/* A workqueue to queue throttle related work */
static struct workqueue_struct * kthrotld_workqueue ;
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
/*
* To implement hierarchical throttling , throtl_grps form a tree and bios
* are dispatched upwards level by level until they reach the top and get
* issued . When dispatching bios from the children and local group at each
* level , if the bios are dispatched into a single bio_list , there ' s a risk
* of a local or child group which can queue many bios at once filling up
* the list starving others .
*
* To avoid such starvation , dispatched bios are queued separately
* according to where they came from . When they are again dispatched to
* the parent , they ' re popped in round - robin order so that no single source
* hogs the dispatch window .
*
* throtl_qnode is used to keep the queued bios separated by their sources .
* Bios are queued to throtl_qnode which in turn is queued to
* throtl_service_queue and then dispatched in round - robin order .
*
* It ' s also used to track the reference counts on blkg ' s . A qnode always
* belongs to a throtl_grp and gets queued on itself or the parent , so
* incrementing the reference of the associated throtl_grp when a qnode is
* queued and decrementing when dequeued is enough to keep the whole blkg
* tree pinned while bios are in flight .
*/
struct throtl_qnode {
struct list_head node ; /* service_queue->queued[] */
struct bio_list bios ; /* queued bios */
struct throtl_grp * tg ; /* tg this qnode belongs to */
} ;
2013-05-15 00:52:32 +04:00
struct throtl_service_queue {
2013-05-15 00:52:36 +04:00
struct throtl_service_queue * parent_sq ; /* the parent service_queue */
2013-05-15 00:52:35 +04:00
/*
* Bios queued directly to this service_queue or dispatched from
* children throtl_grp ' s .
*/
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
struct list_head queued [ 2 ] ; /* throtl_qnode [READ/WRITE] */
2013-05-15 00:52:35 +04:00
unsigned int nr_queued [ 2 ] ; /* number of queued bios */
/*
* RB tree of active children throtl_grp ' s , which are sorted by
* their - > disptime .
*/
2013-05-15 00:52:32 +04:00
struct rb_root pending_tree ; /* RB tree of active tgs */
struct rb_node * first_pending ; /* first node in the tree */
unsigned int nr_pending ; /* # queued in the tree */
unsigned long first_pending_disptime ; /* disptime of the first tg */
2013-05-15 00:52:36 +04:00
struct timer_list pending_timer ; /* fires on first_pending_disptime */
2010-09-16 01:06:35 +04:00
} ;
2013-05-15 00:52:32 +04:00
enum tg_state_flags {
THROTL_TG_PENDING = 1 < < 0 , /* on parent's pending tree */
2013-05-15 00:52:35 +04:00
THROTL_TG_WAS_EMPTY = 1 < < 1 , /* bio_lists[] became non-empty */
2013-05-15 00:52:32 +04:00
} ;
2010-09-16 01:06:35 +04:00
# define rb_entry_tg(node) rb_entry((node), struct throtl_grp, rb_node)
2017-03-27 20:51:30 +03:00
enum {
2017-03-27 20:51:32 +03:00
LIMIT_LOW ,
2017-03-27 20:51:30 +03:00
LIMIT_MAX ,
LIMIT_CNT ,
} ;
2010-09-16 01:06:35 +04:00
struct throtl_grp {
2012-04-17 00:57:26 +04:00
/* must be the first member */
struct blkg_policy_data pd ;
2013-05-15 00:52:32 +04:00
/* active throtl group service_queue member */
2010-09-16 01:06:35 +04:00
struct rb_node rb_node ;
2013-05-15 00:52:32 +04:00
/* throtl_data this group belongs to */
struct throtl_data * td ;
2013-05-15 00:52:34 +04:00
/* this group's service queue */
struct throtl_service_queue service_queue ;
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
/*
* qnode_on_self is used when bios are directly queued to this
* throtl_grp so that local bios compete fairly with bios
* dispatched from children . qnode_on_parent is used when bios are
* dispatched from this throtl_grp into its parent and will compete
* with the sibling qnode_on_parents and the parent ' s
* qnode_on_self .
*/
struct throtl_qnode qnode_on_self [ 2 ] ;
struct throtl_qnode qnode_on_parent [ 2 ] ;
2010-09-16 01:06:35 +04:00
/*
* 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 ;
2013-05-15 00:52:38 +04:00
/* are there any throtl rules between this group and td? */
bool has_rules [ 2 ] ;
2017-03-27 20:51:32 +03:00
/* internally used bytes per second rate limits */
2017-03-27 20:51:30 +03:00
uint64_t bps [ 2 ] [ LIMIT_CNT ] ;
2017-03-27 20:51:32 +03:00
/* user configured bps limits */
uint64_t bps_conf [ 2 ] [ LIMIT_CNT ] ;
2010-09-16 01:06:35 +04:00
2017-03-27 20:51:32 +03:00
/* internally used IOPS limits */
2017-03-27 20:51:30 +03:00
unsigned int iops [ 2 ] [ LIMIT_CNT ] ;
2017-03-27 20:51:32 +03:00
/* user configured IOPS limits */
unsigned int iops_conf [ 2 ] [ LIMIT_CNT ] ;
2010-09-16 01:06:37 +04:00
2010-09-16 01:06:35 +04:00
/* Number of bytes disptached in current slice */
uint64_t bytes_disp [ 2 ] ;
2010-09-16 01:06:37 +04:00
/* Number of bio's dispatched in current slice */
unsigned int io_disp [ 2 ] ;
2010-09-16 01:06:35 +04:00
/* When did we start a new slice */
unsigned long slice_start [ 2 ] ;
unsigned long slice_end [ 2 ] ;
} ;
struct throtl_data
{
/* service tree for active throtl groups */
2013-05-15 00:52:32 +04:00
struct throtl_service_queue service_queue ;
2010-09-16 01:06:35 +04:00
struct request_queue * queue ;
/* Total Number of queued bios on READ and WRITE lists */
unsigned int nr_queued [ 2 ] ;
/* Work for dispatching throttled bios */
2013-05-15 00:52:36 +04:00
struct work_struct dispatch_work ;
2017-03-27 20:51:30 +03:00
unsigned int limit_index ;
bool limit_valid [ LIMIT_CNT ] ;
2010-09-16 01:06:35 +04:00
} ;
2013-05-15 00:52:36 +04:00
static void throtl_pending_timer_fn ( unsigned long arg ) ;
2012-04-17 00:57:26 +04: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 00:57:25 +04:00
static inline struct throtl_grp * blkg_to_tg ( struct blkcg_gq * blkg )
2012-03-06 01:15:14 +04:00
{
2012-04-17 00:57:26 +04:00
return pd_to_tg ( blkg_to_pd ( blkg , & blkcg_policy_throtl ) ) ;
2012-03-06 01:15:14 +04:00
}
2012-04-17 00:57:25 +04:00
static inline struct blkcg_gq * tg_to_blkg ( struct throtl_grp * tg )
2012-03-06 01:15:14 +04:00
{
2012-04-17 00:57:26 +04:00
return pd_to_blkg ( & tg - > pd ) ;
2012-03-06 01:15:14 +04:00
}
2013-05-15 00:52:36 +04:00
/**
* sq_to_tg - return the throl_grp the specified service queue belongs to
* @ sq : the throtl_service_queue of interest
*
* Return the throtl_grp @ sq belongs to . If @ sq is the top - level one
* embedded in throtl_data , % NULL is returned .
*/
static struct throtl_grp * sq_to_tg ( struct throtl_service_queue * sq )
{
if ( sq & & sq - > parent_sq )
return container_of ( sq , struct throtl_grp , service_queue ) ;
else
return NULL ;
}
/**
* sq_to_td - return throtl_data the specified service queue belongs to
* @ sq : the throtl_service_queue of interest
*
2017-02-28 01:29:09 +03:00
* A service_queue can be embedded in either a throtl_grp or throtl_data .
2013-05-15 00:52:36 +04:00
* Determine the associated throtl_data accordingly and return it .
*/
static struct throtl_data * sq_to_td ( struct throtl_service_queue * sq )
{
struct throtl_grp * tg = sq_to_tg ( sq ) ;
if ( tg )
return tg - > td ;
else
return container_of ( sq , struct throtl_data , service_queue ) ;
}
2017-03-27 20:51:30 +03:00
static uint64_t tg_bps_limit ( struct throtl_grp * tg , int rw )
{
return tg - > bps [ rw ] [ tg - > td - > limit_index ] ;
}
static unsigned int tg_iops_limit ( struct throtl_grp * tg , int rw )
{
return tg - > iops [ rw ] [ tg - > td - > limit_index ] ;
}
2013-05-15 00:52:36 +04:00
/**
* throtl_log - log debug message via blktrace
* @ sq : the service_queue being reported
* @ fmt : printf format string
* @ args : printf args
*
* The messages are prefixed with " throtl BLKG_NAME " if @ sq belongs to a
* throtl_grp ; otherwise , just " throtl " .
*/
# define throtl_log(sq, fmt, args...) do { \
struct throtl_grp * __tg = sq_to_tg ( ( sq ) ) ; \
struct throtl_data * __td = sq_to_td ( ( sq ) ) ; \
\
( void ) __td ; \
2016-05-10 03:22:15 +03:00
if ( likely ( ! blk_trace_note_message_enabled ( __td - > queue ) ) ) \
break ; \
2013-05-15 00:52:36 +04:00
if ( ( __tg ) ) { \
char __pbuf [ 128 ] ; \
2012-04-17 00:57:23 +04:00
\
2013-05-15 00:52:36 +04:00
blkg_path ( tg_to_blkg ( __tg ) , __pbuf , sizeof ( __pbuf ) ) ; \
blk_add_trace_msg ( __td - > queue , " throtl %s " fmt , __pbuf , # # args ) ; \
} else { \
blk_add_trace_msg ( __td - > queue , " throtl " fmt , # # args ) ; \
} \
2012-04-17 00:57:23 +04:00
} while ( 0 )
2010-09-16 01:06:35 +04:00
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
static void throtl_qnode_init ( struct throtl_qnode * qn , struct throtl_grp * tg )
{
INIT_LIST_HEAD ( & qn - > node ) ;
bio_list_init ( & qn - > bios ) ;
qn - > tg = tg ;
}
/**
* throtl_qnode_add_bio - add a bio to a throtl_qnode and activate it
* @ bio : bio being added
* @ qn : qnode to add bio to
* @ queued : the service_queue - > queued [ ] list @ qn belongs to
*
* Add @ bio to @ qn and put @ qn on @ queued if it ' s not already on .
* @ qn - > tg ' s reference count is bumped when @ qn is activated . See the
* comment on top of throtl_qnode definition for details .
*/
static void throtl_qnode_add_bio ( struct bio * bio , struct throtl_qnode * qn ,
struct list_head * queued )
{
bio_list_add ( & qn - > bios , bio ) ;
if ( list_empty ( & qn - > node ) ) {
list_add_tail ( & qn - > node , queued ) ;
blkg_get ( tg_to_blkg ( qn - > tg ) ) ;
}
}
/**
* throtl_peek_queued - peek the first bio on a qnode list
* @ queued : the qnode list to peek
*/
static struct bio * throtl_peek_queued ( struct list_head * queued )
{
struct throtl_qnode * qn = list_first_entry ( queued , struct throtl_qnode , node ) ;
struct bio * bio ;
if ( list_empty ( queued ) )
return NULL ;
bio = bio_list_peek ( & qn - > bios ) ;
WARN_ON_ONCE ( ! bio ) ;
return bio ;
}
/**
* throtl_pop_queued - pop the first bio form a qnode list
* @ queued : the qnode list to pop a bio from
* @ tg_to_put : optional out argument for throtl_grp to put
*
* Pop the first bio from the qnode list @ queued . After popping , the first
* qnode is removed from @ queued if empty or moved to the end of @ queued so
* that the popping order is round - robin .
*
* When the first qnode is removed , its associated throtl_grp should be put
* too . If @ tg_to_put is NULL , this function automatically puts it ;
* otherwise , * @ tg_to_put is set to the throtl_grp to put and the caller is
* responsible for putting it .
*/
static struct bio * throtl_pop_queued ( struct list_head * queued ,
struct throtl_grp * * tg_to_put )
{
struct throtl_qnode * qn = list_first_entry ( queued , struct throtl_qnode , node ) ;
struct bio * bio ;
if ( list_empty ( queued ) )
return NULL ;
bio = bio_list_pop ( & qn - > bios ) ;
WARN_ON_ONCE ( ! bio ) ;
if ( bio_list_empty ( & qn - > bios ) ) {
list_del_init ( & qn - > node ) ;
if ( tg_to_put )
* tg_to_put = qn - > tg ;
else
blkg_put ( tg_to_blkg ( qn - > tg ) ) ;
} else {
list_move_tail ( & qn - > node , queued ) ;
}
return bio ;
}
2013-05-15 00:52:34 +04:00
/* init a service_queue, assumes the caller zeroed it */
2015-08-19 00:55:13 +03:00
static void throtl_service_queue_init ( struct throtl_service_queue * sq )
2013-05-15 00:52:34 +04:00
{
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
INIT_LIST_HEAD ( & sq - > queued [ 0 ] ) ;
INIT_LIST_HEAD ( & sq - > queued [ 1 ] ) ;
2013-05-15 00:52:34 +04:00
sq - > pending_tree = RB_ROOT ;
2013-05-15 00:52:36 +04:00
setup_timer ( & sq - > pending_timer , throtl_pending_timer_fn ,
( unsigned long ) sq ) ;
}
2015-08-19 00:55:11 +03:00
static struct blkg_policy_data * throtl_pd_alloc ( gfp_t gfp , int node )
{
2015-08-19 00:55:12 +03:00
struct throtl_grp * tg ;
2015-08-19 00:55:22 +03:00
int rw ;
2015-08-19 00:55:12 +03:00
tg = kzalloc_node ( sizeof ( * tg ) , gfp , node ) ;
if ( ! tg )
2015-08-19 00:55:24 +03:00
return NULL ;
2015-08-19 00:55:12 +03:00
2015-08-19 00:55:13 +03:00
throtl_service_queue_init ( & tg - > service_queue ) ;
for ( rw = READ ; rw < = WRITE ; rw + + ) {
throtl_qnode_init ( & tg - > qnode_on_self [ rw ] , tg ) ;
throtl_qnode_init ( & tg - > qnode_on_parent [ rw ] , tg ) ;
}
RB_CLEAR_NODE ( & tg - > rb_node ) ;
2017-03-27 20:51:30 +03:00
tg - > bps [ READ ] [ LIMIT_MAX ] = U64_MAX ;
tg - > bps [ WRITE ] [ LIMIT_MAX ] = U64_MAX ;
tg - > iops [ READ ] [ LIMIT_MAX ] = UINT_MAX ;
tg - > iops [ WRITE ] [ LIMIT_MAX ] = UINT_MAX ;
2017-03-27 20:51:32 +03:00
tg - > bps_conf [ READ ] [ LIMIT_MAX ] = U64_MAX ;
tg - > bps_conf [ WRITE ] [ LIMIT_MAX ] = U64_MAX ;
tg - > iops_conf [ READ ] [ LIMIT_MAX ] = UINT_MAX ;
tg - > iops_conf [ WRITE ] [ LIMIT_MAX ] = UINT_MAX ;
/* LIMIT_LOW will have default value 0 */
2015-08-19 00:55:13 +03:00
2015-08-19 00:55:12 +03:00
return & tg - > pd ;
2015-08-19 00:55:11 +03:00
}
2015-08-19 00:55:14 +03:00
static void throtl_pd_init ( struct blkg_policy_data * pd )
2011-05-19 23:38:19 +04:00
{
2015-08-19 00:55:14 +03:00
struct throtl_grp * tg = pd_to_tg ( pd ) ;
struct blkcg_gq * blkg = tg_to_blkg ( tg ) ;
2013-05-15 00:52:36 +04:00
struct throtl_data * td = blkg - > q - > td ;
2015-08-19 00:55:13 +03:00
struct throtl_service_queue * sq = & tg - > service_queue ;
2012-03-06 01:15:06 +04:00
2013-05-15 00:52:38 +04:00
/*
2014-07-09 18:08:08 +04:00
* If on the default hierarchy , we switch to properly hierarchical
2013-05-15 00:52:38 +04:00
* behavior where limits on a given throtl_grp are applied to the
* whole subtree rather than just the group itself . e . g . If 16 M
* read_bps limit is set on the root group , the whole system can ' t
* exceed 16 M for the device .
*
2014-07-09 18:08:08 +04:00
* If not on the default hierarchy , the broken flat hierarchy
2013-05-15 00:52:38 +04:00
* behavior is retained where all throtl_grps are treated as if
* they ' re all separate root groups right below throtl_data .
* Limits of a group don ' t interact with limits of other groups
* regardless of the position of the group in the hierarchy .
*/
2015-08-19 00:55:13 +03:00
sq - > parent_sq = & td - > service_queue ;
2015-09-18 18:56:28 +03:00
if ( cgroup_subsys_on_dfl ( io_cgrp_subsys ) & & blkg - > parent )
2015-08-19 00:55:13 +03:00
sq - > parent_sq = & blkg_to_tg ( blkg - > parent ) - > service_queue ;
2013-05-15 00:52:36 +04:00
tg - > td = td ;
2012-04-02 01:38:44 +04:00
}
2013-05-15 00:52:38 +04:00
/*
* Set has_rules [ ] if @ tg or any of its parents have limits configured .
* This doesn ' t require walking up to the top of the hierarchy as the
* parent ' s has_rules [ ] is guaranteed to be correct .
*/
static void tg_update_has_rules ( struct throtl_grp * tg )
{
struct throtl_grp * parent_tg = sq_to_tg ( tg - > service_queue . parent_sq ) ;
2017-03-27 20:51:30 +03:00
struct throtl_data * td = tg - > td ;
2013-05-15 00:52:38 +04:00
int rw ;
for ( rw = READ ; rw < = WRITE ; rw + + )
tg - > has_rules [ rw ] = ( parent_tg & & parent_tg - > has_rules [ rw ] ) | |
2017-03-27 20:51:30 +03:00
( td - > limit_valid [ td - > limit_index ] & &
( tg_bps_limit ( tg , rw ) ! = U64_MAX | |
tg_iops_limit ( tg , rw ) ! = UINT_MAX ) ) ;
2013-05-15 00:52:38 +04:00
}
2015-08-19 00:55:14 +03:00
static void throtl_pd_online ( struct blkg_policy_data * pd )
2013-05-15 00:52:38 +04:00
{
/*
* We don ' t want new groups to escape the limits of its ancestors .
* Update has_rules [ ] after a new group is brought online .
*/
2015-08-19 00:55:14 +03:00
tg_update_has_rules ( pd_to_tg ( pd ) ) ;
2013-05-15 00:52:38 +04:00
}
2017-03-27 20:51:32 +03:00
static void blk_throtl_update_limit_valid ( struct throtl_data * td )
{
struct cgroup_subsys_state * pos_css ;
struct blkcg_gq * blkg ;
bool low_valid = false ;
rcu_read_lock ( ) ;
blkg_for_each_descendant_post ( blkg , pos_css , td - > queue - > root_blkg ) {
struct throtl_grp * tg = blkg_to_tg ( blkg ) ;
if ( tg - > bps [ READ ] [ LIMIT_LOW ] | | tg - > bps [ WRITE ] [ LIMIT_LOW ] | |
tg - > iops [ READ ] [ LIMIT_LOW ] | | tg - > iops [ WRITE ] [ LIMIT_LOW ] )
low_valid = true ;
}
rcu_read_unlock ( ) ;
td - > limit_valid [ LIMIT_LOW ] = low_valid ;
}
static void throtl_pd_offline ( struct blkg_policy_data * pd )
{
struct throtl_grp * tg = pd_to_tg ( pd ) ;
tg - > bps [ READ ] [ LIMIT_LOW ] = 0 ;
tg - > bps [ WRITE ] [ LIMIT_LOW ] = 0 ;
tg - > iops [ READ ] [ LIMIT_LOW ] = 0 ;
tg - > iops [ WRITE ] [ LIMIT_LOW ] = 0 ;
blk_throtl_update_limit_valid ( tg - > td ) ;
if ( tg - > td - > limit_index = = LIMIT_LOW & &
! tg - > td - > limit_valid [ LIMIT_LOW ] )
tg - > td - > limit_index = LIMIT_MAX ;
}
2015-08-19 00:55:11 +03:00
static void throtl_pd_free ( struct blkg_policy_data * pd )
{
2015-08-19 00:55:12 +03:00
struct throtl_grp * tg = pd_to_tg ( pd ) ;
2015-08-19 00:55:13 +03:00
del_timer_sync ( & tg - > service_queue . pending_timer ) ;
2015-08-19 00:55:12 +03:00
kfree ( tg ) ;
2015-08-19 00:55:11 +03:00
}
2013-05-15 00:52:33 +04:00
static struct throtl_grp *
throtl_rb_first ( struct throtl_service_queue * parent_sq )
2010-09-16 01:06:35 +04:00
{
/* Service tree is empty */
2013-05-15 00:52:33 +04:00
if ( ! parent_sq - > nr_pending )
2010-09-16 01:06:35 +04:00
return NULL ;
2013-05-15 00:52:33 +04:00
if ( ! parent_sq - > first_pending )
parent_sq - > first_pending = rb_first ( & parent_sq - > pending_tree ) ;
2010-09-16 01:06:35 +04:00
2013-05-15 00:52:33 +04:00
if ( parent_sq - > first_pending )
return rb_entry_tg ( parent_sq - > first_pending ) ;
2010-09-16 01:06:35 +04:00
return NULL ;
}
static void rb_erase_init ( struct rb_node * n , struct rb_root * root )
{
rb_erase ( n , root ) ;
RB_CLEAR_NODE ( n ) ;
}
2013-05-15 00:52:33 +04:00
static void throtl_rb_erase ( struct rb_node * n ,
struct throtl_service_queue * parent_sq )
2010-09-16 01:06:35 +04:00
{
2013-05-15 00:52:33 +04:00
if ( parent_sq - > first_pending = = n )
parent_sq - > first_pending = NULL ;
rb_erase_init ( n , & parent_sq - > pending_tree ) ;
- - parent_sq - > nr_pending ;
2010-09-16 01:06:35 +04:00
}
2013-05-15 00:52:33 +04:00
static void update_min_dispatch_time ( struct throtl_service_queue * parent_sq )
2010-09-16 01:06:35 +04:00
{
struct throtl_grp * tg ;
2013-05-15 00:52:33 +04:00
tg = throtl_rb_first ( parent_sq ) ;
2010-09-16 01:06:35 +04:00
if ( ! tg )
return ;
2013-05-15 00:52:33 +04:00
parent_sq - > first_pending_disptime = tg - > disptime ;
2010-09-16 01:06:35 +04:00
}
2013-05-15 00:52:36 +04:00
static void tg_service_queue_add ( struct throtl_grp * tg )
2010-09-16 01:06:35 +04:00
{
2013-05-15 00:52:36 +04:00
struct throtl_service_queue * parent_sq = tg - > service_queue . parent_sq ;
2013-05-15 00:52:33 +04:00
struct rb_node * * node = & parent_sq - > pending_tree . rb_node ;
2010-09-16 01:06:35 +04:00
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 )
2013-05-15 00:52:33 +04:00
parent_sq - > first_pending = & tg - > rb_node ;
2010-09-16 01:06:35 +04:00
rb_link_node ( & tg - > rb_node , parent , node ) ;
2013-05-15 00:52:33 +04:00
rb_insert_color ( & tg - > rb_node , & parent_sq - > pending_tree ) ;
2010-09-16 01:06:35 +04:00
}
2013-05-15 00:52:36 +04:00
static void __throtl_enqueue_tg ( struct throtl_grp * tg )
2010-09-16 01:06:35 +04:00
{
2013-05-15 00:52:36 +04:00
tg_service_queue_add ( tg ) ;
2013-05-15 00:52:32 +04:00
tg - > flags | = THROTL_TG_PENDING ;
2013-05-15 00:52:36 +04:00
tg - > service_queue . parent_sq - > nr_pending + + ;
2010-09-16 01:06:35 +04:00
}
2013-05-15 00:52:36 +04:00
static void throtl_enqueue_tg ( struct throtl_grp * tg )
2010-09-16 01:06:35 +04:00
{
2013-05-15 00:52:32 +04:00
if ( ! ( tg - > flags & THROTL_TG_PENDING ) )
2013-05-15 00:52:36 +04:00
__throtl_enqueue_tg ( tg ) ;
2010-09-16 01:06:35 +04:00
}
2013-05-15 00:52:36 +04:00
static void __throtl_dequeue_tg ( struct throtl_grp * tg )
2010-09-16 01:06:35 +04:00
{
2013-05-15 00:52:36 +04:00
throtl_rb_erase ( & tg - > rb_node , tg - > service_queue . parent_sq ) ;
2013-05-15 00:52:32 +04:00
tg - > flags & = ~ THROTL_TG_PENDING ;
2010-09-16 01:06:35 +04:00
}
2013-05-15 00:52:36 +04:00
static void throtl_dequeue_tg ( struct throtl_grp * tg )
2010-09-16 01:06:35 +04:00
{
2013-05-15 00:52:32 +04:00
if ( tg - > flags & THROTL_TG_PENDING )
2013-05-15 00:52:36 +04:00
__throtl_dequeue_tg ( tg ) ;
2010-09-16 01:06:35 +04:00
}
2013-05-15 00:52:31 +04:00
/* Call with queue lock held */
2013-05-15 00:52:36 +04:00
static void throtl_schedule_pending_timer ( struct throtl_service_queue * sq ,
unsigned long expires )
2013-05-15 00:52:31 +04:00
{
2013-05-15 00:52:36 +04:00
mod_timer ( & sq - > pending_timer , expires ) ;
throtl_log ( sq , " schedule timer. delay=%lu jiffies=%lu " ,
expires - jiffies , jiffies ) ;
2013-05-15 00:52:31 +04:00
}
2013-05-15 00:52:37 +04:00
/**
* throtl_schedule_next_dispatch - schedule the next dispatch cycle
* @ sq : the service_queue to schedule dispatch for
* @ force : force scheduling
*
* Arm @ sq - > pending_timer so that the next dispatch cycle starts on the
* dispatch time of the first pending child . Returns % true if either timer
* is armed or there ' s no pending child left . % false if the current
* dispatch window is still open and the caller should continue
* dispatching .
*
* If @ force is % true , the dispatch timer is always scheduled and this
* function is guaranteed to return % true . This is to be used when the
* caller can ' t dispatch itself and needs to invoke pending_timer
* unconditionally . Note that forced scheduling is likely to induce short
* delay before dispatch starts even if @ sq - > first_pending_disptime is not
* in the future and thus shouldn ' t be used in hot paths .
*/
static bool throtl_schedule_next_dispatch ( struct throtl_service_queue * sq ,
bool force )
2010-09-16 01:06:35 +04:00
{
2013-05-15 00:52:32 +04:00
/* any pending children left? */
2013-05-15 00:52:32 +04:00
if ( ! sq - > nr_pending )
2013-05-15 00:52:37 +04:00
return true ;
2010-09-16 01:06:35 +04:00
2013-05-15 00:52:32 +04:00
update_min_dispatch_time ( sq ) ;
2010-09-16 01:06:35 +04:00
2013-05-15 00:52:36 +04:00
/* is the next dispatch time in the future? */
2013-05-15 00:52:37 +04:00
if ( force | | time_after ( sq - > first_pending_disptime , jiffies ) ) {
2013-05-15 00:52:36 +04:00
throtl_schedule_pending_timer ( sq , sq - > first_pending_disptime ) ;
2013-05-15 00:52:37 +04:00
return true ;
2013-05-15 00:52:36 +04:00
}
2013-05-15 00:52:37 +04:00
/* tell the caller to continue dispatching */
return false ;
2010-09-16 01:06:35 +04:00
}
blk-throttle: Account for child group's start time in parent while bio climbs up
With the planned proper hierarchy support, a bio will climb up the
tree before actually being dispatched. This makes sure bio is also
subjected to parent's throttling limits, if any.
It might happen that parent is idle and when bio is transferred to
parent, a new slice starts fresh. But that is incorrect as parents
wait time should have started when bio was queued in child group and
causes IOs to be throttled more than configured as they climb the
hierarchy.
Given the fact that we have not written hierarchical algorithm in a
way where child's and parents time slices are synchronized, we
transfer the child's start time to parent if parent was idling. If
parent was busy doing dispatch of other bios all this while, this is
not an issue.
Child's slice start time is passed to parent. Parent looks at its
last expired slice start time. If child's start time is after parents
old start time, that means parent had been idle and after parent
went idle, child had an IO queued. So use child's start time as
parent start time.
If parent's start time is after child's start time, that means,
when IO got queued in child group, parent was not idle. But later
it dispatched some IO, its slice got trimmed and then it went idle.
After a while child's request got shifted in parent group. In this
case use parent's old start time as new start time as that's the
duration of slice we did not use.
This logic is far from perfect as if there are multiple childs
then first child transferring the bio decides the start time while
a bio might have queued up even earlier in other child, which is
yet to be transferred up to parent. In that case we will lose
time and bandwidth in parent. This patch is just an approximation
to make situation somewhat better.
Signed-off-by: Vivek Goyal <vgoyal@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-05-15 00:52:38 +04:00
static inline void throtl_start_new_slice_with_credit ( struct throtl_grp * tg ,
bool rw , unsigned long start )
{
tg - > bytes_disp [ rw ] = 0 ;
tg - > io_disp [ rw ] = 0 ;
/*
* Previous slice has expired . We must have trimmed it after last
* bio dispatch . That means since start of last slice , we never used
* that bandwidth . Do try to make use of that bandwidth while giving
* credit .
*/
if ( time_after_eq ( start , tg - > slice_start [ rw ] ) )
tg - > slice_start [ rw ] = start ;
tg - > slice_end [ rw ] = jiffies + throtl_slice ;
throtl_log ( & tg - > service_queue ,
" [%c] new slice with credit start=%lu end=%lu jiffies=%lu " ,
rw = = READ ? ' R ' : ' W ' , tg - > slice_start [ rw ] ,
tg - > slice_end [ rw ] , jiffies ) ;
}
2013-05-15 00:52:32 +04:00
static inline void throtl_start_new_slice ( struct throtl_grp * tg , bool rw )
2010-09-16 01:06:35 +04:00
{
tg - > bytes_disp [ rw ] = 0 ;
2010-09-16 01:06:37 +04:00
tg - > io_disp [ rw ] = 0 ;
2010-09-16 01:06:35 +04:00
tg - > slice_start [ rw ] = jiffies ;
tg - > slice_end [ rw ] = jiffies + throtl_slice ;
2013-05-15 00:52:36 +04:00
throtl_log ( & tg - > service_queue ,
" [%c] new slice start=%lu end=%lu jiffies=%lu " ,
rw = = READ ? ' R ' : ' W ' , tg - > slice_start [ rw ] ,
tg - > slice_end [ rw ] , jiffies ) ;
2010-09-16 01:06:35 +04:00
}
2013-05-15 00:52:32 +04:00
static inline void throtl_set_slice_end ( struct throtl_grp * tg , bool rw ,
unsigned long jiffy_end )
2010-12-01 21:34:46 +03:00
{
tg - > slice_end [ rw ] = roundup ( jiffy_end , throtl_slice ) ;
}
2013-05-15 00:52:32 +04:00
static inline void throtl_extend_slice ( struct throtl_grp * tg , bool rw ,
unsigned long jiffy_end )
2010-09-16 01:06:35 +04:00
{
tg - > slice_end [ rw ] = roundup ( jiffy_end , throtl_slice ) ;
2013-05-15 00:52:36 +04:00
throtl_log ( & tg - > service_queue ,
" [%c] extend slice start=%lu end=%lu jiffies=%lu " ,
rw = = READ ? ' R ' : ' W ' , tg - > slice_start [ rw ] ,
tg - > slice_end [ rw ] , jiffies ) ;
2010-09-16 01:06:35 +04:00
}
/* Determine if previously allocated or extended slice is complete or not */
2013-05-15 00:52:32 +04:00
static bool throtl_slice_used ( struct throtl_grp * tg , bool rw )
2010-09-16 01:06:35 +04:00
{
if ( time_in_range ( jiffies , tg - > slice_start [ rw ] , tg - > slice_end [ rw ] ) )
2014-05-02 20:28:17 +04:00
return false ;
2010-09-16 01:06:35 +04:00
return 1 ;
}
/* Trim the used slices and adjust slice start accordingly */
2013-05-15 00:52:32 +04:00
static inline void throtl_trim_slice ( struct throtl_grp * tg , bool rw )
2010-09-16 01:06:35 +04:00
{
2010-10-01 16:51:14 +04:00
unsigned long nr_slices , time_elapsed , io_trim ;
u64 bytes_trim , tmp ;
2010-09-16 01:06:35 +04: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 .
*/
2013-05-15 00:52:32 +04:00
if ( throtl_slice_used ( tg , rw ) )
2010-09-16 01:06:35 +04:00
return ;
2010-12-01 21:34:46 +03: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 .
*/
2013-05-15 00:52:32 +04:00
throtl_set_slice_end ( tg , rw , jiffies + throtl_slice ) ;
2010-12-01 21:34:46 +03:00
2010-09-16 01:06:35 +04:00
time_elapsed = jiffies - tg - > slice_start [ rw ] ;
nr_slices = time_elapsed / throtl_slice ;
if ( ! nr_slices )
return ;
2017-03-27 20:51:30 +03:00
tmp = tg_bps_limit ( tg , rw ) * throtl_slice * nr_slices ;
2010-10-01 16:51:14 +04:00
do_div ( tmp , HZ ) ;
bytes_trim = tmp ;
2010-09-16 01:06:35 +04:00
2017-03-27 20:51:30 +03:00
io_trim = ( tg_iops_limit ( tg , rw ) * throtl_slice * nr_slices ) / HZ ;
2010-09-16 01:06:35 +04:00
2010-09-16 01:06:37 +04:00
if ( ! bytes_trim & & ! io_trim )
2010-09-16 01:06:35 +04:00
return ;
if ( tg - > bytes_disp [ rw ] > = bytes_trim )
tg - > bytes_disp [ rw ] - = bytes_trim ;
else
tg - > bytes_disp [ rw ] = 0 ;
2010-09-16 01:06:37 +04:00
if ( tg - > io_disp [ rw ] > = io_trim )
tg - > io_disp [ rw ] - = io_trim ;
else
tg - > io_disp [ rw ] = 0 ;
2010-09-16 01:06:35 +04:00
tg - > slice_start [ rw ] + = nr_slices * throtl_slice ;
2013-05-15 00:52:36 +04:00
throtl_log ( & tg - > service_queue ,
" [%c] trim slice nr=%lu bytes=%llu io=%lu start=%lu end=%lu jiffies=%lu " ,
rw = = READ ? ' R ' : ' W ' , nr_slices , bytes_trim , io_trim ,
tg - > slice_start [ rw ] , tg - > slice_end [ rw ] , jiffies ) ;
2010-09-16 01:06:35 +04:00
}
2013-05-15 00:52:32 +04:00
static bool tg_with_in_iops_limit ( struct throtl_grp * tg , struct bio * bio ,
unsigned long * wait )
2010-09-16 01:06:35 +04:00
{
bool rw = bio_data_dir ( bio ) ;
2010-09-16 01:06:37 +04:00
unsigned int io_allowed ;
2010-09-16 01:06:35 +04:00
unsigned long jiffy_elapsed , jiffy_wait , jiffy_elapsed_rnd ;
2010-10-01 23:16:42 +04:00
u64 tmp ;
2010-09-16 01:06:35 +04:00
2010-09-16 01:06:37 +04:00
jiffy_elapsed = jiffy_elapsed_rnd = jiffies - tg - > slice_start [ rw ] ;
2010-09-16 01:06:35 +04:00
2010-09-16 01:06:37 +04: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-01 23:16:42 +04: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 .
*/
2017-03-27 20:51:30 +03:00
tmp = ( u64 ) tg_iops_limit ( tg , rw ) * jiffy_elapsed_rnd ;
2010-10-01 23:16:42 +04:00
do_div ( tmp , HZ ) ;
if ( tmp > UINT_MAX )
io_allowed = UINT_MAX ;
else
io_allowed = tmp ;
2010-09-16 01:06:37 +04:00
if ( tg - > io_disp [ rw ] + 1 < = io_allowed ) {
2010-09-16 01:06:35 +04:00
if ( wait )
* wait = 0 ;
2014-05-02 20:28:17 +04:00
return true ;
2010-09-16 01:06:35 +04:00
}
2010-09-16 01:06:37 +04:00
/* Calc approx time to dispatch */
2017-03-27 20:51:30 +03:00
jiffy_wait = ( ( tg - > io_disp [ rw ] + 1 ) * HZ ) / tg_iops_limit ( tg , rw ) + 1 ;
2010-09-16 01:06:37 +04:00
if ( jiffy_wait > jiffy_elapsed )
jiffy_wait = jiffy_wait - jiffy_elapsed ;
else
jiffy_wait = 1 ;
if ( wait )
* wait = jiffy_wait ;
return 0 ;
}
2013-05-15 00:52:32 +04:00
static bool tg_with_in_bps_limit ( struct throtl_grp * tg , struct bio * bio ,
unsigned long * wait )
2010-09-16 01:06:37 +04:00
{
bool rw = bio_data_dir ( bio ) ;
2010-10-01 16:51:14 +04:00
u64 bytes_allowed , extra_bytes , tmp ;
2010-09-16 01:06:37 +04:00
unsigned long jiffy_elapsed , jiffy_wait , jiffy_elapsed_rnd ;
2010-09-16 01:06:35 +04: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 ) ;
2017-03-27 20:51:30 +03:00
tmp = tg_bps_limit ( tg , rw ) * jiffy_elapsed_rnd ;
2010-10-01 23:16:38 +04:00
do_div ( tmp , HZ ) ;
2010-10-01 16:51:14 +04:00
bytes_allowed = tmp ;
2010-09-16 01:06:35 +04:00
2013-10-12 02:44:27 +04:00
if ( tg - > bytes_disp [ rw ] + bio - > bi_iter . bi_size < = bytes_allowed ) {
2010-09-16 01:06:35 +04:00
if ( wait )
* wait = 0 ;
2014-05-02 20:28:17 +04:00
return true ;
2010-09-16 01:06:35 +04:00
}
/* Calc approx time to dispatch */
2013-10-12 02:44:27 +04:00
extra_bytes = tg - > bytes_disp [ rw ] + bio - > bi_iter . bi_size - bytes_allowed ;
2017-03-27 20:51:30 +03:00
jiffy_wait = div64_u64 ( extra_bytes * HZ , tg_bps_limit ( tg , rw ) ) ;
2010-09-16 01:06:35 +04:00
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 01:06:37 +04:00
return 0 ;
}
/*
* 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
*/
2013-05-15 00:52:32 +04:00
static bool tg_may_dispatch ( struct throtl_grp * tg , struct bio * bio ,
unsigned long * wait )
2010-09-16 01:06:37 +04:00
{
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 .
*/
2013-05-15 00:52:35 +04:00
BUG_ON ( tg - > service_queue . nr_queued [ rw ] & &
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
bio ! = throtl_peek_queued ( & tg - > service_queue . queued [ rw ] ) ) ;
2010-09-16 01:06:35 +04:00
2010-09-16 01:06:37 +04:00
/* If tg->bps = -1, then BW is unlimited */
2017-03-27 20:51:30 +03:00
if ( tg_bps_limit ( tg , rw ) = = U64_MAX & &
tg_iops_limit ( tg , rw ) = = UINT_MAX ) {
2010-09-16 01:06:37 +04:00
if ( wait )
* wait = 0 ;
2014-05-02 20:28:17 +04:00
return true ;
2010-09-16 01:06:37 +04:00
}
/*
* If previous slice expired , start a new one otherwise renew / extend
* existing slice to make sure it is at least throtl_slice interval
2016-09-20 00:12:41 +03:00
* long since now . New slice is started only for empty throttle group .
* If there is queued bio , that means there should be an active
* slice and it should be extended instead .
2010-09-16 01:06:37 +04:00
*/
2016-09-20 00:12:41 +03:00
if ( throtl_slice_used ( tg , rw ) & & ! ( tg - > service_queue . nr_queued [ rw ] ) )
2013-05-15 00:52:32 +04:00
throtl_start_new_slice ( tg , rw ) ;
2010-09-16 01:06:37 +04:00
else {
if ( time_before ( tg - > slice_end [ rw ] , jiffies + throtl_slice ) )
2013-05-15 00:52:32 +04:00
throtl_extend_slice ( tg , rw , jiffies + throtl_slice ) ;
2010-09-16 01:06:37 +04:00
}
2013-05-15 00:52:32 +04:00
if ( tg_with_in_bps_limit ( tg , bio , & bps_wait ) & &
tg_with_in_iops_limit ( tg , bio , & iops_wait ) ) {
2010-09-16 01:06:37 +04:00
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 ) )
2013-05-15 00:52:32 +04:00
throtl_extend_slice ( tg , rw , jiffies + max_wait ) ;
2010-09-16 01:06:35 +04:00
return 0 ;
}
static void throtl_charge_bio ( struct throtl_grp * tg , struct bio * bio )
{
bool rw = bio_data_dir ( bio ) ;
/* Charge the bio to the group */
2013-10-12 02:44:27 +04:00
tg - > bytes_disp [ rw ] + = bio - > bi_iter . bi_size ;
2010-09-16 01:06:37 +04:00
tg - > io_disp [ rw ] + + ;
2010-09-16 01:06:35 +04:00
2013-05-15 00:52:36 +04:00
/*
2016-10-20 16:12:12 +03:00
* BIO_THROTTLED is used to prevent the same bio to be throttled
2013-05-15 00:52:36 +04:00
* more than once as a throttled bio will go through blk - throtl the
* second time when it eventually gets issued . Set it when a bio
* is being charged to a tg .
*/
2016-10-20 16:12:12 +03:00
if ( ! bio_flagged ( bio , BIO_THROTTLED ) )
bio_set_flag ( bio , BIO_THROTTLED ) ;
2010-09-16 01:06:35 +04:00
}
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
/**
* throtl_add_bio_tg - add a bio to the specified throtl_grp
* @ bio : bio to add
* @ qn : qnode to use
* @ tg : the target throtl_grp
*
* Add @ bio to @ tg ' s service_queue using @ qn . If @ qn is not specified ,
* tg - > qnode_on_self [ ] is used .
*/
static void throtl_add_bio_tg ( struct bio * bio , struct throtl_qnode * qn ,
struct throtl_grp * tg )
2010-09-16 01:06:35 +04:00
{
2013-05-15 00:52:35 +04:00
struct throtl_service_queue * sq = & tg - > service_queue ;
2010-09-16 01:06:35 +04:00
bool rw = bio_data_dir ( bio ) ;
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
if ( ! qn )
qn = & tg - > qnode_on_self [ rw ] ;
2013-05-15 00:52:35 +04:00
/*
* If @ tg doesn ' t currently have any bios queued in the same
* direction , queueing @ bio can change when @ tg should be
* dispatched . Mark that @ tg was empty . This is automatically
* cleaered on the next tg_update_disptime ( ) .
*/
if ( ! sq - > nr_queued [ rw ] )
tg - > flags | = THROTL_TG_WAS_EMPTY ;
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
throtl_qnode_add_bio ( bio , qn , & sq - > queued [ rw ] ) ;
2013-05-15 00:52:35 +04:00
sq - > nr_queued [ rw ] + + ;
2013-05-15 00:52:36 +04:00
throtl_enqueue_tg ( tg ) ;
2010-09-16 01:06:35 +04:00
}
2013-05-15 00:52:36 +04:00
static void tg_update_disptime ( struct throtl_grp * tg )
2010-09-16 01:06:35 +04:00
{
2013-05-15 00:52:35 +04:00
struct throtl_service_queue * sq = & tg - > service_queue ;
2010-09-16 01:06:35 +04:00
unsigned long read_wait = - 1 , write_wait = - 1 , min_wait = - 1 , disptime ;
struct bio * bio ;
2017-01-22 00:15:33 +03:00
bio = throtl_peek_queued ( & sq - > queued [ READ ] ) ;
if ( bio )
2013-05-15 00:52:32 +04:00
tg_may_dispatch ( tg , bio , & read_wait ) ;
2010-09-16 01:06:35 +04:00
2017-01-22 00:15:33 +03:00
bio = throtl_peek_queued ( & sq - > queued [ WRITE ] ) ;
if ( bio )
2013-05-15 00:52:32 +04:00
tg_may_dispatch ( tg , bio , & write_wait ) ;
2010-09-16 01:06:35 +04:00
min_wait = min ( read_wait , write_wait ) ;
disptime = jiffies + min_wait ;
/* Update dispatch time */
2013-05-15 00:52:36 +04:00
throtl_dequeue_tg ( tg ) ;
2010-09-16 01:06:35 +04:00
tg - > disptime = disptime ;
2013-05-15 00:52:36 +04:00
throtl_enqueue_tg ( tg ) ;
2013-05-15 00:52:35 +04:00
/* see throtl_add_bio_tg() */
tg - > flags & = ~ THROTL_TG_WAS_EMPTY ;
2010-09-16 01:06:35 +04:00
}
blk-throttle: Account for child group's start time in parent while bio climbs up
With the planned proper hierarchy support, a bio will climb up the
tree before actually being dispatched. This makes sure bio is also
subjected to parent's throttling limits, if any.
It might happen that parent is idle and when bio is transferred to
parent, a new slice starts fresh. But that is incorrect as parents
wait time should have started when bio was queued in child group and
causes IOs to be throttled more than configured as they climb the
hierarchy.
Given the fact that we have not written hierarchical algorithm in a
way where child's and parents time slices are synchronized, we
transfer the child's start time to parent if parent was idling. If
parent was busy doing dispatch of other bios all this while, this is
not an issue.
Child's slice start time is passed to parent. Parent looks at its
last expired slice start time. If child's start time is after parents
old start time, that means parent had been idle and after parent
went idle, child had an IO queued. So use child's start time as
parent start time.
If parent's start time is after child's start time, that means,
when IO got queued in child group, parent was not idle. But later
it dispatched some IO, its slice got trimmed and then it went idle.
After a while child's request got shifted in parent group. In this
case use parent's old start time as new start time as that's the
duration of slice we did not use.
This logic is far from perfect as if there are multiple childs
then first child transferring the bio decides the start time while
a bio might have queued up even earlier in other child, which is
yet to be transferred up to parent. In that case we will lose
time and bandwidth in parent. This patch is just an approximation
to make situation somewhat better.
Signed-off-by: Vivek Goyal <vgoyal@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-05-15 00:52:38 +04:00
static void start_parent_slice_with_credit ( struct throtl_grp * child_tg ,
struct throtl_grp * parent_tg , bool rw )
{
if ( throtl_slice_used ( parent_tg , rw ) ) {
throtl_start_new_slice_with_credit ( parent_tg , rw ,
child_tg - > slice_start [ rw ] ) ;
}
}
2013-05-15 00:52:36 +04:00
static void tg_dispatch_one_bio ( struct throtl_grp * tg , bool rw )
2010-09-16 01:06:35 +04:00
{
2013-05-15 00:52:35 +04:00
struct throtl_service_queue * sq = & tg - > service_queue ;
2013-05-15 00:52:38 +04:00
struct throtl_service_queue * parent_sq = sq - > parent_sq ;
struct throtl_grp * parent_tg = sq_to_tg ( parent_sq ) ;
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
struct throtl_grp * tg_to_put = NULL ;
2010-09-16 01:06:35 +04:00
struct bio * bio ;
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
/*
* @ bio is being transferred from @ tg to @ parent_sq . Popping a bio
* from @ tg may put its reference and @ parent_sq might end up
* getting released prematurely . Remember the tg to put and put it
* after @ bio is transferred to @ parent_sq .
*/
bio = throtl_pop_queued ( & sq - > queued [ rw ] , & tg_to_put ) ;
2013-05-15 00:52:35 +04:00
sq - > nr_queued [ rw ] - - ;
2010-09-16 01:06:35 +04:00
throtl_charge_bio ( tg , bio ) ;
2013-05-15 00:52:38 +04:00
/*
* If our parent is another tg , we just need to transfer @ bio to
* the parent using throtl_add_bio_tg ( ) . If our parent is
* @ td - > service_queue , @ bio is ready to be issued . Put it on its
* bio_lists [ ] and decrease total number queued . The caller is
* responsible for issuing these bios .
*/
if ( parent_tg ) {
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
throtl_add_bio_tg ( bio , & tg - > qnode_on_parent [ rw ] , parent_tg ) ;
blk-throttle: Account for child group's start time in parent while bio climbs up
With the planned proper hierarchy support, a bio will climb up the
tree before actually being dispatched. This makes sure bio is also
subjected to parent's throttling limits, if any.
It might happen that parent is idle and when bio is transferred to
parent, a new slice starts fresh. But that is incorrect as parents
wait time should have started when bio was queued in child group and
causes IOs to be throttled more than configured as they climb the
hierarchy.
Given the fact that we have not written hierarchical algorithm in a
way where child's and parents time slices are synchronized, we
transfer the child's start time to parent if parent was idling. If
parent was busy doing dispatch of other bios all this while, this is
not an issue.
Child's slice start time is passed to parent. Parent looks at its
last expired slice start time. If child's start time is after parents
old start time, that means parent had been idle and after parent
went idle, child had an IO queued. So use child's start time as
parent start time.
If parent's start time is after child's start time, that means,
when IO got queued in child group, parent was not idle. But later
it dispatched some IO, its slice got trimmed and then it went idle.
After a while child's request got shifted in parent group. In this
case use parent's old start time as new start time as that's the
duration of slice we did not use.
This logic is far from perfect as if there are multiple childs
then first child transferring the bio decides the start time while
a bio might have queued up even earlier in other child, which is
yet to be transferred up to parent. In that case we will lose
time and bandwidth in parent. This patch is just an approximation
to make situation somewhat better.
Signed-off-by: Vivek Goyal <vgoyal@redhat.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2013-05-15 00:52:38 +04:00
start_parent_slice_with_credit ( tg , parent_tg , rw ) ;
2013-05-15 00:52:38 +04:00
} else {
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
throtl_qnode_add_bio ( bio , & tg - > qnode_on_parent [ rw ] ,
& parent_sq - > queued [ rw ] ) ;
2013-05-15 00:52:38 +04:00
BUG_ON ( tg - > td - > nr_queued [ rw ] < = 0 ) ;
tg - > td - > nr_queued [ rw ] - - ;
}
2010-09-16 01:06:35 +04:00
2013-05-15 00:52:32 +04:00
throtl_trim_slice ( tg , rw ) ;
2013-05-15 00:52:38 +04:00
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
if ( tg_to_put )
blkg_put ( tg_to_blkg ( tg_to_put ) ) ;
2010-09-16 01:06:35 +04:00
}
2013-05-15 00:52:36 +04:00
static int throtl_dispatch_tg ( struct throtl_grp * tg )
2010-09-16 01:06:35 +04:00
{
2013-05-15 00:52:35 +04:00
struct throtl_service_queue * sq = & tg - > service_queue ;
2010-09-16 01:06:35 +04:00
unsigned int nr_reads = 0 , nr_writes = 0 ;
unsigned int max_nr_reads = throtl_grp_quantum * 3 / 4 ;
2010-11-15 21:32:42 +03:00
unsigned int max_nr_writes = throtl_grp_quantum - max_nr_reads ;
2010-09-16 01:06:35 +04:00
struct bio * bio ;
/* Try to dispatch 75% READS and 25% WRITES */
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
while ( ( bio = throtl_peek_queued ( & sq - > queued [ READ ] ) ) & &
2013-05-15 00:52:32 +04:00
tg_may_dispatch ( tg , bio , NULL ) ) {
2010-09-16 01:06:35 +04:00
2013-05-15 00:52:36 +04:00
tg_dispatch_one_bio ( tg , bio_data_dir ( bio ) ) ;
2010-09-16 01:06:35 +04:00
nr_reads + + ;
if ( nr_reads > = max_nr_reads )
break ;
}
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
while ( ( bio = throtl_peek_queued ( & sq - > queued [ WRITE ] ) ) & &
2013-05-15 00:52:32 +04:00
tg_may_dispatch ( tg , bio , NULL ) ) {
2010-09-16 01:06:35 +04:00
2013-05-15 00:52:36 +04:00
tg_dispatch_one_bio ( tg , bio_data_dir ( bio ) ) ;
2010-09-16 01:06:35 +04:00
nr_writes + + ;
if ( nr_writes > = max_nr_writes )
break ;
}
return nr_reads + nr_writes ;
}
2013-05-15 00:52:35 +04:00
static int throtl_select_dispatch ( struct throtl_service_queue * parent_sq )
2010-09-16 01:06:35 +04:00
{
unsigned int nr_disp = 0 ;
while ( 1 ) {
2013-05-15 00:52:35 +04:00
struct throtl_grp * tg = throtl_rb_first ( parent_sq ) ;
struct throtl_service_queue * sq = & tg - > service_queue ;
2010-09-16 01:06:35 +04:00
if ( ! tg )
break ;
if ( time_before ( jiffies , tg - > disptime ) )
break ;
2013-05-15 00:52:36 +04:00
throtl_dequeue_tg ( tg ) ;
2010-09-16 01:06:35 +04:00
2013-05-15 00:52:36 +04:00
nr_disp + = throtl_dispatch_tg ( tg ) ;
2010-09-16 01:06:35 +04:00
2013-05-15 00:52:35 +04:00
if ( sq - > nr_queued [ 0 ] | | sq - > nr_queued [ 1 ] )
2013-05-15 00:52:36 +04:00
tg_update_disptime ( tg ) ;
2010-09-16 01:06:35 +04:00
if ( nr_disp > = throtl_quantum )
break ;
}
return nr_disp ;
}
2013-05-15 00:52:37 +04:00
/**
* throtl_pending_timer_fn - timer function for service_queue - > pending_timer
* @ arg : the throtl_service_queue being serviced
*
* This timer is armed when a child throtl_grp with active bio ' s become
* pending and queued on the service_queue ' s pending_tree and expires when
* the first child throtl_grp should be dispatched . This function
2013-05-15 00:52:38 +04:00
* dispatches bio ' s from the children throtl_grps to the parent
* service_queue .
*
* If the parent ' s parent is another throtl_grp , dispatching is propagated
* by either arming its pending_timer or repeating dispatch directly . If
* the top - level service_tree is reached , throtl_data - > dispatch_work is
* kicked so that the ready bio ' s are issued .
2013-05-15 00:52:37 +04:00
*/
2013-05-15 00:52:36 +04:00
static void throtl_pending_timer_fn ( unsigned long arg )
{
struct throtl_service_queue * sq = ( void * ) arg ;
2013-05-15 00:52:38 +04:00
struct throtl_grp * tg = sq_to_tg ( sq ) ;
2013-05-15 00:52:36 +04:00
struct throtl_data * td = sq_to_td ( sq ) ;
2013-05-15 00:52:31 +04:00
struct request_queue * q = td - > queue ;
2013-05-15 00:52:38 +04:00
struct throtl_service_queue * parent_sq ;
bool dispatched ;
2013-05-15 00:52:37 +04:00
int ret ;
2010-09-16 01:06:35 +04:00
spin_lock_irq ( q - > queue_lock ) ;
2013-05-15 00:52:38 +04:00
again :
parent_sq = sq - > parent_sq ;
dispatched = false ;
2010-09-16 01:06:35 +04:00
2013-05-15 00:52:37 +04:00
while ( true ) {
throtl_log ( sq , " dispatch nr_queued=%u read=%u write=%u " ,
2013-05-15 00:52:38 +04:00
sq - > nr_queued [ READ ] + sq - > nr_queued [ WRITE ] ,
sq - > nr_queued [ READ ] , sq - > nr_queued [ WRITE ] ) ;
2013-05-15 00:52:37 +04:00
ret = throtl_select_dispatch ( sq ) ;
if ( ret ) {
throtl_log ( sq , " bios disp=%u " , ret ) ;
dispatched = true ;
}
2010-09-16 01:06:35 +04:00
2013-05-15 00:52:37 +04:00
if ( throtl_schedule_next_dispatch ( sq , false ) )
break ;
2010-09-16 01:06:35 +04:00
2013-05-15 00:52:37 +04:00
/* this dispatch windows is still open, relax and repeat */
spin_unlock_irq ( q - > queue_lock ) ;
cpu_relax ( ) ;
spin_lock_irq ( q - > queue_lock ) ;
2013-05-15 00:52:35 +04:00
}
2010-09-16 01:06:35 +04:00
2013-05-15 00:52:38 +04:00
if ( ! dispatched )
goto out_unlock ;
2013-05-15 00:52:37 +04:00
2013-05-15 00:52:38 +04:00
if ( parent_sq ) {
/* @parent_sq is another throl_grp, propagate dispatch */
if ( tg - > flags & THROTL_TG_WAS_EMPTY ) {
tg_update_disptime ( tg ) ;
if ( ! throtl_schedule_next_dispatch ( parent_sq , false ) ) {
/* window is already open, repeat dispatching */
sq = parent_sq ;
tg = sq_to_tg ( sq ) ;
goto again ;
}
}
} else {
/* reached the top-level, queue issueing */
queue_work ( kthrotld_workqueue , & td - > dispatch_work ) ;
}
out_unlock :
2010-09-16 01:06:35 +04:00
spin_unlock_irq ( q - > queue_lock ) ;
2013-05-15 00:52:37 +04:00
}
2010-09-16 01:06:35 +04:00
2013-05-15 00:52:37 +04:00
/**
* blk_throtl_dispatch_work_fn - work function for throtl_data - > dispatch_work
* @ work : work item being executed
*
* This function is queued for execution when bio ' s reach the bio_lists [ ]
* of throtl_data - > service_queue . Those bio ' s are ready and issued by this
* function .
*/
2014-04-17 23:41:16 +04:00
static void blk_throtl_dispatch_work_fn ( struct work_struct * work )
2013-05-15 00:52:37 +04:00
{
struct throtl_data * td = container_of ( work , struct throtl_data ,
dispatch_work ) ;
struct throtl_service_queue * td_sq = & td - > service_queue ;
struct request_queue * q = td - > queue ;
struct bio_list bio_list_on_stack ;
struct bio * bio ;
struct blk_plug plug ;
int rw ;
bio_list_init ( & bio_list_on_stack ) ;
spin_lock_irq ( q - > queue_lock ) ;
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
for ( rw = READ ; rw < = WRITE ; rw + + )
while ( ( bio = throtl_pop_queued ( & td_sq - > queued [ rw ] , NULL ) ) )
bio_list_add ( & bio_list_on_stack , bio ) ;
2013-05-15 00:52:37 +04:00
spin_unlock_irq ( q - > queue_lock ) ;
if ( ! bio_list_empty ( & bio_list_on_stack ) ) {
2011-03-09 10:27:37 +03:00
blk_start_plug ( & plug ) ;
2010-09-16 01:06:35 +04:00
while ( ( bio = bio_list_pop ( & bio_list_on_stack ) ) )
generic_make_request ( bio ) ;
2011-03-09 10:27:37 +03:00
blk_finish_plug ( & plug ) ;
2010-09-16 01:06:35 +04:00
}
}
2012-04-17 00:57:26 +04:00
static u64 tg_prfill_conf_u64 ( struct seq_file * sf , struct blkg_policy_data * pd ,
int off )
2012-04-02 01:38:43 +04:00
{
2012-04-17 00:57:26 +04:00
struct throtl_grp * tg = pd_to_tg ( pd ) ;
u64 v = * ( u64 * ) ( ( void * ) tg + off ) ;
2012-04-02 01:38:43 +04:00
2017-03-27 20:51:29 +03:00
if ( v = = U64_MAX )
2012-04-02 01:38:43 +04:00
return 0 ;
2012-04-17 00:57:26 +04:00
return __blkg_prfill_u64 ( sf , pd , v ) ;
2012-04-02 01:38:43 +04:00
}
2012-04-17 00:57:26 +04:00
static u64 tg_prfill_conf_uint ( struct seq_file * sf , struct blkg_policy_data * pd ,
int off )
2010-09-16 01:06:35 +04:00
{
2012-04-17 00:57:26 +04:00
struct throtl_grp * tg = pd_to_tg ( pd ) ;
unsigned int v = * ( unsigned int * ) ( ( void * ) tg + off ) ;
2010-10-01 16:49:49 +04:00
2017-03-27 20:51:29 +03:00
if ( v = = UINT_MAX )
2012-04-02 01:38:44 +04:00
return 0 ;
2012-04-17 00:57:26 +04:00
return __blkg_prfill_u64 ( sf , pd , v ) ;
2010-09-16 01:06:35 +04:00
}
2013-12-05 21:28:04 +04:00
static int tg_print_conf_u64 ( struct seq_file * sf , void * v )
2010-09-16 01:06:37 +04:00
{
2013-12-05 21:28:04 +04:00
blkcg_print_blkgs ( sf , css_to_blkcg ( seq_css ( sf ) ) , tg_prfill_conf_u64 ,
& blkcg_policy_throtl , seq_cft ( sf ) - > private , false ) ;
2012-04-02 01:38:44 +04:00
return 0 ;
2010-09-16 01:06:37 +04:00
}
2013-12-05 21:28:04 +04:00
static int tg_print_conf_uint ( struct seq_file * sf , void * v )
2010-09-16 01:06:37 +04:00
{
2013-12-05 21:28:04 +04:00
blkcg_print_blkgs ( sf , css_to_blkcg ( seq_css ( sf ) ) , tg_prfill_conf_uint ,
& blkcg_policy_throtl , seq_cft ( sf ) - > private , false ) ;
2012-04-02 01:38:44 +04:00
return 0 ;
2012-04-02 01:38:43 +04:00
}
2015-08-19 00:55:32 +03:00
static void tg_conf_updated ( struct throtl_grp * tg )
2012-04-02 01:38:43 +04:00
{
2015-08-19 00:55:32 +03:00
struct throtl_service_queue * sq = & tg - > service_queue ;
2013-08-09 04:11:25 +04:00
struct cgroup_subsys_state * pos_css ;
2015-08-19 00:55:32 +03:00
struct blkcg_gq * blkg ;
2012-04-02 01:38:44 +04:00
2013-05-15 00:52:36 +04:00
throtl_log ( & tg - > service_queue ,
" limit change rbps=%llu wbps=%llu riops=%u wiops=%u " ,
2017-03-27 20:51:30 +03:00
tg_bps_limit ( tg , READ ) , tg_bps_limit ( tg , WRITE ) ,
tg_iops_limit ( tg , READ ) , tg_iops_limit ( tg , WRITE ) ) ;
2013-05-15 00:52:31 +04:00
2013-05-15 00:52:38 +04:00
/*
* Update has_rules [ ] flags for the updated tg ' s subtree . A tg is
* considered to have rules if either the tg itself or any of its
* ancestors has rules . This identifies groups without any
* restrictions in the whole hierarchy and allows them to bypass
* blk - throttle .
*/
2015-08-19 00:55:32 +03:00
blkg_for_each_descendant_pre ( blkg , pos_css , tg_to_blkg ( tg ) )
2013-05-15 00:52:38 +04:00
tg_update_has_rules ( blkg_to_tg ( blkg ) ) ;
2013-05-15 00:52:31 +04:00
/*
* We ' re already holding queue_lock and know @ tg is valid . Let ' s
* apply the new config directly .
*
* 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 .
*/
2013-05-15 00:52:32 +04:00
throtl_start_new_slice ( tg , 0 ) ;
throtl_start_new_slice ( tg , 1 ) ;
2013-05-15 00:52:31 +04:00
2013-05-15 00:52:32 +04:00
if ( tg - > flags & THROTL_TG_PENDING ) {
2013-05-15 00:52:36 +04:00
tg_update_disptime ( tg ) ;
2013-05-15 00:52:37 +04:00
throtl_schedule_next_dispatch ( sq - > parent_sq , true ) ;
2013-05-15 00:52:31 +04:00
}
2015-08-19 00:55:32 +03:00
}
static ssize_t tg_set_conf ( struct kernfs_open_file * of ,
char * buf , size_t nbytes , loff_t off , bool is_u64 )
{
struct blkcg * blkcg = css_to_blkcg ( of_css ( of ) ) ;
struct blkg_conf_ctx ctx ;
struct throtl_grp * tg ;
int ret ;
u64 v ;
ret = blkg_conf_prep ( blkcg , & blkcg_policy_throtl , buf , & ctx ) ;
if ( ret )
return ret ;
ret = - EINVAL ;
if ( sscanf ( ctx . body , " %llu " , & v ) ! = 1 )
goto out_finish ;
if ( ! v )
2017-03-27 20:51:29 +03:00
v = U64_MAX ;
2015-08-19 00:55:32 +03:00
tg = blkg_to_tg ( ctx . blkg ) ;
if ( is_u64 )
* ( u64 * ) ( ( void * ) tg + of_cft ( of ) - > private ) = v ;
else
* ( unsigned int * ) ( ( void * ) tg + of_cft ( of ) - > private ) = v ;
2012-04-02 01:38:43 +04:00
2015-08-19 00:55:32 +03:00
tg_conf_updated ( tg ) ;
2015-08-19 00:55:31 +03:00
ret = 0 ;
out_finish :
2012-04-02 01:38:43 +04:00
blkg_conf_finish ( & ctx ) ;
2015-08-19 00:55:31 +03:00
return ret ? : nbytes ;
2010-09-16 01:06:37 +04:00
}
2014-05-13 20:16:21 +04:00
static ssize_t tg_set_conf_u64 ( struct kernfs_open_file * of ,
char * buf , size_t nbytes , loff_t off )
2012-04-02 01:38:43 +04:00
{
2014-05-13 20:16:21 +04:00
return tg_set_conf ( of , buf , nbytes , off , true ) ;
2012-04-02 01:38:43 +04:00
}
2014-05-13 20:16:21 +04:00
static ssize_t tg_set_conf_uint ( struct kernfs_open_file * of ,
char * buf , size_t nbytes , loff_t off )
2012-04-02 01:38:43 +04:00
{
2014-05-13 20:16:21 +04:00
return tg_set_conf ( of , buf , nbytes , off , false ) ;
2012-04-02 01:38:43 +04:00
}
2015-08-19 00:55:30 +03:00
static struct cftype throtl_legacy_files [ ] = {
2012-04-02 01:38:43 +04:00
{
. name = " throttle.read_bps_device " ,
2017-03-27 20:51:30 +03:00
. private = offsetof ( struct throtl_grp , bps [ READ ] [ LIMIT_MAX ] ) ,
2013-12-05 21:28:04 +04:00
. seq_show = tg_print_conf_u64 ,
2014-05-13 20:16:21 +04:00
. write = tg_set_conf_u64 ,
2012-04-02 01:38:43 +04:00
} ,
{
. name = " throttle.write_bps_device " ,
2017-03-27 20:51:30 +03:00
. private = offsetof ( struct throtl_grp , bps [ WRITE ] [ LIMIT_MAX ] ) ,
2013-12-05 21:28:04 +04:00
. seq_show = tg_print_conf_u64 ,
2014-05-13 20:16:21 +04:00
. write = tg_set_conf_u64 ,
2012-04-02 01:38:43 +04:00
} ,
{
. name = " throttle.read_iops_device " ,
2017-03-27 20:51:30 +03:00
. private = offsetof ( struct throtl_grp , iops [ READ ] [ LIMIT_MAX ] ) ,
2013-12-05 21:28:04 +04:00
. seq_show = tg_print_conf_uint ,
2014-05-13 20:16:21 +04:00
. write = tg_set_conf_uint ,
2012-04-02 01:38:43 +04:00
} ,
{
. name = " throttle.write_iops_device " ,
2017-03-27 20:51:30 +03:00
. private = offsetof ( struct throtl_grp , iops [ WRITE ] [ LIMIT_MAX ] ) ,
2013-12-05 21:28:04 +04:00
. seq_show = tg_print_conf_uint ,
2014-05-13 20:16:21 +04:00
. write = tg_set_conf_uint ,
2012-04-02 01:38:43 +04:00
} ,
{
. name = " throttle.io_service_bytes " ,
2015-08-19 00:55:24 +03:00
. private = ( unsigned long ) & blkcg_policy_throtl ,
. seq_show = blkg_print_stat_bytes ,
2012-04-02 01:38:43 +04:00
} ,
{
. name = " throttle.io_serviced " ,
2015-08-19 00:55:24 +03:00
. private = ( unsigned long ) & blkcg_policy_throtl ,
. seq_show = blkg_print_stat_ios ,
2012-04-02 01:38:43 +04:00
} ,
{ } /* terminate */
} ;
2017-03-27 20:51:32 +03:00
static u64 tg_prfill_limit ( struct seq_file * sf , struct blkg_policy_data * pd ,
2015-08-19 00:55:34 +03:00
int off )
{
struct throtl_grp * tg = pd_to_tg ( pd ) ;
const char * dname = blkg_dev_name ( pd - > blkg ) ;
char bufs [ 4 ] [ 21 ] = { " max " , " max " , " max " , " max " } ;
2017-03-27 20:51:32 +03:00
u64 bps_dft ;
unsigned int iops_dft ;
2015-08-19 00:55:34 +03:00
if ( ! dname )
return 0 ;
2017-03-27 20:51:30 +03:00
2017-03-27 20:51:32 +03:00
if ( off = = LIMIT_LOW ) {
bps_dft = 0 ;
iops_dft = 0 ;
} else {
bps_dft = U64_MAX ;
iops_dft = UINT_MAX ;
}
if ( tg - > bps_conf [ READ ] [ off ] = = bps_dft & &
tg - > bps_conf [ WRITE ] [ off ] = = bps_dft & &
tg - > iops_conf [ READ ] [ off ] = = iops_dft & &
tg - > iops_conf [ WRITE ] [ off ] = = iops_dft )
2015-08-19 00:55:34 +03:00
return 0 ;
2017-03-27 20:51:32 +03:00
if ( tg - > bps_conf [ READ ] [ off ] ! = bps_dft )
2017-03-27 20:51:30 +03:00
snprintf ( bufs [ 0 ] , sizeof ( bufs [ 0 ] ) , " %llu " ,
2017-03-27 20:51:32 +03:00
tg - > bps_conf [ READ ] [ off ] ) ;
if ( tg - > bps_conf [ WRITE ] [ off ] ! = bps_dft )
2017-03-27 20:51:30 +03:00
snprintf ( bufs [ 1 ] , sizeof ( bufs [ 1 ] ) , " %llu " ,
2017-03-27 20:51:32 +03:00
tg - > bps_conf [ WRITE ] [ off ] ) ;
if ( tg - > iops_conf [ READ ] [ off ] ! = iops_dft )
2017-03-27 20:51:30 +03:00
snprintf ( bufs [ 2 ] , sizeof ( bufs [ 2 ] ) , " %u " ,
2017-03-27 20:51:32 +03:00
tg - > iops_conf [ READ ] [ off ] ) ;
if ( tg - > iops_conf [ WRITE ] [ off ] ! = iops_dft )
2017-03-27 20:51:30 +03:00
snprintf ( bufs [ 3 ] , sizeof ( bufs [ 3 ] ) , " %u " ,
2017-03-27 20:51:32 +03:00
tg - > iops_conf [ WRITE ] [ off ] ) ;
2015-08-19 00:55:34 +03:00
seq_printf ( sf , " %s rbps=%s wbps=%s riops=%s wiops=%s \n " ,
dname , bufs [ 0 ] , bufs [ 1 ] , bufs [ 2 ] , bufs [ 3 ] ) ;
return 0 ;
}
2017-03-27 20:51:32 +03:00
static int tg_print_limit ( struct seq_file * sf , void * v )
2015-08-19 00:55:34 +03:00
{
2017-03-27 20:51:32 +03:00
blkcg_print_blkgs ( sf , css_to_blkcg ( seq_css ( sf ) ) , tg_prfill_limit ,
2015-08-19 00:55:34 +03:00
& blkcg_policy_throtl , seq_cft ( sf ) - > private , false ) ;
return 0 ;
}
2017-03-27 20:51:32 +03:00
static ssize_t tg_set_limit ( struct kernfs_open_file * of ,
2015-08-19 00:55:34 +03:00
char * buf , size_t nbytes , loff_t off )
{
struct blkcg * blkcg = css_to_blkcg ( of_css ( of ) ) ;
struct blkg_conf_ctx ctx ;
struct throtl_grp * tg ;
u64 v [ 4 ] ;
int ret ;
2017-03-27 20:51:32 +03:00
int index = of_cft ( of ) - > private ;
2015-08-19 00:55:34 +03:00
ret = blkg_conf_prep ( blkcg , & blkcg_policy_throtl , buf , & ctx ) ;
if ( ret )
return ret ;
tg = blkg_to_tg ( ctx . blkg ) ;
2017-03-27 20:51:32 +03:00
v [ 0 ] = tg - > bps_conf [ READ ] [ index ] ;
v [ 1 ] = tg - > bps_conf [ WRITE ] [ index ] ;
v [ 2 ] = tg - > iops_conf [ READ ] [ index ] ;
v [ 3 ] = tg - > iops_conf [ WRITE ] [ index ] ;
2015-08-19 00:55:34 +03:00
while ( true ) {
char tok [ 27 ] ; /* wiops=18446744073709551616 */
char * p ;
2017-03-27 20:51:29 +03:00
u64 val = U64_MAX ;
2015-08-19 00:55:34 +03:00
int len ;
if ( sscanf ( ctx . body , " %26s%n " , tok , & len ) ! = 1 )
break ;
if ( tok [ 0 ] = = ' \0 ' )
break ;
ctx . body + = len ;
ret = - EINVAL ;
p = tok ;
strsep ( & p , " = " ) ;
if ( ! p | | ( sscanf ( p , " %llu " , & val ) ! = 1 & & strcmp ( p , " max " ) ) )
goto out_finish ;
ret = - ERANGE ;
if ( ! val )
goto out_finish ;
ret = - EINVAL ;
if ( ! strcmp ( tok , " rbps " ) )
v [ 0 ] = val ;
else if ( ! strcmp ( tok , " wbps " ) )
v [ 1 ] = val ;
else if ( ! strcmp ( tok , " riops " ) )
v [ 2 ] = min_t ( u64 , val , UINT_MAX ) ;
else if ( ! strcmp ( tok , " wiops " ) )
v [ 3 ] = min_t ( u64 , val , UINT_MAX ) ;
else
goto out_finish ;
}
2017-03-27 20:51:32 +03:00
tg - > bps_conf [ READ ] [ index ] = v [ 0 ] ;
tg - > bps_conf [ WRITE ] [ index ] = v [ 1 ] ;
tg - > iops_conf [ READ ] [ index ] = v [ 2 ] ;
tg - > iops_conf [ WRITE ] [ index ] = v [ 3 ] ;
2015-08-19 00:55:34 +03:00
2017-03-27 20:51:32 +03:00
if ( index = = LIMIT_MAX ) {
tg - > bps [ READ ] [ index ] = v [ 0 ] ;
tg - > bps [ WRITE ] [ index ] = v [ 1 ] ;
tg - > iops [ READ ] [ index ] = v [ 2 ] ;
tg - > iops [ WRITE ] [ index ] = v [ 3 ] ;
}
tg - > bps [ READ ] [ LIMIT_LOW ] = min ( tg - > bps_conf [ READ ] [ LIMIT_LOW ] ,
tg - > bps_conf [ READ ] [ LIMIT_MAX ] ) ;
tg - > bps [ WRITE ] [ LIMIT_LOW ] = min ( tg - > bps_conf [ WRITE ] [ LIMIT_LOW ] ,
tg - > bps_conf [ WRITE ] [ LIMIT_MAX ] ) ;
tg - > iops [ READ ] [ LIMIT_LOW ] = min ( tg - > iops_conf [ READ ] [ LIMIT_LOW ] ,
tg - > iops_conf [ READ ] [ LIMIT_MAX ] ) ;
tg - > iops [ WRITE ] [ LIMIT_LOW ] = min ( tg - > iops_conf [ WRITE ] [ LIMIT_LOW ] ,
tg - > iops_conf [ WRITE ] [ LIMIT_MAX ] ) ;
if ( index = = LIMIT_LOW ) {
blk_throtl_update_limit_valid ( tg - > td ) ;
if ( tg - > td - > limit_valid [ LIMIT_LOW ] )
tg - > td - > limit_index = LIMIT_LOW ;
}
2015-08-19 00:55:34 +03:00
tg_conf_updated ( tg ) ;
ret = 0 ;
out_finish :
blkg_conf_finish ( & ctx ) ;
return ret ? : nbytes ;
}
static struct cftype throtl_files [ ] = {
2017-03-27 20:51:32 +03:00
# ifdef CONFIG_BLK_DEV_THROTTLING_LOW
{
. name = " low " ,
. flags = CFTYPE_NOT_ON_ROOT ,
. seq_show = tg_print_limit ,
. write = tg_set_limit ,
. private = LIMIT_LOW ,
} ,
# endif
2015-08-19 00:55:34 +03:00
{
. name = " max " ,
. flags = CFTYPE_NOT_ON_ROOT ,
2017-03-27 20:51:32 +03:00
. seq_show = tg_print_limit ,
. write = tg_set_limit ,
. private = LIMIT_MAX ,
2015-08-19 00:55:34 +03:00
} ,
{ } /* terminate */
} ;
2011-03-03 03:05:33 +03:00
static void throtl_shutdown_wq ( struct request_queue * q )
2010-09-16 01:06:35 +04:00
{
struct throtl_data * td = q - > td ;
2013-05-15 00:52:36 +04:00
cancel_work_sync ( & td - > dispatch_work ) ;
2010-09-16 01:06:35 +04:00
}
2012-04-17 00:57:25 +04:00
static struct blkcg_policy blkcg_policy_throtl = {
2015-08-19 00:55:34 +03:00
. dfl_cftypes = throtl_files ,
2015-08-19 00:55:30 +03:00
. legacy_cftypes = throtl_legacy_files ,
2012-04-17 00:57:27 +04:00
2015-08-19 00:55:11 +03:00
. pd_alloc_fn = throtl_pd_alloc ,
2012-04-17 00:57:27 +04:00
. pd_init_fn = throtl_pd_init ,
2013-05-15 00:52:38 +04:00
. pd_online_fn = throtl_pd_online ,
2017-03-27 20:51:32 +03:00
. pd_offline_fn = throtl_pd_offline ,
2015-08-19 00:55:11 +03:00
. pd_free_fn = throtl_pd_free ,
2010-09-16 01:06:35 +04:00
} ;
2015-08-19 00:55:20 +03:00
bool blk_throtl_bio ( struct request_queue * q , struct blkcg_gq * blkg ,
struct bio * bio )
2010-09-16 01:06:35 +04:00
{
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
struct throtl_qnode * qn = NULL ;
2015-08-19 00:55:20 +03:00
struct throtl_grp * tg = blkg_to_tg ( blkg ? : q - > root_blkg ) ;
2013-05-15 00:52:35 +04:00
struct throtl_service_queue * sq ;
2013-05-15 00:52:35 +04:00
bool rw = bio_data_dir ( bio ) ;
2011-10-19 16:33:01 +04:00
bool throttled = false ;
2010-09-16 01:06:35 +04:00
2015-08-19 00:55:20 +03:00
WARN_ON_ONCE ( ! rcu_read_lock_held ( ) ) ;
2013-05-15 00:52:36 +04:00
/* see throtl_charge_bio() */
2016-10-20 16:12:12 +03:00
if ( bio_flagged ( bio , BIO_THROTTLED ) | | ! tg - > has_rules [ rw ] )
2011-10-19 16:33:01 +04:00
goto out ;
2010-09-16 01:06:35 +04:00
spin_lock_irq ( q - > queue_lock ) ;
2015-08-19 00:55:19 +03:00
if ( unlikely ( blk_queue_bypass ( q ) ) )
2011-10-19 16:33:01 +04:00
goto out_unlock ;
2011-05-19 23:38:23 +04:00
2013-05-15 00:52:35 +04:00
sq = & tg - > service_queue ;
2013-05-15 00:52:38 +04:00
while ( true ) {
/* throtl is FIFO - if bios are already queued, should queue */
if ( sq - > nr_queued [ rw ] )
break ;
2011-03-07 23:09:32 +03:00
2013-05-15 00:52:38 +04:00
/* if above limits, break to queue */
if ( ! tg_may_dispatch ( tg , bio , NULL ) )
break ;
/* within limits, let's charge and dispatch directly */
2010-09-16 01:06:35 +04:00
throtl_charge_bio ( tg , bio ) ;
2011-03-22 23:54:29 +03: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 .
*/
2013-05-15 00:52:32 +04:00
throtl_trim_slice ( tg , rw ) ;
2013-05-15 00:52:38 +04:00
/*
* @ bio passed through this layer without being throttled .
* Climb up the ladder . If we ' ' re already at the top , it
* can be executed directly .
*/
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
qn = & tg - > qnode_on_parent [ rw ] ;
2013-05-15 00:52:38 +04:00
sq = sq - > parent_sq ;
tg = sq_to_tg ( sq ) ;
if ( ! tg )
goto out_unlock ;
2010-09-16 01:06:35 +04:00
}
2013-05-15 00:52:38 +04:00
/* out-of-limit, queue to @tg */
2013-05-15 00:52:36 +04:00
throtl_log ( sq , " [%c] bio. bdisp=%llu sz=%u bps=%llu iodisp=%u iops=%u queued=%d/%d " ,
rw = = READ ? ' R ' : ' W ' ,
2017-03-27 20:51:30 +03:00
tg - > bytes_disp [ rw ] , bio - > bi_iter . bi_size ,
tg_bps_limit ( tg , rw ) ,
tg - > io_disp [ rw ] , tg_iops_limit ( tg , rw ) ,
2013-05-15 00:52:36 +04:00
sq - > nr_queued [ READ ] , sq - > nr_queued [ WRITE ] ) ;
2010-09-16 01:06:35 +04:00
2012-03-06 01:15:29 +04:00
bio_associate_current ( bio ) ;
2013-05-15 00:52:38 +04:00
tg - > td - > nr_queued [ rw ] + + ;
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
throtl_add_bio_tg ( bio , qn , tg ) ;
2011-10-19 16:33:01 +04:00
throttled = true ;
2010-09-16 01:06:35 +04:00
2013-05-15 00:52:37 +04:00
/*
* Update @ tg ' s dispatch time and force schedule dispatch if @ tg
* was empty before @ bio . The forced scheduling isn ' t likely to
* cause undue delay as @ bio is likely to be dispatched directly if
* its @ tg ' s disptime is not in the future .
*/
2013-05-15 00:52:35 +04:00
if ( tg - > flags & THROTL_TG_WAS_EMPTY ) {
2013-05-15 00:52:36 +04:00
tg_update_disptime ( tg ) ;
2013-05-15 00:52:37 +04:00
throtl_schedule_next_dispatch ( tg - > service_queue . parent_sq , true ) ;
2010-09-16 01:06:35 +04:00
}
2011-10-19 16:33:01 +04:00
out_unlock :
2010-09-16 01:06:35 +04:00
spin_unlock_irq ( q - > queue_lock ) ;
2011-10-19 16:33:01 +04:00
out :
2013-05-15 00:52:36 +04:00
/*
* As multiple blk - throtls may stack in the same issue path , we
* don ' t want bios to leave with the flag set . Clear the flag if
* being issued .
*/
if ( ! throttled )
2016-10-20 16:12:12 +03:00
bio_clear_flag ( bio , BIO_THROTTLED ) ;
2011-10-19 16:33:01 +04:00
return throttled ;
2010-09-16 01:06:35 +04:00
}
2013-05-15 00:52:37 +04:00
/*
* Dispatch all bios from all children tg ' s queued on @ parent_sq . On
* return , @ parent_sq is guaranteed to not have any active children tg ' s
* and all bios from previously active tg ' s are on @ parent_sq - > bio_lists [ ] .
*/
static void tg_drain_bios ( struct throtl_service_queue * parent_sq )
{
struct throtl_grp * tg ;
while ( ( tg = throtl_rb_first ( parent_sq ) ) ) {
struct throtl_service_queue * sq = & tg - > service_queue ;
struct bio * bio ;
throtl_dequeue_tg ( tg ) ;
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
while ( ( bio = throtl_peek_queued ( & sq - > queued [ READ ] ) ) )
2013-05-15 00:52:37 +04:00
tg_dispatch_one_bio ( tg , bio_data_dir ( bio ) ) ;
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
while ( ( bio = throtl_peek_queued ( & sq - > queued [ WRITE ] ) ) )
2013-05-15 00:52:37 +04:00
tg_dispatch_one_bio ( tg , bio_data_dir ( bio ) ) ;
}
}
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 16:42:16 +04: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 ;
2013-05-15 00:52:37 +04:00
struct blkcg_gq * blkg ;
2013-08-09 04:11:25 +04:00
struct cgroup_subsys_state * pos_css ;
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 16:42:16 +04:00
struct bio * bio ;
2013-05-15 00:52:35 +04:00
int rw ;
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 16:42:16 +04:00
2012-03-30 14:33:28 +04:00
queue_lockdep_assert_held ( q ) ;
2013-05-15 00:52:37 +04:00
rcu_read_lock ( ) ;
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 16:42:16 +04:00
2013-05-15 00:52:37 +04:00
/*
* Drain each tg while doing post - order walk on the blkg tree , so
* that all bios are propagated to td - > service_queue . It ' d be
* better to walk service_queue tree directly but blkg walk is
* easier .
*/
2013-08-09 04:11:25 +04:00
blkg_for_each_descendant_post ( blkg , pos_css , td - > queue - > root_blkg )
2013-05-15 00:52:37 +04:00
tg_drain_bios ( & blkg_to_tg ( blkg ) - > service_queue ) ;
2013-05-15 00:52:35 +04:00
2013-05-15 00:52:37 +04:00
/* finally, transfer bios from top-level tg's into the td */
tg_drain_bios ( & td - > service_queue ) ;
rcu_read_unlock ( ) ;
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 16:42:16 +04:00
spin_unlock_irq ( q - > queue_lock ) ;
2013-05-15 00:52:37 +04:00
/* all bios now should be in td->service_queue, issue them */
2013-05-15 00:52:35 +04:00
for ( rw = READ ; rw < = WRITE ; rw + + )
blk-throttle: add throtl_qnode for dispatch fairness
With flat hierarchy, there's only single level of dispatching
happening and fairness beyond that point is the responsibility of the
rest of the block layer and driver, which usually works out okay;
however, with the planned hierarchy support,
service_queue->bio_lists[] can be filled up by bios from a single
source. While the limits would still be honored, it'd be very easy to
starve IOs from siblings or children.
To avoid such starvation, this patch implements throtl_qnode and
converts service_queue->bio_lists[] to lists of per-source qnodes
which in turn contains the bio's. For example, when a bio is
dispatched from a child group, the bio doesn't get queued on
->bio_lists[] directly but it first gets queued on the group's qnode
which in turn gets queued on service_queue->queued[]. When
dispatching for the upper level, the ->queued[] list is consumed in
round-robing order so that the dispatch windows is consumed fairly by
all IO sources.
There are two ways a bio can come to a throtl_grp - directly queued to
the group or dispatched from a child. For the former
throtl_grp->qnode_on_self[rw] is used. For the latter, the child's
->qnode_on_parent[rw].
Note that this means that the child which is contributing a bio to its
parent should stay pinned until all its bios are dispatched to its
grand-parent. This patch moves blkg refcnting from bio add/remove
spots to qnode activation/deactivation so that the blkg containing an
active qnode is always pinned. As child pins the parent, this is
sufficient for keeping the relevant sub-tree pinned while bios are in
flight.
The starvation issue was spotted by Vivek Goyal.
v2: The original patch used the same throtl_grp->qnode_on_self/parent
for reads and writes causing RWs to be queued incorrectly if there
already are outstanding IOs in the other direction. They should
be throtl_grp->qnode_on_self/parent[2] so that READs and WRITEs
can use different qnodes. Spotted by Vivek Goyal.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
2013-05-15 00:52:38 +04:00
while ( ( bio = throtl_pop_queued ( & td - > service_queue . queued [ rw ] ,
NULL ) ) )
2013-05-15 00:52:35 +04:00
generic_make_request ( bio ) ;
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 16:42:16 +04:00
spin_lock_irq ( q - > queue_lock ) ;
}
2010-09-16 01:06:35 +04:00
int blk_throtl_init ( struct request_queue * q )
{
struct throtl_data * td ;
2012-04-14 00:11:33 +04:00
int ret ;
2010-09-16 01:06:35 +04:00
td = kzalloc_node ( sizeof ( * td ) , GFP_KERNEL , q - > node ) ;
if ( ! td )
return - ENOMEM ;
2013-05-15 00:52:36 +04:00
INIT_WORK ( & td - > dispatch_work , blk_throtl_dispatch_work_fn ) ;
2015-08-19 00:55:13 +03:00
throtl_service_queue_init ( & td - > service_queue ) ;
2010-09-16 01:06:35 +04:00
2012-03-06 01:15:06 +04:00
q - > td = td ;
2011-05-19 23:38:24 +04:00
td - > queue = q ;
2010-10-01 16:49:48 +04:00
2017-03-27 20:51:30 +03:00
td - > limit_valid [ LIMIT_MAX ] = true ;
2017-03-27 20:51:32 +03:00
td - > limit_index = LIMIT_MAX ;
2012-04-14 00:11:33 +04:00
/* activate policy */
2012-04-17 00:57:25 +04:00
ret = blkcg_activate_policy ( q , & blkcg_policy_throtl ) ;
2012-04-14 00:11:33 +04:00
if ( ret )
2012-03-06 01:15:05 +04:00
kfree ( td ) ;
2012-04-14 00:11:33 +04:00
return ret ;
2010-09-16 01:06:35 +04:00
}
void blk_throtl_exit ( struct request_queue * q )
{
2012-03-06 01:15:22 +04:00
BUG_ON ( ! q - > td ) ;
2011-03-03 03:05:33 +03:00
throtl_shutdown_wq ( q ) ;
2012-04-17 00:57:25 +04: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 16:42:16 +04:00
kfree ( q - > td ) ;
2010-09-16 01:06:35 +04:00
}
static int __init throtl_init ( void )
{
2011-03-01 21:40:54 +03:00
kthrotld_workqueue = alloc_workqueue ( " kthrotld " , WQ_MEM_RECLAIM , 0 ) ;
if ( ! kthrotld_workqueue )
panic ( " Failed to create kthrotld \n " ) ;
2012-04-17 00:57:25 +04:00
return blkcg_policy_register ( & blkcg_policy_throtl ) ;
2010-09-16 01:06:35 +04:00
}
module_init ( throtl_init ) ;