From patchwork Wed Feb 16 11:48:04 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Wang Jianchao X-Patchwork-Id: 12748471 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 723AFC433EF for ; Wed, 16 Feb 2022 11:49:43 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232394AbiBPLtx (ORCPT ); Wed, 16 Feb 2022 06:49:53 -0500 Received: from mxb-00190b01.gslb.pphosted.com ([23.128.96.19]:56280 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231834AbiBPLtv (ORCPT ); Wed, 16 Feb 2022 06:49:51 -0500 Received: from mail-pg1-x52b.google.com (mail-pg1-x52b.google.com [IPv6:2607:f8b0:4864:20::52b]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 1AF5A1CEB29; Wed, 16 Feb 2022 03:49:39 -0800 (PST) Received: by mail-pg1-x52b.google.com with SMTP id q132so1924338pgq.7; Wed, 16 Feb 2022 03:49:39 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=zEaED2klU/tmakY6hfsKkyNGyq5NXoTXpDD8xgT9OMY=; b=Swt/iOtKeq9QBud/wmXj5HEStx3FHPc8S8qJuV3jrMvfixPLeUopAm7zhtfBKY0tE3 s6UXelRDPPbp2pY7oX6ldXuotpoeEQ4DZbLGxYLHgDwCeHtZeWwBDW4AxcTYbsp9WLAZ w2tHVcdyFwMgFsxixfBAwcWVK/zNC9stxiZGrfXIQOmkVfQQjlE9wbGePZn3/f74ad6Z RYyzuucyPToveFpTCHVNIpzZ06duDai7Y9kkwZg4Ms4hbPQPlPh/tUOoRMTgMVyX9xlN AXy6ffD8VPeQRDa94XiMJ1ykHmp36DYPOL7wgVZPPw8PcLQ1ZN+1zyGknkMddH88rF6b PGQQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=zEaED2klU/tmakY6hfsKkyNGyq5NXoTXpDD8xgT9OMY=; b=RXfNrMNujgnMQ6WLkbqwh2f/oujI8y+jc1edU7JvZn/DQVM6lzJ7Ir+MkLe28LzqJ2 VI3PvJDfL62IzGBJiXZD9rfa1c3Uyk+dubbmojmZjG7jf2pOCHCbI99PymqQreEV1nKN B+x0SaaM5ULHnU7KjF9MvhjZebDylWzdqUQ+JygSxeW483McfkQnI0qU0gw77M5GkNL6 3duRjwF26DLhFUA19cdIZ33/K6UPcbcyfCp+maiRDIFWS8wGwcFMSQccCKjjBHz/LVce 5FGX19OjRM3NvwxBki1fJPCuF/GKKqrOUJjhxM8TdrXuyoU79RAWuTFlKTyciXFCRYpe k5TA== X-Gm-Message-State: AOAM532apqEphSNL0fj0T17QQ1JavYGJ/rpAIz6aiyQi48nJjNUD/Q0d yzORsqteUheicPqL6tBvgpQ= X-Google-Smtp-Source: ABdhPJy0JcycBTlOT78v0ofYoHJlp6PMfAMEPWhsWXKmgH3HyVh4SblGqNr1/+jWXCAGR2i0d+k2wA== X-Received: by 2002:a63:3f42:0:b0:363:c08a:8dfd with SMTP id m63-20020a633f42000000b00363c08a8dfdmr2025652pga.108.1645012178506; Wed, 16 Feb 2022 03:49:38 -0800 (PST) Received: from localhost.localdomain ([61.16.102.69]) by smtp.gmail.com with ESMTPSA id q1sm26209119pfs.112.2022.02.16.03.49.36 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Feb 2022 03:49:38 -0800 (PST) From: "Wang Jianchao (Kuaishou)" To: Jens Axboe Cc: Josef Bacik , Tejun Heo , Bart Van Assche , linux-block@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [RFC V3 1/6] blk: prepare to make blk-rq-qos pluggable and modular Date: Wed, 16 Feb 2022 19:48:04 +0800 Message-Id: <20220216114809.84551-2-jianchao.wan9@gmail.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20220216114809.84551-1-jianchao.wan9@gmail.com> References: <20220216114809.84551-1-jianchao.wan9@gmail.com> Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org blk-rq-qos is a standalone framework out of io-sched and can be used to control or observe the IO progress in block-layer with hooks. blk-rq-qos is a great design but right now, it is totally fixed and built-in and shut out peoples who want to use it with external module. This patch make blk-rq-qos policies pluggable and modular. (1) Add code to maintain the rq_qos_ops. A rq-qos module need to register itself with rq_qos_register(). The original enum rq_qos_id will be removed in following patch. They will use a dynamic id maintained by rq_qos_ida. (2) Add .init callback into rq_qos_ops. We use it to initialize the resource. (3) Add /sys/block/x/queue/qos We can use '+name' or "-name" to open or close the blk-rq-qos policy. This patch mainly prepare help interfaces and no functional changes. Following patches will adpat the code of wbt, iolatency, iocost and ioprio to make them pluggable and modular one by one. And after that, the /sys/block/xxx/queue/qos interfaces will be exported. Signed-off-by: Wang Jianchao (Kuaishou) --- block/blk-mq-debugfs.c | 9 +- block/blk-rq-qos.c | 303 ++++++++++++++++++++++++++++++++++++++++- block/blk-rq-qos.h | 39 +++++- include/linux/blkdev.h | 4 + 4 files changed, 350 insertions(+), 5 deletions(-) diff --git a/block/blk-mq-debugfs.c b/block/blk-mq-debugfs.c index 3a790eb4995c..4da803bf5617 100644 --- a/block/blk-mq-debugfs.c +++ b/block/blk-mq-debugfs.c @@ -729,7 +729,10 @@ void blk_mq_debugfs_register(struct request_queue *q) if (q->rq_qos) { struct rq_qos *rqos = q->rq_qos; - + /* + * queue has not been registered right now, it is safe to + * iterate the rqos w/o lock + */ while (rqos) { blk_mq_debugfs_register_rqos(rqos); rqos = rqos->next; @@ -844,7 +847,9 @@ void blk_mq_debugfs_unregister_rqos(struct rq_qos *rqos) void blk_mq_debugfs_register_rqos(struct rq_qos *rqos) { struct request_queue *q = rqos->q; - const char *dir_name = rq_qos_id_to_name(rqos->id); + const char *dir_name; + + dir_name = rqos->ops->name ? rqos->ops->name : rq_qos_id_to_name(rqos->id); if (rqos->debugfs_dir || !rqos->ops->debugfs_attrs) return; diff --git a/block/blk-rq-qos.c b/block/blk-rq-qos.c index e83af7bc7591..f269bb9745ad 100644 --- a/block/blk-rq-qos.c +++ b/block/blk-rq-qos.c @@ -2,6 +2,11 @@ #include "blk-rq-qos.h" +static DEFINE_IDA(rq_qos_ida); +static int nr_rqos_blkcg_pols; +static DEFINE_MUTEX(rq_qos_mutex); +static LIST_HEAD(rq_qos_list); + /* * Increment 'v', if 'v' is below 'below'. Returns true if we succeeded, * false if 'v' + 1 would be bigger than 'below'. @@ -294,11 +299,305 @@ void rq_qos_wait(struct rq_wait *rqw, void *private_data, void rq_qos_exit(struct request_queue *q) { - blk_mq_debugfs_unregister_queue_rqos(q); - + /* + * queue must have been unregistered here, it is safe to iterate + * the list w/o lock + */ while (q->rq_qos) { struct rq_qos *rqos = q->rq_qos; q->rq_qos = rqos->next; rqos->ops->exit(rqos); } + blk_mq_debugfs_unregister_queue_rqos(q); +} + +static struct rq_qos *rq_qos_by_name(struct request_queue *q, + const char *name) +{ + struct rq_qos *rqos; + + WARN_ON(!mutex_is_locked(&q->sysfs_lock) && !spin_is_locked(&q->queue_lock)); + + for (rqos = q->rq_qos; rqos; rqos = rqos->next) { + if (!rqos->ops->name) + continue; + + if (!strncmp(rqos->ops->name, name, + strlen(rqos->ops->name))) + return rqos; + } + return NULL; +} + +/* + * After the pluggable blk-qos, rqos's life cycle become complicated, + * as we may modify the rqos list there. Except for the places where + * queue is not registered, there are following places may access rqos + * list concurrently: + * (1) normal IO path, can be serialized by queue freezing + * (2) blkg_create, the .pd_init_fn() may access rqos, can be serialized + * by queue_lock. + * (3) cgroup file, such as ioc_cost_model_write, rq_qos_get is for this + * case to keep the rqos alive. + */ +struct rq_qos *rq_qos_get(struct request_queue *q, int id) +{ + struct rq_qos *rqos; + + spin_lock_irq(&q->queue_lock); + rqos = rq_qos_id(q, id); + if (rqos && rqos->dying) + rqos = NULL; + if (rqos) + refcount_inc(&rqos->ref); + spin_unlock_irq(&q->queue_lock); + return rqos; +} +EXPORT_SYMBOL_GPL(rq_qos_get); + +void rq_qos_put(struct rq_qos *rqos) +{ + struct request_queue *q = rqos->q; + + spin_lock_irq(&q->queue_lock); + refcount_dec(&rqos->ref); + if (rqos->dying) + wake_up(&rqos->waitq); + spin_unlock_irq(&q->queue_lock); +} +EXPORT_SYMBOL_GPL(rq_qos_put); + +void rq_qos_activate(struct request_queue *q, + struct rq_qos *rqos, const struct rq_qos_ops *ops) +{ + struct rq_qos *pos; + + rqos->dying = false; + refcount_set(&rqos->ref, 1); + init_waitqueue_head(&rqos->waitq); + rqos->id = ops->id; + rqos->ops = ops; + rqos->q = q; + rqos->next = NULL; + + spin_lock_irq(&q->queue_lock); + pos = q->rq_qos; + if (pos) { + while (pos->next) + pos = pos->next; + pos->next = rqos; + } else { + q->rq_qos = rqos; + } + spin_unlock_irq(&q->queue_lock); + + if (rqos->ops->debugfs_attrs) + blk_mq_debugfs_register_rqos(rqos); + + if (ops->owner) + __module_get(ops->owner); +} +EXPORT_SYMBOL_GPL(rq_qos_activate); + +void rq_qos_deactivate(struct rq_qos *rqos) +{ + struct request_queue *q = rqos->q; + struct rq_qos **cur; + + spin_lock_irq(&q->queue_lock); + rqos->dying = true; + /* + * Drain all of the usage of get/put_rqos() + */ + wait_event_lock_irq(rqos->waitq, + refcount_read(&rqos->ref) == 1, q->queue_lock); + for (cur = &q->rq_qos; *cur; cur = &(*cur)->next) { + if (*cur == rqos) { + *cur = rqos->next; + break; + } + } + spin_unlock_irq(&q->queue_lock); + blk_mq_debugfs_unregister_rqos(rqos); + + if (rqos->ops->owner) + module_put(rqos->ops->owner); +} +EXPORT_SYMBOL_GPL(rq_qos_deactivate); + +static struct rq_qos_ops *rq_qos_op_find(const char *name) +{ + struct rq_qos_ops *pos; + + list_for_each_entry(pos, &rq_qos_list, node) { + if (!strncmp(pos->name, name, strlen(pos->name))) + return pos; + } + + return NULL; +} + +int rq_qos_register(struct rq_qos_ops *ops) +{ + int ret, start; + + mutex_lock(&rq_qos_mutex); + + if (rq_qos_op_find(ops->name)) { + ret = -EEXIST; + goto out; + } + + if (ops->flags & RQOS_FLAG_CGRP_POL && + nr_rqos_blkcg_pols >= (BLKCG_MAX_POLS - BLKCG_NON_RQOS_POLS)) { + ret = -ENOSPC; + goto out; + } + + start = RQ_QOS_IOPRIO + 1; + ret = ida_simple_get(&rq_qos_ida, start, INT_MAX, GFP_KERNEL); + if (ret < 0) + goto out; + + if (ops->flags & RQOS_FLAG_CGRP_POL) + nr_rqos_blkcg_pols++; + + ops->id = ret; + ret = 0; + INIT_LIST_HEAD(&ops->node); + list_add_tail(&ops->node, &rq_qos_list); +out: + mutex_unlock(&rq_qos_mutex); + return ret; +} +EXPORT_SYMBOL_GPL(rq_qos_register); + +void rq_qos_unregister(struct rq_qos_ops *ops) +{ + mutex_lock(&rq_qos_mutex); + + if (ops->flags & RQOS_FLAG_CGRP_POL) + nr_rqos_blkcg_pols--; + list_del_init(&ops->node); + ida_simple_remove(&rq_qos_ida, ops->id); + mutex_unlock(&rq_qos_mutex); +} +EXPORT_SYMBOL_GPL(rq_qos_unregister); + +ssize_t queue_qos_show(struct request_queue *q, char *buf) +{ + struct rq_qos_ops *ops; + struct rq_qos *rqos; + int ret = 0; + + mutex_lock(&rq_qos_mutex); + /* + * Show the policies in the order of being invoked. + * queue_lock is not needed here as the sysfs_lock is + * protected us from the queue_qos_store() + */ + for (rqos = q->rq_qos; rqos; rqos = rqos->next) { + if (!rqos->ops->name) + continue; + ret += sprintf(buf + ret, "[%s] ", rqos->ops->name); + } + list_for_each_entry(ops, &rq_qos_list, node) { + if (!rq_qos_by_name(q, ops->name)) + ret += sprintf(buf + ret, "%s ", ops->name); + } + + ret--; /* overwrite the last space */ + ret += sprintf(buf + ret, "\n"); + mutex_unlock(&rq_qos_mutex); + + return ret; +} + +int rq_qos_switch(struct request_queue *q, + const struct rq_qos_ops *ops, + struct rq_qos *rqos) +{ + int ret; + + blk_mq_freeze_queue(q); + if (!rqos) { + ret = ops->init(q); + } else { + ops->exit(rqos); + ret = 0; + } + blk_mq_unfreeze_queue(q); + + return ret; +} + +ssize_t queue_qos_store(struct request_queue *q, const char *page, + size_t count) +{ + const struct rq_qos_ops *ops; + struct rq_qos *rqos; + const char *qosname; + char *buf; + bool add; + int ret; + + if (!blk_queue_registered(q)) + return -ENOENT; + + buf = kstrdup(page, GFP_KERNEL); + if (!buf) + return -ENOMEM; + + buf = strim(buf); + if (buf[0] != '+' && buf[0] != '-') { + ret = -EINVAL; + goto out; + } + + add = buf[0] == '+'; + qosname = buf + 1; + + rqos = rq_qos_by_name(q, qosname); + if ((buf[0] == '+' && rqos)) { + ret = -EEXIST; + goto out; + } + + if ((buf[0] == '-' && !rqos)) { + ret = -ENODEV; + goto out; + } + + if (add) { + mutex_lock(&rq_qos_mutex); + ops = rq_qos_op_find(qosname); + if (!ops) { + /* + * module_init callback may request this mutex + */ + mutex_unlock(&rq_qos_mutex); + request_module("%s", qosname); + mutex_lock(&rq_qos_mutex); + ops = rq_qos_op_find(qosname); + } + if (!ops) { + ret = -EINVAL; + } else if (ops->owner && !try_module_get(ops->owner)) { + ops = NULL; + ret = -EAGAIN; + } + mutex_unlock(&rq_qos_mutex); + if (!ops) + goto out; + } else { + ops = rqos->ops; + } + + ret = rq_qos_switch(q, ops, add ? NULL : rqos); + + if (add) + module_put(ops->owner); +out: + kfree(buf); + return ret ? ret : count; } diff --git a/block/blk-rq-qos.h b/block/blk-rq-qos.h index 3cfbc8668cba..586c3f5ec152 100644 --- a/block/blk-rq-qos.h +++ b/block/blk-rq-qos.h @@ -26,16 +26,28 @@ struct rq_wait { }; struct rq_qos { - struct rq_qos_ops *ops; + const struct rq_qos_ops *ops; struct request_queue *q; enum rq_qos_id id; + refcount_t ref; + wait_queue_head_t waitq; + bool dying; struct rq_qos *next; #ifdef CONFIG_BLK_DEBUG_FS struct dentry *debugfs_dir; #endif }; +enum { + RQOS_FLAG_CGRP_POL = 1 << 0, +}; + struct rq_qos_ops { + struct list_head node; + struct module *owner; + const char *name; + int flags; + int id; void (*throttle)(struct rq_qos *, struct bio *); void (*track)(struct rq_qos *, struct request *, struct bio *); void (*merge)(struct rq_qos *, struct request *, struct bio *); @@ -46,6 +58,7 @@ struct rq_qos_ops { void (*cleanup)(struct rq_qos *, struct bio *); void (*queue_depth_changed)(struct rq_qos *); void (*exit)(struct rq_qos *); + int (*init)(struct request_queue *); const struct blk_mq_debugfs_attr *debugfs_attrs; }; @@ -70,6 +83,19 @@ static inline struct rq_qos *rq_qos_id(struct request_queue *q, return rqos; } +static inline struct rq_qos *rq_qos_by_id(struct request_queue *q, int id) +{ + struct rq_qos *rqos; + + WARN_ON(!mutex_is_locked(&q->sysfs_lock) && !spin_is_locked(&q->queue_lock)); + + for (rqos = q->rq_qos; rqos; rqos = rqos->next) { + if (rqos->id == id) + break; + } + return rqos; +} + static inline struct rq_qos *wbt_rq_qos(struct request_queue *q) { return rq_qos_id(q, RQ_QOS_WBT); @@ -132,6 +158,17 @@ static inline void rq_qos_del(struct request_queue *q, struct rq_qos *rqos) blk_mq_debugfs_unregister_rqos(rqos); } +int rq_qos_register(struct rq_qos_ops *ops); +void rq_qos_unregister(struct rq_qos_ops *ops); +void rq_qos_activate(struct request_queue *q, + struct rq_qos *rqos, const struct rq_qos_ops *ops); +void rq_qos_deactivate(struct rq_qos *rqos); +ssize_t queue_qos_show(struct request_queue *q, char *buf); +ssize_t queue_qos_store(struct request_queue *q, const char *page, + size_t count); +struct rq_qos *rq_qos_get(struct request_queue *q, int id); +void rq_qos_put(struct rq_qos *rqos); + typedef bool (acquire_inflight_cb_t)(struct rq_wait *rqw, void *private_data); typedef void (cleanup_cb_t)(struct rq_wait *rqw, void *private_data); diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h index f35aea98bc35..d5698a7cda67 100644 --- a/include/linux/blkdev.h +++ b/include/linux/blkdev.h @@ -44,6 +44,10 @@ struct blk_crypto_profile; * Defined here to simplify include dependency. */ #define BLKCG_MAX_POLS 6 +/* + * Non blk-rq-qos blkcg policies include blk-throttle and bfq + */ +#define BLKCG_NON_RQOS_POLS 2 static inline int blk_validate_block_size(unsigned long bsize) { From patchwork Wed Feb 16 11:48:05 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Wang Jianchao X-Patchwork-Id: 12748472 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id B809BC433F5 for ; Wed, 16 Feb 2022 11:49:44 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232406AbiBPLty (ORCPT ); Wed, 16 Feb 2022 06:49:54 -0500 Received: from mxb-00190b01.gslb.pphosted.com ([23.128.96.19]:56502 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232397AbiBPLtx (ORCPT ); Wed, 16 Feb 2022 06:49:53 -0500 Received: from mail-pj1-x1035.google.com (mail-pj1-x1035.google.com [IPv6:2607:f8b0:4864:20::1035]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 9387C254A6C; Wed, 16 Feb 2022 03:49:41 -0800 (PST) Received: by mail-pj1-x1035.google.com with SMTP id v13-20020a17090ac90d00b001b87bc106bdso6180760pjt.4; Wed, 16 Feb 2022 03:49:41 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=fDL1Twe60USf2xgj32O/RXOb50fO7TEYwGE3ZcD02zk=; b=KnMzaOd+VovKQw2Nl5RMC92jnkyzsrDUqZWcCnGdcMAuIHYguXZ5lA6YoIn3llND2f oLBOujP3f+cXshFSbKXy0MHeQjtSuON0B14CaFftLaFlLxE0SbYgMndX2dY7xDNS/cCR /OIQ/o9za8388+pEQSX+OYHN57RfnOZxDvaM9xd1uRnfbda7xkcjt7Wz7yWu7ylEjV1a IuAlJNauhczUd6K2arLLKFsT4nKmHrqa8AO6hpWnIegcRwP2B8jfnmxOuP+fkzf8hum7 XzVFQ8VUvjrWEdvEgla4GzPKRb0nnsF7mSvAYkqMafZ3Ero1dLq0uZPlKrSiUsOwI6Kg PvXg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=fDL1Twe60USf2xgj32O/RXOb50fO7TEYwGE3ZcD02zk=; b=Svd1VJJXpvFBIQ5b/ERBLXxix5T+kU4eLHgh4iCmYLR+KraT1AGb7YfRv64l8AdHah 6d5OBd1GXZ1wTUf49dt4lUmlQlGXkmfxZ30LXXf63AeTFmDX/3T2q+WZxAwnTRCBzOrc Q8wRMM+kVuXPl2O7prM08MQENdZA9El02sztwT+nnz4L06xDqT87t5aQJI9UrVScYVn+ WD3J0rNn2YSjeyh4baSS6AFqkIqkWVHPhJZD6O+8mMzwLz0TsNeMA3SJ83Zrk5kT0SMW NuhVMPe9NTMlC8ZnifOjbUpjjdvcMafA5Kot95/0FGneXP8Hou7dkY6cOSYvmXz8QnVd tCqA== X-Gm-Message-State: AOAM533xlhZtr+4PoIOkyr0hJYjk2GmaRjAKbgBf9c6N7zTEzN2p2MsW V7PshGrsnRiGLL/V8aOqMJo= X-Google-Smtp-Source: ABdhPJyYcKg75iUjRIxJJ7O1CYyRuOfPhCNBAy8KUNiwUVO33lBoPNaievp5mhLaCaFm4Lmu05VShw== X-Received: by 2002:a17:90b:1a85:b0:1b9:fdd7:ae07 with SMTP id ng5-20020a17090b1a8500b001b9fdd7ae07mr1273573pjb.190.1645012181163; Wed, 16 Feb 2022 03:49:41 -0800 (PST) Received: from localhost.localdomain ([61.16.102.69]) by smtp.gmail.com with ESMTPSA id q1sm26209119pfs.112.2022.02.16.03.49.38 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Feb 2022 03:49:40 -0800 (PST) From: "Wang Jianchao (Kuaishou)" To: Jens Axboe Cc: Josef Bacik , Tejun Heo , Bart Van Assche , linux-block@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [RFC V3 2/6] blk-wbt: make wbt pluggable Date: Wed, 16 Feb 2022 19:48:05 +0800 Message-Id: <20220216114809.84551-3-jianchao.wan9@gmail.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20220216114809.84551-1-jianchao.wan9@gmail.com> References: <20220216114809.84551-1-jianchao.wan9@gmail.com> Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org This patch makes wbt pluggable through /sys/block/xxx/queue/qos. Some queue_lock/unlock is added to protect rq_qos_by_id() in wbt_rq_qos(). Signed-off-by: Wang Jianchao (Kuaishou) --- block/blk-mq-debugfs.c | 2 -- block/blk-rq-qos.h | 6 ----- block/blk-wbt.c | 52 +++++++++++++++++++++++++++++++++++------- block/blk-wbt.h | 7 +++++- 4 files changed, 50 insertions(+), 17 deletions(-) diff --git a/block/blk-mq-debugfs.c b/block/blk-mq-debugfs.c index 4da803bf5617..5094c2d3700a 100644 --- a/block/blk-mq-debugfs.c +++ b/block/blk-mq-debugfs.c @@ -826,8 +826,6 @@ void blk_mq_debugfs_unregister_sched(struct request_queue *q) static const char *rq_qos_id_to_name(enum rq_qos_id id) { switch (id) { - case RQ_QOS_WBT: - return "wbt"; case RQ_QOS_LATENCY: return "latency"; case RQ_QOS_COST: diff --git a/block/blk-rq-qos.h b/block/blk-rq-qos.h index 586c3f5ec152..171a83d6de45 100644 --- a/block/blk-rq-qos.h +++ b/block/blk-rq-qos.h @@ -14,7 +14,6 @@ struct blk_mq_debugfs_attr; enum rq_qos_id { - RQ_QOS_WBT, RQ_QOS_LATENCY, RQ_QOS_COST, RQ_QOS_IOPRIO, @@ -96,11 +95,6 @@ static inline struct rq_qos *rq_qos_by_id(struct request_queue *q, int id) return rqos; } -static inline struct rq_qos *wbt_rq_qos(struct request_queue *q) -{ - return rq_qos_id(q, RQ_QOS_WBT); -} - static inline struct rq_qos *blkcg_rq_qos(struct request_queue *q) { return rq_qos_id(q, RQ_QOS_LATENCY); diff --git a/block/blk-wbt.c b/block/blk-wbt.c index 0c119be0e813..ad637fcf3919 100644 --- a/block/blk-wbt.c +++ b/block/blk-wbt.c @@ -31,6 +31,13 @@ #define CREATE_TRACE_POINTS #include +static struct rq_qos_ops wbt_rqos_ops; + +struct rq_qos *wbt_rq_qos(struct request_queue *q) +{ + return rq_qos_by_id(q, wbt_rqos_ops.id); +} + static inline void wbt_clear_state(struct request *rq) { rq->wbt_flags = 0; @@ -628,9 +635,13 @@ static void wbt_requeue(struct rq_qos *rqos, struct request *rq) void wbt_set_write_cache(struct request_queue *q, bool write_cache_on) { - struct rq_qos *rqos = wbt_rq_qos(q); + struct rq_qos *rqos; + + spin_lock_irq(&q->queue_lock); + rqos = wbt_rq_qos(q); if (rqos) RQWB(rqos)->wc = write_cache_on; + spin_unlock_irq(&q->queue_lock); } /* @@ -638,14 +649,20 @@ void wbt_set_write_cache(struct request_queue *q, bool write_cache_on) */ void wbt_enable_default(struct request_queue *q) { - struct rq_qos *rqos = wbt_rq_qos(q); + struct rq_qos *rqos; + + spin_lock_irq(&q->queue_lock); + rqos = wbt_rq_qos(q); /* Throttling already enabled? */ if (rqos) { if (RQWB(rqos)->enable_state == WBT_STATE_OFF_DEFAULT) RQWB(rqos)->enable_state = WBT_STATE_ON_DEFAULT; + + spin_unlock_irq(&q->queue_lock); return; } + spin_unlock_irq(&q->queue_lock); /* Queue not registered? Maybe shutting down... */ if (!blk_queue_registered(q)) @@ -692,6 +709,7 @@ static void wbt_exit(struct rq_qos *rqos) struct rq_wb *rwb = RQWB(rqos); struct request_queue *q = rqos->q; + rq_qos_deactivate(rqos); blk_stat_remove_callback(q, rwb->cb); blk_stat_free_callback(rwb->cb); kfree(rwb); @@ -702,15 +720,21 @@ static void wbt_exit(struct rq_qos *rqos) */ void wbt_disable_default(struct request_queue *q) { - struct rq_qos *rqos = wbt_rq_qos(q); + struct rq_qos *rqos; struct rq_wb *rwb; + + spin_lock_irq(&q->queue_lock); + rqos = wbt_rq_qos(q); if (!rqos) - return; + goto out; + rwb = RQWB(rqos); if (rwb->enable_state == WBT_STATE_ON_DEFAULT) { blk_stat_deactivate(rwb->cb); rwb->enable_state = WBT_STATE_OFF_DEFAULT; } +out: + spin_unlock_irq(&q->queue_lock); } EXPORT_SYMBOL_GPL(wbt_disable_default); @@ -802,7 +826,9 @@ static const struct blk_mq_debugfs_attr wbt_debugfs_attrs[] = { }; #endif +int wbt_init(struct request_queue *q); static struct rq_qos_ops wbt_rqos_ops = { + .name = "wbt", .throttle = wbt_wait, .issue = wbt_issue, .track = wbt_track, @@ -811,6 +837,7 @@ static struct rq_qos_ops wbt_rqos_ops = { .cleanup = wbt_cleanup, .queue_depth_changed = wbt_queue_depth_changed, .exit = wbt_exit, + .init = wbt_init, #ifdef CONFIG_BLK_DEBUG_FS .debugfs_attrs = wbt_debugfs_attrs, #endif @@ -834,9 +861,6 @@ int wbt_init(struct request_queue *q) for (i = 0; i < WBT_NUM_RWQ; i++) rq_wait_init(&rwb->rq_wait[i]); - rwb->rqos.id = RQ_QOS_WBT; - rwb->rqos.ops = &wbt_rqos_ops; - rwb->rqos.q = q; rwb->last_comp = rwb->last_issue = jiffies; rwb->win_nsec = RWB_WINDOW_NSEC; rwb->enable_state = WBT_STATE_ON_DEFAULT; @@ -846,7 +870,7 @@ int wbt_init(struct request_queue *q) /* * Assign rwb and add the stats callback. */ - rq_qos_add(q, &rwb->rqos); + rq_qos_activate(q, &rwb->rqos, &wbt_rqos_ops); blk_stat_add_callback(q, rwb->cb); rwb->min_lat_nsec = wbt_default_latency_nsec(q); @@ -856,3 +880,15 @@ int wbt_init(struct request_queue *q) return 0; } + +static __init int wbt_mod_init(void) +{ + return rq_qos_register(&wbt_rqos_ops); +} + +static __exit void wbt_mod_exit(void) +{ + return rq_qos_unregister(&wbt_rqos_ops); +} +module_init(wbt_mod_init); +module_exit(wbt_mod_exit); diff --git a/block/blk-wbt.h b/block/blk-wbt.h index 2eb01becde8c..998e23f8bb57 100644 --- a/block/blk-wbt.h +++ b/block/blk-wbt.h @@ -87,7 +87,7 @@ static inline unsigned int wbt_inflight(struct rq_wb *rwb) #ifdef CONFIG_BLK_WBT - +struct rq_qos *wbt_rq_qos(struct request_queue *q); int wbt_init(struct request_queue *); void wbt_disable_default(struct request_queue *); void wbt_enable_default(struct request_queue *); @@ -101,6 +101,11 @@ u64 wbt_default_latency_nsec(struct request_queue *); #else +static inline struct rq_qos *wbt_rq_qos(struct request_queue *q) +{ + return NULL; +} + static inline void wbt_track(struct request *rq, enum wbt_flags flags) { } From patchwork Wed Feb 16 11:48:06 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Wang Jianchao X-Patchwork-Id: 12748473 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 317CEC433EF for ; Wed, 16 Feb 2022 11:49:53 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232446AbiBPLuD (ORCPT ); Wed, 16 Feb 2022 06:50:03 -0500 Received: from mxb-00190b01.gslb.pphosted.com ([23.128.96.19]:56822 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232427AbiBPLt4 (ORCPT ); Wed, 16 Feb 2022 06:49:56 -0500 Received: from mail-pj1-x102c.google.com (mail-pj1-x102c.google.com [IPv6:2607:f8b0:4864:20::102c]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5BD501CFA35; Wed, 16 Feb 2022 03:49:44 -0800 (PST) Received: by mail-pj1-x102c.google.com with SMTP id y9so2187521pjf.1; Wed, 16 Feb 2022 03:49:44 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=/PFb/0cBLQV+uKEKVqTk2arsQ0Wb2EWF5MUutWYpsZM=; b=qXP7n62Q8GDdHxpwO7YXTbt9kAPrkZZ8iujcpJeLAoWwV9XCvi1iB4Vvq+3ZSvkFb4 StPfj/dRRWqkXYGCZh2r7Z62+dpP0pOqcY+b4Emb0sGF76rJpto7ldA5VJO0qmKGAuBU TvT7a3nY6i+9w8tKXmPe3YFKBWFpzWjqDjdce9i1qxrZiUAvOE4lXaWB4T2n72mIPdt5 bhmFK1nmwZ3UdgxPWFApOGXTlWORByOc7XkkmemYUsRoe8LKjnHcqpqlm+7yUjou+RtZ k5o/YCjF1TTJ7U0G715siyHMl1bmI1skEcRXqKhV0L5OPSq+LJl9PeyIUr8QmH4gs7uQ n9Ug== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=/PFb/0cBLQV+uKEKVqTk2arsQ0Wb2EWF5MUutWYpsZM=; b=LbdK/LD1CzTEbpE8c1ZbQaDqQOf2sbf+04JX4yrgq7I/mdqRr2QiUTquSWxYmW3bBC GRFfJ3dsXnXE4DawnQOu3mkMKgCtkyX/nJbMJTNrSvHwBWDBvKZ02CyGnpc8ViUIdIba 2Pa4HPg3Qr2XadYLaPX/xLNveJIf4CRWgUiqj90KIZUtK4+G4F7vT1jt4Bc/G9OW3vg1 ihYwgMoqk6UnLMBhY8az6Rwyaccx192a9MY1NoIokHFH4ibvWz3ovlf0rBevlnv0pNpI oiptAt2AEUbCpY28MLc03Ul3GJYqf+B9pmroCCEjgQQcsmJ/yUYsx5WbXIrpb27G+5Ro 6Uvw== X-Gm-Message-State: AOAM5326Ux5Claso5q7KkzMHD+adjuv3//2FkyBE7c0GB6cHn9yJQsIs yZ7M7xzkxLlOOwHCOUnrLxU= X-Google-Smtp-Source: ABdhPJyOOIfs4iwf4ctUDaFKQGdjhuqAOMo3KCjAFd5ClE1lstGITqLEN+KprkpaOzo+SQ86BzaEZQ== X-Received: by 2002:a17:90b:3e8c:b0:1b8:a738:9f84 with SMTP id rj12-20020a17090b3e8c00b001b8a7389f84mr1287270pjb.232.1645012183888; Wed, 16 Feb 2022 03:49:43 -0800 (PST) Received: from localhost.localdomain ([61.16.102.69]) by smtp.gmail.com with ESMTPSA id q1sm26209119pfs.112.2022.02.16.03.49.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Feb 2022 03:49:43 -0800 (PST) From: "Wang Jianchao (Kuaishou)" To: Jens Axboe Cc: Josef Bacik , Tejun Heo , Bart Van Assche , linux-block@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [RFC V3 3/6] blk-iolatency: make iolatency pluggable Date: Wed, 16 Feb 2022 19:48:06 +0800 Message-Id: <20220216114809.84551-4-jianchao.wan9@gmail.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20220216114809.84551-1-jianchao.wan9@gmail.com> References: <20220216114809.84551-1-jianchao.wan9@gmail.com> Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org Make blk-iolatency pluggable. Then we can close or open it through /sys/block/xxx/queue/qos. Signed-off-by: Wang Jianchao (Kuaishou) --- block/blk-cgroup.c | 6 ------ block/blk-iolatency.c | 33 +++++++++++++++++++++++++-------- block/blk-mq-debugfs.c | 2 -- block/blk-rq-qos.h | 6 ------ block/blk.h | 6 ------ 5 files changed, 25 insertions(+), 28 deletions(-) diff --git a/block/blk-cgroup.c b/block/blk-cgroup.c index 650f7e27989f..3ae2aa557aef 100644 --- a/block/blk-cgroup.c +++ b/block/blk-cgroup.c @@ -1203,12 +1203,6 @@ int blkcg_init_queue(struct request_queue *q) if (ret) goto err_destroy_all; - ret = blk_iolatency_init(q); - if (ret) { - blk_throtl_exit(q); - goto err_destroy_all; - } - return 0; err_destroy_all: diff --git a/block/blk-iolatency.c b/block/blk-iolatency.c index 6593c7123b97..b0596a7a35f0 100644 --- a/block/blk-iolatency.c +++ b/block/blk-iolatency.c @@ -90,6 +90,12 @@ struct blk_iolatency { atomic_t enabled; }; +static struct rq_qos_ops blkcg_iolatency_ops; +static inline struct rq_qos *blkcg_rq_qos(struct request_queue *q) +{ + return rq_qos_by_id(q, blkcg_iolatency_ops.id); +} + static inline struct blk_iolatency *BLKIOLATENCY(struct rq_qos *rqos) { return container_of(rqos, struct blk_iolatency, rqos); @@ -646,13 +652,18 @@ static void blkcg_iolatency_exit(struct rq_qos *rqos) del_timer_sync(&blkiolat->timer); blkcg_deactivate_policy(rqos->q, &blkcg_policy_iolatency); + rq_qos_deactivate(rqos); kfree(blkiolat); } +static int blk_iolatency_init(struct request_queue *q); static struct rq_qos_ops blkcg_iolatency_ops = { + .name = "iolat", + .flags = RQOS_FLAG_CGRP_POL, .throttle = blkcg_iolatency_throttle, .done_bio = blkcg_iolatency_done_bio, .exit = blkcg_iolatency_exit, + .init = blk_iolatency_init, }; static void blkiolatency_timer_fn(struct timer_list *t) @@ -727,15 +738,10 @@ int blk_iolatency_init(struct request_queue *q) return -ENOMEM; rqos = &blkiolat->rqos; - rqos->id = RQ_QOS_LATENCY; - rqos->ops = &blkcg_iolatency_ops; - rqos->q = q; - - rq_qos_add(q, rqos); - + rq_qos_activate(q, rqos, &blkcg_iolatency_ops); ret = blkcg_activate_policy(q, &blkcg_policy_iolatency); if (ret) { - rq_qos_del(q, rqos); + rq_qos_deactivate(rqos); kfree(blkiolat); return ret; } @@ -1046,12 +1052,23 @@ static struct blkcg_policy blkcg_policy_iolatency = { static int __init iolatency_init(void) { - return blkcg_policy_register(&blkcg_policy_iolatency); + int ret; + + ret = rq_qos_register(&blkcg_iolatency_ops); + if (ret) + return ret; + + ret = blkcg_policy_register(&blkcg_policy_iolatency); + if (ret) + rq_qos_unregister(&blkcg_iolatency_ops); + + return ret; } static void __exit iolatency_exit(void) { blkcg_policy_unregister(&blkcg_policy_iolatency); + rq_qos_unregister(&blkcg_iolatency_ops); } module_init(iolatency_init); diff --git a/block/blk-mq-debugfs.c b/block/blk-mq-debugfs.c index 5094c2d3700a..ec1f74bdea74 100644 --- a/block/blk-mq-debugfs.c +++ b/block/blk-mq-debugfs.c @@ -826,8 +826,6 @@ void blk_mq_debugfs_unregister_sched(struct request_queue *q) static const char *rq_qos_id_to_name(enum rq_qos_id id) { switch (id) { - case RQ_QOS_LATENCY: - return "latency"; case RQ_QOS_COST: return "cost"; case RQ_QOS_IOPRIO: diff --git a/block/blk-rq-qos.h b/block/blk-rq-qos.h index 171a83d6de45..2a919db52fef 100644 --- a/block/blk-rq-qos.h +++ b/block/blk-rq-qos.h @@ -14,7 +14,6 @@ struct blk_mq_debugfs_attr; enum rq_qos_id { - RQ_QOS_LATENCY, RQ_QOS_COST, RQ_QOS_IOPRIO, }; @@ -95,11 +94,6 @@ static inline struct rq_qos *rq_qos_by_id(struct request_queue *q, int id) return rqos; } -static inline struct rq_qos *blkcg_rq_qos(struct request_queue *q) -{ - return rq_qos_id(q, RQ_QOS_LATENCY); -} - static inline void rq_wait_init(struct rq_wait *rq_wait) { atomic_set(&rq_wait->inflight, 0); diff --git a/block/blk.h b/block/blk.h index 8bd43b3ad33d..1a314257b6a3 100644 --- a/block/blk.h +++ b/block/blk.h @@ -400,12 +400,6 @@ static inline void blk_queue_bounce(struct request_queue *q, struct bio **bio) __blk_queue_bounce(q, bio); } -#ifdef CONFIG_BLK_CGROUP_IOLATENCY -extern int blk_iolatency_init(struct request_queue *q); -#else -static inline int blk_iolatency_init(struct request_queue *q) { return 0; } -#endif - struct bio *blk_next_bio(struct bio *bio, unsigned int nr_pages, gfp_t gfp); #ifdef CONFIG_BLK_DEV_ZONED From patchwork Wed Feb 16 11:48:07 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Wang Jianchao X-Patchwork-Id: 12748474 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 598E6C433F5 for ; Wed, 16 Feb 2022 11:49:55 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232430AbiBPLuF (ORCPT ); Wed, 16 Feb 2022 06:50:05 -0500 Received: from mxb-00190b01.gslb.pphosted.com ([23.128.96.19]:57298 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232453AbiBPLuD (ORCPT ); Wed, 16 Feb 2022 06:50:03 -0500 Received: from mail-pj1-x102c.google.com (mail-pj1-x102c.google.com [IPv6:2607:f8b0:4864:20::102c]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 3C159255789; Wed, 16 Feb 2022 03:49:47 -0800 (PST) Received: by mail-pj1-x102c.google.com with SMTP id v13-20020a17090ac90d00b001b87bc106bdso6180950pjt.4; Wed, 16 Feb 2022 03:49:47 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=2/BO+Owg3YijmylK7t1XTOPvhHZDRNI4YZ1y+bPLKuc=; b=oUclNyyNbNEFDL8a1EB4uhsGPrriY8QKiDFAtdIolxtXaCPZsa9Owb5K0fVpDwxh5F Ja474iJDWtl1Zt7+lBjEiGfuSkiX7PV+y3p+6LkYae/TzZD66wikkWTCSA4UitHPtITA TJrdqA9YLa7TTQylLMhmOraiqYQBJRtLswI8KSFDFbMK+JOwO7kL3s9P5lRbf/5EDIZ1 33sPzqvN5cSNTjFCUaKnAY7pmNSP1ARnBGwhEn5OFgkoaID7P0+02tovhi0GMmI5IoLB Ac7aHu3UeVbOtKUenIKxEWpJyproyZQZJX0G0ZHq34umKdbFCJWdMKb2vO1dXVsKNB19 C3vQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=2/BO+Owg3YijmylK7t1XTOPvhHZDRNI4YZ1y+bPLKuc=; b=n6urMyPXdPfX57lZ+AvP2Bl7CbRSm+wKL98EF4Pl8uai9skWfzFLzGA2+6QnHSy3wy ZQdY8oHDBoH8n+mepRP+EHJ6b0aEGFX/WxBsuzmHed7io6taRP8ZQw3n98E9rMGuhS0L YfyBtO7TXEQmigLnvj11nhB3ps1NXkFQWyyj38addtZbAyZaWlKTWamBxOT6NPRlQ5Nx fDAToiSXG2lDM1a1ufLLTDBYkdyQlukLfrKoNC+ND0SSHSn0d1jiLr8vh+gFe7fpSV6A 8DEfeN4CXZOYC5Ih/ngcEXuR/uUr4MyrjUMJRyd4z+ZpgGYNGBZfGHbiGsbqIm9bT5pM BoIQ== X-Gm-Message-State: AOAM530qw8Y7NA61mWWmPdXEqvRUnahoVgCql34zY+x99hD16F3MhVAo 4kTe5dTICvL6b6waGyWGvoA= X-Google-Smtp-Source: ABdhPJx8Mlag9h5oMSwDg9Rz81/G2w6S6xq0QGtH6Xq8Vn5QkfkBiZNmyjWph9PCuDQISN+znXZqdw== X-Received: by 2002:a17:902:7293:b0:14e:e9f3:24a2 with SMTP id d19-20020a170902729300b0014ee9f324a2mr2523738pll.72.1645012186581; Wed, 16 Feb 2022 03:49:46 -0800 (PST) Received: from localhost.localdomain ([61.16.102.69]) by smtp.gmail.com with ESMTPSA id q1sm26209119pfs.112.2022.02.16.03.49.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Feb 2022 03:49:46 -0800 (PST) From: "Wang Jianchao (Kuaishou)" To: Jens Axboe Cc: Josef Bacik , Tejun Heo , Bart Van Assche , linux-block@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [RFC V3 4/6] blk-iocost: make iocost pluggable Date: Wed, 16 Feb 2022 19:48:07 +0800 Message-Id: <20220216114809.84551-5-jianchao.wan9@gmail.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20220216114809.84551-1-jianchao.wan9@gmail.com> References: <20220216114809.84551-1-jianchao.wan9@gmail.com> Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org Make blk-iocost pluggable. Then we can close or open it through /sys/block/xxx/queue/qos. Signed-off-by: Wang Jianchao (Kuaishou) --- block/blk-iocost.c | 49 ++++++++++++++++++++++++++---------------- block/blk-mq-debugfs.c | 2 -- block/blk-rq-qos.h | 1 - 3 files changed, 30 insertions(+), 22 deletions(-) diff --git a/block/blk-iocost.c b/block/blk-iocost.c index 769b64394298..73978b540e37 100644 --- a/block/blk-iocost.c +++ b/block/blk-iocost.c @@ -660,9 +660,10 @@ static struct ioc *rqos_to_ioc(struct rq_qos *rqos) return container_of(rqos, struct ioc, rqos); } +static struct rq_qos_ops ioc_rqos_ops; static struct ioc *q_to_ioc(struct request_queue *q) { - return rqos_to_ioc(rq_qos_id(q, RQ_QOS_COST)); + return rqos_to_ioc(rq_qos_by_id(q, ioc_rqos_ops.id)); } static const char *q_name(struct request_queue *q) @@ -2810,6 +2811,7 @@ static void ioc_rqos_exit(struct rq_qos *rqos) struct ioc *ioc = rqos_to_ioc(rqos); blkcg_deactivate_policy(rqos->q, &blkcg_policy_iocost); + rq_qos_deactivate(rqos); spin_lock_irq(&ioc->lock); ioc->running = IOC_STOP; @@ -2820,13 +2822,17 @@ static void ioc_rqos_exit(struct rq_qos *rqos) kfree(ioc); } +static int blk_iocost_init(struct request_queue *q); static struct rq_qos_ops ioc_rqos_ops = { + .name = "iocost", + .flags = RQOS_FLAG_CGRP_POL, .throttle = ioc_rqos_throttle, .merge = ioc_rqos_merge, .done_bio = ioc_rqos_done_bio, .done = ioc_rqos_done, .queue_depth_changed = ioc_rqos_queue_depth_changed, .exit = ioc_rqos_exit, + .init = blk_iocost_init, }; static int blk_iocost_init(struct request_queue *q) @@ -2856,10 +2862,7 @@ static int blk_iocost_init(struct request_queue *q) } rqos = &ioc->rqos; - rqos->id = RQ_QOS_COST; - rqos->ops = &ioc_rqos_ops; - rqos->q = q; - + rq_qos_activate(q, rqos, &ioc_rqos_ops); spin_lock_init(&ioc->lock); timer_setup(&ioc->timer, ioc_timer_fn, 0); INIT_LIST_HEAD(&ioc->active_iocgs); @@ -2883,10 +2886,9 @@ static int blk_iocost_init(struct request_queue *q) * called before policy activation completion, can't assume that the * target bio has an iocg associated and need to test for NULL iocg. */ - rq_qos_add(q, rqos); ret = blkcg_activate_policy(q, &blkcg_policy_iocost); if (ret) { - rq_qos_del(q, rqos); + rq_qos_deactivate(rqos); free_percpu(ioc->pcpu_stat); kfree(ioc); return ret; @@ -3162,6 +3164,7 @@ static ssize_t ioc_qos_write(struct kernfs_open_file *of, char *input, size_t nbytes, loff_t off) { struct block_device *bdev; + struct rq_qos *rqos; struct ioc *ioc; u32 qos[NR_QOS_PARAMS]; bool enable, user; @@ -3172,12 +3175,10 @@ static ssize_t ioc_qos_write(struct kernfs_open_file *of, char *input, if (IS_ERR(bdev)) return PTR_ERR(bdev); - ioc = q_to_ioc(bdev_get_queue(bdev)); - if (!ioc) { - ret = blk_iocost_init(bdev_get_queue(bdev)); - if (ret) - goto err; - ioc = q_to_ioc(bdev_get_queue(bdev)); + rqos = rq_qos_get(bdev_get_queue(bdev), ioc_rqos_ops.id); + if (!rqos) { + ret = -EOPNOTSUPP; + goto err; } spin_lock_irq(&ioc->lock); @@ -3329,6 +3330,7 @@ static ssize_t ioc_cost_model_write(struct kernfs_open_file *of, char *input, size_t nbytes, loff_t off) { struct block_device *bdev; + struct rq_qos *rqos; struct ioc *ioc; u64 u[NR_I_LCOEFS]; bool user; @@ -3339,12 +3341,10 @@ static ssize_t ioc_cost_model_write(struct kernfs_open_file *of, char *input, if (IS_ERR(bdev)) return PTR_ERR(bdev); - ioc = q_to_ioc(bdev_get_queue(bdev)); + rqos = rq_qos_get(bdev_get_queue(bdev), ioc_rqos_ops.id); if (!ioc) { - ret = blk_iocost_init(bdev_get_queue(bdev)); - if (ret) - goto err; - ioc = q_to_ioc(bdev_get_queue(bdev)); + ret = -EOPNOTSUPP; + goto err; } spin_lock_irq(&ioc->lock); @@ -3441,12 +3441,23 @@ static struct blkcg_policy blkcg_policy_iocost = { static int __init ioc_init(void) { - return blkcg_policy_register(&blkcg_policy_iocost); + int ret; + + ret = rq_qos_register(&ioc_rqos_ops); + if (ret) + return ret; + + ret = blkcg_policy_register(&blkcg_policy_iocost); + if (ret) + rq_qos_unregister(&ioc_rqos_ops); + + return ret; } static void __exit ioc_exit(void) { blkcg_policy_unregister(&blkcg_policy_iocost); + rq_qos_unregister(&ioc_rqos_ops); } module_init(ioc_init); diff --git a/block/blk-mq-debugfs.c b/block/blk-mq-debugfs.c index ec1f74bdea74..652cd754dbd3 100644 --- a/block/blk-mq-debugfs.c +++ b/block/blk-mq-debugfs.c @@ -826,8 +826,6 @@ void blk_mq_debugfs_unregister_sched(struct request_queue *q) static const char *rq_qos_id_to_name(enum rq_qos_id id) { switch (id) { - case RQ_QOS_COST: - return "cost"; case RQ_QOS_IOPRIO: return "ioprio"; } diff --git a/block/blk-rq-qos.h b/block/blk-rq-qos.h index 2a919db52fef..6d691527cb51 100644 --- a/block/blk-rq-qos.h +++ b/block/blk-rq-qos.h @@ -14,7 +14,6 @@ struct blk_mq_debugfs_attr; enum rq_qos_id { - RQ_QOS_COST, RQ_QOS_IOPRIO, }; From patchwork Wed Feb 16 11:48:08 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Wang Jianchao X-Patchwork-Id: 12748475 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9B2FDC433F5 for ; Wed, 16 Feb 2022 11:50:00 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232520AbiBPLuK (ORCPT ); Wed, 16 Feb 2022 06:50:10 -0500 Received: from mxb-00190b01.gslb.pphosted.com ([23.128.96.19]:57286 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232462AbiBPLuE (ORCPT ); Wed, 16 Feb 2022 06:50:04 -0500 Received: from mail-pg1-x534.google.com (mail-pg1-x534.google.com [IPv6:2607:f8b0:4864:20::534]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id C3F372560F6; Wed, 16 Feb 2022 03:49:49 -0800 (PST) Received: by mail-pg1-x534.google.com with SMTP id s16so1902534pgs.13; Wed, 16 Feb 2022 03:49:49 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=s9sH4Ya4Z/3kq4RhnFqriNyS1UnoAGX2fvLMWDQ5WWg=; b=QdiVKTeEOAvbArd8oOVN9+JePQlTCEB4PUGvUFdcWGQ91gAJ3rrtvk/XTlIR+J4Lvu s9rWVOg4Oh+m9VauUrP2omm+m4Gx7zkTQBRCXtKwlU6gjdTj83CTaVoICuy8ghe/92mZ lmNP2njcP+sgaxqss2o1ALmUd9vL9mELTk9iuFAaRbMn+Wt3hy2TnRUScaIALaxImJ96 WT8wcDTVpbZjvV4YJ7ifvUY0CpmhrM2BRNJjkeE1tGvETvssuR3vWjJViIdvOYwf11ti ecc9/9yK+M3nU5caAQigusVZMoGMd5NViULRp8ru5E9/YYMMC/HSTXcWQLu6GjiGBed5 s3EQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=s9sH4Ya4Z/3kq4RhnFqriNyS1UnoAGX2fvLMWDQ5WWg=; b=aezuUF5dq5mrsKT4enIDRG+lJK4YGuXDj8HIOcv0EeIB5cuvclTbHeEQouu0dg0Cdf GyZVg/vd/kGQ7jbgUE7uRV2LLW4/clPYmHC3Frjn1tGp5QdY+gnNdH+nSmDxVVUkW+/V Z1wwPFsPMLWRp70u2VxqzbNKcxSO05lcd+uqnFBpF0HHMCrFkOt+S9Ayo1nqu/rutS/a hZpcWaNSETANCGZTiK8ij0k+pQAcB0Sab9AIdPyBu2Y+NoJNS81ETKZ+ci8vtP6AwPKv 5ktcdmv45Xd5MYn3P1+/Fn+vokfMfI/3hQvmVqHxm703hPs3PKO194UIFBfwUhkWwmV9 wpLg== X-Gm-Message-State: AOAM5334zie9xNBipRcfTL2FvSMYBV9HVnpatkANghKI4tTPziu/F4HA mOi321DJfiAWeYCOIojcF4615QK0/l3HTS4m X-Google-Smtp-Source: ABdhPJyLuJomcv5qQ4l2ctZZBwJeMjoUZoQd7B7T2MYZ3KniHyAMViRu0AycbWYUTUiILO5zWfQ+xg== X-Received: by 2002:a05:6a00:1d0c:b0:4e1:9846:3f34 with SMTP id a12-20020a056a001d0c00b004e198463f34mr2053850pfx.59.1645012189309; Wed, 16 Feb 2022 03:49:49 -0800 (PST) Received: from localhost.localdomain ([61.16.102.69]) by smtp.gmail.com with ESMTPSA id q1sm26209119pfs.112.2022.02.16.03.49.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Feb 2022 03:49:49 -0800 (PST) From: "Wang Jianchao (Kuaishou)" To: Jens Axboe Cc: Josef Bacik , Tejun Heo , Bart Van Assche , linux-block@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [RFC V3 5/6] blk-ioprio: make ioprio pluggable and modular Date: Wed, 16 Feb 2022 19:48:08 +0800 Message-Id: <20220216114809.84551-6-jianchao.wan9@gmail.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20220216114809.84551-1-jianchao.wan9@gmail.com> References: <20220216114809.84551-1-jianchao.wan9@gmail.com> Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org Make blk-ioprio pluggable and modular. Then we can close or open it through /sys/block/xxx/queue/qos and rmmod the module if we don't need it which can release one blkcg policy slot. Signed-off-by: Wang Jianchao (Kuaishou) --- block/Kconfig | 2 +- block/Makefile | 3 ++- block/blk-cgroup.c | 5 ----- block/blk-ioprio.c | 50 ++++++++++++++++++++++++++++-------------- block/blk-ioprio.h | 19 ---------------- block/blk-mq-debugfs.c | 4 ---- block/blk-rq-qos.c | 2 +- block/blk-rq-qos.h | 2 +- 8 files changed, 38 insertions(+), 49 deletions(-) delete mode 100644 block/blk-ioprio.h diff --git a/block/Kconfig b/block/Kconfig index d5d4197b7ed2..9cc8e4688953 100644 --- a/block/Kconfig +++ b/block/Kconfig @@ -145,7 +145,7 @@ config BLK_CGROUP_IOCOST their share of the overall weight distribution. config BLK_CGROUP_IOPRIO - bool "Cgroup I/O controller for assigning an I/O priority class" + tristate "Cgroup I/O controller for assigning an I/O priority class" depends on BLK_CGROUP help Enable the .prio interface for assigning an I/O priority class to diff --git a/block/Makefile b/block/Makefile index f38eaa612929..f6a3995af285 100644 --- a/block/Makefile +++ b/block/Makefile @@ -17,7 +17,8 @@ obj-$(CONFIG_BLK_DEV_BSGLIB) += bsg-lib.o obj-$(CONFIG_BLK_CGROUP) += blk-cgroup.o obj-$(CONFIG_BLK_CGROUP_RWSTAT) += blk-cgroup-rwstat.o obj-$(CONFIG_BLK_DEV_THROTTLING) += blk-throttle.o -obj-$(CONFIG_BLK_CGROUP_IOPRIO) += blk-ioprio.o +io-prio-y := blk-ioprio.o +obj-$(CONFIG_BLK_CGROUP_IOPRIO) += io-prio.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 diff --git a/block/blk-cgroup.c b/block/blk-cgroup.c index 3ae2aa557aef..f617f7ba311d 100644 --- a/block/blk-cgroup.c +++ b/block/blk-cgroup.c @@ -32,7 +32,6 @@ #include #include #include "blk.h" -#include "blk-ioprio.h" #include "blk-throttle.h" /* @@ -1195,10 +1194,6 @@ int blkcg_init_queue(struct request_queue *q) if (preloaded) radix_tree_preload_end(); - ret = blk_ioprio_init(q); - if (ret) - goto err_destroy_all; - ret = blk_throtl_init(q); if (ret) goto err_destroy_all; diff --git a/block/blk-ioprio.c b/block/blk-ioprio.c index 2e7f10e1c03f..074cc0978d0b 100644 --- a/block/blk-ioprio.c +++ b/block/blk-ioprio.c @@ -17,7 +17,6 @@ #include #include #include -#include "blk-ioprio.h" #include "blk-rq-qos.h" /** @@ -216,15 +215,23 @@ static void blkcg_ioprio_exit(struct rq_qos *rqos) container_of(rqos, typeof(*blkioprio_blkg), rqos); blkcg_deactivate_policy(rqos->q, &ioprio_policy); + rq_qos_deactivate(rqos); kfree(blkioprio_blkg); } +static int blk_ioprio_init(struct request_queue *q); static struct rq_qos_ops blkcg_ioprio_ops = { +#if IS_MODULE(CONFIG_BLK_CGROUP_IOPRIO) + .owner = THIS_MODULE, +#endif + .flags = RQOS_FLAG_CGRP_POL, + .name = "io-prio", .track = blkcg_ioprio_track, .exit = blkcg_ioprio_exit, + .init = blk_ioprio_init, }; -int blk_ioprio_init(struct request_queue *q) +static int blk_ioprio_init(struct request_queue *q) { struct blk_ioprio *blkioprio_blkg; struct rq_qos *rqos; @@ -234,36 +241,45 @@ int blk_ioprio_init(struct request_queue *q) if (!blkioprio_blkg) return -ENOMEM; + /* + * No need to worry ioprio_blkcg_from_css return NULL as + * the queue is frozen right now. + */ + rqos = &blkioprio_blkg->rqos; + rq_qos_activate(q, rqos, &blkcg_ioprio_ops); + ret = blkcg_activate_policy(q, &ioprio_policy); if (ret) { + rq_qos_deactivate(rqos); kfree(blkioprio_blkg); - return ret; } - rqos = &blkioprio_blkg->rqos; - rqos->id = RQ_QOS_IOPRIO; - rqos->ops = &blkcg_ioprio_ops; - rqos->q = q; - - /* - * Registering the rq-qos policy after activating the blk-cgroup - * policy guarantees that ioprio_blkcg_from_bio(bio) != NULL in the - * rq-qos callbacks. - */ - rq_qos_add(q, rqos); - - return 0; + return ret; } static int __init ioprio_init(void) { - return blkcg_policy_register(&ioprio_policy); + int ret; + + ret = rq_qos_register(&blkcg_ioprio_ops); + if (ret) + return ret; + + ret = blkcg_policy_register(&ioprio_policy); + if (ret) + rq_qos_unregister(&blkcg_ioprio_ops); + + return ret; } static void __exit ioprio_exit(void) { blkcg_policy_unregister(&ioprio_policy); + rq_qos_unregister(&blkcg_ioprio_ops); } module_init(ioprio_init); module_exit(ioprio_exit); +MODULE_AUTHOR("Bart Van Assche"); +MODULE_LICENSE("GPL"); +MODULE_DESCRIPTION("Cgroup I/O controller for assigning an I/O priority class"); diff --git a/block/blk-ioprio.h b/block/blk-ioprio.h deleted file mode 100644 index a7785c2f1aea..000000000000 --- a/block/blk-ioprio.h +++ /dev/null @@ -1,19 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0 */ - -#ifndef _BLK_IOPRIO_H_ -#define _BLK_IOPRIO_H_ - -#include - -struct request_queue; - -#ifdef CONFIG_BLK_CGROUP_IOPRIO -int blk_ioprio_init(struct request_queue *q); -#else -static inline int blk_ioprio_init(struct request_queue *q) -{ - return 0; -} -#endif - -#endif /* _BLK_IOPRIO_H_ */ diff --git a/block/blk-mq-debugfs.c b/block/blk-mq-debugfs.c index 652cd754dbd3..ba43efed3565 100644 --- a/block/blk-mq-debugfs.c +++ b/block/blk-mq-debugfs.c @@ -825,10 +825,6 @@ void blk_mq_debugfs_unregister_sched(struct request_queue *q) static const char *rq_qos_id_to_name(enum rq_qos_id id) { - switch (id) { - case RQ_QOS_IOPRIO: - return "ioprio"; - } return "unknown"; } diff --git a/block/blk-rq-qos.c b/block/blk-rq-qos.c index f269bb9745ad..56525fe62500 100644 --- a/block/blk-rq-qos.c +++ b/block/blk-rq-qos.c @@ -454,7 +454,7 @@ int rq_qos_register(struct rq_qos_ops *ops) goto out; } - start = RQ_QOS_IOPRIO + 1; + start = 1; ret = ida_simple_get(&rq_qos_ida, start, INT_MAX, GFP_KERNEL); if (ret < 0) goto out; diff --git a/block/blk-rq-qos.h b/block/blk-rq-qos.h index 6d691527cb51..bba829bbb461 100644 --- a/block/blk-rq-qos.h +++ b/block/blk-rq-qos.h @@ -14,7 +14,7 @@ struct blk_mq_debugfs_attr; enum rq_qos_id { - RQ_QOS_IOPRIO, + RQ_QOS_UNUSED, }; struct rq_wait { From patchwork Wed Feb 16 11:48:09 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Wang Jianchao X-Patchwork-Id: 12748476 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id C6FADC433EF for ; Wed, 16 Feb 2022 11:50:01 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232484AbiBPLuL (ORCPT ); Wed, 16 Feb 2022 06:50:11 -0500 Received: from mxb-00190b01.gslb.pphosted.com ([23.128.96.19]:57332 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232489AbiBPLuG (ORCPT ); Wed, 16 Feb 2022 06:50:06 -0500 Received: from mail-pj1-x1030.google.com (mail-pj1-x1030.google.com [IPv6:2607:f8b0:4864:20::1030]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 7667B1CEB29; Wed, 16 Feb 2022 03:49:52 -0800 (PST) Received: by mail-pj1-x1030.google.com with SMTP id h14-20020a17090a130e00b001b88991a305so6198209pja.3; Wed, 16 Feb 2022 03:49:52 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=pRrgwOHWLiM1Q+J4i60wpnw6sWhrdkcW+cGlMVFX6jM=; b=GFzblecDliUi6HFrmTuyPU60rqHXFp+G8qiTodPaZMvbFdnRcbNUlbNgpzniJzWOOT A64lU+z7qxke0RNVFnqmbWw9wbnDfozkJyIZmhuYiGqLA/rKGq/Q7lCg0AjfuGV+iK0Q b0cEAOQrVGlYNDsE6g+bfYqMXQtr7nHAZRo2OKKuwiqgxmZNyeviNAdIKw34WbsUwr7a tOpefCBwV6UhXmI2FRndFPel7rOVj2+U/4D6PS/rc8h54qWV+z29+vr9EUnMHuu06I1M xCtSLypxDpTZTkW2ncF3VyK3phW/Gz1A10Wb+BGNzU3SWMoCTX1HvATHCAsxsWXRcz9N caTA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=pRrgwOHWLiM1Q+J4i60wpnw6sWhrdkcW+cGlMVFX6jM=; b=aoMiDu0N1EYN/b7LSYcTb9ugpHmaiXTkHA0gFg5CDjOMmNtedxurSZxOQy5MoAiNF/ i8nP1DdqOgpx92NM5fIbJxo3gJkT0WDgH3TEH0uUhWw+wwKnPvrH7AfBjSdVxAeG5ejd BhDY57dlb0ZmjoQ1rbOAqbjP2EJcH2R0l2tUe6YgoqZ3Gw/1xnSHUfubXH11hNTLNcsV uJHkDBq2HVrQENnSXOp4bCrkbT9ScfSuQmxoNogtLRxJq3qNb3cheW9/LdO+MMv+8ZVV tbzmd4v7/Cr43xwb6R1jJuUx8GBBsGWRXgk6Y7cUpo7xlddnz0nHjtX/yqhLI5BGqhCZ NurQ== X-Gm-Message-State: AOAM531WqpdsQydQkM6rTHrlg/GM6BQG1Y7KPQgl2NYk/3ai7OdN65p0 pltYH0aLce3X08AloKk3WVuGVAmry1TIYWcP X-Google-Smtp-Source: ABdhPJzgDAgMFW1bjTKE3h4NjmPmpSD2L0ngBHK20EB1jYJ2Y8E3MSbHEGcmp53c8sO5W7VbDvFjNg== X-Received: by 2002:a17:903:1249:b0:14e:e477:5019 with SMTP id u9-20020a170903124900b0014ee4775019mr2181392plh.53.1645012191999; Wed, 16 Feb 2022 03:49:51 -0800 (PST) Received: from localhost.localdomain ([61.16.102.69]) by smtp.gmail.com with ESMTPSA id q1sm26209119pfs.112.2022.02.16.03.49.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Feb 2022 03:49:51 -0800 (PST) From: "Wang Jianchao (Kuaishou)" To: Jens Axboe Cc: Josef Bacik , Tejun Heo , Bart Van Assche , linux-block@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [RFC V3 6/6] blk: export the sysfs for switching qos Date: Wed, 16 Feb 2022 19:48:09 +0800 Message-Id: <20220216114809.84551-7-jianchao.wan9@gmail.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20220216114809.84551-1-jianchao.wan9@gmail.com> References: <20220216114809.84551-1-jianchao.wan9@gmail.com> Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org And also remove the unused interfaces. Signed-off-by: Wang Jianchao (Kuaishou) --- block/blk-mq-debugfs.c | 10 +------- block/blk-rq-qos.h | 54 ++---------------------------------------- block/blk-sysfs.c | 2 ++ 3 files changed, 5 insertions(+), 61 deletions(-) diff --git a/block/blk-mq-debugfs.c b/block/blk-mq-debugfs.c index ba43efed3565..9079541e92f1 100644 --- a/block/blk-mq-debugfs.c +++ b/block/blk-mq-debugfs.c @@ -823,11 +823,6 @@ void blk_mq_debugfs_unregister_sched(struct request_queue *q) q->sched_debugfs_dir = NULL; } -static const char *rq_qos_id_to_name(enum rq_qos_id id) -{ - return "unknown"; -} - void blk_mq_debugfs_unregister_rqos(struct rq_qos *rqos) { debugfs_remove_recursive(rqos->debugfs_dir); @@ -837,9 +832,6 @@ void blk_mq_debugfs_unregister_rqos(struct rq_qos *rqos) void blk_mq_debugfs_register_rqos(struct rq_qos *rqos) { struct request_queue *q = rqos->q; - const char *dir_name; - - dir_name = rqos->ops->name ? rqos->ops->name : rq_qos_id_to_name(rqos->id); if (rqos->debugfs_dir || !rqos->ops->debugfs_attrs) return; @@ -848,7 +840,7 @@ void blk_mq_debugfs_register_rqos(struct rq_qos *rqos) q->rqos_debugfs_dir = debugfs_create_dir("rqos", q->debugfs_dir); - rqos->debugfs_dir = debugfs_create_dir(dir_name, + rqos->debugfs_dir = debugfs_create_dir(rqos->ops->name, rqos->q->rqos_debugfs_dir); debugfs_create_files(rqos->debugfs_dir, rqos, rqos->ops->debugfs_attrs); diff --git a/block/blk-rq-qos.h b/block/blk-rq-qos.h index bba829bbb461..498abefea9b4 100644 --- a/block/blk-rq-qos.h +++ b/block/blk-rq-qos.h @@ -13,10 +13,6 @@ struct blk_mq_debugfs_attr; -enum rq_qos_id { - RQ_QOS_UNUSED, -}; - struct rq_wait { wait_queue_head_t wait; atomic_t inflight; @@ -25,7 +21,7 @@ struct rq_wait { struct rq_qos { const struct rq_qos_ops *ops; struct request_queue *q; - enum rq_qos_id id; + int id; refcount_t ref; wait_queue_head_t waitq; bool dying; @@ -70,7 +66,7 @@ struct rq_depth { }; static inline struct rq_qos *rq_qos_id(struct request_queue *q, - enum rq_qos_id id) + int id) { struct rq_qos *rqos; for (rqos = q->rq_qos; rqos; rqos = rqos->next) { @@ -99,52 +95,6 @@ static inline void rq_wait_init(struct rq_wait *rq_wait) init_waitqueue_head(&rq_wait->wait); } -static inline void rq_qos_add(struct request_queue *q, struct rq_qos *rqos) -{ - /* - * No IO can be in-flight when adding rqos, so freeze queue, which - * is fine since we only support rq_qos for blk-mq queue. - * - * Reuse ->queue_lock for protecting against other concurrent - * rq_qos adding/deleting - */ - blk_mq_freeze_queue(q); - - spin_lock_irq(&q->queue_lock); - rqos->next = q->rq_qos; - q->rq_qos = rqos; - spin_unlock_irq(&q->queue_lock); - - blk_mq_unfreeze_queue(q); - - if (rqos->ops->debugfs_attrs) - blk_mq_debugfs_register_rqos(rqos); -} - -static inline void rq_qos_del(struct request_queue *q, struct rq_qos *rqos) -{ - struct rq_qos **cur; - - /* - * See comment in rq_qos_add() about freezing queue & using - * ->queue_lock. - */ - blk_mq_freeze_queue(q); - - spin_lock_irq(&q->queue_lock); - for (cur = &q->rq_qos; *cur; cur = &(*cur)->next) { - if (*cur == rqos) { - *cur = rqos->next; - break; - } - } - spin_unlock_irq(&q->queue_lock); - - blk_mq_unfreeze_queue(q); - - blk_mq_debugfs_unregister_rqos(rqos); -} - int rq_qos_register(struct rq_qos_ops *ops); void rq_qos_unregister(struct rq_qos_ops *ops); void rq_qos_activate(struct request_queue *q, diff --git a/block/blk-sysfs.c b/block/blk-sysfs.c index 9f32882ceb2f..c02747db4e3b 100644 --- a/block/blk-sysfs.c +++ b/block/blk-sysfs.c @@ -574,6 +574,7 @@ QUEUE_RO_ENTRY(queue_max_segments, "max_segments"); QUEUE_RO_ENTRY(queue_max_integrity_segments, "max_integrity_segments"); QUEUE_RO_ENTRY(queue_max_segment_size, "max_segment_size"); QUEUE_RW_ENTRY(elv_iosched, "scheduler"); +QUEUE_RW_ENTRY(queue_qos, "qos"); QUEUE_RO_ENTRY(queue_logical_block_size, "logical_block_size"); QUEUE_RO_ENTRY(queue_physical_block_size, "physical_block_size"); @@ -633,6 +634,7 @@ static struct attribute *queue_attrs[] = { &queue_max_integrity_segments_entry.attr, &queue_max_segment_size_entry.attr, &elv_iosched_entry.attr, + &queue_qos_entry.attr, &queue_hw_sector_size_entry.attr, &queue_logical_block_size_entry.attr, &queue_physical_block_size_entry.attr,