bounce.c 9.12 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
2 3 4 5 6
/* bounce buffer handling for block devices
 *
 * - Split from highmem.c
 */

7 8
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

9
#include <linux/mm.h>
10
#include <linux/export.h>
11
#include <linux/swap.h>
12
#include <linux/gfp.h>
13 14 15 16
#include <linux/bio.h>
#include <linux/pagemap.h>
#include <linux/mempool.h>
#include <linux/blkdev.h>
17
#include <linux/backing-dev.h>
18 19 20
#include <linux/init.h>
#include <linux/hash.h>
#include <linux/highmem.h>
21
#include <linux/memblock.h>
22
#include <linux/printk.h>
23 24
#include <asm/tlbflush.h>

25
#include <trace/events/block.h>
26
#include "blk.h"
27

28 29 30
#define POOL_SIZE	64
#define ISA_POOL_SIZE	16

31 32
static struct bio_set bounce_bio_set, bounce_bio_split;
static mempool_t page_pool, isa_page_pool;
33

34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
static void init_bounce_bioset(void)
{
	static bool bounce_bs_setup;
	int ret;

	if (bounce_bs_setup)
		return;

	ret = bioset_init(&bounce_bio_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS);
	BUG_ON(ret);
	if (bioset_integrity_create(&bounce_bio_set, BIO_POOL_SIZE))
		BUG_ON(1);

	ret = bioset_init(&bounce_bio_split, BIO_POOL_SIZE, 0, 0);
	BUG_ON(ret);
	bounce_bs_setup = true;
}

52
#if defined(CONFIG_HIGHMEM)
53 54
static __init int init_emergency_pool(void)
{
55
	int ret;
56
#if defined(CONFIG_HIGHMEM) && !defined(CONFIG_MEMORY_HOTPLUG)
57
	if (max_pfn <= max_low_pfn)
58
		return 0;
59
#endif
60

61 62
	ret = mempool_init_page_pool(&page_pool, POOL_SIZE, 0);
	BUG_ON(ret);
63
	pr_info("pool size: %d pages\n", POOL_SIZE);
64

65
	init_bounce_bioset();
66 67 68 69
	return 0;
}

__initcall(init_emergency_pool);
70
#endif
71

72
#ifdef CONFIG_HIGHMEM
73 74 75 76 77 78 79
/*
 * highmem version, map in to vec
 */
static void bounce_copy_vec(struct bio_vec *to, unsigned char *vfrom)
{
	unsigned char *vto;

80
	vto = kmap_atomic(to->bv_page);
81
	memcpy(vto + to->bv_offset, vfrom, to->bv_len);
82
	kunmap_atomic(vto);
83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
}

#else /* CONFIG_HIGHMEM */

#define bounce_copy_vec(to, vfrom)	\
	memcpy(page_address((to)->bv_page) + (to)->bv_offset, vfrom, (to)->bv_len)

#endif /* CONFIG_HIGHMEM */

/*
 * allocate pages in the DMA region for the ISA pool
 */
static void *mempool_alloc_pages_isa(gfp_t gfp_mask, void *data)
{
	return mempool_alloc_pages(gfp_mask | GFP_DMA, data);
}

100 101
static DEFINE_MUTEX(isa_mutex);

102 103 104 105 106 107
/*
 * gets called "every" time someone init's a queue with BLK_BOUNCE_ISA
 * as the max address, so check if the pool has already been created.
 */
int init_emergency_isa_pool(void)
{
108 109
	int ret;

110 111 112 113
	mutex_lock(&isa_mutex);

	if (mempool_initialized(&isa_page_pool)) {
		mutex_unlock(&isa_mutex);
114
		return 0;
115
	}
116

117 118 119
	ret = mempool_init(&isa_page_pool, ISA_POOL_SIZE, mempool_alloc_pages_isa,
			   mempool_free_pages, (void *) 0);
	BUG_ON(ret);
120

121
	pr_info("isa pool size: %d pages\n", ISA_POOL_SIZE);
122 123
	init_bounce_bioset();
	mutex_unlock(&isa_mutex);
124 125 126 127 128 129 130 131 132 133 134
	return 0;
}

/*
 * Simple bounce buffer support for highmem pages. Depending on the
 * queue gfp mask set, *to may or may not be a highmem page. kmap it
 * always, it will do the Right Thing
 */
