Commit 020efdad authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'block-5.14-2021-08-13' of git://git.kernel.dk/linux-block 

Pull block fixes from Jens Axboe:
 "A few fixes for block that should go into 5.14:

   - Revert the mq-deadline cgroup addition. More work is needed on this
     front, let's revert it for now and get it right before having it in
     a released kernel (Tejun)

   - blk-iocost lockdep fix (Ming)

   - nbd double completion fix (Xie)

   - Fix for non-idling when clearing the shared tag flag (Yu)"

* tag 'block-5.14-2021-08-13' of git://git.kernel.dk/linux-block:
  nbd: Aovid double completion of a request
  blk-mq: clear active_queues before clearing BLK_MQ_F_TAG_QUEUE_SHARED
  Revert "block/mq-deadline: Add cgroup support"
  blk-iocost: fix lockdep warning on blkcg->lock
parents 42995cee cddce011

block/Kconfig.iosched

+0 −6
Original line number Diff line number Diff line
@@ -9,12 +9,6 @@ config MQ_IOSCHED_DEADLINE 
	help

	  MQ version of the deadline IO scheduler.



config MQ_IOSCHED_DEADLINE_CGROUP

       tristate

       default y

       depends on MQ_IOSCHED_DEADLINE

       depends on BLK_CGROUP



config MQ_IOSCHED_KYBER

	tristate "Kyber I/O scheduler"

	default y

block/Makefile

+0 −2
Original line number Diff line number Diff line
@@ -22,8 +22,6 @@ obj-$(CONFIG_BLK_CGROUP_IOPRIO) += blk-ioprio.o 
obj-$(CONFIG_BLK_CGROUP_IOLATENCY)	+= blk-iolatency.o

obj-$(CONFIG_BLK_CGROUP_IOCOST)	+= blk-iocost.o

obj-$(CONFIG_MQ_IOSCHED_DEADLINE)	+= mq-deadline.o

mq-deadline-y += mq-deadline-main.o

mq-deadline-$(CONFIG_MQ_IOSCHED_DEADLINE_CGROUP)+= mq-deadline-cgroup.o

obj-$(CONFIG_MQ_IOSCHED_KYBER)	+= kyber-iosched.o

bfq-y				:= bfq-iosched.o bfq-wf2q.o bfq-cgroup.o

obj-$(CONFIG_IOSCHED_BFQ)	+= bfq.o

block/blk-iocost.c

+4 −4
Original line number Diff line number Diff line
@@ -3061,19 +3061,19 @@ static ssize_t ioc_weight_write(struct kernfs_open_file *of, char *buf, 
		if (v < CGROUP_WEIGHT_MIN || v > CGROUP_WEIGHT_MAX)

			return -EINVAL;



		spin_lock(&blkcg->lock);

		spin_lock_irq(&blkcg->lock);

		iocc->dfl_weight = v * WEIGHT_ONE;

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

			struct ioc_gq *iocg = blkg_to_iocg(blkg);



			if (iocg) {

				spin_lock_irq(&iocg->ioc->lock);

				spin_lock(&iocg->ioc->lock);

				ioc_now(iocg->ioc, &now);

				weight_updated(iocg, &now);

				spin_unlock_irq(&iocg->ioc->lock);

				spin_unlock(&iocg->ioc->lock);

			}

		}

		spin_unlock(&blkcg->lock);

		spin_unlock_irq(&blkcg->lock);



		return nbytes;

	}

block/blk-mq.c

+4 −2
Original line number Diff line number Diff line
@@ -2994,12 +2994,14 @@ static void queue_set_hctx_shared(struct request_queue *q, bool shared) 
	int i;



	queue_for_each_hw_ctx(q, hctx, i) {

		if (shared)

		if (shared) {

			hctx->flags |= BLK_MQ_F_TAG_QUEUE_SHARED;

		else

		} else {

			blk_mq_tag_idle(hctx);

			hctx->flags &= ~BLK_MQ_F_TAG_QUEUE_SHARED;

		}

	}

}



static void blk_mq_update_tag_set_shared(struct blk_mq_tag_set *set,

					 bool shared)

block/mq-deadline-cgroup.c

