cregit-Linux how code gets into the kernel

Release 4.11 block/blk-throttle.c

Directory: block
 * Interface for controlling IO bandwidth on a request queue
 * Copyright (C) 2010 Vivek Goyal <>

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/blkdev.h>
#include <linux/bio.h>
#include <linux/blktrace_api.h>
#include <linux/blk-cgroup.h>
#include "blk.h"

/* 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 */

static struct blkcg_policy blkcg_policy_throtl;

/* A workqueue to queue throttle related work */

static struct workqueue_struct *kthrotld_workqueue;

 * 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 */

struct throtl_service_queue {
struct throtl_service_queue *parent_sq;	/* the parent service_queue */

         * Bios queued directly to this service_queue or dispatched from
         * children throtl_grp's.
struct list_head	queued[2];	/* throtl_qnode [READ/WRITE] */
unsigned int		nr_queued[2];	/* number of queued bios */

         * RB tree of active children throtl_grp's, which are sorted by
         * their ->disptime.
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 */
struct timer_list	pending_timer;	/* fires on first_pending_disptime */

enum tg_state_flags {
THROTL_TG_PENDING	= 1 << 0,	/* on parent's pending tree */
THROTL_TG_WAS_EMPTY	= 1 << 1,	/* bio_lists[] became non-empty */

#define rb_entry_tg(node)	rb_entry((node), struct throtl_grp, rb_node)

struct throtl_grp {
	/* must be the first member */
struct blkg_policy_data pd;

	/* active throtl group service_queue member */
struct rb_node rb_node;

	/* throtl_data this group belongs to */
struct throtl_data *td;

	/* this group's service queue */
struct throtl_service_queue service_queue;

         * 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];

         * 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;

	/* are there any throtl rules between this group and td? */
bool has_rules[2];

	/* bytes per second rate limits */
uint64_t bps[2];

	/* IOPS limits */
unsigned int iops[2];

	/* Number of bytes disptached in current slice */
uint64_t bytes_disp[2];
	/* Number of bio's dispatched in current slice */
unsigned int io_disp[2];

	/* 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 */
struct throtl_service_queue service_queue;

struct request_queue *queue;

	/* Total Number of queued bios on READ and WRITE lists */
unsigned int nr_queued[2];

	/* Work for dispatching throttled bios */
struct work_struct dispatch_work;

static void throtl_pending_timer_fn(unsigned long arg);

static inline struct throtl_grp *pd_to_tg(struct blkg_policy_data *pd) { return pd ? container_of(pd, struct throtl_grp, pd) : NULL; }


Tejun Heo29100.00%1100.00%

static inline struct throtl_grp *blkg_to_tg(struct blkcg_gq *blkg) { return pd_to_tg(blkg_to_pd(blkg, &blkcg_policy_throtl)); }


Tejun Heo26100.00%3100.00%

static inline struct blkcg_gq *tg_to_blkg(struct throtl_grp *tg) { return pd_to_blkg(&tg->pd); }


Tejun Heo23100.00%3100.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; }


Tejun Heo3494.44%150.00%
Vivek Goyal25.56%150.00%

/** * sq_to_td - return throtl_data the specified service queue belongs to * @sq: the throtl_service_queue of interest * * A service_queue can be embedded in either a throtl_grp or throtl_data. * 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); }


Tejun Heo44100.00%1100.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; \ if (likely(!blk_trace_note_message_enabled(__td->queue))) \ break; \ if ((__tg)) { \ char __pbuf[128]; \ \ 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); \ } \ } while (0)
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; }


Tejun Heo38100.00%1100.00%

/** * 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)); } }


Tejun Heo63100.00%1100.00%

/** * 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; }


Tejun Heo62100.00%1100.00%

/** * 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; }


Tejun Heo123100.00%1100.00%

/* init a service_queue, assumes the caller zeroed it */
static void throtl_service_queue_init(struct throtl_service_queue *sq) { INIT_LIST_HEAD(&sq->queued[0]); INIT_LIST_HEAD(&sq->queued[1]); sq->pending_tree = RB_ROOT; setup_timer(&sq->pending_timer, throtl_pending_timer_fn, (unsigned long)sq); }


Tejun Heo55100.00%4100.00%

static struct blkg_policy_data *throtl_pd_alloc(gfp_t gfp, int node) { struct throtl_grp *tg; int rw; tg = kzalloc_node(sizeof(*tg), gfp, node); if (!tg) return NULL; 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); tg->bps[READ] = -1; tg->bps[WRITE] = -1; tg->iops[READ] = -1; tg->iops[WRITE] = -1; return &tg->pd; }


