dm-thin.c 113 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
2
/*
3
 * Copyright (C) 2011-2012 Red Hat UK.
4 5 6 7 8
 *
 * This file is released under the GPL.
 */

#include "dm-thin-metadata.h"
9
#include "dm-bio-prison-v1.h"
10
#include "dm.h"
11 12 13 14

#include <linux/device-mapper.h>
#include <linux/dm-io.h>
#include <linux/dm-kcopyd.h>
15
#include <linux/jiffies.h>
16
#include <linux/log2.h>
17
#include <linux/list.h>
18
#include <linux/rculist.h>
19 20 21
#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
22
#include <linux/vmalloc.h>
23
#include <linux/sort.h>
24
#include <linux/rbtree.h>
25 26 27 28 29 30

#define	DM_MSG_PREFIX	"thin"

/*
 * Tunable constants
 */
31
#define ENDIO_HOOK_POOL_SIZE 1024
32
#define MAPPING_POOL_SIZE 1024
33
#define COMMIT_PERIOD HZ
34 35
#define NO_SPACE_TIMEOUT_SECS 60

36
static unsigned int no_space_timeout_secs = NO_SPACE_TIMEOUT_SECS;
37

38 39 40
DECLARE_DM_KCOPYD_THROTTLE_WITH_MODULE_PARM(snapshot_copy_throttle,
		"A percentage of time allocated for copy on write");

41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
/*
 * The block size of the device holding pool data must be
 * between 64KB and 1GB.
 */
#define DATA_DEV_BLOCK_SIZE_MIN_SECTORS (64 * 1024 >> SECTOR_SHIFT)
#define DATA_DEV_BLOCK_SIZE_MAX_SECTORS (1024 * 1024 * 1024 >> SECTOR_SHIFT)

/*
 * Device id is restricted to 24 bits.
 */
#define MAX_DEV_ID ((1 << 24) - 1)

/*
 * How do we handle breaking sharing of data blocks?
 * =================================================
 *
 * We use a standard copy-on-write btree to store the mappings for the
 * devices (note I'm talking about copy-on-write of the metadata here, not
 * the data).  When you take an internal snapshot you clone the root node
 * of the origin btree.  After this there is no concept of an origin or a
 * snapshot.  They are just two device trees that happen to point to the
 * same data blocks.
 *
 * When we get a write in we decide if it's to a shared data block using
 * some timestamp magic.  If it is, we have to break sharing.
 *
 * Let's say we write to a shared block in what was the origin.  The
 * steps are:
 *
 * i) plug io further to this physical block. (see bio_prison code).
 *
 * ii) quiesce any read io to that shared data block.  Obviously
73
 * including all devices that share this block.  (see dm_deferred_set code)
74 75 76 77 78
 *
 * iii) copy the data block to a newly allocate block.  This step can be
 * missed out if the io covers the block. (schedule_copy).
 *
 * iv) insert the new mapping into the origin's btree
Joe Thornber's avatar
Joe Thornber committed
79
 * (process_prepared_mapping).  This act of inserting breaks some
80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
 * sharing of btree nodes between the two devices.  Breaking sharing only
 * effects the btree of that specific device.  Btrees for the other
 * devices that share the block never change.  The btree for the origin
 * device as it was after the last commit is untouched, ie. we're using
 * persistent data structures in the functional programming sense.
 *
 * v) unplug io to this physical block, including the io that triggered
 * the breaking of sharing.
 *
 * Steps (ii) and (iii) occur in parallel.
 *
 * The metadata _doesn't_ need to be committed before the io continues.  We
 * get away with this because the io is always written to a _new_ block.
 * If there's a crash, then:
 *
 * - The origin mapping will point to the old origin block (the shared
 * one).  This will contain the data as it was before the io that triggered
 * the breaking of sharing came in.
 *
 * - The snap mapping still points to the old block.  As it would after
 * the commit.
 *
 * The downside of this scheme is the timestamp magic isn't perfect, and
 * will continue to think that data block in the snapshot device is shared
 * even after the write to the origin has broken sharing.  I suspect data
 * blocks will typically be shared by many different devices, so we're
 * breaking sharing n + 1 times, rather than n, where n is the number of
 * devices that reference this data block.  At the moment I think the
 * benefits far, far outweigh the disadvantages.
 */

/*----------------------------------------------------------------*/

/*
 * Key building.
 */
116 117 118 119 120
enum lock_space {
	VIRTUAL,
	PHYSICAL
};

121
static bool build_key(struct dm_thin_device *td, enum lock_space ls,
122
		      dm_block_t b, dm_block_t e, struct dm_cell_key *key)
123
{
124
	key->virtual = (ls == VIRTUAL);
125
	key->dev = dm_thin_dev_id(td);
126
	key->block_begin = b;
127
	key->block_end = e;
128 129

	return dm_cell_key_has_valid_range(key);
130 131 132 133 134
}

static void build_data_key(struct dm_thin_device *td, dm_block_t b,
			   struct dm_cell_key *key)
{
135
	(void) build_key(td, PHYSICAL, b, b + 1llu, key);
136 137 138
}

static void build_virtual_key(struct dm_thin_device *td, dm_block_t b,
139
			      struct dm_cell_key *key)
140
{
141
	(void) build_key(td, VIRTUAL, b, b + 1llu, key);
142 143 144 145
}

/*----------------------------------------------------------------*/

Joe Thornber's avatar
Joe Thornber committed
146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166
#define THROTTLE_THRESHOLD (1 * HZ)

struct throttle {
	struct rw_semaphore lock;
	unsigned long threshold;
	bool throttle_applied;
};

static void throttle_init(struct throttle *t)
{
	init_rwsem(&t->lock);
	t->throttle_applied = false;
}

static void throttle_work_start(struct throttle *t)
{
	t->threshold = jiffies + THROTTLE_THRESHOLD;
}

static void throttle_work_update(struct throttle *t)
{
167
	if (!t->throttle_applied && time_is_before_jiffies(t->threshold)) {
Joe Thornber's avatar
Joe Thornber committed
168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192
		down_write(&t->lock);
		t->throttle_applied = true;
	}
}

static void throttle_work_complete(struct throttle *t)
{
	if (t->throttle_applied) {
		t->throttle_applied = false;
		up_write(&t->lock);
	}
}

static void throttle_lock(struct throttle *t)
{
	down_read(&t->lock);
}

static void throttle_unlock(struct throttle *t)
{
	up_read(&t->lock);
}

/*----------------------------------------------------------------*/

193 194 195 196 197
/*
 * A pool device ties together a metadata device and a data device.  It
 * also provides the interface for creating and destroying internal
 * devices.
 */
Mike Snitzer's avatar
Mike Snitzer committed
198
struct dm_thin_new_mapping;
199

200
/*
201
 * The pool runs in various modes.  Ordered in degraded order for comparisons.
202 203 204
 */
enum pool_mode {
	PM_WRITE,		/* metadata may be changed */
205
	PM_OUT_OF_DATA_SPACE,	/* metadata may be changed, though data may not be allocated */
206 207 208 209 210

	/*
	 * Like READ_ONLY, except may switch back to WRITE on metadata resize. Reported as READ_ONLY.
	 */
	PM_OUT_OF_METADATA_SPACE,
211
	PM_READ_ONLY,		/* metadata may not be changed */
212

213 214 215
	PM_FAIL,		/* all I/O fails */
};

216
struct pool_features {
217 218
	enum pool_mode mode;

Mike Snitzer's avatar
Mike Snitzer committed
219 220 221
	bool zero_new_blocks:1;
	bool discard_enabled:1;
	bool discard_passdown:1;
222
	bool error_if_no_space:1;
223 224
};

225 226
struct thin_c;
typedef void (*process_bio_fn)(struct thin_c *tc, struct bio *bio);
227
typedef void (*process_cell_fn)(struct thin_c *tc, struct dm_bio_prison_cell *cell);
228 229
typedef void (*process_mapping_fn)(struct dm_thin_new_mapping *m);

230 231
#define CELL_SORT_ARRAY_SIZE 8192

232 233 234 235 236
struct pool {
	struct list_head list;
	struct dm_target *ti;	/* Only set if a pool target is bound */

	struct mapped_device *pool_md;
237
	struct block_device *data_dev;
238 239 240 241
	struct block_device *md_dev;
	struct dm_pool_metadata *pmd;

	dm_block_t low_water_blocks;
242
	uint32_t sectors_per_block;
243
	int sectors_per_block_shift;
244

245
	struct pool_features pf;
246
	bool low_water_triggered:1;	/* A dm event has been sent */
247
	bool suspended:1;
248
	bool out_of_data_space:1;
249

250
	struct dm_bio_prison *prison;
251 252
	struct dm_kcopyd_client *copier;

253
	struct work_struct worker;
254
	struct workqueue_struct *wq;
Joe Thornber's avatar
Joe Thornber committed
255
	struct throttle throttle;
256
	struct delayed_work waker;
257
	struct delayed_work no_space_timeout;
258

259
	unsigned long last_commit_jiffies;
260
	unsigned int ref_count;
261 262 263

	spinlock_t lock;
	struct bio_list deferred_flush_bios;
264
	struct bio_list deferred_flush_completions;
265
	struct list_head prepared_mappings;
Joe Thornber's avatar
Joe Thornber committed
266
	struct list_head prepared_discards;
267
	struct list_head prepared_discards_pt2;
268
	struct list_head active_thins;
269

270 271
	struct dm_deferred_set *shared_read_ds;
	struct dm_deferred_set *all_io_ds;
272

Mike Snitzer's avatar
Mike Snitzer committed
273
	struct dm_thin_new_mapping *next_mapping;
274 275 276 277

	process_bio_fn process_bio;
	process_bio_fn process_discard;

278 279 280
	process_cell_fn process_cell;
	process_cell_fn process_discard_cell;

281 282
	process_mapping_fn process_prepared_mapping;
	process_mapping_fn process_prepared_discard;
283
	process_mapping_fn process_prepared_discard_pt2;
284

285
	struct dm_bio_prison_cell **cell_sort_array;
286 287

	mempool_t mapping_pool;
288 289
};

290
static void metadata_operation_failed(struct pool *pool, const char *op, int r);
291

292 293 294 295 296 297 298
static enum pool_mode get_pool_mode(struct pool *pool)
{
	return pool->pf.mode;
}

static void notify_of_pool_mode_change(struct pool *pool)
{
299
	static const char *descs[] = {
300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321
		"write",
		"out-of-data-space",
		"read-only",
		"read-only",
		"fail"
	};
	const char *extra_desc = NULL;
	enum pool_mode mode = get_pool_mode(pool);

	if (mode == PM_OUT_OF_DATA_SPACE) {
		if (!pool->pf.error_if_no_space)
			extra_desc = " (queue IO)";
		else
			extra_desc = " (error IO)";
	}

	dm_table_event(pool->ti->table);
	DMINFO("%s: switching pool to %s%s mode",
	       dm_device_name(pool->pool_md),
	       descs[(int)mode], extra_desc ? : "");
}

322 323 324 325 326 327 328 329 330 331
/*
 * Target context for a pool.
 */
struct pool_c {
	struct dm_target *ti;
	struct pool *pool;
	struct dm_dev *data_dev;
	struct dm_dev *metadata_dev;

	dm_block_t low_water_blocks;
332 333
	struct pool_features requested_pf; /* Features requested during table load */
	struct pool_features adjusted_pf;  /* Features used after adjusting for constituent devices */
334 335 336 337 338 339
};

/*
 * Target context for a thin.
 */
struct thin_c {
340
	struct list_head list;
341
	struct dm_dev *pool_dev;
342
	struct dm_dev *origin_dev;
343
	sector_t origin_size;
344 345 346 347
	dm_thin_id dev_id;

	struct pool *pool;
	struct dm_thin_device *td;
348 349
	struct mapped_device *thin_md;

350
	bool requeue_mode:1;
351
	spinlock_t lock;
352
	struct list_head deferred_cells;
353 354
	struct bio_list deferred_bio_list;
	struct bio_list retry_on_resume_list;
355
	struct rb_root sort_bio_list; /* sorted list of deferred bios */
356 357 358 359 360

	/*
	 * Ensures the thin is not destroyed until the worker has finished
	 * iterating the active_thins list.
	 */
361
	refcount_t refcount;
362
	struct completion can_destroy;
363 364 365 366
};

/*----------------------------------------------------------------*/

367 368 369 370 371 372 373 374 375 376 377 378
static bool block_size_is_power_of_two(struct pool *pool)
{
	return pool->sectors_per_block_shift >= 0;
}

static sector_t block_to_sectors(struct pool *pool, dm_block_t b)
{
	return block_size_is_power_of_two(pool) ?
		(b << pool->sectors_per_block_shift) :
		(b * pool->sectors_per_block);
}

379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
/*----------------------------------------------------------------*/

struct discard_op {
	struct thin_c *tc;
	struct blk_plug plug;
	struct bio *parent_bio;
	struct bio *bio;
};

static void begin_discard(struct discard_op *op, struct thin_c *tc, struct bio *parent)
{
	BUG_ON(!parent);

	op->tc = tc;
	blk_start_plug(&op->plug);
	op->parent_bio = parent;
	op->bio = NULL;
}

static int issue_discard(struct discard_op *op, dm_block_t data_b, dm_block_t data_e)
399
{
400
	struct thin_c *tc = op->tc;
401 402
	sector_t s = block_to_sectors(tc->pool, data_b);
	sector_t len = block_to_sectors(tc->pool, data_e - data_b);
403

404
	return __blkdev_issue_discard(tc->pool_dev->bdev, s, len, GFP_NOIO, &op->bio);
405 406 407 408 409 410 411 412 413 414
}

static void end_discard(struct discard_op *op, int r)
{
	if (op->bio) {
		/*
		 * Even if one of the calls to issue_discard failed, we
		 * need to wait for the chain to complete.
		 */
		bio_chain(op->bio, op->parent_bio);
415
		op->bio->bi_opf = REQ_OP_DISCARD;
416
		submit_bio(op->bio);
417
	}
418

419 420 421 422 423 424
	blk_finish_plug(&op->plug);

	/*
	 * Even if r is set, there could be sub discards in flight that we
	 * need to wait for.
	 */
425 426
	if (r && !op->parent_bio->bi_status)
		op->parent_bio->bi_status = errno_to_blk_status(r);
427
	bio_endio(op->parent_bio);
428 429 430 431
}

/*----------------------------------------------------------------*/

432 433 434 435 436 437 438 439 440 441 442
/*
 * wake_worker() is used when new work is queued and when pool_resume is
 * ready to continue deferred IO processing.
 */
static void wake_worker(struct pool *pool)
{
	queue_work(pool->wq, &pool->worker);
}

/*----------------------------------------------------------------*/

443 444 445 446 447 448 449 450 451 452 453 454 455
static int bio_detain(struct pool *pool, struct dm_cell_key *key, struct bio *bio,
		      struct dm_bio_prison_cell **cell_result)
{
	int r;
	struct dm_bio_prison_cell *cell_prealloc;

	/*
	 * Allocate a cell from the prison's mempool.
	 * This might block but it can't fail.
	 */
	cell_prealloc = dm_bio_prison_alloc_cell(pool->prison, GFP_NOIO);

	r = dm_bio_detain(pool->prison, key, bio, cell_prealloc, cell_result);
456
	if (r) {
457 458 459 460 461
		/*
		 * We reused an old cell; we can get rid of
		 * the new one.
		 */
		dm_bio_prison_free_cell(pool->prison, cell_prealloc);
462
	}
463 464 465 466 467 468 469 470 471 472 473 474

	return r;
}

static void cell_release(struct pool *pool,
			 struct dm_bio_prison_cell *cell,
			 struct bio_list *bios)
{
	dm_cell_release(pool->prison, cell, bios);
	dm_bio_prison_free_cell(pool->prison, cell);
}

475 476 477 478 479 480 481 482 483
static void cell_visit_release(struct pool *pool,
			       void (*fn)(void *, struct dm_bio_prison_cell *),
			       void *context,
			       struct dm_bio_prison_cell *cell)
{
	dm_cell_visit_release(pool->prison, fn, context, cell);
	dm_bio_prison_free_cell(pool->prison, cell);
}

484 485 486 487 488 489 490 491
static void cell_release_no_holder(struct pool *pool,
				   struct dm_bio_prison_cell *cell,
				   struct bio_list *bios)
{
	dm_cell_release_no_holder(pool->prison, cell, bios);
	dm_bio_prison_free_cell(pool->prison, cell);
}

492
static void cell_error_with_code(struct pool *pool,
493
		struct dm_bio_prison_cell *cell, blk_status_t error_code)
494
{
495
	dm_cell_error(pool->prison, cell, error_code);
496 497 498
	dm_bio_prison_free_cell(pool->prison, cell);
}

499
static blk_status_t get_pool_io_error_code(struct pool *pool)
500
{
501
	return pool->out_of_data_space ? BLK_STS_NOSPC : BLK_STS_IOERR;
502 503
}

504 505
static void cell_error(struct pool *pool, struct dm_bio_prison_cell *cell)
{
506
	cell_error_with_code(pool, cell, get_pool_io_error_code(pool));
507 508
}

509 510 511 512 513 514 515
static void cell_success(struct pool *pool, struct dm_bio_prison_cell *cell)
{
	cell_error_with_code(pool, cell, 0);
}

static void cell_requeue(struct pool *pool, struct dm_bio_prison_cell *cell)
{
516
	cell_error_with_code(pool, cell, BLK_STS_DM_REQUEUE);
517 518
}

519 520
/*----------------------------------------------------------------*/

521 522 523 524 525 526 527 528 529 530 531 532 533 534
/*
 * A global list of pools that uses a struct mapped_device as a key.
 */
static struct dm_thin_pool_table {
	struct mutex mutex;
	struct list_head pools;
} dm_thin_pool_table;

static void pool_table_init(void)
{
	mutex_init(&dm_thin_pool_table.mutex);
	INIT_LIST_HEAD(&dm_thin_pool_table.pools);
}

535 536 537 538 539
static void pool_table_exit(void)
{
	mutex_destroy(&dm_thin_pool_table.mutex);
}

540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585
static void __pool_table_insert(struct pool *pool)
{
	BUG_ON(!mutex_is_locked(&dm_thin_pool_table.mutex));
	list_add(&pool->list, &dm_thin_pool_table.pools);
}

static void __pool_table_remove(struct pool *pool)
{
	BUG_ON(!mutex_is_locked(&dm_thin_pool_table.mutex));
	list_del(&pool->list);
}

static struct pool *__pool_table_lookup(struct mapped_device *md)
{
	struct pool *pool = NULL, *tmp;

	BUG_ON(!mutex_is_locked(&dm_thin_pool_table.mutex));

	list_for_each_entry(tmp, &dm_thin_pool_table.pools, list) {
		if (tmp->pool_md == md) {
			pool = tmp;
			break;
		}
	}

	return pool;
}

static struct pool *__pool_table_lookup_metadata_dev(struct block_device *md_dev)
{
	struct pool *pool = NULL, *tmp;

	BUG_ON(!mutex_is_locked(&dm_thin_pool_table.mutex));

	list_for_each_entry(tmp, &dm_thin_pool_table.pools, list) {
		if (tmp->md_dev == md_dev) {
			pool = tmp;
			break;
		}
	}

	return pool;
}

/*----------------------------------------------------------------*/

Mike Snitzer's avatar
Mike Snitzer committed
586
struct dm_thin_endio_hook {
587
	struct thin_c *tc;
588 589
	struct dm_deferred_entry *shared_read_entry;
	struct dm_deferred_entry *all_io_entry;
Mike Snitzer's avatar
Mike Snitzer committed
590
	struct dm_thin_new_mapping *overwrite_mapping;
591
	struct rb_node rb_node;
592
	struct dm_bio_prison_cell *cell;
593 594
};

595 596 597 598 599 600
static void __merge_bio_list(struct bio_list *bios, struct bio_list *master)
{
	bio_list_merge(bios, master);
	bio_list_init(master);
}

601
static void error_bio_list(struct bio_list *bios, blk_status_t error)
602 603
{
	struct bio *bio;
604

605
	while ((bio = bio_list_pop(bios))) {
606
		bio->bi_status = error;
607 608
		bio_endio(bio);
	}
609 610
}

611 612
static void error_thin_bio_list(struct thin_c *tc, struct bio_list *master,
		blk_status_t error)
613
{
614 615 616
	struct bio_list bios;

	bio_list_init(&bios);
617

618
	spin_lock_irq(&tc->lock);
619
	__merge_bio_list(&bios, master);
620
	spin_unlock_irq(&tc->lock);
621

622
	error_bio_list(&bios, error);
623 624
}

