Skip to content

Commit 9755ffd

Browse files
torvaldstorvalds
committedJan 31, 2025
Merge tag 'block-6.14-20250131' of git://git.kernel.dk/linux
Pull more block updates from Jens Axboe: - MD pull request via Song: - Fix a md-cluster regression introduced - More sysfs race fixes - Mark anything inside queue freezing as not being able to do IO for memory allocations - Fix for a regression introduced in loop in this merge window - Fix for a regression in queue mapping setups introduced in this merge window - Fix for the block dio fops attempting an iov_iter revert upton getting -EIOCBQUEUED on the read side. This one is going to stable as well * tag 'block-6.14-20250131' of git://git.kernel.dk/linux: block: force noio scope in blk_mq_freeze_queue block: fix nr_hw_queue update racing with disk addition/removal block: get rid of request queue ->sysfs_dir_lock loop: don't clear LO_FLAGS_PARTSCAN on LOOP_SET_STATUS{,64} md/md-bitmap: Synchronize bitmap_get_stats() with bitmap lifetime blk-mq: create correct map for fallback case block: don't revert iter for -EIOCBQUEUED
·
sent/20250320-vec-methods-adfa41e55311-v2sent/20240723-vma-f80119f9fb35-v13
2 parents c82da38 + 1e1a9ce commit 9755ffd

34 files changed

+164
-130
lines changed
 

‎block/blk-cgroup.c

+6-4
Original file line numberDiff line numberDiff line change
@@ -1546,6 +1546,7 @@ int blkcg_activate_policy(struct gendisk *disk, const struct blkcg_policy *pol)
15461546
struct request_queue *q = disk->queue;
15471547
struct blkg_policy_data *pd_prealloc = NULL;
15481548
struct blkcg_gq *blkg, *pinned_blkg = NULL;
1549+
unsigned int memflags;
15491550
int ret;
15501551

15511552
if (blkcg_policy_enabled(q, pol))
@@ -1560,7 +1561,7 @@ int blkcg_activate_policy(struct gendisk *disk, const struct blkcg_policy *pol)
15601561
return -EINVAL;
15611562

15621563
if (queue_is_mq(q))
1563-
blk_mq_freeze_queue(q);
1564+
memflags = blk_mq_freeze_queue(q);
15641565
retry:
15651566
spin_lock_irq(&q->queue_lock);
15661567

