Commit 3c798398 authored by Tejun Heo's avatar Tejun Heo Committed by Jens Axboe
Browse files

blkcg: mass rename of blkcg API 



During the recent blkcg cleanup, most of blkcg API has changed to such
extent that mass renaming wouldn't cause any noticeable pain.  Take
the chance and cleanup the naming.

* Rename blkio_cgroup to blkcg.

* Drop blkio / blkiocg prefixes and consistently use blkcg.

* Rename blkio_group to blkcg_gq, which is consistent with io_cq but
  keep the blkg prefix / variable name.

* Rename policy method type and field names to signify they're dealing
  with policy data.

* Rename blkio_policy_type to blkcg_policy.

This patch doesn't cause any functional change.

Signed-off-by: default avatarTejun Heo <tj@kernel.org>
Cc: Vivek Goyal <vgoyal@redhat.com>
Signed-off-by: default avatarJens Axboe <axboe@kernel.dk>
parent 36558c8a

block/blk-cgroup.c

+99 −103
Original line number Diff line number Diff line
@@ -26,39 +26,39 @@ 


static DEFINE_MUTEX(blkcg_pol_mutex);



struct blkio_cgroup blkio_root_cgroup = { .cfq_weight = 2 * CFQ_WEIGHT_DEFAULT };

EXPORT_SYMBOL_GPL(blkio_root_cgroup);

struct blkcg blkcg_root = { .cfq_weight = 2 * CFQ_WEIGHT_DEFAULT };

EXPORT_SYMBOL_GPL(blkcg_root);



static struct blkio_policy_type *blkio_policy[BLKCG_MAX_POLS];

static struct blkcg_policy *blkcg_policy[BLKCG_MAX_POLS];



struct blkio_cgroup *cgroup_to_blkio_cgroup(struct cgroup *cgroup)

struct blkcg *cgroup_to_blkcg(struct cgroup *cgroup)

{

	return container_of(cgroup_subsys_state(cgroup, blkio_subsys_id),

			    struct blkio_cgroup, css);

			    struct blkcg, css);

}

EXPORT_SYMBOL_GPL(cgroup_to_blkio_cgroup);

EXPORT_SYMBOL_GPL(cgroup_to_blkcg);



static struct blkio_cgroup *task_blkio_cgroup(struct task_struct *tsk)

static struct blkcg *task_blkcg(struct task_struct *tsk)

{

	return container_of(task_subsys_state(tsk, blkio_subsys_id),

			    struct blkio_cgroup, css);

			    struct blkcg, css);

}



struct blkio_cgroup *bio_blkio_cgroup(struct bio *bio)

struct blkcg *bio_blkcg(struct bio *bio)

{

	if (bio && bio->bi_css)

		return container_of(bio->bi_css, struct blkio_cgroup, css);

	return task_blkio_cgroup(current);

		return container_of(bio->bi_css, struct blkcg, css);

	return task_blkcg(current);

}

EXPORT_SYMBOL_GPL(bio_blkio_cgroup);

EXPORT_SYMBOL_GPL(bio_blkcg);



static bool blkcg_policy_enabled(struct request_queue *q,

				 const struct blkio_policy_type *pol)

				 const struct blkcg_policy *pol)

{

	return pol && test_bit(pol->plid, q->blkcg_pols);

}



static size_t blkg_pd_size(const struct blkio_policy_type *pol)

static size_t blkg_pd_size(const struct blkcg_policy *pol)

{

	return sizeof(struct blkg_policy_data) + pol->pdata_size;

}
@@ -69,7 +69,7 @@ static size_t blkg_pd_size(const struct blkio_policy_type *pol) 
 *

 * Free @blkg which may be partially allocated.

 */

static void blkg_free(struct blkio_group *blkg)

static void blkg_free(struct blkcg_gq *blkg)