Tejun Heo148100.00%5100.00%

static void throtl_pd_init(struct blkg_policy_data *pd) { struct throtl_grp *tg = pd_to_tg(pd); struct blkcg_gq *blkg = tg_to_blkg(tg); struct throtl_data *td = blkg->q->td; struct throtl_service_queue *sq = &tg->service_queue; /* * If on the default hierarchy, we switch to properly hierarchical * behavior where limits on a given throtl_grp are applied to the * whole subtree rather than just the group itself. e.g. If 16M * read_bps limit is set on the root group, the whole system can't * exceed 16M for the device. * * If not on the default hierarchy, the broken flat hierarchy * 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. */ sq->parent_sq = &td->service_queue; if (cgroup_subsys_on_dfl(io_cgrp_subsys) && blkg->parent) sq->parent_sq = &blkg_to_tg(blkg->parent)->service_queue; tg->td = td; }


Tejun Heo8894.62%1392.86%
Vivek Goyal55.38%17.14%

/* * 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); int rw; for (rw = READ; rw <= WRITE; rw++) tg->has_rules[rw] = (parent_tg && parent_tg->has_rules[rw]) || (tg->bps[rw] != -1 || tg->iops[rw] != -1); }


Tejun Heo81100.00%1100.00%

static void throtl_pd_online(struct blkg_policy_data *pd) { /* * We don't want new groups to escape the limits of its ancestors. * Update has_rules[] after a new group is brought online. */ tg_update_has_rules(pd_to_tg(pd)); }


Tejun Heo20100.00%2100.00%

static void throtl_pd_free(struct blkg_policy_data *pd) { struct throtl_grp *tg = pd_to_tg(pd); del_timer_sync(&tg->service_queue.pending_timer); kfree(tg); }


Tejun Heo36100.00%5100.00%

static struct throtl_grp * throtl_rb_first(struct throtl_service_queue *parent_sq) { /* Service tree is empty */ if (!parent_sq->nr_pending) return NULL; if (!parent_sq->first_pending) parent_sq->first_pending = rb_first(&parent_sq->pending_tree); if (parent_sq->first_pending) return rb_entry_tg(parent_sq->first_pending); return NULL; }


Vivek Goyal4676.67%133.33%
Tejun Heo1423.33%266.67%

static void rb_erase_init(struct rb_node *n, struct rb_root *root) { rb_erase(n, root); RB_CLEAR_NODE(n); }


Vivek Goyal28100.00%1100.00%

static void throtl_rb_erase(struct rb_node *n, struct throtl_service_queue *parent_sq) { if (parent_sq->first_pending == n) parent_sq->first_pending = NULL; rb_erase_init(n, &parent_sq->pending_tree); --parent_sq->nr_pending; }


Vivek Goyal3577.78%133.33%
Tejun Heo1022.22%266.67%

static void update_min_dispatch_time(struct throtl_service_queue *parent_sq) { struct throtl_grp *tg; tg = throtl_rb_first(parent_sq); if (!tg) return; parent_sq->first_pending_disptime = tg->disptime; }


Vivek Goyal3286.49%133.33%
Tejun Heo513.51%266.67%

static void tg_service_queue_add(struct throtl_grp *tg) { struct throtl_service_queue *parent_sq = tg->service_queue.parent_sq; struct rb_node **node = &parent_sq->pending_tree.rb_node; struct rb_node *parent = NULL; struct throtl_grp *__tg; unsigned long key = tg->disptime; int left = 1; while (*node != NULL) { parent = *node; __tg = rb_entry_tg(parent); if (time_before(key, __tg->disptime)) node = &parent->rb_left; else { node = &parent->rb_right; left = 0; } } if (left) parent_sq->first_pending = &tg->rb_node; rb_link_node(&tg->rb_node, parent, node); rb_insert_color(&tg->rb_node, &parent_sq->pending_tree); }


Vivek Goyal13186.75%125.00%
Tejun Heo2013.25%375.00%

static void __throtl_enqueue_tg(struct throtl_grp *tg) { tg_service_queue_add(tg); tg->flags |= THROTL_TG_PENDING; tg->service_queue.parent_sq->nr_pending++; }