625 626 627 628 629 630 631 632
static void requeue_deferred_cells(struct thin_c *tc)
{
	struct pool *pool = tc->pool;
	struct list_head cells;
	struct dm_bio_prison_cell *cell, *tmp;

	INIT_LIST_HEAD(&cells);

633
	spin_lock_irq(&tc->lock);
634
	list_splice_init(&tc->deferred_cells, &cells);
635
	spin_unlock_irq(&tc->lock);
636 637 638 639 640

	list_for_each_entry_safe(cell, tmp, &cells, user_list)
		cell_requeue(pool, cell);
}

641 642
static void requeue_io(struct thin_c *tc)
{
643 644 645 646
	struct bio_list bios;

	bio_list_init(&bios);

647
	spin_lock_irq(&tc->lock);
648 649
	__merge_bio_list(&bios, &tc->deferred_bio_list);
	__merge_bio_list(&bios, &tc->retry_on_resume_list);
650
	spin_unlock_irq(&tc->lock);
651

652
	error_bio_list(&bios, BLK_STS_DM_REQUEUE);
653
	requeue_deferred_cells(tc);
654 655
}

656
static void error_retry_list_with_code(struct pool *pool, blk_status_t error)
657 658 659 660 661
{
	struct thin_c *tc;

	rcu_read_lock();
	list_for_each_entry_rcu(tc, &pool->active_thins, list)
662
		error_thin_bio_list(tc, &tc->retry_on_resume_list, error);
663 664 665
	rcu_read_unlock();
}

666 667
static void error_retry_list(struct pool *pool)
{
668
	error_retry_list_with_code(pool, get_pool_io_error_code(pool));
669 670
}

671 672 673 674 675 676 677 678 679
/*
 * This section of code contains the logic for processing a thin device's IO.
 * Much of the code depends on pool object resources (lists, workqueues, etc)
 * but most is exclusively called from the thin target rather than the thin-pool
 * target.
 */

static dm_block_t get_bio_block(struct thin_c *tc, struct bio *bio)
{
680
	struct pool *pool = tc->pool;
681
	sector_t block_nr = bio->bi_iter.bi_sector;
682

683 684
	if (block_size_is_power_of_two(pool))
		block_nr >>= pool->sectors_per_block_shift;
685
	else
686
		(void) sector_div(block_nr, pool->sectors_per_block);
687 688

	return block_nr;
689 690
}

691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710
/*
 * Returns the _complete_ blocks that this bio covers.
 */
static void get_bio_block_range(struct thin_c *tc, struct bio *bio,
				dm_block_t *begin, dm_block_t *end)
{
	struct pool *pool = tc->pool;
	sector_t b = bio->bi_iter.bi_sector;
	sector_t e = b + (bio->bi_iter.bi_size >> SECTOR_SHIFT);

	b += pool->sectors_per_block - 1ull; /* so we round up */

	if (block_size_is_power_of_two(pool)) {
		b >>= pool->sectors_per_block_shift;
		e >>= pool->sectors_per_block_shift;
	} else {
		(void) sector_div(b, pool->sectors_per_block);
		(void) sector_div(e, pool->sectors_per_block);
	}

711
	if (e < b) {
712 713
		/* Can happen if the bio is within a single block. */
		e = b;
714
	}
715 716 717 718 719

	*begin = b;
	*end = e;
}

720 721 722
static void remap(struct thin_c *tc, struct bio *bio, dm_block_t block)
{
	struct pool *pool = tc->pool;
723
	sector_t bi_sector = bio->bi_iter.bi_sector;
724

725
	bio_set_dev(bio, tc->pool_dev->bdev);
726
	if (block_size_is_power_of_two(pool)) {
727 728 729
		bio->bi_iter.bi_sector =
			(block << pool->sectors_per_block_shift) |
			(bi_sector & (pool->sectors_per_block - 1));
730
	} else {
731
		bio->bi_iter.bi_sector = (block * pool->sectors_per_block) +
732
				 sector_div(bi_sector, pool->sectors_per_block);
733
	}
734 735
}

736 737
static void remap_to_origin(struct thin_c *tc, struct bio *bio)
{
738
	bio_set_dev(bio, tc->origin_dev->bdev);
739 740
}

741 742
static int bio_triggers_commit(struct thin_c *tc, struct bio *bio)
{
743
	return op_is_flush(bio->bi_opf) &&
744 745 746
		dm_thin_changed_this_transaction(tc->td);
}

747 748 749 750
static void inc_all_io_entry(struct pool *pool, struct bio *bio)
{
	struct dm_thin_endio_hook *h;

Mike Christie's avatar
Mike Christie committed
751
	if (bio_op(bio) == REQ_OP_DISCARD)
752 753
		return;

754
	h = dm_per_bio_data(bio, sizeof(struct dm_thin_endio_hook));
755 756 757
	h->all_io_entry = dm_deferred_entry_inc(pool->all_io_ds);
}

758
static void issue(struct thin_c *tc, struct bio *bio)
759 760 761
{
	struct pool *pool = tc->pool;

762
	if (!bio_triggers_commit(tc, bio)) {
763
		dm_submit_bio_remap(bio, NULL);
764 765 766
		return;
	}

767
	/*
768 769 770
	 * Complete bio with an error if earlier I/O caused changes to
	 * the metadata that can't be committed e.g, due to I/O errors
	 * on the metadata device.
771
	 */
772 773 774 775 776 777 778 779 780
	if (dm_thin_aborted_changes(tc->td)) {
		bio_io_error(bio);
		return;
	}

	/*
	 * Batch together any bios that trigger commits and then issue a
	 * single commit for them in process_deferred_bios().
	 */
781
	spin_lock_irq(&pool->lock);
782
	bio_list_add(&pool->deferred_flush_bios, bio);
783
	spin_unlock_irq(&pool->lock);
784 785
}

786 787 788 789 790 791 792 793 794 795 796 797 798
static void remap_to_origin_and_issue(struct thin_c *tc, struct bio *bio)
{
	remap_to_origin(tc, bio);
	issue(tc, bio);
}

static void remap_and_issue(struct thin_c *tc, struct bio *bio,
			    dm_block_t block)
{
	remap(tc, bio, block);
	issue(tc, bio);
}

799 800 801 802 803
/*----------------------------------------------------------------*/

/*
 * Bio endio functions.
 */
Mike Snitzer's avatar
Mike Snitzer committed
804
struct dm_thin_new_mapping {
805 806
	struct list_head list;

807
	bool pass_discard:1;
808
	bool maybe_shared:1;
809

810 811 812 813 814 815 816
	/*
	 * Track quiescing, copying and zeroing preparation actions.  When this
	 * counter hits zero the block is prepared and can be inserted into the
	 * btree.
	 */
	atomic_t prepare_actions;

817
	blk_status_t status;
818
	struct thin_c *tc;
819
	dm_block_t virt_begin, virt_end;
820
	dm_block_t data_block;
821
	struct dm_bio_prison_cell *cell;
822 823 824 825 826 827 828 829 830 831 832

	/*
	 * If the bio covers the whole area of a block then we can avoid
	 * zeroing or copying.  Instead this bio is hooked.  The bio will
	 * still be in the cell, so care has to be taken to avoid issuing
	 * the bio twice.
	 */
	struct bio *bio;
	bio_end_io_t *saved_bi_end_io;
};

833
static void __complete_mapping_preparation(struct dm_thin_new_mapping *m)
834 835 836
{
	struct pool *pool = m->tc->pool;

837
	if (atomic_dec_and_test(&m->prepare_actions)) {
838
		list_add_tail(&m->list, &pool->prepared_mappings);
839 840 841 842
		wake_worker(pool);
	}
}

843
static void complete_mapping_preparation(struct dm_thin_new_mapping *m)
844 845 846 847 848
{
	unsigned long flags;
	struct pool *pool = m->tc->pool;

	spin_lock_irqsave(&pool->lock, flags);
849
	__complete_mapping_preparation(m);
850 851 852
	spin_unlock_irqrestore(&pool->lock, flags);
}

853 854 855 856
static void copy_complete(int read_err, unsigned long write_err, void *context)
{
	struct dm_thin_new_mapping *m = context;

857
	m->status = read_err || write_err ? BLK_STS_IOERR : 0;
858 859 860
	complete_mapping_preparation(m);
}

861
static void overwrite_endio(struct bio *bio)
862
{
863
	struct dm_thin_endio_hook *h = dm_per_bio_data(bio, sizeof(struct dm_thin_endio_hook));
Mike Snitzer's avatar
Mike Snitzer committed
864
	struct dm_thin_new_mapping *m = h->overwrite_mapping;
865

866 867
	bio->bi_end_io = m->saved_bi_end_io;

868
	m->status = bio->bi_status;
869
	complete_mapping_preparation(m);
870 871 872 873 874 875 876 877 878 879 880 881 882
}

/*----------------------------------------------------------------*/

/*
 * Workqueue.
 */

/*
 * Prepared mapping jobs.
 */

/*
883 884
 * This sends the bios in the cell, except the original holder, back
 * to the deferred_bios list.
885
 */
886
static void cell_defer_no_holder(struct thin_c *tc, struct dm_bio_prison_cell *cell)
887 888 889
{
	struct pool *pool = tc->pool;
	unsigned long flags;
890
	struct bio_list bios;
891

892 893
	bio_list_init(&bios);
	cell_release_no_holder(pool, cell, &bios);
894

895 896 897 898
	if (!bio_list_empty(&bios)) {
		spin_lock_irqsave(&tc->lock, flags);
		bio_list_merge(&tc->deferred_bio_list, &bios);
		spin_unlock_irqrestore(&tc->lock, flags);
899
		wake_worker(pool);
900
	}
901 902
}

903 904
static void thin_defer_bio(struct thin_c *tc, struct bio *bio);

905 906 907 908 909 910 911 912
struct remap_info {
	struct thin_c *tc;
	struct bio_list defer_bios;
	struct bio_list issue_bios;
};

static void __inc_remap_and_issue_cell(void *context,
				       struct dm_bio_prison_cell *cell)
913
{
914
	struct remap_info *info = context;
915 916
	struct bio *bio;

917
	while ((bio = bio_list_pop(&cell->bios))) {
918
		if (op_is_flush(bio->bi_opf) || bio_op(bio) == REQ_OP_DISCARD)
919
			bio_list_add(&info->defer_bios, bio);
920
		else {
921 922 923 924 925 926 927 928
			inc_all_io_entry(info->tc->pool, bio);

			/*
			 * We can't issue the bios with the bio prison lock
			 * held, so we add them to a list to issue on
			 * return from this function.
			 */
			bio_list_add(&info->issue_bios, bio);
929 930 931 932
		}
	}
}

933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958
static void inc_remap_and_issue_cell(struct thin_c *tc,
				     struct dm_bio_prison_cell *cell,
				     dm_block_t block)
{
	struct bio *bio;
	struct remap_info info;

	info.tc = tc;
	bio_list_init(&info.defer_bios);
	bio_list_init(&info.issue_bios);

	/*
	 * We have to be careful to inc any bios we're about to issue
	 * before the cell is released, and avoid a race with new bios
	 * being added to the cell.
	 */
	cell_visit_release(tc->pool, __inc_remap_and_issue_cell,
			   &info, cell);

	while ((bio = bio_list_pop(&info.defer_bios)))
		thin_defer_bio(tc, bio);

	while ((bio = bio_list_pop(&info.issue_bios)))
		remap_and_issue(info.tc, bio, block);
}

959 960
static void process_prepared_mapping_fail(struct dm_thin_new_mapping *m)
{
961
	cell_error(m->tc->pool, m->cell);
962
	list_del(&m->list);
963
	mempool_free(m, &m->tc->pool->mapping_pool);
964
}
965

966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992
static void complete_overwrite_bio(struct thin_c *tc, struct bio *bio)
{
	struct pool *pool = tc->pool;

	/*
	 * If the bio has the REQ_FUA flag set we must commit the metadata
	 * before signaling its completion.
	 */
	if (!bio_triggers_commit(tc, bio)) {
		bio_endio(bio);
		return;
	}

	/*
	 * Complete bio with an error if earlier I/O caused changes to the
	 * metadata that can't be committed, e.g, due to I/O errors on the
	 * metadata device.
	 */
	if (dm_thin_aborted_changes(tc->td)) {
		bio_io_error(bio);
		return;
	}

	/*
	 * Batch together any bios that trigger commits and then issue a
	 * single commit for them in process_deferred_bios().
	 */
993
	spin_lock_irq(&pool->lock);
994
	bio_list_add(&pool->deferred_flush_completions, bio);
995
	spin_unlock_irq(&pool->lock);
996 997
}

Mike Snitzer's avatar
Mike Snitzer committed
998
static void process_prepared_mapping(struct dm_thin_new_mapping *m)
999 1000
{
	struct thin_c *tc = m->tc;
1001
	struct pool *pool = tc->pool;
1002
	struct bio *bio = m->bio;
1003 1004
	int r;

1005
	if (m->status) {
1006
		cell_error(pool, m->cell);
1007
		goto out;
1008 1009 1010 1011 1012 1013 1014
	}

	/*
	 * Commit the prepared block into the mapping btree.
	 * Any I/O for this block arriving after this point will get
	 * remapped to it directly.
	 */
1015
	r = dm_thin_insert_block(tc->td, m->virt_begin, m->data_block);
1016
	if (r) {
1017
		metadata_operation_failed(pool, "dm_thin_insert_block", r);
1018
		cell_error(pool, m->cell);
1019
		goto out;
1020 1021 1022 1023 1024 1025 1026 1027 1028
	}

	/*
	 * Release any bios held while the block was being provisioned.
	 * If we are processing a write bio that completely covers the block,
	 * we already processed it so can ignore it now when processing
	 * the bios in the cell.
	 */
	if (bio) {
1029
		inc_remap_and_issue_cell(tc, m->cell, m->data_block);
1030
		complete_overwrite_bio(tc, bio);
1031 1032 1033 1034 1035
	} else {
		inc_all_io_entry(tc->pool, m->cell->holder);
		remap_and_issue(tc, m->cell->holder, m->data_block);
		inc_remap_and_issue_cell(tc, m->cell, m->data_block);
	}
1036

1037
out:
1038
	list_del(&m->list);
1039
	mempool_free(m, &pool->mapping_pool);
1040 1041
}

1042 1043 1044
/*----------------------------------------------------------------*/

static void free_discard_mapping(struct dm_thin_new_mapping *m)
Joe Thornber's avatar
Joe Thornber committed
1045 1046
{
	struct thin_c *tc = m->tc;
1047

1048 1049
	if (m->cell)
		cell_defer_no_holder(tc, m->cell);
1050
	mempool_free(m, &tc->pool->mapping_pool);
1051
}
Joe Thornber's avatar
Joe Thornber committed
1052

1053 1054
static void process_prepared_discard_fail(struct dm_thin_new_mapping *m)
{
1055
	bio_io_error(m->bio);
1056 1057 1058 1059 1060
	free_discard_mapping(m);
}

static void process_prepared_discard_success(struct dm_thin_new_mapping *m)
{
1061
	bio_endio(m->bio);
1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
	free_discard_mapping(m);
}

static void process_prepared_discard_no_passdown(struct dm_thin_new_mapping *m)
{
	int r;
	struct thin_c *tc = m->tc;

	r = dm_thin_remove_range(tc->td, m->cell->key.block_begin, m->cell->key.block_end);
	if (r) {
		metadata_operation_failed(tc->pool, "dm_thin_remove_range", r);
		bio_io_error(m->bio);
	} else
1075
		bio_endio(m->bio);
1076

1077
	cell_defer_no_holder(tc, m->cell);
1078
	mempool_free(m, &tc->pool->mapping_pool);
1079 1080
}

1081 1082
/*----------------------------------------------------------------*/

1083 1084
static void passdown_double_checking_shared_status(struct dm_thin_new_mapping *m,
						   struct bio *discard_parent)
1085
{
1086 1087 1088 1089
	/*
	 * We've already unmapped this range of blocks, but before we
	 * passdown we have to check that these blocks are now unused.
	 */
1090
	int r = 0;
1091
	bool shared = true;
1092
	struct thin_c *tc = m->tc;
1093 1094
	struct pool *pool = tc->pool;
	dm_block_t b = m->data_block, e, end = m->data_block + m->virt_end - m->virt_begin;
1095
	struct discard_op op;
Joe Thornber's avatar
Joe Thornber committed
1096

1097
	begin_discard(&op, tc, discard_parent);
1098 1099 1100
	while (b != end) {
		/* find start of unmapped run */
		for (; b < end; b++) {
1101
			r = dm_pool_block_is_shared(pool->pmd, b, &shared);
1102
			if (r)
1103
				goto out;
1104

1105
			if (!shared)
1106
				break;
1107
		}
Joe Thornber's avatar
Joe Thornber committed
1108

1109 1110 1111 1112 1113
		if (b == end)
			break;

		/* find end of run */
		for (e = b + 1; e != end; e++) {
1114
			r = dm_pool_block_is_shared(pool->pmd, e, &shared);
1115
			if (r)
1116
				goto out;
1117

1118
			if (shared)
1119 1120 1121
				break;
		}

1122
		r = issue_discard(&op, b, e);
1123
		if (r)
1124
			goto out;
1125 1126 1127

		b = e;
	}
1128 1129
out:
	end_discard(&op, r);
Joe Thornber's avatar
Joe Thornber committed
1130 1131
}

1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149
static void queue_passdown_pt2(struct dm_thin_new_mapping *m)
{
	unsigned long flags;
	struct pool *pool = m->tc->pool;

	spin_lock_irqsave(&pool->lock, flags);
	list_add_tail(&m->list, &pool->prepared_discards_pt2);
	spin_unlock_irqrestore(&pool->lock, flags);
	wake_worker(pool);
}

static void passdown_endio(struct bio *bio)
{
	/*
	 * It doesn't matter if the passdown discard failed, we still want
	 * to unmap (we ignore err).
	 */
	queue_passdown_pt2(bio->bi_private);
1150
	bio_put(bio);
1151 1152 1153
}

static void process_prepared_discard_passdown_pt1(struct dm_thin_new_mapping *m)
1154 1155 1156
{
	int r;
	struct thin_c *tc = m->tc;
1157
	struct pool *pool = tc->pool;
1158 1159
	struct bio *discard_parent;
	dm_block_t data_end = m->data_block + (m->virt_end - m->virt_begin);
1160

1161 1162 1163 1164 1165
	/*
	 * Only this thread allocates blocks, so we can be sure that the
	 * newly unmapped blocks will not be allocated before the end of
	 * the function.
	 */
1166
	r = dm_thin_remove_range(tc->td, m->virt_begin, m->virt_end);
1167
	if (r) {
1168
		metadata_operation_failed(pool, "dm_thin_remove_range", r);
1169
		bio_io_error(m->bio);
1170
		cell_defer_no_holder(tc, m->cell);
1171
		mempool_free(m, &pool->mapping_pool);
1172 1173
		return;
	}
1174

1175 1176 1177 1178 1179 1180 1181 1182 1183
	/*
	 * Increment the unmapped blocks.  This prevents a race between the
	 * passdown io and reallocation of freed blocks.
	 */
	r = dm_pool_inc_data_range(pool->pmd, m->data_block, data_end);
	if (r) {
		metadata_operation_failed(pool, "dm_pool_inc_data_range", r);
		bio_io_error(m->bio);
		cell_defer_no_holder(tc, m->cell);
1184
		mempool_free(m, &pool->mapping_pool);
1185 1186 1187
		return;
	}

1188
	discard_parent = bio_alloc(NULL, 1, 0, GFP_NOIO);
1189 1190
	discard_parent->bi_end_io = passdown_endio;
	discard_parent->bi_private = m;
1191 1192 1193
	if (m->maybe_shared)
		passdown_double_checking_shared_status(m, discard_parent);
	else {
1194
		struct discard_op op;
1195

1196 1197 1198
		begin_discard(&op, tc, discard_parent);
		r = issue_discard(&op, m->data_block, data_end);
		end_discard(&op, r);
1199
	}
1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219
}

static void process_prepared_discard_passdown_pt2(struct dm_thin_new_mapping *m)
{
	int r;
	struct thin_c *tc = m->tc;
	struct pool *pool = tc->pool;

	/*
	 * The passdown has completed, so now we can decrement all those
	 * unmapped blocks.
	 */
	r = dm_pool_dec_data_range(pool->pmd, m->data_block,
				   m->data_block + (m->virt_end - m->virt_begin));
	if (r) {
		metadata_operation_failed(pool, "dm_pool_dec_data_range", r);
		bio_io_error(m->bio);
	} else
		bio_endio(m->bio);

1220
	cell_defer_no_holder(tc, m->cell);
1221
	mempool_free(m, &pool->mapping_pool);
1222 1223
}

Joe Thornber's avatar
Joe Thornber committed
1224
static void process_prepared(struct pool *pool, struct list_head *head,
1225
			     process_mapping_fn *fn)
