]>
git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - block/blk-lib.c
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>
15 struct completion
*wait
;
18 static void bio_batch_end_io(struct bio
*bio
, int err
)
20 struct bio_batch
*bb
= bio
->bi_private
;
22 if (err
&& (err
!= -EOPNOTSUPP
))
23 clear_bit(BIO_UPTODATE
, &bb
->flags
);
24 if (atomic_dec_and_test(&bb
->done
))
30 * blkdev_issue_discard - queue a discard
31 * @bdev: blockdev to issue discard for
32 * @sector: start sector
33 * @nr_sects: number of sectors to discard
34 * @gfp_mask: memory allocation flags (for bio_alloc)
35 * @flags: BLKDEV_IFL_* flags to control behaviour
38 * Issue a discard request for the sectors in question.
40 int blkdev_issue_discard(struct block_device
*bdev
, sector_t sector
,
41 sector_t nr_sects
, gfp_t gfp_mask
, unsigned long flags
)
43 DECLARE_COMPLETION_ONSTACK(wait
);
44 struct request_queue
*q
= bdev_get_queue(bdev
);
45 int type
= REQ_WRITE
| REQ_DISCARD
;
46 unsigned int max_discard_sectors
, granularity
;
56 if (!blk_queue_discard(q
))
59 /* Zero-sector (unknown) and one-sector granularities are the same. */
60 granularity
= max(q
->limits
.discard_granularity
>> 9, 1U);
61 alignment
= (bdev_discard_alignment(bdev
) >> 9) % granularity
;
64 * Ensure that max_discard_sectors is of the proper
65 * granularity, so that requests stay aligned after a split.
67 max_discard_sectors
= min(q
->limits
.max_discard_sectors
, UINT_MAX
>> 9);
68 max_discard_sectors
-= max_discard_sectors
% granularity
;
69 if (unlikely(!max_discard_sectors
)) {
70 /* Avoid infinite loop below. Being cautious never hurts. */
74 if (flags
& BLKDEV_DISCARD_SECURE
) {
75 if (!blk_queue_secdiscard(q
))
80 atomic_set(&bb
.done
, 1);
81 bb
.flags
= 1 << BIO_UPTODATE
;
84 blk_start_plug(&plug
);
86 unsigned int req_sects
;
87 sector_t end_sect
, tmp
;
89 bio
= bio_alloc(gfp_mask
, 1);
95 req_sects
= min_t(sector_t
, nr_sects
, max_discard_sectors
);
98 * If splitting a request, and the next starting sector would be
99 * misaligned, stop the discard at the previous aligned sector.
101 end_sect
= sector
+ req_sects
;
103 if (req_sects
< nr_sects
&&
104 sector_div(tmp
, granularity
) != alignment
) {
105 end_sect
= end_sect
- alignment
;
106 sector_div(end_sect
, granularity
);
107 end_sect
= end_sect
* granularity
+ alignment
;
108 req_sects
= end_sect
- sector
;
111 bio
->bi_iter
.bi_sector
= sector
;
112 bio
->bi_end_io
= bio_batch_end_io
;
114 bio
->bi_private
= &bb
;
116 bio
->bi_iter
.bi_size
= req_sects
<< 9;
117 nr_sects
-= req_sects
;
120 atomic_inc(&bb
.done
);
121 submit_bio(type
, bio
);
123 blk_finish_plug(&plug
);
125 /* Wait for bios in-flight */
126 if (!atomic_dec_and_test(&bb
.done
))
127 wait_for_completion_io(&wait
);
129 if (!test_bit(BIO_UPTODATE
, &bb
.flags
))
134 EXPORT_SYMBOL(blkdev_issue_discard
);
137 * blkdev_issue_write_same - queue a write same operation
138 * @bdev: target blockdev
139 * @sector: start sector
140 * @nr_sects: number of sectors to write
141 * @gfp_mask: memory allocation flags (for bio_alloc)
142 * @page: page containing data to write
145 * Issue a write same request for the sectors in question.
147 int blkdev_issue_write_same(struct block_device
*bdev
, sector_t sector
,
148 sector_t nr_sects
, gfp_t gfp_mask
,
151 DECLARE_COMPLETION_ONSTACK(wait
);
152 struct request_queue
*q
= bdev_get_queue(bdev
);
153 unsigned int max_write_same_sectors
;
161 max_write_same_sectors
= q
->limits
.max_write_same_sectors
;
163 if (max_write_same_sectors
== 0)
166 atomic_set(&bb
.done
, 1);
167 bb
.flags
= 1 << BIO_UPTODATE
;
171 bio
= bio_alloc(gfp_mask
, 1);
177 bio
->bi_iter
.bi_sector
= sector
;
178 bio
->bi_end_io
= bio_batch_end_io
;
180 bio
->bi_private
= &bb
;
182 bio
->bi_io_vec
->bv_page
= page
;
183 bio
->bi_io_vec
->bv_offset
= 0;
184 bio
->bi_io_vec
->bv_len
= bdev_logical_block_size(bdev
);
186 if (nr_sects
> max_write_same_sectors
) {
187 bio
->bi_iter
.bi_size
= max_write_same_sectors
<< 9;
188 nr_sects
-= max_write_same_sectors
;
189 sector
+= max_write_same_sectors
;
191 bio
->bi_iter
.bi_size
= nr_sects
<< 9;
195 atomic_inc(&bb
.done
);
196 submit_bio(REQ_WRITE
| REQ_WRITE_SAME
, bio
);
199 /* Wait for bios in-flight */
200 if (!atomic_dec_and_test(&bb
.done
))
201 wait_for_completion_io(&wait
);
203 if (!test_bit(BIO_UPTODATE
, &bb
.flags
))
208 EXPORT_SYMBOL(blkdev_issue_write_same
);
211 * blkdev_issue_zeroout - generate number of zero filed write bios
212 * @bdev: blockdev to issue
213 * @sector: start sector
214 * @nr_sects: number of sectors to write
215 * @gfp_mask: memory allocation flags (for bio_alloc)
218 * Generate and issue number of bios with zerofiled pages.
221 int __blkdev_issue_zeroout(struct block_device
*bdev
, sector_t sector
,
222 sector_t nr_sects
, gfp_t gfp_mask
)
228 DECLARE_COMPLETION_ONSTACK(wait
);
230 atomic_set(&bb
.done
, 1);
231 bb
.flags
= 1 << BIO_UPTODATE
;
235 while (nr_sects
!= 0) {
236 bio
= bio_alloc(gfp_mask
,
237 min(nr_sects
, (sector_t
)BIO_MAX_PAGES
));
243 bio
->bi_iter
.bi_sector
= sector
;
245 bio
->bi_end_io
= bio_batch_end_io
;
246 bio
->bi_private
= &bb
;
248 while (nr_sects
!= 0) {
249 sz
= min((sector_t
) PAGE_SIZE
>> 9 , nr_sects
);
250 ret
= bio_add_page(bio
, ZERO_PAGE(0), sz
<< 9, 0);
251 nr_sects
-= ret
>> 9;
257 atomic_inc(&bb
.done
);
258 submit_bio(WRITE
, bio
);
261 /* Wait for bios in-flight */
262 if (!atomic_dec_and_test(&bb
.done
))
263 wait_for_completion_io(&wait
);
265 if (!test_bit(BIO_UPTODATE
, &bb
.flags
))
266 /* One of bios in the batch was completed with error.*/
273 * blkdev_issue_zeroout - zero-fill a block range
274 * @bdev: blockdev to write
275 * @sector: start sector
276 * @nr_sects: number of sectors to write
277 * @gfp_mask: memory allocation flags (for bio_alloc)
280 * Generate and issue number of bios with zerofiled pages.
283 int blkdev_issue_zeroout(struct block_device
*bdev
, sector_t sector
,
284 sector_t nr_sects
, gfp_t gfp_mask
)
286 if (bdev_write_same(bdev
)) {
287 unsigned char bdn
[BDEVNAME_SIZE
];
289 if (!blkdev_issue_write_same(bdev
, sector
, nr_sects
, gfp_mask
,
294 pr_err("%s: WRITE SAME failed. Manually zeroing.\n", bdn
);
297 return __blkdev_issue_zeroout(bdev
, sector
, nr_sects
, gfp_mask
);
299 EXPORT_SYMBOL(blkdev_issue_zeroout
);