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 struct bio *blk_next_bio(struct bio *bio, unsigned int nr_pages, gfp_t gfp)
15 struct bio *new = bio_alloc(gfp, nr_pages);
25 int __blkdev_issue_discard(struct block_device *bdev, sector_t sector,
26 sector_t nr_sects, gfp_t gfp_mask, int flags,
29 struct request_queue *q = bdev_get_queue(bdev);
30 struct bio *bio = *biop;
37 if (bdev_read_only(bdev))
40 if (flags & BLKDEV_DISCARD_SECURE) {
41 if (!blk_queue_secure_erase(q))
43 op = REQ_OP_SECURE_ERASE;
45 if (!blk_queue_discard(q))
50 bs_mask = (bdev_logical_block_size(bdev) >> 9) - 1;
51 if ((sector | nr_sects) & bs_mask)
55 unsigned int req_sects = nr_sects;
60 if (req_sects > UINT_MAX >> 9)
61 req_sects = UINT_MAX >> 9;
63 end_sect = sector + req_sects;
65 bio = blk_next_bio(bio, 0, gfp_mask);
66 bio->bi_iter.bi_sector = sector;
67 bio_set_dev(bio, bdev);
68 bio_set_op_attrs(bio, op, 0);
70 bio->bi_iter.bi_size = req_sects << 9;
71 nr_sects -= req_sects;
75 * We can loop for a long time in here, if someone does
76 * full device discards (like mkfs). Be nice and allow
77 * us to schedule out to avoid softlocking if preempt
94 EXPORT_SYMBOL(__blkdev_issue_discard);
97 * blkdev_issue_discard - queue a discard
98 * @bdev: blockdev to issue discard for
99 * @sector: start sector
100 * @nr_sects: number of sectors to discard
101 * @gfp_mask: memory allocation flags (for bio_alloc)
102 * @flags: BLKDEV_DISCARD_* flags to control behaviour
105 * Issue a discard request for the sectors in question.
107 int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
108 sector_t nr_sects, gfp_t gfp_mask, unsigned long flags)
110 struct bio *bio = NULL;
111 struct blk_plug plug;
114 blk_start_plug(&plug);
115 ret = __blkdev_issue_discard(bdev, sector, nr_sects, gfp_mask, flags,
118 ret = submit_bio_wait(bio);
119 if (ret == -EOPNOTSUPP)
123 blk_finish_plug(&plug);
127 EXPORT_SYMBOL(blkdev_issue_discard);
130 * __blkdev_issue_write_same - generate number of bios with same page
131 * @bdev: target blockdev
132 * @sector: start sector
133 * @nr_sects: number of sectors to write
134 * @gfp_mask: memory allocation flags (for bio_alloc)
135 * @page: page containing data to write
136 * @biop: pointer to anchor bio
139 * Generate and issue number of bios(REQ_OP_WRITE_SAME) with same page.
141 static int __blkdev_issue_write_same(struct block_device *bdev, sector_t sector,
142 sector_t nr_sects, gfp_t gfp_mask, struct page *page,
145 struct request_queue *q = bdev_get_queue(bdev);
146 unsigned int max_write_same_sectors;
147 struct bio *bio = *biop;
153 if (bdev_read_only(bdev))
156 bs_mask = (bdev_logical_block_size(bdev) >> 9) - 1;
157 if ((sector | nr_sects) & bs_mask)
160 if (!bdev_write_same(bdev))
163 /* Ensure that max_write_same_sectors doesn't overflow bi_size */
164 max_write_same_sectors = UINT_MAX >> 9;
167 bio = blk_next_bio(bio, 1, gfp_mask);
168 bio->bi_iter.bi_sector = sector;
169 bio_set_dev(bio, bdev);
171 bio->bi_io_vec->bv_page = page;
172 bio->bi_io_vec->bv_offset = 0;
173 bio->bi_io_vec->bv_len = bdev_logical_block_size(bdev);
174 bio_set_op_attrs(bio, REQ_OP_WRITE_SAME, 0);
176 if (nr_sects > max_write_same_sectors) {
177 bio->bi_iter.bi_size = max_write_same_sectors << 9;
178 nr_sects -= max_write_same_sectors;
179 sector += max_write_same_sectors;
181 bio->bi_iter.bi_size = nr_sects << 9;
192 * blkdev_issue_write_same - queue a write same operation
193 * @bdev: target blockdev
194 * @sector: start sector
195 * @nr_sects: number of sectors to write
196 * @gfp_mask: memory allocation flags (for bio_alloc)
197 * @page: page containing data
200 * Issue a write same request for the sectors in question.
202 int blkdev_issue_write_same(struct block_device *bdev, sector_t sector,
203 sector_t nr_sects, gfp_t gfp_mask,
206 struct bio *bio = NULL;
207 struct blk_plug plug;
210 blk_start_plug(&plug);
211 ret = __blkdev_issue_write_same(bdev, sector, nr_sects, gfp_mask, page,
213 if (ret == 0 && bio) {
214 ret = submit_bio_wait(bio);
217 blk_finish_plug(&plug);
220 EXPORT_SYMBOL(blkdev_issue_write_same);
222 static int __blkdev_issue_write_zeroes(struct block_device *bdev,
223 sector_t sector, sector_t nr_sects, gfp_t gfp_mask,
224 struct bio **biop, unsigned flags)
226 struct bio *bio = *biop;
227 unsigned int max_write_zeroes_sectors;
228 struct request_queue *q = bdev_get_queue(bdev);
233 if (bdev_read_only(bdev))
236 /* Ensure that max_write_zeroes_sectors doesn't overflow bi_size */
237 max_write_zeroes_sectors = bdev_write_zeroes_sectors(bdev);
239 if (max_write_zeroes_sectors == 0)
243 bio = blk_next_bio(bio, 0, gfp_mask);
244 bio->bi_iter.bi_sector = sector;
245 bio_set_dev(bio, bdev);
246 bio->bi_opf = REQ_OP_WRITE_ZEROES;
247 if (flags & BLKDEV_ZERO_NOUNMAP)
248 bio->bi_opf |= REQ_NOUNMAP;
250 if (nr_sects > max_write_zeroes_sectors) {
251 bio->bi_iter.bi_size = max_write_zeroes_sectors << 9;
252 nr_sects -= max_write_zeroes_sectors;
253 sector += max_write_zeroes_sectors;
255 bio->bi_iter.bi_size = nr_sects << 9;
266 * Convert a number of 512B sectors to a number of pages.
267 * The result is limited to a number of pages that can fit into a BIO.
268 * Also make sure that the result is always at least 1 (page) for the cases
269 * where nr_sects is lower than the number of sectors in a page.
271 static unsigned int __blkdev_sectors_to_bio_pages(sector_t nr_sects)
273 sector_t pages = DIV_ROUND_UP_SECTOR_T(nr_sects, PAGE_SIZE / 512);
275 return min(pages, (sector_t)BIO_MAX_PAGES);
278 static int __blkdev_issue_zero_pages(struct block_device *bdev,
279 sector_t sector, sector_t nr_sects, gfp_t gfp_mask,
282 struct request_queue *q = bdev_get_queue(bdev);
283 struct bio *bio = *biop;
290 if (bdev_read_only(bdev))
293 while (nr_sects != 0) {
294 bio = blk_next_bio(bio, __blkdev_sectors_to_bio_pages(nr_sects),
296 bio->bi_iter.bi_sector = sector;
297 bio_set_dev(bio, bdev);
298 bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
300 while (nr_sects != 0) {
301 sz = min((sector_t) PAGE_SIZE, nr_sects << 9);
302 bi_size = bio_add_page(bio, ZERO_PAGE(0), sz, 0);
303 nr_sects -= bi_size >> 9;
304 sector += bi_size >> 9;
316 * __blkdev_issue_zeroout - generate number of zero filed write bios
317 * @bdev: blockdev to issue
318 * @sector: start sector
319 * @nr_sects: number of sectors to write
320 * @gfp_mask: memory allocation flags (for bio_alloc)
321 * @biop: pointer to anchor bio
322 * @flags: controls detailed behavior
325 * Zero-fill a block range, either using hardware offload or by explicitly
326 * writing zeroes to the device.
328 * If a device is using logical block provisioning, the underlying space will
329 * not be released if %flags contains BLKDEV_ZERO_NOUNMAP.
331 * If %flags contains BLKDEV_ZERO_NOFALLBACK, the function will return
332 * -EOPNOTSUPP if no explicit hardware offload for zeroing is provided.
334 int __blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
335 sector_t nr_sects, gfp_t gfp_mask, struct bio **biop,
341 bs_mask = (bdev_logical_block_size(bdev) >> 9) - 1;
342 if ((sector | nr_sects) & bs_mask)
345 ret = __blkdev_issue_write_zeroes(bdev, sector, nr_sects, gfp_mask,
347 if (ret != -EOPNOTSUPP || (flags & BLKDEV_ZERO_NOFALLBACK))
350 return __blkdev_issue_zero_pages(bdev, sector, nr_sects, gfp_mask,
353 EXPORT_SYMBOL(__blkdev_issue_zeroout);
356 * blkdev_issue_zeroout - zero-fill a block range
357 * @bdev: blockdev to write
358 * @sector: start sector
359 * @nr_sects: number of sectors to write
360 * @gfp_mask: memory allocation flags (for bio_alloc)
361 * @flags: controls detailed behavior
364 * Zero-fill a block range, either using hardware offload or by explicitly
365 * writing zeroes to the device. See __blkdev_issue_zeroout() for the
366 * valid values for %flags.
368 int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
369 sector_t nr_sects, gfp_t gfp_mask, unsigned flags)
374 struct blk_plug plug;
375 bool try_write_zeroes = !!bdev_write_zeroes_sectors(bdev);
377 bs_mask = (bdev_logical_block_size(bdev) >> 9) - 1;
378 if ((sector | nr_sects) & bs_mask)
383 blk_start_plug(&plug);
384 if (try_write_zeroes) {
385 ret = __blkdev_issue_write_zeroes(bdev, sector, nr_sects,
386 gfp_mask, &bio, flags);
387 } else if (!(flags & BLKDEV_ZERO_NOFALLBACK)) {
388 ret = __blkdev_issue_zero_pages(bdev, sector, nr_sects,
391 /* No zeroing offload support */
394 if (ret == 0 && bio) {
395 ret = submit_bio_wait(bio);
398 blk_finish_plug(&plug);
399 if (ret && try_write_zeroes) {
400 if (!(flags & BLKDEV_ZERO_NOFALLBACK)) {
401 try_write_zeroes = false;
404 if (!bdev_write_zeroes_sectors(bdev)) {
406 * Zeroing offload support was indicated, but the
407 * device reported ILLEGAL REQUEST (for some devices
408 * there is no non-destructive way to verify whether
409 * WRITE ZEROES is actually supported).
417 EXPORT_SYMBOL(blkdev_issue_zeroout);