1226 1227
{
	struct list_head maps;
Mike Snitzer's avatar
Mike Snitzer committed
1228
	struct dm_thin_new_mapping *m, *tmp;
1229 1230

	INIT_LIST_HEAD(&maps);
1231
	spin_lock_irq(&pool->lock);
Joe Thornber's avatar
Joe Thornber committed
1232
	list_splice_init(head, &maps);
1233
	spin_unlock_irq(&pool->lock);
1234 1235

	list_for_each_entry_safe(m, tmp, &maps, list)
1236
		(*fn)(m);
1237 1238 1239 1240 1241
}

/*
 * Deferred bio jobs.
 */
Joe Thornber's avatar
Joe Thornber committed
1242
static int io_overlaps_block(struct pool *pool, struct bio *bio)
1243
{
1244 1245
	return bio->bi_iter.bi_size ==
		(pool->sectors_per_block << SECTOR_SHIFT);
Joe Thornber's avatar
Joe Thornber committed
1246 1247 1248 1249 1250 1251
}

static int io_overwrites_block(struct pool *pool, struct bio *bio)
{
	return (bio_data_dir(bio) == WRITE) &&
		io_overlaps_block(pool, bio);
1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265
}

static void save_and_set_endio(struct bio *bio, bio_end_io_t **save,
			       bio_end_io_t *fn)
{
	*save = bio->bi_end_io;
	bio->bi_end_io = fn;
}

static int ensure_next_mapping(struct pool *pool)
{
	if (pool->next_mapping)
		return 0;

1266
	pool->next_mapping = mempool_alloc(&pool->mapping_pool, GFP_ATOMIC);
1267 1268 1269 1270

	return pool->next_mapping ? 0 : -ENOMEM;
}

Mike Snitzer's avatar
Mike Snitzer committed
1271
static struct dm_thin_new_mapping *get_next_mapping(struct pool *pool)
1272
{
1273
	struct dm_thin_new_mapping *m = pool->next_mapping;
1274 1275 1276

	BUG_ON(!pool->next_mapping);

1277 1278 1279 1280
	memset(m, 0, sizeof(struct dm_thin_new_mapping));
	INIT_LIST_HEAD(&m->list);
	m->bio = NULL;

1281 1282
	pool->next_mapping = NULL;

1283
	return m;
1284 1285
}

1286 1287 1288 1289 1290 1291 1292 1293 1294
static void ll_zero(struct thin_c *tc, struct dm_thin_new_mapping *m,
		    sector_t begin, sector_t end)
{
	struct dm_io_region to;

	to.bdev = tc->pool_dev->bdev;
	to.sector = begin;
	to.count = end - begin;

1295
	dm_kcopyd_zero(tc->pool->copier, 1, &to, 0, copy_complete, m);
1296 1297
}

1298
static void remap_and_issue_overwrite(struct thin_c *tc, struct bio *bio,
1299
				      dm_block_t data_begin,
1300 1301 1302 1303 1304 1305 1306 1307 1308
				      struct dm_thin_new_mapping *m)
{
	struct pool *pool = tc->pool;
	struct dm_thin_endio_hook *h = dm_per_bio_data(bio, sizeof(struct dm_thin_endio_hook));

	h->overwrite_mapping = m;
	m->bio = bio;
	save_and_set_endio(bio, &m->saved_bi_end_io, overwrite_endio);
	inc_all_io_entry(pool, bio);
1309
	remap_and_issue(tc, bio, data_begin);
1310 1311
}

1312 1313 1314
/*
 * A partial copy also needs to zero the uncopied region.
 */
1315
static void schedule_copy(struct thin_c *tc, dm_block_t virt_block,
1316 1317
			  struct dm_dev *origin, dm_block_t data_origin,
			  dm_block_t data_dest,
1318 1319
			  struct dm_bio_prison_cell *cell, struct bio *bio,
			  sector_t len)
1320 1321
{
	struct pool *pool = tc->pool;
Mike Snitzer's avatar
Mike Snitzer committed
1322
	struct dm_thin_new_mapping *m = get_next_mapping(pool);
1323 1324

	m->tc = tc;
1325 1326
	m->virt_begin = virt_block;
	m->virt_end = virt_block + 1u;
1327 1328 1329
	m->data_block = data_dest;
	m->cell = cell;

1330 1331 1332 1333 1334 1335 1336
	/*
	 * quiesce action + copy action + an extra reference held for the
	 * duration of this function (we may need to inc later for a
	 * partial zero).
	 */
	atomic_set(&m->prepare_actions, 3);

1337
	if (!dm_deferred_set_add_work(pool->shared_read_ds, &m->list))
1338
		complete_mapping_preparation(m); /* already quiesced */
1339 1340 1341 1342 1343 1344 1345

	/*
	 * IO to pool_dev remaps to the pool target's data_dev.
	 *
	 * If the whole block of data is being overwritten, we can issue the
	 * bio immediately. Otherwise we use kcopyd to clone the data first.
	 */
1346 1347 1348
	if (io_overwrites_block(pool, bio))
		remap_and_issue_overwrite(tc, bio, data_dest, m);
	else {
1349 1350
		struct dm_io_region from, to;

1351
		from.bdev = origin->bdev;
1352
		from.sector = data_origin * pool->sectors_per_block;
1353
		from.count = len;
1354 1355 1356

		to.bdev = tc->pool_dev->bdev;
		to.sector = data_dest * pool->sectors_per_block;
1357
		to.count = len;
1358

1359 1360
		dm_kcopyd_copy(pool->copier, &from, 1, &to,
			       0, copy_complete, m);
1361 1362 1363 1364 1365 1366 1367 1368 1369

		/*
		 * Do we need to zero a tail region?
		 */
		if (len < pool->sectors_per_block && pool->pf.zero_new_blocks) {
			atomic_inc(&m->prepare_actions);
			ll_zero(tc, m,
				data_dest * pool->sectors_per_block + len,
				(data_dest + 1) * pool->sectors_per_block);
1370 1371
		}
	}
1372 1373

	complete_mapping_preparation(m); /* drop our ref */
1374 1375
}

1376 1377
static void schedule_internal_copy(struct thin_c *tc, dm_block_t virt_block,
				   dm_block_t data_origin, dm_block_t data_dest,
Mike Snitzer's avatar
Mike Snitzer committed
1378
				   struct dm_bio_prison_cell *cell, struct bio *bio)
1379 1380
{
	schedule_copy(tc, virt_block, tc->pool_dev,
1381 1382
		      data_origin, data_dest, cell, bio,
		      tc->pool->sectors_per_block);
1383 1384
}

1385
static void schedule_zero(struct thin_c *tc, dm_block_t virt_block,
Mike Snitzer's avatar
Mike Snitzer committed
1386
			  dm_block_t data_block, struct dm_bio_prison_cell *cell,
1387 1388 1389
			  struct bio *bio)
{
	struct pool *pool = tc->pool;
Mike Snitzer's avatar
Mike Snitzer committed
1390
	struct dm_thin_new_mapping *m = get_next_mapping(pool);
1391

1392
	atomic_set(&m->prepare_actions, 1); /* no need to quiesce */
1393
	m->tc = tc;
1394 1395
	m->virt_begin = virt_block;
	m->virt_end = virt_block + 1u;
1396 1397 1398 1399 1400 1401 1402 1403
	m->data_block = data_block;
	m->cell = cell;

	/*
	 * If the whole block of data is being overwritten or we are not
	 * zeroing pre-existing data, we can issue the bio immediately.
	 * Otherwise we use kcopyd to zero the data first.
	 */
1404 1405 1406
	if (pool->pf.zero_new_blocks) {
		if (io_overwrites_block(pool, bio))
			remap_and_issue_overwrite(tc, bio, data_block, m);
1407
		else {
1408 1409
			ll_zero(tc, m, data_block * pool->sectors_per_block,
				(data_block + 1) * pool->sectors_per_block);
1410
		}
1411
	} else
1412
		process_prepared_mapping(m);
1413
}
1414

1415 1416 1417 1418 1419 1420 1421 1422
static void schedule_external_copy(struct thin_c *tc, dm_block_t virt_block,
				   dm_block_t data_dest,
				   struct dm_bio_prison_cell *cell, struct bio *bio)
{
	struct pool *pool = tc->pool;
	sector_t virt_block_begin = virt_block * pool->sectors_per_block;
	sector_t virt_block_end = (virt_block + 1) * pool->sectors_per_block;

1423
	if (virt_block_end <= tc->origin_size) {
1424 1425 1426 1427
		schedule_copy(tc, virt_block, tc->origin_dev,
			      virt_block, data_dest, cell, bio,
			      pool->sectors_per_block);

1428
	} else if (virt_block_begin < tc->origin_size) {
1429 1430 1431 1432
		schedule_copy(tc, virt_block, tc->origin_dev,
			      virt_block, data_dest, cell, bio,
			      tc->origin_size - virt_block_begin);

1433
	} else
1434
		schedule_zero(tc, virt_block, data_dest, cell, bio);
1435 1436
}

1437 1438
static void set_pool_mode(struct pool *pool, enum pool_mode new_mode);

1439 1440
static void requeue_bios(struct pool *pool);

1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469
static bool is_read_only_pool_mode(enum pool_mode mode)
{
	return (mode == PM_OUT_OF_METADATA_SPACE || mode == PM_READ_ONLY);
}

static bool is_read_only(struct pool *pool)
{
	return is_read_only_pool_mode(get_pool_mode(pool));
}

static void check_for_metadata_space(struct pool *pool)
{
	int r;
	const char *ooms_reason = NULL;
	dm_block_t nr_free;

	r = dm_pool_get_free_metadata_block_count(pool->pmd, &nr_free);
	if (r)
		ooms_reason = "Could not get free metadata blocks";
	else if (!nr_free)
		ooms_reason = "No free metadata blocks";

	if (ooms_reason && !is_read_only(pool)) {
		DMERR("%s", ooms_reason);
		set_pool_mode(pool, PM_OUT_OF_METADATA_SPACE);
	}
}

static void check_for_data_space(struct pool *pool)
1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480
{
	int r;
	dm_block_t nr_free;

	if (get_pool_mode(pool) != PM_OUT_OF_DATA_SPACE)
		return;

	r = dm_pool_get_free_block_count(pool->pmd, &nr_free);
	if (r)
		return;

1481
	if (nr_free) {
1482
		set_pool_mode(pool, PM_WRITE);
1483 1484
		requeue_bios(pool);
	}
1485 1486
}

1487 1488 1489 1490
/*
 * A non-zero return indicates read_only or fail_io mode.
 * Many callers don't care about the return value.
 */
1491
static int commit(struct pool *pool)
1492 1493 1494
{
	int r;

1495
	if (get_pool_mode(pool) >= PM_OUT_OF_METADATA_SPACE)
1496 1497
		return -EINVAL;

1498
	r = dm_pool_commit_metadata(pool->pmd);
1499 1500
	if (r)
		metadata_operation_failed(pool, "dm_pool_commit_metadata", r);
1501 1502 1503 1504
	else {
		check_for_metadata_space(pool);
		check_for_data_space(pool);
	}
1505 1506 1507 1508

	return r;
}

1509 1510 1511 1512 1513
static void check_low_water_mark(struct pool *pool, dm_block_t free_blocks)
{
	if (free_blocks <= pool->low_water_blocks && !pool->low_water_triggered) {
		DMWARN("%s: reached low water mark for data device: sending event.",
		       dm_device_name(pool->pool_md));
1514
		spin_lock_irq(&pool->lock);
1515
		pool->low_water_triggered = true;
1516
		spin_unlock_irq(&pool->lock);
1517 1518 1519 1520
		dm_table_event(pool->ti->table);
	}
}

1521 1522 1523 1524 1525 1526
static int alloc_data_block(struct thin_c *tc, dm_block_t *result)
{
	int r;
	dm_block_t free_blocks;
	struct pool *pool = tc->pool;

1527
	if (WARN_ON(get_pool_mode(pool) != PM_WRITE))
1528 1529
		return -EINVAL;

1530
	r = dm_pool_get_free_block_count(pool->pmd, &free_blocks);
1531 1532
	if (r) {
		metadata_operation_failed(pool, "dm_pool_get_free_block_count", r);
1533
		return r;
1534
	}
1535

1536
	check_low_water_mark(pool, free_blocks);
1537 1538

	if (!free_blocks) {
1539 1540 1541 1542
		/*
		 * Try to commit to see if that will free up some
		 * more space.
		 */
1543 1544 1545
		r = commit(pool);
		if (r)
			return r;
1546

1547
		r = dm_pool_get_free_block_count(pool->pmd, &free_blocks);
1548 1549
		if (r) {
			metadata_operation_failed(pool, "dm_pool_get_free_block_count", r);
1550
			return r;
1551
		}
1552

1553
		if (!free_blocks) {
1554
			set_pool_mode(pool, PM_OUT_OF_DATA_SPACE);
1555
			return -ENOSPC;
1556 1557 1558 1559
		}
	}

	r = dm_pool_alloc_data_block(pool->pmd, result);
1560
	if (r) {
1561 1562 1563 1564
		if (r == -ENOSPC)
			set_pool_mode(pool, PM_OUT_OF_DATA_SPACE);
		else
			metadata_operation_failed(pool, "dm_pool_alloc_data_block", r);
1565
		return r;
1566
	}
1567

1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580
	r = dm_pool_get_free_metadata_block_count(pool->pmd, &free_blocks);
	if (r) {
		metadata_operation_failed(pool, "dm_pool_get_free_metadata_block_count", r);
		return r;
	}

	if (!free_blocks) {
		/* Let's commit before we use up the metadata reserve. */
		r = commit(pool);
		if (r)
			return r;
	}

1581 1582 1583 1584 1585 1586 1587 1588 1589
	return 0;
}

/*
 * If we have run out of space, queue bios until the device is
 * resumed, presumably after having been reloaded with more space.
 */
static void retry_on_resume(struct bio *bio)
{
1590
	struct dm_thin_endio_hook *h = dm_per_bio_data(bio, sizeof(struct dm_thin_endio_hook));
1591
	struct thin_c *tc = h->tc;
1592

1593
	spin_lock_irq(&tc->lock);
1594
	bio_list_add(&tc->retry_on_resume_list, bio);
1595
	spin_unlock_irq(&tc->lock);
1596 1597
}

1598
static blk_status_t should_error_unserviceable_bio(struct pool *pool)
1599
{
1600 1601 1602 1603 1604 1605
	enum pool_mode m = get_pool_mode(pool);

	switch (m) {
	case PM_WRITE:
		/* Shouldn't get here */
		DMERR_LIMIT("bio unserviceable, yet pool is in PM_WRITE mode");
1606
		return BLK_STS_IOERR;
1607 1608

	case PM_OUT_OF_DATA_SPACE:
1609
		return pool->pf.error_if_no_space ? BLK_STS_NOSPC : 0;
1610

1611
	case PM_OUT_OF_METADATA_SPACE:
1612 1613
	case PM_READ_ONLY:
	case PM_FAIL:
1614
		return BLK_STS_IOERR;
1615 1616 1617
	default:
		/* Shouldn't get here */
		DMERR_LIMIT("bio unserviceable, yet pool has an unknown mode");
1618
		return BLK_STS_IOERR;
1619 1620
	}
}
1621

1622 1623
static void handle_unserviceable_bio(struct pool *pool, struct bio *bio)
{
1624
	blk_status_t error = should_error_unserviceable_bio(pool);
1625

1626
	if (error) {
1627
		bio->bi_status = error;
1628 1629
		bio_endio(bio);
	} else
1630
		retry_on_resume(bio);
1631 1632
}

1633
static void retry_bios_on_resume(struct pool *pool, struct dm_bio_prison_cell *cell)
1634 1635 1636
{
	struct bio *bio;
	struct bio_list bios;
1637
	blk_status_t error;
1638

1639 1640 1641
	error = should_error_unserviceable_bio(pool);
	if (error) {
		cell_error_with_code(pool, cell, error);
1642 1643 1644
		return;
	}

1645
	bio_list_init(&bios);
1646
	cell_release(pool, cell, &bios);
1647

1648 1649
	while ((bio = bio_list_pop(&bios)))
		retry_on_resume(bio);
1650 1651
}

1652 1653
static void process_discard_cell_no_passdown(struct thin_c *tc,
					     struct dm_bio_prison_cell *virt_cell)
Joe Thornber's avatar
Joe Thornber committed
1654 1655
{
	struct pool *pool = tc->pool;
1656
	struct dm_thin_new_mapping *m = get_next_mapping(pool);
Joe Thornber's avatar
Joe Thornber committed
1657

1658 1659 1660 1661 1662 1663 1664 1665 1666
	/*
	 * We don't need to lock the data blocks, since there's no
	 * passdown.  We only lock data blocks for allocation and breaking sharing.
	 */
	m->tc = tc;
	m->virt_begin = virt_cell->key.block_begin;
	m->virt_end = virt_cell->key.block_end;
	m->cell = virt_cell;
	m->bio = virt_cell->holder;
Joe Thornber's avatar
Joe Thornber committed
1667

1668 1669 1670
	if (!dm_deferred_set_add_work(pool->all_io_ds, &m->list))
		pool->process_prepared_discard(m);
}
Joe Thornber's avatar
Joe Thornber committed
1671

1672 1673 1674 1675 1676 1677 1678 1679 1680 1681
static void break_up_discard_bio(struct thin_c *tc, dm_block_t begin, dm_block_t end,
				 struct bio *bio)
{
	struct pool *pool = tc->pool;

	int r;
	bool maybe_shared;
	struct dm_cell_key data_key;
	struct dm_bio_prison_cell *data_cell;
	struct dm_thin_new_mapping *m;
1682 1683
	dm_block_t virt_begin, virt_end, data_begin, data_end;
	dm_block_t len, next_boundary;
1684 1685 1686 1687

	while (begin != end) {
		r = dm_thin_find_mapped_range(tc->td, begin, end, &virt_begin, &virt_end,
					      &data_begin, &maybe_shared);
1688
		if (r) {
Joe Thornber's avatar
Joe Thornber committed
1689
			/*
1690 1691
			 * Silently fail, letting any mappings we've
			 * created complete.
Joe Thornber's avatar
Joe Thornber committed
1692
			 */
1693
			break;
Joe Thornber's avatar
Joe Thornber committed
1694 1695
		}

1696
		data_end = data_begin + (virt_end - virt_begin);
Joe Thornber's avatar
Joe Thornber committed
1697

1698
		/*
1699
		 * Make sure the data region obeys the bio prison restrictions.
1700
		 */
1701 1702 1703 1704 1705 1706 1707 1708 1709
		while (data_begin < data_end) {
			r = ensure_next_mapping(pool);
			if (r)
				return; /* we did our best */

			next_boundary = ((data_begin >> BIO_PRISON_MAX_RANGE_SHIFT) + 1)
				<< BIO_PRISON_MAX_RANGE_SHIFT;
			len = min_t(sector_t, data_end - data_begin, next_boundary - data_begin);

1710 1711
			/* This key is certainly within range given the above splitting */
			(void) build_key(tc->td, PHYSICAL, data_begin, data_begin + len, &data_key);
1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745
			if (bio_detain(tc->pool, &data_key, NULL, &data_cell)) {
				/* contention, we'll give up with this range */
				data_begin += len;
				continue;
			}

			/*
			 * IO may still be going to the destination block.  We must
			 * quiesce before we can do the removal.
			 */
			m = get_next_mapping(pool);
			m->tc = tc;
			m->maybe_shared = maybe_shared;
			m->virt_begin = virt_begin;
			m->virt_end = virt_begin + len;
			m->data_block = data_begin;
			m->cell = data_cell;
			m->bio = bio;

			/*
			 * The parent bio must not complete before sub discard bios are
			 * chained to it (see end_discard's bio_chain)!
			 *
			 * This per-mapping bi_remaining increment is paired with
			 * the implicit decrement that occurs via bio_endio() in
			 * end_discard().
			 */
			bio_inc_remaining(bio);
			if (!dm_deferred_set_add_work(pool->all_io_ds, &m->list))
				pool->process_prepared_discard(m);

			virt_begin += len;
			data_begin += len;
		}
1746 1747

		begin = virt_end;
Joe Thornber's avatar
Joe Thornber committed
1748 1749 1750
	}
}

1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768
static void process_discard_cell_passdown(struct thin_c *tc, struct dm_bio_prison_cell *virt_cell)
{
	struct bio *bio = virt_cell->holder;
	struct dm_thin_endio_hook *h = dm_per_bio_data(bio, sizeof(struct dm_thin_endio_hook));

	/*
	 * The virt_cell will only get freed once the origin bio completes.
	 * This means it will remain locked while all the individual
	 * passdown bios are in flight.
	 */
	h->cell = virt_cell;
	break_up_discard_bio(tc, virt_cell->key.block_begin, virt_cell->key.block_end, bio);

	/*
	 * We complete the bio now, knowing that the bi_remaining field
	 * will prevent completion until the sub range discards have
	 * completed.
	 */
1769
	bio_endio(bio);
1770 1771
}