{

	int i;
@@ -77,14 +77,14 @@ static void blkg_free(struct blkio_group *blkg) 
		return;



	for (i = 0; i < BLKCG_MAX_POLS; i++) {

		struct blkio_policy_type *pol = blkio_policy[i];

		struct blkcg_policy *pol = blkcg_policy[i];

		struct blkg_policy_data *pd = blkg->pd[i];



		if (!pd)

			continue;



		if (pol && pol->ops.blkio_exit_group_fn)

			pol->ops.blkio_exit_group_fn(blkg);

		if (pol && pol->ops.pd_exit_fn)

			pol->ops.pd_exit_fn(blkg);



		kfree(pd);

	}
@@ -99,10 +99,9 @@ static void blkg_free(struct blkio_group *blkg) 
 *

 * Allocate a new blkg assocating @blkcg and @q.

 */

static struct blkio_group *blkg_alloc(struct blkio_cgroup *blkcg,

				      struct request_queue *q)

static struct blkcg_gq *blkg_alloc(struct blkcg *blkcg, struct request_queue *q)

{

	struct blkio_group *blkg;

	struct blkcg_gq *blkg;

	int i;



	/* alloc and init base part */
@@ -116,7 +115,7 @@ static struct blkio_group *blkg_alloc(struct blkio_cgroup *blkcg, 
	blkg->refcnt = 1;



	for (i = 0; i < BLKCG_MAX_POLS; i++) {

		struct blkio_policy_type *pol = blkio_policy[i];

		struct blkcg_policy *pol = blkcg_policy[i];

		struct blkg_policy_data *pd;



		if (!blkcg_policy_enabled(q, pol))
@@ -135,19 +134,19 @@ static struct blkio_group *blkg_alloc(struct blkio_cgroup *blkcg, 


	/* invoke per-policy init */

	for (i = 0; i < BLKCG_MAX_POLS; i++) {

		struct blkio_policy_type *pol = blkio_policy[i];

		struct blkcg_policy *pol = blkcg_policy[i];



		if (blkcg_policy_enabled(blkg->q, pol))

			pol->ops.blkio_init_group_fn(blkg);

			pol->ops.pd_init_fn(blkg);

	}



	return blkg;

}



static struct blkio_group *__blkg_lookup(struct blkio_cgroup *blkcg,

static struct blkcg_gq *__blkg_lookup(struct blkcg *blkcg,

				      struct request_queue *q)

{

	struct blkio_group *blkg;

	struct blkcg_gq *blkg;

	struct hlist_node *n;



	hlist_for_each_entry_rcu(blkg, n, &blkcg->blkg_list, blkcg_node)
@@ -165,8 +164,7 @@ static struct blkio_group *__blkg_lookup(struct blkio_cgroup *blkcg, 
 * under RCU read lock and is guaranteed to return %NULL if @q is bypassing

 * - see blk_queue_bypass_start() for details.

 */

struct blkio_group *blkg_lookup(struct blkio_cgroup *blkcg,

				struct request_queue *q)

struct blkcg_gq *blkg_lookup(struct blkcg *blkcg, struct request_queue *q)

{

	WARN_ON_ONCE(!rcu_read_lock_held());
@@ -176,11 +174,11 @@ struct blkio_group *blkg_lookup(struct blkio_cgroup *blkcg, 
}

EXPORT_SYMBOL_GPL(blkg_lookup);



static struct blkio_group *__blkg_lookup_create(struct blkio_cgroup *blkcg,

static struct blkcg_gq *__blkg_lookup_create(struct blkcg *blkcg,

					     struct request_queue *q)

	__releases(q->queue_lock) __acquires(q->queue_lock)

{

	struct blkio_group *blkg;

	struct blkcg_gq *blkg;



	WARN_ON_ONCE(!rcu_read_lock_held());

	lockdep_assert_held(q->queue_lock);
@@ -213,7 +211,7 @@ out: 
	return blkg;

}



struct blkio_group *blkg_lookup_create(struct blkio_cgroup *blkcg,

struct blkcg_gq *blkg_lookup_create(struct blkcg *blkcg,

				    struct request_queue *q)

{

	/*
@@ -226,10 +224,10 @@ struct blkio_group *blkg_lookup_create(struct blkio_cgroup *blkcg, 
}

EXPORT_SYMBOL_GPL(blkg_lookup_create);



static void blkg_destroy(struct blkio_group *blkg)

static void blkg_destroy(struct blkcg_gq *blkg)

{

	struct request_queue *q = blkg->q;

	struct blkio_cgroup *blkcg = blkg->blkcg;

	struct blkcg *blkcg = blkg->blkcg;



	lockdep_assert_held(q->queue_lock);

	lockdep_assert_held(&blkcg->lock);
@@ -255,12 +253,12 @@ static void blkg_destroy(struct blkio_group *blkg) 
 */

static void blkg_destroy_all(struct request_queue *q)

{

	struct blkio_group *blkg, *n;

	struct blkcg_gq *blkg, *n;



	lockdep_assert_held(q->queue_lock);



	list_for_each_entry_safe(blkg, n, &q->blkg_list, q_node) {

		struct blkio_cgroup *blkcg = blkg->blkcg;

		struct blkcg *blkcg = blkg->blkcg;



		spin_lock(&blkcg->lock);

		blkg_destroy(blkg);
@@ -270,10 +268,10 @@ static void blkg_destroy_all(struct request_queue *q) 


static void blkg_rcu_free(struct rcu_head *rcu_head)

{

	blkg_free(container_of(rcu_head, struct blkio_group, rcu_head));

	blkg_free(container_of(rcu_head, struct blkcg_gq, rcu_head));

}



void __blkg_release(struct blkio_group *blkg)

void __blkg_release(struct blkcg_gq *blkg)

{

	/* release the extra blkcg reference this blkg has been holding */

	css_put(&blkg->blkcg->css);
@@ -291,11 +289,11 @@ void __blkg_release(struct blkio_group *blkg) 
}

EXPORT_SYMBOL_GPL(__blkg_release);



static int

blkiocg_reset_stats(struct cgroup *cgroup, struct cftype *cftype, u64 val)

static int blkcg_reset_stats(struct cgroup *cgroup, struct cftype *cftype,

			     u64 val)

{

	struct blkio_cgroup *blkcg = cgroup_to_blkio_cgroup(cgroup);

	struct blkio_group *blkg;

	struct blkcg *blkcg = cgroup_to_blkcg(cgroup);

	struct blkcg_gq *blkg;

	struct hlist_node *n;

	int i;
@@ -309,11 +307,11 @@ blkiocg_reset_stats(struct cgroup *cgroup, struct cftype *cftype, u64 val) 
	 */

	hlist_for_each_entry(blkg, n, &blkcg->blkg_list, blkcg_node) {

		for (i = 0; i < BLKCG_MAX_POLS; i++) {

			struct blkio_policy_type *pol = blkio_policy[i];

			struct blkcg_policy *pol = blkcg_policy[i];



			if (blkcg_policy_enabled(blkg->q, pol) &&

			    pol->ops.blkio_reset_group_stats_fn)

				pol->ops.blkio_reset_group_stats_fn(blkg);

			    pol->ops.pd_reset_stats_fn)

				pol->ops.pd_reset_stats_fn(blkg);

		}

	}
@@ -322,7 +320,7 @@ blkiocg_reset_stats(struct cgroup *cgroup, struct cftype *cftype, u64 val) 
	return 0;

}



static const char *blkg_dev_name(struct blkio_group *blkg)

static const char *blkg_dev_name(struct blkcg_gq *blkg)

{

	/* some drivers (floppy) instantiate a queue w/o disk registered */

	if (blkg->q->backing_dev_info.dev)
@@ -347,12 +345,12 @@ static const char *blkg_dev_name(struct blkio_group *blkg) 
 * This is to be used to construct print functions for

 * cftype->read_seq_string method.

 */

void blkcg_print_blkgs(struct seq_file *sf, struct blkio_cgroup *blkcg,

void blkcg_print_blkgs(struct seq_file *sf, struct blkcg *blkcg,

		       u64 (*prfill)(struct seq_file *, void *, int),

		       const struct blkio_policy_type *pol, int data,

		       const struct blkcg_policy *pol, int data,

		       bool show_total)

{

	struct blkio_group *blkg;

	struct blkcg_gq *blkg;

	struct hlist_node *n;

	u64 total = 0;
@@ -462,13 +460,12 @@ EXPORT_SYMBOL_GPL(blkg_prfill_rwstat); 
 * value.  This function returns with RCU read lock and queue lock held and

 * must be paired with blkg_conf_finish().

 */

int blkg_conf_prep(struct blkio_cgroup *blkcg,

		   const struct blkio_policy_type *pol, const char *input,

		   struct blkg_conf_ctx *ctx)

int blkg_conf_prep(struct blkcg *blkcg, const struct blkcg_policy *pol,

		   const char *input, struct blkg_conf_ctx *ctx)

	__acquires(rcu) __acquires(disk->queue->queue_lock)

{

	struct gendisk *disk;

	struct blkio_group *blkg;

	struct blkcg_gq *blkg;

	unsigned int major, minor;

	unsigned long long v;

	int part, ret;
@@ -529,16 +526,16 @@ void blkg_conf_finish(struct blkg_conf_ctx *ctx) 
}

EXPORT_SYMBOL_GPL(blkg_conf_finish);



struct cftype blkio_files[] = {

struct cftype blkcg_files[] = {

	{

		.name = "reset_stats",

		.write_u64 = blkiocg_reset_stats,

		.write_u64 = blkcg_reset_stats,

	},

	{ }	/* terminate */

};



/**

 * blkiocg_pre_destroy - cgroup pre_destroy callback

 * blkcg_pre_destroy - cgroup pre_destroy callback

 * @cgroup: cgroup of interest

 *

 * This function is called when @cgroup is about to go away and responsible
@@ -548,15 +545,15 @@ struct cftype blkio_files[] = { 
 *

 * This is the blkcg counterpart of ioc_release_fn().

 */

static int blkiocg_pre_destroy(struct cgroup *cgroup)

static int blkcg_pre_destroy(struct cgroup *cgroup)

{

	struct blkio_cgroup *blkcg = cgroup_to_blkio_cgroup(cgroup);

	struct blkcg *blkcg = cgroup_to_blkcg(cgroup);



	spin_lock_irq(&blkcg->lock);



	while (!hlist_empty(&blkcg->blkg_list)) {

		struct blkio_group *blkg = hlist_entry(blkcg->blkg_list.first,

						struct blkio_group, blkcg_node);

		struct blkcg_gq *blkg = hlist_entry(blkcg->blkg_list.first,

						struct blkcg_gq, blkcg_node);

		struct request_queue *q = blkg->q;



		if (spin_trylock(q->queue_lock)) {
@@ -573,22 +570,22 @@ static int blkiocg_pre_destroy(struct cgroup *cgroup) 
	return 0;

}



static void blkiocg_destroy(struct cgroup *cgroup)

static void blkcg_destroy(struct cgroup *cgroup)

{

	struct blkio_cgroup *blkcg = cgroup_to_blkio_cgroup(cgroup);

	struct blkcg *blkcg = cgroup_to_blkcg(cgroup);



	if (blkcg != &blkio_root_cgroup)

	if (blkcg != &blkcg_root)

		kfree(blkcg);

}



static struct cgroup_subsys_state *blkiocg_create(struct cgroup *cgroup)

static struct cgroup_subsys_state *blkcg_create(struct cgroup *cgroup)

{

	static atomic64_t id_seq = ATOMIC64_INIT(0);

	struct blkio_cgroup *blkcg;

	struct blkcg *blkcg;

	struct cgroup *parent = cgroup->parent;



	if (!parent) {

		blkcg = &blkio_root_cgroup;

		blkcg = &blkcg_root;

		goto done;

	}
@@ -656,7 +653,7 @@ void blkcg_exit_queue(struct request_queue *q) 
 * of the main cic data structures.  For now we allow a task to change

 * its cgroup only if it's the only owner of its ioc.

 */

static int blkiocg_can_attach(struct cgroup *cgrp, struct cgroup_taskset *tset)

static int blkcg_can_attach(struct cgroup *cgrp, struct cgroup_taskset *tset)

{

	struct task_struct *task;

	struct io_context *ioc;
@@ -677,12 +674,12 @@ static int blkiocg_can_attach(struct cgroup *cgrp, struct cgroup_taskset *tset) 


struct cgroup_subsys blkio_subsys = {

	.name = "blkio",

	.create = blkiocg_create,

	.can_attach = blkiocg_can_attach,

	.pre_destroy = blkiocg_pre_destroy,

	.destroy = blkiocg_destroy,

	.create = blkcg_create,

	.can_attach = blkcg_can_attach,

	.pre_destroy = blkcg_pre_destroy,

	.destroy = blkcg_destroy,

	.subsys_id = blkio_subsys_id,

	.base_cftypes = blkio_files,

	.base_cftypes = blkcg_files,

	.module = THIS_MODULE,

};

EXPORT_SYMBOL_GPL(blkio_subsys);
@@ -704,10 +701,10 @@ EXPORT_SYMBOL_GPL(blkio_subsys); 
 * [un]registerations.  Returns 0 on success, -errno on failure.

 */

int blkcg_activate_policy(struct request_queue *q,

			  const struct blkio_policy_type *pol)

			  const struct blkcg_policy *pol)

{

	LIST_HEAD(pds);

	struct blkio_group *blkg;

	struct blkcg_gq *blkg;

	struct blkg_policy_data *pd, *n;

	int cnt = 0, ret;
@@ -720,7 +717,7 @@ int blkcg_activate_policy(struct request_queue *q, 
	spin_lock_irq(q->queue_lock);



	rcu_read_lock();

	blkg = __blkg_lookup_create(&blkio_root_cgroup, q);

	blkg = __blkg_lookup_create(&blkcg_root, q);

	rcu_read_unlock();



	if (IS_ERR(blkg)) {
@@ -764,7 +761,7 @@ int blkcg_activate_policy(struct request_queue *q, 


		blkg->pd[pol->plid] = pd;

		pd->blkg = blkg;

		pol->ops.blkio_init_group_fn(blkg);

		pol->ops.pd_init_fn(blkg);



		spin_unlock(&blkg->blkcg->lock);

	}
@@ -790,9 +787,9 @@ EXPORT_SYMBOL_GPL(blkcg_activate_policy); 
 * blkcg_activate_policy().

 */

void blkcg_deactivate_policy(struct request_queue *q,

			     const struct blkio_policy_type *pol)

			     const struct blkcg_policy *pol)

{

	struct blkio_group *blkg;

	struct blkcg_gq *blkg;



	if (!blkcg_policy_enabled(q, pol))

		return;
@@ -810,8 +807,8 @@ void blkcg_deactivate_policy(struct request_queue *q, 
		/* grab blkcg lock too while removing @pd from @blkg */

		spin_lock(&blkg->blkcg->lock);



		if (pol->ops.blkio_exit_group_fn)

			pol->ops.blkio_exit_group_fn(blkg);

		if (pol->ops.pd_exit_fn)

			pol->ops.pd_exit_fn(blkg);



		kfree(blkg->pd[pol->plid]);

		blkg->pd[pol->plid] = NULL;
@@ -825,14 +822,13 @@ void blkcg_deactivate_policy(struct request_queue *q, 
EXPORT_SYMBOL_GPL(blkcg_deactivate_policy);



/**

 * blkio_policy_register - register a blkcg policy

 * @blkiop: blkcg policy to register

 * blkcg_policy_register - register a blkcg policy

 * @pol: blkcg policy to register

 *

 * Register @blkiop with blkcg core.  Might sleep and @blkiop may be

 * modified on successful registration.  Returns 0 on success and -errno on

 * failure.

 * Register @pol with blkcg core.  Might sleep and @pol may be modified on

 * successful registration.  Returns 0 on success and -errno on failure.

 */

int blkio_policy_register(struct blkio_policy_type *blkiop)

int blkcg_policy_register(struct blkcg_policy *pol)

{

	int i, ret;
@@ -841,45 +837,45 @@ int blkio_policy_register(struct blkio_policy_type *blkiop) 
	/* find an empty slot */

	ret = -ENOSPC;

	for (i = 0; i < BLKCG_MAX_POLS; i++)

		if (!blkio_policy[i])

		if (!blkcg_policy[i])

			break;

	if (i >= BLKCG_MAX_POLS)

		goto out_unlock;



	/* register and update blkgs */

	blkiop->plid = i;

	blkio_policy[i] = blkiop;

	pol->plid = i;

	blkcg_policy[i] = pol;



	/* everything is in place, add intf files for the new policy */

	if (blkiop->cftypes)

		WARN_ON(cgroup_add_cftypes(&blkio_subsys, blkiop->cftypes));

	if (pol->cftypes)

		WARN_ON(cgroup_add_cftypes(&blkio_subsys, pol->cftypes));

	ret = 0;

out_unlock:

	mutex_unlock(&blkcg_pol_mutex);

	return ret;

}

EXPORT_SYMBOL_GPL(blkio_policy_register);

EXPORT_SYMBOL_GPL(blkcg_policy_register);



/**

 * blkiop_policy_unregister - unregister a blkcg policy

 * @blkiop: blkcg policy to unregister

 * blkcg_policy_unregister - unregister a blkcg policy

 * @pol: blkcg policy to unregister

 *

 * Undo blkio_policy_register(@blkiop).  Might sleep.

 * Undo blkcg_policy_register(@pol).  Might sleep.

 */

void blkio_policy_unregister(struct blkio_policy_type *blkiop)

void blkcg_policy_unregister(struct blkcg_policy *pol)

{

	mutex_lock(&blkcg_pol_mutex);



	if (WARN_ON(blkio_policy[blkiop->plid] != blkiop))

	if (WARN_ON(blkcg_policy[pol->plid] != pol))

		goto out_unlock;



	/* kill the intf files first */

	if (blkiop->cftypes)

		cgroup_rm_cftypes(&blkio_subsys, blkiop->cftypes);

	if (pol->cftypes)

		cgroup_rm_cftypes(&blkio_subsys, pol->cftypes);



	/* unregister and update blkgs */

	blkio_policy[blkiop->plid] = NULL;

	blkcg_policy[pol->plid] = NULL;

out_unlock:

	mutex_unlock(&blkcg_pol_mutex);

}

EXPORT_SYMBOL_GPL(blkio_policy_unregister);
 
EXPORT_SYMBOL_GPL(blkcg_policy_unregister);

block/blk-cgroup.h

+54 −55
Original line number Diff line number Diff line
@@ -37,7 +37,7 @@ enum blkg_rwstat_type { 
	BLKG_RWSTAT_TOTAL = BLKG_RWSTAT_NR,

};



struct blkio_cgroup {

struct blkcg {

	struct cgroup_subsys_state	css;

	spinlock_t			lock;

	struct hlist_head		blkg_list;
@@ -45,7 +45,7 @@ struct blkio_cgroup { 
	/* for policies to test whether associated blkcg has changed */

	uint64_t			id;



	/* TODO: per-policy storage in blkio_cgroup */

	/* TODO: per-policy storage in blkcg */

	unsigned int			cfq_weight;	/* belongs to cfq */

};
@@ -62,7 +62,7 @@ struct blkg_rwstat { 
/* per-blkg per-policy data */

struct blkg_policy_data {

	/* the blkg this per-policy data belongs to */

	struct blkio_group		*blkg;

	struct blkcg_gq			*blkg;



	/* used during policy activation */

	struct list_head		alloc_node;
@@ -71,12 +71,13 @@ struct blkg_policy_data { 
	char				pdata[] __aligned(__alignof__(unsigned long long));

};



struct blkio_group {

/* association between a blk cgroup and a request queue */

struct blkcg_gq {

	/* Pointer to the associated request_queue */

	struct request_queue		*q;

	struct list_head		q_node;

	struct hlist_node		blkcg_node;

	struct blkio_cgroup		*blkcg;

	struct blkcg			*blkcg;

	/* reference count */

	int				refcnt;
@@ -85,18 +86,18 @@ struct blkio_group { 
	struct rcu_head			rcu_head;

};



typedef void (blkio_init_group_fn)(struct blkio_group *blkg);

typedef void (blkio_exit_group_fn)(struct blkio_group *blkg);

typedef void (blkio_reset_group_stats_fn)(struct blkio_group *blkg);

typedef void (blkcg_pol_init_pd_fn)(struct blkcg_gq *blkg);

typedef void (blkcg_pol_exit_pd_fn)(struct blkcg_gq *blkg);

typedef void (blkcg_pol_reset_pd_stats_fn)(struct blkcg_gq *blkg);



struct blkio_policy_ops {

	blkio_init_group_fn		*blkio_init_group_fn;

	blkio_exit_group_fn		*blkio_exit_group_fn;

	blkio_reset_group_stats_fn	*blkio_reset_group_stats_fn;

struct blkcg_policy_ops {

	blkcg_pol_init_pd_fn		*pd_init_fn;

	blkcg_pol_exit_pd_fn		*pd_exit_fn;

	blkcg_pol_reset_pd_stats_fn	*pd_reset_stats_fn;

};



struct blkio_policy_type {

	struct blkio_policy_ops		ops;

struct blkcg_policy {

	struct blkcg_policy_ops		ops;

	int				plid;

	/* policy specific private data size */

	size_t				pdata_size;
@@ -104,29 +105,28 @@ struct blkio_policy_type { 
	struct cftype			*cftypes;

};



extern struct blkio_cgroup blkio_root_cgroup;

extern struct blkcg blkcg_root;



struct blkio_cgroup *cgroup_to_blkio_cgroup(struct cgroup *cgroup);

struct blkio_cgroup *bio_blkio_cgroup(struct bio *bio);

struct blkio_group *blkg_lookup(struct blkio_cgroup *blkcg,

				struct request_queue *q);

struct blkio_group *blkg_lookup_create(struct blkio_cgroup *blkcg,

struct blkcg *cgroup_to_blkcg(struct cgroup *cgroup);

struct blkcg *bio_blkcg(struct bio *bio);

struct blkcg_gq *blkg_lookup(struct blkcg *blkcg, struct request_queue *q);

struct blkcg_gq *blkg_lookup_create(struct blkcg *blkcg,

				    struct request_queue *q);

int blkcg_init_queue(struct request_queue *q);

void blkcg_drain_queue(struct request_queue *q);

void blkcg_exit_queue(struct request_queue *q);



/* Blkio controller policy registration */

int blkio_policy_register(struct blkio_policy_type *);

void blkio_policy_unregister(struct blkio_policy_type *);

int blkcg_policy_register(struct blkcg_policy *pol);

void blkcg_policy_unregister(struct blkcg_policy *pol);

int blkcg_activate_policy(struct request_queue *q,

			  const struct blkio_policy_type *pol);

			  const struct blkcg_policy *pol);

void blkcg_deactivate_policy(struct request_queue *q,

			     const struct blkio_policy_type *pol);

			     const struct blkcg_policy *pol);



void blkcg_print_blkgs(struct seq_file *sf, struct blkio_cgroup *blkcg,

void blkcg_print_blkgs(struct seq_file *sf, struct blkcg *blkcg,

		       u64 (*prfill)(struct seq_file *, void *, int),

		       const struct blkio_policy_type *pol, int data,

		       const struct blkcg_policy *pol, int data,

		       bool show_total);

u64 __blkg_prfill_u64(struct seq_file *sf, void *pdata, u64 v);

u64 __blkg_prfill_rwstat(struct seq_file *sf, void *pdata,
@@ -136,13 +136,12 @@ u64 blkg_prfill_rwstat(struct seq_file *sf, void *pdata, int off); 


struct blkg_conf_ctx {

	struct gendisk			*disk;

	struct blkio_group		*blkg;

	struct blkcg_gq			*blkg;

	u64				v;

};



int blkg_conf_prep(struct blkio_cgroup *blkcg,

		   const struct blkio_policy_type *pol, const char *input,

		   struct blkg_conf_ctx *ctx);

int blkg_conf_prep(struct blkcg *blkcg, const struct blkcg_policy *pol,

		   const char *input, struct blkg_conf_ctx *ctx);

void blkg_conf_finish(struct blkg_conf_ctx *ctx);
@@ -153,8 +152,8 @@ void blkg_conf_finish(struct blkg_conf_ctx *ctx); 
 *

 * Return pointer to private data associated with the @blkg-@pol pair.

 */

static inline void *blkg_to_pdata(struct blkio_group *blkg,

			      struct blkio_policy_type *pol)

static inline void *blkg_to_pdata(struct blkcg_gq *blkg,

				  struct blkcg_policy *pol)

{

	return blkg ? blkg->pd[pol->plid]->pdata : NULL;

}
@@ -165,7 +164,7 @@ static inline void *blkg_to_pdata(struct blkio_group *blkg, 
 *

 * @pdata is policy private data.  Determine the blkg it's associated with.

 */

static inline struct blkio_group *pdata_to_blkg(void *pdata)

static inline struct blkcg_gq *pdata_to_blkg(void *pdata)

{

	if (pdata) {

		struct blkg_policy_data *pd =
@@ -183,7 +182,7 @@ static inline struct blkio_group *pdata_to_blkg(void *pdata) 
 *

 * Format the path of the cgroup of @blkg into @buf.

 */

static inline int blkg_path(struct blkio_group *blkg, char *buf, int buflen)

static inline int blkg_path(struct blkcg_gq *blkg, char *buf, int buflen)

{

	int ret;
@@ -201,14 +200,14 @@ static inline int blkg_path(struct blkio_group *blkg, char *buf, int buflen) 
 *

 * The caller should be holding queue_lock and an existing reference.

 */

static inline void blkg_get(struct blkio_group *blkg)

static inline void blkg_get(struct blkcg_gq *blkg)

{

	lockdep_assert_held(blkg->q->queue_lock);

	WARN_ON_ONCE(!blkg->refcnt);

	blkg->refcnt++;

}



void __blkg_release(struct blkio_group *blkg);

void __blkg_release(struct blkcg_gq *blkg);



/**

 * blkg_put - put a blkg reference
@@ -216,7 +215,7 @@ void __blkg_release(struct blkio_group *blkg); 
 *

 * The caller should be holding queue_lock.

 */

static inline void blkg_put(struct blkio_group *blkg)

static inline void blkg_put(struct blkcg_gq *blkg)

{

	lockdep_assert_held(blkg->q->queue_lock);

	WARN_ON_ONCE(blkg->refcnt <= 0);
@@ -343,32 +342,32 @@ static inline void blkg_rwstat_reset(struct blkg_rwstat *rwstat) 


struct cgroup;



struct blkio_group {

struct blkcg_gq {

};



struct blkio_policy_type {

struct blkcg_policy {

};



static inline struct blkio_cgroup *cgroup_to_blkio_cgroup(struct cgroup *cgroup) { return NULL; }

static inline struct blkio_cgroup *bio_blkio_cgroup(struct bio *bio) { return NULL; }

static inline struct blkio_group *blkg_lookup(struct blkio_cgroup *blkcg, void *key) { return NULL; }

static inline struct blkcg *cgroup_to_blkcg(struct cgroup *cgroup) { return NULL; }

static inline struct blkcg *bio_blkcg(struct bio *bio) { return NULL; }

static inline struct blkcg_gq *blkg_lookup(struct blkcg *blkcg, void *key) { return NULL; }

static inline int blkcg_init_queue(struct request_queue *q) { return 0; }

static inline void blkcg_drain_queue(struct request_queue *q) { }

static inline void blkcg_exit_queue(struct request_queue *q) { }

static inline int blkio_policy_register(struct blkio_policy_type *blkiop) { return 0; }

static inline void blkio_policy_unregister(struct blkio_policy_type *blkiop) { }

static inline int blkcg_policy_register(struct blkcg_policy *pol) { return 0; }

static inline void blkcg_policy_unregister(struct blkcg_policy *pol) { }

static inline int blkcg_activate_policy(struct request_queue *q,

					const struct blkio_policy_type *pol) { return 0; }

					const struct blkcg_policy *pol) { return 0; }

static inline void blkcg_deactivate_policy(struct request_queue *q,

					   const struct blkio_policy_type *pol) { }



static inline void *blkg_to_pdata(struct blkio_group *blkg,

				struct blkio_policy_type *pol) { return NULL; }

static inline struct blkio_group *pdata_to_blkg(void *pdata,

				struct blkio_policy_type *pol) { return NULL; }

static inline char *blkg_path(struct blkio_group *blkg) { return NULL; }

static inline void blkg_get(struct blkio_group *blkg) { }

static inline void blkg_put(struct blkio_group *blkg) { }

					   const struct blkcg_policy *pol) { }



static inline void *blkg_to_pdata(struct blkcg_gq *blkg,

				  struct blkcg_policy *pol) { return NULL; }

static inline struct blkcg_gq *pdata_to_blkg(void *pdata,

				  struct blkcg_policy *pol) { return NULL; }

static inline char *blkg_path(struct blkcg_gq *blkg) { return NULL; }

static inline void blkg_get(struct blkcg_gq *blkg) { }

static inline void blkg_put(struct blkcg_gq *blkg) { }



#endif	/* CONFIG_BLK_CGROUP */

#endif	/* _BLK_CGROUP_H */

block/blk-throttle.c

+36 −36

File changed.

Preview size limit exceeded, changes collapsed.

block/cfq-iosched.c

+39 −39

File changed.

Preview size limit exceeded, changes collapsed.

include/linux/blkdev.h

+2 −2
Original line number Diff line number Diff line
@@ -31,7 +31,7 @@ struct blk_trace; 
struct request;

struct sg_io_hdr;

struct bsg_job;

struct blkio_group;

struct blkcg_gq;



#define BLKDEV_MIN_RQ	4

#define BLKDEV_MAX_RQ	128	/* Default maximum */
@@ -371,7 +371,7 @@ struct request_queue { 
	struct list_head	icq_list;

#ifdef CONFIG_BLK_CGROUP

	DECLARE_BITMAP		(blkcg_pols, BLKCG_MAX_POLS);

	struct blkio_group	*root_blkg;

	struct blkcg_gq		*root_blkg;

	struct list_head	blkg_list;

#endif

CRA Git | Maintained and supported by SUSTech CRA and CCSE