static void copy_to_high_bio_irq(struct bio *to, struct bio *from)
{
	unsigned char *vfrom;
135
	struct bio_vec tovec, fromvec;
136
	struct bvec_iter iter;
137 138 139 140 141 142
	/*
	 * The bio of @from is created by bounce, so we can iterate
	 * its bvec from start to end, but the @from->bi_iter can't be
	 * trusted because it might be changed by splitting.
	 */
	struct bvec_iter from_iter = BVEC_ITER_ALL_INIT;
143 144

	bio_for_each_segment(tovec, to, iter) {
145 146
		fromvec = bio_iter_iovec(from, from_iter);
		if (tovec.bv_page != fromvec.bv_page) {
147 148 149 150 151
			/*
			 * fromvec->bv_offset and fromvec->bv_len might have
			 * been modified by the block layer, so use the original
			 * copy, bounce_copy_vec already uses tovec->bv_len
			 */
152
			vfrom = page_address(fromvec.bv_page) +
153 154 155 156 157
				tovec.bv_offset;

			bounce_copy_vec(&tovec, vfrom);
			flush_dcache_page(tovec.bv_page);
		}
158
		bio_advance_iter(from, &from_iter, tovec.bv_len);
159 160 161
	}
}

162
static void bounce_end_io(struct bio *bio, mempool_t *pool)
163 164
{
	struct bio *bio_orig = bio->bi_private;
165
	struct bio_vec *bvec, orig_vec;
166
	int i;
167
	struct bvec_iter orig_iter = bio_orig->bi_iter;
168 169 170 171

	/*
	 * free up bounce indirect pages used
	 */
172
	bio_for_each_segment_all(bvec, bio, i) {
173 174 175 176 177 178
		orig_vec = bio_iter_iovec(bio_orig, orig_iter);
		if (bvec->bv_page != orig_vec.bv_page) {
			dec_zone_page_state(bvec->bv_page, NR_BOUNCE);
			mempool_free(bvec->bv_page, pool);
		}
		bio_advance_iter(bio_orig, &orig_iter, orig_vec.bv_len);
179 180
	}

181
	bio_orig->bi_status = bio->bi_status;
182
	bio_endio(bio_orig);
183 184 185
	bio_put(bio);
}

186
static void bounce_end_io_write(struct bio *bio)
187
{
188
	bounce_end_io(bio, &page_pool);
189 190
}

191
static void bounce_end_io_write_isa(struct bio *bio)
192 193
{

194
	bounce_end_io(bio, &isa_page_pool);
195 196
}

197
static void __bounce_end_io_read(struct bio *bio, mempool_t *pool)
198 199 200
{
	struct bio *bio_orig = bio->bi_private;

201
	if (!bio->bi_status)
202 203
		copy_to_high_bio_irq(bio_orig, bio);

204
	bounce_end_io(bio, pool);
205 206
}

207
static void bounce_end_io_read(struct bio *bio)
208
{
209
	__bounce_end_io_read(bio, &page_pool);
210 211
}

212
static void bounce_end_io_read_isa(struct bio *bio)
213
{
214
	__bounce_end_io_read(bio, &isa_page_pool);
215 216
}

217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250
static struct bio *bounce_clone_bio(struct bio *bio_src, gfp_t gfp_mask,
		struct bio_set *bs)
{
	struct bvec_iter iter;
	struct bio_vec bv;
	struct bio *bio;

	/*
	 * Pre immutable biovecs, __bio_clone() used to just do a memcpy from
	 * bio_src->bi_io_vec to bio->bi_io_vec.
	 *
	 * We can't do that anymore, because:
	 *
	 *  - The point of cloning the biovec is to produce a bio with a biovec
	 *    the caller can modify: bi_idx and bi_bvec_done should be 0.
	 *
	 *  - The original bio could've had more than BIO_MAX_PAGES biovecs; if
	 *    we tried to clone the whole thing bio_alloc_bioset() would fail.
	 *    But the clone should succeed as long as the number of biovecs we
	 *    actually need to allocate is fewer than BIO_MAX_PAGES.
	 *
	 *  - Lastly, bi_vcnt should not be looked at or relied upon by code
	 *    that does not own the bio - reason being drivers don't use it for
	 *    iterating over the biovec anymore, so expecting it to be kept up
	 *    to date (i.e. for clones that share the parent biovec) is just
	 *    asking for trouble and would force extra work on
	 *    __bio_clone_fast() anyways.
	 */

	bio = bio_alloc_bioset(gfp_mask, bio_segments(bio_src), bs);
	if (!bio)
		return NULL;
	bio->bi_disk		= bio_src->bi_disk;
	bio->bi_opf		= bio_src->bi_opf;
251
	bio->bi_ioprio		= bio_src->bi_ioprio;
252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
	bio->bi_write_hint	= bio_src->bi_write_hint;
	bio->bi_iter.bi_sector	= bio_src->bi_iter.bi_sector;
	bio->bi_iter.bi_size	= bio_src->bi_iter.bi_size;