1772 1773
static void process_discard_bio(struct thin_c *tc, struct bio *bio)
{
1774 1775 1776
	dm_block_t begin, end;
	struct dm_cell_key virt_key;
	struct dm_bio_prison_cell *virt_cell;
1777

1778 1779 1780 1781 1782
	get_bio_block_range(tc, bio, &begin, &end);
	if (begin == end) {
		/*
		 * The discard covers less than a block.
		 */
1783
		bio_endio(bio);
1784
		return;
1785
	}
1786

1787 1788 1789 1790 1791 1792 1793
	if (unlikely(!build_key(tc->td, VIRTUAL, begin, end, &virt_key))) {
		DMERR_LIMIT("Discard doesn't respect bio prison limits");
		bio_endio(bio);
		return;
	}

	if (bio_detain(tc->pool, &virt_key, bio, &virt_cell)) {
1794 1795 1796 1797 1798 1799 1800 1801
		/*
		 * Potential starvation issue: We're relying on the
		 * fs/application being well behaved, and not trying to
		 * send IO to a region at the same time as discarding it.
		 * If they do this persistently then it's possible this
		 * cell will never be granted.
		 */
		return;
1802
	}
1803 1804

	tc->pool->process_discard_cell(tc, virt_cell);
1805 1806
}

1807
static void break_sharing(struct thin_c *tc, struct bio *bio, dm_block_t block,
1808
			  struct dm_cell_key *key,
1809
			  struct dm_thin_lookup_result *lookup_result,
Mike Snitzer's avatar
Mike Snitzer committed
1810
			  struct dm_bio_prison_cell *cell)
1811 1812 1813
{
	int r;
	dm_block_t data_block;
1814
	struct pool *pool = tc->pool;
1815 1816 1817 1818

	r = alloc_data_block(tc, &data_block);
	switch (r) {
	case 0:
1819 1820
		schedule_internal_copy(tc, block, lookup_result->block,
				       data_block, cell, bio);
1821 1822 1823
		break;

	case -ENOSPC:
1824
		retry_bios_on_resume(pool, cell);
1825 1826 1827
		break;

	default:
1828 1829
		DMERR_LIMIT("%s: alloc_data_block() failed: error = %d",
			    __func__, r);
1830
		cell_error(pool, cell);
1831 1832 1833 1834
		break;
	}
}

1835 1836 1837 1838 1839 1840 1841
static void __remap_and_issue_shared_cell(void *context,
					  struct dm_bio_prison_cell *cell)
{
	struct remap_info *info = context;
	struct bio *bio;

	while ((bio = bio_list_pop(&cell->bios))) {
1842 1843
		if (bio_data_dir(bio) == WRITE || op_is_flush(bio->bi_opf) ||
		    bio_op(bio) == REQ_OP_DISCARD)
1844 1845
			bio_list_add(&info->defer_bios, bio);
		else {
1846
			struct dm_thin_endio_hook *h = dm_per_bio_data(bio, sizeof(struct dm_thin_endio_hook));
1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875

			h->shared_read_entry = dm_deferred_entry_inc(info->tc->pool->shared_read_ds);
			inc_all_io_entry(info->tc->pool, bio);
			bio_list_add(&info->issue_bios, bio);
		}
	}
}

static void remap_and_issue_shared_cell(struct thin_c *tc,
					struct dm_bio_prison_cell *cell,
					dm_block_t block)
{
	struct bio *bio;
	struct remap_info info;

	info.tc = tc;
	bio_list_init(&info.defer_bios);
	bio_list_init(&info.issue_bios);

	cell_visit_release(tc->pool, __remap_and_issue_shared_cell,
			   &info, cell);

	while ((bio = bio_list_pop(&info.defer_bios)))
		thin_defer_bio(tc, bio);

	while ((bio = bio_list_pop(&info.issue_bios)))
		remap_and_issue(tc, bio, block);
}

1876 1877
static void process_shared_bio(struct thin_c *tc, struct bio *bio,
			       dm_block_t block,
1878 1879
			       struct dm_thin_lookup_result *lookup_result,
			       struct dm_bio_prison_cell *virt_cell)
1880
{
1881
	struct dm_bio_prison_cell *data_cell;
1882
	struct pool *pool = tc->pool;
1883
	struct dm_cell_key key;
1884 1885 1886 1887 1888 1889

	/*
	 * If cell is already occupied, then sharing is already in the process
	 * of being broken so we have nothing further to do here.
	 */
	build_data_key(tc->td, lookup_result->block, &key);
1890 1891
	if (bio_detain(pool, &key, bio, &data_cell)) {
		cell_defer_no_holder(tc, virt_cell);
1892
		return;
1893
	}
1894

1895 1896 1897 1898
	if (bio_data_dir(bio) == WRITE && bio->bi_iter.bi_size) {
		break_sharing(tc, bio, block, &key, lookup_result, data_cell);
		cell_defer_no_holder(tc, virt_cell);
	} else {
1899
		struct dm_thin_endio_hook *h = dm_per_bio_data(bio, sizeof(struct dm_thin_endio_hook));
1900

1901
		h->shared_read_entry = dm_deferred_entry_inc(pool->shared_read_ds);
1902
		inc_all_io_entry(pool, bio);
1903
		remap_and_issue(tc, bio, lookup_result->block);
1904 1905 1906

		remap_and_issue_shared_cell(tc, data_cell, lookup_result->block);
		remap_and_issue_shared_cell(tc, virt_cell, lookup_result->block);
1907 1908 1909 1910
	}
}

static void provision_block(struct thin_c *tc, struct bio *bio, dm_block_t block,
Mike Snitzer's avatar
Mike Snitzer committed
1911
			    struct dm_bio_prison_cell *cell)
1912 1913 1914
{
	int r;
	dm_block_t data_block;
1915
	struct pool *pool = tc->pool;
1916 1917 1918 1919

	/*
	 * Remap empty bios (flushes) immediately, without provisioning.
	 */
1920
	if (!bio->bi_iter.bi_size) {
1921
		inc_all_io_entry(pool, bio);
1922
		cell_defer_no_holder(tc, cell);
1923

1924 1925 1926 1927 1928 1929 1930 1931 1932
		remap_and_issue(tc, bio, 0);
		return;
	}

	/*
	 * Fill read bios with zeroes and complete them immediately.
	 */
	if (bio_data_dir(bio) == READ) {
		zero_fill_bio(bio);
1933
		cell_defer_no_holder(tc, cell);
1934
		bio_endio(bio);
1935 1936 1937 1938 1939 1940
		return;
	}

	r = alloc_data_block(tc, &data_block);
	switch (r) {
	case 0:
1941 1942 1943 1944
		if (tc->origin_dev)
			schedule_external_copy(tc, block, data_block, cell, bio);
		else
			schedule_zero(tc, block, data_block, cell, bio);
1945 1946 1947
		break;

	case -ENOSPC:
1948
		retry_bios_on_resume(pool, cell);
1949 1950 1951
		break;

	default:
1952 1953
		DMERR_LIMIT("%s: alloc_data_block() failed: error = %d",
			    __func__, r);
1954
		cell_error(pool, cell);
1955 1956 1957 1958
		break;
	}
}

1959
static void process_cell(struct thin_c *tc, struct dm_bio_prison_cell *cell)
1960 1961
{
	int r;
1962
	struct pool *pool = tc->pool;
1963
	struct bio *bio = cell->holder;
1964 1965 1966
	dm_block_t block = get_bio_block(tc, bio);
	struct dm_thin_lookup_result lookup_result;

1967 1968
	if (tc->requeue_mode) {
		cell_requeue(pool, cell);
1969
		return;
1970
	}
1971 1972 1973 1974

	r = dm_thin_find_block(tc->td, block, 1, &lookup_result);
	switch (r) {
	case 0:
1975 1976 1977
		if (lookup_result.shared)
			process_shared_bio(tc, bio, block, &lookup_result, cell);
		else {
1978
			inc_all_io_entry(pool, bio);
1979
			remap_and_issue(tc, bio, lookup_result.block);
1980
			inc_remap_and_issue_cell(tc, cell, lookup_result.block);
1981
		}
1982 1983 1984
		break;

	case -ENODATA:
1985
		if (bio_data_dir(bio) == READ && tc->origin_dev) {
1986
			inc_all_io_entry(pool, bio);
1987
			cell_defer_no_holder(tc, cell);
1988

1989 1990 1991 1992 1993 1994 1995 1996 1997 1998
			if (bio_end_sector(bio) <= tc->origin_size)
				remap_to_origin_and_issue(tc, bio);

			else if (bio->bi_iter.bi_sector < tc->origin_size) {
				zero_fill_bio(bio);
				bio->bi_iter.bi_size = (tc->origin_size - bio->bi_iter.bi_sector) << SECTOR_SHIFT;
				remap_to_origin_and_issue(tc, bio);

			} else {
				zero_fill_bio(bio);
1999
				bio_endio(bio);
2000
			}
2001 2002
		} else
			provision_block(tc, bio, block, cell);
2003 2004 2005
		break;

	default:
2006 2007
		DMERR_LIMIT("%s: dm_thin_find_block() failed: error = %d",
			    __func__, r);
2008
		cell_defer_no_holder(tc, cell);
2009 2010 2011 2012 2013
		bio_io_error(bio);
		break;
	}
}

2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033
static void process_bio(struct thin_c *tc, struct bio *bio)
{
	struct pool *pool = tc->pool;
	dm_block_t block = get_bio_block(tc, bio);
	struct dm_bio_prison_cell *cell;
	struct dm_cell_key key;

	/*
	 * If cell is already occupied, then the block is already
	 * being provisioned so we have nothing further to do here.
	 */
	build_virtual_key(tc->td, block, &key);
	if (bio_detain(pool, &key, bio, &cell))
		return;

	process_cell(tc, cell);
}

static void __process_bio_read_only(struct thin_c *tc, struct bio *bio,
				    struct dm_bio_prison_cell *cell)
2034 2035 2036 2037 2038 2039 2040 2041 2042
{
	int r;
	int rw = bio_data_dir(bio);
	dm_block_t block = get_bio_block(tc, bio);
	struct dm_thin_lookup_result lookup_result;

	r = dm_thin_find_block(tc->td, block, 1, &lookup_result);
	switch (r) {
	case 0:
2043
		if (lookup_result.shared && (rw == WRITE) && bio->bi_iter.bi_size) {
2044
			handle_unserviceable_bio(tc->pool, bio);
2045 2046 2047
			if (cell)
				cell_defer_no_holder(tc, cell);
		} else {
2048
			inc_all_io_entry(tc->pool, bio);
2049
			remap_and_issue(tc, bio, lookup_result.block);
2050 2051
			if (cell)
				inc_remap_and_issue_cell(tc, cell, lookup_result.block);
2052
		}
2053 2054 2055
		break;

	case -ENODATA:
2056 2057
		if (cell)
			cell_defer_no_holder(tc, cell);
2058
		if (rw != READ) {
2059
			handle_unserviceable_bio(tc->pool, bio);
2060 2061 2062 2063
			break;
		}

		if (tc->origin_dev) {
2064
			inc_all_io_entry(tc->pool, bio);
2065 2066 2067 2068 2069
			remap_to_origin_and_issue(tc, bio);
			break;
		}

		zero_fill_bio(bio);
2070
		bio_endio(bio);
2071 2072 2073
		break;

	default:
2074 2075
		DMERR_LIMIT("%s: dm_thin_find_block() failed: error = %d",
			    __func__, r);
2076 2077
		if (cell)
			cell_defer_no_holder(tc, cell);
2078 2079 2080 2081 2082
		bio_io_error(bio);
		break;
	}
}

2083 2084 2085 2086 2087 2088 2089 2090 2091 2092
static void process_bio_read_only(struct thin_c *tc, struct bio *bio)
{
	__process_bio_read_only(tc, bio, NULL);
}

static void process_cell_read_only(struct thin_c *tc, struct dm_bio_prison_cell *cell)
{
	__process_bio_read_only(tc, cell->holder, cell);
}

2093 2094
static void process_bio_success(struct thin_c *tc, struct bio *bio)
{
2095
	bio_endio(bio);
2096 2097
}

2098 2099 2100 2101 2102
static void process_bio_fail(struct thin_c *tc, struct bio *bio)
{
	bio_io_error(bio);
}

2103 2104 2105 2106 2107 2108 2109 2110 2111 2112
static void process_cell_success(struct thin_c *tc, struct dm_bio_prison_cell *cell)
{
	cell_success(tc->pool, cell);
}

static void process_cell_fail(struct thin_c *tc, struct dm_bio_prison_cell *cell)
{
	cell_error(tc->pool, cell);
}

2113 2114 2115 2116
/*
 * FIXME: should we also commit due to size of transaction, measured in
 * metadata blocks?
 */
2117 2118
static int need_commit_due_to_time(struct pool *pool)
{
2119 2120
	return !time_in_range(jiffies, pool->last_commit_jiffies,
			      pool->last_commit_jiffies + COMMIT_PERIOD);
2121 2122
}

2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186
#define thin_pbd(node) rb_entry((node), struct dm_thin_endio_hook, rb_node)
#define thin_bio(pbd) dm_bio_from_per_bio_data((pbd), sizeof(struct dm_thin_endio_hook))

static void __thin_bio_rb_add(struct thin_c *tc, struct bio *bio)
{
	struct rb_node **rbp, *parent;
	struct dm_thin_endio_hook *pbd;
	sector_t bi_sector = bio->bi_iter.bi_sector;

	rbp = &tc->sort_bio_list.rb_node;
	parent = NULL;
	while (*rbp) {
		parent = *rbp;
		pbd = thin_pbd(parent);

		if (bi_sector < thin_bio(pbd)->bi_iter.bi_sector)
			rbp = &(*rbp)->rb_left;
		else
			rbp = &(*rbp)->rb_right;
	}

	pbd = dm_per_bio_data(bio, sizeof(struct dm_thin_endio_hook));
	rb_link_node(&pbd->rb_node, parent, rbp);
	rb_insert_color(&pbd->rb_node, &tc->sort_bio_list);
}

static void __extract_sorted_bios(struct thin_c *tc)
{
	struct rb_node *node;
	struct dm_thin_endio_hook *pbd;
	struct bio *bio;

	for (node = rb_first(&tc->sort_bio_list); node; node = rb_next(node)) {
		pbd = thin_pbd(node);
		bio = thin_bio(pbd);

		bio_list_add(&tc->deferred_bio_list, bio);
		rb_erase(&pbd->rb_node, &tc->sort_bio_list);
	}

	WARN_ON(!RB_EMPTY_ROOT(&tc->sort_bio_list));
}

static void __sort_thin_deferred_bios(struct thin_c *tc)
{
	struct bio *bio;
	struct bio_list bios;

	bio_list_init(&bios);
	bio_list_merge(&bios, &tc->deferred_bio_list);
	bio_list_init(&tc->deferred_bio_list);

	/* Sort deferred_bio_list using rb-tree */
	while ((bio = bio_list_pop(&bios)))
		__thin_bio_rb_add(tc, bio);

	/*
	 * Transfer the sorted bios in sort_bio_list back to
	 * deferred_bio_list to allow lockless submission of
	 * all bios.
	 */
	__extract_sorted_bios(tc);
}

2187
static void process_thin_deferred_bios(struct thin_c *tc)
2188
{
2189
	struct pool *pool = tc->pool;
2190 2191
	struct bio *bio;
	struct bio_list bios;
2192
	struct blk_plug plug;
2193
	unsigned int count = 0;
2194

2195
	if (tc->requeue_mode) {
2196 2197
		error_thin_bio_list(tc, &tc->deferred_bio_list,
				BLK_STS_DM_REQUEUE);
2198 2199 2200
		return;
	}

2201 2202
	bio_list_init(&bios);

2203
	spin_lock_irq(&tc->lock);
2204 2205

	if (bio_list_empty(&tc->deferred_bio_list)) {
2206
		spin_unlock_irq(&tc->lock);
2207 2208 2209 2210 2211
		return;
	}

	__sort_thin_deferred_bios(tc);

2212 2213
	bio_list_merge(&bios, &tc->deferred_bio_list);
	bio_list_init(&tc->deferred_bio_list);
2214

2215
	spin_unlock_irq(&tc->lock);
2216

2217
	blk_start_plug(&plug);
2218 2219 2220 2221 2222 2223 2224
	while ((bio = bio_list_pop(&bios))) {
		/*
		 * If we've got no free new_mapping structs, and processing
		 * this bio might require one, we pause until there are some
		 * prepared mappings to process.
		 */
		if (ensure_next_mapping(pool)) {
2225
			spin_lock_irq(&tc->lock);
2226 2227
			bio_list_add(&tc->deferred_bio_list, bio);
			bio_list_merge(&tc->deferred_bio_list, &bios);
2228
			spin_unlock_irq(&tc->lock);
2229 2230
			break;
		}
Joe Thornber's avatar
Joe Thornber committed
2231

Mike Christie's avatar
Mike Christie committed
2232
		if (bio_op(bio) == REQ_OP_DISCARD)
2233
			pool->process_discard(tc, bio);
Joe Thornber's avatar
Joe Thornber committed
2234
		else
2235
			pool->process_bio(tc, bio);
2236 2237

		if ((count++ & 127) == 0) {
Joe Thornber's avatar
Joe Thornber committed
2238
			throttle_work_update(&pool->throttle);
2239 2240
			dm_pool_issue_prefetches(pool->pmd);
		}
2241
		cond_resched();
2242
	}
2243
	blk_finish_plug(&plug);
2244 2245
}

2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262
static int cmp_cells(const void *lhs, const void *rhs)
{
	struct dm_bio_prison_cell *lhs_cell = *((struct dm_bio_prison_cell **) lhs);
	struct dm_bio_prison_cell *rhs_cell = *((struct dm_bio_prison_cell **) rhs);

	BUG_ON(!lhs_cell->holder);
	BUG_ON(!rhs_cell->holder);

	if (lhs_cell->holder->bi_iter.bi_sector < rhs_cell->holder->bi_iter.bi_sector)
		return -1;

	if (lhs_cell->holder->bi_iter.bi_sector > rhs_cell->holder->bi_iter.bi_sector)
		return 1;

	return 0;
}

2263
static unsigned int sort_cells(struct pool *pool, struct list_head *cells)
2264
{
2265
	unsigned int count = 0;
2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280
	struct dm_bio_prison_cell *cell, *tmp;

	list_for_each_entry_safe(cell, tmp, cells, user_list) {
		if (count >= CELL_SORT_ARRAY_SIZE)
			break;

		pool->cell_sort_array[count++] = cell;
		list_del(&cell->user_list);
	}

	sort(pool->cell_sort_array, count, sizeof(cell), cmp_cells, NULL);

	return count;
}

2281 2282 2283 2284
static void process_thin_deferred_cells(struct thin_c *tc)
{
	struct pool *pool = tc->pool;
	struct list_head cells;
2285
	struct dm_bio_prison_cell *cell;
2286
	unsigned int i, j, count;
2287 2288 2289

	INIT_LIST_HEAD(&cells);

2290
	spin_lock_irq(&tc->lock);
2291
	list_splice_init(&tc->deferred_cells, &cells);
2292
	spin_unlock_irq(&tc->lock);
2293 2294 2295 2296

	if (list_empty(&cells))
		return;

2297 2298
	do {
		count = sort_cells(tc->pool, &cells);
2299

2300 2301 2302
		for (i = 0; i < count; i++) {
			cell = pool->cell_sort_array[i];
			BUG_ON(!cell->holder);
2303

2304 2305 2306 2307 2308 2309 2310 2311 2312
			/*
			 * If we've got no free new_mapping structs, and processing
			 * this bio might require one, we pause until there are some
			 * prepared mappings to process.
			 */
			if (ensure_next_mapping(pool)) {
				for (j = i; j < count; j++)
					list_add(&pool->cell_sort_array[j]->user_list, &cells);

2313
				spin_lock_irq(&tc->lock);
2314
				list_splice(&cells, &tc->deferred_cells);
2315
				spin_unlock_irq(&tc->lock);
2316 2317 2318
				return;
			}

Mike Christie's avatar
Mike Christie committed
2319
			if (bio_op(cell->holder) == REQ_OP_DISCARD)
2320 2321 2322 2323
				pool->process_discard_cell(tc, cell);
			else
				pool->process_cell(tc, cell);
		}
2324
		cond_resched();
2325
	} while (!list_empty(&cells));
2326 2327
}

2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366
static void thin_get(struct thin_c *tc);
static void thin_put(struct thin_c *tc);

/*
 * We can't hold rcu_read_lock() around code that can block.  So we
 * find a thin with the rcu lock held; bump a refcount; then drop
 * the lock.
 */
