2 * Functions related to generic helpers functions
4 #include <linux/kernel.h>
5 #include <linux/module.h>
7 #include <linux/blkdev.h>
8 #include <linux/scatterlist.h>
12 static struct bio
*next_bio(struct bio
*bio
, unsigned int nr_pages
,
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
;
31 unsigned int granularity
;
38 if (flags
& BLKDEV_DISCARD_SECURE
) {
39 if (flags
& BLKDEV_DISCARD_ZERO
)
41 if (!blk_queue_secure_erase(q
))
43 op
= REQ_OP_SECURE_ERASE
;
45 if (!blk_queue_discard(q
))
47 if ((flags
& BLKDEV_DISCARD_ZERO
) &&
48 !q
->limits
.discard_zeroes_data
)
53 /* Zero-sector (unknown) and one-sector granularities are the same. */
54 granularity
= max(q
->limits
.discard_granularity
>> 9, 1U);
55 alignment
= (bdev_discard_alignment(bdev
) >> 9) % granularity
;
58 unsigned int req_sects
;
59 sector_t end_sect
, tmp
;
61 /* Make sure bi_size doesn't overflow */
62 req_sects
= min_t(sector_t
, nr_sects
, UINT_MAX
>> 9);
65 * If splitting a request, and the next starting sector would be
66 * misaligned, stop the discard at the previous aligned sector.
68 end_sect
= sector
+ req_sects
;
70 if (req_sects
< nr_sects
&&
71 sector_div(tmp
, granularity
) != alignment
) {
72 end_sect
= end_sect
- alignment
;
73 sector_div(end_sect
, granularity
);
74 end_sect
= end_sect
* granularity
+ alignment
;
75 req_sects
= end_sect
- sector
;
78 bio
= next_bio(bio
, 1, gfp_mask
);
79 bio
->bi_iter
.bi_sector
= sector
;
81 bio_set_op_attrs(bio
, op
, 0);
83 bio
->bi_iter
.bi_size
= req_sects
<< 9;
84 nr_sects
-= req_sects
;
88 * We can loop for a long time in here, if someone does
89 * full device discards (like mkfs). Be nice and allow
90 * us to schedule out to avoid softlocking if preempt
99 EXPORT_SYMBOL(__blkdev_issue_discard
);
102 * blkdev_issue_discard - queue a discard
103 * @bdev: blockdev to issue discard for
104 * @sector: start sector
105 * @nr_sects: number of sectors to discard
106 * @gfp_mask: memory allocation flags (for bio_alloc)
107 * @flags: BLKDEV_IFL_* flags to control behaviour
110 * Issue a discard request for the sectors in question.
112 int blkdev_issue_discard(struct block_device
*bdev
, sector_t sector
,
113 sector_t nr_sects
, gfp_t gfp_mask
, unsigned long flags
)
115 struct bio
*bio
= NULL
;
116 struct blk_plug plug
;
119 blk_start_plug(&plug
);
120 ret
= __blkdev_issue_discard(bdev
, sector
, nr_sects
, gfp_mask
, flags
,
123 ret
= submit_bio_wait(bio
);
124 if (ret
== -EOPNOTSUPP
&& !(flags
& BLKDEV_DISCARD_ZERO
))
127 blk_finish_plug(&plug
);
131 EXPORT_SYMBOL(blkdev_issue_discard
);
134 * blkdev_issue_write_same - queue a write same operation
135 * @bdev: target blockdev
136 * @sector: start sector
137 * @nr_sects: number of sectors to write
138 * @gfp_mask: memory allocation flags (for bio_alloc)
139 * @page: page containing data to write
142 * Issue a write same request for the sectors in question.
144 int blkdev_issue_write_same(struct block_device
*bdev
, sector_t sector
,
145 sector_t nr_sects
, gfp_t gfp_mask
,
148 struct request_queue
*q
= bdev_get_queue(bdev
);
149 unsigned int max_write_same_sectors
;
150 struct bio
*bio
= NULL
;
156 /* Ensure that max_write_same_sectors doesn't overflow bi_size */
157 max_write_same_sectors
= UINT_MAX
>> 9;
160 bio
= next_bio(bio
, 1, gfp_mask
);
161 bio
->bi_iter
.bi_sector
= sector
;
164 bio
->bi_io_vec
->bv_page
= page
;
165 bio
->bi_io_vec
->bv_offset
= 0;
166 bio
->bi_io_vec
->bv_len
= bdev_logical_block_size(bdev
);
167 bio_set_op_attrs(bio
, REQ_OP_WRITE_SAME
, 0);
169 if (nr_sects
> max_write_same_sectors
) {
170 bio
->bi_iter
.bi_size
= max_write_same_sectors
<< 9;
171 nr_sects
-= max_write_same_sectors
;
172 sector
+= max_write_same_sectors
;
174 bio
->bi_iter
.bi_size
= nr_sects
<< 9;
180 ret
= submit_bio_wait(bio
);
181 return ret
!= -EOPNOTSUPP
? ret
: 0;
183 EXPORT_SYMBOL(blkdev_issue_write_same
);
186 * blkdev_issue_zeroout - generate number of zero filed write bios
187 * @bdev: blockdev to issue
188 * @sector: start sector
189 * @nr_sects: number of sectors to write
190 * @gfp_mask: memory allocation flags (for bio_alloc)
193 * Generate and issue number of bios with zerofiled pages.
196 static int __blkdev_issue_zeroout(struct block_device
*bdev
, sector_t sector
,
197 sector_t nr_sects
, gfp_t gfp_mask
)
200 struct bio
*bio
= NULL
;
203 while (nr_sects
!= 0) {
204 bio
= next_bio(bio
, min(nr_sects
, (sector_t
)BIO_MAX_PAGES
),
206 bio
->bi_iter
.bi_sector
= sector
;
208 bio_set_op_attrs(bio
, REQ_OP_WRITE
, 0);
210 while (nr_sects
!= 0) {
211 sz
= min((sector_t
) PAGE_SIZE
>> 9 , nr_sects
);
212 ret
= bio_add_page(bio
, ZERO_PAGE(0), sz
<< 9, 0);
213 nr_sects
-= ret
>> 9;
221 return submit_bio_wait(bio
);
226 * blkdev_issue_zeroout - zero-fill a block range
227 * @bdev: blockdev to write
228 * @sector: start sector
229 * @nr_sects: number of sectors to write
230 * @gfp_mask: memory allocation flags (for bio_alloc)
231 * @discard: whether to discard the block range
234 * Zero-fill a block range. If the discard flag is set and the block
235 * device guarantees that subsequent READ operations to the block range
236 * in question will return zeroes, the blocks will be discarded. Should
237 * the discard request fail, if the discard flag is not set, or if
238 * discard_zeroes_data is not supported, this function will resort to
239 * zeroing the blocks manually, thus provisioning (allocating,
240 * anchoring) them. If the block device supports the WRITE SAME command
241 * blkdev_issue_zeroout() will use it to optimize the process of
242 * clearing the block range. Otherwise the zeroing will be performed
243 * using regular WRITE calls.
246 int blkdev_issue_zeroout(struct block_device
*bdev
, sector_t sector
,
247 sector_t nr_sects
, gfp_t gfp_mask
, bool discard
)
250 if (!blkdev_issue_discard(bdev
, sector
, nr_sects
, gfp_mask
,
251 BLKDEV_DISCARD_ZERO
))
255 if (bdev_write_same(bdev
) &&
256 blkdev_issue_write_same(bdev
, sector
, nr_sects
, gfp_mask
,
260 return __blkdev_issue_zeroout(bdev
, sector
, nr_sects
, gfp_mask
);
262 EXPORT_SYMBOL(blkdev_issue_zeroout
);
This page took 0.041379 seconds and 6 git commands to generate.