Vivek Goyal1858.06%120.00%
Tejun Heo1341.94%480.00%

static void throtl_enqueue_tg(struct throtl_grp *tg) { if (!(tg->flags & THROTL_TG_PENDING)) __throtl_enqueue_tg(tg); }


Vivek Goyal1970.37%133.33%
Tejun Heo829.63%266.67%

static void __throtl_dequeue_tg(struct throtl_grp *tg) { throtl_rb_erase(&tg->rb_node, tg->service_queue.parent_sq); tg->flags &= ~THROTL_TG_PENDING; }


Vivek Goyal2062.50%125.00%
Tejun Heo1237.50%375.00%

static void throtl_dequeue_tg(struct throtl_grp *tg) { if (tg->flags & THROTL_TG_PENDING) __throtl_dequeue_tg(tg); }


Vivek Goyal1875.00%133.33%
Tejun Heo625.00%266.67%

/* Call with queue lock held */
static void throtl_schedule_pending_timer(struct throtl_service_queue *sq, unsigned long expires) { mod_timer(&sq->pending_timer, expires); throtl_log(sq, "schedule timer. delay=%lu jiffies=%lu", expires - jiffies, jiffies); }


Tejun Heo38100.00%3100.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) { /* any pending children left? */ if (!sq->nr_pending) return true; update_min_dispatch_time(sq); /* is the next dispatch time in the future? */ if (force || time_after(sq->first_pending_disptime, jiffies)) { throtl_schedule_pending_timer(sq, sq->first_pending_disptime); return true; } /* tell the caller to continue dispatching */ return false; }


Tejun Heo3454.84%480.00%
Vivek Goyal2845.16%120.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); }


Vivek Goyal106100.00%1100.00%

static inline void throtl_start_new_slice(struct throtl_grp *tg, bool rw) { tg->bytes_disp[rw] = 0; tg->io_disp[rw] = 0; tg->slice_start[rw] = jiffies; tg->slice_end[rw] = jiffies + throtl_slice; 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); }


Vivek Goyal8395.40%266.67%
Tejun Heo44.60%133.33%

static inline void throtl_set_slice_end(struct throtl_grp *tg, bool rw, unsigned long jiffy_end) { tg->slice_end[rw] = roundup(jiffy_end, throtl_slice); }


Vivek Goyal33100.00%1100.00%

static inline void throtl_extend_slice(struct throtl_grp *tg, bool rw, unsigned long jiffy_end) { tg->slice_end[rw] = roundup(jiffy_end, throtl_slice); 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); }


Vivek Goyal6394.03%150.00%
Tejun Heo45.97%150.00%

/* Determine if previously allocated or extended slice is complete or not */
static bool throtl_slice_used(struct throtl_grp *tg, bool rw) { if (time_in_range(jiffies, tg->slice_start[rw], tg->slice_end[rw])) return false; return 1; }


Vivek Goyal4097.56%150.00%
Fabian Frederick12.44%150.00%

/* Trim the used slices and adjust slice start accordingly */
static inline void throtl_trim_slice(struct throtl_grp *tg, bool rw) { unsigned long nr_slices, time_elapsed, io_trim; u64 bytes_trim, tmp; BUG_ON(time_before(tg->slice_end[rw], tg->slice_start[rw])); /* * If bps are unlimited (-1), then time slice don't get * renewed. Don't try to trim the slice if slice is used. A new * slice will start when appropriate. */ if (throtl_slice_used(tg, rw)) return; /* * A bio has been dispatched. Also adjust slice_end. It might happen * that initially cgroup limit was very low resulting in high * slice_end, but later limit was bumped up and bio was dispached * sooner, then we need to reduce slice_end. A high bogus slice_end * is bad because it does not allow new slice to start. */ throtl_set_slice_end(tg, rw, jiffies + throtl_slice); time_elapsed = jiffies - tg->slice_start[rw]; nr_slices = time_elapsed / throtl_slice; if (!nr_slices) return; tmp = tg->bps[rw] * throtl_slice * nr_slices; do_div(tmp, HZ); bytes_trim = tmp; io_trim = (tg->iops[rw] * throtl_slice * nr_slices)/HZ; if (!bytes_trim && !io_trim) return; if (tg->bytes_disp[rw] >= bytes_trim) tg->bytes_disp[rw] -= bytes_trim; else tg->bytes_disp[rw] = 0; if (tg->io_disp[rw] >= io_trim) tg->io_disp[rw] -= io_trim; else tg->io_disp[rw] = 0; tg->slice_start[rw] += nr_slices * throtl_slice; 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); }