static struct thin_c *get_first_thin(struct pool *pool)
{
	struct thin_c *tc = NULL;

	rcu_read_lock();
	if (!list_empty(&pool->active_thins)) {
		tc = list_entry_rcu(pool->active_thins.next, struct thin_c, list);
		thin_get(tc);
	}
	rcu_read_unlock();

	return tc;
}

static struct thin_c *get_next_thin(struct pool *pool, struct thin_c *tc)
{
	struct thin_c *old_tc = tc;

	rcu_read_lock();
	list_for_each_entry_continue_rcu(tc, &pool->active_thins, list) {
		thin_get(tc);
		thin_put(old_tc);
		rcu_read_unlock();
		return tc;
	}
	thin_put(old_tc);
	rcu_read_unlock();

	return NULL;
}

2367 2368 2369
static void process_deferred_bios(struct pool *pool)
{
	struct bio *bio;
2370
	struct bio_list bios, bio_completions;
2371 2372
	struct thin_c *tc;

2373 2374
	tc = get_first_thin(pool);
	while (tc) {
2375
		process_thin_deferred_cells(tc);
2376
		process_thin_deferred_bios(tc);
2377 2378
		tc = get_next_thin(pool, tc);
	}
2379 2380

	/*
2381 2382
	 * If there are any deferred flush bios, we must commit the metadata
	 * before issuing them or signaling their completion.
2383 2384
	 */
	bio_list_init(&bios);
2385 2386
	bio_list_init(&bio_completions);

2387
	spin_lock_irq(&pool->lock);
2388 2389
	bio_list_merge(&bios, &pool->deferred_flush_bios);
	bio_list_init(&pool->deferred_flush_bios);
2390 2391 2392

	bio_list_merge(&bio_completions, &pool->deferred_flush_completions);
	bio_list_init(&pool->deferred_flush_completions);
2393
	spin_unlock_irq(&pool->lock);
2394

2395
	if (bio_list_empty(&bios) && bio_list_empty(&bio_completions) &&
2396
	    !(dm_pool_changed_this_transaction(pool->pmd) && need_commit_due_to_time(pool)))
2397 2398
		return;

2399
	if (commit(pool)) {
2400 2401
		bio_list_merge(&bios, &bio_completions);

2402 2403 2404 2405
		while ((bio = bio_list_pop(&bios)))
			bio_io_error(bio);
		return;
	}
2406
	pool->last_commit_jiffies = jiffies;
2407

2408 2409 2410
	while ((bio = bio_list_pop(&bio_completions)))
		bio_endio(bio);

2411 2412 2413 2414 2415 2416 2417 2418
	while ((bio = bio_list_pop(&bios))) {
		/*
		 * The data device was flushed as part of metadata commit,
		 * so complete redundant flushes immediately.
		 */
		if (bio->bi_opf & REQ_PREFLUSH)
			bio_endio(bio);
		else
2419
			dm_submit_bio_remap(bio, NULL);
2420
	}
2421 2422 2423 2424 2425 2426
}

static void do_worker(struct work_struct *ws)
{
	struct pool *pool = container_of(ws, struct pool, worker);

Joe Thornber's avatar
Joe Thornber committed
2427
	throttle_work_start(&pool->throttle);
2428
	dm_pool_issue_prefetches(pool->pmd);
Joe Thornber's avatar
Joe Thornber committed
2429
	throttle_work_update(&pool->throttle);
2430
	process_prepared(pool, &pool->prepared_mappings, &pool->process_prepared_mapping);
Joe Thornber's avatar
Joe Thornber committed
2431
	throttle_work_update(&pool->throttle);
2432
	process_prepared(pool, &pool->prepared_discards, &pool->process_prepared_discard);
Joe Thornber's avatar
Joe Thornber committed
2433
	throttle_work_update(&pool->throttle);
2434 2435
	process_prepared(pool, &pool->prepared_discards_pt2, &pool->process_prepared_discard_pt2);
	throttle_work_update(&pool->throttle);
2436
	process_deferred_bios(pool);
Joe Thornber's avatar
Joe Thornber committed
2437
	throttle_work_complete(&pool->throttle);
2438 2439
}

2440 2441 2442 2443 2444 2445 2446
/*
 * We want to commit periodically so that not too much
 * unwritten data builds up.
 */
static void do_waker(struct work_struct *ws)
{
	struct pool *pool = container_of(to_delayed_work(ws), struct pool, waker);
2447

2448 2449 2450 2451
	wake_worker(pool);
	queue_delayed_work(pool->wq, &pool->waker, COMMIT_PERIOD);
}

2452 2453 2454
/*
 * We're holding onto IO to allow userland time to react.  After the
 * timeout either the pool will have been resized (and thus back in
2455
 * PM_WRITE mode), or we degrade to PM_OUT_OF_DATA_SPACE w/ error_if_no_space.
2456 2457 2458 2459 2460 2461
 */
static void do_no_space_timeout(struct work_struct *ws)
{
	struct pool *pool = container_of(to_delayed_work(ws), struct pool,
					 no_space_timeout);

2462 2463
	if (get_pool_mode(pool) == PM_OUT_OF_DATA_SPACE && !pool->pf.error_if_no_space) {
		pool->pf.error_if_no_space = true;
2464
		notify_of_pool_mode_change(pool);
2465
		error_retry_list_with_code(pool, BLK_STS_NOSPC);
2466
	}
2467 2468
}

2469 2470
/*----------------------------------------------------------------*/

2471
struct pool_work {
2472
	struct work_struct worker;
2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484
	struct completion complete;
};

static struct pool_work *to_pool_work(struct work_struct *ws)
{
	return container_of(ws, struct pool_work, worker);
}

static void pool_work_complete(struct pool_work *pw)
{
	complete(&pw->complete);
}
2485

2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499
static void pool_work_wait(struct pool_work *pw, struct pool *pool,
			   void (*fn)(struct work_struct *))
{
	INIT_WORK_ONSTACK(&pw->worker, fn);
	init_completion(&pw->complete);
	queue_work(pool->wq, &pw->worker);
	wait_for_completion(&pw->complete);
}

/*----------------------------------------------------------------*/

struct noflush_work {
	struct pool_work pw;
	struct thin_c *tc;
2500 2501
};

2502
static struct noflush_work *to_noflush(struct work_struct *ws)
2503
{
2504
	return container_of(to_pool_work(ws), struct noflush_work, pw);
2505 2506 2507 2508
}

static void do_noflush_start(struct work_struct *ws)
{
2509
	struct noflush_work *w = to_noflush(ws);
2510

2511 2512
	w->tc->requeue_mode = true;
	requeue_io(w->tc);
2513
	pool_work_complete(&w->pw);
2514 2515 2516 2517
}

static void do_noflush_stop(struct work_struct *ws)
{
2518
	struct noflush_work *w = to_noflush(ws);
2519

2520
	w->tc->requeue_mode = false;
2521
	pool_work_complete(&w->pw);
2522 2523 2524 2525 2526 2527 2528
}

static void noflush_work(struct thin_c *tc, void (*fn)(struct work_struct *))
{
	struct noflush_work w;

	w.tc = tc;
2529
	pool_work_wait(&w.pw, tc->pool, fn);
2530 2531 2532 2533
}

/*----------------------------------------------------------------*/

2534 2535 2536 2537
static void set_discard_callbacks(struct pool *pool)
{
	struct pool_c *pt = pool->ti->private;

2538
	if (pt->adjusted_pf.discard_passdown) {
2539
		pool->process_discard_cell = process_discard_cell_passdown;
2540 2541
		pool->process_prepared_discard = process_prepared_discard_passdown_pt1;
		pool->process_prepared_discard_pt2 = process_prepared_discard_passdown_pt2;
2542 2543 2544 2545 2546 2547
	} else {
		pool->process_discard_cell = process_discard_cell_no_passdown;
		pool->process_prepared_discard = process_prepared_discard_no_passdown;
	}
}

2548
static void set_pool_mode(struct pool *pool, enum pool_mode new_mode)
2549
{
2550
	struct pool_c *pt = pool->ti->private;
2551 2552
	bool needs_check = dm_pool_metadata_needs_check(pool->pmd);
	enum pool_mode old_mode = get_pool_mode(pool);
2553
	unsigned long no_space_timeout = READ_ONCE(no_space_timeout_secs) * HZ;
2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573

	/*
	 * Never allow the pool to transition to PM_WRITE mode if user
	 * intervention is required to verify metadata and data consistency.
	 */
	if (new_mode == PM_WRITE && needs_check) {
		DMERR("%s: unable to switch pool to write mode until repaired.",
		      dm_device_name(pool->pool_md));
		if (old_mode != new_mode)
			new_mode = old_mode;
		else
			new_mode = PM_READ_ONLY;
	}
	/*
	 * If we were in PM_FAIL mode, rollback of metadata failed.  We're
	 * not going to recover without a thin_repair.	So we never let the
	 * pool move out of the old mode.
	 */
	if (old_mode == PM_FAIL)
		new_mode = old_mode;
2574

2575
	switch (new_mode) {
2576
	case PM_FAIL:
2577
		dm_pool_metadata_read_only(pool->pmd);
2578 2579
		pool->process_bio = process_bio_fail;
		pool->process_discard = process_bio_fail;
2580 2581
		pool->process_cell = process_cell_fail;
		pool->process_discard_cell = process_cell_fail;
2582 2583
		pool->process_prepared_mapping = process_prepared_mapping_fail;
		pool->process_prepared_discard = process_prepared_discard_fail;
2584 2585

		error_retry_list(pool);
2586 2587
		break;

2588
	case PM_OUT_OF_METADATA_SPACE:
2589
	case PM_READ_ONLY:
2590 2591 2592
		dm_pool_metadata_read_only(pool->pmd);
		pool->process_bio = process_bio_read_only;
		pool->process_discard = process_bio_success;
2593 2594
		pool->process_cell = process_cell_read_only;
		pool->process_discard_cell = process_cell_success;
2595
		pool->process_prepared_mapping = process_prepared_mapping_fail;
2596
		pool->process_prepared_discard = process_prepared_discard_success;
2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609

		error_retry_list(pool);
		break;

	case PM_OUT_OF_DATA_SPACE:
		/*
		 * Ideally we'd never hit this state; the low water mark
		 * would trigger userland to extend the pool before we
		 * completely run out of data space.  However, many small
		 * IOs to unprovisioned space can consume data space at an
		 * alarming rate.  Adjust your low water mark if you're
		 * frequently seeing this mode.
		 */
2610
		pool->out_of_data_space = true;
2611
		pool->process_bio = process_bio_read_only;
2612 2613
		pool->process_discard = process_discard_bio;
		pool->process_cell = process_cell_read_only;
2614
		pool->process_prepared_mapping = process_prepared_mapping;
2615
		set_discard_callbacks(pool);
2616

2617 2618
		if (!pool->pf.error_if_no_space && no_space_timeout)
			queue_delayed_work(pool->wq, &pool->no_space_timeout, no_space_timeout);
2619 2620 2621
		break;

	case PM_WRITE:
2622 2623
		if (old_mode == PM_OUT_OF_DATA_SPACE)
			cancel_delayed_work_sync(&pool->no_space_timeout);
2624
		pool->out_of_data_space = false;
2625
		pool->pf.error_if_no_space = pt->requested_pf.error_if_no_space;
2626
		dm_pool_metadata_read_write(pool->pmd);
2627
		pool->process_bio = process_bio;
2628 2629
		pool->process_discard = process_discard_bio;
		pool->process_cell = process_cell;
2630
		pool->process_prepared_mapping = process_prepared_mapping;
2631
		set_discard_callbacks(pool);
2632 2633
		break;
	}
2634 2635

	pool->pf.mode = new_mode;
2636 2637 2638 2639 2640
	/*
	 * The pool mode may have changed, sync it so bind_control_target()
	 * doesn't cause an unexpected mode transition on resume.
	 */
	pt->adjusted_pf.mode = new_mode;
2641 2642 2643

	if (old_mode != new_mode)
		notify_of_pool_mode_change(pool);
2644 2645
}

2646
static void abort_transaction(struct pool *pool)
2647
{
2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660
	const char *dev_name = dm_device_name(pool->pool_md);

	DMERR_LIMIT("%s: aborting current metadata transaction", dev_name);
	if (dm_pool_abort_metadata(pool->pmd)) {
		DMERR("%s: failed to abort metadata transaction", dev_name);
		set_pool_mode(pool, PM_FAIL);
	}

	if (dm_pool_metadata_set_needs_check(pool->pmd)) {
		DMERR("%s: failed to set 'needs_check' flag in metadata", dev_name);
		set_pool_mode(pool, PM_FAIL);
	}
}
2661

2662 2663
static void metadata_operation_failed(struct pool *pool, const char *op, int r)
{
2664 2665 2666
	DMERR_LIMIT("%s: metadata operation '%s' failed: error = %d",
		    dm_device_name(pool->pool_md), op, r);

2667
	abort_transaction(pool);
2668 2669 2670
	set_pool_mode(pool, PM_READ_ONLY);
}

2671 2672
/*----------------------------------------------------------------*/

2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683
/*
 * Mapping functions.
 */

/*
 * Called only while mapping a thin bio to hand it over to the workqueue.
 */
static void thin_defer_bio(struct thin_c *tc, struct bio *bio)
{
	struct pool *pool = tc->pool;

2684
	spin_lock_irq(&tc->lock);
2685
	bio_list_add(&tc->deferred_bio_list, bio);
2686
	spin_unlock_irq(&tc->lock);
2687 2688 2689 2690

	wake_worker(pool);
}

Joe Thornber's avatar
Joe Thornber committed
2691 2692 2693 2694 2695 2696 2697 2698 2699
static void thin_defer_bio_with_throttle(struct thin_c *tc, struct bio *bio)
{
	struct pool *pool = tc->pool;

	throttle_lock(&pool->throttle);
	thin_defer_bio(tc, bio);
	throttle_unlock(&pool->throttle);
}

2700 2701 2702 2703 2704
static void thin_defer_cell(struct thin_c *tc, struct dm_bio_prison_cell *cell)
{
	struct pool *pool = tc->pool;

	throttle_lock(&pool->throttle);
2705
	spin_lock_irq(&tc->lock);
2706
	list_add_tail(&cell->user_list, &tc->deferred_cells);
2707
	spin_unlock_irq(&tc->lock);
2708 2709 2710 2711 2712
	throttle_unlock(&pool->throttle);

	wake_worker(pool);
}

2713
static void thin_hook_bio(struct thin_c *tc, struct bio *bio)
2714
{
2715
	struct dm_thin_endio_hook *h = dm_per_bio_data(bio, sizeof(struct dm_thin_endio_hook));
2716 2717 2718

	h->tc = tc;
	h->shared_read_entry = NULL;
2719
	h->all_io_entry = NULL;
2720
	h->overwrite_mapping = NULL;
2721
	h->cell = NULL;
2722 2723
}

2724 2725 2726
/*
 * Non-blocking function called from the thin target's map function.
 */
Mikulas Patocka's avatar
Mikulas Patocka committed
2727
static int thin_bio_map(struct dm_target *ti, struct bio *bio)
2728 2729 2730 2731 2732 2733
{
	int r;
	struct thin_c *tc = ti->private;
	dm_block_t block = get_bio_block(tc, bio);
	struct dm_thin_device *td = tc->td;
	struct dm_thin_lookup_result result;
2734
	struct dm_bio_prison_cell *virt_cell, *data_cell;
2735
	struct dm_cell_key key;
2736

2737
	thin_hook_bio(tc, bio);
2738

2739
	if (tc->requeue_mode) {
2740
		bio->bi_status = BLK_STS_DM_REQUEUE;
2741
		bio_endio(bio);
2742 2743 2744
		return DM_MAPIO_SUBMITTED;
	}

2745 2746 2747 2748 2749
	if (get_pool_mode(tc->pool) == PM_FAIL) {
		bio_io_error(bio);
		return DM_MAPIO_SUBMITTED;
	}

2750
	if (op_is_flush(bio->bi_opf) || bio_op(bio) == REQ_OP_DISCARD) {
Joe Thornber's avatar
Joe Thornber committed
2751
		thin_defer_bio_with_throttle(tc, bio);
2752 2753 2754
		return DM_MAPIO_SUBMITTED;
	}

2755 2756 2757 2758 2759
	/*
	 * We must hold the virtual cell before doing the lookup, otherwise
	 * there's a race with discard.
	 */
	build_virtual_key(tc->td, block, &key);
2760
	if (bio_detain(tc->pool, &key, bio, &virt_cell))
2761 2762
		return DM_MAPIO_SUBMITTED;

2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784
	r = dm_thin_find_block(td, block, 0, &result);

	/*
	 * Note that we defer readahead too.
	 */
	switch (r) {
	case 0:
		if (unlikely(result.shared)) {
			/*
			 * We have a race condition here between the
			 * result.shared value returned by the lookup and
			 * snapshot creation, which may cause new
			 * sharing.
			 *
			 * To avoid this always quiesce the origin before
			 * taking the snap.  You want to do this anyway to
			 * ensure a consistent application view
			 * (i.e. lockfs).
			 *
			 * More distant ancestors are irrelevant. The
			 * shared flag will be set in their case.
			 */
2785
			thin_defer_cell(tc, virt_cell);
2786
			return DM_MAPIO_SUBMITTED;
2787
		}
2788 2789

		build_data_key(tc->td, result.block, &key);
2790 2791
		if (bio_detain(tc->pool, &key, bio, &data_cell)) {
			cell_defer_no_holder(tc, virt_cell);
2792 2793 2794 2795
			return DM_MAPIO_SUBMITTED;
		}

		inc_all_io_entry(tc->pool, bio);
2796 2797
		cell_defer_no_holder(tc, data_cell);
		cell_defer_no_holder(tc, virt_cell);
2798 2799 2800

		remap(tc, bio, result.block);
		return DM_MAPIO_REMAPPED;
2801 2802

	case -ENODATA:
2803
	case -EWOULDBLOCK:
2804
		thin_defer_cell(tc, virt_cell);
Joe Thornber's avatar
Joe Thornber committed
2805
		return DM_MAPIO_SUBMITTED;
2806 2807 2808 2809 2810 2811 2812 2813

	default:
		/*
		 * Must always call bio_io_error on failure.
		 * dm_thin_find_block can fail with -EINVAL if the
		 * pool is switched to fail-io mode.
		 */
		bio_io_error(bio);
2814
		cell_defer_no_holder(tc, virt_cell);
Joe Thornber's avatar
Joe Thornber committed
2815
		return DM_MAPIO_SUBMITTED;
2816 2817 2818
	}
}

2819
static void requeue_bios(struct pool *pool)
2820
{
2821 2822 2823 2824
	struct thin_c *tc;

	rcu_read_lock();
	list_for_each_entry_rcu(tc, &pool->active_thins, list) {
2825
		spin_lock_irq(&tc->lock);
2826 2827
		bio_list_merge(&tc->deferred_bio_list, &tc->retry_on_resume_list);
		bio_list_init(&tc->retry_on_resume_list);
2828
		spin_unlock_irq(&tc->lock);
2829 2830
	}
	rcu_read_unlock();
2831 2832
}

2833 2834
/*
 *--------------------------------------------------------------
2835
 * Binding of control targets to a pool object
2836 2837
 *--------------------------------------------------------------
 */
2838 2839 2840 2841 2842
static bool is_factor(sector_t block_size, uint32_t n)
{
	return !sector_div(block_size, n);
}

Mike Snitzer's avatar
Mike Snitzer committed
2843 2844
/*
 * If discard_passdown was enabled verify that the data device
2845
 * supports discards.  Disable discard_passdown if not.
Mike Snitzer's avatar
Mike Snitzer committed
2846
 */
2847
static void disable_discard_passdown_if_not_supported(struct pool_c *pt)
Mike Snitzer's avatar
Mike Snitzer committed
2848
{
2849 2850 2851 2852
	struct pool *pool = pt->pool;
	struct block_device *data_bdev = pt->data_dev->bdev;
	struct queue_limits *data_limits = &bdev_get_queue(data_bdev)->limits;
	const char *reason = NULL;
Mike Snitzer's avatar
Mike Snitzer committed
2853

2854
	if (!pt->adjusted_pf.discard_passdown)
Mike Snitzer's avatar
Mike Snitzer committed
2855 2856
		return;

2857
	if (!bdev_max_discard_sectors(pt->data_dev->bdev))
2858 2859 2860 2861
		reason = "discard unsupported";

	else if (data_limits->max_discard_sectors < pool->sectors_per_block)
		reason = "max discard sectors smaller than a block";
Mike Snitzer's avatar
Mike Snitzer committed
2862

2863
	if (reason) {
2864
		DMWARN("Data device (%pg) %s: Disabling discard passdown.", data_bdev, reason);
2865 2866
		pt->adjusted_pf.discard_passdown = false;
	}
Mike Snitzer's avatar
Mike Snitzer committed
2867 2868
}

