2019-04-30 21:42:43 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2008-01-29 16:53:40 +03:00
|
|
|
/*
|
|
|
|
* Functions related to setting various queue properties from drivers
|
|
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/bio.h>
|
|
|
|
#include <linux/blkdev.h>
|
2018-10-31 01:09:49 +03:00
|
|
|
#include <linux/memblock.h> /* for max_pfn/max_low_pfn */
|
2009-07-31 19:49:12 +04:00
|
|
|
#include <linux/gcd.h>
|
2010-03-15 14:46:51 +03:00
|
|
|
#include <linux/lcm.h>
|
2009-11-11 15:47:45 +03:00
|
|
|
#include <linux/jiffies.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 11:04:11 +03:00
|
|
|
#include <linux/gfp.h>
|
2019-08-28 15:35:42 +03:00
|
|
|
#include <linux/dma-mapping.h>
|
2008-01-29 16:53:40 +03:00
|
|
|
|
|
|
|
#include "blk.h"
|
block: hook up writeback throttling
Enable throttling of buffered writeback to make it a lot
more smooth, and has way less impact on other system activity.
Background writeback should be, by definition, background
activity. The fact that we flush huge bundles of it at the time
means that it potentially has heavy impacts on foreground workloads,
which isn't ideal. We can't easily limit the sizes of writes that
we do, since that would impact file system layout in the presence
of delayed allocation. So just throttle back buffered writeback,
unless someone is waiting for it.
The algorithm for when to throttle takes its inspiration in the
CoDel networking scheduling algorithm. Like CoDel, blk-wb monitors
the minimum latencies of requests over a window of time. In that
window of time, if the minimum latency of any request exceeds a
given target, then a scale count is incremented and the queue depth
is shrunk. The next monitoring window is shrunk accordingly. Unlike
CoDel, if we hit a window that exhibits good behavior, then we
simply increment the scale count and re-calculate the limits for that
scale value. This prevents us from oscillating between a
close-to-ideal value and max all the time, instead remaining in the
windows where we get good behavior.
Unlike CoDel, blk-wb allows the scale count to to negative. This
happens if we primarily have writes going on. Unlike positive
scale counts, this doesn't change the size of the monitoring window.
When the heavy writers finish, blk-bw quickly snaps back to it's
stable state of a zero scale count.
The patch registers a sysfs entry, 'wb_lat_usec'. This sets the latency
target to me met. It defaults to 2 msec for non-rotational storage, and
75 msec for rotational storage. Setting this value to '0' disables
blk-wb. Generally, a user would not have to touch this setting.
We don't enable WBT on devices that are managed with CFQ, and have
a non-root block cgroup attached. If we have a proportional share setup
on this particular disk, then the wbt throttling will interfere with
that. We don't have a strong need for wbt for that case, since we will
rely on CFQ doing that for us.
Signed-off-by: Jens Axboe <axboe@fb.com>
2016-11-09 22:38:14 +03:00
|
|
|
#include "blk-wbt.h"
|
2008-01-29 16:53:40 +03:00
|
|
|
|
2008-01-31 15:03:55 +03:00
|
|
|
unsigned long blk_max_low_pfn;
|
2008-01-29 16:53:40 +03:00
|
|
|
EXPORT_SYMBOL(blk_max_low_pfn);
|
2008-01-31 15:03:55 +03:00
|
|
|
|
|
|
|
unsigned long blk_max_pfn;
|
2008-01-29 16:53:40 +03:00
|
|
|
|
2008-09-14 16:55:09 +04:00
|
|
|
void blk_queue_rq_timeout(struct request_queue *q, unsigned int timeout)
|
|
|
|
{
|
|
|
|
q->rq_timeout = timeout;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(blk_queue_rq_timeout);
|
|
|
|
|
2009-06-16 10:23:52 +04:00
|
|
|
/**
|
|
|
|
* blk_set_default_limits - reset limits to default values
|
2009-06-19 11:18:32 +04:00
|
|
|
* @lim: the queue_limits structure to reset
|
2009-06-16 10:23:52 +04:00
|
|
|
*
|
|
|
|
* Description:
|
2012-01-11 19:27:11 +04:00
|
|
|
* Returns a queue_limit struct to its default state.
|
2009-06-16 10:23:52 +04:00
|
|
|
*/
|
|
|
|
void blk_set_default_limits(struct queue_limits *lim)
|
|
|
|
{
|
2010-02-26 08:20:39 +03:00
|
|
|
lim->max_segments = BLK_MAX_SEGMENTS;
|
2017-02-08 16:46:49 +03:00
|
|
|
lim->max_discard_segments = 1;
|
2010-09-10 22:50:10 +04:00
|
|
|
lim->max_integrity_segments = 0;
|
2009-06-16 10:23:52 +04:00
|
|
|
lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK;
|
2015-08-20 00:24:05 +03:00
|
|
|
lim->virt_boundary_mask = 0;
|
2010-02-26 08:20:37 +03:00
|
|
|
lim->max_segment_size = BLK_MAX_SEGMENT_SIZE;
|
2016-02-11 02:52:47 +03:00
|
|
|
lim->max_sectors = lim->max_hw_sectors = BLK_SAFE_MAX_SECTORS;
|
|
|
|
lim->max_dev_sectors = 0;
|
2014-06-05 23:38:39 +04:00
|
|
|
lim->chunk_sectors = 0;
|
2012-09-18 20:19:27 +04:00
|
|
|
lim->max_write_same_sectors = 0;
|
2016-11-30 23:28:59 +03:00
|
|
|
lim->max_write_zeroes_sectors = 0;
|
2020-05-12 11:55:47 +03:00
|
|
|
lim->max_zone_append_sectors = 0;
|
2009-11-10 13:50:21 +03:00
|
|
|
lim->max_discard_sectors = 0;
|
2015-07-16 18:14:26 +03:00
|
|
|
lim->max_hw_discard_sectors = 0;
|
2009-11-10 13:50:21 +03:00
|
|
|
lim->discard_granularity = 0;
|
|
|
|
lim->discard_alignment = 0;
|
|
|
|
lim->discard_misaligned = 0;
|
2009-06-16 10:23:52 +04:00
|
|
|
lim->logical_block_size = lim->physical_block_size = lim->io_min = 512;
|
2009-06-18 11:56:03 +04:00
|
|
|
lim->bounce_pfn = (unsigned long)(BLK_BOUNCE_ANY >> PAGE_SHIFT);
|
2009-06-16 10:23:52 +04:00
|
|
|
lim->alignment_offset = 0;
|
|
|
|
lim->io_opt = 0;
|
|
|
|
lim->misaligned = 0;
|
2016-10-18 09:40:29 +03:00
|
|
|
lim->zoned = BLK_ZONED_NONE;
|
2021-01-28 07:47:30 +03:00
|
|
|
lim->zone_write_granularity = 0;
|
2009-06-16 10:23:52 +04:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(blk_set_default_limits);
|
|
|
|
|
2012-01-11 19:27:11 +04:00
|
|
|
/**
|
|
|
|
* blk_set_stacking_limits - set default limits for stacking devices
|
|
|
|
* @lim: the queue_limits structure to reset
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Returns a queue_limit struct to its default state. Should be used
|
|
|
|
* by stacking drivers like DM that have no internal limits.
|
|
|
|
*/
|
|
|
|
void blk_set_stacking_limits(struct queue_limits *lim)
|
|
|
|
{
|
|
|
|
blk_set_default_limits(lim);
|
|
|
|
|
|
|
|
/* Inherit limits from component devices */
|
|
|
|
lim->max_segments = USHRT_MAX;
|
2018-07-20 21:57:38 +03:00
|
|
|
lim->max_discard_segments = USHRT_MAX;
|
2012-01-11 19:27:11 +04:00
|
|
|
lim->max_hw_sectors = UINT_MAX;
|
2013-10-18 19:44:49 +04:00
|
|
|
lim->max_segment_size = UINT_MAX;
|
2012-08-01 12:44:28 +04:00
|
|
|
lim->max_sectors = UINT_MAX;
|
2015-11-14 00:46:48 +03:00
|
|
|
lim->max_dev_sectors = UINT_MAX;
|
2012-09-18 20:19:27 +04:00
|
|
|
lim->max_write_same_sectors = UINT_MAX;
|
2016-11-30 23:28:59 +03:00
|
|
|
lim->max_write_zeroes_sectors = UINT_MAX;
|
2020-05-12 11:55:47 +03:00
|
|
|
lim->max_zone_append_sectors = UINT_MAX;
|
2012-01-11 19:27:11 +04:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(blk_set_stacking_limits);
|
|
|
|
|
2008-01-29 16:53:40 +03:00
|
|
|
/**
|
|
|
|
* blk_queue_bounce_limit - set bounce buffer limit for queue
|
2009-04-15 17:10:25 +04:00
|
|
|
* @q: the request queue for the device
|
2013-07-29 17:17:54 +04:00
|
|
|
* @max_addr: the maximum address the device can handle
|
2008-01-29 16:53:40 +03:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Different hardware can have different requirements as to what pages
|
|
|
|
* it can do I/O directly to. A low level driver can call
|
|
|
|
* blk_queue_bounce_limit to have lower memory pages allocated as bounce
|
2013-07-29 17:17:54 +04:00
|
|
|
* buffers for doing I/O to pages residing above @max_addr.
|
2008-01-29 16:53:40 +03:00
|
|
|
**/
|
2013-07-29 17:17:54 +04:00
|
|
|
void blk_queue_bounce_limit(struct request_queue *q, u64 max_addr)
|
2008-01-29 16:53:40 +03:00
|
|
|
{
|
2013-07-29 17:17:54 +04:00
|
|
|
unsigned long b_pfn = max_addr >> PAGE_SHIFT;
|
2008-01-29 16:53:40 +03:00
|
|
|
int dma = 0;
|
|
|
|
|
|
|
|
q->bounce_gfp = GFP_NOIO;
|
|
|
|
#if BITS_PER_LONG == 64
|
2009-04-15 17:10:25 +04:00
|
|
|
/*
|
|
|
|
* Assume anything <= 4GB can be handled by IOMMU. Actually
|
|
|
|
* some IOMMUs can handle everything, but I don't know of a
|
|
|
|
* way to test this here.
|
|
|
|
*/
|
|
|
|
if (b_pfn < (min_t(u64, 0xffffffffUL, BLK_BOUNCE_HIGH) >> PAGE_SHIFT))
|
2008-01-29 16:53:40 +03:00
|
|
|
dma = 1;
|
2010-10-01 16:45:27 +04:00
|
|
|
q->limits.bounce_pfn = max(max_low_pfn, b_pfn);
|
2008-01-29 16:53:40 +03:00
|
|
|
#else
|
2008-01-31 15:03:55 +03:00
|
|
|
if (b_pfn < blk_max_low_pfn)
|
2008-01-29 16:53:40 +03:00
|
|
|
dma = 1;
|
2010-09-24 22:25:49 +04:00
|
|
|
q->limits.bounce_pfn = b_pfn;
|
2010-10-01 16:42:43 +04:00
|
|
|
#endif
|
2008-01-29 16:53:40 +03:00
|
|
|
if (dma) {
|
|
|
|
init_emergency_isa_pool();
|
|
|
|
q->bounce_gfp = GFP_NOIO | GFP_DMA;
|
2010-10-01 16:42:43 +04:00
|
|
|
q->limits.bounce_pfn = b_pfn;
|
2008-01-29 16:53:40 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(blk_queue_bounce_limit);
|
|
|
|
|
|
|
|
/**
|
2015-11-14 00:46:48 +03:00
|
|
|
* blk_queue_max_hw_sectors - set max sectors for a request for this queue
|
|
|
|
* @q: the request queue for the device
|
2010-02-26 08:20:35 +03:00
|
|
|
* @max_hw_sectors: max hardware sectors in the usual 512b unit
|
2008-01-29 16:53:40 +03:00
|
|
|
*
|
|
|
|
* Description:
|
2010-02-26 08:20:35 +03:00
|
|
|
* Enables a low level driver to set a hard upper limit,
|
|
|
|
* max_hw_sectors, on the size of requests. max_hw_sectors is set by
|
2015-06-23 19:13:59 +03:00
|
|
|
* the device driver based upon the capabilities of the I/O
|
|
|
|
* controller.
|
2010-02-26 08:20:35 +03:00
|
|
|
*
|
2015-11-14 00:46:48 +03:00
|
|
|
* max_dev_sectors is a hard limit imposed by the storage device for
|
|
|
|
* READ/WRITE requests. It is set by the disk driver.
|
|
|
|
*
|
2010-02-26 08:20:35 +03:00
|
|
|
* max_sectors is a soft limit imposed by the block layer for
|
|
|
|
* filesystem type requests. This value can be overridden on a
|
|
|
|
* per-device basis in /sys/block/<device>/queue/max_sectors_kb.
|
|
|
|
* The soft limit can not exceed max_hw_sectors.
|
2008-01-29 16:53:40 +03:00
|
|
|
**/
|
2015-11-14 00:46:48 +03:00
|
|
|
void blk_queue_max_hw_sectors(struct request_queue *q, unsigned int max_hw_sectors)
|
2008-01-29 16:53:40 +03:00
|
|
|
{
|
2015-11-14 00:46:48 +03:00
|
|
|
struct queue_limits *limits = &q->limits;
|
|
|
|
unsigned int max_sectors;
|
|
|
|
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 15:29:47 +03:00
|
|
|
if ((max_hw_sectors << 9) < PAGE_SIZE) {
|
|
|
|
max_hw_sectors = 1 << (PAGE_SHIFT - 9);
|
2008-05-01 15:35:17 +04:00
|
|
|
printk(KERN_INFO "%s: set to minimum %d\n",
|
2010-02-26 08:20:35 +03:00
|
|
|
__func__, max_hw_sectors);
|
2008-01-29 16:53:40 +03:00
|
|
|
}
|
|
|
|
|
2020-11-20 04:55:13 +03:00
|
|
|
max_hw_sectors = round_down(max_hw_sectors,
|
|
|
|
limits->logical_block_size >> SECTOR_SHIFT);
|
2015-08-13 21:57:56 +03:00
|
|
|
limits->max_hw_sectors = max_hw_sectors;
|
2020-11-20 04:55:13 +03:00
|
|
|
|
2015-11-14 00:46:48 +03:00
|
|
|
max_sectors = min_not_zero(max_hw_sectors, limits->max_dev_sectors);
|
|
|
|
max_sectors = min_t(unsigned int, max_sectors, BLK_DEF_MAX_SECTORS);
|
2020-11-20 04:55:13 +03:00
|
|
|
max_sectors = round_down(max_sectors,
|
|
|
|
limits->logical_block_size >> SECTOR_SHIFT);
|
2015-11-14 00:46:48 +03:00
|
|
|
limits->max_sectors = max_sectors;
|
2020-11-20 04:55:13 +03:00
|
|
|
|
2017-02-02 17:56:50 +03:00
|
|
|
q->backing_dev_info->io_pages = max_sectors >> (PAGE_SHIFT - 9);
|
2008-01-29 16:53:40 +03:00
|
|
|
}
|
2010-02-26 08:20:38 +03:00
|
|
|
EXPORT_SYMBOL(blk_queue_max_hw_sectors);
|
2008-01-29 16:53:40 +03:00
|
|
|
|
2014-06-05 23:38:39 +04:00
|
|
|
/**
|
|
|
|
* blk_queue_chunk_sectors - set size of the chunk for this queue
|
|
|
|
* @q: the request queue for the device
|
|
|
|
* @chunk_sectors: chunk sectors in the usual 512b unit
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* If a driver doesn't want IOs to cross a given chunk size, it can set
|
2020-09-22 05:32:49 +03:00
|
|
|
* this limit and prevent merging across chunks. Note that the block layer
|
|
|
|
* must accept a page worth of data at any offset. So if the crossing of
|
|
|
|
* chunks is a hard limitation in the driver, it must still be prepared
|
|
|
|
* to split single page bios.
|
2014-06-05 23:38:39 +04:00
|
|
|
**/
|
|
|
|
void blk_queue_chunk_sectors(struct request_queue *q, unsigned int chunk_sectors)
|
|
|
|
{
|
|
|
|
q->limits.chunk_sectors = chunk_sectors;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(blk_queue_chunk_sectors);
|
|
|
|
|
2009-09-30 15:54:20 +04:00
|
|
|
/**
|
|
|
|
* blk_queue_max_discard_sectors - set max sectors for a single discard
|
|
|
|
* @q: the request queue for the device
|
2009-10-12 10:20:47 +04:00
|
|
|
* @max_discard_sectors: maximum number of sectors to discard
|
2009-09-30 15:54:20 +04:00
|
|
|
**/
|
|
|
|
void blk_queue_max_discard_sectors(struct request_queue *q,
|
|
|
|
unsigned int max_discard_sectors)
|
|
|
|
{
|
2015-07-16 18:14:26 +03:00
|
|
|
q->limits.max_hw_discard_sectors = max_discard_sectors;
|
2009-09-30 15:54:20 +04:00
|
|
|
q->limits.max_discard_sectors = max_discard_sectors;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(blk_queue_max_discard_sectors);
|
|
|
|
|
2012-09-18 20:19:27 +04:00
|
|
|
/**
|
|
|
|
* blk_queue_max_write_same_sectors - set max sectors for a single write same
|
|
|
|
* @q: the request queue for the device
|
|
|
|
* @max_write_same_sectors: maximum number of sectors to write per command
|
|
|
|
**/
|
|
|
|
void blk_queue_max_write_same_sectors(struct request_queue *q,
|
|
|
|
unsigned int max_write_same_sectors)
|
|
|
|
{
|
|
|
|
q->limits.max_write_same_sectors = max_write_same_sectors;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(blk_queue_max_write_same_sectors);
|
|
|
|
|
2016-11-30 23:28:59 +03:00
|
|
|
/**
|
|
|
|
* blk_queue_max_write_zeroes_sectors - set max sectors for a single
|
|
|
|
* write zeroes
|
|
|
|
* @q: the request queue for the device
|
|
|
|
* @max_write_zeroes_sectors: maximum number of sectors to write per command
|
|
|
|
**/
|
|
|
|
void blk_queue_max_write_zeroes_sectors(struct request_queue *q,
|
|
|
|
unsigned int max_write_zeroes_sectors)
|
|
|
|
{
|
|
|
|
q->limits.max_write_zeroes_sectors = max_write_zeroes_sectors;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(blk_queue_max_write_zeroes_sectors);
|
|
|
|
|
2020-05-12 11:55:47 +03:00
|
|
|
/**
|
|
|
|
* blk_queue_max_zone_append_sectors - set max sectors for a single zone append
|
|
|
|
* @q: the request queue for the device
|
|
|
|
* @max_zone_append_sectors: maximum number of sectors to write per command
|
|
|
|
**/
|
|
|
|
void blk_queue_max_zone_append_sectors(struct request_queue *q,
|
|
|
|
unsigned int max_zone_append_sectors)
|
|
|
|
{
|
|
|
|
unsigned int max_sectors;
|
|
|
|
|
|
|
|
if (WARN_ON(!blk_queue_is_zoned(q)))
|
|
|
|
return;
|
|
|
|
|
|
|
|
max_sectors = min(q->limits.max_hw_sectors, max_zone_append_sectors);
|
|
|
|
max_sectors = min(q->limits.chunk_sectors, max_sectors);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Signal eventual driver bugs resulting in the max_zone_append sectors limit
|
|
|
|
* being 0 due to a 0 argument, the chunk_sectors limit (zone size) not set,
|
|
|
|
* or the max_hw_sectors limit not set.
|
|
|
|
*/
|
|
|
|
WARN_ON(!max_sectors);
|
|
|
|
|
|
|
|
q->limits.max_zone_append_sectors = max_sectors;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(blk_queue_max_zone_append_sectors);
|
|
|
|
|
2008-01-29 16:53:40 +03:00
|
|
|
/**
|
2010-02-26 08:20:39 +03:00
|
|
|
* blk_queue_max_segments - set max hw segments for a request for this queue
|
2008-01-29 16:53:40 +03:00
|
|
|
* @q: the request queue for the device
|
|
|
|
* @max_segments: max number of segments
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Enables a low level driver to set an upper limit on the number of
|
2010-02-26 08:20:39 +03:00
|
|
|
* hw data segments in a request.
|
2008-01-29 16:53:40 +03:00
|
|
|
**/
|
2010-02-26 08:20:39 +03:00
|
|
|
void blk_queue_max_segments(struct request_queue *q, unsigned short max_segments)
|
2008-01-29 16:53:40 +03:00
|
|
|
{
|
|
|
|
if (!max_segments) {
|
|
|
|
max_segments = 1;
|
2008-05-01 15:35:17 +04:00
|
|
|
printk(KERN_INFO "%s: set to minimum %d\n",
|
|
|
|
__func__, max_segments);
|
2008-01-29 16:53:40 +03:00
|
|
|
}
|
|
|
|
|
2010-02-26 08:20:39 +03:00
|
|
|
q->limits.max_segments = max_segments;
|
2008-01-29 16:53:40 +03:00
|
|
|
}
|
2010-02-26 08:20:39 +03:00
|
|
|
EXPORT_SYMBOL(blk_queue_max_segments);
|
2008-01-29 16:53:40 +03:00
|
|
|
|
2017-02-08 16:46:49 +03:00
|
|
|
/**
|
|
|
|
* blk_queue_max_discard_segments - set max segments for discard requests
|
|
|
|
* @q: the request queue for the device
|
|
|
|
* @max_segments: max number of segments
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Enables a low level driver to set an upper limit on the number of
|
|
|
|
* segments in a discard request.
|
|
|
|
**/
|
|
|
|
void blk_queue_max_discard_segments(struct request_queue *q,
|
|
|
|
unsigned short max_segments)
|
|
|
|
{
|
|
|
|
q->limits.max_discard_segments = max_segments;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(blk_queue_max_discard_segments);
|
|
|
|
|
2008-01-29 16:53:40 +03:00
|
|
|
/**
|
|
|
|
* blk_queue_max_segment_size - set max segment size for blk_rq_map_sg
|
|
|
|
* @q: the request queue for the device
|
|
|
|
* @max_size: max size of segment in bytes
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Enables a low level driver to set an upper limit on the size of a
|
|
|
|
* coalesced segment
|
|
|
|
**/
|
|
|
|
void blk_queue_max_segment_size(struct request_queue *q, unsigned int max_size)
|
|
|
|
{
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 15:29:47 +03:00
|
|
|
if (max_size < PAGE_SIZE) {
|
|
|
|
max_size = PAGE_SIZE;
|
2008-05-01 15:35:17 +04:00
|
|
|
printk(KERN_INFO "%s: set to minimum %d\n",
|
|
|
|
__func__, max_size);
|
2008-01-29 16:53:40 +03:00
|
|
|
}
|
|
|
|
|
2019-05-21 10:01:41 +03:00
|
|
|
/* see blk_queue_virt_boundary() for the explanation */
|
|
|
|
WARN_ON_ONCE(q->limits.virt_boundary_mask);
|
|
|
|
|
2009-05-23 01:17:51 +04:00
|
|
|
q->limits.max_segment_size = max_size;
|
2008-01-29 16:53:40 +03:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(blk_queue_max_segment_size);
|
|
|
|
|
|
|
|
/**
|
2009-05-23 01:17:49 +04:00
|
|
|
* blk_queue_logical_block_size - set logical block size for the queue
|
2008-01-29 16:53:40 +03:00
|
|
|
* @q: the request queue for the device
|
2009-05-23 01:17:49 +04:00
|
|
|
* @size: the logical block size, in bytes
|
2008-01-29 16:53:40 +03:00
|
|
|
*
|
|
|
|
* Description:
|
2009-05-23 01:17:49 +04:00
|
|
|
* This should be set to the lowest possible block size that the
|
|
|
|
* storage device can address. The default of 512 covers most
|
|
|
|
* hardware.
|
2008-01-29 16:53:40 +03:00
|
|
|
**/
|
2020-01-15 16:35:25 +03:00
|
|
|
void blk_queue_logical_block_size(struct request_queue *q, unsigned int size)
|
2008-01-29 16:53:40 +03:00
|
|
|
{
|
2020-11-20 04:55:13 +03:00
|
|
|
struct queue_limits *limits = &q->limits;
|
|
|
|
|
|
|
|
limits->logical_block_size = size;
|
|
|
|
|
|
|
|
if (limits->physical_block_size < size)
|
|
|
|
limits->physical_block_size = size;
|
2009-05-23 01:17:53 +04:00
|
|
|
|
2020-11-20 04:55:13 +03:00
|
|
|
if (limits->io_min < limits->physical_block_size)
|
|
|
|
limits->io_min = limits->physical_block_size;
|
2009-05-23 01:17:53 +04:00
|
|
|
|
2020-11-20 04:55:13 +03:00
|
|
|
limits->max_hw_sectors =
|
|
|
|
round_down(limits->max_hw_sectors, size >> SECTOR_SHIFT);
|
|
|
|
limits->max_sectors =
|
|
|
|
round_down(limits->max_sectors, size >> SECTOR_SHIFT);
|
2008-01-29 16:53:40 +03:00
|
|
|
}
|
2009-05-23 01:17:49 +04:00
|
|
|
EXPORT_SYMBOL(blk_queue_logical_block_size);
|
2008-01-29 16:53:40 +03:00
|
|
|
|
2009-05-23 01:17:53 +04:00
|
|
|
/**
|
|
|
|
* blk_queue_physical_block_size - set physical block size for the queue
|
|
|
|
* @q: the request queue for the device
|
|
|
|
* @size: the physical block size, in bytes
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* This should be set to the lowest possible sector size that the
|
|
|
|
* hardware can operate on without reverting to read-modify-write
|
|
|
|
* operations.
|
|
|
|
*/
|
2010-10-13 23:18:03 +04:00
|
|
|
void blk_queue_physical_block_size(struct request_queue *q, unsigned int size)
|
2009-05-23 01:17:53 +04:00
|
|
|
{
|
|
|
|
q->limits.physical_block_size = size;
|
|
|
|
|
|
|
|
if (q->limits.physical_block_size < q->limits.logical_block_size)
|
|
|
|
q->limits.physical_block_size = q->limits.logical_block_size;
|
|
|
|
|
|
|
|
if (q->limits.io_min < q->limits.physical_block_size)
|
|
|
|
q->limits.io_min = q->limits.physical_block_size;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(blk_queue_physical_block_size);
|
|
|
|
|
2021-01-28 07:47:30 +03:00
|
|
|
/**
|
|
|
|
* blk_queue_zone_write_granularity - set zone write granularity for the queue
|
|
|
|
* @q: the request queue for the zoned device
|
|
|
|
* @size: the zone write granularity size, in bytes
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* This should be set to the lowest possible size allowing to write in
|
|
|
|
* sequential zones of a zoned block device.
|
|
|
|
*/
|
|
|
|
void blk_queue_zone_write_granularity(struct request_queue *q,
|
|
|
|
unsigned int size)
|
|
|
|
{
|
|
|
|
if (WARN_ON_ONCE(!blk_queue_is_zoned(q)))
|
|
|
|
return;
|
|
|
|
|
|
|
|
q->limits.zone_write_granularity = size;
|
|
|
|
|
|
|
|
if (q->limits.zone_write_granularity < q->limits.logical_block_size)
|
|
|
|
q->limits.zone_write_granularity = q->limits.logical_block_size;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(blk_queue_zone_write_granularity);
|
|
|
|
|
2009-05-23 01:17:53 +04:00
|
|
|
/**
|
|
|
|
* blk_queue_alignment_offset - set physical block alignment offset
|
|
|
|
* @q: the request queue for the device
|
2009-06-12 07:00:41 +04:00
|
|
|
* @offset: alignment offset in bytes
|
2009-05-23 01:17:53 +04:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Some devices are naturally misaligned to compensate for things like
|
|
|
|
* the legacy DOS partition table 63-sector offset. Low-level drivers
|
|
|
|
* should call this function for devices whose first sector is not
|
|
|
|
* naturally aligned.
|
|
|
|
*/
|
|
|
|
void blk_queue_alignment_offset(struct request_queue *q, unsigned int offset)
|
|
|
|
{
|
|
|
|
q->limits.alignment_offset =
|
|
|
|
offset & (q->limits.physical_block_size - 1);
|
|
|
|
q->limits.misaligned = 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(blk_queue_alignment_offset);
|
|
|
|
|
2020-09-24 09:51:34 +03:00
|
|
|
void blk_queue_update_readahead(struct request_queue *q)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* For read-ahead of large files to be effective, we need to read ahead
|
|
|
|
* at least twice the optimal I/O size.
|
|
|
|
*/
|
|
|
|
q->backing_dev_info->ra_pages =
|
|
|
|
max(queue_io_opt(q) * 2 / PAGE_SIZE, VM_READAHEAD_PAGES);
|
|
|
|
q->backing_dev_info->io_pages =
|
|
|
|
queue_max_sectors(q) >> (PAGE_SHIFT - 9);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(blk_queue_update_readahead);
|
|
|
|
|
2009-07-31 19:49:11 +04:00
|
|
|
/**
|
|
|
|
* blk_limits_io_min - set minimum request size for a device
|
|
|
|
* @limits: the queue limits
|
|
|
|
* @min: smallest I/O size in bytes
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Some devices have an internal block size bigger than the reported
|
|
|
|
* hardware sector size. This function can be used to signal the
|
|
|
|
* smallest I/O the device can perform without incurring a performance
|
|
|
|
* penalty.
|
|
|
|
*/
|
|
|
|
void blk_limits_io_min(struct queue_limits *limits, unsigned int min)
|
|
|
|
{
|
|
|
|
limits->io_min = min;
|
|
|
|
|
|
|
|
if (limits->io_min < limits->logical_block_size)
|
|
|
|
limits->io_min = limits->logical_block_size;
|
|
|
|
|
|
|
|
if (limits->io_min < limits->physical_block_size)
|
|
|
|
limits->io_min = limits->physical_block_size;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(blk_limits_io_min);
|
|
|
|
|
2009-05-23 01:17:53 +04:00
|
|
|
/**
|
|
|
|
* blk_queue_io_min - set minimum request size for the queue
|
|
|
|
* @q: the request queue for the device
|
2009-06-12 07:00:41 +04:00
|
|
|
* @min: smallest I/O size in bytes
|
2009-05-23 01:17:53 +04:00
|
|
|
*
|
|
|
|
* Description:
|
2009-07-31 19:49:13 +04:00
|
|
|
* Storage devices may report a granularity or preferred minimum I/O
|
|
|
|
* size which is the smallest request the device can perform without
|
|
|
|
* incurring a performance penalty. For disk drives this is often the
|
|
|
|
* physical block size. For RAID arrays it is often the stripe chunk
|
|
|
|
* size. A properly aligned multiple of minimum_io_size is the
|
|
|
|
* preferred request size for workloads where a high number of I/O
|
|
|
|
* operations is desired.
|
2009-05-23 01:17:53 +04:00
|
|
|
*/
|
|
|
|
void blk_queue_io_min(struct request_queue *q, unsigned int min)
|
|
|
|
{
|
2009-07-31 19:49:11 +04:00
|
|
|
blk_limits_io_min(&q->limits, min);
|
2009-05-23 01:17:53 +04:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(blk_queue_io_min);
|
|
|
|
|
2009-09-11 23:54:52 +04:00
|
|
|
/**
|
|
|
|
* blk_limits_io_opt - set optimal request size for a device
|
|
|
|
* @limits: the queue limits
|
|
|
|
* @opt: smallest I/O size in bytes
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Storage devices may report an optimal I/O size, which is the
|
|
|
|
* device's preferred unit for sustained I/O. This is rarely reported
|
|
|
|
* for disk drives. For RAID arrays it is usually the stripe width or
|
|
|
|
* the internal track size. A properly aligned multiple of
|
|
|
|
* optimal_io_size is the preferred request size for workloads where
|
|
|
|
* sustained throughput is desired.
|
|
|
|
*/
|
|
|
|
void blk_limits_io_opt(struct queue_limits *limits, unsigned int opt)
|
|
|
|
{
|
|
|
|
limits->io_opt = opt;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(blk_limits_io_opt);
|
|
|
|
|
2009-05-23 01:17:53 +04:00
|
|
|
/**
|
|
|
|
* blk_queue_io_opt - set optimal request size for the queue
|
|
|
|
* @q: the request queue for the device
|
2009-06-12 07:00:41 +04:00
|
|
|
* @opt: optimal request size in bytes
|
2009-05-23 01:17:53 +04:00
|
|
|
*
|
|
|
|
* Description:
|
2009-07-31 19:49:13 +04:00
|
|
|
* Storage devices may report an optimal I/O size, which is the
|
|
|
|
* device's preferred unit for sustained I/O. This is rarely reported
|
|
|
|
* for disk drives. For RAID arrays it is usually the stripe width or
|
|
|
|
* the internal track size. A properly aligned multiple of
|
|
|
|
* optimal_io_size is the preferred request size for workloads where
|
|
|
|
* sustained throughput is desired.
|
2009-05-23 01:17:53 +04:00
|
|
|
*/
|
|
|
|
void blk_queue_io_opt(struct request_queue *q, unsigned int opt)
|
|
|
|
{
|
2009-09-11 23:54:52 +04:00
|
|
|
blk_limits_io_opt(&q->limits, opt);
|
2020-09-24 09:51:34 +03:00
|
|
|
q->backing_dev_info->ra_pages =
|
|
|
|
max(queue_io_opt(q) * 2 / PAGE_SIZE, VM_READAHEAD_PAGES);
|
2009-05-23 01:17:53 +04:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(blk_queue_io_opt);
|
|
|
|
|
blk-settings: align max_sectors on "logical_block_size" boundary
We get I/O errors when we run md-raid1 on the top of dm-integrity on the
top of ramdisk.
device-mapper: integrity: Bio not aligned on 8 sectors: 0xff00, 0xff
device-mapper: integrity: Bio not aligned on 8 sectors: 0xff00, 0xff
device-mapper: integrity: Bio not aligned on 8 sectors: 0xffff, 0x1
device-mapper: integrity: Bio not aligned on 8 sectors: 0xffff, 0x1
device-mapper: integrity: Bio not aligned on 8 sectors: 0x8048, 0xff
device-mapper: integrity: Bio not aligned on 8 sectors: 0x8147, 0xff
device-mapper: integrity: Bio not aligned on 8 sectors: 0x8246, 0xff
device-mapper: integrity: Bio not aligned on 8 sectors: 0x8345, 0xbb
The ramdisk device has logical_block_size 512 and max_sectors 255. The
dm-integrity device uses logical_block_size 4096 and it doesn't affect the
"max_sectors" value - thus, it inherits 255 from the ramdisk. So, we have
a device with max_sectors not aligned on logical_block_size.
The md-raid device sees that the underlying leg has max_sectors 255 and it
will split the bios on 255-sector boundary, making the bios unaligned on
logical_block_size.
In order to fix the bug, we round down max_sectors to logical_block_size.
Cc: stable@vger.kernel.org
Reviewed-by: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2021-02-24 05:25:30 +03:00
|
|
|
static unsigned int blk_round_down_sectors(unsigned int sectors, unsigned int lbs)
|
|
|
|
{
|
|
|
|
sectors = round_down(sectors, lbs >> SECTOR_SHIFT);
|
|
|
|
if (sectors < PAGE_SIZE >> SECTOR_SHIFT)
|
|
|
|
sectors = PAGE_SIZE >> SECTOR_SHIFT;
|
|
|
|
return sectors;
|
|
|
|
}
|
|
|
|
|
2009-05-23 01:17:53 +04:00
|
|
|
/**
|
|
|
|
* blk_stack_limits - adjust queue_limits for stacked devices
|
2009-12-29 10:35:35 +03:00
|
|
|
* @t: the stacking driver limits (top device)
|
|
|
|
* @b: the underlying queue limits (bottom, component device)
|
2010-01-11 11:21:51 +03:00
|
|
|
* @start: first data sector within component device
|
2009-05-23 01:17:53 +04:00
|
|
|
*
|
|
|
|
* Description:
|
2009-12-29 10:35:35 +03:00
|
|
|
* This function is used by stacking drivers like MD and DM to ensure
|
|
|
|
* that all component devices have compatible block sizes and
|
|
|
|
* alignments. The stacking driver must provide a queue_limits
|
|
|
|
* struct (top) and then iteratively call the stacking function for
|
|
|
|
* all component (bottom) devices. The stacking function will
|
|
|
|
* attempt to combine the values and ensure proper alignment.
|
|
|
|
*
|
|
|
|
* Returns 0 if the top and bottom queue_limits are compatible. The
|
|
|
|
* top device's block sizes and alignment offsets may be adjusted to
|
|
|
|
* ensure alignment with the bottom device. If no compatible sizes
|
|
|
|
* and alignments exist, -1 is returned and the resulting top
|
|
|
|
* queue_limits will have the misaligned flag set to indicate that
|
|
|
|
* the alignment_offset is undefined.
|
2009-05-23 01:17:53 +04:00
|
|
|
*/
|
|
|
|
int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
|
2010-01-11 11:21:51 +03:00
|
|
|
sector_t start)
|
2009-05-23 01:17:53 +04:00
|
|
|
{
|
2010-01-11 11:21:51 +03:00
|
|
|
unsigned int top, bottom, alignment, ret = 0;
|
2009-11-10 13:50:21 +03:00
|
|
|
|
2009-05-23 01:17:53 +04:00
|
|
|
t->max_sectors = min_not_zero(t->max_sectors, b->max_sectors);
|
|
|
|
t->max_hw_sectors = min_not_zero(t->max_hw_sectors, b->max_hw_sectors);
|
2015-11-14 00:46:48 +03:00
|
|
|
t->max_dev_sectors = min_not_zero(t->max_dev_sectors, b->max_dev_sectors);
|
2012-09-18 20:19:27 +04:00
|
|
|
t->max_write_same_sectors = min(t->max_write_same_sectors,
|
|
|
|
b->max_write_same_sectors);
|
2016-11-30 23:28:59 +03:00
|
|
|
t->max_write_zeroes_sectors = min(t->max_write_zeroes_sectors,
|
|
|
|
b->max_write_zeroes_sectors);
|
2020-05-12 11:55:47 +03:00
|
|
|
t->max_zone_append_sectors = min(t->max_zone_append_sectors,
|
|
|
|
b->max_zone_append_sectors);
|
2009-06-09 08:23:22 +04:00
|
|
|
t->bounce_pfn = min_not_zero(t->bounce_pfn, b->bounce_pfn);
|
2009-05-23 01:17:53 +04:00
|
|
|
|
|
|
|
t->seg_boundary_mask = min_not_zero(t->seg_boundary_mask,
|
|
|
|
b->seg_boundary_mask);
|
2015-08-20 00:24:05 +03:00
|
|
|
t->virt_boundary_mask = min_not_zero(t->virt_boundary_mask,
|
|
|
|
b->virt_boundary_mask);
|
2009-05-23 01:17:53 +04:00
|
|
|
|
2010-02-26 08:20:39 +03:00
|
|
|
t->max_segments = min_not_zero(t->max_segments, b->max_segments);
|
2017-02-08 16:46:49 +03:00
|
|
|
t->max_discard_segments = min_not_zero(t->max_discard_segments,
|
|
|
|
b->max_discard_segments);
|
2010-09-10 22:50:10 +04:00
|
|
|
t->max_integrity_segments = min_not_zero(t->max_integrity_segments,
|
|
|
|
b->max_integrity_segments);
|
2009-05-23 01:17:53 +04:00
|
|
|
|
|
|
|
t->max_segment_size = min_not_zero(t->max_segment_size,
|
|
|
|
b->max_segment_size);
|
|
|
|
|
2010-01-11 11:21:47 +03:00
|
|
|
t->misaligned |= b->misaligned;
|
|
|
|
|
2010-01-11 11:21:51 +03:00
|
|
|
alignment = queue_limit_alignment_offset(b, start);
|
2009-12-21 17:55:51 +03:00
|
|
|
|
2009-12-29 10:35:35 +03:00
|
|
|
/* Bottom device has different alignment. Check that it is
|
|
|
|
* compatible with the current top alignment.
|
|
|
|
*/
|
2009-12-21 17:55:51 +03:00
|
|
|
if (t->alignment_offset != alignment) {
|
|
|
|
|
|
|
|
top = max(t->physical_block_size, t->io_min)
|
|
|
|
+ t->alignment_offset;
|
2009-12-29 10:35:35 +03:00
|
|
|
bottom = max(b->physical_block_size, b->io_min) + alignment;
|
2009-12-21 17:55:51 +03:00
|
|
|
|
2009-12-29 10:35:35 +03:00
|
|
|
/* Verify that top and bottom intervals line up */
|
2014-10-09 02:26:13 +04:00
|
|
|
if (max(top, bottom) % min(top, bottom)) {
|
2009-12-21 17:55:51 +03:00
|
|
|
t->misaligned = 1;
|
2010-01-11 11:21:47 +03:00
|
|
|
ret = -1;
|
|
|
|
}
|
2009-12-21 17:55:51 +03:00
|
|
|
}
|
|
|
|
|
2009-05-23 01:17:53 +04:00
|
|
|
t->logical_block_size = max(t->logical_block_size,
|
|
|
|
b->logical_block_size);
|
|
|
|
|
|
|
|
t->physical_block_size = max(t->physical_block_size,
|
|
|
|
b->physical_block_size);
|
|
|
|
|
|
|
|
t->io_min = max(t->io_min, b->io_min);
|
2015-03-30 20:39:09 +03:00
|
|
|
t->io_opt = lcm_not_zero(t->io_opt, b->io_opt);
|
2020-12-01 19:07:09 +03:00
|
|
|
|
|
|
|
/* Set non-power-of-2 compatible chunk_sectors boundary */
|
|
|
|
if (b->chunk_sectors)
|
|
|
|
t->chunk_sectors = gcd(t->chunk_sectors, b->chunk_sectors);
|
2009-12-21 17:55:51 +03:00
|
|
|
|
2009-12-29 10:35:35 +03:00
|
|
|
/* Physical block size a multiple of the logical block size? */
|
2009-12-21 17:55:51 +03:00
|
|
|
if (t->physical_block_size & (t->logical_block_size - 1)) {
|
|
|
|
t->physical_block_size = t->logical_block_size;
|
2009-05-23 01:17:53 +04:00
|
|
|
t->misaligned = 1;
|
2010-01-11 11:21:47 +03:00
|
|
|
ret = -1;
|
2009-11-10 13:50:21 +03:00
|
|
|
}
|
|
|
|
|
2009-12-29 10:35:35 +03:00
|
|
|
/* Minimum I/O a multiple of the physical block size? */
|
2009-12-21 17:55:51 +03:00
|
|
|
if (t->io_min & (t->physical_block_size - 1)) {
|
|
|
|
t->io_min = t->physical_block_size;
|
|
|
|
t->misaligned = 1;
|
2010-01-11 11:21:47 +03:00
|
|
|
ret = -1;
|
2009-05-23 01:17:53 +04:00
|
|
|
}
|
|
|
|
|
2009-12-29 10:35:35 +03:00
|
|
|
/* Optimal I/O a multiple of the physical block size? */
|
2009-12-21 17:55:51 +03:00
|
|
|
if (t->io_opt & (t->physical_block_size - 1)) {
|
|
|
|
t->io_opt = 0;
|
|
|
|
t->misaligned = 1;
|
2010-01-11 11:21:47 +03:00
|
|
|
ret = -1;
|
2009-12-21 17:55:51 +03:00
|
|
|
}
|
2009-05-23 01:17:53 +04:00
|
|
|
|
2020-09-22 05:32:48 +03:00
|
|
|
/* chunk_sectors a multiple of the physical block size? */
|
|
|
|
if ((t->chunk_sectors << 9) & (t->physical_block_size - 1)) {
|
|
|
|
t->chunk_sectors = 0;
|
|
|
|
t->misaligned = 1;
|
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
|
2013-07-12 09:39:53 +04:00
|
|
|
t->raid_partial_stripes_expensive =
|
|
|
|
max(t->raid_partial_stripes_expensive,
|
|
|
|
b->raid_partial_stripes_expensive);
|
|
|
|
|
2009-12-29 10:35:35 +03:00
|
|
|
/* Find lowest common alignment_offset */
|
2015-03-30 20:39:09 +03:00
|
|
|
t->alignment_offset = lcm_not_zero(t->alignment_offset, alignment)
|
2014-10-09 02:26:13 +04:00
|
|
|
% max(t->physical_block_size, t->io_min);
|
2009-11-10 13:50:21 +03:00
|
|
|
|
2009-12-29 10:35:35 +03:00
|
|
|
/* Verify that new alignment_offset is on a logical block boundary */
|
2010-01-11 11:21:47 +03:00
|
|
|
if (t->alignment_offset & (t->logical_block_size - 1)) {
|
2009-05-23 01:17:53 +04:00
|
|
|
t->misaligned = 1;
|
2010-01-11 11:21:47 +03:00
|
|
|
ret = -1;
|
|
|
|
}
|
2009-05-23 01:17:53 +04:00
|
|
|
|
blk-settings: align max_sectors on "logical_block_size" boundary
We get I/O errors when we run md-raid1 on the top of dm-integrity on the
top of ramdisk.
device-mapper: integrity: Bio not aligned on 8 sectors: 0xff00, 0xff
device-mapper: integrity: Bio not aligned on 8 sectors: 0xff00, 0xff
device-mapper: integrity: Bio not aligned on 8 sectors: 0xffff, 0x1
device-mapper: integrity: Bio not aligned on 8 sectors: 0xffff, 0x1
device-mapper: integrity: Bio not aligned on 8 sectors: 0x8048, 0xff
device-mapper: integrity: Bio not aligned on 8 sectors: 0x8147, 0xff
device-mapper: integrity: Bio not aligned on 8 sectors: 0x8246, 0xff
device-mapper: integrity: Bio not aligned on 8 sectors: 0x8345, 0xbb
The ramdisk device has logical_block_size 512 and max_sectors 255. The
dm-integrity device uses logical_block_size 4096 and it doesn't affect the
"max_sectors" value - thus, it inherits 255 from the ramdisk. So, we have
a device with max_sectors not aligned on logical_block_size.
The md-raid device sees that the underlying leg has max_sectors 255 and it
will split the bios on 255-sector boundary, making the bios unaligned on
logical_block_size.
In order to fix the bug, we round down max_sectors to logical_block_size.
Cc: stable@vger.kernel.org
Reviewed-by: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2021-02-24 05:25:30 +03:00
|
|
|
t->max_sectors = blk_round_down_sectors(t->max_sectors, t->logical_block_size);
|
|
|
|
t->max_hw_sectors = blk_round_down_sectors(t->max_hw_sectors, t->logical_block_size);
|
|
|
|
t->max_dev_sectors = blk_round_down_sectors(t->max_dev_sectors, t->logical_block_size);
|
|
|
|
|
2009-12-21 17:55:51 +03:00
|
|
|
/* Discard alignment and granularity */
|
|
|
|
if (b->discard_granularity) {
|
2010-01-11 11:21:51 +03:00
|
|
|
alignment = queue_limit_discard_alignment(b, start);
|
2009-12-21 17:55:51 +03:00
|
|
|
|
|
|
|
if (t->discard_granularity != 0 &&
|
|
|
|
t->discard_alignment != alignment) {
|
|
|
|
top = t->discard_granularity + t->discard_alignment;
|
|
|
|
bottom = b->discard_granularity + alignment;
|
2009-07-31 19:49:12 +04:00
|
|
|
|
2009-12-21 17:55:51 +03:00
|
|
|
/* Verify that top and bottom intervals line up */
|
2012-12-14 07:15:36 +04:00
|
|
|
if ((max(top, bottom) % min(top, bottom)) != 0)
|
2009-12-21 17:55:51 +03:00
|
|
|
t->discard_misaligned = 1;
|
|
|
|
}
|
|
|
|
|
2009-12-29 10:35:35 +03:00
|
|
|
t->max_discard_sectors = min_not_zero(t->max_discard_sectors,
|
|
|
|
b->max_discard_sectors);
|
2015-07-16 18:14:26 +03:00
|
|
|
t->max_hw_discard_sectors = min_not_zero(t->max_hw_discard_sectors,
|
|
|
|
b->max_hw_discard_sectors);
|
2009-12-21 17:55:51 +03:00
|
|
|
t->discard_granularity = max(t->discard_granularity,
|
|
|
|
b->discard_granularity);
|
2015-03-30 20:39:09 +03:00
|
|
|
t->discard_alignment = lcm_not_zero(t->discard_alignment, alignment) %
|
2012-12-14 07:15:36 +04:00
|
|
|
t->discard_granularity;
|
2009-12-21 17:55:51 +03:00
|
|
|
}
|
2009-07-31 19:49:12 +04:00
|
|
|
|
2021-01-28 07:47:30 +03:00
|
|
|
t->zone_write_granularity = max(t->zone_write_granularity,
|
|
|
|
b->zone_write_granularity);
|
2020-07-20 09:12:49 +03:00
|
|
|
t->zoned = max(t->zoned, b->zoned);
|
2010-01-11 11:21:47 +03:00
|
|
|
return ret;
|
2009-05-23 01:17:53 +04:00
|
|
|
}
|
2009-05-28 13:04:53 +04:00
|
|
|
EXPORT_SYMBOL(blk_stack_limits);
|
2009-05-23 01:17:53 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* disk_stack_limits - adjust queue limits for stacked drivers
|
2009-06-09 08:23:22 +04:00
|
|
|
* @disk: MD/DM gendisk (top)
|
2009-05-23 01:17:53 +04:00
|
|
|
* @bdev: the underlying block device (bottom)
|
|
|
|
* @offset: offset to beginning of data within component device
|
|
|
|
*
|
|
|
|
* Description:
|
2010-01-11 11:21:51 +03:00
|
|
|
* Merges the limits for a top level gendisk and a bottom level
|
|
|
|
* block_device.
|
2009-05-23 01:17:53 +04:00
|
|
|
*/
|
|
|
|
void disk_stack_limits(struct gendisk *disk, struct block_device *bdev,
|
|
|
|
sector_t offset)
|
|
|
|
{
|
|
|
|
struct request_queue *t = disk->queue;
|
|
|
|
|
2020-07-20 09:12:50 +03:00
|
|
|
if (blk_stack_limits(&t->limits, &bdev_get_queue(bdev)->limits,
|
|
|
|
get_start_sect(bdev) + (offset >> 9)) < 0) {
|
2009-05-23 01:17:53 +04:00
|
|
|
char top[BDEVNAME_SIZE], bottom[BDEVNAME_SIZE];
|
|
|
|
|
|
|
|
disk_name(disk, 0, top);
|
|
|
|
bdevname(bdev, bottom);
|
|
|
|
|
|
|
|
printk(KERN_NOTICE "%s: Warning: Device %s is misaligned\n",
|
|
|
|
top, bottom);
|
|
|
|
}
|
2020-02-28 17:51:48 +03:00
|
|
|
|
2020-09-24 09:51:34 +03:00
|
|
|
blk_queue_update_readahead(disk->queue);
|
2009-05-23 01:17:53 +04:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(disk_stack_limits);
|
|
|
|
|
2008-07-04 11:30:03 +04:00
|
|
|
/**
|
|
|
|
* blk_queue_update_dma_pad - update pad mask
|
|
|
|
* @q: the request queue for the device
|
|
|
|
* @mask: pad mask
|
|
|
|
*
|
|
|
|
* Update dma pad mask.
|
|
|
|
*
|
|
|
|
* Appending pad buffer to a request modifies the last entry of a
|
|
|
|
* scatter list such that it includes the pad buffer.
|
|
|
|
**/
|
|
|
|
void blk_queue_update_dma_pad(struct request_queue *q, unsigned int mask)
|
|
|
|
{
|
|
|
|
if (mask > q->dma_pad_mask)
|
|
|
|
q->dma_pad_mask = mask;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(blk_queue_update_dma_pad);
|
|
|
|
|
2008-01-29 16:53:40 +03:00
|
|
|
/**
|
|
|
|
* blk_queue_segment_boundary - set boundary rules for segment merging
|
|
|
|
* @q: the request queue for the device
|
|
|
|
* @mask: the memory boundary mask
|
|
|
|
**/
|
|
|
|
void blk_queue_segment_boundary(struct request_queue *q, unsigned long mask)
|
|
|
|
{
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 15:29:47 +03:00
|
|
|
if (mask < PAGE_SIZE - 1) {
|
|
|
|
mask = PAGE_SIZE - 1;
|
2008-05-01 15:35:17 +04:00
|
|
|
printk(KERN_INFO "%s: set to minimum %lx\n",
|
|
|
|
__func__, mask);
|
2008-01-29 16:53:40 +03:00
|
|
|
}
|
|
|
|
|
2009-05-23 01:17:51 +04:00
|
|
|
q->limits.seg_boundary_mask = mask;
|
2008-01-29 16:53:40 +03:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(blk_queue_segment_boundary);
|
|
|
|
|
2015-08-20 00:24:05 +03:00
|
|
|
/**
|
|
|
|
* blk_queue_virt_boundary - set boundary rules for bio merging
|
|
|
|
* @q: the request queue for the device
|
|
|
|
* @mask: the memory boundary mask
|
|
|
|
**/
|
|
|
|
void blk_queue_virt_boundary(struct request_queue *q, unsigned long mask)
|
|
|
|
{
|
|
|
|
q->limits.virt_boundary_mask = mask;
|
2019-05-21 10:01:41 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Devices that require a virtual boundary do not support scatter/gather
|
|
|
|
* I/O natively, but instead require a descriptor list entry for each
|
|
|
|
* page (which might not be idential to the Linux PAGE_SIZE). Because
|
|
|
|
* of that they are not limited by our notion of "segment size".
|
|
|
|
*/
|
2019-07-24 19:26:56 +03:00
|
|
|
if (mask)
|
|
|
|
q->limits.max_segment_size = UINT_MAX;
|
2015-08-20 00:24:05 +03:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(blk_queue_virt_boundary);
|
|
|
|
|
2008-01-29 16:53:40 +03:00
|
|
|
/**
|
|
|
|
* blk_queue_dma_alignment - set dma length and memory alignment
|
|
|
|
* @q: the request queue for the device
|
|
|
|
* @mask: alignment mask
|
|
|
|
*
|
|
|
|
* description:
|
2008-08-19 22:13:11 +04:00
|
|
|
* set required memory and length alignment for direct dma transactions.
|
2009-04-01 18:01:39 +04:00
|
|
|
* this is used when building direct io requests for the queue.
|
2008-01-29 16:53:40 +03:00
|
|
|
*
|
|
|
|
**/
|
|
|
|
void blk_queue_dma_alignment(struct request_queue *q, int mask)
|
|
|
|
{
|
|
|
|
q->dma_alignment = mask;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(blk_queue_dma_alignment);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* blk_queue_update_dma_alignment - update dma length and memory alignment
|
|
|
|
* @q: the request queue for the device
|
|
|
|
* @mask: alignment mask
|
|
|
|
*
|
|
|
|
* description:
|
2008-08-19 22:13:11 +04:00
|
|
|
* update required memory and length alignment for direct dma transactions.
|
2008-01-29 16:53:40 +03:00
|
|
|
* If the requested alignment is larger than the current alignment, then
|
|
|
|
* the current queue alignment is updated to the new value, otherwise it
|
|
|
|
* is left alone. The design of this is to allow multiple objects
|
|
|
|
* (driver, device, transport etc) to set their respective
|
|
|
|
* alignments without having them interfere.
|
|
|
|
*
|
|
|
|
**/
|
|
|
|
void blk_queue_update_dma_alignment(struct request_queue *q, int mask)
|
|
|
|
{
|
|
|
|
BUG_ON(mask > PAGE_SIZE);
|
|
|
|
|
|
|
|
if (mask > q->dma_alignment)
|
|
|
|
q->dma_alignment = mask;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(blk_queue_update_dma_alignment);
|
|
|
|
|
2016-03-30 19:21:08 +03:00
|
|
|
/**
|
|
|
|
* blk_set_queue_depth - tell the block layer about the device queue depth
|
|
|
|
* @q: the request queue for the device
|
|
|
|
* @depth: queue depth
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void blk_set_queue_depth(struct request_queue *q, unsigned int depth)
|
|
|
|
{
|
|
|
|
q->queue_depth = depth;
|
2019-08-29 01:05:55 +03:00
|
|
|
rq_qos_queue_depth_changed(q);
|
2016-03-30 19:21:08 +03:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(blk_set_queue_depth);
|
|
|
|
|
2016-04-12 21:32:46 +03:00
|
|
|
/**
|
|
|
|
* blk_queue_write_cache - configure queue's write cache
|
|
|
|
* @q: the request queue for the device
|
|
|
|
* @wc: write back cache on or off
|
|
|
|
* @fua: device supports FUA writes, if true
|
|
|
|
*
|
|
|
|
* Tell the block layer about the write cache of @q.
|
|
|
|
*/
|
|
|
|
void blk_queue_write_cache(struct request_queue *q, bool wc, bool fua)
|
|
|
|
{
|
2016-04-13 22:33:19 +03:00
|
|
|
if (wc)
|
2018-11-14 19:02:07 +03:00
|
|
|
blk_queue_flag_set(QUEUE_FLAG_WC, q);
|
2016-04-13 22:33:19 +03:00
|
|
|
else
|
2018-11-14 19:02:07 +03:00
|
|
|
blk_queue_flag_clear(QUEUE_FLAG_WC, q);
|
2016-04-13 22:33:19 +03:00
|
|
|
if (fua)
|
2018-11-14 19:02:07 +03:00
|
|
|
blk_queue_flag_set(QUEUE_FLAG_FUA, q);
|
2016-04-13 22:33:19 +03:00
|
|
|
else
|
2018-11-14 19:02:07 +03:00
|
|
|
blk_queue_flag_clear(QUEUE_FLAG_FUA, q);
|
block: hook up writeback throttling
Enable throttling of buffered writeback to make it a lot
more smooth, and has way less impact on other system activity.
Background writeback should be, by definition, background
activity. The fact that we flush huge bundles of it at the time
means that it potentially has heavy impacts on foreground workloads,
which isn't ideal. We can't easily limit the sizes of writes that
we do, since that would impact file system layout in the presence
of delayed allocation. So just throttle back buffered writeback,
unless someone is waiting for it.
The algorithm for when to throttle takes its inspiration in the
CoDel networking scheduling algorithm. Like CoDel, blk-wb monitors
the minimum latencies of requests over a window of time. In that
window of time, if the minimum latency of any request exceeds a
given target, then a scale count is incremented and the queue depth
is shrunk. The next monitoring window is shrunk accordingly. Unlike
CoDel, if we hit a window that exhibits good behavior, then we
simply increment the scale count and re-calculate the limits for that
scale value. This prevents us from oscillating between a
close-to-ideal value and max all the time, instead remaining in the
windows where we get good behavior.
Unlike CoDel, blk-wb allows the scale count to to negative. This
happens if we primarily have writes going on. Unlike positive
scale counts, this doesn't change the size of the monitoring window.
When the heavy writers finish, blk-bw quickly snaps back to it's
stable state of a zero scale count.
The patch registers a sysfs entry, 'wb_lat_usec'. This sets the latency
target to me met. It defaults to 2 msec for non-rotational storage, and
75 msec for rotational storage. Setting this value to '0' disables
blk-wb. Generally, a user would not have to touch this setting.
We don't enable WBT on devices that are managed with CFQ, and have
a non-root block cgroup attached. If we have a proportional share setup
on this particular disk, then the wbt throttling will interfere with
that. We don't have a strong need for wbt for that case, since we will
rely on CFQ doing that for us.
Signed-off-by: Jens Axboe <axboe@fb.com>
2016-11-09 22:38:14 +03:00
|
|
|
|
2018-07-03 18:32:35 +03:00
|
|
|
wbt_set_write_cache(q, test_bit(QUEUE_FLAG_WC, &q->queue_flags));
|
2016-04-12 21:32:46 +03:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(blk_queue_write_cache);
|
|
|
|
|
2019-09-05 12:51:31 +03:00
|
|
|
/**
|
|
|
|
* blk_queue_required_elevator_features - Set a queue required elevator features
|
|
|
|
* @q: the request queue for the target device
|
|
|
|
* @features: Required elevator features OR'ed together
|
|
|
|
*
|
|
|
|
* Tell the block layer that for the device controlled through @q, only the
|
|
|
|
* only elevators that can be used are those that implement at least the set of
|
|
|
|
* features specified by @features.
|
|
|
|
*/
|
|
|
|
void blk_queue_required_elevator_features(struct request_queue *q,
|
|
|
|
unsigned int features)
|
|
|
|
{
|
|
|
|
q->required_elevator_features = features;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(blk_queue_required_elevator_features);
|
|
|
|
|
2019-08-28 15:35:42 +03:00
|
|
|
/**
|
|
|
|
* blk_queue_can_use_dma_map_merging - configure queue for merging segments.
|
|
|
|
* @q: the request queue for the device
|
|
|
|
* @dev: the device pointer for dma
|
|
|
|
*
|
|
|
|
* Tell the block layer about merging the segments by dma map of @q.
|
|
|
|
*/
|
|
|
|
bool blk_queue_can_use_dma_map_merging(struct request_queue *q,
|
|
|
|
struct device *dev)
|
|
|
|
{
|
|
|
|
unsigned long boundary = dma_get_merge_boundary(dev);
|
|
|
|
|
|
|
|
if (!boundary)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* No need to update max_segment_size. see blk_queue_virt_boundary() */
|
|
|
|
blk_queue_virt_boundary(q, boundary);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(blk_queue_can_use_dma_map_merging);
|
|
|
|
|
2020-09-15 10:33:46 +03:00
|
|
|
/**
|
|
|
|
* blk_queue_set_zoned - configure a disk queue zoned model.
|
|
|
|
* @disk: the gendisk of the queue to configure
|
|
|
|
* @model: the zoned model to set
|
|
|
|
*
|
|
|
|
* Set the zoned model of the request queue of @disk according to @model.
|
|
|
|
* When @model is BLK_ZONED_HM (host managed), this should be called only
|
|
|
|
* if zoned block device support is enabled (CONFIG_BLK_DEV_ZONED option).
|
|
|
|
* If @model specifies BLK_ZONED_HA (host aware), the effective model used
|
|
|
|
* depends on CONFIG_BLK_DEV_ZONED settings and on the existence of partitions
|
|
|
|
* on the disk.
|
|
|
|
*/
|
|
|
|
void blk_queue_set_zoned(struct gendisk *disk, enum blk_zoned_model model)
|
|
|
|
{
|
2021-01-28 07:47:30 +03:00
|
|
|
struct request_queue *q = disk->queue;
|
|
|
|
|
2020-09-15 10:33:46 +03:00
|
|
|
switch (model) {
|
|
|
|
case BLK_ZONED_HM:
|
|
|
|
/*
|
|
|
|
* Host managed devices are supported only if
|
|
|
|
* CONFIG_BLK_DEV_ZONED is enabled.
|
|
|
|
*/
|
|
|
|
WARN_ON_ONCE(!IS_ENABLED(CONFIG_BLK_DEV_ZONED));
|
|
|
|
break;
|
|
|
|
case BLK_ZONED_HA:
|
|
|
|
/*
|
|
|
|
* Host aware devices can be treated either as regular block
|
|
|
|
* devices (similar to drive managed devices) or as zoned block
|
|
|
|
* devices to take advantage of the zone command set, similarly
|
|
|
|
* to host managed devices. We try the latter if there are no
|
|
|
|
* partitions and zoned block device support is enabled, else
|
|
|
|
* we do nothing special as far as the block layer is concerned.
|
|
|
|
*/
|
|
|
|
if (!IS_ENABLED(CONFIG_BLK_DEV_ZONED) ||
|
2021-01-24 13:02:41 +03:00
|
|
|
!xa_empty(&disk->part_tbl))
|
2020-09-15 10:33:46 +03:00
|
|
|
model = BLK_ZONED_NONE;
|
|
|
|
break;
|
|
|
|
case BLK_ZONED_NONE:
|
|
|
|
default:
|
|
|
|
if (WARN_ON_ONCE(model != BLK_ZONED_NONE))
|
|
|
|
model = BLK_ZONED_NONE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2021-01-28 07:47:30 +03:00
|
|
|
q->limits.zoned = model;
|
|
|
|
if (model != BLK_ZONED_NONE) {
|
|
|
|
/*
|
|
|
|
* Set the zone write granularity to the device logical block
|
|
|
|
* size by default. The driver can change this value if needed.
|
|
|
|
*/
|
|
|
|
blk_queue_zone_write_granularity(q,
|
|
|
|
queue_logical_block_size(q));
|
2021-01-28 07:47:32 +03:00
|
|
|
} else {
|
|
|
|
blk_queue_clear_zone_settings(q);
|
2021-01-28 07:47:30 +03:00
|
|
|
}
|
2020-09-15 10:33:46 +03:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(blk_queue_set_zoned);
|
|
|
|
|
2008-08-28 11:27:42 +04:00
|
|
|
static int __init blk_settings_init(void)
|
2008-01-29 16:53:40 +03:00
|
|
|
{
|
|
|
|
blk_max_low_pfn = max_low_pfn - 1;
|
|
|
|
blk_max_pfn = max_pfn - 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
subsys_initcall(blk_settings_init);
|