]>
git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - block/blk-lib.c
1 // SPDX-License-Identifier: GPL-2.0
3 * Functions related to generic helpers functions
5 #include <linux/kernel.h>
6 #include <linux/module.h>
8 #include <linux/blkdev.h>
9 #include <linux/scatterlist.h>
13 static struct bio
*next_bio(struct bio
*bio
, unsigned int nr_pages
,
16 struct bio
*new = bio_alloc(gfp
, nr_pages
);
26 int __blkdev_issue_discard(struct block_device
*bdev
, sector_t sector
,
27 sector_t nr_sects
, gfp_t gfp_mask
, int flags
,
30 struct request_queue
*q
= bdev_get_queue(bdev
);
31 struct bio
*bio
= *biop
;
38 if (flags
& BLKDEV_DISCARD_SECURE
) {
39 if (!blk_queue_secure_erase(q
))
41 op
= REQ_OP_SECURE_ERASE
;
43 if (!blk_queue_discard(q
))
48 bs_mask
= (bdev_logical_block_size(bdev
) >> 9) - 1;
49 if ((sector
| nr_sects
) & bs_mask
)
56 sector_t req_sects
= min_t(sector_t
, nr_sects
,
57 bio_allowed_max_sectors(q
));
59 WARN_ON_ONCE((req_sects
<< 9) > UINT_MAX
);
61 bio
= next_bio(bio
, 0, gfp_mask
);
62 bio
->bi_iter
.bi_sector
= sector
;
63 bio_set_dev(bio
, bdev
);
64 bio_set_op_attrs(bio
, op
, 0);
66 bio
->bi_iter
.bi_size
= req_sects
<< 9;
68 nr_sects
-= req_sects
;
71 * We can loop for a long time in here, if someone does
72 * full device discards (like mkfs). Be nice and allow
73 * us to schedule out to avoid softlocking if preempt
82 EXPORT_SYMBOL(__blkdev_issue_discard
);
85 * blkdev_issue_discard - queue a discard
86 * @bdev: blockdev to issue discard for
87 * @sector: start sector
88 * @nr_sects: number of sectors to discard
89 * @gfp_mask: memory allocation flags (for bio_alloc)
90 * @flags: BLKDEV_DISCARD_* flags to control behaviour
93 * Issue a discard request for the sectors in question.
95 int blkdev_issue_discard(struct block_device
*bdev
, sector_t sector
,
96 sector_t nr_sects
, gfp_t gfp_mask
, unsigned long flags
)
98 struct bio
*bio
= NULL
;
102 blk_start_plug(&plug
);
103 ret
= __blkdev_issue_discard(bdev
, sector
, nr_sects
, gfp_mask
, flags
,
106 ret
= submit_bio_wait(bio
);
107 if (ret
== -EOPNOTSUPP
)
111 blk_finish_plug(&plug
);
115 EXPORT_SYMBOL(blkdev_issue_discard
);
118 * __blkdev_issue_write_same - generate number of bios with same page
119 * @bdev: target blockdev
120 * @sector: start sector
121 * @nr_sects: number of sectors to write
122 * @gfp_mask: memory allocation flags (for bio_alloc)
123 * @page: page containing data to write
124 * @biop: pointer to anchor bio
127 * Generate and issue number of bios(REQ_OP_WRITE_SAME) with same page.
129 static int __blkdev_issue_write_same(struct block_device
*bdev
, sector_t sector
,
130 sector_t nr_sects
, gfp_t gfp_mask
, struct page
*page
,
133 struct request_queue
*q
= bdev_get_queue(bdev
);
134 unsigned int max_write_same_sectors
;
135 struct bio
*bio
= *biop
;
141 bs_mask
= (bdev_logical_block_size(bdev
) >> 9) - 1;
142 if ((sector
| nr_sects
) & bs_mask
)
145 if (!bdev_write_same(bdev
))
148 /* Ensure that max_write_same_sectors doesn't overflow bi_size */
149 max_write_same_sectors
= bio_allowed_max_sectors(q
);
152 bio
= next_bio(bio
, 1, gfp_mask
);
153 bio
->bi_iter
.bi_sector
= sector
;
154 bio_set_dev(bio
, bdev
);
156 bio
->bi_io_vec
->bv_page
= page
;
157 bio
->bi_io_vec
->bv_offset
= 0;
158 bio
->bi_io_vec
->bv_len
= bdev_logical_block_size(bdev
);
159 bio_set_op_attrs(bio
, REQ_OP_WRITE_SAME
, 0);
161 if (nr_sects
> max_write_same_sectors
) {
162 bio
->bi_iter
.bi_size
= max_write_same_sectors
<< 9;
163 nr_sects
-= max_write_same_sectors
;
164 sector
+= max_write_same_sectors
;
166 bio
->bi_iter
.bi_size
= nr_sects
<< 9;
177 * blkdev_issue_write_same - queue a write same operation
178 * @bdev: target blockdev
179 * @sector: start sector
180 * @nr_sects: number of sectors to write
181 * @gfp_mask: memory allocation flags (for bio_alloc)
182 * @page: page containing data
185 * Issue a write same request for the sectors in question.
187 int blkdev_issue_write_same(struct block_device
*bdev
, sector_t sector
,
188 sector_t nr_sects
, gfp_t gfp_mask
,
191 struct bio
*bio
= NULL
;
192 struct blk_plug plug
;
195 blk_start_plug(&plug
);
196 ret
= __blkdev_issue_write_same(bdev
, sector
, nr_sects
, gfp_mask
, page
,
198 if (ret
== 0 && bio
) {
199 ret
= submit_bio_wait(bio
);
202 blk_finish_plug(&plug
);
205 EXPORT_SYMBOL(blkdev_issue_write_same
);
207 static int __blkdev_issue_write_zeroes(struct block_device
*bdev
,
208 sector_t sector
, sector_t nr_sects
, gfp_t gfp_mask
,
209 struct bio
**biop
, unsigned flags
)
211 struct bio
*bio
= *biop
;
212 unsigned int max_write_zeroes_sectors
;
213 struct request_queue
*q
= bdev_get_queue(bdev
);
218 /* Ensure that max_write_zeroes_sectors doesn't overflow bi_size */
219 max_write_zeroes_sectors
= bdev_write_zeroes_sectors(bdev
);
221 if (max_write_zeroes_sectors
== 0)
225 bio
= next_bio(bio
, 0, gfp_mask
);
226 bio
->bi_iter
.bi_sector
= sector
;
227 bio_set_dev(bio
, bdev
);
228 bio
->bi_opf
= REQ_OP_WRITE_ZEROES
;
229 if (flags
& BLKDEV_ZERO_NOUNMAP
)
230 bio
->bi_opf
|= REQ_NOUNMAP
;
232 if (nr_sects
> max_write_zeroes_sectors
) {
233 bio
->bi_iter
.bi_size
= max_write_zeroes_sectors
<< 9;
234 nr_sects
-= max_write_zeroes_sectors
;
235 sector
+= max_write_zeroes_sectors
;
237 bio
->bi_iter
.bi_size
= nr_sects
<< 9;
248 * Convert a number of 512B sectors to a number of pages.
249 * The result is limited to a number of pages that can fit into a BIO.
250 * Also make sure that the result is always at least 1 (page) for the cases
251 * where nr_sects is lower than the number of sectors in a page.
253 static unsigned int __blkdev_sectors_to_bio_pages(sector_t nr_sects
)
255 sector_t pages
= DIV_ROUND_UP_SECTOR_T(nr_sects
, PAGE_SIZE
/ 512);
257 return min(pages
, (sector_t
)BIO_MAX_PAGES
);
260 static int __blkdev_issue_zero_pages(struct block_device
*bdev
,
261 sector_t sector
, sector_t nr_sects
, gfp_t gfp_mask
,
264 struct request_queue
*q
= bdev_get_queue(bdev
);
265 struct bio
*bio
= *biop
;
272 while (nr_sects
!= 0) {
273 bio
= next_bio(bio
, __blkdev_sectors_to_bio_pages(nr_sects
),
275 bio
->bi_iter
.bi_sector
= sector
;
276 bio_set_dev(bio
, bdev
);
277 bio_set_op_attrs(bio
, REQ_OP_WRITE
, 0);
279 while (nr_sects
!= 0) {
280 sz
= min((sector_t
) PAGE_SIZE
, nr_sects
<< 9);
281 bi_size
= bio_add_page(bio
, ZERO_PAGE(0), sz
, 0);
282 nr_sects
-= bi_size
>> 9;
283 sector
+= bi_size
>> 9;
295 * __blkdev_issue_zeroout - generate number of zero filed write bios
296 * @bdev: blockdev to issue
297 * @sector: start sector
298 * @nr_sects: number of sectors to write
299 * @gfp_mask: memory allocation flags (for bio_alloc)
300 * @biop: pointer to anchor bio
301 * @flags: controls detailed behavior
304 * Zero-fill a block range, either using hardware offload or by explicitly
305 * writing zeroes to the device.
307 * If a device is using logical block provisioning, the underlying space will
308 * not be released if %flags contains BLKDEV_ZERO_NOUNMAP.
310 * If %flags contains BLKDEV_ZERO_NOFALLBACK, the function will return
311 * -EOPNOTSUPP if no explicit hardware offload for zeroing is provided.
313 int __blkdev_issue_zeroout(struct block_device
*bdev
, sector_t sector
,
314 sector_t nr_sects
, gfp_t gfp_mask
, struct bio
**biop
,
320 bs_mask
= (bdev_logical_block_size(bdev
) >> 9) - 1;
321 if ((sector
| nr_sects
) & bs_mask
)
324 ret
= __blkdev_issue_write_zeroes(bdev
, sector
, nr_sects
, gfp_mask
,
326 if (ret
!= -EOPNOTSUPP
|| (flags
& BLKDEV_ZERO_NOFALLBACK
))
329 return __blkdev_issue_zero_pages(bdev
, sector
, nr_sects
, gfp_mask
,
332 EXPORT_SYMBOL(__blkdev_issue_zeroout
);
335 * blkdev_issue_zeroout - zero-fill a block range
336 * @bdev: blockdev to write
337 * @sector: start sector
338 * @nr_sects: number of sectors to write
339 * @gfp_mask: memory allocation flags (for bio_alloc)
340 * @flags: controls detailed behavior
343 * Zero-fill a block range, either using hardware offload or by explicitly
344 * writing zeroes to the device. See __blkdev_issue_zeroout() for the
345 * valid values for %flags.
347 int blkdev_issue_zeroout(struct block_device
*bdev
, sector_t sector
,
348 sector_t nr_sects
, gfp_t gfp_mask
, unsigned flags
)
353 struct blk_plug plug
;
354 bool try_write_zeroes
= !!bdev_write_zeroes_sectors(bdev
);
356 bs_mask
= (bdev_logical_block_size(bdev
) >> 9) - 1;
357 if ((sector
| nr_sects
) & bs_mask
)
362 blk_start_plug(&plug
);
363 if (try_write_zeroes
) {
364 ret
= __blkdev_issue_write_zeroes(bdev
, sector
, nr_sects
,
365 gfp_mask
, &bio
, flags
);
366 } else if (!(flags
& BLKDEV_ZERO_NOFALLBACK
)) {
367 ret
= __blkdev_issue_zero_pages(bdev
, sector
, nr_sects
,
370 /* No zeroing offload support */
373 if (ret
== 0 && bio
) {
374 ret
= submit_bio_wait(bio
);
377 blk_finish_plug(&plug
);
378 if (ret
&& try_write_zeroes
) {
379 if (!(flags
& BLKDEV_ZERO_NOFALLBACK
)) {
380 try_write_zeroes
= false;
383 if (!bdev_write_zeroes_sectors(bdev
)) {
385 * Zeroing offload support was indicated, but the
386 * device reported ILLEGAL REQUEST (for some devices
387 * there is no non-destructive way to verify whether
388 * WRITE ZEROES is actually supported).
396 EXPORT_SYMBOL(blkdev_issue_zeroout
);