Vivek Goyal25098.04%480.00%
Tejun Heo51.96%120.00%

static bool tg_with_in_iops_limit(struct throtl_grp *tg, struct bio *bio, unsigned long *wait) { bool rw = bio_data_dir(bio); unsigned int io_allowed; unsigned long jiffy_elapsed, jiffy_wait, jiffy_elapsed_rnd; u64 tmp; 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); /* * jiffy_elapsed_rnd should not be a big value as minimum iops can be * 1 then at max jiffy elapsed should be equivalent of 1 second as we * will allow dispatch after 1 second and after that slice should * have been trimmed. */ tmp = (u64)tg->iops[rw] * jiffy_elapsed_rnd; do_div(tmp, HZ); if (tmp > UINT_MAX) io_allowed = UINT_MAX; else io_allowed = tmp; if (tg->io_disp[rw] + 1 <= io_allowed) { if (wait) *wait = 0; return true; } /* Calc approx time to dispatch */ jiffy_wait = ((tg->io_disp[rw] + 1) * HZ)/tg->iops[rw] + 1; if (jiffy_wait > jiffy_elapsed) jiffy_wait = jiffy_wait - jiffy_elapsed; else jiffy_wait = 1; if (wait) *wait = jiffy_wait; return 0; }


Vivek Goyal19599.49%375.00%
Fabian Frederick10.51%125.00%

static bool tg_with_in_bps_limit(struct throtl_grp *tg, struct bio *bio, unsigned long *wait) { bool rw = bio_data_dir(bio); u64 bytes_allowed, extra_bytes, tmp; unsigned long jiffy_elapsed, jiffy_wait, jiffy_elapsed_rnd; 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); tmp = tg->bps[rw] * jiffy_elapsed_rnd; do_div(tmp, HZ); bytes_allowed = tmp; if (tg->bytes_disp[rw] + bio->bi_iter.bi_size <= bytes_allowed) { if (wait) *wait = 0; return true; } /* Calc approx time to dispatch */ extra_bytes = tg->bytes_disp[rw] + bio->bi_iter.bi_size - bytes_allowed; jiffy_wait = div64_u64(extra_bytes * HZ, tg->bps[rw]); if (!jiffy_wait) jiffy_wait = 1; /* * This wait time is without taking into consideration the rounding * up we did. Add that time also. */ jiffy_wait = jiffy_wait + (jiffy_elapsed_rnd - jiffy_elapsed); if (wait) *wait = jiffy_wait; return 0; }


Vivek Goyal19097.44%360.00%
Kent Overstreet42.05%120.00%
Fabian Frederick10.51%120.00%

/* * Returns whether one can dispatch a bio or not. Also returns approx number * of jiffies to wait before this bio is with-in IO rate and can be dispatched */
static bool tg_may_dispatch(struct throtl_grp *tg, struct bio *bio, unsigned long *wait) { bool rw = bio_data_dir(bio); unsigned long bps_wait = 0, iops_wait = 0, max_wait = 0; /* * Currently whole state machine of group depends on first bio * queued in the group bio list. So one should not be calling * this function with a different bio if there are other bios * queued. */ BUG_ON(tg->service_queue.nr_queued[rw] && bio != throtl_peek_queued(&tg->service_queue.queued[rw])); /* If tg->bps = -1, then BW is unlimited */ if (tg->bps[rw] == -1 && tg->iops[rw] == -1) { if (wait) *wait = 0; return true; } /* * If previous slice expired, start a new one otherwise renew/extend * existing slice to make sure it is at least throtl_slice interval * long since now. 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. */ if (throtl_slice_used(tg, rw) && !(tg->service_queue.nr_queued[rw])) throtl_start_new_slice(tg, rw); else { if (time_before(tg->slice_end[rw], jiffies + throtl_slice)) throtl_extend_slice(tg, rw, jiffies + throtl_slice); } if (tg_with_in_bps_limit(tg, bio, &bps_wait) && tg_with_in_iops_limit(tg, bio, &iops_wait)) { if (wait) *wait = 0; return 1