deleted100644 → 0
+0 −126
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0



#include <linux/blk-cgroup.h>

#include <linux/ioprio.h>



#include "mq-deadline-cgroup.h"



static struct blkcg_policy dd_blkcg_policy;



static struct blkcg_policy_data *dd_cpd_alloc(gfp_t gfp)

{

	struct dd_blkcg *pd;



	pd = kzalloc(sizeof(*pd), gfp);

	if (!pd)

		return NULL;

	pd->stats = alloc_percpu_gfp(typeof(*pd->stats),

				     GFP_KERNEL | __GFP_ZERO);

	if (!pd->stats) {

		kfree(pd);

		return NULL;

	}

	return &pd->cpd;

}



static void dd_cpd_free(struct blkcg_policy_data *cpd)

{

	struct dd_blkcg *dd_blkcg = container_of(cpd, typeof(*dd_blkcg), cpd);



	free_percpu(dd_blkcg->stats);

	kfree(dd_blkcg);

}



static struct dd_blkcg *dd_blkcg_from_pd(struct blkg_policy_data *pd)

{

	return container_of(blkcg_to_cpd(pd->blkg->blkcg, &dd_blkcg_policy),

			    struct dd_blkcg, cpd);

}



/*

 * Convert an association between a block cgroup and a request queue into a

 * pointer to the mq-deadline information associated with a (blkcg, queue) pair.

 */

struct dd_blkcg *dd_blkcg_from_bio(struct bio *bio)

{

	struct blkg_policy_data *pd;



	pd = blkg_to_pd(bio->bi_blkg, &dd_blkcg_policy);

	if (!pd)

		return NULL;



	return dd_blkcg_from_pd(pd);

}



static size_t dd_pd_stat(struct blkg_policy_data *pd, char *buf, size_t size)

{

	static const char *const prio_class_name[] = {

		[IOPRIO_CLASS_NONE]	= "NONE",

		[IOPRIO_CLASS_RT]	= "RT",

		[IOPRIO_CLASS_BE]	= "BE",

		[IOPRIO_CLASS_IDLE]	= "IDLE",

	};

	struct dd_blkcg *blkcg = dd_blkcg_from_pd(pd);

	int res = 0;

	u8 prio;



	for (prio = 0; prio < ARRAY_SIZE(blkcg->stats->stats); prio++)

		res += scnprintf(buf + res, size - res,

			" [%s] dispatched=%u inserted=%u merged=%u",

			prio_class_name[prio],

			ddcg_sum(blkcg, dispatched, prio) +

			ddcg_sum(blkcg, merged, prio) -

			ddcg_sum(blkcg, completed, prio),

			ddcg_sum(blkcg, inserted, prio) -

			ddcg_sum(blkcg, completed, prio),

			ddcg_sum(blkcg, merged, prio));



	return res;

}



static struct blkg_policy_data *dd_pd_alloc(gfp_t gfp, struct request_queue *q,

					    struct blkcg *blkcg)

{

	struct dd_blkg *pd;



	pd = kzalloc(sizeof(*pd), gfp);

	if (!pd)

		return NULL;

	return &pd->pd;

}



static void dd_pd_free(struct blkg_policy_data *pd)

{

	struct dd_blkg *dd_blkg = container_of(pd, typeof(*dd_blkg), pd);



	kfree(dd_blkg);

}



static struct blkcg_policy dd_blkcg_policy = {

	.cpd_alloc_fn		= dd_cpd_alloc,

	.cpd_free_fn		= dd_cpd_free,



	.pd_alloc_fn		= dd_pd_alloc,

	.pd_free_fn		= dd_pd_free,

	.pd_stat_fn		= dd_pd_stat,

};



int dd_activate_policy(struct request_queue *q)

{

	return blkcg_activate_policy(q, &dd_blkcg_policy);

}



void dd_deactivate_policy(struct request_queue *q)

{

	blkcg_deactivate_policy(q, &dd_blkcg_policy);

}



int __init dd_blkcg_init(void)

{

	return blkcg_policy_register(&dd_blkcg_policy);

}



void __exit dd_blkcg_exit(void)

{

	blkcg_policy_unregister(&dd_blkcg_policy);

}