	switch (bio_op(bio)) {
	case REQ_OP_DISCARD:
	case REQ_OP_SECURE_ERASE:
	case REQ_OP_WRITE_ZEROES:
		break;
	case REQ_OP_WRITE_SAME:
		bio->bi_io_vec[bio->bi_vcnt++] = bio_src->bi_io_vec[0];
		break;
	default:
		bio_for_each_segment(bv, bio_src, iter)
			bio->bi_io_vec[bio->bi_vcnt++] = bv;
		break;
	}

	if (bio_integrity(bio_src)) {
		int ret;

		ret = bio_integrity_clone(bio, bio_src, gfp_mask);
		if (ret < 0) {
			bio_put(bio);
			return NULL;
		}
	}

280
	bio_clone_blkg_association(bio, bio_src);
281
	blkcg_bio_issue_init(bio);
282

283 284 285
	return bio;
}

286
static void __blk_queue_bounce(struct request_queue *q, struct bio **bio_orig,
287
			       mempool_t *pool)
288
{
289 290
	struct bio *bio;
	int rw = bio_data_dir(*bio_orig);
291 292
	struct bio_vec *to, from;
	struct bvec_iter iter;
293 294 295
	unsigned i = 0;
	bool bounce = false;
	int sectors = 0;
296
	bool passthrough = bio_is_passthrough(*bio_orig);
297

298 299 300
	bio_for_each_segment(from, *bio_orig, iter) {
		if (i++ < BIO_MAX_PAGES)
			sectors += from.bv_len >> 9;
301
		if (page_to_pfn(from.bv_page) > q->limits.bounce_pfn)
302 303 304 305 306
			bounce = true;
	}
	if (!bounce)
		return;

307
	if (!passthrough && sectors < bio_sectors(*bio_orig)) {
308
		bio = bio_split(*bio_orig, sectors, GFP_NOIO, &bounce_bio_split);
309 310 311 312
		bio_chain(bio, *bio_orig);
		generic_make_request(*bio_orig);
		*bio_orig = bio;
	}
313
	bio = bounce_clone_bio(*bio_orig, GFP_NOIO, passthrough ? NULL :
314
			&bounce_bio_set);
315

316
	bio_for_each_segment_all(to, bio, i) {
317
		struct page *page = to->bv_page;
318

319
		if (page_to_pfn(page) <= q->limits.bounce_pfn)
320
			continue;
321

322
		to->bv_page = mempool_alloc(pool, q->bounce_gfp);
323
		inc_zone_page_state(to->bv_page, NR_BOUNCE);
324 325 326 327

		if (rw == WRITE) {
			char *vto, *vfrom;

328 329
			flush_dcache_page(page);

330
			vto = page_address(to->bv_page) + to->bv_offset;
331
			vfrom = kmap_atomic(page) + to->bv_offset;
332
			memcpy(vto, vfrom, to->bv_len);
333
			kunmap_atomic(vfrom);
334 335 336
		}
	}

337
	trace_block_bio_bounce(q, *bio_orig);
338

339 340
	bio->bi_flags |= (1 << BIO_BOUNCED);

341
	if (pool == &page_pool) {
342 343 344 345 346 347 348 349 350 351 352 353 354
		bio->bi_end_io = bounce_end_io_write;
		if (rw == READ)
			bio->bi_end_io = bounce_end_io_read;
	} else {
		bio->bi_end_io = bounce_end_io_write_isa;
		if (rw == READ)
			bio->bi_end_io = bounce_end_io_read_isa;
	}

	bio->bi_private = *bio_orig;
	*bio_orig = bio;
}

355
void blk_queue_bounce(struct request_queue *q, struct bio **bio_orig)
356 357 358
{
	mempool_t *pool;

359 360 361
	/*
	 * Data-less bio, nothing to bounce
	 */
362
	if (!bio_has_data(*bio_orig))
363 364
		return;

365 366 367 368 369 370
	/*
	 * for non-isa bounce case, just check if the bounce pfn is equal
	 * to or bigger than the highest pfn in the system -- in that case,
	 * don't waste time iterating over bio segments
	 */
	if (!(q->bounce_gfp & GFP_DMA)) {
371
		if (q->limits.bounce_pfn >= blk_max_pfn)
372
			return;
373
		pool = &page_pool;
374
	} else {
375 376
		BUG_ON(!mempool_initialized(&isa_page_pool));
		pool = &isa_page_pool;
377 378 379 380 381
	}

	/*
	 * slow path
	 */
382
	__blk_queue_bounce(q, bio_orig, pool);
383
}