@@ -1624,7 +1625,7 @@ int blkcg_activate_policy(struct gendisk *disk, const struct blkcg_policy *pol)
16241625
spin_unlock_irq(&q->queue_lock);
16251626
out:
16261627
if (queue_is_mq(q))
1627-
blk_mq_unfreeze_queue(q);
1628+
blk_mq_unfreeze_queue(q, memflags);
16281629
if (pinned_blkg)
16291630
blkg_put(pinned_blkg);
16301631
if (pd_prealloc)
@@ -1668,12 +1669,13 @@ void blkcg_deactivate_policy(struct gendisk *disk,
16681669
{
16691670
struct request_queue *q = disk->queue;
16701671
struct blkcg_gq *blkg;
1672+
unsigned int memflags;
16711673

16721674
if (!blkcg_policy_enabled(q, pol))
16731675
return;
16741676

16751677
if (queue_is_mq(q))
1676-
blk_mq_freeze_queue(q);
1678+
memflags = blk_mq_freeze_queue(q);
16771679

16781680
mutex_lock(&q->blkcg_mutex);
16791681
spin_lock_irq(&q->queue_lock);
@@ -1697,7 +1699,7 @@ void blkcg_deactivate_policy(struct gendisk *disk,
16971699
mutex_unlock(&q->blkcg_mutex);
16981700

16991701
if (queue_is_mq(q))
1700-
blk_mq_unfreeze_queue(q);
1702+
blk_mq_unfreeze_queue(q, memflags);
17011703
}
17021704
EXPORT_SYMBOL_GPL(blkcg_deactivate_policy);
17031705

‎block/blk-core.c

-1
Original file line numberDiff line numberDiff line change
@@ -430,7 +430,6 @@ struct request_queue *blk_alloc_queue(struct queue_limits *lim, int node_id)
430430
refcount_set(&q->refs, 1);
431431
mutex_init(&q->debugfs_mutex);
432432
mutex_init(&q->sysfs_lock);
433-
mutex_init(&q->sysfs_dir_lock);
434433
mutex_init(&q->limits_lock);
435434
mutex_init(&q->rq_qos_mutex);
436435
spin_lock_init(&q->queue_lock);

‎block/blk-ia-ranges.c

-4
Original file line numberDiff line numberDiff line change
@@ -111,7 +111,6 @@ int disk_register_independent_access_ranges(struct gendisk *disk)
111111
struct request_queue *q = disk->queue;
112112
int i, ret;
113113

114-
lockdep_assert_held(&q->sysfs_dir_lock);
115114
lockdep_assert_held(&q->sysfs_lock);
116115

117116
if (!iars)
@@ -155,7 +154,6 @@ void disk_unregister_independent_access_ranges(struct gendisk *disk)
155154
struct blk_independent_access_ranges *iars = disk->ia_ranges;
156155
int i;
157156

158-
lockdep_assert_held(&q->sysfs_dir_lock);
159157
lockdep_assert_held(&q->sysfs_lock);
160158

161159
if (!iars)
@@ -289,7 +287,6 @@ void disk_set_independent_access_ranges(struct gendisk *disk,
289287
{
290288
struct request_queue *q = disk->queue;
291289

292-
mutex_lock(&q->sysfs_dir_lock);
293290
mutex_lock(&q->sysfs_lock);
294291
if (iars && !disk_check_ia_ranges(disk, iars)) {
295292
kfree(iars);
@@ -313,6 +310,5 @@ void disk_set_independent_access_ranges(struct gendisk *disk,
313310
disk_register_independent_access_ranges(disk);
314311
unlock:
315312
mutex_unlock(&q->sysfs_lock);
316-
mutex_unlock(&q->sysfs_dir_lock);
317313
}
318314
EXPORT_SYMBOL_GPL(disk_set_independent_access_ranges);

‎block/blk-iocost.c

+8-6
Original file line numberDiff line numberDiff line change
@@ -3224,6 +3224,7 @@ static ssize_t ioc_qos_write(struct kernfs_open_file *of, char *input,
32243224
u32 qos[NR_QOS_PARAMS];
32253225
bool enable, user;
32263226
char *body, *p;
3227+
unsigned int memflags;
32273228
int ret;
32283229

32293230
blkg_conf_init(&ctx, input);
@@ -3247,7 +3248,7 @@ static ssize_t ioc_qos_write(struct kernfs_open_file *of, char *input,
32473248
ioc = q_to_ioc(disk->queue);
32483249
}
32493250

3250-
blk_mq_freeze_queue(disk->queue);
3251+
memflags = blk_mq_freeze_queue(disk->queue);
32513252
blk_mq_quiesce_queue(disk->queue);
32523253

32533254
spin_lock_irq(&ioc->lock);
@@ -3347,15 +3348,15 @@ static ssize_t ioc_qos_write(struct kernfs_open_file *of, char *input,
33473348
wbt_enable_default(disk);
33483349

33493350
blk_mq_unquiesce_queue(disk->queue);
3350-
blk_mq_unfreeze_queue(disk->queue);
3351+
blk_mq_unfreeze_queue(disk->queue, memflags);
33513352

33523353
blkg_conf_exit(&ctx);
33533354
return nbytes;
33543355
einval:
33553356
spin_unlock_irq(&ioc->lock);
33563357

33573358
blk_mq_unquiesce_queue(disk->queue);
3358-
blk_mq_unfreeze_queue(disk->queue);
3359+
blk_mq_unfreeze_queue(disk->queue, memflags);
33593360

33603361
ret = -EINVAL;
33613362
err:
@@ -3414,6 +3415,7 @@ static ssize_t ioc_cost_model_write(struct kernfs_open_file *of, char *input,
34143415
{
34153416
struct blkg_conf_ctx ctx;
34163417
struct request_queue *q;
3418+
unsigned int memflags;
34173419
struct ioc *ioc;
34183420
u64 u[NR_I_LCOEFS];
34193421
bool user;
@@ -3441,7 +3443,7 @@ static ssize_t ioc_cost_model_write(struct kernfs_open_file *of, char *input,
34413443
ioc = q_to_ioc(q);
34423444
}
34433445

3444-
blk_mq_freeze_queue(q);
3446+
memflags = blk_mq_freeze_queue(q);
34453447
blk_mq_quiesce_queue(q);
34463448

34473449
spin_lock_irq(&ioc->lock);
@@ -3493,7 +3495,7 @@ static ssize_t ioc_cost_model_write(struct kernfs_open_file *of, char *input,
34933495
spin_unlock_irq(&ioc->lock);
34943496

34953497
blk_mq_unquiesce_queue(q);
3496-
blk_mq_unfreeze_queue(q);
3498+
blk_mq_unfreeze_queue(q, memflags);
34973499

34983500
blkg_conf_exit(&ctx);
34993501
return nbytes;
@@ -3502,7 +3504,7 @@ static ssize_t ioc_cost_model_write(struct kernfs_open_file *of, char *input,
35023504
spin_unlock_irq(&ioc->lock);
35033505

35043506
blk_mq_unquiesce_queue(q);
3505-
blk_mq_unfreeze_queue(q);
3507+
blk_mq_unfreeze_queue(q, memflags);
35063508

35073509
ret = -EINVAL;
35083510
err:

‎block/blk-iolatency.c

+4-2
Original file line numberDiff line numberDiff line change
@@ -749,9 +749,11 @@ static void blkiolatency_enable_work_fn(struct work_struct *work)
749749
*/
750750
enabled = atomic_read(&blkiolat->enable_cnt);
751751
if (enabled != blkiolat->enabled) {
752-
blk_mq_freeze_queue(blkiolat->rqos.disk->queue);
752+
unsigned int memflags;
753+
754+
memflags = blk_mq_freeze_queue(blkiolat->rqos.disk->queue);
753755
blkiolat->enabled = enabled;
754-
blk_mq_unfreeze_queue(blkiolat->rqos.disk->queue);
756+
blk_mq_unfreeze_queue(blkiolat->rqos.disk->queue, memflags);
755757
}
756758
}
757759

‎block/blk-mq-cpumap.c

+1-2
Original file line numberDiff line numberDiff line change
@@ -87,7 +87,6 @@ void blk_mq_map_hw_queues(struct blk_mq_queue_map *qmap,
8787
return;
8888

8989
fallback:
90-
WARN_ON_ONCE(qmap->nr_queues > 1);
91-
blk_mq_clear_mq_map(qmap);
90+
blk_mq_map_queues(qmap);
9291
}
9392
EXPORT_SYMBOL_GPL(blk_mq_map_hw_queues);

‎block/blk-mq-sysfs.c

+14-26
Original file line numberDiff line numberDiff line change
@@ -223,30 +223,27 @@ int blk_mq_sysfs_register(struct gendisk *disk)
223223
unsigned long i, j;
224224
int ret;
225225

226-
lockdep_assert_held(&q->sysfs_dir_lock);
227-
228226
ret = kobject_add(q->mq_kobj, &disk_to_dev(disk)->kobj, "mq");
229227
if (ret < 0)
230-
goto out;
228+
return ret;
231229

232230
kobject_uevent(q->mq_kobj, KOBJ_ADD);
233231

232+
mutex_lock(&q->tag_set->tag_list_lock);
234233
queue_for_each_hw_ctx(q, hctx, i) {
235234
ret = blk_mq_register_hctx(hctx);
236235
if (ret)
237-
goto unreg;
236+
goto out_unreg;
238237
}
238+
mutex_unlock(&q->tag_set->tag_list_lock);
239+
return 0;
239240

240-
q->mq_sysfs_init_done = true;
241-
242-
out:
243-
return ret;
244-
245-
unreg:
241+
out_unreg:
246242
queue_for_each_hw_ctx(q, hctx, j) {
247243
if (j < i)
248244
blk_mq_unregister_hctx(hctx);
249245
}
246+
mutex_unlock(&q->tag_set->tag_list_lock);
250247

251248
kobject_uevent(q->mq_kobj, KOBJ_REMOVE);
252249
kobject_del(q->mq_kobj);
@@ -259,31 +256,25 @@ void blk_mq_sysfs_unregister(struct gendisk *disk)
259256
struct blk_mq_hw_ctx *hctx;
260257
unsigned long i;
261258

262-
lockdep_assert_held(&q->sysfs_dir_lock);
263-
259+
mutex_lock(&q->tag_set->tag_list_lock);
264260
queue_for_each_hw_ctx(q, hctx, i)
265261
blk_mq_unregister_hctx(hctx);
262+
mutex_unlock(&q->tag_set->tag_list_lock);
266263

267264
kobject_uevent(q->mq_kobj, KOBJ_REMOVE);
268265
kobject_del(q->mq_kobj);
269-
270-
q->mq_sysfs_init_done = false;
271266
}
272267

273268
void blk_mq_sysfs_unregister_hctxs(struct request_queue *q)
274269
{
275270
struct blk_mq_hw_ctx *hctx;
276271
unsigned long i;
277272

278-
mutex_lock(&q->sysfs_dir_lock);
279-
if (!q->mq_sysfs_init_done)
280-
goto unlock;
273+
if (!blk_queue_registered(q))
274+
return;
281275

282276
queue_for_each_hw_ctx(q, hctx, i)
283277
blk_mq_unregister_hctx(hctx);
284-
285-
unlock:
286-
mutex_unlock(&q->sysfs_dir_lock);
287278
}
288279

289280
int blk_mq_sysfs_register_hctxs(struct request_queue *q)
@@ -292,18 +283,15 @@ int blk_mq_sysfs_register_hctxs(struct request_queue *q)
292283
unsigned long i;
293284
int ret = 0;
294285

295-
mutex_lock(&q->sysfs_dir_lock);
296-
if (!q->mq_sysfs_init_done)
297-
goto unlock;
286+
if (!blk_queue_registered(q))
287+
goto out;
298288

299289
queue_for_each_hw_ctx(q, hctx, i) {
300290
ret = blk_mq_register_hctx(hctx);
301291
if (ret)
302292
break;
303293
}
304294

305-
unlock:
306-
mutex_unlock(&q->sysfs_dir_lock);
307-
295+
out:
308296
return ret;
309297
}

‎block/blk-mq.c

+13-8
Original file line numberDiff line numberDiff line change
@@ -210,12 +210,12 @@ int blk_mq_freeze_queue_wait_timeout(struct request_queue *q,
210210
}
211211
EXPORT_SYMBOL_GPL(blk_mq_freeze_queue_wait_timeout);
212212

213-
void blk_mq_freeze_queue(struct request_queue *q)
213+
void blk_mq_freeze_queue_nomemsave(struct request_queue *q)
214214
{
215215
blk_freeze_queue_start(q);
216216
blk_mq_freeze_queue_wait(q);
217217
}
218-
EXPORT_SYMBOL_GPL(blk_mq_freeze_queue);
218+
EXPORT_SYMBOL_GPL(blk_mq_freeze_queue_nomemsave);
219219

220220
bool __blk_mq_unfreeze_queue(struct request_queue *q, bool force_atomic)
221221
{
@@ -236,12 +236,12 @@ bool __blk_mq_unfreeze_queue(struct request_queue *q, bool force_atomic)
236236
return unfreeze;
237237
}
238238

239-
void blk_mq_unfreeze_queue(struct request_queue *q)
239+
void blk_mq_unfreeze_queue_nomemrestore(struct request_queue *q)
240240
{
241241
if (__blk_mq_unfreeze_queue(q, false))
242242
blk_unfreeze_release_lock(q);
243243
}
244-
EXPORT_SYMBOL_GPL(blk_mq_unfreeze_queue);
244+
EXPORT_SYMBOL_GPL(blk_mq_unfreeze_queue_nomemrestore);
245245

246246
/*
247247
* non_owner variant of blk_freeze_queue_start
@@ -4223,13 +4223,14 @@ static void blk_mq_update_tag_set_shared(struct blk_mq_tag_set *set,
42234223
bool shared)
42244224
{
42254225
struct request_queue *q;
4226+
unsigned int memflags;
42264227

42274228
lockdep_assert_held(&set->tag_list_lock);
42284229

42294230
list_for_each_entry(q, &set->tag_list, tag_set_list) {
4230-
blk_mq_freeze_queue(q);
4231+
memflags = blk_mq_freeze_queue(q);
42314232
queue_set_hctx_shared(q, shared);
4232-
blk_mq_unfreeze_queue(q);
4233+
blk_mq_unfreeze_queue(q, memflags);
42334234
}
42344235
}
42354236

@@ -4992,6 +4993,7 @@ static void __blk_mq_update_nr_hw_queues(struct blk_mq_tag_set *set,
49924993
struct request_queue *q;
49934994
LIST_HEAD(head);
49944995
int prev_nr_hw_queues = set->nr_hw_queues;
4996+
unsigned int memflags;
49954997
int i;
49964998

49974999
lockdep_assert_held(&set->tag_list_lock);
@@ -5003,8 +5005,10 @@ static void __blk_mq_update_nr_hw_queues(struct blk_mq_tag_set *set,
50035005
if (set->nr_maps == 1 && nr_hw_queues == set->nr_hw_queues)
50045006
return;
50055007

5008+
memflags = memalloc_noio_save();
50065009
list_for_each_entry(q, &set->tag_list, tag_set_list)
5007-
blk_mq_freeze_queue(q);
5010+
blk_mq_freeze_queue_nomemsave(q);
5011+
50085012
/*
50095013
* Switch IO scheduler to 'none', cleaning up the data associated
50105014
* with the previous scheduler. We will switch back once we are done
@@ -5052,7 +5056,8 @@ static void __blk_mq_update_nr_hw_queues(struct blk_mq_tag_set *set,
50525056
blk_mq_elv_switch_back(&head, q);
50535057

50545058
list_for_each_entry(q, &set->tag_list, tag_set_list)
5055-
blk_mq_unfreeze_queue(q);
5059+
blk_mq_unfreeze_queue_nomemrestore(q);
5060+
memalloc_noio_restore(memflags);
50565061

50575062
/* Free the excess tags when nr_hw_queues shrink. */
50585063
for (i = set->nr_hw_queues; i < prev_nr_hw_queues; i++)

‎block/blk-pm.c

+1-1
Original file line numberDiff line numberDiff line change
@@ -89,7 +89,7 @@ int blk_pre_runtime_suspend(struct request_queue *q)
8989
if (percpu_ref_is_zero(&q->q_usage_counter))
9090
ret = 0;
9191
/* Switch q_usage_counter back to per-cpu mode. */
92-
blk_mq_unfreeze_queue(q);
92+
blk_mq_unfreeze_queue_nomemrestore(q);
9393

9494
if (ret < 0) {
9595
spin_lock_irq(&q->queue_lock);

‎block/blk-rq-qos.c

+7-5
Original file line numberDiff line numberDiff line change
@@ -299,6 +299,7 @@ int rq_qos_add(struct rq_qos *rqos, struct gendisk *disk, enum rq_qos_id id,
299299
const struct rq_qos_ops *ops)
300300
{
301301
struct request_queue *q = disk->queue;
302+
unsigned int memflags;
302303

303304
lockdep_assert_held(&q->rq_qos_mutex);
304305

@@ -310,14 +311,14 @@ int rq_qos_add(struct rq_qos *rqos, struct gendisk *disk, enum rq_qos_id id,
310311
* No IO can be in-flight when adding rqos, so freeze queue, which
311312
* is fine since we only support rq_qos for blk-mq queue.
312313
*/
313-
blk_mq_freeze_queue(q);
314+
memflags = blk_mq_freeze_queue(q);
314315

315316
if (rq_qos_id(q, rqos->id))
316317
goto ebusy;
317318
rqos->next = q->rq_qos;
318319
q->rq_qos = rqos;
319320

320-
blk_mq_unfreeze_queue(q);
321+
blk_mq_unfreeze_queue(q, memflags);
321322

322323
if (rqos->ops->debugfs_attrs) {
323324
mutex_lock(&q->debugfs_mutex);
@@ -327,25 +328,26 @@ int rq_qos_add(struct rq_qos *rqos, struct gendisk *disk, enum rq_qos_id id,
327328

328329
return 0;
329330
ebusy:
330-
blk_mq_unfreeze_queue(q);
331+
blk_mq_unfreeze_queue(q, memflags);
331332
return -EBUSY;
332333
}
333334

334335
void rq_qos_del(struct rq_qos *rqos)
335336
{
336337
struct request_queue *q = rqos->disk->queue;
337338
struct rq_qos **cur;
339+
unsigned int memflags;
338340

339341
lockdep_assert_held(&q->rq_qos_mutex);
340342

341-
blk_mq_freeze_queue(q);
343+
memflags = blk_mq_freeze_queue(q);
342344
for (cur = &q->rq_qos; *cur; cur = &(*cur)->next) {
343345
if (*cur == rqos) {
344346
*cur = rqos->next;
345347
break;
346348
}
347349
}
348-
blk_mq_unfreeze_queue(q);
350+
blk_mq_unfreeze_queue(q, memflags);
349351

350352
mutex_lock(&q->debugfs_mutex);
351353
blk_mq_debugfs_unregister_rqos(rqos);

‎block/blk-settings.c

+3-2
Original file line numberDiff line numberDiff line change
@@ -461,11 +461,12 @@ EXPORT_SYMBOL_GPL(queue_limits_commit_update);
461461
int queue_limits_commit_update_frozen(struct request_queue *q,
462462
struct queue_limits *lim)
463463
{
464+
unsigned int memflags;
464465
int ret;
465466

466-
blk_mq_freeze_queue(q);
467+
memflags = blk_mq_freeze_queue(q);
467468
ret = queue_limits_commit_update(q, lim);
468-
blk_mq_unfreeze_queue(q);
469+
blk_mq_unfreeze_queue(q, memflags);
469470

470471
return ret;
471472
}

‎block/blk-sysfs.c

+3-10
Original file line numberDiff line numberDiff line change
@@ -681,7 +681,7 @@ queue_attr_store(struct kobject *kobj, struct attribute *attr,
681681
struct queue_sysfs_entry *entry = to_queue(attr);
682682
struct gendisk *disk = container_of(kobj, struct gendisk, queue_kobj);
683683
struct request_queue *q = disk->queue;
684-
unsigned int noio_flag;
684+
unsigned int memflags;
685685
ssize_t res;
686686

687687
if (!entry->store_limit && !entry->store)
@@ -711,11 +711,9 @@ queue_attr_store(struct kobject *kobj, struct attribute *attr,
711711
}
712712

713713
mutex_lock(&q->sysfs_lock);
714-
blk_mq_freeze_queue(q);
715-
noio_flag = memalloc_noio_save();
714+
memflags = blk_mq_freeze_queue(q);
716715
res = entry->store(disk, page, length);
717-
memalloc_noio_restore(noio_flag);
718-
blk_mq_unfreeze_queue(q);
716+
blk_mq_unfreeze_queue(q, memflags);
719717
mutex_unlock(&q->sysfs_lock);
720718
return res;
721719
}
@@ -764,7 +762,6 @@ int blk_register_queue(struct gendisk *disk)
764762
struct request_queue *q = disk->queue;
765763
int ret;
766764

767-
mutex_lock(&q->sysfs_dir_lock);
768765
kobject_init(&disk->queue_kobj, &blk_queue_ktype);
769766
ret = kobject_add(&disk->queue_kobj, &disk_to_dev(disk)->kobj, "queue");
770767
if (ret < 0)
@@ -805,7 +802,6 @@ int blk_register_queue(struct gendisk *disk)
805802
if (q->elevator)
806803
kobject_uevent(&q->elevator->kobj, KOBJ_ADD);
807804
mutex_unlock(&q->sysfs_lock);
808-
mutex_unlock(&q->sysfs_dir_lock);
809805

810806
/*
811807
* SCSI probing may synchronously create and destroy a lot of
@@ -830,7 +826,6 @@ int blk_register_queue(struct gendisk *disk)
830826
mutex_unlock(&q->sysfs_lock);
831827
out_put_queue_kobj:
832828
kobject_put(&disk->queue_kobj);
833-
mutex_unlock(&q->sysfs_dir_lock);
834829
return ret;
835830
}
836831

@@ -861,7 +856,6 @@ void blk_unregister_queue(struct gendisk *disk)
861856
blk_queue_flag_clear(QUEUE_FLAG_REGISTERED, q);
862857
mutex_unlock(&q->sysfs_lock);
863858

864-
mutex_lock(&q->sysfs_dir_lock);
865859
/*
866860
* Remove the sysfs attributes before unregistering the queue data
867861
* structures that can be modified through sysfs.
@@ -878,7 +872,6 @@ void blk_unregister_queue(struct gendisk *disk)
878872
/* Now that we've deleted all child objects, we can delete the queue. */
879873
kobject_uevent(&disk->queue_kobj, KOBJ_REMOVE);
880874
kobject_del(&disk->queue_kobj);
881-
mutex_unlock(&q->sysfs_dir_lock);
882875

883876
blk_debugfs_remove(disk);
884877
}

‎block/blk-throttle.c

+3-2
Original file line numberDiff line numberDiff line change
@@ -1202,6 +1202,7 @@ static int blk_throtl_init(struct gendisk *disk)
12021202
{
12031203
struct request_queue *q = disk->queue;
12041204
struct throtl_data *td;
1205+
unsigned int memflags;
12051206
int ret;
12061207

12071208
td = kzalloc_node(sizeof(*td), GFP_KERNEL, q->node);
@@ -1215,7 +1216,7 @@ static int blk_throtl_init(struct gendisk *disk)
12151216
* Freeze queue before activating policy, to synchronize with IO path,
12161217
* which is protected by 'q_usage_counter'.
12171218
*/
1218-
blk_mq_freeze_queue(disk->queue);
1219+
memflags = blk_mq_freeze_queue(disk->queue);
12191220
blk_mq_quiesce_queue(disk->queue);
12201221

12211222
q->td = td;
@@ -1239,7 +1240,7 @@ static int blk_throtl_init(struct gendisk *disk)
12391240

12401241
out:
12411242
blk_mq_unquiesce_queue(disk->queue);
1242-
blk_mq_unfreeze_queue(disk->queue);
1243+
blk_mq_unfreeze_queue(disk->queue, memflags);
12431244

12441245
return ret;
12451246
}

‎block/blk-zoned.c

+3-2
Original file line numberDiff line numberDiff line change
@@ -1717,9 +1717,10 @@ int blk_revalidate_disk_zones(struct gendisk *disk)
17171717
else
17181718
pr_warn("%s: failed to revalidate zones\n", disk->disk_name);
17191719
if (ret) {
1720-
blk_mq_freeze_queue(q);
1720+
unsigned int memflags = blk_mq_freeze_queue(q);
1721+
17211722
disk_free_zone_resources(disk);
1722-
blk_mq_unfreeze_queue(q);
1723+
blk_mq_unfreeze_queue(q, memflags);
17231724
}
17241725

17251726
return ret;

‎block/elevator.c

+10-6
Original file line numberDiff line numberDiff line change
@@ -570,6 +570,7 @@ static struct elevator_type *elevator_get_default(struct request_queue *q)
570570
void elevator_init_mq(struct request_queue *q)
571571
{
572572
struct elevator_type *e;
573+
unsigned int memflags;
573574
int err;
574575

575576
WARN_ON_ONCE(blk_queue_registered(q));
@@ -590,13 +591,13 @@ void elevator_init_mq(struct request_queue *q)
590591
*
591592
* Disk isn't added yet, so verifying queue lock only manually.
592593
*/
593-
blk_mq_freeze_queue(q);
594+
memflags = blk_mq_freeze_queue(q);
594595

595596
blk_mq_cancel_work_sync(q);
596597

597598
err = blk_mq_init_sched(q, e);
598599

599-
blk_mq_unfreeze_queue(q);
600+
blk_mq_unfreeze_queue(q, memflags);
600601

601602
if (err) {
602603
pr_warn("\"%s\" elevator initialization failed, "
@@ -614,11 +615,12 @@ void elevator_init_mq(struct request_queue *q)
614615
*/
615616
int elevator_switch(struct request_queue *q, struct elevator_type *new_e)
616617
{
618+
unsigned int memflags;
617619
int ret;
618620

619621
lockdep_assert_held(&q->sysfs_lock);
620622

621-
blk_mq_freeze_queue(q);
623+
memflags = blk_mq_freeze_queue(q);
622624
blk_mq_quiesce_queue(q);
623625

624626
if (q->elevator) {
@@ -639,7 +641,7 @@ int elevator_switch(struct request_queue *q, struct elevator_type *new_e)
639641

640642
out_unfreeze:
641643
blk_mq_unquiesce_queue(q);
642-
blk_mq_unfreeze_queue(q);
644+
blk_mq_unfreeze_queue(q, memflags);
643645

644646
if (ret) {
645647
pr_warn("elv: switch to \"%s\" failed, falling back to \"none\"\n",
@@ -651,9 +653,11 @@ int elevator_switch(struct request_queue *q, struct elevator_type *new_e)
651653

652654
void elevator_disable(struct request_queue *q)
653655
{
656+
unsigned int memflags;
657+
654658
lockdep_assert_held(&q->sysfs_lock);
655659

656-
blk_mq_freeze_queue(q);
660+
memflags = blk_mq_freeze_queue(q);
657661
blk_mq_quiesce_queue(q);
658662

659663
elv_unregister_queue(q);
@@ -664,7 +668,7 @@ void elevator_disable(struct request_queue *q)
664668
blk_add_trace_msg(q, "elv switch: none");
665669

666670
blk_mq_unquiesce_queue(q);
667-
blk_mq_unfreeze_queue(q);
671+
blk_mq_unfreeze_queue(q, memflags);
668672
}
669673

670674
/*

‎block/fops.c

+3-2
Original file line numberDiff line numberDiff line change
@@ -783,11 +783,12 @@ static ssize_t blkdev_read_iter(struct kiocb *iocb, struct iov_iter *to)
783783
file_accessed(iocb->ki_filp);
784784

785785
ret = blkdev_direct_IO(iocb, to);
786-
if (ret >= 0) {
786+
if (ret > 0) {
787787
iocb->ki_pos += ret;
788788
count -= ret;
789789
}
790-
iov_iter_revert(to, count - iov_iter_count(to));
790+
if (ret != -EIOCBQUEUED)
791+
iov_iter_revert(to, count - iov_iter_count(to));
791792
if (ret < 0 || !count)
792793
goto reexpand;
793794
}

‎drivers/block/aoe/aoedev.c

+3-2
Original file line numberDiff line numberDiff line change
@@ -226,10 +226,11 @@ aoedev_downdev(struct aoedev *d)
226226
/* fast fail all pending I/O */
227227
if (d->blkq) {
228228
/* UP is cleared, freeze+quiesce to insure all are errored */
229-
blk_mq_freeze_queue(d->blkq);
229+
unsigned int memflags = blk_mq_freeze_queue(d->blkq);
230+
230231
blk_mq_quiesce_queue(d->blkq);
231232
blk_mq_unquiesce_queue(d->blkq);
232-
blk_mq_unfreeze_queue(d->blkq);
233+
blk_mq_unfreeze_queue(d->blkq, memflags);
233234
}
234235

235236
if (d->gd)

‎drivers/block/ataflop.c

+3-2
Original file line numberDiff line numberDiff line change
@@ -746,6 +746,7 @@ static int do_format(int drive, int type, struct atari_format_descr *desc)
746746
unsigned char *p;
747747
int sect, nsect;
748748
unsigned long flags;
749+
unsigned int memflags;
749750
int ret;
750751

751752
if (type) {
@@ -758,7 +759,7 @@ static int do_format(int drive, int type, struct atari_format_descr *desc)
758759
}
759760

760761
q = unit[drive].disk[type]->queue;
761-
blk_mq_freeze_queue(q);
762+
memflags = blk_mq_freeze_queue(q);
762763
blk_mq_quiesce_queue(q);
763764

764765
local_irq_save(flags);
@@ -817,7 +818,7 @@ static int do_format(int drive, int type, struct atari_format_descr *desc)
817818
ret = FormatError ? -EIO : 0;
818819
out:
819820
blk_mq_unquiesce_queue(q);
820-
blk_mq_unfreeze_queue(q);
821+
blk_mq_unfreeze_queue(q, memflags);
821822
return ret;
822823
}
823824

‎drivers/block/loop.c

+13-10
Original file line numberDiff line numberDiff line change
@@ -586,6 +586,7 @@ static int loop_change_fd(struct loop_device *lo, struct block_device *bdev,
586586
{
587587
struct file *file = fget(arg);
588588
struct file *old_file;
589+
unsigned int memflags;
589590
int error;
590591
bool partscan;
591592
bool is_loop;
@@ -623,14 +624,14 @@ static int loop_change_fd(struct loop_device *lo, struct block_device *bdev,
623624

624625
/* and ... switch */
625626
disk_force_media_change(lo->lo_disk);
626-
blk_mq_freeze_queue(lo->lo_queue);
627+
memflags = blk_mq_freeze_queue(lo->lo_queue);
627628
mapping_set_gfp_mask(old_file->f_mapping, lo->old_gfp_mask);
628629
lo->lo_backing_file = file;
629630
lo->old_gfp_mask = mapping_gfp_mask(file->f_mapping);
630631
mapping_set_gfp_mask(file->f_mapping,
631632
lo->old_gfp_mask & ~(__GFP_IO|__GFP_FS));
632633
loop_update_dio(lo);
633-
blk_mq_unfreeze_queue(lo->lo_queue);
634+
blk_mq_unfreeze_queue(lo->lo_queue, memflags);
634635
partscan = lo->lo_flags & LO_FLAGS_PARTSCAN;
635636
loop_global_unlock(lo, is_loop);
636637

@@ -1255,6 +1256,7 @@ loop_set_status(struct loop_device *lo, const struct loop_info64 *info)
12551256
int err;
12561257
bool partscan = false;
12571258
bool size_changed = false;
1259+
unsigned int memflags;
12581260

12591261
err = mutex_lock_killable(&lo->lo_mutex);
12601262
if (err)
@@ -1272,7 +1274,7 @@ loop_set_status(struct loop_device *lo, const struct loop_info64 *info)
12721274
}
12731275

12741276
/* I/O needs to be drained before changing lo_offset or lo_sizelimit */
1275-
blk_mq_freeze_queue(lo->lo_queue);
1277+
memflags = blk_mq_freeze_queue(lo->lo_queue);
12761278

12771279
err = loop_set_status_from_info(lo, info);
12781280
if (err)
@@ -1281,8 +1283,7 @@ loop_set_status(struct loop_device *lo, const struct loop_info64 *info)
12811283
partscan = !(lo->lo_flags & LO_FLAGS_PARTSCAN) &&
12821284
(info->lo_flags & LO_FLAGS_PARTSCAN);
12831285

1284-
lo->lo_flags &= ~(LOOP_SET_STATUS_SETTABLE_FLAGS |
1285-
LOOP_SET_STATUS_CLEARABLE_FLAGS);
1286+
lo->lo_flags &= ~LOOP_SET_STATUS_CLEARABLE_FLAGS;
12861287
lo->lo_flags |= (info->lo_flags & LOOP_SET_STATUS_SETTABLE_FLAGS);
12871288

12881289
if (size_changed) {
@@ -1295,7 +1296,7 @@ loop_set_status(struct loop_device *lo, const struct loop_info64 *info)
12951296
loop_update_dio(lo);
12961297

12971298
out_unfreeze:
1298-
blk_mq_unfreeze_queue(lo->lo_queue);
1299+
blk_mq_unfreeze_queue(lo->lo_queue, memflags);
12991300
if (partscan)
13001301
clear_bit(GD_SUPPRESS_PART_SCAN, &lo->lo_disk->state);
13011302
out_unlock:
@@ -1447,6 +1448,7 @@ static int loop_set_capacity(struct loop_device *lo)
14471448
static int loop_set_dio(struct loop_device *lo, unsigned long arg)
14481449
{
14491450
bool use_dio = !!arg;
1451+
unsigned int memflags;
14501452

14511453
if (lo->lo_state != Lo_bound)
14521454
return -ENXIO;
@@ -1460,18 +1462,19 @@ static int loop_set_dio(struct loop_device *lo, unsigned long arg)
14601462
vfs_fsync(lo->lo_backing_file, 0);
14611463
}
14621464

1463-
blk_mq_freeze_queue(lo->lo_queue);
1465+
memflags = blk_mq_freeze_queue(lo->lo_queue);
14641466
if (use_dio)
14651467
lo->lo_flags |= LO_FLAGS_DIRECT_IO;
14661468
else
14671469
lo->lo_flags &= ~LO_FLAGS_DIRECT_IO;
1468-
blk_mq_unfreeze_queue(lo->lo_queue);
1470+
blk_mq_unfreeze_queue(lo->lo_queue, memflags);
14691471
return 0;
14701472
}
14711473

14721474
static int loop_set_block_size(struct loop_device *lo, unsigned long arg)
14731475
{
14741476
struct queue_limits lim;
1477+
unsigned int memflags;
14751478
int err = 0;
14761479

14771480
if (lo->lo_state != Lo_bound)
@@ -1486,10 +1489,10 @@ static int loop_set_block_size(struct loop_device *lo, unsigned long arg)
14861489
lim = queue_limits_start_update(lo->lo_queue);
14871490
loop_update_limits(lo, &lim, arg);
14881491

1489-
blk_mq_freeze_queue(lo->lo_queue);
1492+
memflags = blk_mq_freeze_queue(lo->lo_queue);
14901493
err = queue_limits_commit_update(lo->lo_queue, &lim);
14911494
loop_update_dio(lo);
1492-
blk_mq_unfreeze_queue(lo->lo_queue);
1495+
blk_mq_unfreeze_queue(lo->lo_queue, memflags);
14931496

14941497
return err;
14951498
}

‎drivers/block/nbd.c

+4-3
Original file line numberDiff line numberDiff line change
@@ -1234,6 +1234,7 @@ static int nbd_add_socket(struct nbd_device *nbd, unsigned long arg,
12341234
struct socket *sock;
12351235
struct nbd_sock **socks;
12361236
struct nbd_sock *nsock;
1237+
unsigned int memflags;
12371238
int err;
12381239

12391240
/* Arg will be cast to int, check it to avoid overflow */
@@ -1247,7 +1248,7 @@ static int nbd_add_socket(struct nbd_device *nbd, unsigned long arg,
12471248
* We need to make sure we don't get any errant requests while we're
12481249
* reallocating the ->socks array.
12491250
*/
1250-
blk_mq_freeze_queue(nbd->disk->queue);
1251+
memflags = blk_mq_freeze_queue(nbd->disk->queue);
12511252

12521253
if (!netlink && !nbd->task_setup &&
12531254
!test_bit(NBD_RT_BOUND, &config->runtime_flags))
@@ -1288,12 +1289,12 @@ static int nbd_add_socket(struct nbd_device *nbd, unsigned long arg,
12881289
INIT_WORK(&nsock->work, nbd_pending_cmd_work);
12891290
socks[config->num_connections++] = nsock;
12901291
atomic_inc(&config->live_connections);
1291-
blk_mq_unfreeze_queue(nbd->disk->queue);
1292+
blk_mq_unfreeze_queue(nbd->disk->queue, memflags);
12921293

12931294
return 0;
12941295

12951296
put_socket:
1296-
blk_mq_unfreeze_queue(nbd->disk->queue);
1297+
blk_mq_unfreeze_queue(nbd->disk->queue, memflags);
12971298
sockfd_put(sock);
12981299
return err;
12991300
}

‎drivers/block/rbd.c

+3-2
Original file line numberDiff line numberDiff line change
@@ -7281,9 +7281,10 @@ static ssize_t do_rbd_remove(const char *buf, size_t count)
72817281
* Prevent new IO from being queued and wait for existing
72827282
* IO to complete/fail.
72837283
*/
7284-
blk_mq_freeze_queue(rbd_dev->disk->queue);
7284+
unsigned int memflags = blk_mq_freeze_queue(rbd_dev->disk->queue);
7285+
72857286
blk_mark_disk_dead(rbd_dev->disk);
7286-
blk_mq_unfreeze_queue(rbd_dev->disk->queue);
7287+
blk_mq_unfreeze_queue(rbd_dev->disk->queue, memflags);
72877288
}
72887289

72897290
del_gendisk(rbd_dev->disk);

‎drivers/block/sunvdc.c

+3-2
Original file line numberDiff line numberDiff line change
@@ -1113,6 +1113,7 @@ static void vdc_requeue_inflight(struct vdc_port *port)
11131113
static void vdc_queue_drain(struct vdc_port *port)
11141114
{
11151115
struct request_queue *q = port->disk->queue;
1116+
unsigned int memflags;
11161117

11171118
/*
11181119
* Mark the queue as draining, then freeze/quiesce to ensure
@@ -1121,12 +1122,12 @@ static void vdc_queue_drain(struct vdc_port *port)
11211122
port->drain = 1;
11221123
spin_unlock_irq(&port->vio.lock);
11231124

1124-
blk_mq_freeze_queue(q);
1125+
memflags = blk_mq_freeze_queue(q);
11251126
blk_mq_quiesce_queue(q);
11261127

11271128
spin_lock_irq(&port->vio.lock);
11281129
port->drain = 0;
1129-
blk_mq_unquiesce_queue(q);
1130+
blk_mq_unquiesce_queue(q, memflags);
11301131
blk_mq_unfreeze_queue(q);
11311132
}
11321133

‎drivers/block/swim3.c

+3-2
Original file line numberDiff line numberDiff line change
@@ -840,6 +840,7 @@ static int grab_drive(struct floppy_state *fs, enum swim_state state,
840840
static void release_drive(struct floppy_state *fs)
841841
{
842842
struct request_queue *q = disks[fs->index]->queue;
843+
unsigned int memflags;
843844
unsigned long flags;
844845

845846
swim3_dbg("%s", "-> release drive\n");
@@ -848,10 +849,10 @@ static void release_drive(struct floppy_state *fs)
848849
fs->state = idle;
849850
spin_unlock_irqrestore(&swim3_lock, flags);
850851

851-
blk_mq_freeze_queue(q);
852+
memflags = blk_mq_freeze_queue(q);
852853
blk_mq_quiesce_queue(q);
853854
blk_mq_unquiesce_queue(q);
854-
blk_mq_unfreeze_queue(q);
855+
blk_mq_unfreeze_queue(q, memflags);
855856
}
856857

857858
static int fd_eject(struct floppy_state *fs)

‎drivers/block/virtio_blk.c

+3-2
Original file line numberDiff line numberDiff line change
@@ -1583,11 +1583,12 @@ static int virtblk_freeze_priv(struct virtio_device *vdev)
15831583
{
15841584
struct virtio_blk *vblk = vdev->priv;
15851585
struct request_queue *q = vblk->disk->queue;
1586+
unsigned int memflags;
15861587

15871588
/* Ensure no requests in virtqueues before deleting vqs. */
1588-
blk_mq_freeze_queue(q);
1589+
memflags = blk_mq_freeze_queue(q);
15891590
blk_mq_quiesce_queue_nowait(q);
1590-
blk_mq_unfreeze_queue(q);
1591+
blk_mq_unfreeze_queue(q, memflags);
15911592

15921593
/* Ensure we don't receive any more interrupts */
15931594
virtio_reset_device(vdev);

‎drivers/md/md-bitmap.c

+4-1
Original file line numberDiff line numberDiff line change
@@ -2355,7 +2355,10 @@ static int bitmap_get_stats(void *data, struct md_bitmap_stats *stats)
23552355

23562356
if (!bitmap)
23572357
return -ENOENT;
2358-
2358+
if (bitmap->mddev->bitmap_info.external)
2359+
return -ENOENT;
2360+
if (!bitmap->storage.sb_page) /* no superblock */
2361+
return -EINVAL;
23592362
sb = kmap_local_page(bitmap->storage.sb_page);
23602363
stats->sync_size = le64_to_cpu(sb->sync_size);
23612364
kunmap_local(sb);

‎drivers/md/md.c

+5
Original file line numberDiff line numberDiff line change
@@ -8376,6 +8376,10 @@ static int md_seq_show(struct seq_file *seq, void *v)
83768376
return 0;
83778377

83788378
spin_unlock(&all_mddevs_lock);
8379+
8380+
/* prevent bitmap to be freed after checking */
8381+
mutex_lock(&mddev->bitmap_info.mutex);
8382+
83798383
spin_lock(&mddev->lock);
83808384
if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
83818385
seq_printf(seq, "%s : ", mdname(mddev));
@@ -8451,6 +8455,7 @@ static int md_seq_show(struct seq_file *seq, void *v)
84518455
seq_printf(seq, "\n");
84528456
}
84538457
spin_unlock(&mddev->lock);
8458+
mutex_unlock(&mddev->bitmap_info.mutex);
84548459
spin_lock(&all_mddevs_lock);
84558460

84568461
if (mddev == list_last_entry(&all_mddevs, struct mddev, all_mddevs))

‎drivers/mtd/mtd_blkdevs.c

+3-2
Original file line numberDiff line numberDiff line change
@@ -404,6 +404,7 @@ int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new)
404404
int del_mtd_blktrans_dev(struct mtd_blktrans_dev *old)
405405
{
406406
unsigned long flags;
407+
unsigned int memflags;
407408

408409
lockdep_assert_held(&mtd_table_mutex);
409410

@@ -420,10 +421,10 @@ int del_mtd_blktrans_dev(struct mtd_blktrans_dev *old)
420421
spin_unlock_irqrestore(&old->queue_lock, flags);
421422

422423
/* freeze+quiesce queue to ensure all requests are flushed */
423-
blk_mq_freeze_queue(old->rq);
424+
memflags = blk_mq_freeze_queue(old->rq);
424425
blk_mq_quiesce_queue(old->rq);
425426
blk_mq_unquiesce_queue(old->rq);
426-
blk_mq_unfreeze_queue(old->rq);
427+
blk_mq_unfreeze_queue(old->rq, memflags);
427428

428429
/* If the device is currently open, tell trans driver to close it,
429430
then put mtd device, and don't touch it again */

‎drivers/nvme/host/core.c

+10-7
Original file line numberDiff line numberDiff line change
@@ -2132,15 +2132,16 @@ static int nvme_update_ns_info_generic(struct nvme_ns *ns,
21322132
struct nvme_ns_info *info)
21332133
{
21342134
struct queue_limits lim;
2135+
unsigned int memflags;
21352136
int ret;
21362137

21372138
lim = queue_limits_start_update(ns->disk->queue);
21382139
nvme_set_ctrl_limits(ns->ctrl, &lim);
21392140

2140-
blk_mq_freeze_queue(ns->disk->queue);
2141+
memflags = blk_mq_freeze_queue(ns->disk->queue);
21412142
ret = queue_limits_commit_update(ns->disk->queue, &lim);
21422143
set_disk_ro(ns->disk, nvme_ns_is_readonly(ns, info));
2143-
blk_mq_unfreeze_queue(ns->disk->queue);
2144+
blk_mq_unfreeze_queue(ns->disk->queue, memflags);
21442145

21452146
/* Hide the block-interface for these devices */
21462147
if (!ret)
@@ -2155,6 +2156,7 @@ static int nvme_update_ns_info_block(struct nvme_ns *ns,
21552156
struct nvme_id_ns_nvm *nvm = NULL;
21562157
struct nvme_zone_info zi = {};
21572158
struct nvme_id_ns *id;
2159+
unsigned int memflags;
21582160
sector_t capacity;
21592161
unsigned lbaf;
21602162
int ret;
@@ -2186,7 +2188,7 @@ static int nvme_update_ns_info_block(struct nvme_ns *ns,
21862188

21872189
lim = queue_limits_start_update(ns->disk->queue);
21882190

2189-
blk_mq_freeze_queue(ns->disk->queue);
2191+
memflags = blk_mq_freeze_queue(ns->disk->queue);
21902192
ns->head->lba_shift = id->lbaf[lbaf].ds;
21912193
ns->head->nuse = le64_to_cpu(id->nuse);
21922194
capacity = nvme_lba_to_sect(ns->head, le64_to_cpu(id->nsze));
@@ -2219,7 +2221,7 @@ static int nvme_update_ns_info_block(struct nvme_ns *ns,
22192221

22202222
ret = queue_limits_commit_update(ns->disk->queue, &lim);
22212223
if (ret) {
2222-
blk_mq_unfreeze_queue(ns->disk->queue);
2224+
blk_mq_unfreeze_queue(ns->disk->queue, memflags);
22232225
goto out;
22242226
}
22252227

@@ -2235,7 +2237,7 @@ static int nvme_update_ns_info_block(struct nvme_ns *ns,
22352237
ns->head->features |= NVME_NS_DEAC;
22362238
set_disk_ro(ns->disk, nvme_ns_is_readonly(ns, info));
22372239
set_bit(NVME_NS_READY, &ns->flags);
2238-
blk_mq_unfreeze_queue(ns->disk->queue);
2240+
blk_mq_unfreeze_queue(ns->disk->queue, memflags);
22392241

22402242
if (blk_queue_is_zoned(ns->queue)) {
22412243
ret = blk_revalidate_disk_zones(ns->disk);
@@ -2291,9 +2293,10 @@ static int nvme_update_ns_info(struct nvme_ns *ns, struct nvme_ns_info *info)
22912293
if (!ret && nvme_ns_head_multipath(ns->head)) {
22922294
struct queue_limits *ns_lim = &ns->disk->queue->limits;
22932295
struct queue_limits lim;
2296+
unsigned int memflags;
22942297

22952298
lim = queue_limits_start_update(ns->head->disk->queue);
2296-
blk_mq_freeze_queue(ns->head->disk->queue);
2299+
memflags = blk_mq_freeze_queue(ns->head->disk->queue);
22972300
/*
22982301
* queue_limits mixes values that are the hardware limitations
22992302
* for bio splitting with what is the device configuration.
@@ -2325,7 +2328,7 @@ static int nvme_update_ns_info(struct nvme_ns *ns, struct nvme_ns_info *info)
23252328
set_disk_ro(ns->head->disk, nvme_ns_is_readonly(ns, info));
23262329
nvme_mpath_revalidate_paths(ns);
23272330

2328-
blk_mq_unfreeze_queue(ns->head->disk->queue);
2331+
blk_mq_unfreeze_queue(ns->head->disk->queue, memflags);
23292332
}
23302333

23312334
return ret;

‎drivers/nvme/host/multipath.c

+1-1
Original file line numberDiff line numberDiff line change
@@ -60,7 +60,7 @@ void nvme_mpath_unfreeze(struct nvme_subsystem *subsys)
6060
lockdep_assert_held(&subsys->lock);
6161
list_for_each_entry(h, &subsys->nsheads, entry)
6262
if (h->disk)
63-
blk_mq_unfreeze_queue(h->disk->queue);
63+
blk_mq_unfreeze_queue_nomemrestore(h->disk->queue);
6464
}
6565

6666
void nvme_mpath_wait_freeze(struct nvme_subsystem *subsys)

‎drivers/scsi/scsi_lib.c

+3-2
Original file line numberDiff line numberDiff line change
@@ -2736,6 +2736,7 @@ int
27362736
scsi_device_quiesce(struct scsi_device *sdev)
27372737
{
27382738
struct request_queue *q = sdev->request_queue;
2739+
unsigned int memflags;
27392740
int err;
27402741

27412742
/*
@@ -2750,15 +2751,15 @@ scsi_device_quiesce(struct scsi_device *sdev)
27502751

27512752
blk_set_pm_only(q);
27522753

2753-
blk_mq_freeze_queue(q);
2754+
memflags = blk_mq_freeze_queue(q);
27542755
/*
27552756
* Ensure that the effect of blk_set_pm_only() will be visible
27562757
* for percpu_ref_tryget() callers that occur after the queue
27572758
* unfreeze even if the queue was already frozen before this function
27582759
* was called. See also https://lwn.net/Articles/573497/.
27592760
*/
27602761
synchronize_rcu();
2761-
blk_mq_unfreeze_queue(q);
2762+
blk_mq_unfreeze_queue(q, memflags);
27622763

27632764
mutex_lock(&sdev->state_mutex);
27642765
err = scsi_device_set_state(sdev, SDEV_QUIESCE);

‎drivers/scsi/scsi_scan.c

+3-2
Original file line numberDiff line numberDiff line change
@@ -220,6 +220,7 @@ static int scsi_realloc_sdev_budget_map(struct scsi_device *sdev,
220220
int new_shift = sbitmap_calculate_shift(depth);
221221
bool need_alloc = !sdev->budget_map.map;
222222
bool need_free = false;
223+
unsigned int memflags;
223224
int ret;
224225
struct sbitmap sb_backup;
225226

@@ -240,7 +241,7 @@ static int scsi_realloc_sdev_budget_map(struct scsi_device *sdev,
240241
* and here disk isn't added yet, so freezing is pretty fast
241242
*/
242243
if (need_free) {
243-
blk_mq_freeze_queue(sdev->request_queue);
244+
memflags = blk_mq_freeze_queue(sdev->request_queue);
244245
sb_backup = sdev->budget_map;
245246
}
246247
ret = sbitmap_init_node(&sdev->budget_map,
@@ -256,7 +257,7 @@ static int scsi_realloc_sdev_budget_map(struct scsi_device *sdev,
256257
else
257258
sbitmap_free(&sb_backup);
258259
ret = 0;
259-
blk_mq_unfreeze_queue(sdev->request_queue);
260+
blk_mq_unfreeze_queue(sdev->request_queue, memflags);
260261
}
261262
return ret;
262263
}

‎drivers/ufs/core/ufs-sysfs.c

+5-2
Original file line numberDiff line numberDiff line change
@@ -1439,6 +1439,7 @@ static ssize_t max_number_of_rtt_store(struct device *dev,
14391439
struct ufs_hba *hba = dev_get_drvdata(dev);
14401440
struct ufs_dev_info *dev_info = &hba->dev_info;
14411441
struct scsi_device *sdev;
1442+
unsigned int memflags;
14421443
unsigned int rtt;
14431444
int ret;
14441445

@@ -1458,14 +1459,16 @@ static ssize_t max_number_of_rtt_store(struct device *dev,
14581459

14591460
ufshcd_rpm_get_sync(hba);
14601461

1462+
memflags = memalloc_noio_save();
14611463
shost_for_each_device(sdev, hba->host)
1462-
blk_mq_freeze_queue(sdev->request_queue);
1464+
blk_mq_freeze_queue_nomemsave(sdev->request_queue);
14631465

14641466
ret = ufshcd_query_attr(hba, UPIU_QUERY_OPCODE_WRITE_ATTR,
14651467
QUERY_ATTR_IDN_MAX_NUM_OF_RTT, 0, 0, &rtt);
14661468

14671469
shost_for_each_device(sdev, hba->host)
1468-
blk_mq_unfreeze_queue(sdev->request_queue);
1470+
blk_mq_unfreeze_queue_nomemrestore(sdev->request_queue);
1471+
memalloc_noio_restore(memflags);
14691472

14701473
ufshcd_rpm_put_sync(hba);
14711474

‎include/linux/blk-mq.h

+16-2
Original file line numberDiff line numberDiff line change
@@ -900,8 +900,22 @@ void blk_mq_delay_run_hw_queues(struct request_queue *q, unsigned long msecs);
900900
void blk_mq_tagset_busy_iter(struct blk_mq_tag_set *tagset,
901901
busy_tag_iter_fn *fn, void *priv);
902902
void blk_mq_tagset_wait_completed_request(struct blk_mq_tag_set *tagset);
903-
void blk_mq_freeze_queue(struct request_queue *q);
904-
void blk_mq_unfreeze_queue(struct request_queue *q);
903+
void blk_mq_freeze_queue_nomemsave(struct request_queue *q);
904+
void blk_mq_unfreeze_queue_nomemrestore(struct request_queue *q);
905+
static inline unsigned int __must_check
906+
blk_mq_freeze_queue(struct request_queue *q)
907+
{
908+
unsigned int memflags = memalloc_noio_save();
909+
910+
blk_mq_freeze_queue_nomemsave(q);
911+
return memflags;
912+
}
913+
static inline void
914+
blk_mq_unfreeze_queue(struct request_queue *q, unsigned int memflags)
915+
{
916+
blk_mq_unfreeze_queue_nomemrestore(q);
917+
memalloc_noio_restore(memflags);
918+
}
905919
void blk_freeze_queue_start(struct request_queue *q);
906920
void blk_mq_freeze_queue_wait(struct request_queue *q);
907921
int blk_mq_freeze_queue_wait_timeout(struct request_queue *q,

‎include/linux/blkdev.h

-3
Original file line numberDiff line numberDiff line change
@@ -561,7 +561,6 @@ struct request_queue {
561561
struct list_head flush_list;
562562

563563
struct mutex sysfs_lock;
564-
struct mutex sysfs_dir_lock;
565564
struct mutex limits_lock;
566565

567566
/*
@@ -605,8 +604,6 @@ struct request_queue {
605604
* Serializes all debugfs metadata operations using the above dentries.
606605
*/
607606
struct mutex debugfs_mutex;
608-
609-
bool mq_sysfs_init_done;
610607
};
611608

612609
/* Keep blk_queue_flag_name[] in sync with the definitions below */

0 commit comments

Comments
 (0)
Please sign in to comment.