github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-09-14 08:01:12 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

block: split out a new blk_plug.h header

Browse Source 
blkdev.h gets included in various places outside the block layer just
for struct blk_plug and related plugging functions.

Split blk_plug into a separate helper to reduce the amount of code
that needs to get rebuilt when blkdev.h changes and to slightly
reduce compile times.

In io_uring this requires pulling in a few other headers explicitly that
previously were implicitly included through blkdev.h.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Christian Brauner (Amutable) <brauner@kernel.org>
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Reviewed-by: Damien Le Moal <dlemoal@kernel.org>
Link: https://patch.msgid.link/20260804125524.740996-1-hch@lst.de
Signed-off-by: Jens Axboe <axboe@kernel.dk>
This commit is contained in:
Christoph Hellwig 2026-08-04 05:55:10 -07:00 committed by Jens Axboe
parent ca8f6548e6
commit 758b86f7bc
16 changed files with 108 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
fs/aio.c
View File

@ -35,7 +35,7 @@
#include <linux/workqueue.h>
#include <linux/security.h>
#include <linux/eventfd.h>
#include <linux/blkdev.h>
#include <linux/blk_plug.h>
#include <linux/compat.h>
#include <linux/migrate.h>
#include <linux/ramfs.h>

2
fs/fs-writeback.c
View File

@ -25,7 +25,7 @@
#include <linux/pagemap.h>
#include <linux/kthread.h>
#include <linux/writeback.h>
#include <linux/blkdev.h>
#include <linux/blk_plug.h>
#include <linux/backing-dev.h>
#include <linux/tracepoint.h>
#include <linux/device.h>

95
include/linux/blk_plug.h Normal file
View File

@ -0,0 +1,95 @@
/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _LINUX_BLK_PLUG_H
#define _LINUX_BLK_PLUG_H
#include <linux/sched.h>
struct blk_plug_cb;
typedef void (*blk_plug_cb_fn)(struct blk_plug_cb *cb, bool from_schedule);
struct rq_list {
struct request *head;
struct request *tail;
};
#ifdef CONFIG_BLOCK
/*
* blk_plug permits building a queue of related requests by holding the I/O
* fragments for a short period. This allows merging of sequential requests
* into single larger request. As the requests are moved from a per-task list to
* the device's request_queue in a batch, this results in improved scalability
* as the lock contention for request_queue lock is reduced.
*
* It is ok not to disable preemption when adding the request to the plug list
* or when attempting a merge. For details, please see schedule() where
* blk_flush_plug() is called.
*/
struct blk_plug {
struct rq_list mq_list; /* blk-mq requests */
/* if ios_left is > 1, we can batch tag/rq allocations */
struct rq_list cached_rqs;
u64 cur_ktime;
unsigned short nr_ios;
unsigned short rq_count;
bool multiple_queues;
bool has_elevator;
struct list_head cb_list; /* md requires an unplug callback */
};
void blk_start_plug(struct blk_plug *);
void blk_start_plug_nr_ios(struct blk_plug *, unsigned short);
void blk_finish_plug(struct blk_plug *);
void __blk_flush_plug(struct blk_plug *plug, bool from_schedule);
static inline void blk_flush_plug(struct blk_plug *plug, bool async)
{
if (plug)
__blk_flush_plug(plug, async);
}
static __always_inline void blk_plug_invalidate_ts(void)
{
if (unlikely(current->flags & PF_BLOCK_TS)) {
current->plug->cur_ktime = 0;
current->flags &= ~PF_BLOCK_TS;
}
}
struct blk_plug_cb {
struct list_head list;
blk_plug_cb_fn callback;
void *data;
};
struct blk_plug_cb *blk_check_plugged(blk_plug_cb_fn unplug, void *data,
int size);
#else /* CONFIG_BLOCK */
struct blk_plug {
};
static inline void blk_start_plug(struct blk_plug *plug)
{
}
static inline void blk_start_plug_nr_ios(struct blk_plug *plug,
unsigned short nr_ios)
{
}
static inline void blk_finish_plug(struct blk_plug *plug)
{
}
static inline void blk_flush_plug(struct blk_plug *plug, bool async)
{
}
static inline void blk_plug_invalidate_ts(void)
{
}
#endif /* CONFIG_BLOCK */
#endif /* _LINUX_BLK_PLUG_H */

86
include/linux/blkdev.h
View File