2869 2870 2871 2872
static int bind_control_target(struct pool *pool, struct dm_target *ti)
{
	struct pool_c *pt = ti->private;

2873
	/*
2874
	 * We want to make sure that a pool in PM_FAIL mode is never upgraded.
2875
	 */
2876
	enum pool_mode old_mode = get_pool_mode(pool);
2877
	enum pool_mode new_mode = pt->adjusted_pf.mode;
2878

2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889
	/*
	 * Don't change the pool's mode until set_pool_mode() below.
	 * Otherwise the pool's process_* function pointers may
	 * not match the desired pool mode.
	 */
	pt->adjusted_pf.mode = old_mode;

	pool->ti = ti;
	pool->pf = pt->adjusted_pf;
	pool->low_water_blocks = pt->low_water_blocks;

Mike Snitzer's avatar
Mike Snitzer committed
2890
	set_pool_mode(pool, new_mode);
2891

2892 2893 2894 2895 2896 2897 2898 2899 2900
	return 0;
}

static void unbind_control_target(struct pool *pool, struct dm_target *ti)
{
	if (pool->ti == ti)
		pool->ti = NULL;
}

2901 2902
/*
 *--------------------------------------------------------------
2903
 * Pool creation
2904 2905
 *--------------------------------------------------------------
 */
2906 2907 2908
/* Initialize pool features. */
static void pool_features_init(struct pool_features *pf)
{
2909
	pf->mode = PM_WRITE;
Mike Snitzer's avatar
Mike Snitzer committed
2910 2911 2912
	pf->zero_new_blocks = true;
	pf->discard_enabled = true;
	pf->discard_passdown = true;
2913
	pf->error_if_no_space = false;
2914 2915
}

2916 2917 2918 2919
static void __pool_destroy(struct pool *pool)
{
	__pool_table_remove(pool);

2920
	vfree(pool->cell_sort_array);
2921 2922 2923
	if (dm_pool_metadata_close(pool->pmd) < 0)
		DMWARN("%s: dm_pool_metadata_close() failed.", __func__);

2924
	dm_bio_prison_destroy(pool->prison);
2925 2926
	dm_kcopyd_client_destroy(pool->copier);

2927 2928
	cancel_delayed_work_sync(&pool->waker);
	cancel_delayed_work_sync(&pool->no_space_timeout);
2929 2930 2931 2932
	if (pool->wq)
		destroy_workqueue(pool->wq);

	if (pool->next_mapping)
2933 2934
		mempool_free(pool->next_mapping, &pool->mapping_pool);
	mempool_exit(&pool->mapping_pool);
2935 2936
	dm_deferred_set_destroy(pool->shared_read_ds);
	dm_deferred_set_destroy(pool->all_io_ds);
2937 2938 2939
	kfree(pool);
}

Mike Snitzer's avatar
Mike Snitzer committed
2940 2941
static struct kmem_cache *_new_mapping_cache;

2942 2943
static struct pool *pool_create(struct mapped_device *pool_md,
				struct block_device *metadata_dev,
2944
				struct block_device *data_dev,
2945 2946
				unsigned long block_size,
				int read_only, char **error)
2947 2948 2949 2950 2951
{
	int r;
	void *err_p;
	struct pool *pool;
	struct dm_pool_metadata *pmd;
2952
	bool format_device = read_only ? false : true;
2953

2954
	pmd = dm_pool_metadata_open(metadata_dev, block_size, format_device);
2955 2956 2957 2958 2959
	if (IS_ERR(pmd)) {
		*error = "Error creating metadata object";
		return (struct pool *)pmd;
	}

2960
	pool = kzalloc(sizeof(*pool), GFP_KERNEL);
2961 2962 2963 2964 2965 2966 2967 2968
	if (!pool) {
		*error = "Error allocating memory for pool";
		err_p = ERR_PTR(-ENOMEM);
		goto bad_pool;
	}

	pool->pmd = pmd;
	pool->sectors_per_block = block_size;
2969 2970 2971 2972
	if (block_size & (block_size - 1))
		pool->sectors_per_block_shift = -1;
	else
		pool->sectors_per_block_shift = __ffs(block_size);
2973
	pool->low_water_blocks = 0;
2974
	pool_features_init(&pool->pf);
2975
	pool->prison = dm_bio_prison_create();
2976 2977 2978 2979 2980 2981
	if (!pool->prison) {
		*error = "Error creating pool's bio prison";
		err_p = ERR_PTR(-ENOMEM);
		goto bad_prison;
	}

2982
	pool->copier = dm_kcopyd_client_create(&dm_kcopyd_throttle);
2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000
	if (IS_ERR(pool->copier)) {
		r = PTR_ERR(pool->copier);
		*error = "Error creating pool's kcopyd client";
		err_p = ERR_PTR(r);
		goto bad_kcopyd_client;
	}

	/*
	 * Create singlethreaded workqueue that will service all devices
	 * that use this metadata.
	 */
	pool->wq = alloc_ordered_workqueue("dm-" DM_MSG_PREFIX, WQ_MEM_RECLAIM);
	if (!pool->wq) {
		*error = "Error creating pool's workqueue";
		err_p = ERR_PTR(-ENOMEM);
		goto bad_wq;
	}

Joe Thornber's avatar
Joe Thornber committed
3001
	throttle_init(&pool->throttle);
3002
	INIT_WORK(&pool->worker, do_worker);
3003
	INIT_DELAYED_WORK(&pool->waker, do_waker);
3004
	INIT_DELAYED_WORK(&pool->no_space_timeout, do_no_space_timeout);
3005 3006
	spin_lock_init(&pool->lock);
	bio_list_init(&pool->deferred_flush_bios);
3007
	bio_list_init(&pool->deferred_flush_completions);
3008
	INIT_LIST_HEAD(&pool->prepared_mappings);
Joe Thornber's avatar
Joe Thornber committed
3009
	INIT_LIST_HEAD(&pool->prepared_discards);
3010
	INIT_LIST_HEAD(&pool->prepared_discards_pt2);
3011
	INIT_LIST_HEAD(&pool->active_thins);
3012
	pool->low_water_triggered = false;
3013
	pool->suspended = true;
3014
	pool->out_of_data_space = false;
3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028

	pool->shared_read_ds = dm_deferred_set_create();
	if (!pool->shared_read_ds) {
		*error = "Error creating pool's shared read deferred set";
		err_p = ERR_PTR(-ENOMEM);
		goto bad_shared_read_ds;
	}

	pool->all_io_ds = dm_deferred_set_create();
	if (!pool->all_io_ds) {
		*error = "Error creating pool's all io deferred set";
		err_p = ERR_PTR(-ENOMEM);
		goto bad_all_io_ds;
	}
3029 3030

	pool->next_mapping = NULL;
3031 3032 3033
	r = mempool_init_slab_pool(&pool->mapping_pool, MAPPING_POOL_SIZE,
				   _new_mapping_cache);
	if (r) {
3034
		*error = "Error creating pool's mapping mempool";
3035
		err_p = ERR_PTR(r);
3036 3037 3038
		goto bad_mapping_pool;
	}

3039 3040 3041
	pool->cell_sort_array =
		vmalloc(array_size(CELL_SORT_ARRAY_SIZE,
				   sizeof(*pool->cell_sort_array)));
3042 3043 3044 3045 3046 3047
	if (!pool->cell_sort_array) {
		*error = "Error allocating cell sort array";
		err_p = ERR_PTR(-ENOMEM);
		goto bad_sort_array;
	}

3048
	pool->ref_count = 1;
3049
	pool->last_commit_jiffies = jiffies;
3050 3051
	pool->pool_md = pool_md;
	pool->md_dev = metadata_dev;
3052
	pool->data_dev = data_dev;
3053 3054 3055 3056
	__pool_table_insert(pool);

	return pool;

3057
bad_sort_array:
3058
	mempool_exit(&pool->mapping_pool);
3059
bad_mapping_pool:
3060 3061 3062 3063
	dm_deferred_set_destroy(pool->all_io_ds);
bad_all_io_ds:
	dm_deferred_set_destroy(pool->shared_read_ds);
bad_shared_read_ds:
3064 3065 3066 3067
	destroy_workqueue(pool->wq);
bad_wq:
	dm_kcopyd_client_destroy(pool->copier);
bad_kcopyd_client:
3068
	dm_bio_prison_destroy(pool->prison);
3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093
bad_prison:
	kfree(pool);
bad_pool:
	if (dm_pool_metadata_close(pmd))
		DMWARN("%s: dm_pool_metadata_close() failed.", __func__);

	return err_p;
}

static void __pool_inc(struct pool *pool)
{
	BUG_ON(!mutex_is_locked(&dm_thin_pool_table.mutex));
	pool->ref_count++;
}

static void __pool_dec(struct pool *pool)
{
	BUG_ON(!mutex_is_locked(&dm_thin_pool_table.mutex));
	BUG_ON(!pool->ref_count);
	if (!--pool->ref_count)
		__pool_destroy(pool);
}

static struct pool *__pool_find(struct mapped_device *pool_md,
				struct block_device *metadata_dev,
3094
				struct block_device *data_dev,
3095 3096
				unsigned long block_size, int read_only,
				char **error, int *created)
3097 3098 3099 3100
{
	struct pool *pool = __pool_table_lookup_metadata_dev(metadata_dev);

	if (pool) {
3101 3102
		if (pool->pool_md != pool_md) {
			*error = "metadata device already in use by a pool";
3103
			return ERR_PTR(-EBUSY);
3104
		}
3105 3106 3107 3108
		if (pool->data_dev != data_dev) {
			*error = "data device already in use by a pool";
			return ERR_PTR(-EBUSY);
		}
3109 3110 3111 3112 3113
		__pool_inc(pool);

	} else {
		pool = __pool_table_lookup(pool_md);
		if (pool) {
3114
			if (pool->md_dev != metadata_dev || pool->data_dev != data_dev) {
3115
				*error = "different pool cannot replace a pool";
3116
				return ERR_PTR(-EINVAL);
3117
			}
3118 3119
			__pool_inc(pool);

3120
		} else {
3121
			pool = pool_create(pool_md, metadata_dev, data_dev, block_size, read_only, error);
3122 3123
			*created = 1;
		}
3124 3125 3126 3127 3128
	}

	return pool;
}

3129 3130
/*
 *--------------------------------------------------------------
3131
 * Pool target methods
3132 3133
 *--------------------------------------------------------------
 */
3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152
static void pool_dtr(struct dm_target *ti)
{
	struct pool_c *pt = ti->private;

	mutex_lock(&dm_thin_pool_table.mutex);

	unbind_control_target(pt->pool, ti);
	__pool_dec(pt->pool);
	dm_put_device(ti, pt->metadata_dev);
	dm_put_device(ti, pt->data_dev);
	kfree(pt);

	mutex_unlock(&dm_thin_pool_table.mutex);
}

static int parse_pool_features(struct dm_arg_set *as, struct pool_features *pf,
			       struct dm_target *ti)
{
	int r;
3153
	unsigned int argc;
3154 3155
	const char *arg_name;

3156
	static const struct dm_arg _args[] = {
3157
		{0, 4, "Invalid number of pool feature arguments"},
3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173
	};

	/*
	 * No feature arguments supplied.
	 */
	if (!as->argc)
		return 0;

	r = dm_read_arg_group(_args, as, &argc, &ti->error);
	if (r)
		return -EINVAL;

	while (argc && !r) {
		arg_name = dm_shift_arg(as);
		argc--;

3174
		if (!strcasecmp(arg_name, "skip_block_zeroing"))
Mike Snitzer's avatar
Mike Snitzer committed
3175
			pf->zero_new_blocks = false;
3176 3177

		else if (!strcasecmp(arg_name, "ignore_discard"))
Mike Snitzer's avatar
Mike Snitzer committed
3178
			pf->discard_enabled = false;
3179 3180

		else if (!strcasecmp(arg_name, "no_discard_passdown"))
Mike Snitzer's avatar
Mike Snitzer committed
3181
			pf->discard_passdown = false;
3182

3183 3184 3185
		else if (!strcasecmp(arg_name, "read_only"))
			pf->mode = PM_READ_ONLY;

3186 3187 3188
		else if (!strcasecmp(arg_name, "error_if_no_space"))
			pf->error_if_no_space = true;

3189 3190 3191 3192 3193
		else {
			ti->error = "Unrecognised pool feature requested";
			r = -EINVAL;
			break;
		}
3194 3195 3196 3197 3198
	}

	return r;
}

3199 3200 3201 3202 3203 3204 3205 3206 3207 3208
static void metadata_low_callback(void *context)
{
	struct pool *pool = context;

	DMWARN("%s: reached low water mark for metadata device: sending event.",
	       dm_device_name(pool->pool_md));

	dm_table_event(pool->ti->table);
}

3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221
/*
 * We need to flush the data device **before** committing the metadata.
 *
 * This ensures that the data blocks of any newly inserted mappings are
 * properly written to non-volatile storage and won't be lost in case of a
 * crash.
 *
 * Failure to do so can result in data corruption in the case of internal or
 * external snapshots and in the case of newly provisioned blocks, when block
 * zeroing is enabled.
 */
static int metadata_pre_commit_callback(void *context)
{
3222
	struct pool *pool = context;
3223

3224
	return blkdev_issue_flush(pool->data_dev);
3225 3226
}

3227 3228
static sector_t get_dev_size(struct block_device *bdev)
{
3229
	return bdev_nr_sectors(bdev);
3230 3231 3232
}

static void warn_if_metadata_device_too_big(struct block_device *bdev)
3233
{
3234
	sector_t metadata_dev_size = get_dev_size(bdev);
3235

3236
	if (metadata_dev_size > THIN_METADATA_MAX_SECTORS_WARNING)
3237 3238
		DMWARN("Metadata device %pg is larger than %u sectors: excess space will not be used.",
		       bdev, THIN_METADATA_MAX_SECTORS);
3239 3240 3241 3242 3243 3244 3245 3246
}

static sector_t get_metadata_dev_size(struct block_device *bdev)
{
	sector_t metadata_dev_size = get_dev_size(bdev);

	if (metadata_dev_size > THIN_METADATA_MAX_SECTORS)
		metadata_dev_size = THIN_METADATA_MAX_SECTORS;
3247 3248 3249 3250

	return metadata_dev_size;
}

3251 3252 3253 3254
static dm_block_t get_metadata_dev_size_in_blocks(struct block_device *bdev)
{
	sector_t metadata_dev_size = get_metadata_dev_size(bdev);

3255
	sector_div(metadata_dev_size, THIN_METADATA_BLOCK_SIZE);
3256 3257 3258 3259

	return metadata_dev_size;
}

3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273
/*
 * When a metadata threshold is crossed a dm event is triggered, and
 * userland should respond by growing the metadata device.  We could let
 * userland set the threshold, like we do with the data threshold, but I'm
 * not sure they know enough to do this well.
 */
static dm_block_t calc_metadata_threshold(struct pool_c *pt)
{
	/*
	 * 4M is ample for all ops with the possible exception of thin
	 * device deletion which is harmless if it fails (just retry the
	 * delete after you've grown the device).
	 */
	dm_block_t quarter = get_metadata_dev_size_in_blocks(pt->metadata_dev->bdev) / 4;
3274

3275 3276 3277
	return min((dm_block_t)1024ULL /* 4M */, quarter);
}

3278 3279 3280 3281 3282 3283 3284 3285
/*
 * thin-pool <metadata dev> <data dev>
 *	     <data block size (sectors)>
 *	     <low water mark (blocks)>
 *	     [<#feature args> [<arg>]*]
 *
 * Optional feature arguments are:
 *	     skip_block_zeroing: skips the zeroing of newly-provisioned blocks.
3286 3287
 *	     ignore_discard: disable discard
 *	     no_discard_passdown: don't pass discards down to the data device
3288 3289
 *	     read_only: Don't allow any changes to be made to the pool metadata.
 *	     error_if_no_space: error IOs, instead of queueing, if no space.
3290
 */
3291
static int pool_ctr(struct dm_target *ti, unsigned int argc, char **argv)
3292
{
3293
	int r, pool_created = 0;
3294 3295 3296 3297 3298 3299 3300 3301
	struct pool_c *pt;
	struct pool *pool;
	struct pool_features pf;
	struct dm_arg_set as;
	struct dm_dev *data_dev;
	unsigned long block_size;
	dm_block_t low_water_blocks;
	struct dm_dev *metadata_dev;
3302
	blk_mode_t metadata_mode;
3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313

	/*
	 * FIXME Remove validation from scope of lock.
	 */
	mutex_lock(&dm_thin_pool_table.mutex);

	if (argc < 4) {
		ti->error = "Invalid argument count";
		r = -EINVAL;
		goto out_unlock;
	}
3314

3315 3316 3317
	as.argc = argc;
	as.argv = argv;

3318 3319 3320 3321 3322 3323 3324
	/* make sure metadata and data are different devices */
	if (!strcmp(argv[0], argv[1])) {
		ti->error = "Error setting metadata or data device";
		r = -EINVAL;
		goto out_unlock;
	}

3325 3326 3327 3328 3329 3330 3331 3332 3333 3334
	/*
	 * Set default pool features.
	 */
	pool_features_init(&pf);

	dm_consume_args(&as, 4);
	r = parse_pool_features(&as, &pf, ti);
	if (r)
		goto out_unlock;

3335 3336
	metadata_mode = BLK_OPEN_READ |
		((pf.mode == PM_READ_ONLY) ? 0 : BLK_OPEN_WRITE);
3337
	r = dm_get_device(ti, argv[0], metadata_mode, &metadata_dev);
3338 3339 3340 3341
	if (r) {
		ti->error = "Error opening metadata block device";
		goto out_unlock;
	}
3342
	warn_if_metadata_device_too_big(metadata_dev->bdev);
3343

3344
	r = dm_get_device(ti, argv[1], BLK_OPEN_READ | BLK_OPEN_WRITE, &data_dev);
3345 3346 3347 3348 3349 3350 3351 3352
	if (r) {
		ti->error = "Error getting data device";
		goto out_metadata;
	}

	if (kstrtoul(argv[2], 10, &block_size) || !block_size ||
	    block_size < DATA_DEV_BLOCK_SIZE_MIN_SECTORS ||
	    block_size > DATA_DEV_BLOCK_SIZE_MAX_SECTORS ||
3353
	    block_size & (DATA_DEV_BLOCK_SIZE_MIN_SECTORS - 1)) {
3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370
		ti->error = "Invalid block size";
		r = -EINVAL;
		goto out;
	}

	if (kstrtoull(argv[3], 10, (unsigned long long *)&low_water_blocks)) {
		ti->error = "Invalid low water mark";
		r = -EINVAL;
		goto out;
	}

	pt = kzalloc(sizeof(*pt), GFP_KERNEL);
	if (!pt) {
		r = -ENOMEM;
		goto out;
	}

3371
	pool = __pool_find(dm_table_get_md(ti->table), metadata_dev->bdev, data_dev->bdev,
3372
			   block_size, pf.mode == PM_READ_ONLY, &ti->error, &pool_created);
3373 3374 3375 3376 3377
	if (IS_ERR(pool)) {
		r = PTR_ERR(pool);
		goto out_free_pt;
	}

3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389
	/*
	 * 'pool_created' reflects whether this is the first table load.
	 * Top level discard support is not allowed to be changed after
	 * initial load.  This would require a pool reload to trigger thin
	 * device changes.
	 */
	if (!pool_created && pf.discard_enabled != pool->pf.discard_enabled) {
		ti->error = "Discard support cannot be disabled once enabled";
		r = -EINVAL;
		goto out_flags_changed;
	}

3390 3391 3392 3393 3394
	pt->pool = pool;
	pt->ti = ti;
	pt->metadata_dev = metadata_dev;
	pt->data_dev = data_dev;
	pt->low_water_blocks = low_water_blocks;
3395
	pt->adjusted_pf = pt->requested_pf = pf;
3396
	ti->num_flush_bios = 1;
3397
	ti->limit_swap_bios = true;
Mike Snitzer's avatar
Mike Snitzer committed
3398

3399 3400 3401 3402 3403 3404
	/*
	 * Only need to enable discards if the pool should pass
	 * them down to the data device.  The thin device's discard
	 * processing will cause mappings to be removed from the btree.
	 */
	if (pf.discard_enabled && pf.discard_passdown) {
3405
		ti->num_discard_bios = 1;
3406 3407 3408 3409 3410
		/*
		 * Setting 'discards_supported' circumvents the normal
		 * stacking of discard limits (this keeps the pool and
		 * thin devices' discard limits consistent).
		 */
3411
		ti->discards_supported = true;
3412
		ti->max_discard_granularity = true;
3413
	}
3414 3415
	ti->private = pt;

3416 3417 3418 3419
	r = dm_pool_register_metadata_threshold(pt->pool->pmd,
						calc_metadata_threshold(pt),
						metadata_low_callback,
						pool);
3420 3421
	if (r) {
		ti->error = "Error registering metadata threshold";
3422
		goto out_flags_changed;
3423
	}
3424

3425 3426 3427
	dm_pool_register_pre_commit_callback(pool->pmd,
					     metadata_pre_commit_callback, pool);

3428 3429 3430 3431
	mutex_unlock(&dm_thin_pool_table.mutex);

	return 0;

3432 3433
out_flags_changed:
	__pool_dec(pool);
3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445
out_free_pt:
	kfree(pt);
out:
	dm_put_device(ti, data_dev);
out_metadata:
	dm_put_device(ti, metadata_dev);
out_unlock:
	mutex_unlock(&dm_thin_pool_table.mutex);

	return r;
}

