2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Block device elevator/IO-scheduler.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2000 Andrea Arcangeli <andrea@suse.de> SuSE
|
|
|
|
*
|
2006-09-04 15:41:16 +02:00
|
|
|
* 30042000 Jens Axboe <axboe@kernel.dk> :
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* Split the elevator a bit so that it is possible to choose a different
|
|
|
|
* one or even write a new "plug in". There are three pieces:
|
|
|
|
* - elevator_fn, inserts a new request in the queue list
|
|
|
|
* - elevator_merge_fn, decides whether a new buffer can be merged with
|
|
|
|
* an existing request
|
|
|
|
* - elevator_dequeue_fn, called when a request is taken off the active list
|
|
|
|
*
|
|
|
|
* 20082000 Dave Jones <davej@suse.de> :
|
|
|
|
* Removed tests for max-bomb-segments, which was breaking elvtune
|
|
|
|
* when run without -bN
|
|
|
|
*
|
|
|
|
* Jens:
|
|
|
|
* - Rework again to work with bio instead of buffer_heads
|
|
|
|
* - loose bi_dev comparisons, partition handling is right now
|
|
|
|
* - completely modularize elevator setup and teardown
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/elevator.h>
|
|
|
|
#include <linux/bio.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/compiler.h>
|
2006-03-23 20:00:26 +01:00
|
|
|
#include <linux/blktrace_api.h>
|
2006-07-28 09:23:08 +02:00
|
|
|
#include <linux/hash.h>
|
2008-08-26 09:15:47 +02:00
|
|
|
#include <linux/uaccess.h>
|
2013-03-23 04:42:27 +01:00
|
|
|
#include <linux/pm_runtime.h>
|
2015-05-22 23:13:17 +02:00
|
|
|
#include <linux/blk-cgroup.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
tracing/events: convert block trace points to TRACE_EVENT()
TRACE_EVENT is a more generic way to define tracepoints. Doing so adds
these new capabilities to this tracepoint:
- zero-copy and per-cpu splice() tracing
- binary tracing without printf overhead
- structured logging records exposed under /debug/tracing/events
- trace events embedded in function tracer output and other plugins
- user-defined, per tracepoint filter expressions
...
Cons:
- no dev_t info for the output of plug, unplug_timer and unplug_io events.
no dev_t info for getrq and sleeprq events if bio == NULL.
no dev_t info for rq_abort,...,rq_requeue events if rq->rq_disk == NULL.
This is mainly because we can't get the deivce from a request queue.
But this may change in the future.
- A packet command is converted to a string in TP_assign, not TP_print.
While blktrace do the convertion just before output.
Since pc requests should be rather rare, this is not a big issue.
- In blktrace, an event can have 2 different print formats, but a TRACE_EVENT
has a unique format, which means we have some unused data in a trace entry.
The overhead is minimized by using __dynamic_array() instead of __array().
I've benchmarked the ioctl blktrace vs the splice based TRACE_EVENT tracing:
dd dd + ioctl blktrace dd + TRACE_EVENT (splice)
1 7.36s, 42.7 MB/s 7.50s, 42.0 MB/s 7.41s, 42.5 MB/s
2 7.43s, 42.3 MB/s 7.48s, 42.1 MB/s 7.43s, 42.4 MB/s
3 7.38s, 42.6 MB/s 7.45s, 42.2 MB/s 7.41s, 42.5 MB/s
So the overhead of tracing is very small, and no regression when using
those trace events vs blktrace.
And the binary output of TRACE_EVENT is much smaller than blktrace:
# ls -l -h
-rw-r--r-- 1 root root 8.8M 06-09 13:24 sda.blktrace.0
-rw-r--r-- 1 root root 195K 06-09 13:24 sda.blktrace.1
-rw-r--r-- 1 root root 2.7M 06-09 13:25 trace_splice.out
Following are some comparisons between TRACE_EVENT and blktrace:
plug:
kjournald-480 [000] 303.084981: block_plug: [kjournald]
kjournald-480 [000] 303.084981: 8,0 P N [kjournald]
unplug_io:
kblockd/0-118 [000] 300.052973: block_unplug_io: [kblockd/0] 1
kblockd/0-118 [000] 300.052974: 8,0 U N [kblockd/0] 1
remap:
kjournald-480 [000] 303.085042: block_remap: 8,0 W 102736992 + 8 <- (8,8) 33384
kjournald-480 [000] 303.085043: 8,0 A W 102736992 + 8 <- (8,8) 33384
bio_backmerge:
kjournald-480 [000] 303.085086: block_bio_backmerge: 8,0 W 102737032 + 8 [kjournald]
kjournald-480 [000] 303.085086: 8,0 M W 102737032 + 8 [kjournald]
getrq:
kjournald-480 [000] 303.084974: block_getrq: 8,0 W 102736984 + 8 [kjournald]
kjournald-480 [000] 303.084975: 8,0 G W 102736984 + 8 [kjournald]
bash-2066 [001] 1072.953770: 8,0 G N [bash]
bash-2066 [001] 1072.953773: block_getrq: 0,0 N 0 + 0 [bash]
rq_complete:
konsole-2065 [001] 300.053184: block_rq_complete: 8,0 W () 103669040 + 16 [0]
konsole-2065 [001] 300.053191: 8,0 C W 103669040 + 16 [0]
ksoftirqd/1-7 [001] 1072.953811: 8,0 C N (5a 00 08 00 00 00 00 00 24 00) [0]
ksoftirqd/1-7 [001] 1072.953813: block_rq_complete: 0,0 N (5a 00 08 00 00 00 00 00 24 00) 0 + 0 [0]
rq_insert:
kjournald-480 [000] 303.084985: block_rq_insert: 8,0 W 0 () 102736984 + 8 [kjournald]
kjournald-480 [000] 303.084986: 8,0 I W 102736984 + 8 [kjournald]
Changelog from v2 -> v3:
- use the newly introduced __dynamic_array().
Changelog from v1 -> v2:
- use __string() instead of __array() to minimize the memory required
to store hex dump of rq->cmd().
- support large pc requests.
- add missing blk_fill_rwbs_rq() in block_rq_requeue TRACE_EVENT.
- some cleanups.
Signed-off-by: Li Zefan <lizf@cn.fujitsu.com>
LKML-Reference: <4A2DF669.5070905@cn.fujitsu.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2009-06-09 07:43:05 +02:00
|
|
|
#include <trace/events/block.h>
|
|
|
|
|
2008-09-14 14:55:09 +02:00
|
|
|
#include "blk.h"
|
2017-01-17 14:03:22 +01:00
|
|
|
#include "blk-mq-sched.h"
|
2017-04-19 11:33:27 +02:00
|
|
|
#include "blk-wbt.h"
|
2008-09-14 14:55:09 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static DEFINE_SPINLOCK(elv_list_lock);
|
|
|
|
static LIST_HEAD(elv_list);
|
|
|
|
|
2006-07-28 09:23:08 +02:00
|
|
|
/*
|
|
|
|
* Merge hash stuff.
|
|
|
|
*/
|
2009-05-07 15:24:39 +02:00
|
|
|
#define rq_hash_key(rq) (blk_rq_pos(rq) + blk_rq_sectors(rq))
|
2006-07-28 09:23:08 +02:00
|
|
|
|
2006-12-20 11:04:12 +01:00
|
|
|
/*
|
|
|
|
* Query io scheduler to see if the current process issuing bio may be
|
|
|
|
* merged with rq.
|
|
|
|
*/
|
2016-07-07 20:48:22 +02:00
|
|
|
static int elv_iosched_allow_bio_merge(struct request *rq, struct bio *bio)
|
2006-12-20 11:04:12 +01:00
|
|
|
{
|
2007-07-24 09:28:11 +02:00
|
|
|
struct request_queue *q = rq->q;
|
2008-10-31 10:05:07 +01:00
|
|
|
struct elevator_queue *e = q->elevator;
|
2006-12-20 11:04:12 +01:00
|
|
|
|
2017-01-17 14:03:22 +01:00
|
|
|
if (e->uses_mq && e->type->ops.mq.allow_merge)
|
|
|
|
return e->type->ops.mq.allow_merge(q, rq, bio);
|
|
|
|
else if (!e->uses_mq && e->type->ops.sq.elevator_allow_bio_merge_fn)
|
2016-12-10 23:13:59 +01:00
|
|
|
return e->type->ops.sq.elevator_allow_bio_merge_fn(q, rq, bio);
|
2006-12-20 11:04:12 +01:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* can we safely merge with this request?
|
|
|
|
*/
|
2016-07-07 20:48:22 +02:00
|
|
|
bool elv_bio_merge_ok(struct request *rq, struct bio *bio)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2012-02-08 09:19:38 +01:00
|
|
|
if (!blk_rq_merge_ok(rq, bio))
|
2016-07-07 20:48:22 +02:00
|
|
|
return false;
|
2008-06-30 20:04:41 +02:00
|
|
|
|
2016-07-07 20:48:22 +02:00
|
|
|
if (!elv_iosched_allow_bio_merge(rq, bio))
|
|
|
|
return false;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2016-07-07 20:48:22 +02:00
|
|
|
return true;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2016-07-07 20:48:22 +02:00
|
|
|
EXPORT_SYMBOL(elv_bio_merge_ok);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2017-10-25 20:35:02 +02:00
|
|
|
static bool elevator_match(const struct elevator_type *e, const char *name)
|
|
|
|
{
|
|
|
|
if (!strcmp(e->elevator_name, name))
|
|
|
|
return true;
|
|
|
|
if (e->elevator_alias && !strcmp(e->elevator_alias, name))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-10-25 20:33:42 +02:00
|
|
|
/*
|
|
|
|
* Return scheduler with name 'name' and with matching 'mq capability
|
|
|
|
*/
|
|
|
|
static struct elevator_type *elevator_find(const char *name, bool mq)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-11 09:24:27 +02:00
|
|
|
struct elevator_type *e;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-07-10 12:26:24 +02:00
|
|
|
list_for_each_entry(e, &elv_list, list) {
|
2017-10-25 20:35:02 +02:00
|
|
|
if (elevator_match(e, name) && (mq == e->uses_mq))
|
2006-10-11 09:24:27 +02:00
|
|
|
return e;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-10-11 09:24:27 +02:00
|
|
|
return NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void elevator_put(struct elevator_type *e)
|
|
|
|
{
|
|
|
|
module_put(e->elevator_owner);
|
|
|
|
}
|
|
|
|
|
2017-10-25 20:33:42 +02:00
|
|
|
static struct elevator_type *elevator_get(struct request_queue *q,
|
|
|
|
const char *name, bool try_loading)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-10-20 10:56:41 +02:00
|
|
|
struct elevator_type *e;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-04-26 14:41:53 +02:00
|
|
|
spin_lock(&elv_list_lock);
|
2005-10-20 10:56:41 +02:00
|
|
|
|
2017-10-25 20:33:42 +02:00
|
|
|
e = elevator_find(name, q->mq_ops != NULL);
|
2013-01-23 01:48:03 +01:00
|
|
|
if (!e && try_loading) {
|
2008-02-19 10:20:37 +01:00
|
|
|
spin_unlock(&elv_list_lock);
|
2011-05-06 02:02:12 +02:00
|
|
|
request_module("%s-iosched", name);
|
2008-02-19 10:20:37 +01:00
|
|
|
spin_lock(&elv_list_lock);
|
2017-10-25 20:33:42 +02:00
|
|
|
e = elevator_find(name, q->mq_ops != NULL);
|
2008-02-19 10:20:37 +01:00
|
|
|
}
|
|
|
|
|
2005-10-20 10:56:41 +02:00
|
|
|
if (e && !try_module_get(e->elevator_owner))
|
|
|
|
e = NULL;
|
|
|
|
|
2007-04-26 14:41:53 +02:00
|
|
|
spin_unlock(&elv_list_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
2011-09-08 12:32:14 +02:00
|
|
|
static char chosen_elevator[ELV_NAME_MAX];
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-01-24 10:07:58 +01:00
|
|
|
static int __init elevator_setup(char *str)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-01-16 09:47:37 +01:00
|
|
|
/*
|
|
|
|
* Be backwards-compatible with previous kernels, so users
|
|
|
|
* won't get the wrong elevator.
|
|
|
|
*/
|
2009-10-03 09:37:51 +02:00
|
|
|
strncpy(chosen_elevator, str, sizeof(chosen_elevator) - 1);
|
2006-03-31 12:30:33 +02:00
|
|
|
return 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
__setup("elevator=", elevator_setup);
|
|
|
|
|
2013-01-18 23:05:56 +01:00
|
|
|
/* called during boot to load the elevator chosen by the elevator param */
|
|
|
|
void __init load_default_elevator_module(void)
|
|
|
|
{
|
|
|
|
struct elevator_type *e;
|
|
|
|
|
|
|
|
if (!chosen_elevator[0])
|
|
|
|
return;
|
|
|
|
|
2017-10-25 20:33:42 +02:00
|
|
|
/*
|
|
|
|
* Boot parameter is deprecated, we haven't supported that for MQ.
|
|
|
|
* Only look for non-mq schedulers from here.
|
|
|
|
*/
|
2013-01-18 23:05:56 +01:00
|
|
|
spin_lock(&elv_list_lock);
|
2017-10-25 20:33:42 +02:00
|
|
|
e = elevator_find(chosen_elevator, false);
|
2013-01-18 23:05:56 +01:00
|
|
|
spin_unlock(&elv_list_lock);
|
|
|
|
|
|
|
|
if (!e)
|
|
|
|
request_module("%s-iosched", chosen_elevator);
|
|
|
|
}
|
|
|
|
|
2006-03-19 00:35:43 +01:00
|
|
|
static struct kobj_type elv_ktype;
|
|
|
|
|
2013-07-03 13:25:24 +02:00
|
|
|
struct elevator_queue *elevator_alloc(struct request_queue *q,
|
2007-07-24 09:28:11 +02:00
|
|
|
struct elevator_type *e)
|
2006-03-19 00:35:43 +01:00
|
|
|
{
|
2008-10-31 10:05:07 +01:00
|
|
|
struct elevator_queue *eq;
|
2006-07-28 09:23:08 +02:00
|
|
|
|
2013-08-30 00:21:42 +02:00
|
|
|
eq = kzalloc_node(sizeof(*eq), GFP_KERNEL, q->node);
|
2006-07-28 09:23:08 +02:00
|
|
|
if (unlikely(!eq))
|
2015-04-23 18:47:44 +02:00
|
|
|
return NULL;
|
2006-07-28 09:23:08 +02:00
|
|
|
|
2011-12-14 00:33:41 +01:00
|
|
|
eq->type = e;
|
2007-12-18 07:05:35 +01:00
|
|
|
kobject_init(&eq->kobj, &elv_ktype);
|
2006-07-28 09:23:08 +02:00
|
|
|
mutex_init(&eq->sysfs_lock);
|
2012-12-17 16:01:27 +01:00
|
|
|
hash_init(eq->hash);
|
2017-01-17 14:03:22 +01:00
|
|
|
eq->uses_mq = e->uses_mq;
|
2006-07-28 09:23:08 +02:00
|
|
|
|
2006-03-19 00:35:43 +01:00
|
|
|
return eq;
|
|
|
|
}
|
2013-07-03 13:25:24 +02:00
|
|
|
EXPORT_SYMBOL(elevator_alloc);
|
2006-03-19 00:35:43 +01:00
|
|
|
|
|
|
|
static void elevator_release(struct kobject *kobj)
|
|
|
|
{
|
2008-10-31 10:05:07 +01:00
|
|
|
struct elevator_queue *e;
|
2006-07-28 09:23:08 +02:00
|
|
|
|
2008-10-31 10:05:07 +01:00
|
|
|
e = container_of(kobj, struct elevator_queue, kobj);
|
2011-12-14 00:33:41 +01:00
|
|
|
elevator_put(e->type);
|
2006-03-19 00:35:43 +01:00
|
|
|
kfree(e);
|
|
|
|
}
|
|
|
|
|
2018-05-31 19:11:40 +02:00
|
|
|
/*
|
|
|
|
* Use the default elevator specified by config boot param for non-mq devices,
|
|
|
|
* or by config option. Don't try to load modules as we could be running off
|
|
|
|
* async and request_module() isn't allowed from async.
|
|
|
|
*/
|
2018-05-31 19:11:38 +02:00
|
|
|
int elevator_init(struct request_queue *q)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct elevator_type *e = NULL;
|
2018-05-31 19:11:39 +02:00
|
|
|
int err = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2013-10-16 00:42:16 +02:00
|
|
|
/*
|
|
|
|
* q->sysfs_lock must be held to provide mutual exclusion between
|
|
|
|
* elevator_switch() and here.
|
|
|
|
*/
|
2018-05-31 19:11:39 +02:00
|
|
|
mutex_lock(&q->sysfs_lock);
|
2010-05-25 19:15:15 +02:00
|
|
|
if (unlikely(q->elevator))
|
2018-05-31 19:11:39 +02:00
|
|
|
goto out_unlock;
|
2010-05-25 19:15:15 +02:00
|
|
|
|
2018-05-31 19:11:40 +02:00
|
|
|
if (*chosen_elevator) {
|
2017-10-25 20:33:42 +02:00
|
|
|
e = elevator_get(q, chosen_elevator, false);
|
2008-02-01 00:37:27 +01:00
|
|
|
if (!e)
|
|
|
|
printk(KERN_ERR "I/O scheduler %s not found\n",
|
|
|
|
chosen_elevator);
|
|
|
|
}
|
2006-01-24 10:09:14 +01:00
|
|
|
|
2018-05-31 19:11:40 +02:00
|
|
|
if (!e)
|
|
|
|
e = elevator_get(q, CONFIG_DEFAULT_IOSCHED, false);
|
2008-02-01 00:37:27 +01:00
|
|
|
if (!e) {
|
2018-05-31 19:11:40 +02:00
|
|
|
printk(KERN_ERR
|
|
|
|
"Default I/O scheduler not found. Using noop.\n");
|
|
|
|
e = elevator_get(q, "noop", false);
|
2006-01-24 10:07:58 +01:00
|
|
|
}
|
|
|
|
|
2018-05-31 19:11:40 +02:00
|
|
|
err = e->ops.sq.elevator_init_fn(q, e);
|
2017-04-05 21:01:30 +02:00
|
|
|
if (err)
|
2014-10-23 18:46:48 +02:00
|
|
|
elevator_put(e);
|
2018-05-31 19:11:39 +02:00
|
|
|
out_unlock:
|
|
|
|
mutex_unlock(&q->sysfs_lock);
|
2014-10-23 18:46:48 +02:00
|
|
|
return err;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2006-07-13 11:55:04 +02:00
|
|
|
|
2017-04-07 16:52:27 +02:00
|
|
|
void elevator_exit(struct request_queue *q, struct elevator_queue *e)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-03-19 00:35:43 +01:00
|
|
|
mutex_lock(&e->sysfs_lock);
|
2017-01-17 14:03:22 +01:00
|
|
|
if (e->uses_mq && e->type->ops.mq.exit_sched)
|
2017-04-07 16:52:27 +02:00
|
|
|
blk_mq_exit_sched(q, e);
|
2017-01-17 14:03:22 +01:00
|
|
|
else if (!e->uses_mq && e->type->ops.sq.elevator_exit_fn)
|
2016-12-10 23:13:59 +01:00
|
|
|
e->type->ops.sq.elevator_exit_fn(e);
|
2006-03-19 00:35:43 +01:00
|
|
|
mutex_unlock(&e->sysfs_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-03-19 00:35:43 +01:00
|
|
|
kobject_put(&e->kobj);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2006-07-13 11:55:04 +02:00
|
|
|
|
2006-07-28 09:23:08 +02:00
|
|
|
static inline void __elv_rqhash_del(struct request *rq)
|
|
|
|
{
|
2012-12-17 16:01:27 +01:00
|
|
|
hash_del(&rq->hash);
|
2016-10-20 15:12:13 +02:00
|
|
|
rq->rq_flags &= ~RQF_HASHED;
|
2006-07-28 09:23:08 +02:00
|
|
|
}
|
|
|
|
|
2016-12-07 16:43:31 +01:00
|
|
|
void elv_rqhash_del(struct request_queue *q, struct request *rq)
|
2006-07-28 09:23:08 +02:00
|
|
|
{
|
|
|
|
if (ELV_ON_HASH(rq))
|
|
|
|
__elv_rqhash_del(rq);
|
|
|
|
}
|
2017-01-17 14:03:22 +01:00
|
|
|
EXPORT_SYMBOL_GPL(elv_rqhash_del);
|
2006-07-28 09:23:08 +02:00
|
|
|
|
2016-12-07 16:43:31 +01:00
|
|
|
void elv_rqhash_add(struct request_queue *q, struct request *rq)
|
2006-07-28 09:23:08 +02:00
|
|
|
{
|
2008-10-31 10:05:07 +01:00
|
|
|
struct elevator_queue *e = q->elevator;
|
2006-07-28 09:23:08 +02:00
|
|
|
|
|
|
|
BUG_ON(ELV_ON_HASH(rq));
|
2012-12-17 16:01:27 +01:00
|
|
|
hash_add(e->hash, &rq->hash, rq_hash_key(rq));
|
2016-10-20 15:12:13 +02:00
|
|
|
rq->rq_flags |= RQF_HASHED;
|
2006-07-28 09:23:08 +02:00
|
|
|
}
|
2017-01-17 14:03:22 +01:00
|
|
|
EXPORT_SYMBOL_GPL(elv_rqhash_add);
|
2006-07-28 09:23:08 +02:00
|
|
|
|
2016-12-07 16:43:31 +01:00
|
|
|
void elv_rqhash_reposition(struct request_queue *q, struct request *rq)
|
2006-07-28 09:23:08 +02:00
|
|
|
{
|
|
|
|
__elv_rqhash_del(rq);
|
|
|
|
elv_rqhash_add(q, rq);
|
|
|
|
}
|
|
|
|
|
2016-12-07 16:43:31 +01:00
|
|
|
struct request *elv_rqhash_find(struct request_queue *q, sector_t offset)
|
2006-07-28 09:23:08 +02:00
|
|
|
{
|
2008-10-31 10:05:07 +01:00
|
|
|
struct elevator_queue *e = q->elevator;
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 02:06:00 +01:00
|
|
|
struct hlist_node *next;
|
2006-07-28 09:23:08 +02:00
|
|
|
struct request *rq;
|
|
|
|
|
2013-02-28 21:52:24 +01:00
|
|
|
hash_for_each_possible_safe(e->hash, rq, next, hash, offset) {
|
2006-07-28 09:23:08 +02:00
|
|
|
BUG_ON(!ELV_ON_HASH(rq));
|
|
|
|
|
|
|
|
if (unlikely(!rq_mergeable(rq))) {
|
|
|
|
__elv_rqhash_del(rq);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rq_hash_key(rq) == offset)
|
|
|
|
return rq;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-07-13 11:55:04 +02:00
|
|
|
/*
|
|
|
|
* RB-tree support functions for inserting/lookup/removal of requests
|
|
|
|
* in a sorted RB tree.
|
|
|
|
*/
|
iosched: prevent aliased requests from starving other I/O
Hi, Jens,
If you recall, I posted an RFC patch for this back in July of last year:
http://lkml.org/lkml/2010/7/13/279
The basic problem is that a process can issue a never-ending stream of
async direct I/Os to the same sector on a device, thus starving out
other I/O in the system (due to the way the alias handling works in both
cfq and deadline). The solution I proposed back then was to start
dispatching from the fifo after a certain number of aliases had been
dispatched. Vivek asked why we had to treat aliases differently at all,
and I never had a good answer. So, I put together a simple patch which
allows aliases to be added to the rb tree (it adds them to the right,
though that doesn't matter as the order isn't guaranteed anyway). I
think this is the preferred solution, as it doesn't break up time slices
in CFQ or batches in deadline. I've tested it, and it does solve the
starvation issue. Let me know what you think.
Cheers,
Jeff
Signed-off-by: Jeff Moyer <jmoyer@redhat.com>
Signed-off-by: Jens Axboe <jaxboe@fusionio.com>
2011-06-02 21:19:05 +02:00
|
|
|
void elv_rb_add(struct rb_root *root, struct request *rq)
|
2006-07-13 11:55:04 +02:00
|
|
|
{
|
|
|
|
struct rb_node **p = &root->rb_node;
|
|
|
|
struct rb_node *parent = NULL;
|
|
|
|
struct request *__rq;
|
|
|
|
|
|
|
|
while (*p) {
|
|
|
|
parent = *p;
|
|
|
|
__rq = rb_entry(parent, struct request, rb_node);
|
|
|
|
|
2009-05-07 15:24:39 +02:00
|
|
|
if (blk_rq_pos(rq) < blk_rq_pos(__rq))
|
2006-07-13 11:55:04 +02:00
|
|
|
p = &(*p)->rb_left;
|
iosched: prevent aliased requests from starving other I/O
Hi, Jens,
If you recall, I posted an RFC patch for this back in July of last year:
http://lkml.org/lkml/2010/7/13/279
The basic problem is that a process can issue a never-ending stream of
async direct I/Os to the same sector on a device, thus starving out
other I/O in the system (due to the way the alias handling works in both
cfq and deadline). The solution I proposed back then was to start
dispatching from the fifo after a certain number of aliases had been
dispatched. Vivek asked why we had to treat aliases differently at all,
and I never had a good answer. So, I put together a simple patch which
allows aliases to be added to the rb tree (it adds them to the right,
though that doesn't matter as the order isn't guaranteed anyway). I
think this is the preferred solution, as it doesn't break up time slices
in CFQ or batches in deadline. I've tested it, and it does solve the
starvation issue. Let me know what you think.
Cheers,
Jeff
Signed-off-by: Jeff Moyer <jmoyer@redhat.com>
Signed-off-by: Jens Axboe <jaxboe@fusionio.com>
2011-06-02 21:19:05 +02:00
|
|
|
else if (blk_rq_pos(rq) >= blk_rq_pos(__rq))
|
2006-07-13 11:55:04 +02:00
|
|
|
p = &(*p)->rb_right;
|
|
|
|
}
|
|
|
|
|
|
|
|
rb_link_node(&rq->rb_node, parent, p);
|
|
|
|
rb_insert_color(&rq->rb_node, root);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(elv_rb_add);
|
|
|
|
|
|
|
|
void elv_rb_del(struct rb_root *root, struct request *rq)
|
|
|
|
{
|
|
|
|
BUG_ON(RB_EMPTY_NODE(&rq->rb_node));
|
|
|
|
rb_erase(&rq->rb_node, root);
|
|
|
|
RB_CLEAR_NODE(&rq->rb_node);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(elv_rb_del);
|
|
|
|
|
|
|
|
struct request *elv_rb_find(struct rb_root *root, sector_t sector)
|
|
|
|
{
|
|
|
|
struct rb_node *n = root->rb_node;
|
|
|
|
struct request *rq;
|
|
|
|
|
|
|
|
while (n) {
|
|
|
|
rq = rb_entry(n, struct request, rb_node);
|
|
|
|
|
2009-05-07 15:24:39 +02:00
|
|
|
if (sector < blk_rq_pos(rq))
|
2006-07-13 11:55:04 +02:00
|
|
|
n = n->rb_left;
|
2009-05-07 15:24:39 +02:00
|
|
|
else if (sector > blk_rq_pos(rq))
|
2006-07-13 11:55:04 +02:00
|
|
|
n = n->rb_right;
|
|
|
|
else
|
|
|
|
return rq;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(elv_rb_find);
|
|
|
|
|
2005-10-20 16:23:44 +02:00
|
|
|
/*
|
|
|
|
* Insert rq into dispatch queue of q. Queue lock must be held on
|
2007-10-20 01:55:04 +02:00
|
|
|
* entry. rq is sort instead into the dispatch queue. To be used by
|
2006-07-13 11:55:04 +02:00
|
|
|
* specific elevators.
|
2005-10-20 16:23:44 +02:00
|
|
|
*/
|
2007-07-24 09:28:11 +02:00
|
|
|
void elv_dispatch_sort(struct request_queue *q, struct request *rq)
|
2005-10-20 16:23:44 +02:00
|
|
|
{
|
|
|
|
sector_t boundary;
|
|
|
|
struct list_head *entry;
|
|
|
|
|
2005-10-20 16:46:23 +02:00
|
|
|
if (q->last_merge == rq)
|
|
|
|
q->last_merge = NULL;
|
2006-07-28 09:23:08 +02:00
|
|
|
|
|
|
|
elv_rqhash_del(q, rq);
|
|
|
|
|
2005-11-10 08:52:05 +01:00
|
|
|
q->nr_sorted--;
|
2005-10-20 16:46:23 +02:00
|
|
|
|
2005-10-20 16:37:00 +02:00
|
|
|
boundary = q->end_sector;
|
2005-10-20 16:23:44 +02:00
|
|
|
list_for_each_prev(entry, &q->queue_head) {
|
|
|
|
struct request *pos = list_entry_rq(entry);
|
|
|
|
|
2016-08-16 09:59:35 +02:00
|
|
|
if (req_op(rq) != req_op(pos))
|
2008-08-09 17:42:20 +02:00
|
|
|
break;
|
2007-01-19 01:27:47 +01:00
|
|
|
if (rq_data_dir(rq) != rq_data_dir(pos))
|
|
|
|
break;
|
2016-10-20 15:12:13 +02:00
|
|
|
if (pos->rq_flags & (RQF_STARTED | RQF_SOFTBARRIER))
|
2005-10-20 16:23:44 +02:00
|
|
|
break;
|
2009-05-07 15:24:39 +02:00
|
|
|
if (blk_rq_pos(rq) >= boundary) {
|
|
|
|
if (blk_rq_pos(pos) < boundary)
|
2005-10-20 16:23:44 +02:00
|
|
|
continue;
|
|
|
|
} else {
|
2009-05-07 15:24:39 +02:00
|
|
|
if (blk_rq_pos(pos) >= boundary)
|
2005-10-20 16:23:44 +02:00
|
|
|
break;
|
|
|
|
}
|
2009-05-07 15:24:39 +02:00
|
|
|
if (blk_rq_pos(rq) >= blk_rq_pos(pos))
|
2005-10-20 16:23:44 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_add(&rq->queuelist, entry);
|
|
|
|
}
|
2006-07-13 11:55:04 +02:00
|
|
|
EXPORT_SYMBOL(elv_dispatch_sort);
|
|
|
|
|
2006-07-28 09:23:08 +02:00
|
|
|
/*
|
2006-07-13 11:55:04 +02:00
|
|
|
* Insert rq into dispatch queue of q. Queue lock must be held on
|
|
|
|
* entry. rq is added to the back of the dispatch queue. To be used by
|
|
|
|
* specific elevators.
|
2006-07-28 09:23:08 +02:00
|
|
|
*/
|
|
|
|
void elv_dispatch_add_tail(struct request_queue *q, struct request *rq)
|
|
|
|
{
|
|
|
|
if (q->last_merge == rq)
|
|
|
|
q->last_merge = NULL;
|
|
|
|
|
|
|
|
elv_rqhash_del(q, rq);
|
|
|
|
|
|
|
|
q->nr_sorted--;
|
|
|
|
|
|
|
|
q->end_sector = rq_end_sector(rq);
|
|
|
|
q->boundary_rq = rq;
|
|
|
|
list_add_tail(&rq->queuelist, &q->queue_head);
|
|
|
|
}
|
2006-07-13 11:55:04 +02:00
|
|
|
EXPORT_SYMBOL(elv_dispatch_add_tail);
|
|
|
|
|
2017-02-08 14:46:48 +01:00
|
|
|
enum elv_merge elv_merge(struct request_queue *q, struct request **req,
|
|
|
|
struct bio *bio)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-10-31 10:05:07 +01:00
|
|
|
struct elevator_queue *e = q->elevator;
|
2006-07-28 09:23:08 +02:00
|
|
|
struct request *__rq;
|
2005-10-20 16:46:23 +02:00
|
|
|
|
2010-01-29 09:04:08 +01:00
|
|
|
/*
|
|
|
|
* Levels of merges:
|
|
|
|
* nomerges: No merges at all attempted
|
|
|
|
* noxmerges: Only simple one-hit cache try
|
|
|
|
* merges: All merge tries attempted
|
|
|
|
*/
|
2015-10-20 17:13:55 +02:00
|
|
|
if (blk_queue_nomerges(q) || !bio_mergeable(bio))
|
2010-01-29 09:04:08 +01:00
|
|
|
return ELEVATOR_NO_MERGE;
|
|
|
|
|
2006-07-28 09:23:08 +02:00
|
|
|
/*
|
|
|
|
* First try one-hit cache.
|
|
|
|
*/
|
2016-07-07 20:48:22 +02:00
|
|
|
if (q->last_merge && elv_bio_merge_ok(q->last_merge, bio)) {
|
2017-02-08 14:46:48 +01:00
|
|
|
enum elv_merge ret = blk_try_merge(q->last_merge, bio);
|
|
|
|
|
2005-10-20 16:46:23 +02:00
|
|
|
if (ret != ELEVATOR_NO_MERGE) {
|
|
|
|
*req = q->last_merge;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-01-29 09:04:08 +01:00
|
|
|
if (blk_queue_noxmerges(q))
|
2008-04-29 14:44:19 +02:00
|
|
|
return ELEVATOR_NO_MERGE;
|
|
|
|
|
2006-07-28 09:23:08 +02:00
|
|
|
/*
|
|
|
|
* See if our hash lookup can find a potential backmerge.
|
|
|
|
*/
|
2013-10-12 00:44:27 +02:00
|
|
|
__rq = elv_rqhash_find(q, bio->bi_iter.bi_sector);
|
2016-07-07 20:48:22 +02:00
|
|
|
if (__rq && elv_bio_merge_ok(__rq, bio)) {
|
2006-07-28 09:23:08 +02:00
|
|
|
*req = __rq;
|
|
|
|
return ELEVATOR_BACK_MERGE;
|
|
|
|
}
|
|
|
|
|
2017-01-17 14:03:22 +01:00
|
|
|
if (e->uses_mq && e->type->ops.mq.request_merge)
|
|
|
|
return e->type->ops.mq.request_merge(q, req, bio);
|
|
|
|
else if (!e->uses_mq && e->type->ops.sq.elevator_merge_fn)
|
2016-12-10 23:13:59 +01:00
|
|
|
return e->type->ops.sq.elevator_merge_fn(q, req, bio);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
return ELEVATOR_NO_MERGE;
|
|
|
|
}
|
|
|
|
|
2011-03-21 10:14:27 +01:00
|
|
|
/*
|
|
|
|
* Attempt to do an insertion back merge. Only check for the case where
|
|
|
|
* we can append 'rq' to an existing request, so we can throw 'rq' away
|
|
|
|
* afterwards.
|
|
|
|
*
|
|
|
|
* Returns true if we merged, false otherwise
|
|
|
|
*/
|
2017-01-17 14:03:22 +01:00
|
|
|
bool elv_attempt_insert_merge(struct request_queue *q, struct request *rq)
|
2011-03-21 10:14:27 +01:00
|
|
|
{
|
|
|
|
struct request *__rq;
|
block: recursive merge requests
In a workload, thread 1 accesses a, a+2, ..., thread 2 accesses a+1, a+3,....
When the requests are flushed to queue, a and a+1 are merged to (a, a+1), a+2
and a+3 too to (a+2, a+3), but (a, a+1) and (a+2, a+3) aren't merged.
If we do recursive merge for such interleave access, some workloads throughput
get improvement. A recent worload I'm checking on is swap, below change
boostes the throughput around 5% ~ 10%.
Signed-off-by: Shaohua Li <shli@fusionio.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2012-11-09 08:44:27 +01:00
|
|
|
bool ret;
|
2011-03-21 10:14:27 +01:00
|
|
|
|
|
|
|
if (blk_queue_nomerges(q))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* First try one-hit cache.
|
|
|
|
*/
|
|
|
|
if (q->last_merge && blk_attempt_req_merge(q, q->last_merge, rq))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (blk_queue_noxmerges(q))
|
|
|
|
return false;
|
|
|
|
|
block: recursive merge requests
In a workload, thread 1 accesses a, a+2, ..., thread 2 accesses a+1, a+3,....
When the requests are flushed to queue, a and a+1 are merged to (a, a+1), a+2
and a+3 too to (a+2, a+3), but (a, a+1) and (a+2, a+3) aren't merged.
If we do recursive merge for such interleave access, some workloads throughput
get improvement. A recent worload I'm checking on is swap, below change
boostes the throughput around 5% ~ 10%.
Signed-off-by: Shaohua Li <shli@fusionio.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2012-11-09 08:44:27 +01:00
|
|
|
ret = false;
|
2011-03-21 10:14:27 +01:00
|
|
|
/*
|
|
|
|
* See if our hash lookup can find a potential backmerge.
|
|
|
|
*/
|
block: recursive merge requests
In a workload, thread 1 accesses a, a+2, ..., thread 2 accesses a+1, a+3,....
When the requests are flushed to queue, a and a+1 are merged to (a, a+1), a+2
and a+3 too to (a+2, a+3), but (a, a+1) and (a+2, a+3) aren't merged.
If we do recursive merge for such interleave access, some workloads throughput
get improvement. A recent worload I'm checking on is swap, below change
boostes the throughput around 5% ~ 10%.
Signed-off-by: Shaohua Li <shli@fusionio.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2012-11-09 08:44:27 +01:00
|
|
|
while (1) {
|
|
|
|
__rq = elv_rqhash_find(q, blk_rq_pos(rq));
|
|
|
|
if (!__rq || !blk_attempt_req_merge(q, __rq, rq))
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* The merged request could be merged with others, try again */
|
|
|
|
ret = true;
|
|
|
|
rq = __rq;
|
|
|
|
}
|
block: recursive merge requests
In my workload, thread 1 accesses a, a+2, ..., thread 2 accesses a+1,
a+3,.... When the requests are flushed to queue, a and a+1 are merged
to (a, a+1), a+2 and a+3 too to (a+2, a+3), but (a, a+1) and (a+2, a+3)
aren't merged.
With recursive merge below, the workload throughput gets improved 20%
and context switch drops 60%.
Signed-off-by: Shaohua Li <shaohua.li@intel.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2011-12-16 14:00:31 +01:00
|
|
|
|
block: recursive merge requests
In a workload, thread 1 accesses a, a+2, ..., thread 2 accesses a+1, a+3,....
When the requests are flushed to queue, a and a+1 are merged to (a, a+1), a+2
and a+3 too to (a+2, a+3), but (a, a+1) and (a+2, a+3) aren't merged.
If we do recursive merge for such interleave access, some workloads throughput
get improvement. A recent worload I'm checking on is swap, below change
boostes the throughput around 5% ~ 10%.
Signed-off-by: Shaohua Li <shli@fusionio.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2012-11-09 08:44:27 +01:00
|
|
|
return ret;
|
2011-03-21 10:14:27 +01:00
|
|
|
}
|
|
|
|
|
2017-02-08 14:46:48 +01:00
|
|
|
void elv_merged_request(struct request_queue *q, struct request *rq,
|
|
|
|
enum elv_merge type)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-10-31 10:05:07 +01:00
|
|
|
struct elevator_queue *e = q->elevator;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2017-01-17 14:03:22 +01:00
|
|
|
if (e->uses_mq && e->type->ops.mq.request_merged)
|
|
|
|
e->type->ops.mq.request_merged(q, rq, type);
|
|
|
|
else if (!e->uses_mq && e->type->ops.sq.elevator_merged_fn)
|
2016-12-10 23:13:59 +01:00
|
|
|
e->type->ops.sq.elevator_merged_fn(q, rq, type);
|
2005-10-20 16:46:23 +02:00
|
|
|
|
2006-07-13 11:55:04 +02:00
|
|
|
if (type == ELEVATOR_BACK_MERGE)
|
|
|
|
elv_rqhash_reposition(q, rq);
|
2006-07-28 09:23:08 +02:00
|
|
|
|
2005-10-20 16:46:23 +02:00
|
|
|
q->last_merge = rq;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-07-24 09:28:11 +02:00
|
|
|
void elv_merge_requests(struct request_queue *q, struct request *rq,
|
2005-04-17 00:20:36 +02:00
|
|
|
struct request *next)
|
|
|
|
{
|
2008-10-31 10:05:07 +01:00
|
|
|
struct elevator_queue *e = q->elevator;
|
2017-01-17 14:03:22 +01:00
|
|
|
bool next_sorted = false;
|
|
|
|
|
|
|
|
if (e->uses_mq && e->type->ops.mq.requests_merged)
|
|
|
|
e->type->ops.mq.requests_merged(q, rq, next);
|
|
|
|
else if (e->type->ops.sq.elevator_merge_req_fn) {
|
2017-02-01 20:22:23 +01:00
|
|
|
next_sorted = (__force bool)(next->rq_flags & RQF_SORTED);
|
2017-01-17 14:03:22 +01:00
|
|
|
if (next_sorted)
|
|
|
|
e->type->ops.sq.elevator_merge_req_fn(q, rq, next);
|
|
|
|
}
|
2005-10-20 16:46:23 +02:00
|
|
|
|
2006-07-28 09:23:08 +02:00
|
|
|
elv_rqhash_reposition(q, rq);
|
|
|
|
|
2011-03-21 10:14:27 +01:00
|
|
|
if (next_sorted) {
|
|
|
|
elv_rqhash_del(q, next);
|
|
|
|
q->nr_sorted--;
|
|
|
|
}
|
|
|
|
|
2005-10-20 16:46:23 +02:00
|
|
|
q->last_merge = rq;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2010-04-09 06:14:23 +02:00
|
|
|
void elv_bio_merged(struct request_queue *q, struct request *rq,
|
|
|
|
struct bio *bio)
|
|
|
|
{
|
|
|
|
struct elevator_queue *e = q->elevator;
|
|
|
|
|
2017-01-17 14:03:22 +01:00
|
|
|
if (WARN_ON_ONCE(e->uses_mq))
|
|
|
|
return;
|
|
|
|
|
2016-12-10 23:13:59 +01:00
|
|
|
if (e->type->ops.sq.elevator_bio_merged_fn)
|
|
|
|
e->type->ops.sq.elevator_bio_merged_fn(q, rq, bio);
|
2010-04-09 06:14:23 +02:00
|
|
|
}
|
|
|
|
|
2014-12-04 01:00:23 +01:00
|
|
|
#ifdef CONFIG_PM
|
2013-03-23 04:42:27 +01:00
|
|
|
static void blk_pm_requeue_request(struct request *rq)
|
|
|
|
{
|
2016-10-20 15:12:13 +02:00
|
|
|
if (rq->q->dev && !(rq->rq_flags & RQF_PM))
|
2013-03-23 04:42:27 +01:00
|
|
|
rq->q->nr_pending--;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void blk_pm_add_request(struct request_queue *q, struct request *rq)
|
|
|
|
{
|
2016-10-20 15:12:13 +02:00
|
|
|
if (q->dev && !(rq->rq_flags & RQF_PM) && q->nr_pending++ == 0 &&
|
2013-03-23 04:42:27 +01:00
|
|
|
(q->rpm_status == RPM_SUSPENDED || q->rpm_status == RPM_SUSPENDING))
|
|
|
|
pm_request_resume(q->dev);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void blk_pm_requeue_request(struct request *rq) {}
|
|
|
|
static inline void blk_pm_add_request(struct request_queue *q,
|
|
|
|
struct request *rq)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-07-24 09:28:11 +02:00
|
|
|
void elv_requeue_request(struct request_queue *q, struct request *rq)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* it already went through dequeue, we need to decrement the
|
|
|
|
* in_flight count again
|
|
|
|
*/
|
2005-10-20 16:23:44 +02:00
|
|
|
if (blk_account_rq(rq)) {
|
2009-05-20 08:54:31 +02:00
|
|
|
q->in_flight[rq_is_sync(rq)]--;
|
2016-10-20 15:12:13 +02:00
|
|
|
if (rq->rq_flags & RQF_SORTED)
|
2007-01-14 12:26:09 +01:00
|
|
|
elv_deactivate_rq(q, rq);
|
2005-10-20 16:23:44 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2016-10-20 15:12:13 +02:00
|
|
|
rq->rq_flags &= ~RQF_STARTED;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2013-03-23 04:42:27 +01:00
|
|
|
blk_pm_requeue_request(rq);
|
|
|
|
|
2011-03-30 09:52:30 +02:00
|
|
|
__elv_add_request(q, rq, ELEVATOR_INSERT_REQUEUE);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2009-03-27 10:31:51 +01:00
|
|
|
void elv_drain_elevator(struct request_queue *q)
|
2005-11-10 08:52:05 +01:00
|
|
|
{
|
2017-01-17 14:03:22 +01:00
|
|
|
struct elevator_queue *e = q->elevator;
|
2005-11-10 08:52:05 +01:00
|
|
|
static int printed;
|
2011-10-19 14:32:38 +02:00
|
|
|
|
2017-01-17 14:03:22 +01:00
|
|
|
if (WARN_ON_ONCE(e->uses_mq))
|
|
|
|
return;
|
|
|
|
|
2011-10-19 14:32:38 +02:00
|
|
|
lockdep_assert_held(q->queue_lock);
|
|
|
|
|
2017-01-17 14:03:22 +01:00
|
|
|
while (e->type->ops.sq.elevator_dispatch_fn(q, 1))
|
2005-11-10 08:52:05 +01:00
|
|
|
;
|
2018-09-27 03:55:13 +02:00
|
|
|
if (q->nr_sorted && !blk_queue_is_zoned(q) && printed++ < 10 ) {
|
2005-11-10 08:52:05 +01:00
|
|
|
printk(KERN_ERR "%s: forced dispatching is broken "
|
|
|
|
"(nr_sorted=%u), please report this\n",
|
2011-12-14 00:33:41 +01:00
|
|
|
q->elevator->type->elevator_name, q->nr_sorted);
|
2005-11-10 08:52:05 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-03-30 09:52:30 +02:00
|
|
|
void __elv_add_request(struct request_queue *q, struct request *rq, int where)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-10-30 08:34:33 +01:00
|
|
|
trace_block_rq_insert(q, rq);
|
2006-03-23 20:00:26 +01:00
|
|
|
|
2013-03-23 04:42:27 +01:00
|
|
|
blk_pm_add_request(q, rq);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
rq->q = q;
|
|
|
|
|
2016-10-20 15:12:13 +02:00
|
|
|
if (rq->rq_flags & RQF_SOFTBARRIER) {
|
2011-03-30 09:52:30 +02:00
|
|
|
/* barriers are scheduling boundary, update end_sector */
|
2017-01-31 16:57:29 +01:00
|
|
|
if (!blk_rq_is_passthrough(rq)) {
|
2011-03-30 09:52:30 +02:00
|
|
|
q->end_sector = rq_end_sector(rq);
|
|
|
|
q->boundary_rq = rq;
|
|
|
|
}
|
2016-10-20 15:12:13 +02:00
|
|
|
} else if (!(rq->rq_flags & RQF_ELVPRIV) &&
|
2011-04-21 19:28:35 +02:00
|
|
|
(where == ELEVATOR_INSERT_SORT ||
|
|
|
|
where == ELEVATOR_INSERT_SORT_MERGE))
|
2011-03-30 09:52:30 +02:00
|
|
|
where = ELEVATOR_INSERT_BACK;
|
|
|
|
|
2005-10-20 16:23:44 +02:00
|
|
|
switch (where) {
|
2010-09-03 11:56:16 +02:00
|
|
|
case ELEVATOR_INSERT_REQUEUE:
|
2005-10-20 16:23:44 +02:00
|
|
|
case ELEVATOR_INSERT_FRONT:
|
2016-10-20 15:12:13 +02:00
|
|
|
rq->rq_flags |= RQF_SOFTBARRIER;
|
2005-10-20 16:23:44 +02:00
|
|
|
list_add(&rq->queuelist, &q->queue_head);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ELEVATOR_INSERT_BACK:
|
2016-10-20 15:12:13 +02:00
|
|
|
rq->rq_flags |= RQF_SOFTBARRIER;
|
2005-11-10 08:52:05 +01:00
|
|
|
elv_drain_elevator(q);
|
2005-10-20 16:23:44 +02:00
|
|
|
list_add_tail(&rq->queuelist, &q->queue_head);
|
|
|
|
/*
|
|
|
|
* We kick the queue here for the following reasons.
|
|
|
|
* - The elevator might have returned NULL previously
|
|
|
|
* to delay requests and returned them now. As the
|
|
|
|
* queue wasn't empty before this request, ll_rw_blk
|
|
|
|
* won't run the queue on return, resulting in hang.
|
|
|
|
* - Usually, back inserted requests won't be merged
|
|
|
|
* with anything. There's no point in delaying queue
|
|
|
|
* processing.
|
|
|
|
*/
|
2011-04-18 11:41:33 +02:00
|
|
|
__blk_run_queue(q);
|
2005-10-20 16:23:44 +02:00
|
|
|
break;
|
|
|
|
|
2011-03-21 10:14:27 +01:00
|
|
|
case ELEVATOR_INSERT_SORT_MERGE:
|
|
|
|
/*
|
|
|
|
* If we succeed in merging this request with one in the
|
|
|
|
* queue already, we are done - rq has now been freed,
|
|
|
|
* so no need to do anything further.
|
|
|
|
*/
|
|
|
|
if (elv_attempt_insert_merge(q, rq))
|
|
|
|
break;
|
2017-06-21 18:40:11 +02:00
|
|
|
/* fall through */
|
2005-10-20 16:23:44 +02:00
|
|
|
case ELEVATOR_INSERT_SORT:
|
2017-01-31 16:57:29 +01:00
|
|
|
BUG_ON(blk_rq_is_passthrough(rq));
|
2016-10-20 15:12:13 +02:00
|
|
|
rq->rq_flags |= RQF_SORTED;
|
2005-11-10 08:52:05 +01:00
|
|
|
q->nr_sorted++;
|
2006-07-28 09:23:08 +02:00
|
|
|
if (rq_mergeable(rq)) {
|
|
|
|
elv_rqhash_add(q, rq);
|
|
|
|
if (!q->last_merge)
|
|
|
|
q->last_merge = rq;
|
|
|
|
}
|
|
|
|
|
2005-11-01 09:23:49 +01:00
|
|
|
/*
|
|
|
|
* Some ioscheds (cfq) run q->request_fn directly, so
|
|
|
|
* rq cannot be accessed after calling
|
|
|
|
* elevator_add_req_fn.
|
|
|
|
*/
|
2016-12-10 23:13:59 +01:00
|
|
|
q->elevator->type->ops.sq.elevator_add_req_fn(q, rq);
|
2005-10-20 16:23:44 +02:00
|
|
|
break;
|
|
|
|
|
2011-01-25 12:43:54 +01:00
|
|
|
case ELEVATOR_INSERT_FLUSH:
|
2016-10-20 15:12:13 +02:00
|
|
|
rq->rq_flags |= RQF_SOFTBARRIER;
|
2011-01-25 12:43:54 +01:00
|
|
|
blk_insert_flush(rq);
|
|
|
|
break;
|
2005-10-20 16:23:44 +02:00
|
|
|
default:
|
|
|
|
printk(KERN_ERR "%s: bad insertion point %d\n",
|
2008-05-01 13:35:17 +02:00
|
|
|
__func__, where);
|
2005-10-20 16:23:44 +02:00
|
|
|
BUG();
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2006-07-13 11:55:04 +02:00
|
|
|
EXPORT_SYMBOL(__elv_add_request);
|
|
|
|
|
2011-03-10 08:52:07 +01:00
|
|
|
void elv_add_request(struct request_queue *q, struct request *rq, int where)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(q->queue_lock, flags);
|
2011-03-10 08:52:07 +01:00
|
|
|
__elv_add_request(q, rq, where);
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_unlock_irqrestore(q->queue_lock, flags);
|
|
|
|
}
|
2006-07-13 11:55:04 +02:00
|
|
|
EXPORT_SYMBOL(elv_add_request);
|
|
|
|
|
2007-07-24 09:28:11 +02:00
|
|
|
struct request *elv_latter_request(struct request_queue *q, struct request *rq)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-10-31 10:05:07 +01:00
|
|
|
struct elevator_queue *e = q->elevator;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2017-01-17 14:03:22 +01:00
|
|
|
if (e->uses_mq && e->type->ops.mq.next_request)
|
|
|
|
return e->type->ops.mq.next_request(q, rq);
|
|
|
|
else if (!e->uses_mq && e->type->ops.sq.elevator_latter_req_fn)
|
2016-12-10 23:13:59 +01:00
|
|
|
return e->type->ops.sq.elevator_latter_req_fn(q, rq);
|
2017-01-17 14:03:22 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-07-24 09:28:11 +02:00
|
|
|
struct request *elv_former_request(struct request_queue *q, struct request *rq)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-10-31 10:05:07 +01:00
|
|
|
struct elevator_queue *e = q->elevator;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2017-01-17 14:03:22 +01:00
|
|
|
if (e->uses_mq && e->type->ops.mq.former_request)
|
|
|
|
return e->type->ops.mq.former_request(q, rq);
|
|
|
|
if (!e->uses_mq && e->type->ops.sq.elevator_former_req_fn)
|
2016-12-10 23:13:59 +01:00
|
|
|
return e->type->ops.sq.elevator_former_req_fn(q, rq);
|
2005-04-17 00:20:36 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-03-05 22:15:27 +01:00
|
|
|
int elv_set_request(struct request_queue *q, struct request *rq,
|
|
|
|
struct bio *bio, gfp_t gfp_mask)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-10-31 10:05:07 +01:00
|
|
|
struct elevator_queue *e = q->elevator;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2017-01-17 14:03:22 +01:00
|
|
|
if (WARN_ON_ONCE(e->uses_mq))
|
|
|
|
return 0;
|
|
|
|
|
2016-12-10 23:13:59 +01:00
|
|
|
if (e->type->ops.sq.elevator_set_req_fn)
|
|
|
|
return e->type->ops.sq.elevator_set_req_fn(q, rq, bio, gfp_mask);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-07-24 09:28:11 +02:00
|
|
|
void elv_put_request(struct request_queue *q, struct request *rq)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-10-31 10:05:07 +01:00
|
|
|
struct elevator_queue *e = q->elevator;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2017-01-17 14:03:22 +01:00
|
|
|
if (WARN_ON_ONCE(e->uses_mq))
|
|
|
|
return;
|
|
|
|
|
2016-12-10 23:13:59 +01:00
|
|
|
if (e->type->ops.sq.elevator_put_req_fn)
|
|
|
|
e->type->ops.sq.elevator_put_req_fn(rq);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2016-10-28 16:48:16 +02:00
|
|
|
int elv_may_queue(struct request_queue *q, unsigned int op)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-10-31 10:05:07 +01:00
|
|
|
struct elevator_queue *e = q->elevator;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2017-01-17 14:03:22 +01:00
|
|
|
if (WARN_ON_ONCE(e->uses_mq))
|
|
|
|
return 0;
|
|
|
|
|
2016-12-10 23:13:59 +01:00
|
|
|
if (e->type->ops.sq.elevator_may_queue_fn)
|
|
|
|
return e->type->ops.sq.elevator_may_queue_fn(q, op);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
return ELV_MQUEUE_MAY;
|
|
|
|
}
|
|
|
|
|
2007-07-24 09:28:11 +02:00
|
|
|
void elv_completed_request(struct request_queue *q, struct request *rq)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-10-31 10:05:07 +01:00
|
|
|
struct elevator_queue *e = q->elevator;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2017-01-17 14:03:22 +01:00
|
|
|
if (WARN_ON_ONCE(e->uses_mq))
|
|
|
|
return;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* request is released from the driver, io must be done
|
|
|
|
*/
|
2005-10-20 16:23:44 +02:00
|
|
|
if (blk_account_rq(rq)) {
|
2009-05-20 08:54:31 +02:00
|
|
|
q->in_flight[rq_is_sync(rq)]--;
|
2016-10-20 15:12:13 +02:00
|
|
|
if ((rq->rq_flags & RQF_SORTED) &&
|
2016-12-10 23:13:59 +01:00
|
|
|
e->type->ops.sq.elevator_completed_req_fn)
|
|
|
|
e->type->ops.sq.elevator_completed_req_fn(q, rq);
|
2006-01-12 15:39:26 +01:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-03-19 00:35:43 +01:00
|
|
|
#define to_elv(atr) container_of((atr), struct elv_fs_entry, attr)
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
elv_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-03-19 00:35:43 +01:00
|
|
|
struct elv_fs_entry *entry = to_elv(attr);
|
2008-10-31 10:05:07 +01:00
|
|
|
struct elevator_queue *e;
|
2006-03-19 00:35:43 +01:00
|
|
|
ssize_t error;
|
|
|
|
|
|
|
|
if (!entry->show)
|
|
|
|
return -EIO;
|
|
|
|
|
2008-10-31 10:05:07 +01:00
|
|
|
e = container_of(kobj, struct elevator_queue, kobj);
|
2006-03-19 00:35:43 +01:00
|
|
|
mutex_lock(&e->sysfs_lock);
|
2011-12-14 00:33:41 +01:00
|
|
|
error = e->type ? entry->show(e, page) : -ENOENT;
|
2006-03-19 00:35:43 +01:00
|
|
|
mutex_unlock(&e->sysfs_lock);
|
|
|
|
return error;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-03-19 00:35:43 +01:00
|
|
|
static ssize_t
|
|
|
|
elv_attr_store(struct kobject *kobj, struct attribute *attr,
|
|
|
|
const char *page, size_t length)
|
|
|
|
{
|
|
|
|
struct elv_fs_entry *entry = to_elv(attr);
|
2008-10-31 10:05:07 +01:00
|
|
|
struct elevator_queue *e;
|
2006-03-19 00:35:43 +01:00
|
|
|
ssize_t error;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-03-19 00:35:43 +01:00
|
|
|
if (!entry->store)
|
|
|
|
return -EIO;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-10-31 10:05:07 +01:00
|
|
|
e = container_of(kobj, struct elevator_queue, kobj);
|
2006-03-19 00:35:43 +01:00
|
|
|
mutex_lock(&e->sysfs_lock);
|
2011-12-14 00:33:41 +01:00
|
|
|
error = e->type ? entry->store(e, page, length) : -ENOENT;
|
2006-03-19 00:35:43 +01:00
|
|
|
mutex_unlock(&e->sysfs_lock);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2010-01-19 02:58:23 +01:00
|
|
|
static const struct sysfs_ops elv_sysfs_ops = {
|
2006-03-19 00:35:43 +01:00
|
|
|
.show = elv_attr_show,
|
|
|
|
.store = elv_attr_store,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct kobj_type elv_ktype = {
|
|
|
|
.sysfs_ops = &elv_sysfs_ops,
|
|
|
|
.release = elevator_release,
|
|
|
|
};
|
|
|
|
|
block: split .sysfs_lock into two locks
commit cecf5d87ff2035127bb5a9ee054d0023a4a7cad3 upstream.
The kernfs built-in lock of 'kn->count' is held in sysfs .show/.store
path. Meantime, inside block's .show/.store callback, q->sysfs_lock is
required.
However, when mq & iosched kobjects are removed via
blk_mq_unregister_dev() & elv_unregister_queue(), q->sysfs_lock is held
too. This way causes AB-BA lock because the kernfs built-in lock of
'kn-count' is required inside kobject_del() too, see the lockdep warning[1].
On the other hand, it isn't necessary to acquire q->sysfs_lock for
both blk_mq_unregister_dev() & elv_unregister_queue() because
clearing REGISTERED flag prevents storing to 'queue/scheduler'
from being happened. Also sysfs write(store) is exclusive, so no
necessary to hold the lock for elv_unregister_queue() when it is
called in switching elevator path.
So split .sysfs_lock into two: one is still named as .sysfs_lock for
covering sync .store, the other one is named as .sysfs_dir_lock
for covering kobjects and related status change.
sysfs itself can handle the race between add/remove kobjects and
showing/storing attributes under kobjects. For switching scheduler
via storing to 'queue/scheduler', we use the queue flag of
QUEUE_FLAG_REGISTERED with .sysfs_lock for avoiding the race, then
we can avoid to hold .sysfs_lock during removing/adding kobjects.
[1] lockdep warning
======================================================
WARNING: possible circular locking dependency detected
5.3.0-rc3-00044-g73277fc75ea0 #1380 Not tainted
------------------------------------------------------
rmmod/777 is trying to acquire lock:
00000000ac50e981 (kn->count#202){++++}, at: kernfs_remove_by_name_ns+0x59/0x72
but task is already holding lock:
00000000fb16ae21 (&q->sysfs_lock){+.+.}, at: blk_unregister_queue+0x78/0x10b
which lock already depends on the new lock.
the existing dependency chain (in reverse order) is:
-> #1 (&q->sysfs_lock){+.+.}:
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
__mutex_lock+0x14a/0xa9b
blk_mq_hw_sysfs_show+0x63/0xb6
sysfs_kf_seq_show+0x11f/0x196
seq_read+0x2cd/0x5f2
vfs_read+0xc7/0x18c
ksys_read+0xc4/0x13e
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
-> #0 (kn->count#202){++++}:
check_prev_add+0x5d2/0xc45
validate_chain+0xed3/0xf94
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
__kernfs_remove+0x237/0x40b
kernfs_remove_by_name_ns+0x59/0x72
remove_files+0x61/0x96
sysfs_remove_group+0x81/0xa4
sysfs_remove_groups+0x3b/0x44
kobject_del+0x44/0x94
blk_mq_unregister_dev+0x83/0xdd
blk_unregister_queue+0xa0/0x10b
del_gendisk+0x259/0x3fa
null_del_dev+0x8b/0x1c3 [null_blk]
null_exit+0x5c/0x95 [null_blk]
__se_sys_delete_module+0x204/0x337
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
other info that might help us debug this:
Possible unsafe locking scenario:
CPU0 CPU1
---- ----
lock(&q->sysfs_lock);
lock(kn->count#202);
lock(&q->sysfs_lock);
lock(kn->count#202);
*** DEADLOCK ***
2 locks held by rmmod/777:
#0: 00000000e69bd9de (&lock){+.+.}, at: null_exit+0x2e/0x95 [null_blk]
#1: 00000000fb16ae21 (&q->sysfs_lock){+.+.}, at: blk_unregister_queue+0x78/0x10b
stack backtrace:
CPU: 0 PID: 777 Comm: rmmod Not tainted 5.3.0-rc3-00044-g73277fc75ea0 #1380
Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS ?-20180724_192412-buildhw-07.phx4
Call Trace:
dump_stack+0x9a/0xe6
check_noncircular+0x207/0x251
? print_circular_bug+0x32a/0x32a
? find_usage_backwards+0x84/0xb0
check_prev_add+0x5d2/0xc45
validate_chain+0xed3/0xf94
? check_prev_add+0xc45/0xc45
? mark_lock+0x11b/0x804
? check_usage_forwards+0x1ca/0x1ca
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
? kernfs_remove_by_name_ns+0x59/0x72
__kernfs_remove+0x237/0x40b
? kernfs_remove_by_name_ns+0x59/0x72
? kernfs_next_descendant_post+0x7d/0x7d
? strlen+0x10/0x23
? strcmp+0x22/0x44
kernfs_remove_by_name_ns+0x59/0x72
remove_files+0x61/0x96
sysfs_remove_group+0x81/0xa4
sysfs_remove_groups+0x3b/0x44
kobject_del+0x44/0x94
blk_mq_unregister_dev+0x83/0xdd
blk_unregister_queue+0xa0/0x10b
del_gendisk+0x259/0x3fa
? disk_events_poll_msecs_store+0x12b/0x12b
? check_flags+0x1ea/0x204
? mark_held_locks+0x1f/0x7a
null_del_dev+0x8b/0x1c3 [null_blk]
null_exit+0x5c/0x95 [null_blk]
__se_sys_delete_module+0x204/0x337
? free_module+0x39f/0x39f
? blkcg_maybe_throttle_current+0x8a/0x718
? rwlock_bug+0x62/0x62
? __blkcg_punt_bio_submit+0xd0/0xd0
? trace_hardirqs_on_thunk+0x1a/0x20
? mark_held_locks+0x1f/0x7a
? do_syscall_64+0x4c/0x295
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
RIP: 0033:0x7fb696cdbe6b
Code: 73 01 c3 48 8b 0d 1d 20 0c 00 f7 d8 64 89 01 48 83 c8 ff c3 66 2e 0f 1f 84 00 00 008
RSP: 002b:00007ffec9588788 EFLAGS: 00000206 ORIG_RAX: 00000000000000b0
RAX: ffffffffffffffda RBX: 0000559e589137c0 RCX: 00007fb696cdbe6b
RDX: 000000000000000a RSI: 0000000000000800 RDI: 0000559e58913828
RBP: 0000000000000000 R08: 00007ffec9587701 R09: 0000000000000000
R10: 00007fb696d4eae0 R11: 0000000000000206 R12: 00007ffec95889b0
R13: 00007ffec95896b3 R14: 0000559e58913260 R15: 0000559e589137c0
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Hannes Reinecke <hare@suse.com>
Cc: Greg KH <gregkh@linuxfoundation.org>
Cc: Mike Snitzer <snitzer@redhat.com>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Signed-off-by: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
(jwang:cherry picked from commit cecf5d87ff2035127bb5a9ee054d0023a4a7cad3,
adjust ctx for 4,19)
Signed-off-by: Jack Wang <jinpu.wang@cloud.ionos.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2019-08-27 13:01:48 +02:00
|
|
|
/*
|
|
|
|
* elv_register_queue is called from either blk_register_queue or
|
|
|
|
* elevator_switch, elevator switch is prevented from being happen
|
|
|
|
* in the two paths, so it is safe to not hold q->sysfs_lock.
|
|
|
|
*/
|
|
|
|
int elv_register_queue(struct request_queue *q, bool uevent)
|
2006-03-19 00:35:43 +01:00
|
|
|
{
|
2012-03-05 22:14:56 +01:00
|
|
|
struct elevator_queue *e = q->elevator;
|
2006-03-19 00:35:43 +01:00
|
|
|
int error;
|
|
|
|
|
2007-12-18 07:05:35 +01:00
|
|
|
error = kobject_add(&e->kobj, &q->kobj, "%s", "iosched");
|
2006-03-19 00:35:43 +01:00
|
|
|
if (!error) {
|
2011-12-14 00:33:41 +01:00
|
|
|
struct elv_fs_entry *attr = e->type->elevator_attrs;
|
2006-03-19 00:35:43 +01:00
|
|
|
if (attr) {
|
2006-03-19 04:27:18 +01:00
|
|
|
while (attr->attr.name) {
|
|
|
|
if (sysfs_create_file(&e->kobj, &attr->attr))
|
2006-03-19 00:35:43 +01:00
|
|
|
break;
|
2006-03-19 04:27:18 +01:00
|
|
|
attr++;
|
2006-03-19 00:35:43 +01:00
|
|
|
}
|
|
|
|
}
|
block: split .sysfs_lock into two locks
commit cecf5d87ff2035127bb5a9ee054d0023a4a7cad3 upstream.
The kernfs built-in lock of 'kn->count' is held in sysfs .show/.store
path. Meantime, inside block's .show/.store callback, q->sysfs_lock is
required.
However, when mq & iosched kobjects are removed via
blk_mq_unregister_dev() & elv_unregister_queue(), q->sysfs_lock is held
too. This way causes AB-BA lock because the kernfs built-in lock of
'kn-count' is required inside kobject_del() too, see the lockdep warning[1].
On the other hand, it isn't necessary to acquire q->sysfs_lock for
both blk_mq_unregister_dev() & elv_unregister_queue() because
clearing REGISTERED flag prevents storing to 'queue/scheduler'
from being happened. Also sysfs write(store) is exclusive, so no
necessary to hold the lock for elv_unregister_queue() when it is
called in switching elevator path.
So split .sysfs_lock into two: one is still named as .sysfs_lock for
covering sync .store, the other one is named as .sysfs_dir_lock
for covering kobjects and related status change.
sysfs itself can handle the race between add/remove kobjects and
showing/storing attributes under kobjects. For switching scheduler
via storing to 'queue/scheduler', we use the queue flag of
QUEUE_FLAG_REGISTERED with .sysfs_lock for avoiding the race, then
we can avoid to hold .sysfs_lock during removing/adding kobjects.
[1] lockdep warning
======================================================
WARNING: possible circular locking dependency detected
5.3.0-rc3-00044-g73277fc75ea0 #1380 Not tainted
------------------------------------------------------
rmmod/777 is trying to acquire lock:
00000000ac50e981 (kn->count#202){++++}, at: kernfs_remove_by_name_ns+0x59/0x72
but task is already holding lock:
00000000fb16ae21 (&q->sysfs_lock){+.+.}, at: blk_unregister_queue+0x78/0x10b
which lock already depends on the new lock.
the existing dependency chain (in reverse order) is:
-> #1 (&q->sysfs_lock){+.+.}:
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
__mutex_lock+0x14a/0xa9b
blk_mq_hw_sysfs_show+0x63/0xb6
sysfs_kf_seq_show+0x11f/0x196
seq_read+0x2cd/0x5f2
vfs_read+0xc7/0x18c
ksys_read+0xc4/0x13e
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
-> #0 (kn->count#202){++++}:
check_prev_add+0x5d2/0xc45
validate_chain+0xed3/0xf94
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
__kernfs_remove+0x237/0x40b
kernfs_remove_by_name_ns+0x59/0x72
remove_files+0x61/0x96
sysfs_remove_group+0x81/0xa4
sysfs_remove_groups+0x3b/0x44
kobject_del+0x44/0x94
blk_mq_unregister_dev+0x83/0xdd
blk_unregister_queue+0xa0/0x10b
del_gendisk+0x259/0x3fa
null_del_dev+0x8b/0x1c3 [null_blk]
null_exit+0x5c/0x95 [null_blk]
__se_sys_delete_module+0x204/0x337
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
other info that might help us debug this:
Possible unsafe locking scenario:
CPU0 CPU1
---- ----
lock(&q->sysfs_lock);
lock(kn->count#202);
lock(&q->sysfs_lock);
lock(kn->count#202);
*** DEADLOCK ***
2 locks held by rmmod/777:
#0: 00000000e69bd9de (&lock){+.+.}, at: null_exit+0x2e/0x95 [null_blk]
#1: 00000000fb16ae21 (&q->sysfs_lock){+.+.}, at: blk_unregister_queue+0x78/0x10b
stack backtrace:
CPU: 0 PID: 777 Comm: rmmod Not tainted 5.3.0-rc3-00044-g73277fc75ea0 #1380
Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS ?-20180724_192412-buildhw-07.phx4
Call Trace:
dump_stack+0x9a/0xe6
check_noncircular+0x207/0x251
? print_circular_bug+0x32a/0x32a
? find_usage_backwards+0x84/0xb0
check_prev_add+0x5d2/0xc45
validate_chain+0xed3/0xf94
? check_prev_add+0xc45/0xc45
? mark_lock+0x11b/0x804
? check_usage_forwards+0x1ca/0x1ca
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
? kernfs_remove_by_name_ns+0x59/0x72
__kernfs_remove+0x237/0x40b
? kernfs_remove_by_name_ns+0x59/0x72
? kernfs_next_descendant_post+0x7d/0x7d
? strlen+0x10/0x23
? strcmp+0x22/0x44
kernfs_remove_by_name_ns+0x59/0x72
remove_files+0x61/0x96
sysfs_remove_group+0x81/0xa4
sysfs_remove_groups+0x3b/0x44
kobject_del+0x44/0x94
blk_mq_unregister_dev+0x83/0xdd
blk_unregister_queue+0xa0/0x10b
del_gendisk+0x259/0x3fa
? disk_events_poll_msecs_store+0x12b/0x12b
? check_flags+0x1ea/0x204
? mark_held_locks+0x1f/0x7a
null_del_dev+0x8b/0x1c3 [null_blk]
null_exit+0x5c/0x95 [null_blk]
__se_sys_delete_module+0x204/0x337
? free_module+0x39f/0x39f
? blkcg_maybe_throttle_current+0x8a/0x718
? rwlock_bug+0x62/0x62
? __blkcg_punt_bio_submit+0xd0/0xd0
? trace_hardirqs_on_thunk+0x1a/0x20
? mark_held_locks+0x1f/0x7a
? do_syscall_64+0x4c/0x295
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
RIP: 0033:0x7fb696cdbe6b
Code: 73 01 c3 48 8b 0d 1d 20 0c 00 f7 d8 64 89 01 48 83 c8 ff c3 66 2e 0f 1f 84 00 00 008
RSP: 002b:00007ffec9588788 EFLAGS: 00000206 ORIG_RAX: 00000000000000b0
RAX: ffffffffffffffda RBX: 0000559e589137c0 RCX: 00007fb696cdbe6b
RDX: 000000000000000a RSI: 0000000000000800 RDI: 0000559e58913828
RBP: 0000000000000000 R08: 00007ffec9587701 R09: 0000000000000000
R10: 00007fb696d4eae0 R11: 0000000000000206 R12: 00007ffec95889b0
R13: 00007ffec95896b3 R14: 0000559e58913260 R15: 0000559e589137c0
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Hannes Reinecke <hare@suse.com>
Cc: Greg KH <gregkh@linuxfoundation.org>
Cc: Mike Snitzer <snitzer@redhat.com>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Signed-off-by: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
(jwang:cherry picked from commit cecf5d87ff2035127bb5a9ee054d0023a4a7cad3,
adjust ctx for 4,19)
Signed-off-by: Jack Wang <jinpu.wang@cloud.ionos.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2019-08-27 13:01:48 +02:00
|
|
|
if (uevent)
|
|
|
|
kobject_uevent(&e->kobj, KOBJ_ADD);
|
|
|
|
|
2010-10-07 09:35:16 +02:00
|
|
|
e->registered = 1;
|
2017-01-17 14:03:22 +01:00
|
|
|
if (!e->uses_mq && e->type->ops.sq.elevator_registered_fn)
|
2016-12-10 23:13:59 +01:00
|
|
|
e->type->ops.sq.elevator_registered_fn(q);
|
2006-03-19 00:35:43 +01:00
|
|
|
}
|
|
|
|
return error;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2006-06-08 08:49:06 +02:00
|
|
|
|
block: split .sysfs_lock into two locks
commit cecf5d87ff2035127bb5a9ee054d0023a4a7cad3 upstream.
The kernfs built-in lock of 'kn->count' is held in sysfs .show/.store
path. Meantime, inside block's .show/.store callback, q->sysfs_lock is
required.
However, when mq & iosched kobjects are removed via
blk_mq_unregister_dev() & elv_unregister_queue(), q->sysfs_lock is held
too. This way causes AB-BA lock because the kernfs built-in lock of
'kn-count' is required inside kobject_del() too, see the lockdep warning[1].
On the other hand, it isn't necessary to acquire q->sysfs_lock for
both blk_mq_unregister_dev() & elv_unregister_queue() because
clearing REGISTERED flag prevents storing to 'queue/scheduler'
from being happened. Also sysfs write(store) is exclusive, so no
necessary to hold the lock for elv_unregister_queue() when it is
called in switching elevator path.
So split .sysfs_lock into two: one is still named as .sysfs_lock for
covering sync .store, the other one is named as .sysfs_dir_lock
for covering kobjects and related status change.
sysfs itself can handle the race between add/remove kobjects and
showing/storing attributes under kobjects. For switching scheduler
via storing to 'queue/scheduler', we use the queue flag of
QUEUE_FLAG_REGISTERED with .sysfs_lock for avoiding the race, then
we can avoid to hold .sysfs_lock during removing/adding kobjects.
[1] lockdep warning
======================================================
WARNING: possible circular locking dependency detected
5.3.0-rc3-00044-g73277fc75ea0 #1380 Not tainted
------------------------------------------------------
rmmod/777 is trying to acquire lock:
00000000ac50e981 (kn->count#202){++++}, at: kernfs_remove_by_name_ns+0x59/0x72
but task is already holding lock:
00000000fb16ae21 (&q->sysfs_lock){+.+.}, at: blk_unregister_queue+0x78/0x10b
which lock already depends on the new lock.
the existing dependency chain (in reverse order) is:
-> #1 (&q->sysfs_lock){+.+.}:
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
__mutex_lock+0x14a/0xa9b
blk_mq_hw_sysfs_show+0x63/0xb6
sysfs_kf_seq_show+0x11f/0x196
seq_read+0x2cd/0x5f2
vfs_read+0xc7/0x18c
ksys_read+0xc4/0x13e
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
-> #0 (kn->count#202){++++}:
check_prev_add+0x5d2/0xc45
validate_chain+0xed3/0xf94
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
__kernfs_remove+0x237/0x40b
kernfs_remove_by_name_ns+0x59/0x72
remove_files+0x61/0x96
sysfs_remove_group+0x81/0xa4
sysfs_remove_groups+0x3b/0x44
kobject_del+0x44/0x94
blk_mq_unregister_dev+0x83/0xdd
blk_unregister_queue+0xa0/0x10b
del_gendisk+0x259/0x3fa
null_del_dev+0x8b/0x1c3 [null_blk]
null_exit+0x5c/0x95 [null_blk]
__se_sys_delete_module+0x204/0x337
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
other info that might help us debug this:
Possible unsafe locking scenario:
CPU0 CPU1
---- ----
lock(&q->sysfs_lock);
lock(kn->count#202);
lock(&q->sysfs_lock);
lock(kn->count#202);
*** DEADLOCK ***
2 locks held by rmmod/777:
#0: 00000000e69bd9de (&lock){+.+.}, at: null_exit+0x2e/0x95 [null_blk]
#1: 00000000fb16ae21 (&q->sysfs_lock){+.+.}, at: blk_unregister_queue+0x78/0x10b
stack backtrace:
CPU: 0 PID: 777 Comm: rmmod Not tainted 5.3.0-rc3-00044-g73277fc75ea0 #1380
Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS ?-20180724_192412-buildhw-07.phx4
Call Trace:
dump_stack+0x9a/0xe6
check_noncircular+0x207/0x251
? print_circular_bug+0x32a/0x32a
? find_usage_backwards+0x84/0xb0
check_prev_add+0x5d2/0xc45
validate_chain+0xed3/0xf94
? check_prev_add+0xc45/0xc45
? mark_lock+0x11b/0x804
? check_usage_forwards+0x1ca/0x1ca
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
? kernfs_remove_by_name_ns+0x59/0x72
__kernfs_remove+0x237/0x40b
? kernfs_remove_by_name_ns+0x59/0x72
? kernfs_next_descendant_post+0x7d/0x7d
? strlen+0x10/0x23
? strcmp+0x22/0x44
kernfs_remove_by_name_ns+0x59/0x72
remove_files+0x61/0x96
sysfs_remove_group+0x81/0xa4
sysfs_remove_groups+0x3b/0x44
kobject_del+0x44/0x94
blk_mq_unregister_dev+0x83/0xdd
blk_unregister_queue+0xa0/0x10b
del_gendisk+0x259/0x3fa
? disk_events_poll_msecs_store+0x12b/0x12b
? check_flags+0x1ea/0x204
? mark_held_locks+0x1f/0x7a
null_del_dev+0x8b/0x1c3 [null_blk]
null_exit+0x5c/0x95 [null_blk]
__se_sys_delete_module+0x204/0x337
? free_module+0x39f/0x39f
? blkcg_maybe_throttle_current+0x8a/0x718
? rwlock_bug+0x62/0x62
? __blkcg_punt_bio_submit+0xd0/0xd0
? trace_hardirqs_on_thunk+0x1a/0x20
? mark_held_locks+0x1f/0x7a
? do_syscall_64+0x4c/0x295
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
RIP: 0033:0x7fb696cdbe6b
Code: 73 01 c3 48 8b 0d 1d 20 0c 00 f7 d8 64 89 01 48 83 c8 ff c3 66 2e 0f 1f 84 00 00 008
RSP: 002b:00007ffec9588788 EFLAGS: 00000206 ORIG_RAX: 00000000000000b0
RAX: ffffffffffffffda RBX: 0000559e589137c0 RCX: 00007fb696cdbe6b
RDX: 000000000000000a RSI: 0000000000000800 RDI: 0000559e58913828
RBP: 0000000000000000 R08: 00007ffec9587701 R09: 0000000000000000
R10: 00007fb696d4eae0 R11: 0000000000000206 R12: 00007ffec95889b0
R13: 00007ffec95896b3 R14: 0000559e58913260 R15: 0000559e589137c0
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Hannes Reinecke <hare@suse.com>
Cc: Greg KH <gregkh@linuxfoundation.org>
Cc: Mike Snitzer <snitzer@redhat.com>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Signed-off-by: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
(jwang:cherry picked from commit cecf5d87ff2035127bb5a9ee054d0023a4a7cad3,
adjust ctx for 4,19)
Signed-off-by: Jack Wang <jinpu.wang@cloud.ionos.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2019-08-27 13:01:48 +02:00
|
|
|
/*
|
|
|
|
* elv_unregister_queue is called from either blk_unregister_queue or
|
|
|
|
* elevator_switch, elevator switch is prevented from being happen
|
|
|
|
* in the two paths, so it is safe to not hold q->sysfs_lock.
|
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
void elv_unregister_queue(struct request_queue *q)
|
|
|
|
{
|
2011-12-14 00:33:40 +01:00
|
|
|
if (q) {
|
|
|
|
struct elevator_queue *e = q->elevator;
|
|
|
|
|
|
|
|
kobject_uevent(&e->kobj, KOBJ_REMOVE);
|
|
|
|
kobject_del(&e->kobj);
|
block: split .sysfs_lock into two locks
commit cecf5d87ff2035127bb5a9ee054d0023a4a7cad3 upstream.
The kernfs built-in lock of 'kn->count' is held in sysfs .show/.store
path. Meantime, inside block's .show/.store callback, q->sysfs_lock is
required.
However, when mq & iosched kobjects are removed via
blk_mq_unregister_dev() & elv_unregister_queue(), q->sysfs_lock is held
too. This way causes AB-BA lock because the kernfs built-in lock of
'kn-count' is required inside kobject_del() too, see the lockdep warning[1].
On the other hand, it isn't necessary to acquire q->sysfs_lock for
both blk_mq_unregister_dev() & elv_unregister_queue() because
clearing REGISTERED flag prevents storing to 'queue/scheduler'
from being happened. Also sysfs write(store) is exclusive, so no
necessary to hold the lock for elv_unregister_queue() when it is
called in switching elevator path.
So split .sysfs_lock into two: one is still named as .sysfs_lock for
covering sync .store, the other one is named as .sysfs_dir_lock
for covering kobjects and related status change.
sysfs itself can handle the race between add/remove kobjects and
showing/storing attributes under kobjects. For switching scheduler
via storing to 'queue/scheduler', we use the queue flag of
QUEUE_FLAG_REGISTERED with .sysfs_lock for avoiding the race, then
we can avoid to hold .sysfs_lock during removing/adding kobjects.
[1] lockdep warning
======================================================
WARNING: possible circular locking dependency detected
5.3.0-rc3-00044-g73277fc75ea0 #1380 Not tainted
------------------------------------------------------
rmmod/777 is trying to acquire lock:
00000000ac50e981 (kn->count#202){++++}, at: kernfs_remove_by_name_ns+0x59/0x72
but task is already holding lock:
00000000fb16ae21 (&q->sysfs_lock){+.+.}, at: blk_unregister_queue+0x78/0x10b
which lock already depends on the new lock.
the existing dependency chain (in reverse order) is:
-> #1 (&q->sysfs_lock){+.+.}:
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
__mutex_lock+0x14a/0xa9b
blk_mq_hw_sysfs_show+0x63/0xb6
sysfs_kf_seq_show+0x11f/0x196
seq_read+0x2cd/0x5f2
vfs_read+0xc7/0x18c
ksys_read+0xc4/0x13e
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
-> #0 (kn->count#202){++++}:
check_prev_add+0x5d2/0xc45
validate_chain+0xed3/0xf94
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
__kernfs_remove+0x237/0x40b
kernfs_remove_by_name_ns+0x59/0x72
remove_files+0x61/0x96
sysfs_remove_group+0x81/0xa4
sysfs_remove_groups+0x3b/0x44
kobject_del+0x44/0x94
blk_mq_unregister_dev+0x83/0xdd
blk_unregister_queue+0xa0/0x10b
del_gendisk+0x259/0x3fa
null_del_dev+0x8b/0x1c3 [null_blk]
null_exit+0x5c/0x95 [null_blk]
__se_sys_delete_module+0x204/0x337
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
other info that might help us debug this:
Possible unsafe locking scenario:
CPU0 CPU1
---- ----
lock(&q->sysfs_lock);
lock(kn->count#202);
lock(&q->sysfs_lock);
lock(kn->count#202);
*** DEADLOCK ***
2 locks held by rmmod/777:
#0: 00000000e69bd9de (&lock){+.+.}, at: null_exit+0x2e/0x95 [null_blk]
#1: 00000000fb16ae21 (&q->sysfs_lock){+.+.}, at: blk_unregister_queue+0x78/0x10b
stack backtrace:
CPU: 0 PID: 777 Comm: rmmod Not tainted 5.3.0-rc3-00044-g73277fc75ea0 #1380
Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS ?-20180724_192412-buildhw-07.phx4
Call Trace:
dump_stack+0x9a/0xe6
check_noncircular+0x207/0x251
? print_circular_bug+0x32a/0x32a
? find_usage_backwards+0x84/0xb0
check_prev_add+0x5d2/0xc45
validate_chain+0xed3/0xf94
? check_prev_add+0xc45/0xc45
? mark_lock+0x11b/0x804
? check_usage_forwards+0x1ca/0x1ca
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
? kernfs_remove_by_name_ns+0x59/0x72
__kernfs_remove+0x237/0x40b
? kernfs_remove_by_name_ns+0x59/0x72
? kernfs_next_descendant_post+0x7d/0x7d
? strlen+0x10/0x23
? strcmp+0x22/0x44
kernfs_remove_by_name_ns+0x59/0x72
remove_files+0x61/0x96
sysfs_remove_group+0x81/0xa4
sysfs_remove_groups+0x3b/0x44
kobject_del+0x44/0x94
blk_mq_unregister_dev+0x83/0xdd
blk_unregister_queue+0xa0/0x10b
del_gendisk+0x259/0x3fa
? disk_events_poll_msecs_store+0x12b/0x12b
? check_flags+0x1ea/0x204
? mark_held_locks+0x1f/0x7a
null_del_dev+0x8b/0x1c3 [null_blk]
null_exit+0x5c/0x95 [null_blk]
__se_sys_delete_module+0x204/0x337
? free_module+0x39f/0x39f
? blkcg_maybe_throttle_current+0x8a/0x718
? rwlock_bug+0x62/0x62
? __blkcg_punt_bio_submit+0xd0/0xd0
? trace_hardirqs_on_thunk+0x1a/0x20
? mark_held_locks+0x1f/0x7a
? do_syscall_64+0x4c/0x295
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
RIP: 0033:0x7fb696cdbe6b
Code: 73 01 c3 48 8b 0d 1d 20 0c 00 f7 d8 64 89 01 48 83 c8 ff c3 66 2e 0f 1f 84 00 00 008
RSP: 002b:00007ffec9588788 EFLAGS: 00000206 ORIG_RAX: 00000000000000b0
RAX: ffffffffffffffda RBX: 0000559e589137c0 RCX: 00007fb696cdbe6b
RDX: 000000000000000a RSI: 0000000000000800 RDI: 0000559e58913828
RBP: 0000000000000000 R08: 00007ffec9587701 R09: 0000000000000000
R10: 00007fb696d4eae0 R11: 0000000000000206 R12: 00007ffec95889b0
R13: 00007ffec95896b3 R14: 0000559e58913260 R15: 0000559e589137c0
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Hannes Reinecke <hare@suse.com>
Cc: Greg KH <gregkh@linuxfoundation.org>
Cc: Mike Snitzer <snitzer@redhat.com>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Signed-off-by: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
(jwang:cherry picked from commit cecf5d87ff2035127bb5a9ee054d0023a4a7cad3,
adjust ctx for 4,19)
Signed-off-by: Jack Wang <jinpu.wang@cloud.ionos.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2019-08-27 13:01:48 +02:00
|
|
|
|
2011-12-14 00:33:40 +01:00
|
|
|
e->registered = 0;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2014-06-23 00:32:48 +02:00
|
|
|
int elv_register(struct elevator_type *e)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-03-15 12:59:19 +01:00
|
|
|
char *def = "";
|
2007-04-26 14:41:53 +02:00
|
|
|
|
2011-12-14 00:33:42 +01:00
|
|
|
/* create icq_cache if requested */
|
|
|
|
if (e->icq_size) {
|
|
|
|
if (WARN_ON(e->icq_size < sizeof(struct io_cq)) ||
|
|
|
|
WARN_ON(e->icq_align < __alignof__(struct io_cq)))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
snprintf(e->icq_cache_name, sizeof(e->icq_cache_name),
|
|
|
|
"%s_io_cq", e->elevator_name);
|
|
|
|
e->icq_cache = kmem_cache_create(e->icq_cache_name, e->icq_size,
|
|
|
|
e->icq_align, 0, NULL);
|
|
|
|
if (!e->icq_cache)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* register, don't allow duplicate names */
|
2007-04-26 14:41:53 +02:00
|
|
|
spin_lock(&elv_list_lock);
|
2017-10-25 20:33:42 +02:00
|
|
|
if (elevator_find(e->elevator_name, e->uses_mq)) {
|
2011-12-14 00:33:42 +01:00
|
|
|
spin_unlock(&elv_list_lock);
|
2018-08-28 01:31:11 +02:00
|
|
|
kmem_cache_destroy(e->icq_cache);
|
2011-12-14 00:33:42 +01:00
|
|
|
return -EBUSY;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
list_add_tail(&e->list, &elv_list);
|
2007-04-26 14:41:53 +02:00
|
|
|
spin_unlock(&elv_list_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2011-12-14 00:33:42 +01:00
|
|
|
/* print pretty message */
|
2017-10-25 20:35:02 +02:00
|
|
|
if (elevator_match(e, chosen_elevator) ||
|
2006-01-24 10:07:58 +01:00
|
|
|
(!*chosen_elevator &&
|
2017-10-25 20:35:02 +02:00
|
|
|
elevator_match(e, CONFIG_DEFAULT_IOSCHED)))
|
2007-03-15 12:59:19 +01:00
|
|
|
def = " (default)";
|
|
|
|
|
2008-02-01 00:37:27 +01:00
|
|
|
printk(KERN_INFO "io scheduler %s registered%s\n", e->elevator_name,
|
|
|
|
def);
|
2011-12-14 00:33:42 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(elv_register);
|
|
|
|
|
|
|
|
void elv_unregister(struct elevator_type *e)
|
|
|
|
{
|
2011-12-14 00:33:42 +01:00
|
|
|
/* unregister */
|
2007-04-26 14:41:53 +02:00
|
|
|
spin_lock(&elv_list_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
list_del_init(&e->list);
|
2007-04-26 14:41:53 +02:00
|
|
|
spin_unlock(&elv_list_lock);
|
2011-12-14 00:33:42 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Destroy icq_cache if it exists. icq's are RCU managed. Make
|
|
|
|
* sure all RCU operations are complete before proceeding.
|
|
|
|
*/
|
|
|
|
if (e->icq_cache) {
|
|
|
|
rcu_barrier();
|
|
|
|
kmem_cache_destroy(e->icq_cache);
|
|
|
|
e->icq_cache = NULL;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(elv_unregister);
|
|
|
|
|
2018-08-21 09:15:03 +02:00
|
|
|
int elevator_switch_mq(struct request_queue *q,
|
2017-04-07 16:52:27 +02:00
|
|
|
struct elevator_type *new_e)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2018-01-17 20:48:09 +01:00
|
|
|
lockdep_assert_held(&q->sysfs_lock);
|
|
|
|
|
2017-04-07 16:52:27 +02:00
|
|
|
if (q->elevator) {
|
2019-09-23 17:12:09 +02:00
|
|
|
if (q->elevator->registered)
|
2017-04-07 16:52:27 +02:00
|
|
|
elv_unregister_queue(q);
|
block: split .sysfs_lock into two locks
commit cecf5d87ff2035127bb5a9ee054d0023a4a7cad3 upstream.
The kernfs built-in lock of 'kn->count' is held in sysfs .show/.store
path. Meantime, inside block's .show/.store callback, q->sysfs_lock is
required.
However, when mq & iosched kobjects are removed via
blk_mq_unregister_dev() & elv_unregister_queue(), q->sysfs_lock is held
too. This way causes AB-BA lock because the kernfs built-in lock of
'kn-count' is required inside kobject_del() too, see the lockdep warning[1].
On the other hand, it isn't necessary to acquire q->sysfs_lock for
both blk_mq_unregister_dev() & elv_unregister_queue() because
clearing REGISTERED flag prevents storing to 'queue/scheduler'
from being happened. Also sysfs write(store) is exclusive, so no
necessary to hold the lock for elv_unregister_queue() when it is
called in switching elevator path.
So split .sysfs_lock into two: one is still named as .sysfs_lock for
covering sync .store, the other one is named as .sysfs_dir_lock
for covering kobjects and related status change.
sysfs itself can handle the race between add/remove kobjects and
showing/storing attributes under kobjects. For switching scheduler
via storing to 'queue/scheduler', we use the queue flag of
QUEUE_FLAG_REGISTERED with .sysfs_lock for avoiding the race, then
we can avoid to hold .sysfs_lock during removing/adding kobjects.
[1] lockdep warning
======================================================
WARNING: possible circular locking dependency detected
5.3.0-rc3-00044-g73277fc75ea0 #1380 Not tainted
------------------------------------------------------
rmmod/777 is trying to acquire lock:
00000000ac50e981 (kn->count#202){++++}, at: kernfs_remove_by_name_ns+0x59/0x72
but task is already holding lock:
00000000fb16ae21 (&q->sysfs_lock){+.+.}, at: blk_unregister_queue+0x78/0x10b
which lock already depends on the new lock.
the existing dependency chain (in reverse order) is:
-> #1 (&q->sysfs_lock){+.+.}:
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
__mutex_lock+0x14a/0xa9b
blk_mq_hw_sysfs_show+0x63/0xb6
sysfs_kf_seq_show+0x11f/0x196
seq_read+0x2cd/0x5f2
vfs_read+0xc7/0x18c
ksys_read+0xc4/0x13e
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
-> #0 (kn->count#202){++++}:
check_prev_add+0x5d2/0xc45
validate_chain+0xed3/0xf94
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
__kernfs_remove+0x237/0x40b
kernfs_remove_by_name_ns+0x59/0x72
remove_files+0x61/0x96
sysfs_remove_group+0x81/0xa4
sysfs_remove_groups+0x3b/0x44
kobject_del+0x44/0x94
blk_mq_unregister_dev+0x83/0xdd
blk_unregister_queue+0xa0/0x10b
del_gendisk+0x259/0x3fa
null_del_dev+0x8b/0x1c3 [null_blk]
null_exit+0x5c/0x95 [null_blk]
__se_sys_delete_module+0x204/0x337
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
other info that might help us debug this:
Possible unsafe locking scenario:
CPU0 CPU1
---- ----
lock(&q->sysfs_lock);
lock(kn->count#202);
lock(&q->sysfs_lock);
lock(kn->count#202);
*** DEADLOCK ***
2 locks held by rmmod/777:
#0: 00000000e69bd9de (&lock){+.+.}, at: null_exit+0x2e/0x95 [null_blk]
#1: 00000000fb16ae21 (&q->sysfs_lock){+.+.}, at: blk_unregister_queue+0x78/0x10b
stack backtrace:
CPU: 0 PID: 777 Comm: rmmod Not tainted 5.3.0-rc3-00044-g73277fc75ea0 #1380
Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS ?-20180724_192412-buildhw-07.phx4
Call Trace:
dump_stack+0x9a/0xe6
check_noncircular+0x207/0x251
? print_circular_bug+0x32a/0x32a
? find_usage_backwards+0x84/0xb0
check_prev_add+0x5d2/0xc45
validate_chain+0xed3/0xf94
? check_prev_add+0xc45/0xc45
? mark_lock+0x11b/0x804
? check_usage_forwards+0x1ca/0x1ca
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
? kernfs_remove_by_name_ns+0x59/0x72
__kernfs_remove+0x237/0x40b
? kernfs_remove_by_name_ns+0x59/0x72
? kernfs_next_descendant_post+0x7d/0x7d
? strlen+0x10/0x23
? strcmp+0x22/0x44
kernfs_remove_by_name_ns+0x59/0x72
remove_files+0x61/0x96
sysfs_remove_group+0x81/0xa4
sysfs_remove_groups+0x3b/0x44
kobject_del+0x44/0x94
blk_mq_unregister_dev+0x83/0xdd
blk_unregister_queue+0xa0/0x10b
del_gendisk+0x259/0x3fa
? disk_events_poll_msecs_store+0x12b/0x12b
? check_flags+0x1ea/0x204
? mark_held_locks+0x1f/0x7a
null_del_dev+0x8b/0x1c3 [null_blk]
null_exit+0x5c/0x95 [null_blk]
__se_sys_delete_module+0x204/0x337
? free_module+0x39f/0x39f
? blkcg_maybe_throttle_current+0x8a/0x718
? rwlock_bug+0x62/0x62
? __blkcg_punt_bio_submit+0xd0/0xd0
? trace_hardirqs_on_thunk+0x1a/0x20
? mark_held_locks+0x1f/0x7a
? do_syscall_64+0x4c/0x295
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
RIP: 0033:0x7fb696cdbe6b
Code: 73 01 c3 48 8b 0d 1d 20 0c 00 f7 d8 64 89 01 48 83 c8 ff c3 66 2e 0f 1f 84 00 00 008
RSP: 002b:00007ffec9588788 EFLAGS: 00000206 ORIG_RAX: 00000000000000b0
RAX: ffffffffffffffda RBX: 0000559e589137c0 RCX: 00007fb696cdbe6b
RDX: 000000000000000a RSI: 0000000000000800 RDI: 0000559e58913828
RBP: 0000000000000000 R08: 00007ffec9587701 R09: 0000000000000000
R10: 00007fb696d4eae0 R11: 0000000000000206 R12: 00007ffec95889b0
R13: 00007ffec95896b3 R14: 0000559e58913260 R15: 0000559e589137c0
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Hannes Reinecke <hare@suse.com>
Cc: Greg KH <gregkh@linuxfoundation.org>
Cc: Mike Snitzer <snitzer@redhat.com>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Signed-off-by: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
(jwang:cherry picked from commit cecf5d87ff2035127bb5a9ee054d0023a4a7cad3,
adjust ctx for 4,19)
Signed-off-by: Jack Wang <jinpu.wang@cloud.ionos.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2019-08-27 13:01:48 +02:00
|
|
|
|
2017-04-07 16:52:27 +02:00
|
|
|
ioc_clear_queue(q);
|
|
|
|
elevator_exit(q, q->elevator);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = blk_mq_init_sched(q, new_e);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (new_e) {
|
block: split .sysfs_lock into two locks
commit cecf5d87ff2035127bb5a9ee054d0023a4a7cad3 upstream.
The kernfs built-in lock of 'kn->count' is held in sysfs .show/.store
path. Meantime, inside block's .show/.store callback, q->sysfs_lock is
required.
However, when mq & iosched kobjects are removed via
blk_mq_unregister_dev() & elv_unregister_queue(), q->sysfs_lock is held
too. This way causes AB-BA lock because the kernfs built-in lock of
'kn-count' is required inside kobject_del() too, see the lockdep warning[1].
On the other hand, it isn't necessary to acquire q->sysfs_lock for
both blk_mq_unregister_dev() & elv_unregister_queue() because
clearing REGISTERED flag prevents storing to 'queue/scheduler'
from being happened. Also sysfs write(store) is exclusive, so no
necessary to hold the lock for elv_unregister_queue() when it is
called in switching elevator path.
So split .sysfs_lock into two: one is still named as .sysfs_lock for
covering sync .store, the other one is named as .sysfs_dir_lock
for covering kobjects and related status change.
sysfs itself can handle the race between add/remove kobjects and
showing/storing attributes under kobjects. For switching scheduler
via storing to 'queue/scheduler', we use the queue flag of
QUEUE_FLAG_REGISTERED with .sysfs_lock for avoiding the race, then
we can avoid to hold .sysfs_lock during removing/adding kobjects.
[1] lockdep warning
======================================================
WARNING: possible circular locking dependency detected
5.3.0-rc3-00044-g73277fc75ea0 #1380 Not tainted
------------------------------------------------------
rmmod/777 is trying to acquire lock:
00000000ac50e981 (kn->count#202){++++}, at: kernfs_remove_by_name_ns+0x59/0x72
but task is already holding lock:
00000000fb16ae21 (&q->sysfs_lock){+.+.}, at: blk_unregister_queue+0x78/0x10b
which lock already depends on the new lock.
the existing dependency chain (in reverse order) is:
-> #1 (&q->sysfs_lock){+.+.}:
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
__mutex_lock+0x14a/0xa9b
blk_mq_hw_sysfs_show+0x63/0xb6
sysfs_kf_seq_show+0x11f/0x196
seq_read+0x2cd/0x5f2
vfs_read+0xc7/0x18c
ksys_read+0xc4/0x13e
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
-> #0 (kn->count#202){++++}:
check_prev_add+0x5d2/0xc45
validate_chain+0xed3/0xf94
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
__kernfs_remove+0x237/0x40b
kernfs_remove_by_name_ns+0x59/0x72
remove_files+0x61/0x96
sysfs_remove_group+0x81/0xa4
sysfs_remove_groups+0x3b/0x44
kobject_del+0x44/0x94
blk_mq_unregister_dev+0x83/0xdd
blk_unregister_queue+0xa0/0x10b
del_gendisk+0x259/0x3fa
null_del_dev+0x8b/0x1c3 [null_blk]
null_exit+0x5c/0x95 [null_blk]
__se_sys_delete_module+0x204/0x337
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
other info that might help us debug this:
Possible unsafe locking scenario:
CPU0 CPU1
---- ----
lock(&q->sysfs_lock);
lock(kn->count#202);
lock(&q->sysfs_lock);
lock(kn->count#202);
*** DEADLOCK ***
2 locks held by rmmod/777:
#0: 00000000e69bd9de (&lock){+.+.}, at: null_exit+0x2e/0x95 [null_blk]
#1: 00000000fb16ae21 (&q->sysfs_lock){+.+.}, at: blk_unregister_queue+0x78/0x10b
stack backtrace:
CPU: 0 PID: 777 Comm: rmmod Not tainted 5.3.0-rc3-00044-g73277fc75ea0 #1380
Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS ?-20180724_192412-buildhw-07.phx4
Call Trace:
dump_stack+0x9a/0xe6
check_noncircular+0x207/0x251
? print_circular_bug+0x32a/0x32a
? find_usage_backwards+0x84/0xb0
check_prev_add+0x5d2/0xc45
validate_chain+0xed3/0xf94
? check_prev_add+0xc45/0xc45
? mark_lock+0x11b/0x804
? check_usage_forwards+0x1ca/0x1ca
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
? kernfs_remove_by_name_ns+0x59/0x72
__kernfs_remove+0x237/0x40b
? kernfs_remove_by_name_ns+0x59/0x72
? kernfs_next_descendant_post+0x7d/0x7d
? strlen+0x10/0x23
? strcmp+0x22/0x44
kernfs_remove_by_name_ns+0x59/0x72
remove_files+0x61/0x96
sysfs_remove_group+0x81/0xa4
sysfs_remove_groups+0x3b/0x44
kobject_del+0x44/0x94
blk_mq_unregister_dev+0x83/0xdd
blk_unregister_queue+0xa0/0x10b
del_gendisk+0x259/0x3fa
? disk_events_poll_msecs_store+0x12b/0x12b
? check_flags+0x1ea/0x204
? mark_held_locks+0x1f/0x7a
null_del_dev+0x8b/0x1c3 [null_blk]
null_exit+0x5c/0x95 [null_blk]
__se_sys_delete_module+0x204/0x337
? free_module+0x39f/0x39f
? blkcg_maybe_throttle_current+0x8a/0x718
? rwlock_bug+0x62/0x62
? __blkcg_punt_bio_submit+0xd0/0xd0
? trace_hardirqs_on_thunk+0x1a/0x20
? mark_held_locks+0x1f/0x7a
? do_syscall_64+0x4c/0x295
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
RIP: 0033:0x7fb696cdbe6b
Code: 73 01 c3 48 8b 0d 1d 20 0c 00 f7 d8 64 89 01 48 83 c8 ff c3 66 2e 0f 1f 84 00 00 008
RSP: 002b:00007ffec9588788 EFLAGS: 00000206 ORIG_RAX: 00000000000000b0
RAX: ffffffffffffffda RBX: 0000559e589137c0 RCX: 00007fb696cdbe6b
RDX: 000000000000000a RSI: 0000000000000800 RDI: 0000559e58913828
RBP: 0000000000000000 R08: 00007ffec9587701 R09: 0000000000000000
R10: 00007fb696d4eae0 R11: 0000000000000206 R12: 00007ffec95889b0
R13: 00007ffec95896b3 R14: 0000559e58913260 R15: 0000559e589137c0
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Hannes Reinecke <hare@suse.com>
Cc: Greg KH <gregkh@linuxfoundation.org>
Cc: Mike Snitzer <snitzer@redhat.com>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Signed-off-by: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
(jwang:cherry picked from commit cecf5d87ff2035127bb5a9ee054d0023a4a7cad3,
adjust ctx for 4,19)
Signed-off-by: Jack Wang <jinpu.wang@cloud.ionos.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2019-08-27 13:01:48 +02:00
|
|
|
ret = elv_register_queue(q, true);
|
2017-04-07 16:52:27 +02:00
|
|
|
if (ret) {
|
|
|
|
elevator_exit(q, q->elevator);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (new_e)
|
|
|
|
blk_add_trace_msg(q, "elv switch: %s", new_e->elevator_name);
|
|
|
|
else
|
|
|
|
blk_add_trace_msg(q, "elv switch: none");
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-05-31 19:11:40 +02:00
|
|
|
/*
|
|
|
|
* For blk-mq devices, we default to using mq-deadline, if available, for single
|
|
|
|
* queue devices. If deadline isn't available OR we have multiple queues,
|
|
|
|
* default to "none".
|
|
|
|
*/
|
|
|
|
int elevator_init_mq(struct request_queue *q)
|
|
|
|
{
|
|
|
|
struct elevator_type *e;
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
if (q->nr_hw_queues != 1)
|
|
|
|
return 0;
|
|
|
|
|
2019-08-27 13:01:45 +02:00
|
|
|
WARN_ON_ONCE(test_bit(QUEUE_FLAG_REGISTERED, &q->queue_flags));
|
|
|
|
|
2018-05-31 19:11:40 +02:00
|
|
|
if (unlikely(q->elevator))
|
2019-08-27 13:01:45 +02:00
|
|
|
goto out;
|
2018-05-31 19:11:40 +02:00
|
|
|
|
|
|
|
e = elevator_get(q, "mq-deadline", false);
|
|
|
|
if (!e)
|
2019-08-27 13:01:45 +02:00
|
|
|
goto out;
|
2018-05-31 19:11:40 +02:00
|
|
|
|
|
|
|
err = blk_mq_init_sched(q, e);
|
|
|
|
if (err)
|
|
|
|
elevator_put(e);
|
2019-08-27 13:01:45 +02:00
|
|
|
out:
|
2018-05-31 19:11:40 +02:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* switch to new_e io scheduler. be careful not to introduce deadlocks -
|
|
|
|
* we don't free the old io scheduler, before we have allocated what we
|
|
|
|
* need for the new one. this way we have a chance of going back to the old
|
2005-10-28 08:29:39 +02:00
|
|
|
* one, if the new one fails init for some reason.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2007-07-24 09:28:11 +02:00
|
|
|
static int elevator_switch(struct request_queue *q, struct elevator_type *new_e)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2012-03-05 22:14:56 +01:00
|
|
|
struct elevator_queue *old = q->elevator;
|
2017-01-17 14:03:22 +01:00
|
|
|
bool old_registered = false;
|
2012-03-05 22:15:20 +01:00
|
|
|
int err;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2018-01-17 20:48:09 +01:00
|
|
|
lockdep_assert_held(&q->sysfs_lock);
|
|
|
|
|
2018-08-21 09:15:03 +02:00
|
|
|
if (q->mq_ops) {
|
|
|
|
blk_mq_freeze_queue(q);
|
|
|
|
blk_mq_quiesce_queue(q);
|
|
|
|
|
|
|
|
err = elevator_switch_mq(q, new_e);
|
|
|
|
|
|
|
|
blk_mq_unquiesce_queue(q);
|
|
|
|
blk_mq_unfreeze_queue(q);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
2017-01-17 14:03:22 +01:00
|
|
|
|
2012-03-05 22:14:56 +01:00
|
|
|
/*
|
|
|
|
* Turn on BYPASS and drain all requests w/ elevator private data.
|
|
|
|
* Block layer doesn't call into a quiesced elevator - all requests
|
|
|
|
* are directly put on the dispatch list without elevator data
|
|
|
|
* using INSERT_BACK. All requests have SOFTBARRIER set and no
|
|
|
|
* merge happens either.
|
|
|
|
*/
|
2017-01-17 14:03:22 +01:00
|
|
|
if (old) {
|
|
|
|
old_registered = old->registered;
|
|
|
|
|
2017-04-07 16:52:27 +02:00
|
|
|
blk_queue_bypass_start(q);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2017-01-17 14:03:22 +01:00
|
|
|
/* unregister and clear all auxiliary data of the old elevator */
|
|
|
|
if (old_registered)
|
|
|
|
elv_unregister_queue(q);
|
|
|
|
|
|
|
|
ioc_clear_queue(q);
|
|
|
|
}
|
2011-12-14 00:33:40 +01:00
|
|
|
|
2012-03-05 22:14:56 +01:00
|
|
|
/* allocate, init and register new elevator */
|
2017-04-07 16:52:27 +02:00
|
|
|
err = new_e->ops.sq.elevator_init_fn(q, new_e);
|
2017-04-05 21:01:30 +02:00
|
|
|
if (err)
|
|
|
|
goto fail_init;
|
2012-03-05 22:14:56 +01:00
|
|
|
|
block: split .sysfs_lock into two locks
commit cecf5d87ff2035127bb5a9ee054d0023a4a7cad3 upstream.
The kernfs built-in lock of 'kn->count' is held in sysfs .show/.store
path. Meantime, inside block's .show/.store callback, q->sysfs_lock is
required.
However, when mq & iosched kobjects are removed via
blk_mq_unregister_dev() & elv_unregister_queue(), q->sysfs_lock is held
too. This way causes AB-BA lock because the kernfs built-in lock of
'kn-count' is required inside kobject_del() too, see the lockdep warning[1].
On the other hand, it isn't necessary to acquire q->sysfs_lock for
both blk_mq_unregister_dev() & elv_unregister_queue() because
clearing REGISTERED flag prevents storing to 'queue/scheduler'
from being happened. Also sysfs write(store) is exclusive, so no
necessary to hold the lock for elv_unregister_queue() when it is
called in switching elevator path.
So split .sysfs_lock into two: one is still named as .sysfs_lock for
covering sync .store, the other one is named as .sysfs_dir_lock
for covering kobjects and related status change.
sysfs itself can handle the race between add/remove kobjects and
showing/storing attributes under kobjects. For switching scheduler
via storing to 'queue/scheduler', we use the queue flag of
QUEUE_FLAG_REGISTERED with .sysfs_lock for avoiding the race, then
we can avoid to hold .sysfs_lock during removing/adding kobjects.
[1] lockdep warning
======================================================
WARNING: possible circular locking dependency detected
5.3.0-rc3-00044-g73277fc75ea0 #1380 Not tainted
------------------------------------------------------
rmmod/777 is trying to acquire lock:
00000000ac50e981 (kn->count#202){++++}, at: kernfs_remove_by_name_ns+0x59/0x72
but task is already holding lock:
00000000fb16ae21 (&q->sysfs_lock){+.+.}, at: blk_unregister_queue+0x78/0x10b
which lock already depends on the new lock.
the existing dependency chain (in reverse order) is:
-> #1 (&q->sysfs_lock){+.+.}:
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
__mutex_lock+0x14a/0xa9b
blk_mq_hw_sysfs_show+0x63/0xb6
sysfs_kf_seq_show+0x11f/0x196
seq_read+0x2cd/0x5f2
vfs_read+0xc7/0x18c
ksys_read+0xc4/0x13e
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
-> #0 (kn->count#202){++++}:
check_prev_add+0x5d2/0xc45
validate_chain+0xed3/0xf94
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
__kernfs_remove+0x237/0x40b
kernfs_remove_by_name_ns+0x59/0x72
remove_files+0x61/0x96
sysfs_remove_group+0x81/0xa4
sysfs_remove_groups+0x3b/0x44
kobject_del+0x44/0x94
blk_mq_unregister_dev+0x83/0xdd
blk_unregister_queue+0xa0/0x10b
del_gendisk+0x259/0x3fa
null_del_dev+0x8b/0x1c3 [null_blk]
null_exit+0x5c/0x95 [null_blk]
__se_sys_delete_module+0x204/0x337
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
other info that might help us debug this:
Possible unsafe locking scenario:
CPU0 CPU1
---- ----
lock(&q->sysfs_lock);
lock(kn->count#202);
lock(&q->sysfs_lock);
lock(kn->count#202);
*** DEADLOCK ***
2 locks held by rmmod/777:
#0: 00000000e69bd9de (&lock){+.+.}, at: null_exit+0x2e/0x95 [null_blk]
#1: 00000000fb16ae21 (&q->sysfs_lock){+.+.}, at: blk_unregister_queue+0x78/0x10b
stack backtrace:
CPU: 0 PID: 777 Comm: rmmod Not tainted 5.3.0-rc3-00044-g73277fc75ea0 #1380
Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS ?-20180724_192412-buildhw-07.phx4
Call Trace:
dump_stack+0x9a/0xe6
check_noncircular+0x207/0x251
? print_circular_bug+0x32a/0x32a
? find_usage_backwards+0x84/0xb0
check_prev_add+0x5d2/0xc45
validate_chain+0xed3/0xf94
? check_prev_add+0xc45/0xc45
? mark_lock+0x11b/0x804
? check_usage_forwards+0x1ca/0x1ca
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
? kernfs_remove_by_name_ns+0x59/0x72
__kernfs_remove+0x237/0x40b
? kernfs_remove_by_name_ns+0x59/0x72
? kernfs_next_descendant_post+0x7d/0x7d
? strlen+0x10/0x23
? strcmp+0x22/0x44
kernfs_remove_by_name_ns+0x59/0x72
remove_files+0x61/0x96
sysfs_remove_group+0x81/0xa4
sysfs_remove_groups+0x3b/0x44
kobject_del+0x44/0x94
blk_mq_unregister_dev+0x83/0xdd
blk_unregister_queue+0xa0/0x10b
del_gendisk+0x259/0x3fa
? disk_events_poll_msecs_store+0x12b/0x12b
? check_flags+0x1ea/0x204
? mark_held_locks+0x1f/0x7a
null_del_dev+0x8b/0x1c3 [null_blk]
null_exit+0x5c/0x95 [null_blk]
__se_sys_delete_module+0x204/0x337
? free_module+0x39f/0x39f
? blkcg_maybe_throttle_current+0x8a/0x718
? rwlock_bug+0x62/0x62
? __blkcg_punt_bio_submit+0xd0/0xd0
? trace_hardirqs_on_thunk+0x1a/0x20
? mark_held_locks+0x1f/0x7a
? do_syscall_64+0x4c/0x295
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
RIP: 0033:0x7fb696cdbe6b
Code: 73 01 c3 48 8b 0d 1d 20 0c 00 f7 d8 64 89 01 48 83 c8 ff c3 66 2e 0f 1f 84 00 00 008
RSP: 002b:00007ffec9588788 EFLAGS: 00000206 ORIG_RAX: 00000000000000b0
RAX: ffffffffffffffda RBX: 0000559e589137c0 RCX: 00007fb696cdbe6b
RDX: 000000000000000a RSI: 0000000000000800 RDI: 0000559e58913828
RBP: 0000000000000000 R08: 00007ffec9587701 R09: 0000000000000000
R10: 00007fb696d4eae0 R11: 0000000000000206 R12: 00007ffec95889b0
R13: 00007ffec95896b3 R14: 0000559e58913260 R15: 0000559e589137c0
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Hannes Reinecke <hare@suse.com>
Cc: Greg KH <gregkh@linuxfoundation.org>
Cc: Mike Snitzer <snitzer@redhat.com>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Signed-off-by: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
(jwang:cherry picked from commit cecf5d87ff2035127bb5a9ee054d0023a4a7cad3,
adjust ctx for 4,19)
Signed-off-by: Jack Wang <jinpu.wang@cloud.ionos.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2019-08-27 13:01:48 +02:00
|
|
|
err = elv_register_queue(q, true);
|
2017-04-07 16:52:27 +02:00
|
|
|
if (err)
|
|
|
|
goto fail_register;
|
2012-03-05 22:14:56 +01:00
|
|
|
|
|
|
|
/* done, kill the old one and finish */
|
2017-01-17 14:03:22 +01:00
|
|
|
if (old) {
|
2017-04-07 16:52:27 +02:00
|
|
|
elevator_exit(q, old);
|
|
|
|
blk_queue_bypass_end(q);
|
2017-01-17 14:03:22 +01:00
|
|
|
}
|
|
|
|
|
2017-04-07 16:52:27 +02:00
|
|
|
blk_add_trace_msg(q, "elv switch: %s", new_e->elevator_name);
|
2008-05-27 14:55:00 +02:00
|
|
|
|
2010-08-23 13:52:19 +02:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
fail_register:
|
2017-04-07 16:52:27 +02:00
|
|
|
elevator_exit(q, q->elevator);
|
2012-03-05 22:14:56 +01:00
|
|
|
fail_init:
|
|
|
|
/* switch failed, restore and re-register old elevator */
|
2017-01-17 14:03:22 +01:00
|
|
|
if (old) {
|
|
|
|
q->elevator = old;
|
block: split .sysfs_lock into two locks
commit cecf5d87ff2035127bb5a9ee054d0023a4a7cad3 upstream.
The kernfs built-in lock of 'kn->count' is held in sysfs .show/.store
path. Meantime, inside block's .show/.store callback, q->sysfs_lock is
required.
However, when mq & iosched kobjects are removed via
blk_mq_unregister_dev() & elv_unregister_queue(), q->sysfs_lock is held
too. This way causes AB-BA lock because the kernfs built-in lock of
'kn-count' is required inside kobject_del() too, see the lockdep warning[1].
On the other hand, it isn't necessary to acquire q->sysfs_lock for
both blk_mq_unregister_dev() & elv_unregister_queue() because
clearing REGISTERED flag prevents storing to 'queue/scheduler'
from being happened. Also sysfs write(store) is exclusive, so no
necessary to hold the lock for elv_unregister_queue() when it is
called in switching elevator path.
So split .sysfs_lock into two: one is still named as .sysfs_lock for
covering sync .store, the other one is named as .sysfs_dir_lock
for covering kobjects and related status change.
sysfs itself can handle the race between add/remove kobjects and
showing/storing attributes under kobjects. For switching scheduler
via storing to 'queue/scheduler', we use the queue flag of
QUEUE_FLAG_REGISTERED with .sysfs_lock for avoiding the race, then
we can avoid to hold .sysfs_lock during removing/adding kobjects.
[1] lockdep warning
======================================================
WARNING: possible circular locking dependency detected
5.3.0-rc3-00044-g73277fc75ea0 #1380 Not tainted
------------------------------------------------------
rmmod/777 is trying to acquire lock:
00000000ac50e981 (kn->count#202){++++}, at: kernfs_remove_by_name_ns+0x59/0x72
but task is already holding lock:
00000000fb16ae21 (&q->sysfs_lock){+.+.}, at: blk_unregister_queue+0x78/0x10b
which lock already depends on the new lock.
the existing dependency chain (in reverse order) is:
-> #1 (&q->sysfs_lock){+.+.}:
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
__mutex_lock+0x14a/0xa9b
blk_mq_hw_sysfs_show+0x63/0xb6
sysfs_kf_seq_show+0x11f/0x196
seq_read+0x2cd/0x5f2
vfs_read+0xc7/0x18c
ksys_read+0xc4/0x13e
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
-> #0 (kn->count#202){++++}:
check_prev_add+0x5d2/0xc45
validate_chain+0xed3/0xf94
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
__kernfs_remove+0x237/0x40b
kernfs_remove_by_name_ns+0x59/0x72
remove_files+0x61/0x96
sysfs_remove_group+0x81/0xa4
sysfs_remove_groups+0x3b/0x44
kobject_del+0x44/0x94
blk_mq_unregister_dev+0x83/0xdd
blk_unregister_queue+0xa0/0x10b
del_gendisk+0x259/0x3fa
null_del_dev+0x8b/0x1c3 [null_blk]
null_exit+0x5c/0x95 [null_blk]
__se_sys_delete_module+0x204/0x337
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
other info that might help us debug this:
Possible unsafe locking scenario:
CPU0 CPU1
---- ----
lock(&q->sysfs_lock);
lock(kn->count#202);
lock(&q->sysfs_lock);
lock(kn->count#202);
*** DEADLOCK ***
2 locks held by rmmod/777:
#0: 00000000e69bd9de (&lock){+.+.}, at: null_exit+0x2e/0x95 [null_blk]
#1: 00000000fb16ae21 (&q->sysfs_lock){+.+.}, at: blk_unregister_queue+0x78/0x10b
stack backtrace:
CPU: 0 PID: 777 Comm: rmmod Not tainted 5.3.0-rc3-00044-g73277fc75ea0 #1380
Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS ?-20180724_192412-buildhw-07.phx4
Call Trace:
dump_stack+0x9a/0xe6
check_noncircular+0x207/0x251
? print_circular_bug+0x32a/0x32a
? find_usage_backwards+0x84/0xb0
check_prev_add+0x5d2/0xc45
validate_chain+0xed3/0xf94
? check_prev_add+0xc45/0xc45
? mark_lock+0x11b/0x804
? check_usage_forwards+0x1ca/0x1ca
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
? kernfs_remove_by_name_ns+0x59/0x72
__kernfs_remove+0x237/0x40b
? kernfs_remove_by_name_ns+0x59/0x72
? kernfs_next_descendant_post+0x7d/0x7d
? strlen+0x10/0x23
? strcmp+0x22/0x44
kernfs_remove_by_name_ns+0x59/0x72
remove_files+0x61/0x96
sysfs_remove_group+0x81/0xa4
sysfs_remove_groups+0x3b/0x44
kobject_del+0x44/0x94
blk_mq_unregister_dev+0x83/0xdd
blk_unregister_queue+0xa0/0x10b
del_gendisk+0x259/0x3fa
? disk_events_poll_msecs_store+0x12b/0x12b
? check_flags+0x1ea/0x204
? mark_held_locks+0x1f/0x7a
null_del_dev+0x8b/0x1c3 [null_blk]
null_exit+0x5c/0x95 [null_blk]
__se_sys_delete_module+0x204/0x337
? free_module+0x39f/0x39f
? blkcg_maybe_throttle_current+0x8a/0x718
? rwlock_bug+0x62/0x62
? __blkcg_punt_bio_submit+0xd0/0xd0
? trace_hardirqs_on_thunk+0x1a/0x20
? mark_held_locks+0x1f/0x7a
? do_syscall_64+0x4c/0x295
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
RIP: 0033:0x7fb696cdbe6b
Code: 73 01 c3 48 8b 0d 1d 20 0c 00 f7 d8 64 89 01 48 83 c8 ff c3 66 2e 0f 1f 84 00 00 008
RSP: 002b:00007ffec9588788 EFLAGS: 00000206 ORIG_RAX: 00000000000000b0
RAX: ffffffffffffffda RBX: 0000559e589137c0 RCX: 00007fb696cdbe6b
RDX: 000000000000000a RSI: 0000000000000800 RDI: 0000559e58913828
RBP: 0000000000000000 R08: 00007ffec9587701 R09: 0000000000000000
R10: 00007fb696d4eae0 R11: 0000000000000206 R12: 00007ffec95889b0
R13: 00007ffec95896b3 R14: 0000559e58913260 R15: 0000559e589137c0
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Hannes Reinecke <hare@suse.com>
Cc: Greg KH <gregkh@linuxfoundation.org>
Cc: Mike Snitzer <snitzer@redhat.com>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Signed-off-by: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
(jwang:cherry picked from commit cecf5d87ff2035127bb5a9ee054d0023a4a7cad3,
adjust ctx for 4,19)
Signed-off-by: Jack Wang <jinpu.wang@cloud.ionos.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2019-08-27 13:01:48 +02:00
|
|
|
elv_register_queue(q, true);
|
2017-04-07 16:52:27 +02:00
|
|
|
blk_queue_bypass_end(q);
|
2017-01-17 14:03:22 +01:00
|
|
|
}
|
2008-04-29 14:48:33 +02:00
|
|
|
|
2010-08-23 13:52:19 +02:00
|
|
|
return err;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2010-08-23 13:52:19 +02:00
|
|
|
/*
|
|
|
|
* Switch this queue to the given IO scheduler.
|
|
|
|
*/
|
2013-10-16 00:42:19 +02:00
|
|
|
static int __elevator_change(struct request_queue *q, const char *name)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
char elevator_name[ELV_NAME_MAX];
|
|
|
|
struct elevator_type *e;
|
|
|
|
|
2017-08-28 18:52:44 +02:00
|
|
|
/* Make sure queue is not in the middle of being removed */
|
2019-08-27 13:01:47 +02:00
|
|
|
if (!blk_queue_registered(q))
|
2017-08-28 18:52:44 +02:00
|
|
|
return -ENOENT;
|
|
|
|
|
2017-01-17 14:03:22 +01:00
|
|
|
/*
|
|
|
|
* Special case for mq, turn off scheduling
|
|
|
|
*/
|
|
|
|
if (q->mq_ops && !strncmp(name, "none", 4))
|
|
|
|
return elevator_switch(q, NULL);
|
2009-05-22 23:17:52 +02:00
|
|
|
|
2008-10-14 08:49:56 +02:00
|
|
|
strlcpy(elevator_name, name, sizeof(elevator_name));
|
2017-10-25 20:33:42 +02:00
|
|
|
e = elevator_get(q, strstrip(elevator_name), true);
|
2017-05-10 15:40:04 +02:00
|
|
|
if (!e)
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EINVAL;
|
|
|
|
|
2017-10-25 20:35:02 +02:00
|
|
|
if (q->elevator && elevator_match(q->elevator->type, elevator_name)) {
|
2005-10-31 00:02:24 +01:00
|
|
|
elevator_put(e);
|
2010-08-23 13:52:19 +02:00
|
|
|
return 0;
|
2005-10-31 00:02:24 +01:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-08-23 13:52:19 +02:00
|
|
|
return elevator_switch(q, e);
|
|
|
|
}
|
2013-10-16 00:42:19 +02:00
|
|
|
|
2017-04-15 14:38:22 +02:00
|
|
|
static inline bool elv_support_iosched(struct request_queue *q)
|
|
|
|
{
|
|
|
|
if (q->mq_ops && q->tag_set && (q->tag_set->flags &
|
|
|
|
BLK_MQ_F_NO_SCHED))
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-08-23 13:52:19 +02:00
|
|
|
ssize_t elv_iosched_store(struct request_queue *q, const char *name,
|
|
|
|
size_t count)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2017-04-15 14:38:22 +02:00
|
|
|
if (!(q->mq_ops || q->request_fn) || !elv_support_iosched(q))
|
2010-08-23 13:52:19 +02:00
|
|
|
return count;
|
|
|
|
|
2013-10-16 00:42:19 +02:00
|
|
|
ret = __elevator_change(q, name);
|
2010-08-23 13:52:19 +02:00
|
|
|
if (!ret)
|
|
|
|
return count;
|
|
|
|
|
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-07-24 09:28:11 +02:00
|
|
|
ssize_t elv_iosched_show(struct request_queue *q, char *name)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-10-31 10:05:07 +01:00
|
|
|
struct elevator_queue *e = q->elevator;
|
2017-01-17 14:03:22 +01:00
|
|
|
struct elevator_type *elv = NULL;
|
2007-07-10 12:26:24 +02:00
|
|
|
struct elevator_type *__e;
|
2017-10-25 20:35:02 +02:00
|
|
|
bool uses_mq = q->mq_ops != NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
int len = 0;
|
|
|
|
|
2017-10-05 21:22:52 +02:00
|
|
|
if (!queue_is_rq_based(q))
|
2009-05-22 23:17:52 +02:00
|
|
|
return sprintf(name, "none\n");
|
|
|
|
|
2017-01-17 14:03:22 +01:00
|
|
|
if (!q->elevator)
|
|
|
|
len += sprintf(name+len, "[none] ");
|
|
|
|
else
|
|
|
|
elv = e->type;
|
2009-05-22 23:17:52 +02:00
|
|
|
|
2007-04-26 14:41:53 +02:00
|
|
|
spin_lock(&elv_list_lock);
|
2007-07-10 12:26:24 +02:00
|
|
|
list_for_each_entry(__e, &elv_list, list) {
|
2017-10-25 20:35:02 +02:00
|
|
|
if (elv && elevator_match(elv, __e->elevator_name) &&
|
|
|
|
(__e->uses_mq == uses_mq)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
len += sprintf(name+len, "[%s] ", elv->elevator_name);
|
2017-01-17 14:03:22 +01:00
|
|
|
continue;
|
|
|
|
}
|
2017-04-15 14:38:22 +02:00
|
|
|
if (__e->uses_mq && q->mq_ops && elv_support_iosched(q))
|
2017-01-17 14:03:22 +01:00
|
|
|
len += sprintf(name+len, "%s ", __e->elevator_name);
|
|
|
|
else if (!__e->uses_mq && !q->mq_ops)
|
2005-04-17 00:20:36 +02:00
|
|
|
len += sprintf(name+len, "%s ", __e->elevator_name);
|
|
|
|
}
|
2007-04-26 14:41:53 +02:00
|
|
|
spin_unlock(&elv_list_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2017-01-17 14:03:22 +01:00
|
|
|
if (q->mq_ops && q->elevator)
|
|
|
|
len += sprintf(name+len, "none");
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
len += sprintf(len+name, "\n");
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2007-07-24 09:28:11 +02:00
|
|
|
struct request *elv_rb_former_request(struct request_queue *q,
|
|
|
|
struct request *rq)
|
2006-07-13 11:55:04 +02:00
|
|
|
{
|
|
|
|
struct rb_node *rbprev = rb_prev(&rq->rb_node);
|
|
|
|
|
|
|
|
if (rbprev)
|
|
|
|
return rb_entry_rq(rbprev);
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(elv_rb_former_request);
|
|
|
|
|
2007-07-24 09:28:11 +02:00
|
|
|
struct request *elv_rb_latter_request(struct request_queue *q,
|
|
|
|
struct request *rq)
|
2006-07-13 11:55:04 +02:00
|
|
|
{
|
|
|
|
struct rb_node *rbnext = rb_next(&rq->rb_node);
|
|
|
|
|
|
|
|
if (rbnext)
|
|
|
|
return rb_entry_rq(rbnext);
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(elv_rb_latter_request);
|