@ -7,6 +7,7 @@
#include <linux/types.h>
#include <linux/blk_types.h>
#include <linux/blk_plug.h>
#include <linux/device.h>
#include <linux/list.h>
#include <linux/llist.h>
@ -21,7 +22,6 @@
#include <linux/rcupdate.h>
#include <linux/percpu-refcount.h>
#include <linux/blkzoned.h>
#include <linux/sched.h>
#include <linux/sbitmap.h>
#include <linux/uuid.h>
#include <linux/xarray.h>
@ -1169,94 +1169,10 @@ extern void blk_put_queue(struct request_queue *);
void blk_mark_disk_dead(struct gendisk *disk);
struct rq_list {
struct request *head;
struct request *tail;
};
#ifdef CONFIG_BLOCK
/*
* blk_plug permits building a queue of related requests by holding the I/O
* fragments for a short period. This allows merging of sequential requests
* into single larger request. As the requests are moved from a per-task list to
* the device's request_queue in a batch, this results in improved scalability
* as the lock contention for request_queue lock is reduced.
*
* It is ok not to disable preemption when adding the request to the plug list
* or when attempting a merge. For details, please see schedule() where
* blk_flush_plug() is called.
*/
struct blk_plug {
struct rq_list mq_list; /* blk-mq requests */
/* if ios_left is > 1, we can batch tag/rq allocations */
struct rq_list cached_rqs;
u64 cur_ktime;
unsigned short nr_ios;
unsigned short rq_count;
bool multiple_queues;
bool has_elevator;
struct list_head cb_list; /* md requires an unplug callback */
};
struct blk_plug_cb;
typedef void (*blk_plug_cb_fn)(struct blk_plug_cb *, bool);
struct blk_plug_cb {
struct list_head list;
blk_plug_cb_fn callback;
void *data;
};
extern struct blk_plug_cb *blk_check_plugged(blk_plug_cb_fn unplug,
void *data, int size);
extern void blk_start_plug(struct blk_plug *);
extern void blk_start_plug_nr_ios(struct blk_plug *, unsigned short);
extern void blk_finish_plug(struct blk_plug *);
void __blk_flush_plug(struct blk_plug *plug, bool from_schedule);
static inline void blk_flush_plug(struct blk_plug *plug, bool async)
{
if (plug)
__blk_flush_plug(plug, async);
}
static __always_inline void blk_plug_invalidate_ts(void)
{
if (unlikely(current->flags & PF_BLOCK_TS)) {
current->plug->cur_ktime = 0;
current->flags &= ~PF_BLOCK_TS;
}
}
int blkdev_issue_flush(struct block_device *bdev);
long nr_blockdev_pages(void);
#else /* CONFIG_BLOCK */
struct blk_plug {
};
static inline void blk_start_plug_nr_ios(struct blk_plug *plug,
unsigned short nr_ios)
{
}
static inline void blk_start_plug(struct blk_plug *plug)
{
}
static inline void blk_finish_plug(struct blk_plug *plug)
{
}
static inline void blk_flush_plug(struct blk_plug *plug, bool async)
{
}
static inline void blk_plug_invalidate_ts(void)
{
}
static inline int blkdev_issue_flush(struct block_device *bdev)
{
return 0;

2
include/linux/io_uring_types.h
View File

@ -1,7 +1,7 @@
#ifndef IO_URING_TYPES_H
#define IO_URING_TYPES_H
#include <linux/blkdev.h>
#include <linux/blk_plug.h>
#include <linux/hashtable.h>
#include <linux/task_work.h>
#include <linux/bitmap.h>

1
io_uring/io_uring.h
View File

@ -3,6 +3,7 @@
#define IOU_CORE_H
#include <linux/errno.h>
#include <linux/file.h>
#include <linux/lockdep.h>
#include <linux/resume_user_mode.h>
#include <linux/poll.h>

1
io_uring/kbuf.c
View File

@ -7,6 +7,7 @@
#include <linux/slab.h>
#include <linux/namei.h>
#include <linux/poll.h>
#include <linux/uio.h>
#include <linux/vmalloc.h>
#include <linux/io_uring.h>

2
io_uring/rsrc.h
View File

@ -2,8 +2,10 @@
#ifndef IOU_RSRC_H
#define IOU_RSRC_H
#include <linux/bvec.h>
#include <linux/io_uring_types.h>
#include <linux/lockdep.h>
#include <linux/uio.h>
#define IO_VEC_CACHE_SOFT_CAP 256

1
io_uring/rw.h
View File

@ -2,6 +2,7 @@
#include <linux/io_uring_types.h>
#include <linux/pagemap.h>
#include <linux/uio.h>
struct io_meta_state {
u32 seed;

1
kernel/exit.c
View File

@ -48,7 +48,6 @@
#include <linux/audit.h> /* for audit_free() */
#include <linux/resource.h>
#include <linux/task_io_accounting_ops.h>
#include <linux/blkdev.h>
#include <linux/task_work.h>
#include <linux/fs_struct.h>
#include <linux/init_task.h>

1
kernel/sched/core.c
View File

@ -40,7 +40,6 @@
#include <linux/sched/rseq_api.h>
#include <linux/sched/rt.h>
#include <linux/blkdev.h>
#include <linux/context_tracking.h>
#include <linux/cpuset.h>
#include <linux/delayacct.h>

2
mm/madvise.c
View File

@ -25,7 +25,7 @@
#include <linux/ksm.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/blkdev.h>
#include <linux/blk_plug.h>
#include <linux/backing-dev.h>
#include <linux/pagewalk.h>
#include <linux/swap.h>

1
mm/page-writeback.c
View File

@ -25,7 +25,6 @@
#include <linux/init.h>
#include <linux/backing-dev.h>
#include <linux/task_io_accounting_ops.h>
#include <linux/blkdev.h>
#include <linux/mpage.h>
#include <linux/rmap.h>
#include <linux/percpu.h>

2
mm/readahead.c
View File

@ -113,7 +113,7 @@
* ->read_folio() which may be less efficient.
*/
#include <linux/blkdev.h>
#include <linux/blk_plug.h>
#include <linux/kernel.h>
#include <linux/dax.h>
#include <linux/gfp.h>

2
mm/swap_state.c
View File

@ -17,7 +17,7 @@
#include <linux/pagemap.h>
#include <linux/folio_batch.h>
#include <linux/backing-dev.h>
#include <linux/blkdev.h>
#include <linux/blk_plug.h>
#include <linux/migrate.h>
#include <linux/vmalloc.h>
#include <linux/huge_mm.h>

2
mm/vmscan.c
View File

@ -25,7 +25,7 @@
#include <linux/vmstat.h>
#include <linux/file.h>
#include <linux/writeback.h>
#include <linux/blkdev.h>
#include <linux/blk_plug.h>
#include <linux/buffer_head.h> /* for buffer_heads_over_limit */
#include <linux/mm_inline.h>
#include <linux/backing-dev.h>