Mikulas Patocka's avatar
Mikulas Patocka committed
3446
static int pool_map(struct dm_target *ti, struct bio *bio)
3447 3448 3449 3450 3451 3452 3453
{
	struct pool_c *pt = ti->private;
	struct pool *pool = pt->pool;

	/*
	 * As this is a singleton target, ti->begin is always zero.
	 */
3454
	spin_lock_irq(&pool->lock);
3455
	bio_set_dev(bio, pt->data_dev->bdev);
3456
	spin_unlock_irq(&pool->lock);
3457

3458
	return DM_MAPIO_REMAPPED;
3459 3460
}

3461
static int maybe_resize_data_dev(struct dm_target *ti, bool *need_commit)
3462 3463 3464 3465
{
	int r;
	struct pool_c *pt = ti->private;
	struct pool *pool = pt->pool;
3466 3467
	sector_t data_size = ti->len;
	dm_block_t sb_data_size;
3468

3469
	*need_commit = false;
3470

3471 3472
	(void) sector_div(data_size, pool->sectors_per_block);

3473 3474
	r = dm_pool_get_data_dev_size(pool->pmd, &sb_data_size);
	if (r) {
3475 3476
		DMERR("%s: failed to retrieve data device size",
		      dm_device_name(pool->pool_md));
3477 3478 3479 3480
		return r;
	}

	if (data_size < sb_data_size) {
3481 3482
		DMERR("%s: pool target (%llu blocks) too small: expected %llu",
		      dm_device_name(pool->pool_md),
3483
		      (unsigned long long)data_size, sb_data_size);
3484 3485 3486
		return -EINVAL;

	} else if (data_size > sb_data_size) {
3487 3488 3489 3490 3491 3492
		if (dm_pool_metadata_needs_check(pool->pmd)) {
			DMERR("%s: unable to grow the data device until repaired.",
			      dm_device_name(pool->pool_md));
			return 0;
		}

3493 3494 3495 3496
		if (sb_data_size)
			DMINFO("%s: growing the data device from %llu to %llu blocks",
			       dm_device_name(pool->pool_md),
			       sb_data_size, (unsigned long long)data_size);
3497 3498
		r = dm_pool_resize_data_dev(pool->pmd, data_size);
		if (r) {
3499
			metadata_operation_failed(pool, "dm_pool_resize_data_dev", r);
3500 3501 3502
			return r;
		}

3503
		*need_commit = true;
3504 3505 3506 3507 3508
	}

	return 0;
}

3509 3510 3511 3512 3513 3514 3515 3516 3517
static int maybe_resize_metadata_dev(struct dm_target *ti, bool *need_commit)
{
	int r;
	struct pool_c *pt = ti->private;
	struct pool *pool = pt->pool;
	dm_block_t metadata_dev_size, sb_metadata_dev_size;

	*need_commit = false;

3518
	metadata_dev_size = get_metadata_dev_size_in_blocks(pool->md_dev);
3519 3520 3521

	r = dm_pool_get_metadata_dev_size(pool->pmd, &sb_metadata_dev_size);
	if (r) {
3522 3523
		DMERR("%s: failed to retrieve metadata device size",
		      dm_device_name(pool->pool_md));
3524 3525 3526 3527
		return r;
	}

	if (metadata_dev_size < sb_metadata_dev_size) {
3528 3529
		DMERR("%s: metadata device (%llu blocks) too small: expected %llu",
		      dm_device_name(pool->pool_md),
3530 3531 3532 3533
		      metadata_dev_size, sb_metadata_dev_size);
		return -EINVAL;

	} else if (metadata_dev_size > sb_metadata_dev_size) {
3534 3535 3536 3537 3538 3539
		if (dm_pool_metadata_needs_check(pool->pmd)) {
			DMERR("%s: unable to grow the metadata device until repaired.",
			      dm_device_name(pool->pool_md));
			return 0;
		}

3540
		warn_if_metadata_device_too_big(pool->md_dev);
3541 3542 3543
		DMINFO("%s: growing the metadata device from %llu to %llu blocks",
		       dm_device_name(pool->pool_md),
		       sb_metadata_dev_size, metadata_dev_size);
3544 3545 3546 3547

		if (get_pool_mode(pool) == PM_OUT_OF_METADATA_SPACE)
			set_pool_mode(pool, PM_WRITE);

3548 3549
		r = dm_pool_resize_metadata_dev(pool->pmd, metadata_dev_size);
		if (r) {
3550
			metadata_operation_failed(pool, "dm_pool_resize_metadata_dev", r);
3551 3552 3553 3554 3555 3556 3557 3558 3559
			return r;
		}

		*need_commit = true;
	}

	return 0;
}

3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573
/*
 * Retrieves the number of blocks of the data device from
 * the superblock and compares it to the actual device size,
 * thus resizing the data device in case it has grown.
 *
 * This both copes with opening preallocated data devices in the ctr
 * being followed by a resume
 * -and-
 * calling the resume method individually after userspace has
 * grown the data device in reaction to a table event.
 */
static int pool_preresume(struct dm_target *ti)
{
	int r;
3574
	bool need_commit1, need_commit2;
3575 3576 3577 3578 3579 3580 3581 3582
	struct pool_c *pt = ti->private;
	struct pool *pool = pt->pool;

	/*
	 * Take control of the pool object.
	 */
	r = bind_control_target(pool, ti);
	if (r)
3583
		goto out;
3584 3585 3586

	r = maybe_resize_data_dev(ti, &need_commit1);
	if (r)
3587
		goto out;
3588

3589 3590
	r = maybe_resize_metadata_dev(ti, &need_commit2);
	if (r)
3591
		goto out;
3592 3593

	if (need_commit1 || need_commit2)
3594
		(void) commit(pool);
3595 3596 3597 3598 3599 3600 3601 3602
out:
	/*
	 * When a thin-pool is PM_FAIL, it cannot be rebuilt if
	 * bio is in deferred list. Therefore need to return 0
	 * to allow pool_resume() to flush IO.
	 */
	if (r && get_pool_mode(pool) == PM_FAIL)
		r = 0;
3603

3604
	return r;
3605 3606
}

3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630
static void pool_suspend_active_thins(struct pool *pool)
{
	struct thin_c *tc;

	/* Suspend all active thin devices */
	tc = get_first_thin(pool);
	while (tc) {
		dm_internal_suspend_noflush(tc->thin_md);
		tc = get_next_thin(pool, tc);
	}
}

static void pool_resume_active_thins(struct pool *pool)
{
	struct thin_c *tc;

	/* Resume all active thin devices */
	tc = get_first_thin(pool);
	while (tc) {
		dm_internal_resume(tc->thin_md);
		tc = get_next_thin(pool, tc);
	}
}

3631 3632 3633 3634 3635
static void pool_resume(struct dm_target *ti)
{
	struct pool_c *pt = ti->private;
	struct pool *pool = pt->pool;

3636 3637 3638 3639 3640 3641 3642
	/*
	 * Must requeue active_thins' bios and then resume
	 * active_thins _before_ clearing 'suspend' flag.
	 */
	requeue_bios(pool);
	pool_resume_active_thins(pool);

3643
	spin_lock_irq(&pool->lock);
3644
	pool->low_water_triggered = false;
3645
	pool->suspended = false;
3646
	spin_unlock_irq(&pool->lock);
3647

3648
	do_waker(&pool->waker.work);
3649 3650
}

3651 3652 3653 3654 3655
static void pool_presuspend(struct dm_target *ti)
{
	struct pool_c *pt = ti->private;
	struct pool *pool = pt->pool;

3656
	spin_lock_irq(&pool->lock);
3657
	pool->suspended = true;
3658
	spin_unlock_irq(&pool->lock);
3659 3660

	pool_suspend_active_thins(pool);
3661 3662 3663 3664 3665 3666 3667
}

static void pool_presuspend_undo(struct dm_target *ti)
{
	struct pool_c *pt = ti->private;
	struct pool *pool = pt->pool;

3668 3669
	pool_resume_active_thins(pool);

3670
	spin_lock_irq(&pool->lock);
3671
	pool->suspended = false;
3672
	spin_unlock_irq(&pool->lock);
3673 3674
}

3675 3676 3677 3678 3679
static void pool_postsuspend(struct dm_target *ti)
{
	struct pool_c *pt = ti->private;
	struct pool *pool = pt->pool;

3680 3681
	cancel_delayed_work_sync(&pool->waker);
	cancel_delayed_work_sync(&pool->no_space_timeout);
3682
	flush_workqueue(pool->wq);
3683
	(void) commit(pool);
3684 3685
}

3686
static int check_arg_count(unsigned int argc, unsigned int args_required)
3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708
{
	if (argc != args_required) {
		DMWARN("Message received with %u arguments instead of %u.",
		       argc, args_required);
		return -EINVAL;
	}

	return 0;
}

static int read_dev_id(char *arg, dm_thin_id *dev_id, int warning)
{
	if (!kstrtoull(arg, 10, (unsigned long long *)dev_id) &&
	    *dev_id <= MAX_DEV_ID)
		return 0;

	if (warning)
		DMWARN("Message received with invalid device id: %s", arg);

	return -EINVAL;
}

3709
static int process_create_thin_mesg(unsigned int argc, char **argv, struct pool *pool)
3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731
{
	dm_thin_id dev_id;
	int r;

	r = check_arg_count(argc, 2);
	if (r)
		return r;

	r = read_dev_id(argv[1], &dev_id, 1);
	if (r)
		return r;

	r = dm_pool_create_thin(pool->pmd, dev_id);
	if (r) {
		DMWARN("Creation of new thinly-provisioned device with id %s failed.",
		       argv[1]);
		return r;
	}

	return 0;
}

3732
static int process_create_snap_mesg(unsigned int argc, char **argv, struct pool *pool)
3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759
{
	dm_thin_id dev_id;
	dm_thin_id origin_dev_id;
	int r;

	r = check_arg_count(argc, 3);
	if (r)
		return r;

	r = read_dev_id(argv[1], &dev_id, 1);
	if (r)
		return r;

	r = read_dev_id(argv[2], &origin_dev_id, 1);
	if (r)
		return r;

	r = dm_pool_create_snap(pool->pmd, dev_id, origin_dev_id);
	if (r) {
		DMWARN("Creation of new snapshot %s of device %s failed.",
		       argv[1], argv[2]);
		return r;
	}

	return 0;
}

3760
static int process_delete_mesg(unsigned int argc, char **argv, struct pool *pool)
3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779
{
	dm_thin_id dev_id;
	int r;

	r = check_arg_count(argc, 2);
	if (r)
		return r;

	r = read_dev_id(argv[1], &dev_id, 1);
	if (r)
		return r;

	r = dm_pool_delete_thin_device(pool->pmd, dev_id);
	if (r)
		DMWARN("Deletion of thin device %s failed.", argv[1]);

	return r;
}

3780
static int process_set_transaction_id_mesg(unsigned int argc, char **argv, struct pool *pool)
3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808
{
	dm_thin_id old_id, new_id;
	int r;

	r = check_arg_count(argc, 3);
	if (r)
		return r;

	if (kstrtoull(argv[1], 10, (unsigned long long *)&old_id)) {
		DMWARN("set_transaction_id message: Unrecognised id %s.", argv[1]);
		return -EINVAL;
	}

	if (kstrtoull(argv[2], 10, (unsigned long long *)&new_id)) {
		DMWARN("set_transaction_id message: Unrecognised new id %s.", argv[2]);
		return -EINVAL;
	}

	r = dm_pool_set_metadata_transaction_id(pool->pmd, old_id, new_id);
	if (r) {
		DMWARN("Failed to change transaction id from %s to %s.",
		       argv[1], argv[2]);
		return r;
	}

	return 0;
}

3809
static int process_reserve_metadata_snap_mesg(unsigned int argc, char **argv, struct pool *pool)
3810 3811 3812 3813 3814 3815 3816
{
	int r;

	r = check_arg_count(argc, 1);
	if (r)
		return r;

3817
	(void) commit(pool);
3818

3819 3820 3821 3822 3823 3824 3825
	r = dm_pool_reserve_metadata_snap(pool->pmd);
	if (r)
		DMWARN("reserve_metadata_snap message failed.");

	return r;
}

3826
static int process_release_metadata_snap_mesg(unsigned int argc, char **argv, struct pool *pool)
3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840
{
	int r;

	r = check_arg_count(argc, 1);
	if (r)
		return r;

	r = dm_pool_release_metadata_snap(pool->pmd);
	if (r)
		DMWARN("release_metadata_snap message failed.");

	return r;
}

3841 3842 3843 3844 3845 3846
/*
 * Messages supported:
 *   create_thin	<dev_id>
 *   create_snap	<dev_id> <origin_id>
 *   delete		<dev_id>
 *   set_transaction_id <current_trans_id> <new_trans_id>
3847 3848
 *   reserve_metadata_snap
 *   release_metadata_snap
3849
 */
3850 3851
static int pool_message(struct dm_target *ti, unsigned int argc, char **argv,
			char *result, unsigned int maxlen)
3852 3853 3854 3855 3856
{
	int r = -EINVAL;
	struct pool_c *pt = ti->private;
	struct pool *pool = pt->pool;

3857
	if (get_pool_mode(pool) >= PM_OUT_OF_METADATA_SPACE) {
3858 3859
		DMERR("%s: unable to service pool target messages in READ_ONLY or FAIL mode",
		      dm_device_name(pool->pool_md));
3860
		return -EOPNOTSUPP;
3861 3862
	}

3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874
	if (!strcasecmp(argv[0], "create_thin"))
		r = process_create_thin_mesg(argc, argv, pool);

	else if (!strcasecmp(argv[0], "create_snap"))
		r = process_create_snap_mesg(argc, argv, pool);

	else if (!strcasecmp(argv[0], "delete"))
		r = process_delete_mesg(argc, argv, pool);

	else if (!strcasecmp(argv[0], "set_transaction_id"))
		r = process_set_transaction_id_mesg(argc, argv, pool);

3875 3876 3877 3878 3879 3880
	else if (!strcasecmp(argv[0], "reserve_metadata_snap"))
		r = process_reserve_metadata_snap_mesg(argc, argv, pool);

	else if (!strcasecmp(argv[0], "release_metadata_snap"))
		r = process_release_metadata_snap_mesg(argc, argv, pool);

3881 3882 3883
	else
		DMWARN("Unrecognised thin pool target message received: %s", argv[0]);

3884
	if (!r)
3885
		(void) commit(pool);
3886 3887 3888 3889

	return r;
}

3890
static void emit_flags(struct pool_features *pf, char *result,
3891
		       unsigned int sz, unsigned int maxlen)
3892
{
3893
	unsigned int count = !pf->zero_new_blocks + !pf->discard_enabled +
3894 3895
		!pf->discard_passdown + (pf->mode == PM_READ_ONLY) +
		pf->error_if_no_space;
3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908
	DMEMIT("%u ", count);

	if (!pf->zero_new_blocks)
		DMEMIT("skip_block_zeroing ");

	if (!pf->discard_enabled)
		DMEMIT("ignore_discard ");

	if (!pf->discard_passdown)
		DMEMIT("no_discard_passdown ");

	if (pf->mode == PM_READ_ONLY)
		DMEMIT("read_only ");
3909 3910 3911

	if (pf->error_if_no_space)
		DMEMIT("error_if_no_space ");
3912 3913
}

3914 3915 3916 3917
/*
 * Status line is:
 *    <transaction id> <used metadata sectors>/<total metadata sectors>
 *    <used data sectors>/<total data sectors> <held metadata root>
3918
 *    <pool mode> <discard config> <no space config> <needs_check>
3919
 */
3920
static void pool_status(struct dm_target *ti, status_type_t type,
3921
			unsigned int status_flags, char *result, unsigned int maxlen)
3922
{
3923
	int r;
3924
	unsigned int sz = 0;
3925 3926 3927 3928 3929 3930
	uint64_t transaction_id;
	dm_block_t nr_free_blocks_data;
	dm_block_t nr_free_blocks_metadata;
	dm_block_t nr_blocks_data;
	dm_block_t nr_blocks_metadata;
	dm_block_t held_root;
3931
	enum pool_mode mode;
3932 3933 3934 3935 3936 3937 3938
	char buf[BDEVNAME_SIZE];
	char buf2[BDEVNAME_SIZE];
	struct pool_c *pt = ti->private;
	struct pool *pool = pt->pool;

	switch (type) {
	case STATUSTYPE_INFO:
3939 3940 3941 3942 3943
		if (get_pool_mode(pool) == PM_FAIL) {
			DMEMIT("Fail");
			break;
		}

3944 3945
		/* Commit to ensure statistics aren't out-of-date */
		if (!(status_flags & DM_STATUS_NOFLUSH_FLAG) && !dm_suspended(ti))
3946
			(void) commit(pool);
3947

3948 3949
		r = dm_pool_get_metadata_transaction_id(pool->pmd, &transaction_id);
		if (r) {
3950 3951
			DMERR("%s: dm_pool_get_metadata_transaction_id returned %d",
			      dm_device_name(pool->pool_md), r);
3952 3953
			goto err;
		}
3954

3955 3956
		r = dm_pool_get_free_metadata_block_count(pool->pmd, &nr_free_blocks_metadata);
		if (r) {
3957 3958
			DMERR("%s: dm_pool_get_free_metadata_block_count returned %d",
			      dm_device_name(pool->pool_md), r);
3959 3960
			goto err;
		}
3961 3962

		r = dm_pool_get_metadata_dev_size(pool->pmd, &nr_blocks_metadata);
3963
		if (r) {
3964 3965
			DMERR("%s: dm_pool_get_metadata_dev_size returned %d",
			      dm_device_name(pool->pool_md), r);
3966 3967
			goto err;
		}
3968

3969 3970
		r = dm_pool_get_free_block_count(pool->pmd, &nr_free_blocks_data);
		if (r) {
3971 3972
			DMERR("%s: dm_pool_get_free_block_count returned %d",
			      dm_device_name(pool->pool_md), r);
3973 3974
			goto err;
		}
3975 3976

		r = dm_pool_get_data_dev_size(pool->pmd, &nr_blocks_data);
3977
		if (r) {
3978 3979
			DMERR("%s: dm_pool_get_data_dev_size returned %d",
			      dm_device_name(pool->pool_md), r);
3980 3981
			goto err;
		}
3982

3983
		r = dm_pool_get_metadata_snap(pool->pmd, &held_root);
3984
		if (r) {
3985 3986
			DMERR("%s: dm_pool_get_metadata_snap returned %d",
			      dm_device_name(pool->pool_md), r);
3987 3988
			goto err;
		}
3989 3990 3991 3992 3993 3994 3995 3996 3997

		DMEMIT("%llu %llu/%llu %llu/%llu ",
		       (unsigned long long)transaction_id,
		       (unsigned long long)(nr_blocks_metadata - nr_free_blocks_metadata),
		       (unsigned long long)nr_blocks_metadata,
		       (unsigned long long)(nr_blocks_data - nr_free_blocks_data),
		       (unsigned long long)nr_blocks_data);

		if (held_root)
3998 3999 4000 4001
			DMEMIT("%llu ", held_root);
		else
			DMEMIT("- ");

4002 4003
		mode = get_pool_mode(pool);
		if (mode == PM_OUT_OF_DATA_SPACE)
4004
			DMEMIT("out_of_data_space ");
4005
		else if (is_read_only_pool_mode(mode))
4006
			DMEMIT("ro ");
4007
		else
4008 4009
			DMEMIT("rw ");

4010
		if (!pool->pf.discard_enabled)
4011
			DMEMIT("ignore_discard ");
4012
		else if (pool->pf.discard_passdown)
4013 4014 4015 4016 4017 4018
			DMEMIT("discard_passdown ");
		else
			DMEMIT("no_discard_passdown ");

		if (pool->pf.error_if_no_space)
			DMEMIT("error_if_no_space ");
4019
		else
4020
			DMEMIT("queue_if_no_space ");
4021

4022 4023 4024 4025 4026
		if (dm_pool_metadata_needs_check(pool->pmd))
			DMEMIT("needs_check ");
		else
			DMEMIT("- ");

4027 4028
		DMEMIT("%llu ", (unsigned long long)calc_metadata_threshold(pt));

4029 4030 4031 4032 4033 4034 4035 4036
		break;

	case STATUSTYPE_TABLE:
		DMEMIT("%s %s %lu %llu ",
		       format_dev_t(buf, pt->metadata_dev->bdev->bd_dev),
		       format_dev_t(buf2, pt->data_dev->bdev->bd_dev),
		       (unsigned long)pool->sectors_per_block,
		       (unsigned long long)pt->low_water_blocks);
4037
		emit_flags(&pt->requested_pf, result, sz, maxlen);
4038
		break;
4039 4040 4041 4042

	case STATUSTYPE_IMA:
		*result = '\0';
		break;
4043
	}
4044
	return;
4045

4046 4047
err:
	DMEMIT("Error");
4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061
}

