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 sector_t
bio_discard_limit(struct block_device
*bdev
, sector_t sector
)
15 unsigned int discard_granularity
= bdev_discard_granularity(bdev
);
16 sector_t granularity_aligned_sector
;
18 if (bdev_is_partition(bdev
))
19 sector
+= bdev
->bd_start_sect
;
21 granularity_aligned_sector
=
22 round_up(sector
, discard_granularity
>> SECTOR_SHIFT
);
25 * Make sure subsequent bios start aligned to the discard granularity if
26 * it needs to be split.
28 if (granularity_aligned_sector
!= sector
)
29 return granularity_aligned_sector
- sector
;
32 * Align the bio size to the discard granularity to make splitting the bio
33 * at discard granularity boundaries easier in the driver if needed.
35 return round_down(UINT_MAX
, discard_granularity
) >> SECTOR_SHIFT
;
38 int __blkdev_issue_discard(struct block_device
*bdev
, sector_t sector
,
39 sector_t nr_sects
, gfp_t gfp_mask
, struct bio
**biop
)
41 struct bio
*bio
= *biop
;
44 if (bdev_read_only(bdev
))
46 if (!bdev_max_discard_sectors(bdev
))
49 /* In case the discard granularity isn't set by buggy device driver */
50 if (WARN_ON_ONCE(!bdev_discard_granularity(bdev
))) {
51 pr_err_ratelimited("%pg: Error: discard_granularity is 0.\n",
56 bs_mask
= (bdev_logical_block_size(bdev
) >> 9) - 1;
57 if ((sector
| nr_sects
) & bs_mask
)
65 min(nr_sects
, bio_discard_limit(bdev
, sector
));
67 bio
= blk_next_bio(bio
, bdev
, 0, REQ_OP_DISCARD
, gfp_mask
);
68 bio
->bi_iter
.bi_sector
= sector
;
69 bio
->bi_iter
.bi_size
= req_sects
<< 9;
71 nr_sects
-= req_sects
;
74 * We can loop for a long time in here, if someone does
75 * full device discards (like mkfs). Be nice and allow
76 * us to schedule out to avoid softlocking if preempt
85 EXPORT_SYMBOL(__blkdev_issue_discard
);
88 * blkdev_issue_discard - queue a discard
89 * @bdev: blockdev to issue discard for
90 * @sector: start sector
91 * @nr_sects: number of sectors to discard
92 * @gfp_mask: memory allocation flags (for bio_alloc)
95 * Issue a discard request for the sectors in question.
97 int blkdev_issue_discard(struct block_device
*bdev
, sector_t sector
,
98 sector_t nr_sects
, gfp_t gfp_mask
)
100 struct bio
*bio
= NULL
;
101 struct blk_plug plug
;
104 blk_start_plug(&plug
);
105 ret
= __blkdev_issue_discard(bdev
, sector
, nr_sects
, gfp_mask
, &bio
);
107 ret
= submit_bio_wait(bio
);
108 if (ret
== -EOPNOTSUPP
)
112 blk_finish_plug(&plug
);
116 EXPORT_SYMBOL(blkdev_issue_discard
);
118 static int __blkdev_issue_write_zeroes(struct block_device
*bdev
,
119 sector_t sector
, sector_t nr_sects
, gfp_t gfp_mask
,
120 struct bio
**biop
, unsigned flags
)
122 struct bio
*bio
= *biop
;
123 unsigned int max_sectors
;
125 if (bdev_read_only(bdev
))
128 /* Ensure that max_sectors doesn't overflow bi_size */
129 max_sectors
= bdev_write_zeroes_sectors(bdev
);
131 if (max_sectors
== 0)
135 unsigned int len
= min_t(sector_t
, nr_sects
, max_sectors
);
137 bio
= blk_next_bio(bio
, bdev
, 0, REQ_OP_WRITE_ZEROES
, gfp_mask
);
138 bio
->bi_iter
.bi_sector
= sector
;
139 if (flags
& BLKDEV_ZERO_NOUNMAP
)
140 bio
->bi_opf
|= REQ_NOUNMAP
;
142 bio
->bi_iter
.bi_size
= len
<< SECTOR_SHIFT
;
153 * Convert a number of 512B sectors to a number of pages.
154 * The result is limited to a number of pages that can fit into a BIO.
155 * Also make sure that the result is always at least 1 (page) for the cases
156 * where nr_sects is lower than the number of sectors in a page.
158 static unsigned int __blkdev_sectors_to_bio_pages(sector_t nr_sects
)
160 sector_t pages
= DIV_ROUND_UP_SECTOR_T(nr_sects
, PAGE_SIZE
/ 512);
162 return min(pages
, (sector_t
)BIO_MAX_VECS
);
165 static int __blkdev_issue_zero_pages(struct block_device
*bdev
,
166 sector_t sector
, sector_t nr_sects
, gfp_t gfp_mask
,
169 struct bio
*bio
= *biop
;
173 if (bdev_read_only(bdev
))
176 while (nr_sects
!= 0) {
177 bio
= blk_next_bio(bio
, bdev
, __blkdev_sectors_to_bio_pages(nr_sects
),
178 REQ_OP_WRITE
, gfp_mask
);
179 bio
->bi_iter
.bi_sector
= sector
;
181 while (nr_sects
!= 0) {
182 sz
= min((sector_t
) PAGE_SIZE
, nr_sects
<< 9);
183 bi_size
= bio_add_page(bio
, ZERO_PAGE(0), sz
, 0);
184 nr_sects
-= bi_size
>> 9;
185 sector
+= bi_size
>> 9;
197 * __blkdev_issue_zeroout - generate number of zero filed write bios
198 * @bdev: blockdev to issue
199 * @sector: start sector
200 * @nr_sects: number of sectors to write
201 * @gfp_mask: memory allocation flags (for bio_alloc)
202 * @biop: pointer to anchor bio
203 * @flags: controls detailed behavior
206 * Zero-fill a block range, either using hardware offload or by explicitly
207 * writing zeroes to the device.
209 * If a device is using logical block provisioning, the underlying space will
210 * not be released if %flags contains BLKDEV_ZERO_NOUNMAP.
212 * If %flags contains BLKDEV_ZERO_NOFALLBACK, the function will return
213 * -EOPNOTSUPP if no explicit hardware offload for zeroing is provided.
215 int __blkdev_issue_zeroout(struct block_device
*bdev
, sector_t sector
,
216 sector_t nr_sects
, gfp_t gfp_mask
, struct bio
**biop
,
222 bs_mask
= (bdev_logical_block_size(bdev
) >> 9) - 1;
223 if ((sector
| nr_sects
) & bs_mask
)
226 ret
= __blkdev_issue_write_zeroes(bdev
, sector
, nr_sects
, gfp_mask
,
228 if (ret
!= -EOPNOTSUPP
|| (flags
& BLKDEV_ZERO_NOFALLBACK
))
231 return __blkdev_issue_zero_pages(bdev
, sector
, nr_sects
, gfp_mask
,
234 EXPORT_SYMBOL(__blkdev_issue_zeroout
);
237 * blkdev_issue_zeroout - zero-fill a block range
238 * @bdev: blockdev to write
239 * @sector: start sector
240 * @nr_sects: number of sectors to write
241 * @gfp_mask: memory allocation flags (for bio_alloc)
242 * @flags: controls detailed behavior
245 * Zero-fill a block range, either using hardware offload or by explicitly
246 * writing zeroes to the device. See __blkdev_issue_zeroout() for the
247 * valid values for %flags.
249 int blkdev_issue_zeroout(struct block_device
*bdev
, sector_t sector
,
250 sector_t nr_sects
, gfp_t gfp_mask
, unsigned flags
)
255 struct blk_plug plug
;
256 bool try_write_zeroes
= !!bdev_write_zeroes_sectors(bdev
);
258 bs_mask
= (bdev_logical_block_size(bdev
) >> 9) - 1;
259 if ((sector
| nr_sects
) & bs_mask
)
264 blk_start_plug(&plug
);
265 if (try_write_zeroes
) {
266 ret
= __blkdev_issue_write_zeroes(bdev
, sector
, nr_sects
,
267 gfp_mask
, &bio
, flags
);
268 } else if (!(flags
& BLKDEV_ZERO_NOFALLBACK
)) {
269 ret
= __blkdev_issue_zero_pages(bdev
, sector
, nr_sects
,
272 /* No zeroing offload support */
275 if (ret
== 0 && bio
) {
276 ret
= submit_bio_wait(bio
);
279 blk_finish_plug(&plug
);
280 if (ret
&& try_write_zeroes
) {
281 if (!(flags
& BLKDEV_ZERO_NOFALLBACK
)) {
282 try_write_zeroes
= false;
285 if (!bdev_write_zeroes_sectors(bdev
)) {
287 * Zeroing offload support was indicated, but the
288 * device reported ILLEGAL REQUEST (for some devices
289 * there is no non-destructive way to verify whether
290 * WRITE ZEROES is actually supported).
298 EXPORT_SYMBOL(blkdev_issue_zeroout
);
300 int blkdev_issue_secure_erase(struct block_device
*bdev
, sector_t sector
,
301 sector_t nr_sects
, gfp_t gfp
)
303 sector_t bs_mask
= (bdev_logical_block_size(bdev
) >> 9) - 1;
304 unsigned int max_sectors
= bdev_max_secure_erase_sectors(bdev
);
305 struct bio
*bio
= NULL
;
306 struct blk_plug plug
;
309 /* make sure that "len << SECTOR_SHIFT" doesn't overflow */
310 if (max_sectors
> UINT_MAX
>> SECTOR_SHIFT
)
311 max_sectors
= UINT_MAX
>> SECTOR_SHIFT
;
312 max_sectors
&= ~bs_mask
;
314 if (max_sectors
== 0)
316 if ((sector
| nr_sects
) & bs_mask
)
318 if (bdev_read_only(bdev
))
321 blk_start_plug(&plug
);
323 unsigned int len
= min_t(sector_t
, nr_sects
, max_sectors
);
325 bio
= blk_next_bio(bio
, bdev
, 0, REQ_OP_SECURE_ERASE
, gfp
);
326 bio
->bi_iter
.bi_sector
= sector
;
327 bio
->bi_iter
.bi_size
= len
<< SECTOR_SHIFT
;
334 ret
= submit_bio_wait(bio
);
337 blk_finish_plug(&plug
);
341 EXPORT_SYMBOL(blkdev_issue_secure_erase
);