static int pool_iterate_devices(struct dm_target *ti,
				iterate_devices_callout_fn fn, void *data)
{
	struct pool_c *pt = ti->private;

	return fn(ti, pt->data_dev, 0, ti->len, data);
}

static void pool_io_hints(struct dm_target *ti, struct queue_limits *limits)
{
	struct pool_c *pt = ti->private;
	struct pool *pool = pt->pool;
4062 4063 4064
	sector_t io_opt_sectors = limits->io_opt >> SECTOR_SHIFT;

	/*
4065 4066 4067 4068 4069 4070 4071
	 * If max_sectors is smaller than pool->sectors_per_block adjust it
	 * to the highest possible power-of-2 factor of pool->sectors_per_block.
	 * This is especially beneficial when the pool's data device is a RAID
	 * device that has a full stripe width that matches pool->sectors_per_block
	 * -- because even though partial RAID stripe-sized IOs will be issued to a
	 *    single RAID stripe; when aggregated they will end on a full RAID stripe
	 *    boundary.. which avoids additional partial RAID stripe writes cascading
4072 4073 4074 4075 4076 4077 4078 4079
	 */
	if (limits->max_sectors < pool->sectors_per_block) {
		while (!is_factor(pool->sectors_per_block, limits->max_sectors)) {
			if ((limits->max_sectors & (limits->max_sectors - 1)) == 0)
				limits->max_sectors--;
			limits->max_sectors = rounddown_pow_of_two(limits->max_sectors);
		}
	}
4080

4081 4082 4083 4084 4085
	/*
	 * If the system-determined stacked limits are compatible with the
	 * pool's blocksize (io_opt is a factor) do not override them.
	 */
	if (io_opt_sectors < pool->sectors_per_block ||
4086 4087 4088 4089 4090
	    !is_factor(io_opt_sectors, pool->sectors_per_block)) {
		if (is_factor(pool->sectors_per_block, limits->max_sectors))
			blk_limits_io_min(limits, limits->max_sectors << SECTOR_SHIFT);
		else
			blk_limits_io_min(limits, pool->sectors_per_block << SECTOR_SHIFT);
4091 4092
		blk_limits_io_opt(limits, pool->sectors_per_block << SECTOR_SHIFT);
	}
4093 4094 4095 4096 4097 4098

	/*
	 * pt->adjusted_pf is a staging area for the actual features to use.
	 * They get transferred to the live pool in bind_control_target()
	 * called from pool_preresume().
	 */
4099 4100

	if (pt->adjusted_pf.discard_enabled) {
4101 4102
		disable_discard_passdown_if_not_supported(pt);
		if (!pt->adjusted_pf.discard_passdown)
4103
			limits->max_hw_discard_sectors = 0;
4104 4105 4106 4107 4108
		/*
		 * The pool uses the same discard limits as the underlying data
		 * device.  DM core has already set this up.
		 */
	} else {
4109 4110 4111 4112 4113 4114
		/*
		 * Must explicitly disallow stacking discard limits otherwise the
		 * block layer will stack them if pool's data device has support.
		 */
		limits->discard_granularity = 0;
	}
4115 4116 4117 4118 4119 4120
}

static struct target_type pool_target = {
	.name = "thin-pool",
	.features = DM_TARGET_SINGLETON | DM_TARGET_ALWAYS_WRITEABLE |
		    DM_TARGET_IMMUTABLE,
4121
	.version = {1, 23, 0},
4122 4123 4124 4125
	.module = THIS_MODULE,
	.ctr = pool_ctr,
	.dtr = pool_dtr,
	.map = pool_map,
4126 4127
	.presuspend = pool_presuspend,
	.presuspend_undo = pool_presuspend_undo,
4128 4129 4130 4131 4132 4133 4134 4135 4136
	.postsuspend = pool_postsuspend,
	.preresume = pool_preresume,
	.resume = pool_resume,
	.message = pool_message,
	.status = pool_status,
	.iterate_devices = pool_iterate_devices,
	.io_hints = pool_io_hints,
};

4137 4138
/*
 *--------------------------------------------------------------
4139
 * Thin target methods
4140 4141
 *--------------------------------------------------------------
 */
4142 4143
static void thin_get(struct thin_c *tc)
{
4144
	refcount_inc(&tc->refcount);
4145 4146 4147 4148
}

static void thin_put(struct thin_c *tc)
{
4149
	if (refcount_dec_and_test(&tc->refcount))
4150 4151 4152
		complete(&tc->can_destroy);
}

4153 4154 4155
static void thin_dtr(struct dm_target *ti)
{
	struct thin_c *tc = ti->private;
4156

4157
	spin_lock_irq(&tc->pool->lock);
4158
	list_del_rcu(&tc->list);
4159
	spin_unlock_irq(&tc->pool->lock);
4160
	synchronize_rcu();
4161

4162 4163 4164
	thin_put(tc);
	wait_for_completion(&tc->can_destroy);

4165 4166 4167 4168 4169
	mutex_lock(&dm_thin_pool_table.mutex);

	__pool_dec(tc->pool);
	dm_pool_close_thin_device(tc->td);
	dm_put_device(ti, tc->pool_dev);
4170 4171
	if (tc->origin_dev)
		dm_put_device(ti, tc->origin_dev);
4172 4173 4174 4175 4176 4177 4178 4179
	kfree(tc);

	mutex_unlock(&dm_thin_pool_table.mutex);
}

/*
 * Thin target parameters:
 *
4180
 * <pool_dev> <dev_id> [origin_dev]
4181 4182 4183
 *
 * pool_dev: the path to the pool (eg, /dev/mapper/my_pool)
 * dev_id: the internal device identifier
4184
 * origin_dev: a device external to the pool that should act as the origin
4185 4186 4187
 *
 * If the pool device has discards disabled, they get disabled for the thin
 * device as well.
4188
 */
4189
static int thin_ctr(struct dm_target *ti, unsigned int argc, char **argv)
4190 4191 4192
{
	int r;
	struct thin_c *tc;
4193
	struct dm_dev *pool_dev, *origin_dev;
4194 4195 4196 4197
	struct mapped_device *pool_md;

	mutex_lock(&dm_thin_pool_table.mutex);

4198
	if (argc != 2 && argc != 3) {
4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209
		ti->error = "Invalid argument count";
		r = -EINVAL;
		goto out_unlock;
	}

	tc = ti->private = kzalloc(sizeof(*tc), GFP_KERNEL);
	if (!tc) {
		ti->error = "Out of memory";
		r = -ENOMEM;
		goto out_unlock;
	}
4210
	tc->thin_md = dm_table_get_md(ti->table);
4211
	spin_lock_init(&tc->lock);
4212
	INIT_LIST_HEAD(&tc->deferred_cells);
4213 4214
	bio_list_init(&tc->deferred_bio_list);
	bio_list_init(&tc->retry_on_resume_list);
4215
	tc->sort_bio_list = RB_ROOT;
4216

4217
	if (argc == 3) {
4218 4219 4220 4221 4222 4223
		if (!strcmp(argv[0], argv[2])) {
			ti->error = "Error setting origin device";
			r = -EINVAL;
			goto bad_origin_dev;
		}

4224
		r = dm_get_device(ti, argv[2], BLK_OPEN_READ, &origin_dev);
4225 4226 4227 4228 4229 4230 4231
		if (r) {
			ti->error = "Error opening origin device";
			goto bad_origin_dev;
		}
		tc->origin_dev = origin_dev;
	}

4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259
	r = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &pool_dev);
	if (r) {
		ti->error = "Error opening pool device";
		goto bad_pool_dev;
	}
	tc->pool_dev = pool_dev;

	if (read_dev_id(argv[1], (unsigned long long *)&tc->dev_id, 0)) {
		ti->error = "Invalid device id";
		r = -EINVAL;
		goto bad_common;
	}

	pool_md = dm_get_md(tc->pool_dev->bdev->bd_dev);
	if (!pool_md) {
		ti->error = "Couldn't get pool mapped device";
		r = -EINVAL;
		goto bad_common;
	}

	tc->pool = __pool_table_lookup(pool_md);
	if (!tc->pool) {
		ti->error = "Couldn't find pool object";
		r = -EINVAL;
		goto bad_pool_lookup;
	}
	__pool_inc(tc->pool);

4260 4261
	if (get_pool_mode(tc->pool) == PM_FAIL) {
		ti->error = "Couldn't open thin device, Pool is in fail mode";
4262
		r = -EINVAL;
4263
		goto bad_pool;
4264 4265
	}

4266 4267 4268
	r = dm_pool_open_thin_device(tc->pool->pmd, tc->dev_id, &tc->td);
	if (r) {
		ti->error = "Couldn't open thin internal device";
4269
		goto bad_pool;
4270 4271
	}

4272 4273
	r = dm_set_target_max_io_len(ti, tc->pool->sectors_per_block);
	if (r)
4274
		goto bad;
4275

4276
	ti->num_flush_bios = 1;
4277
	ti->limit_swap_bios = true;
Joe Thornber's avatar
Joe Thornber committed
4278
	ti->flush_supported = true;
4279
	ti->accounts_remapped_io = true;
4280
	ti->per_io_data_size = sizeof(struct dm_thin_endio_hook);
4281 4282 4283

	/* In case the pool supports discards, pass them on. */
	if (tc->pool->pf.discard_enabled) {
4284
		ti->discards_supported = true;
4285
		ti->num_discard_bios = 1;
4286
		ti->max_discard_granularity = true;
4287
	}
4288 4289 4290

	mutex_unlock(&dm_thin_pool_table.mutex);

4291
	spin_lock_irq(&tc->pool->lock);
4292
	if (tc->pool->suspended) {
4293
		spin_unlock_irq(&tc->pool->lock);
4294 4295 4296 4297 4298
		mutex_lock(&dm_thin_pool_table.mutex); /* reacquire for __pool_dec */
		ti->error = "Unable to activate thin device while pool is suspended";
		r = -EINVAL;
		goto bad;
	}
4299
	refcount_set(&tc->refcount, 1);
4300
	init_completion(&tc->can_destroy);
4301
	list_add_tail_rcu(&tc->list, &tc->pool->active_thins);
4302
	spin_unlock_irq(&tc->pool->lock);
4303 4304 4305 4306 4307 4308 4309 4310
	/*
	 * This synchronize_rcu() call is needed here otherwise we risk a
	 * wake_worker() call finding no bios to process (because the newly
	 * added tc isn't yet visible).  So this reduces latency since we
	 * aren't then dependent on the periodic commit to wake_worker().
	 */
	synchronize_rcu();

4311 4312
	dm_put(pool_md);

4313 4314
	return 0;

4315
bad:
4316
	dm_pool_close_thin_device(tc->td);
4317
bad_pool:
4318 4319 4320 4321 4322 4323
	__pool_dec(tc->pool);
bad_pool_lookup:
	dm_put(pool_md);
bad_common:
	dm_put_device(ti, tc->pool_dev);
bad_pool_dev:
4324 4325 4326
	if (tc->origin_dev)
		dm_put_device(ti, tc->origin_dev);
bad_origin_dev:
4327 4328 4329 4330 4331 4332 4333
	kfree(tc);
out_unlock:
	mutex_unlock(&dm_thin_pool_table.mutex);

	return r;
}

Mikulas Patocka's avatar
Mikulas Patocka committed
4334
static int thin_map(struct dm_target *ti, struct bio *bio)
4335
{
4336
	bio->bi_iter.bi_sector = dm_target_offset(ti, bio->bi_iter.bi_sector);
4337

Mikulas Patocka's avatar
Mikulas Patocka committed
4338
	return thin_bio_map(ti, bio);
4339 4340
}

4341 4342
static int thin_endio(struct dm_target *ti, struct bio *bio,
		blk_status_t *err)
4343 4344
{
	unsigned long flags;
4345
	struct dm_thin_endio_hook *h = dm_per_bio_data(bio, sizeof(struct dm_thin_endio_hook));
4346
	struct list_head work;
Mike Snitzer's avatar
Mike Snitzer committed
4347
	struct dm_thin_new_mapping *m, *tmp;
4348 4349 4350 4351
	struct pool *pool = h->tc->pool;

	if (h->shared_read_entry) {
		INIT_LIST_HEAD(&work);
4352
		dm_deferred_entry_dec(h->shared_read_entry, &work);
4353 4354 4355 4356

		spin_lock_irqsave(&pool->lock, flags);
		list_for_each_entry_safe(m, tmp, &work, list) {
			list_del(&m->list);
4357
			__complete_mapping_preparation(m);
4358 4359 4360 4361
		}
		spin_unlock_irqrestore(&pool->lock, flags);
	}

Joe Thornber's avatar
Joe Thornber committed
4362 4363
	if (h->all_io_entry) {
		INIT_LIST_HEAD(&work);
4364
		dm_deferred_entry_dec(h->all_io_entry, &work);
4365 4366 4367
		if (!list_empty(&work)) {
			spin_lock_irqsave(&pool->lock, flags);
			list_for_each_entry_safe(m, tmp, &work, list)
4368
				list_add_tail(&m->list, &pool->prepared_discards);
4369 4370 4371
			spin_unlock_irqrestore(&pool->lock, flags);
			wake_worker(pool);
		}
Joe Thornber's avatar
Joe Thornber committed
4372 4373
	}

4374 4375 4376
	if (h->cell)
		cell_defer_no_holder(h->tc, h->cell);

4377
	return DM_ENDIO_DONE;
4378 4379
}

4380
static void thin_presuspend(struct dm_target *ti)
4381
{
4382 4383
	struct thin_c *tc = ti->private;

4384
	if (dm_noflush_suspending(ti))
4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396
		noflush_work(tc, do_noflush_start);
}

static void thin_postsuspend(struct dm_target *ti)
{
	struct thin_c *tc = ti->private;

	/*
	 * The dm_noflush_suspending flag has been cleared by now, so
	 * unfortunately we must always run this.
	 */
	noflush_work(tc, do_noflush_stop);
4397 4398
}

4399 4400 4401 4402 4403 4404 4405 4406 4407 4408
static int thin_preresume(struct dm_target *ti)
{
	struct thin_c *tc = ti->private;

	if (tc->origin_dev)
		tc->origin_size = get_dev_size(tc->origin_dev->bdev);

	return 0;
}

4409 4410 4411
/*
 * <nr mapped sectors> <highest mapped sector>
 */
4412
static void thin_status(struct dm_target *ti, status_type_t type,
4413
			unsigned int status_flags, char *result, unsigned int maxlen)
4414 4415 4416 4417 4418 4419 4420
{
	int r;
	ssize_t sz = 0;
	dm_block_t mapped, highest;
	char buf[BDEVNAME_SIZE];
	struct thin_c *tc = ti->private;

4421 4422
	if (get_pool_mode(tc->pool) == PM_FAIL) {
		DMEMIT("Fail");
4423
		return;
4424 4425
	}

4426 4427 4428 4429 4430 4431
	if (!tc->td)
		DMEMIT("-");
	else {
		switch (type) {
		case STATUSTYPE_INFO:
			r = dm_thin_get_mapped_count(tc->td, &mapped);
4432 4433 4434 4435
			if (r) {
				DMERR("dm_thin_get_mapped_count returned %d", r);
				goto err;
			}
4436 4437

			r = dm_thin_get_highest_mapped_block(tc->td, &highest);
4438 4439 4440 4441
			if (r < 0) {
				DMERR("dm_thin_get_highest_mapped_block returned %d", r);
				goto err;
			}
4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454

			DMEMIT("%llu ", mapped * tc->pool->sectors_per_block);
			if (r)
				DMEMIT("%llu", ((highest + 1) *
						tc->pool->sectors_per_block) - 1);
			else
				DMEMIT("-");
			break;

		case STATUSTYPE_TABLE:
			DMEMIT("%s %lu",
			       format_dev_t(buf, tc->pool_dev->bdev->bd_dev),
			       (unsigned long) tc->dev_id);
4455 4456
			if (tc->origin_dev)
				DMEMIT(" %s", format_dev_t(buf, tc->origin_dev->bdev->bd_dev));
4457
			break;
4458 4459 4460 4461

		case STATUSTYPE_IMA:
			*result = '\0';
			break;
4462 4463 4464
		}
	}

4465 4466 4467 4468
	return;

err:
	DMEMIT("Error");
4469 4470 4471 4472 4473
}

static int thin_iterate_devices(struct dm_target *ti,
				iterate_devices_callout_fn fn, void *data)
{
4474
	sector_t blocks;
4475
	struct thin_c *tc = ti->private;
4476
	struct pool *pool = tc->pool;
4477 4478 4479 4480 4481

	/*
	 * We can't call dm_pool_get_data_dev_size() since that blocks.  So
	 * we follow a more convoluted path through to the pool's target.
	 */
4482
	if (!pool->ti)
4483 4484
		return 0;	/* nothing is bound */

4485 4486
	blocks = pool->ti->len;
	(void) sector_div(blocks, pool->sectors_per_block);
4487
	if (blocks)
4488
		return fn(ti, tc->pool_dev, 0, pool->sectors_per_block * blocks, data);
4489 4490 4491 4492

	return 0;
}

4493 4494 4495 4496
static void thin_io_hints(struct dm_target *ti, struct queue_limits *limits)
{
	struct thin_c *tc = ti->private;
	struct pool *pool = tc->pool;
4497

4498 4499
	if (pool->pf.discard_enabled) {
		limits->discard_granularity = pool->sectors_per_block << SECTOR_SHIFT;
4500
		limits->max_hw_discard_sectors = pool->sectors_per_block * BIO_PRISON_MAX_RANGE;
4501
	}
4502 4503
}

4504 4505
static struct target_type thin_target = {
	.name = "thin",
4506
	.version = {1, 23, 0},
4507 4508 4509 4510
	.module	= THIS_MODULE,
	.ctr = thin_ctr,
	.dtr = thin_dtr,
	.map = thin_map,
4511
	.end_io = thin_endio,
4512
	.preresume = thin_preresume,
4513
	.presuspend = thin_presuspend,
4514 4515 4516
	.postsuspend = thin_postsuspend,
	.status = thin_status,
	.iterate_devices = thin_iterate_devices,
4517
	.io_hints = thin_io_hints,
4518 4519 4520 4521 4522 4523
};

/*----------------------------------------------------------------*/

static int __init dm_thin_init(void)
{
4524
	int r = -ENOMEM;
4525 4526 4527

	pool_table_init();

4528 4529 4530 4531
	_new_mapping_cache = KMEM_CACHE(dm_thin_new_mapping, 0);
	if (!_new_mapping_cache)
		return r;

4532 4533
	r = dm_register_target(&thin_target);
	if (r)
4534
		goto bad_new_mapping_cache;
4535 4536 4537

	r = dm_register_target(&pool_target);
	if (r)
4538
		goto bad_thin_target;
Mike Snitzer's avatar
Mike Snitzer committed
4539 4540 4541

	return 0;

4542
bad_thin_target:
Mike Snitzer's avatar
Mike Snitzer committed
4543
	dm_unregister_target(&thin_target);
4544 4545
bad_new_mapping_cache:
	kmem_cache_destroy(_new_mapping_cache);
4546 4547 4548 4549 4550 4551 4552 4553

	return r;
}

static void dm_thin_exit(void)
{
	dm_unregister_target(&thin_target);
	dm_unregister_target(&pool_target);
Mike Snitzer's avatar
Mike Snitzer committed
4554 4555

	kmem_cache_destroy(_new_mapping_cache);
4556 4557

	pool_table_exit();
4558 4559 4560 4561 4562
}

module_init(dm_thin_init);
module_exit(dm_thin_exit);

4563
module_param_named(no_space_timeout, no_space_timeout_secs, uint, 0644);
4564 4565
MODULE_PARM_DESC(no_space_timeout, "Out of data space queue IO timeout in seconds");

4566
MODULE_DESCRIPTION(DM_NAME " thin provisioning target");
4567
MODULE_AUTHOR("Joe Thornber <dm-devel@lists.linux.dev>");
4568
MODULE_LICENSE("GPL");