volumes.c 163.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/*
 * Copyright (C) 2007 Oracle.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License v2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 021110-1307, USA.
 */
#include <linux/sched.h>
#include <linux/bio.h>
20
#include <linux/slab.h>
21
#include <linux/buffer_head.h>
22
#include <linux/blkdev.h>
23
#include <linux/random.h>
24
#include <linux/iocontext.h>
25
#include <linux/capability.h>
26
#include <linux/ratelimit.h>
27
#include <linux/kthread.h>
D
David Woodhouse 已提交
28
#include <linux/raid/pq.h>
29
#include <linux/semaphore.h>
D
David Woodhouse 已提交
30
#include <asm/div64.h>
31 32 33 34 35 36
#include "ctree.h"
#include "extent_map.h"
#include "disk-io.h"
#include "transaction.h"
#include "print-tree.h"
#include "volumes.h"
D
David Woodhouse 已提交
37
#include "raid56.h"
38
#include "async-thread.h"
39
#include "check-integrity.h"
40
#include "rcu-string.h"
41
#include "math.h"
42
#include "dev-replace.h"
43
#include "sysfs.h"
44

Y
Yan Zheng 已提交
45 46 47 48
static int init_first_rw_device(struct btrfs_trans_handle *trans,
				struct btrfs_root *root,
				struct btrfs_device *device);
static int btrfs_relocate_sys_chunks(struct btrfs_root *root);
49
static void __btrfs_reset_dev_stats(struct btrfs_device *dev);
50
static void btrfs_dev_stat_print_on_error(struct btrfs_device *dev);
51
static void btrfs_dev_stat_print_on_load(struct btrfs_device *device);
Y
Yan Zheng 已提交
52

53 54 55
static DEFINE_MUTEX(uuid_mutex);
static LIST_HEAD(fs_uuids);

56 57 58 59 60 61 62 63 64 65
static void lock_chunks(struct btrfs_root *root)
{
	mutex_lock(&root->fs_info->chunk_mutex);
}

static void unlock_chunks(struct btrfs_root *root)
{
	mutex_unlock(&root->fs_info->chunk_mutex);
}

66 67 68 69 70 71 72 73 74 75 76 77 78 79 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
static struct btrfs_fs_devices *__alloc_fs_devices(void)
{
	struct btrfs_fs_devices *fs_devs;

	fs_devs = kzalloc(sizeof(*fs_devs), GFP_NOFS);
	if (!fs_devs)
		return ERR_PTR(-ENOMEM);

	mutex_init(&fs_devs->device_list_mutex);

	INIT_LIST_HEAD(&fs_devs->devices);
	INIT_LIST_HEAD(&fs_devs->alloc_list);
	INIT_LIST_HEAD(&fs_devs->list);

	return fs_devs;
}

/**
 * alloc_fs_devices - allocate struct btrfs_fs_devices
 * @fsid:	a pointer to UUID for this FS.  If NULL a new UUID is
 *		generated.
 *
 * Return: a pointer to a new &struct btrfs_fs_devices on success;
 * ERR_PTR() on error.  Returned struct is not linked onto any lists and
 * can be destroyed with kfree() right away.
 */
static struct btrfs_fs_devices *alloc_fs_devices(const u8 *fsid)
{
	struct btrfs_fs_devices *fs_devs;

	fs_devs = __alloc_fs_devices();
	if (IS_ERR(fs_devs))
		return fs_devs;

	if (fsid)
		memcpy(fs_devs->fsid, fsid, BTRFS_FSID_SIZE);
	else
		generate_random_uuid(fs_devs->fsid);

	return fs_devs;
}

Y
Yan Zheng 已提交
108 109 110 111 112 113 114 115
static void free_fs_devices(struct btrfs_fs_devices *fs_devices)
{
	struct btrfs_device *device;
	WARN_ON(fs_devices->opened);
	while (!list_empty(&fs_devices->devices)) {
		device = list_entry(fs_devices->devices.next,
				    struct btrfs_device, dev_list);
		list_del(&device->dev_list);
116
		rcu_string_free(device->name);
Y
Yan Zheng 已提交
117 118 119 120 121
		kfree(device);
	}
	kfree(fs_devices);
}

122 123 124 125 126 127 128
static void btrfs_kobject_uevent(struct block_device *bdev,
				 enum kobject_action action)
{
	int ret;

	ret = kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, action);
	if (ret)
129
		pr_warn("BTRFS: Sending event '%d' to kobject: '%s' (%p): failed\n",
130 131 132 133 134
			action,
			kobject_name(&disk_to_dev(bdev->bd_disk)->kobj),
			&disk_to_dev(bdev->bd_disk)->kobj);
}

135
void btrfs_cleanup_fs_uuids(void)
136 137 138
{
	struct btrfs_fs_devices *fs_devices;

Y
Yan Zheng 已提交
139 140 141 142
	while (!list_empty(&fs_uuids)) {
		fs_devices = list_entry(fs_uuids.next,
					struct btrfs_fs_devices, list);
		list_del(&fs_devices->list);
Y
Yan Zheng 已提交
143
		free_fs_devices(fs_devices);
144 145 146
	}
}

147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167
static struct btrfs_device *__alloc_device(void)
{
	struct btrfs_device *dev;

	dev = kzalloc(sizeof(*dev), GFP_NOFS);
	if (!dev)
		return ERR_PTR(-ENOMEM);

	INIT_LIST_HEAD(&dev->dev_list);
	INIT_LIST_HEAD(&dev->dev_alloc_list);

	spin_lock_init(&dev->io_lock);

	spin_lock_init(&dev->reada_lock);
	atomic_set(&dev->reada_in_flight, 0);
	INIT_RADIX_TREE(&dev->reada_zones, GFP_NOFS & ~__GFP_WAIT);
	INIT_RADIX_TREE(&dev->reada_extents, GFP_NOFS & ~__GFP_WAIT);

	return dev;
}

168 169
static noinline struct btrfs_device *__find_device(struct list_head *head,
						   u64 devid, u8 *uuid)
170 171 172
{
	struct btrfs_device *dev;

173
	list_for_each_entry(dev, head, dev_list) {
174
		if (dev->devid == devid &&
175
		    (!uuid || !memcmp(dev->uuid, uuid, BTRFS_UUID_SIZE))) {
176
			return dev;
177
		}
178 179 180 181
	}
	return NULL;
}

182
static noinline struct btrfs_fs_devices *find_fsid(u8 *fsid)
183 184 185
{
	struct btrfs_fs_devices *fs_devices;

186
	list_for_each_entry(fs_devices, &fs_uuids, list) {
187 188 189 190 191 192
		if (memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE) == 0)
			return fs_devices;
	}
	return NULL;
}

193 194 195 196 197 198 199 200 201 202 203
static int
btrfs_get_bdev_and_sb(const char *device_path, fmode_t flags, void *holder,
		      int flush, struct block_device **bdev,
		      struct buffer_head **bh)
{
	int ret;

	*bdev = blkdev_get_by_path(device_path, flags, holder);

	if (IS_ERR(*bdev)) {
		ret = PTR_ERR(*bdev);
204
		printk(KERN_INFO "BTRFS: open %s failed\n", device_path);
205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230
		goto error;
	}

	if (flush)
		filemap_write_and_wait((*bdev)->bd_inode->i_mapping);
	ret = set_blocksize(*bdev, 4096);
	if (ret) {
		blkdev_put(*bdev, flags);
		goto error;
	}
	invalidate_bdev(*bdev);
	*bh = btrfs_read_dev_super(*bdev);
	if (!*bh) {
		ret = -EINVAL;
		blkdev_put(*bdev, flags);
		goto error;
	}

	return 0;

error:
	*bdev = NULL;
	*bh = NULL;
	return ret;
}

231 232 233 234 235 236 237 238 239 240 241 242 243 244
static void requeue_list(struct btrfs_pending_bios *pending_bios,
			struct bio *head, struct bio *tail)
{

	struct bio *old_head;

	old_head = pending_bios->head;
	pending_bios->head = head;
	if (pending_bios->tail)
		tail->bi_next = old_head;
	else
		pending_bios->tail = tail;
}

245 246 247 248 249 250 251 252 253 254 255
/*
 * we try to collect pending bios for a device so we don't get a large
 * number of procs sending bios down to the same device.  This greatly
 * improves the schedulers ability to collect and merge the bios.
 *
 * But, it also turns into a long list of bios to process and that is sure
 * to eventually make the worker thread block.  The solution here is to
 * make some progress and then put this work struct back at the end of
 * the list if the block device is congested.  This way, multiple devices
 * can make progress from a single worker thread.
 */
256
static noinline void run_scheduled_bios(struct btrfs_device *device)
257 258 259
{
	struct bio *pending;
	struct backing_dev_info *bdi;
260
	struct btrfs_fs_info *fs_info;
261
	struct btrfs_pending_bios *pending_bios;
262 263 264
	struct bio *tail;
	struct bio *cur;
	int again = 0;
265
	unsigned long num_run;
266
	unsigned long batch_run = 0;
267
	unsigned long limit;
268
	unsigned long last_waited = 0;
269
	int force_reg = 0;
270
	int sync_pending = 0;
271 272 273 274 275 276 277 278 279
	struct blk_plug plug;

	/*
	 * this function runs all the bios we've collected for
	 * a particular device.  We don't want to wander off to
	 * another device without first sending all of these down.
	 * So, setup a plug here and finish it off before we return
	 */
	blk_start_plug(&plug);
280

281
	bdi = blk_get_backing_dev_info(device->bdev);
282 283 284 285
	fs_info = device->dev_root->fs_info;
	limit = btrfs_async_submit_limit(fs_info);
	limit = limit * 2 / 3;

286 287 288
loop:
	spin_lock(&device->io_lock);

289
loop_lock:
290
	num_run = 0;
291

292 293 294 295 296
	/* take all the bios off the list at once and process them
	 * later on (without the lock held).  But, remember the
	 * tail and other pointers so the bios can be properly reinserted
	 * into the list if we hit congestion
	 */
297
	if (!force_reg && device->pending_sync_bios.head) {
298
		pending_bios = &device->pending_sync_bios;
299 300
		force_reg = 1;
	} else {
301
		pending_bios = &device->pending_bios;
302 303
		force_reg = 0;
	}
304 305 306

	pending = pending_bios->head;
	tail = pending_bios->tail;
307 308 309 310 311 312 313 314 315 316
	WARN_ON(pending && !tail);

	/*
	 * if pending was null this time around, no bios need processing
	 * at all and we can stop.  Otherwise it'll loop back up again
	 * and do an additional check so no bios are missed.
	 *
	 * device->running_pending is used to synchronize with the
	 * schedule_bio code.
	 */
317 318
	if (device->pending_sync_bios.head == NULL &&
	    device->pending_bios.head == NULL) {
319 320
		again = 0;
		device->running_pending = 0;
321 322 323
	} else {
		again = 1;
		device->running_pending = 1;
324
	}
325 326 327 328

	pending_bios->head = NULL;
	pending_bios->tail = NULL;

329 330
	spin_unlock(&device->io_lock);

331
	while (pending) {
332 333

		rmb();
334 335 336 337 338 339 340 341
		/* we want to work on both lists, but do more bios on the
		 * sync list than the regular list
		 */
		if ((num_run > 32 &&
		    pending_bios != &device->pending_sync_bios &&
		    device->pending_sync_bios.head) ||
		   (num_run > 64 && pending_bios == &device->pending_sync_bios &&
		    device->pending_bios.head)) {
342 343 344 345 346
			spin_lock(&device->io_lock);
			requeue_list(pending_bios, pending, tail);
			goto loop_lock;
		}

347 348 349
		cur = pending;
		pending = pending->bi_next;
		cur->bi_next = NULL;
350

351
		if (atomic_dec_return(&fs_info->nr_async_bios) < limit &&
352 353
		    waitqueue_active(&fs_info->async_submit_wait))
			wake_up(&fs_info->async_submit_wait);
354 355

		BUG_ON(atomic_read(&cur->bi_cnt) == 0);
356

357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372
		/*
		 * if we're doing the sync list, record that our
		 * plug has some sync requests on it
		 *
		 * If we're doing the regular list and there are
		 * sync requests sitting around, unplug before
		 * we add more
		 */
		if (pending_bios == &device->pending_sync_bios) {
			sync_pending = 1;
		} else if (sync_pending) {
			blk_finish_plug(&plug);
			blk_start_plug(&plug);
			sync_pending = 0;
		}

373
		btrfsic_submit_bio(cur->bi_rw, cur);
374 375
		num_run++;
		batch_run++;
376
		if (need_resched())
377
			cond_resched();
378 379 380 381 382 383

		/*
		 * we made progress, there is more work to do and the bdi
		 * is now congested.  Back off and let other work structs
		 * run instead
		 */
384
		if (pending && bdi_write_congested(bdi) && batch_run > 8 &&
385
		    fs_info->fs_devices->open_devices > 1) {
386
			struct io_context *ioc;
387

388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409
			ioc = current->io_context;

			/*
			 * the main goal here is that we don't want to
			 * block if we're going to be able to submit
			 * more requests without blocking.
			 *
			 * This code does two great things, it pokes into
			 * the elevator code from a filesystem _and_
			 * it makes assumptions about how batching works.
			 */
			if (ioc && ioc->nr_batch_requests > 0 &&
			    time_before(jiffies, ioc->last_waited + HZ/50UL) &&
			    (last_waited == 0 ||
			     ioc->last_waited == last_waited)) {
				/*
				 * we want to go through our batch of
				 * requests and stop.  So, we copy out
				 * the ioc->last_waited time and test
				 * against it before looping
				 */
				last_waited = ioc->last_waited;
410
				if (need_resched())
411
					cond_resched();
412 413
				continue;
			}
414
			spin_lock(&device->io_lock);
415
			requeue_list(pending_bios, pending, tail);
416
			device->running_pending = 1;
417 418

			spin_unlock(&device->io_lock);
419 420
			btrfs_queue_work(fs_info->submit_workers,
					 &device->work);
421 422
			goto done;
		}
423 424 425 426 427 428
		/* unplug every 64 requests just for good measure */
		if (batch_run % 64 == 0) {
			blk_finish_plug(&plug);
			blk_start_plug(&plug);
			sync_pending = 0;
		}
429
	}
430

431 432 433 434 435 436 437 438 439
	cond_resched();
	if (again)
		goto loop;

	spin_lock(&device->io_lock);
	if (device->pending_bios.head || device->pending_sync_bios.head)
		goto loop_lock;
	spin_unlock(&device->io_lock);

440
done:
441
	blk_finish_plug(&plug);
442 443
}

444
static void pending_bios_fn(struct btrfs_work *work)
445 446 447 448 449 450 451
{
	struct btrfs_device *device;

	device = container_of(work, struct btrfs_device, work);
	run_scheduled_bios(device);
}

452 453 454 455 456 457 458 459
/*
 * Add new device to list of registered devices
 *
 * Returns:
 * 1   - first time device is seen
 * 0   - device already known
 * < 0 - error
 */
460
static noinline int device_list_add(const char *path,
461 462 463 464 465
			   struct btrfs_super_block *disk_super,
			   u64 devid, struct btrfs_fs_devices **fs_devices_ret)
{
	struct btrfs_device *device;
	struct btrfs_fs_devices *fs_devices;
466
	struct rcu_string *name;
467
	int ret = 0;
468 469 470 471
	u64 found_transid = btrfs_super_generation(disk_super);

	fs_devices = find_fsid(disk_super->fsid);
	if (!fs_devices) {
472 473 474 475
		fs_devices = alloc_fs_devices(disk_super->fsid);
		if (IS_ERR(fs_devices))
			return PTR_ERR(fs_devices);

476 477 478
		list_add(&fs_devices->list, &fs_uuids);
		fs_devices->latest_devid = devid;
		fs_devices->latest_trans = found_transid;
479

480 481
		device = NULL;
	} else {
482 483
		device = __find_device(&fs_devices->devices, devid,
				       disk_super->dev_item.uuid);
484 485
	}
	if (!device) {
Y
Yan Zheng 已提交
486 487 488
		if (fs_devices->opened)
			return -EBUSY;

489 490 491
		device = btrfs_alloc_device(NULL, &devid,
					    disk_super->dev_item.uuid);
		if (IS_ERR(device)) {
492
			/* we can safely leave the fs_devices entry around */
493
			return PTR_ERR(device);
494
		}
495 496 497

		name = rcu_string_strdup(path, GFP_NOFS);
		if (!name) {
498 499 500
			kfree(device);
			return -ENOMEM;
		}
501
		rcu_assign_pointer(device->name, name);
502

503
		mutex_lock(&fs_devices->device_list_mutex);
504
		list_add_rcu(&device->dev_list, &fs_devices->devices);
505
		fs_devices->num_devices++;
506 507
		mutex_unlock(&fs_devices->device_list_mutex);

508
		ret = 1;
Y
Yan Zheng 已提交
509
		device->fs_devices = fs_devices;
510 511
	} else if (!device->name || strcmp(device->name->str, path)) {
		name = rcu_string_strdup(path, GFP_NOFS);
512 513
		if (!name)
			return -ENOMEM;
514 515
		rcu_string_free(device->name);
		rcu_assign_pointer(device->name, name);
516 517 518 519
		if (device->missing) {
			fs_devices->missing_devices--;
			device->missing = 0;
		}
520 521 522 523 524 525 526
	}

	if (found_transid > fs_devices->latest_trans) {
		fs_devices->latest_devid = devid;
		fs_devices->latest_trans = found_transid;
	}
	*fs_devices_ret = fs_devices;
527 528

	return ret;
529 530
}

Y
Yan Zheng 已提交
531 532 533 534 535 536
static struct btrfs_fs_devices *clone_fs_devices(struct btrfs_fs_devices *orig)
{
	struct btrfs_fs_devices *fs_devices;
	struct btrfs_device *device;
	struct btrfs_device *orig_dev;

537 538 539
	fs_devices = alloc_fs_devices(orig->fsid);
	if (IS_ERR(fs_devices))
		return fs_devices;
Y
Yan Zheng 已提交
540 541 542

	fs_devices->latest_devid = orig->latest_devid;
	fs_devices->latest_trans = orig->latest_trans;
543
	fs_devices->total_devices = orig->total_devices;
Y
Yan Zheng 已提交
544

545
	/* We have held the volume lock, it is safe to get the devices. */
Y
Yan Zheng 已提交
546
	list_for_each_entry(orig_dev, &orig->devices, dev_list) {
547 548
		struct rcu_string *name;

549 550 551
		device = btrfs_alloc_device(NULL, &orig_dev->devid,
					    orig_dev->uuid);
		if (IS_ERR(device))
Y
Yan Zheng 已提交
552 553
			goto error;

554 555 556 557 558 559
		/*
		 * This is ok to do without rcu read locked because we hold the
		 * uuid mutex so nothing we touch in here is going to disappear.
		 */
		name = rcu_string_strdup(orig_dev->name->str, GFP_NOFS);
		if (!name) {
560
			kfree(device);
Y
Yan Zheng 已提交
561
			goto error;
562
		}
563
		rcu_assign_pointer(device->name, name);
Y
Yan Zheng 已提交
564 565 566 567 568 569 570 571 572 573 574

		list_add(&device->dev_list, &fs_devices->devices);
		device->fs_devices = fs_devices;
		fs_devices->num_devices++;
	}
	return fs_devices;
error:
	free_fs_devices(fs_devices);
	return ERR_PTR(-ENOMEM);
}

575 576
void btrfs_close_extra_devices(struct btrfs_fs_info *fs_info,
			       struct btrfs_fs_devices *fs_devices, int step)
577
{
578
	struct btrfs_device *device, *next;
579

580 581 582 583
	struct block_device *latest_bdev = NULL;
	u64 latest_devid = 0;
	u64 latest_transid = 0;

584 585
	mutex_lock(&uuid_mutex);
again:
586
	/* This is the initialized path, it is safe to release the devices. */
587
	list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) {
588
		if (device->in_fs_metadata) {
589 590 591
			if (!device->is_tgtdev_for_dev_replace &&
			    (!latest_transid ||
			     device->generation > latest_transid)) {
592 593 594 595
				latest_devid = device->devid;
				latest_transid = device->generation;
				latest_bdev = device->bdev;
			}
Y
Yan Zheng 已提交
596
			continue;
597
		}
Y
Yan Zheng 已提交
598

599 600 601 602 603 604 605 606 607 608 609 610 611 612 613
		if (device->devid == BTRFS_DEV_REPLACE_DEVID) {
			/*
			 * In the first step, keep the device which has
			 * the correct fsid and the devid that is used
			 * for the dev_replace procedure.
			 * In the second step, the dev_replace state is
			 * read from the device tree and it is known
			 * whether the procedure is really active or
			 * not, which means whether this device is
			 * used or whether it should be removed.
			 */
			if (step == 0 || device->is_tgtdev_for_dev_replace) {
				continue;
			}
		}
Y
Yan Zheng 已提交
614
		if (device->bdev) {
615
			blkdev_put(device->bdev, device->mode);
Y
Yan Zheng 已提交
616 617 618 619 620 621
			device->bdev = NULL;
			fs_devices->open_devices--;
		}
		if (device->writeable) {
			list_del_init(&device->dev_alloc_list);
			device->writeable = 0;
622 623
			if (!device->is_tgtdev_for_dev_replace)
				fs_devices->rw_devices--;
Y
Yan Zheng 已提交
624
		}
Y
Yan Zheng 已提交
625 626
		list_del_init(&device->dev_list);
		fs_devices->num_devices--;
627
		rcu_string_free(device->name);
Y
Yan Zheng 已提交
628
		kfree(device);
629
	}
Y
Yan Zheng 已提交
630 631 632 633 634 635

	if (fs_devices->seed) {
		fs_devices = fs_devices->seed;
		goto again;
	}

636 637 638 639
	fs_devices->latest_bdev = latest_bdev;
	fs_devices->latest_devid = latest_devid;
	fs_devices->latest_trans = latest_transid;

640 641
	mutex_unlock(&uuid_mutex);
}
642

643 644 645 646 647 648 649 650 651
static void __free_device(struct work_struct *work)
{
	struct btrfs_device *device;

	device = container_of(work, struct btrfs_device, rcu_work);

	if (device->bdev)
		blkdev_put(device->bdev, device->mode);

652
	rcu_string_free(device->name);
653 654 655 656 657 658 659 660 661 662 663 664 665
	kfree(device);
}

static void free_device(struct rcu_head *head)
{
	struct btrfs_device *device;

	device = container_of(head, struct btrfs_device, rcu);

	INIT_WORK(&device->rcu_work, __free_device);
	schedule_work(&device->rcu_work);
}

Y
Yan Zheng 已提交
666
static int __btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
667 668
{
	struct btrfs_device *device;
Y
Yan Zheng 已提交
669

Y
Yan Zheng 已提交
670 671
	if (--fs_devices->opened > 0)
		return 0;
672

673
	mutex_lock(&fs_devices->device_list_mutex);
674
	list_for_each_entry(device, &fs_devices->devices, dev_list) {
675
		struct btrfs_device *new_device;
676
		struct rcu_string *name;
677 678

		if (device->bdev)
679
			fs_devices->open_devices--;
680

681 682
		if (device->writeable &&
		    device->devid != BTRFS_DEV_REPLACE_DEVID) {
Y
Yan Zheng 已提交
683 684 685 686
			list_del_init(&device->dev_alloc_list);
			fs_devices->rw_devices--;
		}

687 688
		if (device->can_discard)
			fs_devices->num_can_discard--;
689 690
		if (device->missing)
			fs_devices->missing_devices--;
691

692 693 694
		new_device = btrfs_alloc_device(NULL, &device->devid,
						device->uuid);
		BUG_ON(IS_ERR(new_device)); /* -ENOMEM */
695 696

		/* Safe because we are under uuid_mutex */
697 698
		if (device->name) {
			name = rcu_string_strdup(device->name->str, GFP_NOFS);
699
			BUG_ON(!name); /* -ENOMEM */
700 701
			rcu_assign_pointer(new_device->name, name);
		}
702

703
		list_replace_rcu(&device->dev_list, &new_device->dev_list);
704
		new_device->fs_devices = device->fs_devices;
705 706

		call_rcu(&device->rcu, free_device);
707
	}
708 709
	mutex_unlock(&fs_devices->device_list_mutex);

Y
Yan Zheng 已提交
710 711
	WARN_ON(fs_devices->open_devices);
	WARN_ON(fs_devices->rw_devices);
Y
Yan Zheng 已提交
712 713 714
	fs_devices->opened = 0;
	fs_devices->seeding = 0;

715 716 717
	return 0;
}

Y
Yan Zheng 已提交
718 719
int btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
{
Y
Yan Zheng 已提交
720
	struct btrfs_fs_devices *seed_devices = NULL;
Y
Yan Zheng 已提交
721 722 723 724
	int ret;

	mutex_lock(&uuid_mutex);
	ret = __btrfs_close_devices(fs_devices);
Y
Yan Zheng 已提交
725 726 727 728
	if (!fs_devices->opened) {
		seed_devices = fs_devices->seed;
		fs_devices->seed = NULL;
	}
Y
Yan Zheng 已提交
729
	mutex_unlock(&uuid_mutex);
Y
Yan Zheng 已提交
730 731 732 733 734 735 736

	while (seed_devices) {
		fs_devices = seed_devices;
		seed_devices = fs_devices->seed;
		__btrfs_close_devices(fs_devices);
		free_fs_devices(fs_devices);
	}
737 738 739 740 741 742
	/*
	 * Wait for rcu kworkers under __btrfs_close_devices
	 * to finish all blkdev_puts so device is really
	 * free when umount is done.
	 */
	rcu_barrier();
Y
Yan Zheng 已提交
743 744 745
	return ret;
}

Y
Yan Zheng 已提交
746 747
static int __btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
				fmode_t flags, void *holder)
748
{
749
	struct request_queue *q;
750 751 752
	struct block_device *bdev;
	struct list_head *head = &fs_devices->devices;
	struct btrfs_device *device;
753 754 755 756 757 758
	struct block_device *latest_bdev = NULL;
	struct buffer_head *bh;
	struct btrfs_super_block *disk_super;
	u64 latest_devid = 0;
	u64 latest_transid = 0;
	u64 devid;
Y
Yan Zheng 已提交
759
	int seeding = 1;
760
	int ret = 0;
761

762 763
	flags |= FMODE_EXCL;

764
	list_for_each_entry(device, head, dev_list) {
765 766
		if (device->bdev)
			continue;
767 768 769
		if (!device->name)
			continue;

770 771 772
		/* Just open everything we can; ignore failures here */
		if (btrfs_get_bdev_and_sb(device->name->str, flags, holder, 1,
					    &bdev, &bh))
773
			continue;
774 775

		disk_super = (struct btrfs_super_block *)bh->b_data;
776
		devid = btrfs_stack_device_id(&disk_super->dev_item);
777 778 779
		if (devid != device->devid)
			goto error_brelse;

Y
Yan Zheng 已提交
780 781 782 783 784 785
		if (memcmp(device->uuid, disk_super->dev_item.uuid,
			   BTRFS_UUID_SIZE))
			goto error_brelse;

		device->generation = btrfs_super_generation(disk_super);
		if (!latest_transid || device->generation > latest_transid) {
786
			latest_devid = devid;
Y
Yan Zheng 已提交
787
			latest_transid = device->generation;
788 789 790
			latest_bdev = bdev;
		}

Y
Yan Zheng 已提交
791 792 793 794 795 796 797
		if (btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_SEEDING) {
			device->writeable = 0;
		} else {
			device->writeable = !bdev_read_only(bdev);
			seeding = 0;
		}

798 799 800 801 802 803
		q = bdev_get_queue(bdev);
		if (blk_queue_discard(q)) {
			device->can_discard = 1;
			fs_devices->num_can_discard++;
		}

804
		device->bdev = bdev;
805
		device->in_fs_metadata = 0;
806 807
		device->mode = flags;

808 809 810
		if (!blk_queue_nonrot(bdev_get_queue(bdev)))
			fs_devices->rotating = 1;

811
		fs_devices->open_devices++;
812 813
		if (device->writeable &&
		    device->devid != BTRFS_DEV_REPLACE_DEVID) {
Y
Yan Zheng 已提交
814 815 816 817
			fs_devices->rw_devices++;
			list_add(&device->dev_alloc_list,
				 &fs_devices->alloc_list);
		}
818
		brelse(bh);
819
		continue;
820

821 822
error_brelse:
		brelse(bh);
823
		blkdev_put(bdev, flags);
824
		continue;
825
	}
826
	if (fs_devices->open_devices == 0) {
827
		ret = -EINVAL;
828 829
		goto out;
	}
Y
Yan Zheng 已提交
830 831
	fs_devices->seeding = seeding;
	fs_devices->opened = 1;
832 833 834
	fs_devices->latest_bdev = latest_bdev;
	fs_devices->latest_devid = latest_devid;
	fs_devices->latest_trans = latest_transid;
Y
Yan Zheng 已提交
835
	fs_devices->total_rw_bytes = 0;
836
out:
Y
Yan Zheng 已提交
837 838 839 840
	return ret;
}

int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
841
		       fmode_t flags, void *holder)
Y
Yan Zheng 已提交
842 843 844 845 846
{
	int ret;

	mutex_lock(&uuid_mutex);
	if (fs_devices->opened) {
Y
Yan Zheng 已提交
847 848
		fs_devices->opened++;
		ret = 0;
Y
Yan Zheng 已提交
849
	} else {
850
		ret = __btrfs_open_devices(fs_devices, flags, holder);
Y
Yan Zheng 已提交
851
	}
852 853 854 855
	mutex_unlock(&uuid_mutex);
	return ret;
}

856 857 858 859 860
/*
 * Look for a btrfs signature on a device. This may be called out of the mount path
 * and we are not allowed to call set_blocksize during the scan. The superblock
 * is read via pagecache
 */
861
int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
862 863 864 865
			  struct btrfs_fs_devices **fs_devices_ret)
{
	struct btrfs_super_block *disk_super;
	struct block_device *bdev;
866 867 868
	struct page *page;
	void *p;
	int ret = -EINVAL;
869
	u64 devid;
870
	u64 transid;
871
	u64 total_devices;
872 873
	u64 bytenr;
	pgoff_t index;
874

875 876 877 878 879 880 881
	/*
	 * we would like to check all the supers, but that would make
	 * a btrfs mount succeed after a mkfs from a different FS.
	 * So, we need to add a special mount option to scan for
	 * later supers, using BTRFS_SUPER_MIRROR_MAX instead
	 */
	bytenr = btrfs_sb_offset(0);
882
	flags |= FMODE_EXCL;
883
	mutex_lock(&uuid_mutex);
884 885 886 887 888

	bdev = blkdev_get_by_path(path, flags, holder);

	if (IS_ERR(bdev)) {
		ret = PTR_ERR(bdev);
889
		goto error;
890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917
	}

	/* make sure our super fits in the device */
	if (bytenr + PAGE_CACHE_SIZE >= i_size_read(bdev->bd_inode))
		goto error_bdev_put;

	/* make sure our super fits in the page */
	if (sizeof(*disk_super) > PAGE_CACHE_SIZE)
		goto error_bdev_put;

	/* make sure our super doesn't straddle pages on disk */
	index = bytenr >> PAGE_CACHE_SHIFT;
	if ((bytenr + sizeof(*disk_super) - 1) >> PAGE_CACHE_SHIFT != index)
		goto error_bdev_put;

	/* pull in the page with our super */
	page = read_cache_page_gfp(bdev->bd_inode->i_mapping,
				   index, GFP_NOFS);

	if (IS_ERR_OR_NULL(page))
		goto error_bdev_put;

	p = kmap(page);

	/* align our pointer to the offset of the super block */
	disk_super = p + (bytenr & ~PAGE_CACHE_MASK);

	if (btrfs_super_bytenr(disk_super) != bytenr ||
918
	    btrfs_super_magic(disk_super) != BTRFS_MAGIC)
919 920
		goto error_unmap;

921
	devid = btrfs_stack_device_id(&disk_super->dev_item);
922
	transid = btrfs_super_generation(disk_super);
923
	total_devices = btrfs_super_num_devices(disk_super);
924

925
	ret = device_list_add(path, disk_super, devid, fs_devices_ret);
926 927 928 929 930 931 932 933 934 935 936 937
	if (ret > 0) {
		if (disk_super->label[0]) {
			if (disk_super->label[BTRFS_LABEL_SIZE - 1])
				disk_super->label[BTRFS_LABEL_SIZE - 1] = '\0';
			printk(KERN_INFO "BTRFS: device label %s ", disk_super->label);
		} else {
			printk(KERN_INFO "BTRFS: device fsid %pU ", disk_super->fsid);
		}

		printk(KERN_CONT "devid %llu transid %llu %s\n", devid, transid, path);
		ret = 0;
	}
938 939
	if (!ret && fs_devices_ret)
		(*fs_devices_ret)->total_devices = total_devices;
940 941 942 943 944 945

error_unmap:
	kunmap(page);
	page_cache_release(page);

error_bdev_put:
946
	blkdev_put(bdev, flags);
947
error:
948
	mutex_unlock(&uuid_mutex);
949 950
	return ret;
}
951

952 953 954 955 956 957 958 959 960 961 962 963 964 965 966
/* helper to account the used device space in the range */
int btrfs_account_dev_extents_size(struct btrfs_device *device, u64 start,
				   u64 end, u64 *length)
{
	struct btrfs_key key;
	struct btrfs_root *root = device->dev_root;
	struct btrfs_dev_extent *dev_extent;
	struct btrfs_path *path;
	u64 extent_end;
	int ret;
	int slot;
	struct extent_buffer *l;

	*length = 0;

967
	if (start >= device->total_bytes || device->is_tgtdev_for_dev_replace)
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 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
		return 0;

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;
	path->reada = 2;

	key.objectid = device->devid;
	key.offset = start;
	key.type = BTRFS_DEV_EXTENT_KEY;

	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
	if (ret < 0)
		goto out;
	if (ret > 0) {
		ret = btrfs_previous_item(root, path, key.objectid, key.type);
		if (ret < 0)
			goto out;
	}

	while (1) {
		l = path->nodes[0];
		slot = path->slots[0];
		if (slot >= btrfs_header_nritems(l)) {
			ret = btrfs_next_leaf(root, path);
			if (ret == 0)
				continue;
			if (ret < 0)
				goto out;

			break;
		}
		btrfs_item_key_to_cpu(l, &key, slot);

		if (key.objectid < device->devid)
			goto next;

		if (key.objectid > device->devid)
			break;

		if (btrfs_key_type(&key) != BTRFS_DEV_EXTENT_KEY)
			goto next;

		dev_extent = btrfs_item_ptr(l, slot, struct btrfs_dev_extent);
		extent_end = key.offset + btrfs_dev_extent_length(l,
								  dev_extent);
		if (key.offset <= start && extent_end > end) {
			*length = end - start + 1;
			break;
		} else if (key.offset <= start && extent_end > start)
			*length += extent_end - start;
		else if (key.offset > start && extent_end <= end)
			*length += extent_end - key.offset;
		else if (key.offset > start && key.offset <= end) {
			*length += end - key.offset + 1;
			break;
		} else if (key.offset > end)
			break;

next:
		path->slots[0]++;
	}
	ret = 0;
out:
	btrfs_free_path(path);
	return ret;
}

1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
static int contains_pending_extent(struct btrfs_trans_handle *trans,
				   struct btrfs_device *device,
				   u64 *start, u64 len)
{
	struct extent_map *em;
	int ret = 0;

	list_for_each_entry(em, &trans->transaction->pending_chunks, list) {
		struct map_lookup *map;
		int i;

		map = (struct map_lookup *)em->bdev;
		for (i = 0; i < map->num_stripes; i++) {
			if (map->stripes[i].dev != device)
				continue;
			if (map->stripes[i].physical >= *start + len ||
			    map->stripes[i].physical + em->orig_block_len <=
			    *start)
				continue;
			*start = map->stripes[i].physical +
				em->orig_block_len;
			ret = 1;
		}
	}

	return ret;
}


1065
/*
1066 1067 1068 1069 1070 1071 1072
 * find_free_dev_extent - find free space in the specified device
 * @device:	the device which we search the free space in
 * @num_bytes:	the size of the free space that we need
 * @start:	store the start of the free space.
 * @len:	the size of the free space. that we find, or the size of the max
 * 		free space if we don't find suitable free space
 *
1073 1074 1075
 * this uses a pretty simple search, the expectation is that it is
 * called very infrequently and that a given device has a small number
 * of extents
1076 1077 1078 1079 1080 1081 1082 1083
 *
 * @start is used to store the start of the free space if we find. But if we
 * don't find suitable free space, it will be used to store the start position
 * of the max free space.
 *
 * @len is used to store the size of the free space that we find.
 * But if we don't find suitable free space, it is used to store the size of
 * the max free space.
1084
 */
1085 1086
int find_free_dev_extent(struct btrfs_trans_handle *trans,
			 struct btrfs_device *device, u64 num_bytes,
1087
			 u64 *start, u64 *len)
1088 1089 1090
{
	struct btrfs_key key;
	struct btrfs_root *root = device->dev_root;
1091
	struct btrfs_dev_extent *dev_extent;
Y
Yan Zheng 已提交
1092
	struct btrfs_path *path;
1093 1094 1095 1096 1097
	u64 hole_size;
	u64 max_hole_start;
	u64 max_hole_size;
	u64 extent_end;
	u64 search_start;
1098 1099
	u64 search_end = device->total_bytes;
	int ret;
1100
	int slot;
1101 1102 1103 1104
	struct extent_buffer *l;

	/* FIXME use last free of some kind */

1105 1106 1107
	/* we don't want to overwrite the superblock on the drive,
	 * so we make sure to start at an offset of at least 1MB
	 */
A
Arne Jansen 已提交
1108
	search_start = max(root->fs_info->alloc_start, 1024ull * 1024);
1109

1110 1111 1112 1113
	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;
again:
1114 1115
	max_hole_start = search_start;
	max_hole_size = 0;
1116
	hole_size = 0;
1117

1118
	if (search_start >= search_end || device->is_tgtdev_for_dev_replace) {
1119
		ret = -ENOSPC;
1120
		goto out;
1121 1122 1123
	}

	path->reada = 2;
1124 1125
	path->search_commit_root = 1;
	path->skip_locking = 1;
1126

1127 1128 1129
	key.objectid = device->devid;
	key.offset = search_start;
	key.type = BTRFS_DEV_EXTENT_KEY;
1130

1131
	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1132
	if (ret < 0)
1133
		goto out;
1134 1135 1136
	if (ret > 0) {
		ret = btrfs_previous_item(root, path, key.objectid, key.type);
		if (ret < 0)
1137
			goto out;
1138
	}
1139

1140 1141 1142 1143 1144 1145 1146 1147
	while (1) {
		l = path->nodes[0];
		slot = path->slots[0];
		if (slot >= btrfs_header_nritems(l)) {
			ret = btrfs_next_leaf(root, path);
			if (ret == 0)
				continue;
			if (ret < 0)
1148 1149 1150
				goto out;

			break;
1151 1152 1153 1154 1155 1156 1157
		}
		btrfs_item_key_to_cpu(l, &key, slot);

		if (key.objectid < device->devid)
			goto next;

		if (key.objectid > device->devid)
1158
			break;
1159

1160 1161
		if (btrfs_key_type(&key) != BTRFS_DEV_EXTENT_KEY)
			goto next;
1162

1163 1164
		if (key.offset > search_start) {
			hole_size = key.offset - search_start;
1165

1166 1167 1168 1169 1170 1171 1172 1173 1174
			/*
			 * Have to check before we set max_hole_start, otherwise
			 * we could end up sending back this offset anyway.
			 */
			if (contains_pending_extent(trans, device,
						    &search_start,
						    hole_size))
				hole_size = 0;

1175 1176 1177 1178
			if (hole_size > max_hole_size) {
				max_hole_start = search_start;
				max_hole_size = hole_size;
			}
1179

1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191
			/*
			 * If this free space is greater than which we need,
			 * it must be the max free space that we have found
			 * until now, so max_hole_start must point to the start
			 * of this free space and the length of this free space
			 * is stored in max_hole_size. Thus, we return
			 * max_hole_start and max_hole_size and go back to the
			 * caller.
			 */
			if (hole_size >= num_bytes) {
				ret = 0;
				goto out;
1192 1193 1194 1195
			}
		}

		dev_extent = btrfs_item_ptr(l, slot, struct btrfs_dev_extent);
1196 1197 1198 1199
		extent_end = key.offset + btrfs_dev_extent_length(l,
								  dev_extent);
		if (extent_end > search_start)
			search_start = extent_end;
1200 1201 1202 1203 1204
next:
		path->slots[0]++;
		cond_resched();
	}

1205 1206 1207 1208 1209 1210 1211 1212
	/*
	 * At this point, search_start should be the end of
	 * allocated dev extents, and when shrinking the device,
	 * search_end may be smaller than search_start.
	 */
	if (search_end > search_start)
		hole_size = search_end - search_start;

1213 1214 1215
	if (hole_size > max_hole_size) {
		max_hole_start = search_start;
		max_hole_size = hole_size;
1216 1217
	}

1218 1219 1220 1221 1222
	if (contains_pending_extent(trans, device, &search_start, hole_size)) {
		btrfs_release_path(path);
		goto again;
	}

1223 1224 1225 1226 1227 1228 1229
	/* See above. */
	if (hole_size < num_bytes)
		ret = -ENOSPC;
	else
		ret = 0;

out:
Y
Yan Zheng 已提交
1230
	btrfs_free_path(path);
1231
	*start = max_hole_start;
1232
	if (len)
1233
		*len = max_hole_size;
1234 1235 1236
	return ret;
}

1237
static int btrfs_free_dev_extent(struct btrfs_trans_handle *trans,
1238 1239 1240 1241 1242 1243 1244
			  struct btrfs_device *device,
			  u64 start)
{
	int ret;
	struct btrfs_path *path;
	struct btrfs_root *root = device->dev_root;
	struct btrfs_key key;
1245 1246 1247
	struct btrfs_key found_key;
	struct extent_buffer *leaf = NULL;
	struct btrfs_dev_extent *extent = NULL;
1248 1249 1250 1251 1252 1253 1254 1255

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

	key.objectid = device->devid;
	key.offset = start;
	key.type = BTRFS_DEV_EXTENT_KEY;
1256
again:
1257
	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1258 1259 1260
	if (ret > 0) {
		ret = btrfs_previous_item(root, path, key.objectid,
					  BTRFS_DEV_EXTENT_KEY);
1261 1262
		if (ret)
			goto out;
1263 1264 1265 1266 1267 1268
		leaf = path->nodes[0];
		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
		extent = btrfs_item_ptr(leaf, path->slots[0],
					struct btrfs_dev_extent);
		BUG_ON(found_key.offset > start || found_key.offset +
		       btrfs_dev_extent_length(leaf, extent) < start);
1269 1270 1271
		key = found_key;
		btrfs_release_path(path);
		goto again;
1272 1273 1274 1275
	} else if (ret == 0) {
		leaf = path->nodes[0];
		extent = btrfs_item_ptr(leaf, path->slots[0],
					struct btrfs_dev_extent);
1276 1277 1278
	} else {
		btrfs_error(root->fs_info, ret, "Slot search failed");
		goto out;
1279
	}
1280

1281 1282 1283 1284 1285 1286 1287
	if (device->bytes_used > 0) {
		u64 len = btrfs_dev_extent_length(leaf, extent);
		device->bytes_used -= len;
		spin_lock(&root->fs_info->free_chunk_lock);
		root->fs_info->free_chunk_space += len;
		spin_unlock(&root->fs_info->free_chunk_lock);
	}
1288
	ret = btrfs_del_item(trans, root, path);
1289 1290 1291 1292
	if (ret) {
		btrfs_error(root->fs_info, ret,
			    "Failed to remove dev extent item");
	}
1293
out:
1294 1295 1296 1297
	btrfs_free_path(path);
	return ret;
}

1298 1299 1300 1301
static int btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans,
				  struct btrfs_device *device,
				  u64 chunk_tree, u64 chunk_objectid,
				  u64 chunk_offset, u64 start, u64 num_bytes)
1302 1303 1304 1305 1306 1307 1308 1309
{
	int ret;
	struct btrfs_path *path;
	struct btrfs_root *root = device->dev_root;
	struct btrfs_dev_extent *extent;
	struct extent_buffer *leaf;
	struct btrfs_key key;

1310
	WARN_ON(!device->in_fs_metadata);
1311
	WARN_ON(device->is_tgtdev_for_dev_replace);
1312 1313 1314 1315 1316
	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

	key.objectid = device->devid;
Y
Yan Zheng 已提交
1317
	key.offset = start;
1318 1319 1320
	key.type = BTRFS_DEV_EXTENT_KEY;
	ret = btrfs_insert_empty_item(trans, root, path, &key,
				      sizeof(*extent));
1321 1322
	if (ret)
		goto out;
1323 1324 1325 1326

	leaf = path->nodes[0];
	extent = btrfs_item_ptr(leaf, path->slots[0],
				struct btrfs_dev_extent);
1327 1328 1329 1330 1331
	btrfs_set_dev_extent_chunk_tree(leaf, extent, chunk_tree);
	btrfs_set_dev_extent_chunk_objectid(leaf, extent, chunk_objectid);
	btrfs_set_dev_extent_chunk_offset(leaf, extent, chunk_offset);

	write_extent_buffer(leaf, root->fs_info->chunk_tree_uuid,
1332
		    btrfs_dev_extent_chunk_tree_uuid(extent), BTRFS_UUID_SIZE);
1333

1334 1335
	btrfs_set_dev_extent_length(leaf, extent, num_bytes);
	btrfs_mark_buffer_dirty(leaf);
1336
out:
1337 1338 1339 1340
	btrfs_free_path(path);
	return ret;
}

1341
static u64 find_next_chunk(struct btrfs_fs_info *fs_info)
1342
{
1343 1344 1345 1346
	struct extent_map_tree *em_tree;
	struct extent_map *em;
	struct rb_node *n;
	u64 ret = 0;
1347

1348 1349 1350 1351 1352 1353
	em_tree = &fs_info->mapping_tree.map_tree;
	read_lock(&em_tree->lock);
	n = rb_last(&em_tree->map);
	if (n) {
		em = rb_entry(n, struct extent_map, rb_node);
		ret = em->start + em->len;
1354
	}
1355 1356
	read_unlock(&em_tree->lock);

1357 1358 1359
	return ret;
}

1360 1361
static noinline int find_next_devid(struct btrfs_fs_info *fs_info,
				    u64 *devid_ret)
1362 1363 1364 1365
{
	int ret;
	struct btrfs_key key;
	struct btrfs_key found_key;
Y
Yan Zheng 已提交
1366 1367 1368 1369 1370
	struct btrfs_path *path;

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;
1371 1372 1373 1374 1375

	key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
	key.type = BTRFS_DEV_ITEM_KEY;
	key.offset = (u64)-1;

1376
	ret = btrfs_search_slot(NULL, fs_info->chunk_root, &key, path, 0, 0);
1377 1378 1379
	if (ret < 0)
		goto error;

1380
	BUG_ON(ret == 0); /* Corruption */
1381

1382 1383
	ret = btrfs_previous_item(fs_info->chunk_root, path,
				  BTRFS_DEV_ITEMS_OBJECTID,
1384 1385
				  BTRFS_DEV_ITEM_KEY);
	if (ret) {
1386
		*devid_ret = 1;
1387 1388 1389
	} else {
		btrfs_item_key_to_cpu(path->nodes[0], &found_key,
				      path->slots[0]);
1390
		*devid_ret = found_key.offset + 1;
1391 1392 1393
	}
	ret = 0;
error:
Y
Yan Zheng 已提交
1394
	btrfs_free_path(path);
1395 1396 1397 1398 1399 1400 1401
	return ret;
}

/*
 * the device information is stored in the chunk root
 * the btrfs_device struct should be fully filled in
 */
1402 1403 1404
static int btrfs_add_device(struct btrfs_trans_handle *trans,
			    struct btrfs_root *root,
			    struct btrfs_device *device)
1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420
{
	int ret;
	struct btrfs_path *path;
	struct btrfs_dev_item *dev_item;
	struct extent_buffer *leaf;
	struct btrfs_key key;
	unsigned long ptr;

	root = root->fs_info->chunk_root;

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

	key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
	key.type = BTRFS_DEV_ITEM_KEY;
Y
Yan Zheng 已提交
1421
	key.offset = device->devid;
1422 1423

	ret = btrfs_insert_empty_item(trans, root, path, &key,
1424
				      sizeof(*dev_item));
1425 1426 1427 1428 1429 1430 1431
	if (ret)
		goto out;

	leaf = path->nodes[0];
	dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item);

	btrfs_set_device_id(leaf, dev_item, device->devid);
Y
Yan Zheng 已提交
1432
	btrfs_set_device_generation(leaf, dev_item, 0);
1433 1434 1435 1436 1437 1438
	btrfs_set_device_type(leaf, dev_item, device->type);
	btrfs_set_device_io_align(leaf, dev_item, device->io_align);
	btrfs_set_device_io_width(leaf, dev_item, device->io_width);
	btrfs_set_device_sector_size(leaf, dev_item, device->sector_size);
	btrfs_set_device_total_bytes(leaf, dev_item, device->total_bytes);
	btrfs_set_device_bytes_used(leaf, dev_item, device->bytes_used);
1439 1440 1441
	btrfs_set_device_group(leaf, dev_item, 0);
	btrfs_set_device_seek_speed(leaf, dev_item, 0);
	btrfs_set_device_bandwidth(leaf, dev_item, 0);
1442
	btrfs_set_device_start_offset(leaf, dev_item, 0);
1443

1444
	ptr = btrfs_device_uuid(dev_item);
1445
	write_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE);
1446
	ptr = btrfs_device_fsid(dev_item);
Y
Yan Zheng 已提交
1447
	write_extent_buffer(leaf, root->fs_info->fsid, ptr, BTRFS_UUID_SIZE);
1448 1449
	btrfs_mark_buffer_dirty(leaf);

Y
Yan Zheng 已提交
1450
	ret = 0;
1451 1452 1453 1454
out:
	btrfs_free_path(path);
	return ret;
}
1455

1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471
/*
 * Function to update ctime/mtime for a given device path.
 * Mainly used for ctime/mtime based probe like libblkid.
 */
static void update_dev_time(char *path_name)
{
	struct file *filp;

	filp = filp_open(path_name, O_RDWR, 0);
	if (!filp)
		return;
	file_update_time(filp);
	filp_close(filp, NULL);
	return;
}

1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485
static int btrfs_rm_dev_item(struct btrfs_root *root,
			     struct btrfs_device *device)
{
	int ret;
	struct btrfs_path *path;
	struct btrfs_key key;
	struct btrfs_trans_handle *trans;

	root = root->fs_info->chunk_root;

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

1486
	trans = btrfs_start_transaction(root, 0);
1487 1488 1489 1490
	if (IS_ERR(trans)) {
		btrfs_free_path(path);
		return PTR_ERR(trans);
	}
1491 1492 1493
	key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
	key.type = BTRFS_DEV_ITEM_KEY;
	key.offset = device->devid;
1494
	lock_chunks(root);
1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509

	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
	if (ret < 0)
		goto out;

	if (ret > 0) {
		ret = -ENOENT;
		goto out;
	}

	ret = btrfs_del_item(trans, root, path);
	if (ret)
		goto out;
out:
	btrfs_free_path(path);
1510
	unlock_chunks(root);
1511 1512 1513 1514 1515 1516 1517
	btrfs_commit_transaction(trans, root);
	return ret;
}

int btrfs_rm_device(struct btrfs_root *root, char *device_path)
{
	struct btrfs_device *device;
Y
Yan Zheng 已提交
1518
	struct btrfs_device *next_device;
1519
	struct block_device *bdev;
1520
	struct buffer_head *bh = NULL;
1521
	struct btrfs_super_block *disk_super;
1522
	struct btrfs_fs_devices *cur_devices;
1523 1524
	u64 all_avail;
	u64 devid;
Y
Yan Zheng 已提交
1525 1526
	u64 num_devices;
	u8 *dev_uuid;
1527
	unsigned seq;
1528
	int ret = 0;
1529
	bool clear_super = false;
1530 1531 1532

	mutex_lock(&uuid_mutex);

1533 1534 1535 1536 1537 1538 1539
	do {
		seq = read_seqbegin(&root->fs_info->profiles_lock);

		all_avail = root->fs_info->avail_data_alloc_bits |
			    root->fs_info->avail_system_alloc_bits |
			    root->fs_info->avail_metadata_alloc_bits;
	} while (read_seqretry(&root->fs_info->profiles_lock, seq));
1540

1541 1542 1543 1544 1545 1546 1547 1548 1549
	num_devices = root->fs_info->fs_devices->num_devices;
	btrfs_dev_replace_lock(&root->fs_info->dev_replace);
	if (btrfs_dev_replace_is_ongoing(&root->fs_info->dev_replace)) {
		WARN_ON(num_devices < 1);
		num_devices--;
	}
	btrfs_dev_replace_unlock(&root->fs_info->dev_replace);

	if ((all_avail & BTRFS_BLOCK_GROUP_RAID10) && num_devices <= 4) {
1550
		ret = BTRFS_ERROR_DEV_RAID10_MIN_NOT_MET;
1551 1552 1553
		goto out;
	}

1554
	if ((all_avail & BTRFS_BLOCK_GROUP_RAID1) && num_devices <= 2) {
1555
		ret = BTRFS_ERROR_DEV_RAID1_MIN_NOT_MET;
1556 1557 1558
		goto out;
	}

D
David Woodhouse 已提交
1559 1560
	if ((all_avail & BTRFS_BLOCK_GROUP_RAID5) &&
	    root->fs_info->fs_devices->rw_devices <= 2) {
1561
		ret = BTRFS_ERROR_DEV_RAID5_MIN_NOT_MET;
D
David Woodhouse 已提交
1562 1563 1564 1565
		goto out;
	}
	if ((all_avail & BTRFS_BLOCK_GROUP_RAID6) &&
	    root->fs_info->fs_devices->rw_devices <= 3) {
1566
		ret = BTRFS_ERROR_DEV_RAID6_MIN_NOT_MET;
D
David Woodhouse 已提交
1567 1568 1569
		goto out;
	}

1570 1571 1572
	if (strcmp(device_path, "missing") == 0) {
		struct list_head *devices;
		struct btrfs_device *tmp;
1573

1574 1575
		device = NULL;
		devices = &root->fs_info->fs_devices->devices;
1576 1577 1578 1579
		/*
		 * It is safe to read the devices since the volume_mutex
		 * is held.
		 */
1580
		list_for_each_entry(tmp, devices, dev_list) {
1581 1582 1583
			if (tmp->in_fs_metadata &&
			    !tmp->is_tgtdev_for_dev_replace &&
			    !tmp->bdev) {
1584 1585 1586 1587 1588 1589 1590 1591
				device = tmp;
				break;
			}
		}
		bdev = NULL;
		bh = NULL;
		disk_super = NULL;
		if (!device) {
1592
			ret = BTRFS_ERROR_DEV_MISSING_NOT_FOUND;
1593 1594 1595
			goto out;
		}
	} else {
1596
		ret = btrfs_get_bdev_and_sb(device_path,
1597
					    FMODE_WRITE | FMODE_EXCL,
1598 1599 1600
					    root->fs_info->bdev_holder, 0,
					    &bdev, &bh);
		if (ret)
1601 1602
			goto out;
		disk_super = (struct btrfs_super_block *)bh->b_data;
1603
		devid = btrfs_stack_device_id(&disk_super->dev_item);
Y
Yan Zheng 已提交
1604
		dev_uuid = disk_super->dev_item.uuid;
1605
		device = btrfs_find_device(root->fs_info, devid, dev_uuid,
Y
Yan Zheng 已提交
1606
					   disk_super->fsid);
1607 1608 1609 1610
		if (!device) {
			ret = -ENOENT;
			goto error_brelse;
		}
Y
Yan Zheng 已提交
1611
	}
1612

1613
	if (device->is_tgtdev_for_dev_replace) {
1614
		ret = BTRFS_ERROR_DEV_TGT_REPLACE;
1615 1616 1617
		goto error_brelse;
	}

Y
Yan Zheng 已提交
1618
	if (device->writeable && root->fs_info->fs_devices->rw_devices == 1) {
1619
		ret = BTRFS_ERROR_DEV_ONLY_WRITABLE;
Y
Yan Zheng 已提交
1620 1621 1622 1623
		goto error_brelse;
	}

	if (device->writeable) {
1624
		lock_chunks(root);
Y
Yan Zheng 已提交
1625
		list_del_init(&device->dev_alloc_list);
1626
		unlock_chunks(root);
Y
Yan Zheng 已提交
1627
		root->fs_info->fs_devices->rw_devices--;
1628
		clear_super = true;
1629
	}
1630

1631
	mutex_unlock(&uuid_mutex);
1632
	ret = btrfs_shrink_device(device, 0);
1633
	mutex_lock(&uuid_mutex);
1634
	if (ret)
1635
		goto error_undo;
1636

1637 1638 1639 1640 1641
	/*
	 * TODO: the superblock still includes this device in its num_devices
	 * counter although write_all_supers() is not locked out. This
	 * could give a filesystem state which requires a degraded mount.
	 */
1642 1643
	ret = btrfs_rm_dev_item(root->fs_info->chunk_root, device);
	if (ret)
1644
		goto error_undo;
1645

1646 1647 1648 1649 1650
	spin_lock(&root->fs_info->free_chunk_lock);
	root->fs_info->free_chunk_space = device->total_bytes -
		device->bytes_used;
	spin_unlock(&root->fs_info->free_chunk_lock);

Y
Yan Zheng 已提交
1651
	device->in_fs_metadata = 0;
1652
	btrfs_scrub_cancel_dev(root->fs_info, device);
1653 1654 1655 1656

	/*
	 * the device list mutex makes sure that we don't change
	 * the device list while someone else is writing out all
1657 1658 1659 1660 1661
	 * the device supers. Whoever is writing all supers, should
	 * lock the device list mutex before getting the number of
	 * devices in the super block (super_copy). Conversely,
	 * whoever updates the number of devices in the super block
	 * (super_copy) should hold the device list mutex.
1662
	 */
1663 1664

	cur_devices = device->fs_devices;
1665
	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
1666
	list_del_rcu(&device->dev_list);
1667

Y
Yan Zheng 已提交
1668
	device->fs_devices->num_devices--;
1669
	device->fs_devices->total_devices--;
Y
Yan Zheng 已提交
1670

1671 1672 1673
	if (device->missing)
		root->fs_info->fs_devices->missing_devices--;

Y
Yan Zheng 已提交
1674 1675 1676 1677 1678 1679 1680
	next_device = list_entry(root->fs_info->fs_devices->devices.next,
				 struct btrfs_device, dev_list);
	if (device->bdev == root->fs_info->sb->s_bdev)
		root->fs_info->sb->s_bdev = next_device->bdev;
	if (device->bdev == root->fs_info->fs_devices->latest_bdev)
		root->fs_info->fs_devices->latest_bdev = next_device->bdev;

1681
	if (device->bdev)
Y
Yan Zheng 已提交
1682
		device->fs_devices->open_devices--;
1683

1684 1685 1686
	/* remove sysfs entry */
	btrfs_kobj_rm_device(root->fs_info, device);

1687
	call_rcu(&device->rcu, free_device);
Y
Yan Zheng 已提交
1688

1689 1690
	num_devices = btrfs_super_num_devices(root->fs_info->super_copy) - 1;
	btrfs_set_super_num_devices(root->fs_info->super_copy, num_devices);
1691
	mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
Y
Yan Zheng 已提交
1692

1693
	if (cur_devices->open_devices == 0) {
Y
Yan Zheng 已提交
1694 1695 1696
		struct btrfs_fs_devices *fs_devices;
		fs_devices = root->fs_info->fs_devices;
		while (fs_devices) {
1697 1698
			if (fs_devices->seed == cur_devices) {
				fs_devices->seed = cur_devices->seed;
Y
Yan Zheng 已提交
1699
				break;
1700
			}
Y
Yan Zheng 已提交
1701
			fs_devices = fs_devices->seed;
Y
Yan Zheng 已提交
1702
		}
1703
		cur_devices->seed = NULL;
1704
		lock_chunks(root);
1705
		__btrfs_close_devices(cur_devices);
1706
		unlock_chunks(root);
1707
		free_fs_devices(cur_devices);
Y
Yan Zheng 已提交
1708 1709
	}

1710 1711 1712
	root->fs_info->num_tolerated_disk_barrier_failures =
		btrfs_calc_num_tolerated_disk_barrier_failures(root->fs_info);

Y
Yan Zheng 已提交
1713 1714 1715 1716
	/*
	 * at this point, the device is zero sized.  We want to
	 * remove it from the devices list and zero out the old super
	 */
1717
	if (clear_super && disk_super) {
1718 1719 1720
		u64 bytenr;
		int i;

1721 1722 1723 1724 1725 1726
		/* make sure this device isn't detected as part of
		 * the FS anymore
		 */
		memset(&disk_super->magic, 0, sizeof(disk_super->magic));
		set_buffer_dirty(bh);
		sync_dirty_buffer(bh);
1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754

		/* clear the mirror copies of super block on the disk
		 * being removed, 0th copy is been taken care above and
		 * the below would take of the rest
		 */
		for (i = 1; i < BTRFS_SUPER_MIRROR_MAX; i++) {
			bytenr = btrfs_sb_offset(i);
			if (bytenr + BTRFS_SUPER_INFO_SIZE >=
					i_size_read(bdev->bd_inode))
				break;

			brelse(bh);
			bh = __bread(bdev, bytenr / 4096,
					BTRFS_SUPER_INFO_SIZE);
			if (!bh)
				continue;

			disk_super = (struct btrfs_super_block *)bh->b_data;

			if (btrfs_super_bytenr(disk_super) != bytenr ||
				btrfs_super_magic(disk_super) != BTRFS_MAGIC) {
				continue;
			}
			memset(&disk_super->magic, 0,
						sizeof(disk_super->magic));
			set_buffer_dirty(bh);
			sync_dirty_buffer(bh);
		}
1755
	}
1756 1757 1758

	ret = 0;

1759 1760
	if (bdev) {
		/* Notify udev that device has changed */
1761
		btrfs_kobject_uevent(bdev, KOBJ_CHANGE);
1762

1763 1764 1765 1766
		/* Update ctime/mtime for device path for libblkid */
		update_dev_time(device_path);
	}

1767 1768
error_brelse:
	brelse(bh);
1769
	if (bdev)
1770
		blkdev_put(bdev, FMODE_READ | FMODE_EXCL);
1771 1772 1773
out:
	mutex_unlock(&uuid_mutex);
	return ret;
1774 1775
error_undo:
	if (device->writeable) {
1776
		lock_chunks(root);
1777 1778
		list_add(&device->dev_alloc_list,
			 &root->fs_info->fs_devices->alloc_list);
1779
		unlock_chunks(root);
1780 1781 1782
		root->fs_info->fs_devices->rw_devices++;
	}
	goto error_brelse;
1783 1784
}

1785 1786 1787 1788
void btrfs_rm_dev_replace_srcdev(struct btrfs_fs_info *fs_info,
				 struct btrfs_device *srcdev)
{
	WARN_ON(!mutex_is_locked(&fs_info->fs_devices->device_list_mutex));
1789

1790 1791 1792 1793 1794 1795 1796 1797 1798
	list_del_rcu(&srcdev->dev_list);
	list_del_rcu(&srcdev->dev_alloc_list);
	fs_info->fs_devices->num_devices--;
	if (srcdev->missing) {
		fs_info->fs_devices->missing_devices--;
		fs_info->fs_devices->rw_devices++;
	}
	if (srcdev->can_discard)
		fs_info->fs_devices->num_can_discard--;
1799
	if (srcdev->bdev) {
1800 1801
		fs_info->fs_devices->open_devices--;

1802 1803 1804 1805
		/* zero out the old super */
		btrfs_scratch_superblock(srcdev);
	}

1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836
	call_rcu(&srcdev->rcu, free_device);
}

void btrfs_destroy_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
				      struct btrfs_device *tgtdev)
{
	struct btrfs_device *next_device;

	WARN_ON(!tgtdev);
	mutex_lock(&fs_info->fs_devices->device_list_mutex);
	if (tgtdev->bdev) {
		btrfs_scratch_superblock(tgtdev);
		fs_info->fs_devices->open_devices--;
	}
	fs_info->fs_devices->num_devices--;
	if (tgtdev->can_discard)
		fs_info->fs_devices->num_can_discard++;

	next_device = list_entry(fs_info->fs_devices->devices.next,
				 struct btrfs_device, dev_list);
	if (tgtdev->bdev == fs_info->sb->s_bdev)
		fs_info->sb->s_bdev = next_device->bdev;
	if (tgtdev->bdev == fs_info->fs_devices->latest_bdev)
		fs_info->fs_devices->latest_bdev = next_device->bdev;
	list_del_rcu(&tgtdev->dev_list);

	call_rcu(&tgtdev->rcu, free_device);

	mutex_unlock(&fs_info->fs_devices->device_list_mutex);
}

1837 1838
static int btrfs_find_device_by_path(struct btrfs_root *root, char *device_path,
				     struct btrfs_device **device)
1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854
{
	int ret = 0;
	struct btrfs_super_block *disk_super;
	u64 devid;
	u8 *dev_uuid;
	struct block_device *bdev;
	struct buffer_head *bh;

	*device = NULL;
	ret = btrfs_get_bdev_and_sb(device_path, FMODE_READ,
				    root->fs_info->bdev_holder, 0, &bdev, &bh);
	if (ret)
		return ret;
	disk_super = (struct btrfs_super_block *)bh->b_data;
	devid = btrfs_stack_device_id(&disk_super->dev_item);
	dev_uuid = disk_super->dev_item.uuid;
1855
	*device = btrfs_find_device(root->fs_info, devid, dev_uuid,
1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885
				    disk_super->fsid);
	brelse(bh);
	if (!*device)
		ret = -ENOENT;
	blkdev_put(bdev, FMODE_READ);
	return ret;
}

int btrfs_find_device_missing_or_by_path(struct btrfs_root *root,
					 char *device_path,
					 struct btrfs_device **device)
{
	*device = NULL;
	if (strcmp(device_path, "missing") == 0) {
		struct list_head *devices;
		struct btrfs_device *tmp;

		devices = &root->fs_info->fs_devices->devices;
		/*
		 * It is safe to read the devices since the volume_mutex
		 * is held by the caller.
		 */
		list_for_each_entry(tmp, devices, dev_list) {
			if (tmp->in_fs_metadata && !tmp->bdev) {
				*device = tmp;
				break;
			}
		}

		if (!*device) {
1886
			btrfs_err(root->fs_info, "no missing device found");
1887 1888 1889 1890 1891 1892 1893 1894 1895
			return -ENOENT;
		}

		return 0;
	} else {
		return btrfs_find_device_by_path(root, device_path, device);
	}
}

Y
Yan Zheng 已提交
1896 1897 1898
/*
 * does all the dirty work required for changing file system's UUID.
 */
1899
static int btrfs_prepare_sprout(struct btrfs_root *root)
Y
Yan Zheng 已提交
1900 1901 1902
{
	struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
	struct btrfs_fs_devices *old_devices;
Y
Yan Zheng 已提交
1903
	struct btrfs_fs_devices *seed_devices;
1904
	struct btrfs_super_block *disk_super = root->fs_info->super_copy;
Y
Yan Zheng 已提交
1905 1906 1907 1908
	struct btrfs_device *device;
	u64 super_flags;

	BUG_ON(!mutex_is_locked(&uuid_mutex));
Y
Yan Zheng 已提交
1909
	if (!fs_devices->seeding)
Y
Yan Zheng 已提交
1910 1911
		return -EINVAL;

1912 1913 1914
	seed_devices = __alloc_fs_devices();
	if (IS_ERR(seed_devices))
		return PTR_ERR(seed_devices);
Y
Yan Zheng 已提交
1915

Y
Yan Zheng 已提交
1916 1917 1918 1919
	old_devices = clone_fs_devices(fs_devices);
	if (IS_ERR(old_devices)) {
		kfree(seed_devices);
		return PTR_ERR(old_devices);
Y
Yan Zheng 已提交
1920
	}
Y
Yan Zheng 已提交
1921

Y
Yan Zheng 已提交
1922 1923
	list_add(&old_devices->list, &fs_uuids);

Y
Yan Zheng 已提交
1924 1925 1926 1927
	memcpy(seed_devices, fs_devices, sizeof(*seed_devices));
	seed_devices->opened = 1;
	INIT_LIST_HEAD(&seed_devices->devices);
	INIT_LIST_HEAD(&seed_devices->alloc_list);
1928
	mutex_init(&seed_devices->device_list_mutex);
1929 1930

	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
1931 1932
	list_splice_init_rcu(&fs_devices->devices, &seed_devices->devices,
			      synchronize_rcu);
1933

Y
Yan Zheng 已提交
1934 1935 1936 1937 1938
	list_splice_init(&fs_devices->alloc_list, &seed_devices->alloc_list);
	list_for_each_entry(device, &seed_devices->devices, dev_list) {
		device->fs_devices = seed_devices;
	}

Y
Yan Zheng 已提交
1939 1940 1941
	fs_devices->seeding = 0;
	fs_devices->num_devices = 0;
	fs_devices->open_devices = 0;
Y
Yan Zheng 已提交
1942
	fs_devices->seed = seed_devices;
Y
Yan Zheng 已提交
1943 1944 1945 1946

	generate_random_uuid(fs_devices->fsid);
	memcpy(root->fs_info->fsid, fs_devices->fsid, BTRFS_FSID_SIZE);
	memcpy(disk_super->fsid, fs_devices->fsid, BTRFS_FSID_SIZE);
1947 1948
	mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);

Y
Yan Zheng 已提交
1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995
	super_flags = btrfs_super_flags(disk_super) &
		      ~BTRFS_SUPER_FLAG_SEEDING;
	btrfs_set_super_flags(disk_super, super_flags);

	return 0;
}

/*
 * strore the expected generation for seed devices in device items.
 */
static int btrfs_finish_sprout(struct btrfs_trans_handle *trans,
			       struct btrfs_root *root)
{
	struct btrfs_path *path;
	struct extent_buffer *leaf;
	struct btrfs_dev_item *dev_item;
	struct btrfs_device *device;
	struct btrfs_key key;
	u8 fs_uuid[BTRFS_UUID_SIZE];
	u8 dev_uuid[BTRFS_UUID_SIZE];
	u64 devid;
	int ret;

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

	root = root->fs_info->chunk_root;
	key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
	key.offset = 0;
	key.type = BTRFS_DEV_ITEM_KEY;

	while (1) {
		ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
		if (ret < 0)
			goto error;

		leaf = path->nodes[0];
next_slot:
		if (path->slots[0] >= btrfs_header_nritems(leaf)) {
			ret = btrfs_next_leaf(root, path);
			if (ret > 0)
				break;
			if (ret < 0)
				goto error;
			leaf = path->nodes[0];
			btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1996
			btrfs_release_path(path);
Y
Yan Zheng 已提交
1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007
			continue;
		}

		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
		if (key.objectid != BTRFS_DEV_ITEMS_OBJECTID ||
		    key.type != BTRFS_DEV_ITEM_KEY)
			break;

		dev_item = btrfs_item_ptr(leaf, path->slots[0],
					  struct btrfs_dev_item);
		devid = btrfs_device_id(leaf, dev_item);
2008
		read_extent_buffer(leaf, dev_uuid, btrfs_device_uuid(dev_item),
Y
Yan Zheng 已提交
2009
				   BTRFS_UUID_SIZE);
2010
		read_extent_buffer(leaf, fs_uuid, btrfs_device_fsid(dev_item),
Y
Yan Zheng 已提交
2011
				   BTRFS_UUID_SIZE);
2012 2013
		device = btrfs_find_device(root->fs_info, devid, dev_uuid,
					   fs_uuid);
2014
		BUG_ON(!device); /* Logic error */
Y
Yan Zheng 已提交
2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030

		if (device->fs_devices->seeding) {
			btrfs_set_device_generation(leaf, dev_item,
						    device->generation);
			btrfs_mark_buffer_dirty(leaf);
		}

		path->slots[0]++;
		goto next_slot;
	}
	ret = 0;
error:
	btrfs_free_path(path);
	return ret;
}

2031 2032
int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
{
2033
	struct request_queue *q;
2034 2035 2036 2037
	struct btrfs_trans_handle *trans;
	struct btrfs_device *device;
	struct block_device *bdev;
	struct list_head *devices;
Y
Yan Zheng 已提交
2038
	struct super_block *sb = root->fs_info->sb;
2039
	struct rcu_string *name;
2040
	u64 total_bytes;
Y
Yan Zheng 已提交
2041
	int seeding_dev = 0;
2042 2043
	int ret = 0;

Y
Yan Zheng 已提交
2044
	if ((sb->s_flags & MS_RDONLY) && !root->fs_info->fs_devices->seeding)
2045
		return -EROFS;
2046

2047
	bdev = blkdev_get_by_path(device_path, FMODE_WRITE | FMODE_EXCL,
2048
				  root->fs_info->bdev_holder);
2049 2050
	if (IS_ERR(bdev))
		return PTR_ERR(bdev);
2051

Y
Yan Zheng 已提交
2052 2053 2054 2055 2056 2057
	if (root->fs_info->fs_devices->seeding) {
		seeding_dev = 1;
		down_write(&sb->s_umount);
		mutex_lock(&uuid_mutex);
	}

2058
	filemap_write_and_wait(bdev->bd_inode->i_mapping);
2059

2060
	devices = &root->fs_info->fs_devices->devices;
2061 2062

	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
2063
	list_for_each_entry(device, devices, dev_list) {
2064 2065
		if (device->bdev == bdev) {
			ret = -EEXIST;
2066 2067
			mutex_unlock(
				&root->fs_info->fs_devices->device_list_mutex);
Y
Yan Zheng 已提交
2068
			goto error;
2069 2070
		}
	}
2071
	mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
2072

2073 2074
	device = btrfs_alloc_device(root->fs_info, NULL, NULL);
	if (IS_ERR(device)) {
2075
		/* we can safely leave the fs_devices entry around */
2076
		ret = PTR_ERR(device);
Y
Yan Zheng 已提交
2077
		goto error;
2078 2079
	}

2080 2081
	name = rcu_string_strdup(device_path, GFP_NOFS);
	if (!name) {
2082
		kfree(device);
Y
Yan Zheng 已提交
2083 2084
		ret = -ENOMEM;
		goto error;
2085
	}
2086
	rcu_assign_pointer(device->name, name);
Y
Yan Zheng 已提交
2087

2088
	trans = btrfs_start_transaction(root, 0);
2089
	if (IS_ERR(trans)) {
2090
		rcu_string_free(device->name);
2091 2092 2093 2094 2095
		kfree(device);
		ret = PTR_ERR(trans);
		goto error;
	}

Y
Yan Zheng 已提交
2096 2097
	lock_chunks(root);

2098 2099 2100
	q = bdev_get_queue(bdev);
	if (blk_queue_discard(q))
		device->can_discard = 1;
Y
Yan Zheng 已提交
2101 2102
	device->writeable = 1;
	device->generation = trans->transid;
2103 2104 2105 2106
	device->io_width = root->sectorsize;
	device->io_align = root->sectorsize;
	device->sector_size = root->sectorsize;
	device->total_bytes = i_size_read(bdev->bd_inode);
2107
	device->disk_total_bytes = device->total_bytes;
2108 2109
	device->dev_root = root->fs_info->dev_root;
	device->bdev = bdev;
2110
	device->in_fs_metadata = 1;
2111
	device->is_tgtdev_for_dev_replace = 0;
2112
	device->mode = FMODE_EXCL;
2113
	device->dev_stats_valid = 1;
Y
Yan Zheng 已提交
2114
	set_blocksize(device->bdev, 4096);
2115

Y
Yan Zheng 已提交
2116 2117
	if (seeding_dev) {
		sb->s_flags &= ~MS_RDONLY;
2118
		ret = btrfs_prepare_sprout(root);
2119
		BUG_ON(ret); /* -ENOMEM */
Y
Yan Zheng 已提交
2120
	}
2121

Y
Yan Zheng 已提交
2122
	device->fs_devices = root->fs_info->fs_devices;
2123 2124

	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
2125
	list_add_rcu(&device->dev_list, &root->fs_info->fs_devices->devices);
Y
Yan Zheng 已提交
2126 2127 2128 2129 2130
	list_add(&device->dev_alloc_list,
		 &root->fs_info->fs_devices->alloc_list);
	root->fs_info->fs_devices->num_devices++;
	root->fs_info->fs_devices->open_devices++;
	root->fs_info->fs_devices->rw_devices++;
2131
	root->fs_info->fs_devices->total_devices++;
2132 2133
	if (device->can_discard)
		root->fs_info->fs_devices->num_can_discard++;
Y
Yan Zheng 已提交
2134
	root->fs_info->fs_devices->total_rw_bytes += device->total_bytes;
2135

2136 2137 2138 2139
	spin_lock(&root->fs_info->free_chunk_lock);
	root->fs_info->free_chunk_space += device->total_bytes;
	spin_unlock(&root->fs_info->free_chunk_lock);

2140 2141 2142
	if (!blk_queue_nonrot(bdev_get_queue(bdev)))
		root->fs_info->fs_devices->rotating = 1;

2143 2144
	total_bytes = btrfs_super_total_bytes(root->fs_info->super_copy);
	btrfs_set_super_total_bytes(root->fs_info->super_copy,
2145 2146
				    total_bytes + device->total_bytes);

2147 2148
	total_bytes = btrfs_super_num_devices(root->fs_info->super_copy);
	btrfs_set_super_num_devices(root->fs_info->super_copy,
2149
				    total_bytes + 1);
2150 2151 2152 2153

	/* add sysfs device entry */
	btrfs_kobj_add_device(root->fs_info, device);

2154
	mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
2155

Y
Yan Zheng 已提交
2156 2157
	if (seeding_dev) {
		ret = init_first_rw_device(trans, root, device);
2158 2159
		if (ret) {
			btrfs_abort_transaction(trans, root, ret);
2160
			goto error_trans;
2161
		}
Y
Yan Zheng 已提交
2162
		ret = btrfs_finish_sprout(trans, root);
2163 2164
		if (ret) {
			btrfs_abort_transaction(trans, root, ret);
2165
			goto error_trans;
2166
		}
Y
Yan Zheng 已提交
2167 2168
	} else {
		ret = btrfs_add_device(trans, root, device);
2169 2170
		if (ret) {
			btrfs_abort_transaction(trans, root, ret);
2171
			goto error_trans;
2172
		}
Y
Yan Zheng 已提交
2173 2174
	}

2175 2176 2177 2178 2179 2180
	/*
	 * we've got more storage, clear any full flags on the space
	 * infos
	 */
	btrfs_clear_space_info_full(root->fs_info);

2181
	unlock_chunks(root);
2182 2183
	root->fs_info->num_tolerated_disk_barrier_failures =
		btrfs_calc_num_tolerated_disk_barrier_failures(root->fs_info);
2184
	ret = btrfs_commit_transaction(trans, root);
2185

Y
Yan Zheng 已提交
2186 2187 2188
	if (seeding_dev) {
		mutex_unlock(&uuid_mutex);
		up_write(&sb->s_umount);
2189

2190 2191 2192
		if (ret) /* transaction commit */
			return ret;

Y
Yan Zheng 已提交
2193
		ret = btrfs_relocate_sys_chunks(root);
2194 2195 2196 2197 2198
		if (ret < 0)
			btrfs_error(root->fs_info, ret,
				    "Failed to relocate sys chunks after "
				    "device initialization. This can be fixed "
				    "using the \"btrfs balance\" command.");
2199 2200 2201 2202 2203 2204 2205
		trans = btrfs_attach_transaction(root);
		if (IS_ERR(trans)) {
			if (PTR_ERR(trans) == -ENOENT)
				return 0;
			return PTR_ERR(trans);
		}
		ret = btrfs_commit_transaction(trans, root);
Y
Yan Zheng 已提交
2206
	}
2207

2208 2209
	/* Update ctime/mtime for libblkid */
	update_dev_time(device_path);
Y
Yan Zheng 已提交
2210
	return ret;
2211 2212 2213 2214

error_trans:
	unlock_chunks(root);
	btrfs_end_transaction(trans, root);
2215
	rcu_string_free(device->name);
2216
	btrfs_kobj_rm_device(root->fs_info, device);
2217
	kfree(device);
Y
Yan Zheng 已提交
2218
error:
2219
	blkdev_put(bdev, FMODE_EXCL);
Y
Yan Zheng 已提交
2220 2221 2222 2223
	if (seeding_dev) {
		mutex_unlock(&uuid_mutex);
		up_write(&sb->s_umount);
	}
2224
	return ret;
2225 2226
}

2227 2228 2229 2230 2231 2232 2233 2234 2235
int btrfs_init_dev_replace_tgtdev(struct btrfs_root *root, char *device_path,
				  struct btrfs_device **device_out)
{
	struct request_queue *q;
	struct btrfs_device *device;
	struct block_device *bdev;
	struct btrfs_fs_info *fs_info = root->fs_info;
	struct list_head *devices;
	struct rcu_string *name;
2236
	u64 devid = BTRFS_DEV_REPLACE_DEVID;
2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257
	int ret = 0;

	*device_out = NULL;
	if (fs_info->fs_devices->seeding)
		return -EINVAL;

	bdev = blkdev_get_by_path(device_path, FMODE_WRITE | FMODE_EXCL,
				  fs_info->bdev_holder);
	if (IS_ERR(bdev))
		return PTR_ERR(bdev);

	filemap_write_and_wait(bdev->bd_inode->i_mapping);

	devices = &fs_info->fs_devices->devices;
	list_for_each_entry(device, devices, dev_list) {
		if (device->bdev == bdev) {
			ret = -EEXIST;
			goto error;
		}
	}

2258 2259 2260
	device = btrfs_alloc_device(NULL, &devid, NULL);
	if (IS_ERR(device)) {
		ret = PTR_ERR(device);
2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287
		goto error;
	}

	name = rcu_string_strdup(device_path, GFP_NOFS);
	if (!name) {
		kfree(device);
		ret = -ENOMEM;
		goto error;
	}
	rcu_assign_pointer(device->name, name);

	q = bdev_get_queue(bdev);
	if (blk_queue_discard(q))
		device->can_discard = 1;
	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
	device->writeable = 1;
	device->generation = 0;
	device->io_width = root->sectorsize;
	device->io_align = root->sectorsize;
	device->sector_size = root->sectorsize;
	device->total_bytes = i_size_read(bdev->bd_inode);
	device->disk_total_bytes = device->total_bytes;
	device->dev_root = fs_info->dev_root;
	device->bdev = bdev;
	device->in_fs_metadata = 1;
	device->is_tgtdev_for_dev_replace = 1;
	device->mode = FMODE_EXCL;
2288
	device->dev_stats_valid = 1;
2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316
	set_blocksize(device->bdev, 4096);
	device->fs_devices = fs_info->fs_devices;
	list_add(&device->dev_list, &fs_info->fs_devices->devices);
	fs_info->fs_devices->num_devices++;
	fs_info->fs_devices->open_devices++;
	if (device->can_discard)
		fs_info->fs_devices->num_can_discard++;
	mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);

	*device_out = device;
	return ret;

error:
	blkdev_put(bdev, FMODE_EXCL);
	return ret;
}

void btrfs_init_dev_replace_tgtdev_for_resume(struct btrfs_fs_info *fs_info,
					      struct btrfs_device *tgtdev)
{
	WARN_ON(fs_info->fs_devices->rw_devices == 0);
	tgtdev->io_width = fs_info->dev_root->sectorsize;
	tgtdev->io_align = fs_info->dev_root->sectorsize;
	tgtdev->sector_size = fs_info->dev_root->sectorsize;
	tgtdev->dev_root = fs_info->dev_root;
	tgtdev->in_fs_metadata = 1;
}

2317 2318
static noinline int btrfs_update_device(struct btrfs_trans_handle *trans,
					struct btrfs_device *device)
2319 2320 2321 2322 2323 2324 2325 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
{
	int ret;
	struct btrfs_path *path;
	struct btrfs_root *root;
	struct btrfs_dev_item *dev_item;
	struct extent_buffer *leaf;
	struct btrfs_key key;

	root = device->dev_root->fs_info->chunk_root;

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

	key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
	key.type = BTRFS_DEV_ITEM_KEY;
	key.offset = device->devid;

	ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
	if (ret < 0)
		goto out;

	if (ret > 0) {
		ret = -ENOENT;
		goto out;
	}

	leaf = path->nodes[0];
	dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item);

	btrfs_set_device_id(leaf, dev_item, device->devid);
	btrfs_set_device_type(leaf, dev_item, device->type);
	btrfs_set_device_io_align(leaf, dev_item, device->io_align);
	btrfs_set_device_io_width(leaf, dev_item, device->io_width);
	btrfs_set_device_sector_size(leaf, dev_item, device->sector_size);
2354
	btrfs_set_device_total_bytes(leaf, dev_item, device->disk_total_bytes);
2355 2356 2357 2358 2359 2360 2361 2362
	btrfs_set_device_bytes_used(leaf, dev_item, device->bytes_used);
	btrfs_mark_buffer_dirty(leaf);

out:
	btrfs_free_path(path);
	return ret;
}

2363
static int __btrfs_grow_device(struct btrfs_trans_handle *trans,
2364 2365 2366
		      struct btrfs_device *device, u64 new_size)
{
	struct btrfs_super_block *super_copy =
2367
		device->dev_root->fs_info->super_copy;
2368 2369 2370
	u64 old_total = btrfs_super_total_bytes(super_copy);
	u64 diff = new_size - device->total_bytes;

Y
Yan Zheng 已提交
2371 2372
	if (!device->writeable)
		return -EACCES;
2373 2374
	if (new_size <= device->total_bytes ||
	    device->is_tgtdev_for_dev_replace)
Y
Yan Zheng 已提交
2375 2376
		return -EINVAL;

2377
	btrfs_set_super_total_bytes(super_copy, old_total + diff);
Y
Yan Zheng 已提交
2378 2379 2380
	device->fs_devices->total_rw_bytes += diff;

	device->total_bytes = new_size;
2381
	device->disk_total_bytes = new_size;
2382 2383
	btrfs_clear_space_info_full(device->dev_root->fs_info);

2384 2385 2386
	return btrfs_update_device(trans, device);
}

2387 2388 2389 2390 2391 2392 2393 2394 2395 2396
int btrfs_grow_device(struct btrfs_trans_handle *trans,
		      struct btrfs_device *device, u64 new_size)
{
	int ret;
	lock_chunks(device->dev_root);
	ret = __btrfs_grow_device(trans, device, new_size);
	unlock_chunks(device->dev_root);
	return ret;
}

2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415
static int btrfs_free_chunk(struct btrfs_trans_handle *trans,
			    struct btrfs_root *root,
			    u64 chunk_tree, u64 chunk_objectid,
			    u64 chunk_offset)
{
	int ret;
	struct btrfs_path *path;
	struct btrfs_key key;

	root = root->fs_info->chunk_root;
	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

	key.objectid = chunk_objectid;
	key.offset = chunk_offset;
	key.type = BTRFS_CHUNK_ITEM_KEY;

	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
2416 2417 2418 2419 2420 2421 2422 2423
	if (ret < 0)
		goto out;
	else if (ret > 0) { /* Logic error or corruption */
		btrfs_error(root->fs_info, -ENOENT,
			    "Failed lookup while freeing chunk.");
		ret = -ENOENT;
		goto out;
	}
2424 2425

	ret = btrfs_del_item(trans, root, path);
2426 2427 2428 2429
	if (ret < 0)
		btrfs_error(root->fs_info, ret,
			    "Failed to delete chunk item.");
out:
2430
	btrfs_free_path(path);
2431
	return ret;
2432 2433
}

2434
static int btrfs_del_sys_chunk(struct btrfs_root *root, u64 chunk_objectid, u64
2435 2436
			chunk_offset)
{
2437
	struct btrfs_super_block *super_copy = root->fs_info->super_copy;
2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479
	struct btrfs_disk_key *disk_key;
	struct btrfs_chunk *chunk;
	u8 *ptr;
	int ret = 0;
	u32 num_stripes;
	u32 array_size;
	u32 len = 0;
	u32 cur;
	struct btrfs_key key;

	array_size = btrfs_super_sys_array_size(super_copy);

	ptr = super_copy->sys_chunk_array;
	cur = 0;

	while (cur < array_size) {
		disk_key = (struct btrfs_disk_key *)ptr;
		btrfs_disk_key_to_cpu(&key, disk_key);

		len = sizeof(*disk_key);

		if (key.type == BTRFS_CHUNK_ITEM_KEY) {
			chunk = (struct btrfs_chunk *)(ptr + len);
			num_stripes = btrfs_stack_chunk_num_stripes(chunk);
			len += btrfs_chunk_item_size(num_stripes);
		} else {
			ret = -EIO;
			break;
		}
		if (key.objectid == chunk_objectid &&
		    key.offset == chunk_offset) {
			memmove(ptr, ptr + len, array_size - (cur + len));
			array_size -= len;
			btrfs_set_super_sys_array_size(super_copy, array_size);
		} else {
			ptr += len;
			cur += len;
		}
	}
	return ret;
}

2480
static int btrfs_relocate_chunk(struct btrfs_root *root,
2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495
			 u64 chunk_tree, u64 chunk_objectid,
			 u64 chunk_offset)
{
	struct extent_map_tree *em_tree;
	struct btrfs_root *extent_root;
	struct btrfs_trans_handle *trans;
	struct extent_map *em;
	struct map_lookup *map;
	int ret;
	int i;

	root = root->fs_info->chunk_root;
	extent_root = root->fs_info->extent_root;
	em_tree = &root->fs_info->mapping_tree.map_tree;

2496 2497 2498 2499
	ret = btrfs_can_relocate(extent_root, chunk_offset);
	if (ret)
		return -ENOSPC;

2500
	/* step one, relocate all the extents inside this chunk */
2501
	ret = btrfs_relocate_block_group(extent_root, chunk_offset);
2502 2503
	if (ret)
		return ret;
2504

2505
	trans = btrfs_start_transaction(root, 0);
2506 2507 2508 2509 2510
	if (IS_ERR(trans)) {
		ret = PTR_ERR(trans);
		btrfs_std_error(root->fs_info, ret);
		return ret;
	}
2511

2512 2513
	lock_chunks(root);

2514 2515 2516 2517
	/*
	 * step two, delete the device extents and the
	 * chunk tree entries
	 */
2518
	read_lock(&em_tree->lock);
2519
	em = lookup_extent_mapping(em_tree, chunk_offset, 1);
2520
	read_unlock(&em_tree->lock);
2521

2522
	BUG_ON(!em || em->start > chunk_offset ||
2523
	       em->start + em->len < chunk_offset);
2524 2525 2526 2527 2528 2529
	map = (struct map_lookup *)em->bdev;

	for (i = 0; i < map->num_stripes; i++) {
		ret = btrfs_free_dev_extent(trans, map->stripes[i].dev,
					    map->stripes[i].physical);
		BUG_ON(ret);
2530

2531 2532 2533 2534
		if (map->stripes[i].dev) {
			ret = btrfs_update_device(trans, map->stripes[i].dev);
			BUG_ON(ret);
		}
2535 2536 2537 2538 2539 2540
	}
	ret = btrfs_free_chunk(trans, root, chunk_tree, chunk_objectid,
			       chunk_offset);

	BUG_ON(ret);

2541 2542
	trace_btrfs_chunk_free(root, map, chunk_offset, em->len);

2543 2544 2545 2546 2547
	if (map->type & BTRFS_BLOCK_GROUP_SYSTEM) {
		ret = btrfs_del_sys_chunk(root, chunk_objectid, chunk_offset);
		BUG_ON(ret);
	}

Y
Yan Zheng 已提交
2548 2549 2550
	ret = btrfs_remove_block_group(trans, extent_root, chunk_offset);
	BUG_ON(ret);

2551
	write_lock(&em_tree->lock);
Y
Yan Zheng 已提交
2552
	remove_extent_mapping(em_tree, em);
2553
	write_unlock(&em_tree->lock);
Y
Yan Zheng 已提交
2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574

	/* once for the tree */
	free_extent_map(em);
	/* once for us */
	free_extent_map(em);

	unlock_chunks(root);
	btrfs_end_transaction(trans, root);
	return 0;
}

static int btrfs_relocate_sys_chunks(struct btrfs_root *root)
{
	struct btrfs_root *chunk_root = root->fs_info->chunk_root;
	struct btrfs_path *path;
	struct extent_buffer *leaf;
	struct btrfs_chunk *chunk;
	struct btrfs_key key;
	struct btrfs_key found_key;
	u64 chunk_tree = chunk_root->root_key.objectid;
	u64 chunk_type;
2575 2576
	bool retried = false;
	int failed = 0;
Y
Yan Zheng 已提交
2577 2578 2579 2580 2581 2582
	int ret;

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

2583
again:
Y
Yan Zheng 已提交
2584 2585 2586 2587 2588 2589 2590 2591
	key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
	key.offset = (u64)-1;
	key.type = BTRFS_CHUNK_ITEM_KEY;

	while (1) {
		ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0);
		if (ret < 0)
			goto error;
2592
		BUG_ON(ret == 0); /* Corruption */
Y
Yan Zheng 已提交
2593 2594 2595 2596 2597 2598 2599

		ret = btrfs_previous_item(chunk_root, path, key.objectid,
					  key.type);
		if (ret < 0)
			goto error;
		if (ret > 0)
			break;
2600

Y
Yan Zheng 已提交
2601 2602
		leaf = path->nodes[0];
		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
2603

Y
Yan Zheng 已提交
2604 2605 2606
		chunk = btrfs_item_ptr(leaf, path->slots[0],
				       struct btrfs_chunk);
		chunk_type = btrfs_chunk_type(leaf, chunk);
2607
		btrfs_release_path(path);
2608

Y
Yan Zheng 已提交
2609 2610 2611 2612
		if (chunk_type & BTRFS_BLOCK_GROUP_SYSTEM) {
			ret = btrfs_relocate_chunk(chunk_root, chunk_tree,
						   found_key.objectid,
						   found_key.offset);
2613 2614 2615 2616
			if (ret == -ENOSPC)
				failed++;
			else if (ret)
				BUG();
Y
Yan Zheng 已提交
2617
		}
2618

Y
Yan Zheng 已提交
2619 2620 2621 2622 2623
		if (found_key.offset == 0)
			break;
		key.offset = found_key.offset - 1;
	}
	ret = 0;
2624 2625 2626 2627
	if (failed && !retried) {
		failed = 0;
		retried = true;
		goto again;
2628
	} else if (WARN_ON(failed && retried)) {
2629 2630
		ret = -ENOSPC;
	}
Y
Yan Zheng 已提交
2631 2632 2633
error:
	btrfs_free_path(path);
	return ret;
2634 2635
}

2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726
static int insert_balance_item(struct btrfs_root *root,
			       struct btrfs_balance_control *bctl)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_balance_item *item;
	struct btrfs_disk_balance_args disk_bargs;
	struct btrfs_path *path;
	struct extent_buffer *leaf;
	struct btrfs_key key;
	int ret, err;

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

	trans = btrfs_start_transaction(root, 0);
	if (IS_ERR(trans)) {
		btrfs_free_path(path);
		return PTR_ERR(trans);
	}

	key.objectid = BTRFS_BALANCE_OBJECTID;
	key.type = BTRFS_BALANCE_ITEM_KEY;
	key.offset = 0;

	ret = btrfs_insert_empty_item(trans, root, path, &key,
				      sizeof(*item));
	if (ret)
		goto out;

	leaf = path->nodes[0];
	item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item);

	memset_extent_buffer(leaf, 0, (unsigned long)item, sizeof(*item));

	btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->data);
	btrfs_set_balance_data(leaf, item, &disk_bargs);
	btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->meta);
	btrfs_set_balance_meta(leaf, item, &disk_bargs);
	btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->sys);
	btrfs_set_balance_sys(leaf, item, &disk_bargs);

	btrfs_set_balance_flags(leaf, item, bctl->flags);

	btrfs_mark_buffer_dirty(leaf);
out:
	btrfs_free_path(path);
	err = btrfs_commit_transaction(trans, root);
	if (err && !ret)
		ret = err;
	return ret;
}

static int del_balance_item(struct btrfs_root *root)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_path *path;
	struct btrfs_key key;
	int ret, err;

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

	trans = btrfs_start_transaction(root, 0);
	if (IS_ERR(trans)) {
		btrfs_free_path(path);
		return PTR_ERR(trans);
	}

	key.objectid = BTRFS_BALANCE_OBJECTID;
	key.type = BTRFS_BALANCE_ITEM_KEY;
	key.offset = 0;

	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
	if (ret < 0)
		goto out;
	if (ret > 0) {
		ret = -ENOENT;
		goto out;
	}

	ret = btrfs_del_item(trans, root, path);
out:
	btrfs_free_path(path);
	err = btrfs_commit_transaction(trans, root);
	if (err && !ret)
		ret = err;
	return ret;
}

2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766
/*
 * This is a heuristic used to reduce the number of chunks balanced on
 * resume after balance was interrupted.
 */
static void update_balance_args(struct btrfs_balance_control *bctl)
{
	/*
	 * Turn on soft mode for chunk types that were being converted.
	 */
	if (bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT)
		bctl->data.flags |= BTRFS_BALANCE_ARGS_SOFT;
	if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT)
		bctl->sys.flags |= BTRFS_BALANCE_ARGS_SOFT;
	if (bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT)
		bctl->meta.flags |= BTRFS_BALANCE_ARGS_SOFT;

	/*
	 * Turn on usage filter if is not already used.  The idea is
	 * that chunks that we have already balanced should be
	 * reasonably full.  Don't do it for chunks that are being
	 * converted - that will keep us from relocating unconverted
	 * (albeit full) chunks.
	 */
	if (!(bctl->data.flags & BTRFS_BALANCE_ARGS_USAGE) &&
	    !(bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT)) {
		bctl->data.flags |= BTRFS_BALANCE_ARGS_USAGE;
		bctl->data.usage = 90;
	}
	if (!(bctl->sys.flags & BTRFS_BALANCE_ARGS_USAGE) &&
	    !(bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT)) {
		bctl->sys.flags |= BTRFS_BALANCE_ARGS_USAGE;
		bctl->sys.usage = 90;
	}
	if (!(bctl->meta.flags & BTRFS_BALANCE_ARGS_USAGE) &&
	    !(bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT)) {
		bctl->meta.flags |= BTRFS_BALANCE_ARGS_USAGE;
		bctl->meta.usage = 90;
	}
}

2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795
/*
 * Should be called with both balance and volume mutexes held to
 * serialize other volume operations (add_dev/rm_dev/resize) with
 * restriper.  Same goes for unset_balance_control.
 */
static void set_balance_control(struct btrfs_balance_control *bctl)
{
	struct btrfs_fs_info *fs_info = bctl->fs_info;

	BUG_ON(fs_info->balance_ctl);

	spin_lock(&fs_info->balance_lock);
	fs_info->balance_ctl = bctl;
	spin_unlock(&fs_info->balance_lock);
}

static void unset_balance_control(struct btrfs_fs_info *fs_info)
{
	struct btrfs_balance_control *bctl = fs_info->balance_ctl;

	BUG_ON(!fs_info->balance_ctl);

	spin_lock(&fs_info->balance_lock);
	fs_info->balance_ctl = NULL;
	spin_unlock(&fs_info->balance_lock);

	kfree(bctl);
}

I
Ilya Dryomov 已提交
2796 2797 2798 2799
/*
 * Balance filters.  Return 1 if chunk should be filtered out
 * (should not be balanced).
 */
2800
static int chunk_profiles_filter(u64 chunk_type,
I
Ilya Dryomov 已提交
2801 2802
				 struct btrfs_balance_args *bargs)
{
2803 2804
	chunk_type = chunk_to_extended(chunk_type) &
				BTRFS_EXTENDED_PROFILE_MASK;
I
Ilya Dryomov 已提交
2805

2806
	if (bargs->profiles & chunk_type)
I
Ilya Dryomov 已提交
2807 2808 2809 2810 2811
		return 0;

	return 1;
}

I
Ilya Dryomov 已提交
2812 2813 2814 2815 2816 2817 2818 2819 2820 2821
static int chunk_usage_filter(struct btrfs_fs_info *fs_info, u64 chunk_offset,
			      struct btrfs_balance_args *bargs)
{
	struct btrfs_block_group_cache *cache;
	u64 chunk_used, user_thresh;
	int ret = 1;

	cache = btrfs_lookup_block_group(fs_info, chunk_offset);
	chunk_used = btrfs_block_group_used(&cache->item);

2822
	if (bargs->usage == 0)
2823
		user_thresh = 1;
2824 2825 2826 2827 2828 2829
	else if (bargs->usage > 100)
		user_thresh = cache->key.offset;
	else
		user_thresh = div_factor_fine(cache->key.offset,
					      bargs->usage);

I
Ilya Dryomov 已提交
2830 2831 2832 2833 2834 2835 2836
	if (chunk_used < user_thresh)
		ret = 0;

	btrfs_put_block_group(cache);
	return ret;
}

I
Ilya Dryomov 已提交
2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853
static int chunk_devid_filter(struct extent_buffer *leaf,
			      struct btrfs_chunk *chunk,
			      struct btrfs_balance_args *bargs)
{
	struct btrfs_stripe *stripe;
	int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
	int i;

	for (i = 0; i < num_stripes; i++) {
		stripe = btrfs_stripe_nr(chunk, i);
		if (btrfs_stripe_devid(leaf, stripe) == bargs->devid)
			return 0;
	}

	return 1;
}

I
Ilya Dryomov 已提交
2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870
/* [pstart, pend) */
static int chunk_drange_filter(struct extent_buffer *leaf,
			       struct btrfs_chunk *chunk,
			       u64 chunk_offset,
			       struct btrfs_balance_args *bargs)
{
	struct btrfs_stripe *stripe;
	int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
	u64 stripe_offset;
	u64 stripe_length;
	int factor;
	int i;

	if (!(bargs->flags & BTRFS_BALANCE_ARGS_DEVID))
		return 0;

	if (btrfs_chunk_type(leaf, chunk) & (BTRFS_BLOCK_GROUP_DUP |
D
David Woodhouse 已提交
2871 2872 2873 2874 2875 2876 2877 2878 2879
	     BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID10)) {
		factor = num_stripes / 2;
	} else if (btrfs_chunk_type(leaf, chunk) & BTRFS_BLOCK_GROUP_RAID5) {
		factor = num_stripes - 1;
	} else if (btrfs_chunk_type(leaf, chunk) & BTRFS_BLOCK_GROUP_RAID6) {
		factor = num_stripes - 2;
	} else {
		factor = num_stripes;
	}
I
Ilya Dryomov 已提交
2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897

	for (i = 0; i < num_stripes; i++) {
		stripe = btrfs_stripe_nr(chunk, i);
		if (btrfs_stripe_devid(leaf, stripe) != bargs->devid)
			continue;

		stripe_offset = btrfs_stripe_offset(leaf, stripe);
		stripe_length = btrfs_chunk_length(leaf, chunk);
		do_div(stripe_length, factor);

		if (stripe_offset < bargs->pend &&
		    stripe_offset + stripe_length > bargs->pstart)
			return 0;
	}

	return 1;
}

2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911
/* [vstart, vend) */
static int chunk_vrange_filter(struct extent_buffer *leaf,
			       struct btrfs_chunk *chunk,
			       u64 chunk_offset,
			       struct btrfs_balance_args *bargs)
{
	if (chunk_offset < bargs->vend &&
	    chunk_offset + btrfs_chunk_length(leaf, chunk) > bargs->vstart)
		/* at least part of the chunk is inside this vrange */
		return 0;

	return 1;
}

2912
static int chunk_soft_convert_filter(u64 chunk_type,
2913 2914 2915 2916 2917
				     struct btrfs_balance_args *bargs)
{
	if (!(bargs->flags & BTRFS_BALANCE_ARGS_CONVERT))
		return 0;

2918 2919
	chunk_type = chunk_to_extended(chunk_type) &
				BTRFS_EXTENDED_PROFILE_MASK;
2920

2921
	if (bargs->target == chunk_type)
2922 2923 2924 2925 2926
		return 1;

	return 0;
}

2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947
static int should_balance_chunk(struct btrfs_root *root,
				struct extent_buffer *leaf,
				struct btrfs_chunk *chunk, u64 chunk_offset)
{
	struct btrfs_balance_control *bctl = root->fs_info->balance_ctl;
	struct btrfs_balance_args *bargs = NULL;
	u64 chunk_type = btrfs_chunk_type(leaf, chunk);

	/* type filter */
	if (!((chunk_type & BTRFS_BLOCK_GROUP_TYPE_MASK) &
	      (bctl->flags & BTRFS_BALANCE_TYPE_MASK))) {
		return 0;
	}

	if (chunk_type & BTRFS_BLOCK_GROUP_DATA)
		bargs = &bctl->data;
	else if (chunk_type & BTRFS_BLOCK_GROUP_SYSTEM)
		bargs = &bctl->sys;
	else if (chunk_type & BTRFS_BLOCK_GROUP_METADATA)
		bargs = &bctl->meta;

I
Ilya Dryomov 已提交
2948 2949 2950 2951
	/* profiles filter */
	if ((bargs->flags & BTRFS_BALANCE_ARGS_PROFILES) &&
	    chunk_profiles_filter(chunk_type, bargs)) {
		return 0;
I
Ilya Dryomov 已提交
2952 2953 2954 2955 2956 2957
	}

	/* usage filter */
	if ((bargs->flags & BTRFS_BALANCE_ARGS_USAGE) &&
	    chunk_usage_filter(bctl->fs_info, chunk_offset, bargs)) {
		return 0;
I
Ilya Dryomov 已提交
2958 2959 2960 2961 2962 2963
	}

	/* devid filter */
	if ((bargs->flags & BTRFS_BALANCE_ARGS_DEVID) &&
	    chunk_devid_filter(leaf, chunk, bargs)) {
		return 0;
I
Ilya Dryomov 已提交
2964 2965 2966 2967 2968 2969
	}

	/* drange filter, makes sense only with devid filter */
	if ((bargs->flags & BTRFS_BALANCE_ARGS_DRANGE) &&
	    chunk_drange_filter(leaf, chunk, chunk_offset, bargs)) {
		return 0;
2970 2971 2972 2973 2974 2975
	}

	/* vrange filter */
	if ((bargs->flags & BTRFS_BALANCE_ARGS_VRANGE) &&
	    chunk_vrange_filter(leaf, chunk, chunk_offset, bargs)) {
		return 0;
I
Ilya Dryomov 已提交
2976 2977
	}

2978 2979 2980 2981 2982 2983
	/* soft profile changing mode */
	if ((bargs->flags & BTRFS_BALANCE_ARGS_SOFT) &&
	    chunk_soft_convert_filter(chunk_type, bargs)) {
		return 0;
	}

2984 2985 2986 2987 2988 2989 2990 2991 2992 2993
	/*
	 * limited by count, must be the last filter
	 */
	if ((bargs->flags & BTRFS_BALANCE_ARGS_LIMIT)) {
		if (bargs->limit == 0)
			return 0;
		else
			bargs->limit--;
	}

2994 2995 2996
	return 1;
}

2997
static int __btrfs_balance(struct btrfs_fs_info *fs_info)
2998
{
2999
	struct btrfs_balance_control *bctl = fs_info->balance_ctl;
3000 3001 3002
	struct btrfs_root *chunk_root = fs_info->chunk_root;
	struct btrfs_root *dev_root = fs_info->dev_root;
	struct list_head *devices;
3003 3004 3005
	struct btrfs_device *device;
	u64 old_size;
	u64 size_to_free;
3006
	struct btrfs_chunk *chunk;
3007 3008 3009
	struct btrfs_path *path;
	struct btrfs_key key;
	struct btrfs_key found_key;
3010
	struct btrfs_trans_handle *trans;
3011 3012
	struct extent_buffer *leaf;
	int slot;
3013 3014
	int ret;
	int enospc_errors = 0;
3015
	bool counting = true;
3016 3017 3018
	u64 limit_data = bctl->data.limit;
	u64 limit_meta = bctl->meta.limit;
	u64 limit_sys = bctl->sys.limit;
3019 3020

	/* step one make some room on all the devices */
3021
	devices = &fs_info->fs_devices->devices;
3022
	list_for_each_entry(device, devices, dev_list) {
3023 3024 3025
		old_size = device->total_bytes;
		size_to_free = div_factor(old_size, 1);
		size_to_free = min(size_to_free, (u64)1 * 1024 * 1024);
Y
Yan Zheng 已提交
3026
		if (!device->writeable ||
3027 3028
		    device->total_bytes - device->bytes_used > size_to_free ||
		    device->is_tgtdev_for_dev_replace)
3029 3030 3031
			continue;

		ret = btrfs_shrink_device(device, old_size - size_to_free);
3032 3033
		if (ret == -ENOSPC)
			break;
3034 3035
		BUG_ON(ret);

3036
		trans = btrfs_start_transaction(dev_root, 0);
3037
		BUG_ON(IS_ERR(trans));
3038 3039 3040 3041 3042 3043 3044 3045 3046

		ret = btrfs_grow_device(trans, device, old_size);
		BUG_ON(ret);

		btrfs_end_transaction(trans, dev_root);
	}

	/* step two, relocate all the chunks */
	path = btrfs_alloc_path();
3047 3048 3049 3050
	if (!path) {
		ret = -ENOMEM;
		goto error;
	}
3051 3052 3053 3054 3055 3056

	/* zero out stat counters */
	spin_lock(&fs_info->balance_lock);
	memset(&bctl->stat, 0, sizeof(bctl->stat));
	spin_unlock(&fs_info->balance_lock);
again:
3057 3058 3059 3060 3061
	if (!counting) {
		bctl->data.limit = limit_data;
		bctl->meta.limit = limit_meta;
		bctl->sys.limit = limit_sys;
	}
3062 3063 3064 3065
	key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
	key.offset = (u64)-1;
	key.type = BTRFS_CHUNK_ITEM_KEY;

3066
	while (1) {
3067
		if ((!counting && atomic_read(&fs_info->balance_pause_req)) ||
3068
		    atomic_read(&fs_info->balance_cancel_req)) {
3069 3070 3071 3072
			ret = -ECANCELED;
			goto error;
		}

3073 3074 3075 3076 3077 3078 3079 3080 3081
		ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0);
		if (ret < 0)
			goto error;

		/*
		 * this shouldn't happen, it means the last relocate
		 * failed
		 */
		if (ret == 0)
3082
			BUG(); /* FIXME break ? */
3083 3084 3085

		ret = btrfs_previous_item(chunk_root, path, 0,
					  BTRFS_CHUNK_ITEM_KEY);
3086 3087
		if (ret) {
			ret = 0;
3088
			break;
3089
		}
3090

3091 3092 3093
		leaf = path->nodes[0];
		slot = path->slots[0];
		btrfs_item_key_to_cpu(leaf, &found_key, slot);
3094

3095 3096
		if (found_key.objectid != key.objectid)
			break;
3097

3098 3099
		chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);

3100 3101 3102 3103 3104 3105
		if (!counting) {
			spin_lock(&fs_info->balance_lock);
			bctl->stat.considered++;
			spin_unlock(&fs_info->balance_lock);
		}

3106 3107
		ret = should_balance_chunk(chunk_root, leaf, chunk,
					   found_key.offset);
3108
		btrfs_release_path(path);
3109 3110 3111
		if (!ret)
			goto loop;

3112 3113 3114 3115 3116 3117 3118
		if (counting) {
			spin_lock(&fs_info->balance_lock);
			bctl->stat.expected++;
			spin_unlock(&fs_info->balance_lock);
			goto loop;
		}

3119 3120 3121 3122
		ret = btrfs_relocate_chunk(chunk_root,
					   chunk_root->root_key.objectid,
					   found_key.objectid,
					   found_key.offset);
3123 3124
		if (ret && ret != -ENOSPC)
			goto error;
3125
		if (ret == -ENOSPC) {
3126
			enospc_errors++;
3127 3128 3129 3130 3131
		} else {
			spin_lock(&fs_info->balance_lock);
			bctl->stat.completed++;
			spin_unlock(&fs_info->balance_lock);
		}
3132
loop:
3133 3134
		if (found_key.offset == 0)
			break;
3135
		key.offset = found_key.offset - 1;
3136
	}
3137

3138 3139 3140 3141 3142
	if (counting) {
		btrfs_release_path(path);
		counting = false;
		goto again;
	}
3143 3144
error:
	btrfs_free_path(path);
3145
	if (enospc_errors) {
3146
		btrfs_info(fs_info, "%d enospc errors during balance",
3147 3148 3149 3150 3151
		       enospc_errors);
		if (!ret)
			ret = -ENOSPC;
	}

3152 3153 3154
	return ret;
}

3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178
/**
 * alloc_profile_is_valid - see if a given profile is valid and reduced
 * @flags: profile to validate
 * @extended: if true @flags is treated as an extended profile
 */
static int alloc_profile_is_valid(u64 flags, int extended)
{
	u64 mask = (extended ? BTRFS_EXTENDED_PROFILE_MASK :
			       BTRFS_BLOCK_GROUP_PROFILE_MASK);

	flags &= ~BTRFS_BLOCK_GROUP_TYPE_MASK;

	/* 1) check that all other bits are zeroed */
	if (flags & ~mask)
		return 0;

	/* 2) see if profile is reduced */
	if (flags == 0)
		return !extended; /* "0" is valid for usual profiles */

	/* true if exactly one bit set */
	return (flags & (flags - 1)) == 0;
}

3179 3180
static inline int balance_need_close(struct btrfs_fs_info *fs_info)
{
3181 3182 3183 3184
	/* cancel requested || normal exit path */
	return atomic_read(&fs_info->balance_cancel_req) ||
		(atomic_read(&fs_info->balance_pause_req) == 0 &&
		 atomic_read(&fs_info->balance_cancel_req) == 0);
3185 3186
}

3187 3188
static void __cancel_balance(struct btrfs_fs_info *fs_info)
{
3189 3190
	int ret;

3191
	unset_balance_control(fs_info);
3192
	ret = del_balance_item(fs_info->tree_root);
3193 3194
	if (ret)
		btrfs_std_error(fs_info, ret);
3195 3196

	atomic_set(&fs_info->mutually_exclusive_operation_running, 0);
3197 3198 3199 3200 3201 3202 3203 3204 3205
}

/*
 * Should be called with both balance and volume mutexes held
 */
int btrfs_balance(struct btrfs_balance_control *bctl,
		  struct btrfs_ioctl_balance_args *bargs)
{
	struct btrfs_fs_info *fs_info = bctl->fs_info;
3206
	u64 allowed;
3207
	int mixed = 0;
3208
	int ret;
3209
	u64 num_devices;
3210
	unsigned seq;
3211

3212
	if (btrfs_fs_closing(fs_info) ||
3213 3214
	    atomic_read(&fs_info->balance_pause_req) ||
	    atomic_read(&fs_info->balance_cancel_req)) {
3215 3216 3217 3218
		ret = -EINVAL;
		goto out;
	}

3219 3220 3221 3222
	allowed = btrfs_super_incompat_flags(fs_info->super_copy);
	if (allowed & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS)
		mixed = 1;

3223 3224 3225 3226
	/*
	 * In case of mixed groups both data and meta should be picked,
	 * and identical options should be given for both of them.
	 */
3227 3228
	allowed = BTRFS_BALANCE_DATA | BTRFS_BALANCE_METADATA;
	if (mixed && (bctl->flags & allowed)) {
3229 3230 3231
		if (!(bctl->flags & BTRFS_BALANCE_DATA) ||
		    !(bctl->flags & BTRFS_BALANCE_METADATA) ||
		    memcmp(&bctl->data, &bctl->meta, sizeof(bctl->data))) {
3232 3233
			btrfs_err(fs_info, "with mixed groups data and "
				   "metadata balance options must be the same");
3234 3235 3236 3237 3238
			ret = -EINVAL;
			goto out;
		}
	}

3239 3240 3241 3242 3243 3244 3245
	num_devices = fs_info->fs_devices->num_devices;
	btrfs_dev_replace_lock(&fs_info->dev_replace);
	if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace)) {
		BUG_ON(num_devices < 1);
		num_devices--;
	}
	btrfs_dev_replace_unlock(&fs_info->dev_replace);
3246
	allowed = BTRFS_AVAIL_ALLOC_BIT_SINGLE;
3247
	if (num_devices == 1)
3248
		allowed |= BTRFS_BLOCK_GROUP_DUP;
3249
	else if (num_devices > 1)
3250
		allowed |= (BTRFS_BLOCK_GROUP_RAID0 | BTRFS_BLOCK_GROUP_RAID1);
3251 3252 3253 3254 3255
	if (num_devices > 2)
		allowed |= BTRFS_BLOCK_GROUP_RAID5;
	if (num_devices > 3)
		allowed |= (BTRFS_BLOCK_GROUP_RAID10 |
			    BTRFS_BLOCK_GROUP_RAID6);
3256 3257 3258
	if ((bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
	    (!alloc_profile_is_valid(bctl->data.target, 1) ||
	     (bctl->data.target & ~allowed))) {
3259 3260
		btrfs_err(fs_info, "unable to start balance with target "
			   "data profile %llu",
3261
		       bctl->data.target);
3262 3263 3264
		ret = -EINVAL;
		goto out;
	}
3265 3266 3267
	if ((bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
	    (!alloc_profile_is_valid(bctl->meta.target, 1) ||
	     (bctl->meta.target & ~allowed))) {
3268 3269
		btrfs_err(fs_info,
			   "unable to start balance with target metadata profile %llu",
3270
		       bctl->meta.target);
3271 3272 3273
		ret = -EINVAL;
		goto out;
	}
3274 3275 3276
	if ((bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
	    (!alloc_profile_is_valid(bctl->sys.target, 1) ||
	     (bctl->sys.target & ~allowed))) {
3277 3278
		btrfs_err(fs_info,
			   "unable to start balance with target system profile %llu",
3279
		       bctl->sys.target);
3280 3281 3282 3283
		ret = -EINVAL;
		goto out;
	}

3284 3285
	/* allow dup'ed data chunks only in mixed mode */
	if (!mixed && (bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
3286
	    (bctl->data.target & BTRFS_BLOCK_GROUP_DUP)) {
3287
		btrfs_err(fs_info, "dup for data is not allowed");
3288 3289 3290 3291 3292 3293
		ret = -EINVAL;
		goto out;
	}

	/* allow to reduce meta or sys integrity only if force set */
	allowed = BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID1 |
D
David Woodhouse 已提交
3294 3295 3296
			BTRFS_BLOCK_GROUP_RAID10 |
			BTRFS_BLOCK_GROUP_RAID5 |
			BTRFS_BLOCK_GROUP_RAID6;
3297 3298 3299 3300 3301 3302 3303 3304 3305 3306
	do {
		seq = read_seqbegin(&fs_info->profiles_lock);

		if (((bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
		     (fs_info->avail_system_alloc_bits & allowed) &&
		     !(bctl->sys.target & allowed)) ||
		    ((bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
		     (fs_info->avail_metadata_alloc_bits & allowed) &&
		     !(bctl->meta.target & allowed))) {
			if (bctl->flags & BTRFS_BALANCE_FORCE) {
3307
				btrfs_info(fs_info, "force reducing metadata integrity");
3308
			} else {
3309 3310
				btrfs_err(fs_info, "balance will reduce metadata "
					   "integrity, use force if you want this");
3311 3312 3313
				ret = -EINVAL;
				goto out;
			}
3314
		}
3315
	} while (read_seqretry(&fs_info->profiles_lock, seq));
3316

3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336
	if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) {
		int num_tolerated_disk_barrier_failures;
		u64 target = bctl->sys.target;

		num_tolerated_disk_barrier_failures =
			btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
		if (num_tolerated_disk_barrier_failures > 0 &&
		    (target &
		     (BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID0 |
		      BTRFS_AVAIL_ALLOC_BIT_SINGLE)))
			num_tolerated_disk_barrier_failures = 0;
		else if (num_tolerated_disk_barrier_failures > 1 &&
			 (target &
			  (BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID10)))
			num_tolerated_disk_barrier_failures = 1;

		fs_info->num_tolerated_disk_barrier_failures =
			num_tolerated_disk_barrier_failures;
	}

3337
	ret = insert_balance_item(fs_info->tree_root, bctl);
3338
	if (ret && ret != -EEXIST)
3339 3340
		goto out;

3341 3342 3343 3344 3345 3346 3347 3348 3349
	if (!(bctl->flags & BTRFS_BALANCE_RESUME)) {
		BUG_ON(ret == -EEXIST);
		set_balance_control(bctl);
	} else {
		BUG_ON(ret != -EEXIST);
		spin_lock(&fs_info->balance_lock);
		update_balance_args(bctl);
		spin_unlock(&fs_info->balance_lock);
	}
3350

3351
	atomic_inc(&fs_info->balance_running);
3352 3353 3354 3355 3356
	mutex_unlock(&fs_info->balance_mutex);

	ret = __btrfs_balance(fs_info);

	mutex_lock(&fs_info->balance_mutex);
3357
	atomic_dec(&fs_info->balance_running);
3358

3359 3360 3361 3362 3363
	if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) {
		fs_info->num_tolerated_disk_barrier_failures =
			btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
	}

3364 3365
	if (bargs) {
		memset(bargs, 0, sizeof(*bargs));
3366
		update_ioctl_balance_args(fs_info, 0, bargs);
3367 3368
	}

3369 3370 3371 3372 3373
	if ((ret && ret != -ECANCELED && ret != -ENOSPC) ||
	    balance_need_close(fs_info)) {
		__cancel_balance(fs_info);
	}

3374
	wake_up(&fs_info->balance_wait_q);
3375 3376 3377

	return ret;
out:
3378 3379
	if (bctl->flags & BTRFS_BALANCE_RESUME)
		__cancel_balance(fs_info);
3380
	else {
3381
		kfree(bctl);
3382 3383
		atomic_set(&fs_info->mutually_exclusive_operation_running, 0);
	}
3384 3385 3386 3387 3388
	return ret;
}

static int balance_kthread(void *data)
{
3389
	struct btrfs_fs_info *fs_info = data;
3390
	int ret = 0;
3391 3392 3393 3394

	mutex_lock(&fs_info->volume_mutex);
	mutex_lock(&fs_info->balance_mutex);

3395
	if (fs_info->balance_ctl) {
3396
		btrfs_info(fs_info, "continuing balance");
3397
		ret = btrfs_balance(fs_info->balance_ctl, NULL);
3398
	}
3399 3400 3401

	mutex_unlock(&fs_info->balance_mutex);
	mutex_unlock(&fs_info->volume_mutex);
3402

3403 3404 3405
	return ret;
}

3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417
int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info)
{
	struct task_struct *tsk;

	spin_lock(&fs_info->balance_lock);
	if (!fs_info->balance_ctl) {
		spin_unlock(&fs_info->balance_lock);
		return 0;
	}
	spin_unlock(&fs_info->balance_lock);

	if (btrfs_test_opt(fs_info->tree_root, SKIP_BALANCE)) {
3418
		btrfs_info(fs_info, "force skipping balance");
3419 3420 3421 3422
		return 0;
	}

	tsk = kthread_run(balance_kthread, fs_info, "btrfs-balance");
3423
	return PTR_ERR_OR_ZERO(tsk);
3424 3425
}

3426
int btrfs_recover_balance(struct btrfs_fs_info *fs_info)
3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443
{
	struct btrfs_balance_control *bctl;
	struct btrfs_balance_item *item;
	struct btrfs_disk_balance_args disk_bargs;
	struct btrfs_path *path;
	struct extent_buffer *leaf;
	struct btrfs_key key;
	int ret;

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

	key.objectid = BTRFS_BALANCE_OBJECTID;
	key.type = BTRFS_BALANCE_ITEM_KEY;
	key.offset = 0;

3444
	ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);
3445
	if (ret < 0)
3446
		goto out;
3447 3448
	if (ret > 0) { /* ret = -ENOENT; */
		ret = 0;
3449 3450 3451 3452 3453 3454 3455
		goto out;
	}

	bctl = kzalloc(sizeof(*bctl), GFP_NOFS);
	if (!bctl) {
		ret = -ENOMEM;
		goto out;
3456 3457 3458 3459 3460
	}

	leaf = path->nodes[0];
	item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item);

3461 3462 3463
	bctl->fs_info = fs_info;
	bctl->flags = btrfs_balance_flags(leaf, item);
	bctl->flags |= BTRFS_BALANCE_RESUME;
3464 3465 3466 3467 3468 3469 3470 3471

	btrfs_balance_data(leaf, item, &disk_bargs);
	btrfs_disk_balance_args_to_cpu(&bctl->data, &disk_bargs);
	btrfs_balance_meta(leaf, item, &disk_bargs);
	btrfs_disk_balance_args_to_cpu(&bctl->meta, &disk_bargs);
	btrfs_balance_sys(leaf, item, &disk_bargs);
	btrfs_disk_balance_args_to_cpu(&bctl->sys, &disk_bargs);

3472 3473
	WARN_ON(atomic_xchg(&fs_info->mutually_exclusive_operation_running, 1));

3474 3475
	mutex_lock(&fs_info->volume_mutex);
	mutex_lock(&fs_info->balance_mutex);
3476

3477 3478 3479 3480
	set_balance_control(bctl);

	mutex_unlock(&fs_info->balance_mutex);
	mutex_unlock(&fs_info->volume_mutex);
3481 3482
out:
	btrfs_free_path(path);
3483 3484 3485
	return ret;
}

3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514
int btrfs_pause_balance(struct btrfs_fs_info *fs_info)
{
	int ret = 0;

	mutex_lock(&fs_info->balance_mutex);
	if (!fs_info->balance_ctl) {
		mutex_unlock(&fs_info->balance_mutex);
		return -ENOTCONN;
	}

	if (atomic_read(&fs_info->balance_running)) {
		atomic_inc(&fs_info->balance_pause_req);
		mutex_unlock(&fs_info->balance_mutex);

		wait_event(fs_info->balance_wait_q,
			   atomic_read(&fs_info->balance_running) == 0);

		mutex_lock(&fs_info->balance_mutex);
		/* we are good with balance_ctl ripped off from under us */
		BUG_ON(atomic_read(&fs_info->balance_running));
		atomic_dec(&fs_info->balance_pause_req);
	} else {
		ret = -ENOTCONN;
	}

	mutex_unlock(&fs_info->balance_mutex);
	return ret;
}

3515 3516
int btrfs_cancel_balance(struct btrfs_fs_info *fs_info)
{
3517 3518 3519
	if (fs_info->sb->s_flags & MS_RDONLY)
		return -EROFS;

3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553
	mutex_lock(&fs_info->balance_mutex);
	if (!fs_info->balance_ctl) {
		mutex_unlock(&fs_info->balance_mutex);
		return -ENOTCONN;
	}

	atomic_inc(&fs_info->balance_cancel_req);
	/*
	 * if we are running just wait and return, balance item is
	 * deleted in btrfs_balance in this case
	 */
	if (atomic_read(&fs_info->balance_running)) {
		mutex_unlock(&fs_info->balance_mutex);
		wait_event(fs_info->balance_wait_q,
			   atomic_read(&fs_info->balance_running) == 0);
		mutex_lock(&fs_info->balance_mutex);
	} else {
		/* __cancel_balance needs volume_mutex */
		mutex_unlock(&fs_info->balance_mutex);
		mutex_lock(&fs_info->volume_mutex);
		mutex_lock(&fs_info->balance_mutex);

		if (fs_info->balance_ctl)
			__cancel_balance(fs_info);

		mutex_unlock(&fs_info->volume_mutex);
	}

	BUG_ON(fs_info->balance_ctl || atomic_read(&fs_info->balance_running));
	atomic_dec(&fs_info->balance_cancel_req);
	mutex_unlock(&fs_info->balance_mutex);
	return 0;
}

3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565
static int btrfs_uuid_scan_kthread(void *data)
{
	struct btrfs_fs_info *fs_info = data;
	struct btrfs_root *root = fs_info->tree_root;
	struct btrfs_key key;
	struct btrfs_key max_key;
	struct btrfs_path *path = NULL;
	int ret = 0;
	struct extent_buffer *eb;
	int slot;
	struct btrfs_root_item root_item;
	u32 item_size;
3566
	struct btrfs_trans_handle *trans = NULL;
3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584

	path = btrfs_alloc_path();
	if (!path) {
		ret = -ENOMEM;
		goto out;
	}

	key.objectid = 0;
	key.type = BTRFS_ROOT_ITEM_KEY;
	key.offset = 0;

	max_key.objectid = (u64)-1;
	max_key.type = BTRFS_ROOT_ITEM_KEY;
	max_key.offset = (u64)-1;

	path->keep_locks = 1;

	while (1) {
3585
		ret = btrfs_search_forward(root, &key, path, 0);
3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608
		if (ret) {
			if (ret > 0)
				ret = 0;
			break;
		}

		if (key.type != BTRFS_ROOT_ITEM_KEY ||
		    (key.objectid < BTRFS_FIRST_FREE_OBJECTID &&
		     key.objectid != BTRFS_FS_TREE_OBJECTID) ||
		    key.objectid > BTRFS_LAST_FREE_OBJECTID)
			goto skip;

		eb = path->nodes[0];
		slot = path->slots[0];
		item_size = btrfs_item_size_nr(eb, slot);
		if (item_size < sizeof(root_item))
			goto skip;

		read_extent_buffer(eb, &root_item,
				   btrfs_item_ptr_offset(eb, slot),
				   (int)sizeof(root_item));
		if (btrfs_root_refs(&root_item) == 0)
			goto skip;
3609 3610 3611 3612 3613 3614 3615

		if (!btrfs_is_empty_uuid(root_item.uuid) ||
		    !btrfs_is_empty_uuid(root_item.received_uuid)) {
			if (trans)
				goto update_tree;

			btrfs_release_path(path);
3616 3617 3618 3619 3620 3621 3622 3623 3624
			/*
			 * 1 - subvol uuid item
			 * 1 - received_subvol uuid item
			 */
			trans = btrfs_start_transaction(fs_info->uuid_root, 2);
			if (IS_ERR(trans)) {
				ret = PTR_ERR(trans);
				break;
			}
3625 3626 3627 3628 3629 3630
			continue;
		} else {
			goto skip;
		}
update_tree:
		if (!btrfs_is_empty_uuid(root_item.uuid)) {
3631 3632 3633 3634 3635
			ret = btrfs_uuid_tree_add(trans, fs_info->uuid_root,
						  root_item.uuid,
						  BTRFS_UUID_KEY_SUBVOL,
						  key.objectid);
			if (ret < 0) {
3636
				btrfs_warn(fs_info, "uuid_tree_add failed %d",
3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647
					ret);
				break;
			}
		}

		if (!btrfs_is_empty_uuid(root_item.received_uuid)) {
			ret = btrfs_uuid_tree_add(trans, fs_info->uuid_root,
						  root_item.received_uuid,
						 BTRFS_UUID_KEY_RECEIVED_SUBVOL,
						  key.objectid);
			if (ret < 0) {
3648
				btrfs_warn(fs_info, "uuid_tree_add failed %d",
3649 3650 3651 3652 3653
					ret);
				break;
			}
		}

3654
skip:
3655 3656
		if (trans) {
			ret = btrfs_end_transaction(trans, fs_info->uuid_root);
3657
			trans = NULL;
3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679
			if (ret)
				break;
		}

		btrfs_release_path(path);
		if (key.offset < (u64)-1) {
			key.offset++;
		} else if (key.type < BTRFS_ROOT_ITEM_KEY) {
			key.offset = 0;
			key.type = BTRFS_ROOT_ITEM_KEY;
		} else if (key.objectid < (u64)-1) {
			key.offset = 0;
			key.type = BTRFS_ROOT_ITEM_KEY;
			key.objectid++;
		} else {
			break;
		}
		cond_resched();
	}

out:
	btrfs_free_path(path);
3680 3681
	if (trans && !IS_ERR(trans))
		btrfs_end_transaction(trans, fs_info->uuid_root);
3682
	if (ret)
3683
		btrfs_warn(fs_info, "btrfs_uuid_scan_kthread failed %d", ret);
3684 3685
	else
		fs_info->update_uuid_tree_gen = 1;
3686 3687 3688 3689
	up(&fs_info->uuid_tree_rescan_sem);
	return 0;
}

3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746
/*
 * Callback for btrfs_uuid_tree_iterate().
 * returns:
 * 0	check succeeded, the entry is not outdated.
 * < 0	if an error occured.
 * > 0	if the check failed, which means the caller shall remove the entry.
 */
static int btrfs_check_uuid_tree_entry(struct btrfs_fs_info *fs_info,
				       u8 *uuid, u8 type, u64 subid)
{
	struct btrfs_key key;
	int ret = 0;
	struct btrfs_root *subvol_root;

	if (type != BTRFS_UUID_KEY_SUBVOL &&
	    type != BTRFS_UUID_KEY_RECEIVED_SUBVOL)
		goto out;

	key.objectid = subid;
	key.type = BTRFS_ROOT_ITEM_KEY;
	key.offset = (u64)-1;
	subvol_root = btrfs_read_fs_root_no_name(fs_info, &key);
	if (IS_ERR(subvol_root)) {
		ret = PTR_ERR(subvol_root);
		if (ret == -ENOENT)
			ret = 1;
		goto out;
	}

	switch (type) {
	case BTRFS_UUID_KEY_SUBVOL:
		if (memcmp(uuid, subvol_root->root_item.uuid, BTRFS_UUID_SIZE))
			ret = 1;
		break;
	case BTRFS_UUID_KEY_RECEIVED_SUBVOL:
		if (memcmp(uuid, subvol_root->root_item.received_uuid,
			   BTRFS_UUID_SIZE))
			ret = 1;
		break;
	}

out:
	return ret;
}

static int btrfs_uuid_rescan_kthread(void *data)
{
	struct btrfs_fs_info *fs_info = (struct btrfs_fs_info *)data;
	int ret;

	/*
	 * 1st step is to iterate through the existing UUID tree and
	 * to delete all entries that contain outdated data.
	 * 2nd step is to add all missing entries to the UUID tree.
	 */
	ret = btrfs_uuid_tree_iterate(fs_info, btrfs_check_uuid_tree_entry);
	if (ret < 0) {
3747
		btrfs_warn(fs_info, "iterating uuid_tree failed %d", ret);
3748 3749 3750 3751 3752 3753
		up(&fs_info->uuid_tree_rescan_sem);
		return ret;
	}
	return btrfs_uuid_scan_kthread(data);
}

3754 3755 3756 3757 3758
int btrfs_create_uuid_tree(struct btrfs_fs_info *fs_info)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *tree_root = fs_info->tree_root;
	struct btrfs_root *uuid_root;
3759 3760
	struct task_struct *task;
	int ret;
3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779

	/*
	 * 1 - root node
	 * 1 - root item
	 */
	trans = btrfs_start_transaction(tree_root, 2);
	if (IS_ERR(trans))
		return PTR_ERR(trans);

	uuid_root = btrfs_create_tree(trans, fs_info,
				      BTRFS_UUID_TREE_OBJECTID);
	if (IS_ERR(uuid_root)) {
		btrfs_abort_transaction(trans, tree_root,
					PTR_ERR(uuid_root));
		return PTR_ERR(uuid_root);
	}

	fs_info->uuid_root = uuid_root;

3780 3781 3782 3783 3784 3785 3786
	ret = btrfs_commit_transaction(trans, tree_root);
	if (ret)
		return ret;

	down(&fs_info->uuid_tree_rescan_sem);
	task = kthread_run(btrfs_uuid_scan_kthread, fs_info, "btrfs-uuid");
	if (IS_ERR(task)) {
3787
		/* fs_info->update_uuid_tree_gen remains 0 in all error case */
3788
		btrfs_warn(fs_info, "failed to start uuid_scan task");
3789 3790 3791 3792 3793
		up(&fs_info->uuid_tree_rescan_sem);
		return PTR_ERR(task);
	}

	return 0;
3794
}
3795

3796 3797 3798 3799 3800 3801 3802 3803
int btrfs_check_uuid_tree(struct btrfs_fs_info *fs_info)
{
	struct task_struct *task;

	down(&fs_info->uuid_tree_rescan_sem);
	task = kthread_run(btrfs_uuid_rescan_kthread, fs_info, "btrfs-uuid");
	if (IS_ERR(task)) {
		/* fs_info->update_uuid_tree_gen remains 0 in all error case */
3804
		btrfs_warn(fs_info, "failed to start uuid_rescan task");
3805 3806 3807 3808 3809 3810 3811
		up(&fs_info->uuid_tree_rescan_sem);
		return PTR_ERR(task);
	}

	return 0;
}

3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828
/*
 * shrinking a device means finding all of the device extents past
 * the new size, and then following the back refs to the chunks.
 * The chunk relocation code actually frees the device extent
 */
int btrfs_shrink_device(struct btrfs_device *device, u64 new_size)
{
	struct btrfs_trans_handle *trans;
	struct btrfs_root *root = device->dev_root;
	struct btrfs_dev_extent *dev_extent = NULL;
	struct btrfs_path *path;
	u64 length;
	u64 chunk_tree;
	u64 chunk_objectid;
	u64 chunk_offset;
	int ret;
	int slot;
3829 3830
	int failed = 0;
	bool retried = false;
3831 3832
	struct extent_buffer *l;
	struct btrfs_key key;
3833
	struct btrfs_super_block *super_copy = root->fs_info->super_copy;
3834
	u64 old_total = btrfs_super_total_bytes(super_copy);
3835
	u64 old_size = device->total_bytes;
3836 3837
	u64 diff = device->total_bytes - new_size;

3838 3839 3840
	if (device->is_tgtdev_for_dev_replace)
		return -EINVAL;

3841 3842 3843 3844 3845 3846
	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

	path->reada = 2;

3847 3848
	lock_chunks(root);

3849
	device->total_bytes = new_size;
3850
	if (device->writeable) {
Y
Yan Zheng 已提交
3851
		device->fs_devices->total_rw_bytes -= diff;
3852 3853 3854 3855
		spin_lock(&root->fs_info->free_chunk_lock);
		root->fs_info->free_chunk_space -= diff;
		spin_unlock(&root->fs_info->free_chunk_lock);
	}
3856
	unlock_chunks(root);
3857

3858
again:
3859 3860 3861 3862
	key.objectid = device->devid;
	key.offset = (u64)-1;
	key.type = BTRFS_DEV_EXTENT_KEY;

3863
	do {
3864 3865 3866 3867 3868 3869 3870 3871 3872
		ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
		if (ret < 0)
			goto done;

		ret = btrfs_previous_item(root, path, 0, key.type);
		if (ret < 0)
			goto done;
		if (ret) {
			ret = 0;
3873
			btrfs_release_path(path);
3874
			break;
3875 3876 3877 3878 3879 3880
		}

		l = path->nodes[0];
		slot = path->slots[0];
		btrfs_item_key_to_cpu(l, &key, path->slots[0]);

3881
		if (key.objectid != device->devid) {
3882
			btrfs_release_path(path);
3883
			break;
3884
		}
3885 3886 3887 3888

		dev_extent = btrfs_item_ptr(l, slot, struct btrfs_dev_extent);
		length = btrfs_dev_extent_length(l, dev_extent);

3889
		if (key.offset + length <= new_size) {
3890
			btrfs_release_path(path);
3891
			break;
3892
		}
3893 3894 3895 3896

		chunk_tree = btrfs_dev_extent_chunk_tree(l, dev_extent);
		chunk_objectid = btrfs_dev_extent_chunk_objectid(l, dev_extent);
		chunk_offset = btrfs_dev_extent_chunk_offset(l, dev_extent);
3897
		btrfs_release_path(path);
3898 3899 3900

		ret = btrfs_relocate_chunk(root, chunk_tree, chunk_objectid,
					   chunk_offset);
3901
		if (ret && ret != -ENOSPC)
3902
			goto done;
3903 3904
		if (ret == -ENOSPC)
			failed++;
3905
	} while (key.offset-- > 0);
3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917

	if (failed && !retried) {
		failed = 0;
		retried = true;
		goto again;
	} else if (failed && retried) {
		ret = -ENOSPC;
		lock_chunks(root);

		device->total_bytes = old_size;
		if (device->writeable)
			device->fs_devices->total_rw_bytes += diff;
3918 3919 3920
		spin_lock(&root->fs_info->free_chunk_lock);
		root->fs_info->free_chunk_space += diff;
		spin_unlock(&root->fs_info->free_chunk_lock);
3921 3922
		unlock_chunks(root);
		goto done;
3923 3924
	}

3925
	/* Shrinking succeeded, else we would be at "done". */
3926
	trans = btrfs_start_transaction(root, 0);
3927 3928 3929 3930 3931
	if (IS_ERR(trans)) {
		ret = PTR_ERR(trans);
		goto done;
	}

3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945
	lock_chunks(root);

	device->disk_total_bytes = new_size;
	/* Now btrfs_update_device() will change the on-disk size. */
	ret = btrfs_update_device(trans, device);
	if (ret) {
		unlock_chunks(root);
		btrfs_end_transaction(trans, root);
		goto done;
	}
	WARN_ON(diff > old_total);
	btrfs_set_super_total_bytes(super_copy, old_total - diff);
	unlock_chunks(root);
	btrfs_end_transaction(trans, root);
3946 3947 3948 3949 3950
done:
	btrfs_free_path(path);
	return ret;
}

3951
static int btrfs_add_system_chunk(struct btrfs_root *root,
3952 3953 3954
			   struct btrfs_key *key,
			   struct btrfs_chunk *chunk, int item_size)
{
3955
	struct btrfs_super_block *super_copy = root->fs_info->super_copy;
3956 3957 3958 3959 3960
	struct btrfs_disk_key disk_key;
	u32 array_size;
	u8 *ptr;

	array_size = btrfs_super_sys_array_size(super_copy);
3961 3962
	if (array_size + item_size + sizeof(disk_key)
			> BTRFS_SYSTEM_CHUNK_ARRAY_SIZE)
3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974
		return -EFBIG;

	ptr = super_copy->sys_chunk_array + array_size;
	btrfs_cpu_key_to_disk(&disk_key, key);
	memcpy(ptr, &disk_key, sizeof(disk_key));
	ptr += sizeof(disk_key);
	memcpy(ptr, chunk, item_size);
	item_size += sizeof(disk_key);
	btrfs_set_super_sys_array_size(super_copy, array_size + item_size);
	return 0;
}

3975 3976 3977 3978
/*
 * sort the devices in descending order by max_avail, total_avail
 */
static int btrfs_cmp_device_info(const void *a, const void *b)
3979
{
3980 3981
	const struct btrfs_device_info *di_a = a;
	const struct btrfs_device_info *di_b = b;
3982

3983
	if (di_a->max_avail > di_b->max_avail)
3984
		return -1;
3985
	if (di_a->max_avail < di_b->max_avail)
3986
		return 1;
3987 3988 3989 3990 3991
	if (di_a->total_avail > di_b->total_avail)
		return -1;
	if (di_a->total_avail < di_b->total_avail)
		return 1;
	return 0;
3992
}
3993

3994
static struct btrfs_raid_attr btrfs_raid_array[BTRFS_NR_RAID_TYPES] = {
3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034
	[BTRFS_RAID_RAID10] = {
		.sub_stripes	= 2,
		.dev_stripes	= 1,
		.devs_max	= 0,	/* 0 == as many as possible */
		.devs_min	= 4,
		.devs_increment	= 2,
		.ncopies	= 2,
	},
	[BTRFS_RAID_RAID1] = {
		.sub_stripes	= 1,
		.dev_stripes	= 1,
		.devs_max	= 2,
		.devs_min	= 2,
		.devs_increment	= 2,
		.ncopies	= 2,
	},
	[BTRFS_RAID_DUP] = {
		.sub_stripes	= 1,
		.dev_stripes	= 2,
		.devs_max	= 1,
		.devs_min	= 1,
		.devs_increment	= 1,
		.ncopies	= 2,
	},
	[BTRFS_RAID_RAID0] = {
		.sub_stripes	= 1,
		.dev_stripes	= 1,
		.devs_max	= 0,
		.devs_min	= 2,
		.devs_increment	= 1,
		.ncopies	= 1,
	},
	[BTRFS_RAID_SINGLE] = {
		.sub_stripes	= 1,
		.dev_stripes	= 1,
		.devs_max	= 1,
		.devs_min	= 1,
		.devs_increment	= 1,
		.ncopies	= 1,
	},
4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050
	[BTRFS_RAID_RAID5] = {
		.sub_stripes	= 1,
		.dev_stripes	= 1,
		.devs_max	= 0,
		.devs_min	= 2,
		.devs_increment	= 1,
		.ncopies	= 2,
	},
	[BTRFS_RAID_RAID6] = {
		.sub_stripes	= 1,
		.dev_stripes	= 1,
		.devs_max	= 0,
		.devs_min	= 3,
		.devs_increment	= 1,
		.ncopies	= 3,
	},
4051 4052
};

D
David Woodhouse 已提交
4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063
static u32 find_raid56_stripe_len(u32 data_devices, u32 dev_stripe_target)
{
	/* TODO allow them to set a preferred stripe size */
	return 64 * 1024;
}

static void check_raid56_incompat_flag(struct btrfs_fs_info *info, u64 type)
{
	if (!(type & (BTRFS_BLOCK_GROUP_RAID5 | BTRFS_BLOCK_GROUP_RAID6)))
		return;

4064
	btrfs_set_fs_incompat(info, RAID56);
D
David Woodhouse 已提交
4065 4066
}

4067 4068 4069 4070 4071 4072 4073 4074 4075 4076
#define BTRFS_MAX_DEVS(r) ((BTRFS_LEAF_DATA_SIZE(r)		\
			- sizeof(struct btrfs_item)		\
			- sizeof(struct btrfs_chunk))		\
			/ sizeof(struct btrfs_stripe) + 1)

#define BTRFS_MAX_DEVS_SYS_CHUNK ((BTRFS_SYSTEM_CHUNK_ARRAY_SIZE	\
				- 2 * sizeof(struct btrfs_disk_key)	\
				- 2 * sizeof(struct btrfs_chunk))	\
				/ sizeof(struct btrfs_stripe) + 1)

4077
static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
4078 4079
			       struct btrfs_root *extent_root, u64 start,
			       u64 type)
4080
{
4081 4082 4083 4084 4085 4086 4087 4088 4089
	struct btrfs_fs_info *info = extent_root->fs_info;
	struct btrfs_fs_devices *fs_devices = info->fs_devices;
	struct list_head *cur;
	struct map_lookup *map = NULL;
	struct extent_map_tree *em_tree;
	struct extent_map *em;
	struct btrfs_device_info *devices_info = NULL;
	u64 total_avail;
	int num_stripes;	/* total number of stripes to allocate */
D
David Woodhouse 已提交
4090 4091
	int data_stripes;	/* number of stripes that count for
				   block group size */
4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102
	int sub_stripes;	/* sub_stripes info for map */
	int dev_stripes;	/* stripes per dev */
	int devs_max;		/* max devs to use */
	int devs_min;		/* min devs needed */
	int devs_increment;	/* ndevs has to be a multiple of this */
	int ncopies;		/* how many copies to data has */
	int ret;
	u64 max_stripe_size;
	u64 max_chunk_size;
	u64 stripe_size;
	u64 num_bytes;
D
David Woodhouse 已提交
4103
	u64 raid_stripe_len = BTRFS_STRIPE_LEN;
4104 4105 4106
	int ndevs;
	int i;
	int j;
4107
	int index;
4108

4109
	BUG_ON(!alloc_profile_is_valid(type, 0));
4110

4111 4112
	if (list_empty(&fs_devices->alloc_list))
		return -ENOSPC;
4113

4114
	index = __get_raid_index(type);
4115

4116 4117 4118 4119 4120 4121
	sub_stripes = btrfs_raid_array[index].sub_stripes;
	dev_stripes = btrfs_raid_array[index].dev_stripes;
	devs_max = btrfs_raid_array[index].devs_max;
	devs_min = btrfs_raid_array[index].devs_min;
	devs_increment = btrfs_raid_array[index].devs_increment;
	ncopies = btrfs_raid_array[index].ncopies;
4122

4123
	if (type & BTRFS_BLOCK_GROUP_DATA) {
4124 4125
		max_stripe_size = 1024 * 1024 * 1024;
		max_chunk_size = 10 * max_stripe_size;
4126 4127
		if (!devs_max)
			devs_max = BTRFS_MAX_DEVS(info->chunk_root);
4128
	} else if (type & BTRFS_BLOCK_GROUP_METADATA) {
4129 4130 4131 4132 4133
		/* for larger filesystems, use larger metadata chunks */
		if (fs_devices->total_rw_bytes > 50ULL * 1024 * 1024 * 1024)
			max_stripe_size = 1024 * 1024 * 1024;
		else
			max_stripe_size = 256 * 1024 * 1024;
4134
		max_chunk_size = max_stripe_size;
4135 4136
		if (!devs_max)
			devs_max = BTRFS_MAX_DEVS(info->chunk_root);
4137
	} else if (type & BTRFS_BLOCK_GROUP_SYSTEM) {
4138
		max_stripe_size = 32 * 1024 * 1024;
4139
		max_chunk_size = 2 * max_stripe_size;
4140 4141
		if (!devs_max)
			devs_max = BTRFS_MAX_DEVS_SYS_CHUNK;
4142
	} else {
4143
		btrfs_err(info, "invalid chunk type 0x%llx requested",
4144 4145
		       type);
		BUG_ON(1);
4146 4147
	}

Y
Yan Zheng 已提交
4148 4149 4150
	/* we don't want a chunk larger than 10% of writeable space */
	max_chunk_size = min(div_factor(fs_devices->total_rw_bytes, 1),
			     max_chunk_size);
4151

4152 4153 4154 4155
	devices_info = kzalloc(sizeof(*devices_info) * fs_devices->rw_devices,
			       GFP_NOFS);
	if (!devices_info)
		return -ENOMEM;
4156

4157
	cur = fs_devices->alloc_list.next;
4158

4159
	/*
4160 4161
	 * in the first pass through the devices list, we gather information
	 * about the available holes on each device.
4162
	 */
4163 4164 4165 4166 4167
	ndevs = 0;
	while (cur != &fs_devices->alloc_list) {
		struct btrfs_device *device;
		u64 max_avail;
		u64 dev_offset;
4168

4169
		device = list_entry(cur, struct btrfs_device, dev_alloc_list);
4170

4171
		cur = cur->next;
4172

4173
		if (!device->writeable) {
J
Julia Lawall 已提交
4174
			WARN(1, KERN_ERR
4175
			       "BTRFS: read-only device in alloc_list\n");
4176 4177
			continue;
		}
4178

4179 4180
		if (!device->in_fs_metadata ||
		    device->is_tgtdev_for_dev_replace)
4181
			continue;
4182

4183 4184 4185 4186
		if (device->total_bytes > device->bytes_used)
			total_avail = device->total_bytes - device->bytes_used;
		else
			total_avail = 0;
4187 4188 4189 4190

		/* If there is no space on this device, skip it. */
		if (total_avail == 0)
			continue;
4191

4192
		ret = find_free_dev_extent(trans, device,
4193 4194 4195 4196
					   max_stripe_size * dev_stripes,
					   &dev_offset, &max_avail);
		if (ret && ret != -ENOSPC)
			goto error;
4197

4198 4199
		if (ret == 0)
			max_avail = max_stripe_size * dev_stripes;
4200

4201 4202
		if (max_avail < BTRFS_STRIPE_LEN * dev_stripes)
			continue;
4203

4204 4205 4206 4207 4208
		if (ndevs == fs_devices->rw_devices) {
			WARN(1, "%s: found more than %llu devices\n",
			     __func__, fs_devices->rw_devices);
			break;
		}
4209 4210 4211 4212 4213 4214
		devices_info[ndevs].dev_offset = dev_offset;
		devices_info[ndevs].max_avail = max_avail;
		devices_info[ndevs].total_avail = total_avail;
		devices_info[ndevs].dev = device;
		++ndevs;
	}
4215

4216 4217 4218 4219 4220
	/*
	 * now sort the devices by hole size / available space
	 */
	sort(devices_info, ndevs, sizeof(struct btrfs_device_info),
	     btrfs_cmp_device_info, NULL);
4221

4222 4223
	/* round down to number of usable stripes */
	ndevs -= ndevs % devs_increment;
4224

4225 4226 4227
	if (ndevs < devs_increment * sub_stripes || ndevs < devs_min) {
		ret = -ENOSPC;
		goto error;
4228
	}
4229

4230 4231 4232 4233 4234 4235 4236 4237
	if (devs_max && ndevs > devs_max)
		ndevs = devs_max;
	/*
	 * the primary goal is to maximize the number of stripes, so use as many
	 * devices as possible, even if the stripes are not maximum sized.
	 */
	stripe_size = devices_info[ndevs-1].max_avail;
	num_stripes = ndevs * dev_stripes;
4238

D
David Woodhouse 已提交
4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254
	/*
	 * this will have to be fixed for RAID1 and RAID10 over
	 * more drives
	 */
	data_stripes = num_stripes / ncopies;

	if (type & BTRFS_BLOCK_GROUP_RAID5) {
		raid_stripe_len = find_raid56_stripe_len(ndevs - 1,
				 btrfs_super_stripesize(info->super_copy));
		data_stripes = num_stripes - 1;
	}
	if (type & BTRFS_BLOCK_GROUP_RAID6) {
		raid_stripe_len = find_raid56_stripe_len(ndevs - 2,
				 btrfs_super_stripesize(info->super_copy));
		data_stripes = num_stripes - 2;
	}
4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275

	/*
	 * Use the number of data stripes to figure out how big this chunk
	 * is really going to be in terms of logical address space,
	 * and compare that answer with the max chunk size
	 */
	if (stripe_size * data_stripes > max_chunk_size) {
		u64 mask = (1ULL << 24) - 1;
		stripe_size = max_chunk_size;
		do_div(stripe_size, data_stripes);

		/* bump the answer up to a 16MB boundary */
		stripe_size = (stripe_size + mask) & ~mask;

		/* but don't go higher than the limits we found
		 * while searching for free extents
		 */
		if (stripe_size > devices_info[ndevs-1].max_avail)
			stripe_size = devices_info[ndevs-1].max_avail;
	}

4276
	do_div(stripe_size, dev_stripes);
4277 4278

	/* align to BTRFS_STRIPE_LEN */
D
David Woodhouse 已提交
4279 4280
	do_div(stripe_size, raid_stripe_len);
	stripe_size *= raid_stripe_len;
4281 4282 4283 4284 4285 4286 4287

	map = kmalloc(map_lookup_size(num_stripes), GFP_NOFS);
	if (!map) {
		ret = -ENOMEM;
		goto error;
	}
	map->num_stripes = num_stripes;
4288

4289 4290 4291 4292 4293 4294
	for (i = 0; i < ndevs; ++i) {
		for (j = 0; j < dev_stripes; ++j) {
			int s = i * dev_stripes + j;
			map->stripes[s].dev = devices_info[i].dev;
			map->stripes[s].physical = devices_info[i].dev_offset +
						   j * stripe_size;
4295 4296
		}
	}
Y
Yan Zheng 已提交
4297
	map->sector_size = extent_root->sectorsize;
D
David Woodhouse 已提交
4298 4299 4300
	map->stripe_len = raid_stripe_len;
	map->io_align = raid_stripe_len;
	map->io_width = raid_stripe_len;
Y
Yan Zheng 已提交
4301 4302
	map->type = type;
	map->sub_stripes = sub_stripes;
4303

D
David Woodhouse 已提交
4304
	num_bytes = stripe_size * data_stripes;
4305

4306
	trace_btrfs_chunk_alloc(info->chunk_root, map, start, num_bytes);
4307

4308
	em = alloc_extent_map();
Y
Yan Zheng 已提交
4309
	if (!em) {
4310
		kfree(map);
4311 4312
		ret = -ENOMEM;
		goto error;
4313
	}
4314
	set_bit(EXTENT_FLAG_FS_MAPPING, &em->flags);
Y
Yan Zheng 已提交
4315 4316
	em->bdev = (struct block_device *)map;
	em->start = start;
4317
	em->len = num_bytes;
Y
Yan Zheng 已提交
4318 4319
	em->block_start = 0;
	em->block_len = em->len;
4320
	em->orig_block_len = stripe_size;
4321

Y
Yan Zheng 已提交
4322
	em_tree = &extent_root->fs_info->mapping_tree.map_tree;
4323
	write_lock(&em_tree->lock);
4324
	ret = add_extent_mapping(em_tree, em, 0);
4325 4326 4327 4328
	if (!ret) {
		list_add_tail(&em->list, &trans->transaction->pending_chunks);
		atomic_inc(&em->refs);
	}
4329
	write_unlock(&em_tree->lock);
4330 4331
	if (ret) {
		free_extent_map(em);
4332
		goto error;
4333
	}
4334

4335 4336 4337
	ret = btrfs_make_block_group(trans, extent_root, 0, type,
				     BTRFS_FIRST_CHUNK_TREE_OBJECTID,
				     start, num_bytes);
4338 4339
	if (ret)
		goto error_del_extent;
Y
Yan Zheng 已提交
4340

4341
	free_extent_map(em);
D
David Woodhouse 已提交
4342 4343
	check_raid56_incompat_flag(extent_root->fs_info, type);

4344
	kfree(devices_info);
Y
Yan Zheng 已提交
4345
	return 0;
4346

4347
error_del_extent:
4348 4349 4350 4351 4352 4353 4354 4355
	write_lock(&em_tree->lock);
	remove_extent_mapping(em_tree, em);
	write_unlock(&em_tree->lock);

	/* One for our allocation */
	free_extent_map(em);
	/* One for the tree reference */
	free_extent_map(em);
4356 4357 4358
error:
	kfree(devices_info);
	return ret;
Y
Yan Zheng 已提交
4359 4360
}

4361
int btrfs_finish_chunk_alloc(struct btrfs_trans_handle *trans,
Y
Yan Zheng 已提交
4362
				struct btrfs_root *extent_root,
4363
				u64 chunk_offset, u64 chunk_size)
Y
Yan Zheng 已提交
4364 4365 4366 4367 4368 4369
{
	struct btrfs_key key;
	struct btrfs_root *chunk_root = extent_root->fs_info->chunk_root;
	struct btrfs_device *device;
	struct btrfs_chunk *chunk;
	struct btrfs_stripe *stripe;
4370 4371 4372 4373 4374 4375 4376
	struct extent_map_tree *em_tree;
	struct extent_map *em;
	struct map_lookup *map;
	size_t item_size;
	u64 dev_offset;
	u64 stripe_size;
	int i = 0;
Y
Yan Zheng 已提交
4377 4378
	int ret;

4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391
	em_tree = &extent_root->fs_info->mapping_tree.map_tree;
	read_lock(&em_tree->lock);
	em = lookup_extent_mapping(em_tree, chunk_offset, chunk_size);
	read_unlock(&em_tree->lock);

	if (!em) {
		btrfs_crit(extent_root->fs_info, "unable to find logical "
			   "%Lu len %Lu", chunk_offset, chunk_size);
		return -EINVAL;
	}

	if (em->start != chunk_offset || em->len != chunk_size) {
		btrfs_crit(extent_root->fs_info, "found a bad mapping, wanted"
4392
			  " %Lu-%Lu, found %Lu-%Lu", chunk_offset,
4393 4394 4395 4396 4397 4398 4399 4400 4401
			  chunk_size, em->start, em->len);
		free_extent_map(em);
		return -EINVAL;
	}

	map = (struct map_lookup *)em->bdev;
	item_size = btrfs_chunk_item_size(map->num_stripes);
	stripe_size = em->orig_block_len;

Y
Yan Zheng 已提交
4402
	chunk = kzalloc(item_size, GFP_NOFS);
4403 4404 4405 4406 4407 4408 4409 4410
	if (!chunk) {
		ret = -ENOMEM;
		goto out;
	}

	for (i = 0; i < map->num_stripes; i++) {
		device = map->stripes[i].dev;
		dev_offset = map->stripes[i].physical;
Y
Yan Zheng 已提交
4411 4412

		device->bytes_used += stripe_size;
4413
		ret = btrfs_update_device(trans, device);
4414
		if (ret)
4415 4416 4417 4418 4419 4420 4421 4422
			goto out;
		ret = btrfs_alloc_dev_extent(trans, device,
					     chunk_root->root_key.objectid,
					     BTRFS_FIRST_CHUNK_TREE_OBJECTID,
					     chunk_offset, dev_offset,
					     stripe_size);
		if (ret)
			goto out;
Y
Yan Zheng 已提交
4423 4424
	}

4425 4426 4427 4428 4429
	spin_lock(&extent_root->fs_info->free_chunk_lock);
	extent_root->fs_info->free_chunk_space -= (stripe_size *
						   map->num_stripes);
	spin_unlock(&extent_root->fs_info->free_chunk_lock);

Y
Yan Zheng 已提交
4430
	stripe = &chunk->stripe;
4431 4432 4433
	for (i = 0; i < map->num_stripes; i++) {
		device = map->stripes[i].dev;
		dev_offset = map->stripes[i].physical;
4434

4435 4436 4437
		btrfs_set_stack_stripe_devid(stripe, device->devid);
		btrfs_set_stack_stripe_offset(stripe, dev_offset);
		memcpy(stripe->dev_uuid, device->uuid, BTRFS_UUID_SIZE);
Y
Yan Zheng 已提交
4438
		stripe++;
4439 4440
	}

Y
Yan Zheng 已提交
4441
	btrfs_set_stack_chunk_length(chunk, chunk_size);
4442
	btrfs_set_stack_chunk_owner(chunk, extent_root->root_key.objectid);
Y
Yan Zheng 已提交
4443 4444 4445 4446 4447
	btrfs_set_stack_chunk_stripe_len(chunk, map->stripe_len);
	btrfs_set_stack_chunk_type(chunk, map->type);
	btrfs_set_stack_chunk_num_stripes(chunk, map->num_stripes);
	btrfs_set_stack_chunk_io_align(chunk, map->stripe_len);
	btrfs_set_stack_chunk_io_width(chunk, map->stripe_len);
4448
	btrfs_set_stack_chunk_sector_size(chunk, extent_root->sectorsize);
Y
Yan Zheng 已提交
4449
	btrfs_set_stack_chunk_sub_stripes(chunk, map->sub_stripes);
4450

Y
Yan Zheng 已提交
4451 4452 4453
	key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
	key.type = BTRFS_CHUNK_ITEM_KEY;
	key.offset = chunk_offset;
4454

Y
Yan Zheng 已提交
4455
	ret = btrfs_insert_item(trans, chunk_root, &key, chunk, item_size);
4456 4457 4458 4459 4460
	if (ret == 0 && map->type & BTRFS_BLOCK_GROUP_SYSTEM) {
		/*
		 * TODO: Cleanup of inserted chunk root in case of
		 * failure.
		 */
4461
		ret = btrfs_add_system_chunk(chunk_root, &key, chunk,
Y
Yan Zheng 已提交
4462
					     item_size);
4463
	}
4464

4465
out:
4466
	kfree(chunk);
4467
	free_extent_map(em);
4468
	return ret;
Y
Yan Zheng 已提交
4469
}
4470

Y
Yan Zheng 已提交
4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482
/*
 * Chunk allocation falls into two parts. The first part does works
 * that make the new allocated chunk useable, but not do any operation
 * that modifies the chunk tree. The second part does the works that
 * require modifying the chunk tree. This division is important for the
 * bootstrap process of adding storage to a seed btrfs.
 */
int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
		      struct btrfs_root *extent_root, u64 type)
{
	u64 chunk_offset;

4483 4484
	chunk_offset = find_next_chunk(extent_root->fs_info);
	return __btrfs_alloc_chunk(trans, extent_root, chunk_offset, type);
Y
Yan Zheng 已提交
4485 4486
}

4487
static noinline int init_first_rw_device(struct btrfs_trans_handle *trans,
Y
Yan Zheng 已提交
4488 4489 4490 4491 4492 4493 4494 4495 4496 4497
					 struct btrfs_root *root,
					 struct btrfs_device *device)
{
	u64 chunk_offset;
	u64 sys_chunk_offset;
	u64 alloc_profile;
	struct btrfs_fs_info *fs_info = root->fs_info;
	struct btrfs_root *extent_root = fs_info->extent_root;
	int ret;

4498
	chunk_offset = find_next_chunk(fs_info);
4499
	alloc_profile = btrfs_get_alloc_profile(extent_root, 0);
4500 4501
	ret = __btrfs_alloc_chunk(trans, extent_root, chunk_offset,
				  alloc_profile);
4502 4503
	if (ret)
		return ret;
Y
Yan Zheng 已提交
4504

4505
	sys_chunk_offset = find_next_chunk(root->fs_info);
4506
	alloc_profile = btrfs_get_alloc_profile(fs_info->chunk_root, 0);
4507 4508
	ret = __btrfs_alloc_chunk(trans, extent_root, sys_chunk_offset,
				  alloc_profile);
4509 4510 4511 4512
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto out;
	}
Y
Yan Zheng 已提交
4513 4514

	ret = btrfs_add_device(trans, fs_info->chunk_root, device);
4515
	if (ret)
4516 4517
		btrfs_abort_transaction(trans, root, ret);
out:
4518
	return ret;
Y
Yan Zheng 已提交
4519 4520 4521 4522 4523 4524 4525 4526 4527 4528
}

int btrfs_chunk_readonly(struct btrfs_root *root, u64 chunk_offset)
{
	struct extent_map *em;
	struct map_lookup *map;
	struct btrfs_mapping_tree *map_tree = &root->fs_info->mapping_tree;
	int readonly = 0;
	int i;

4529
	read_lock(&map_tree->map_tree.lock);
Y
Yan Zheng 已提交
4530
	em = lookup_extent_mapping(&map_tree->map_tree, chunk_offset, 1);
4531
	read_unlock(&map_tree->map_tree.lock);
Y
Yan Zheng 已提交
4532 4533 4534
	if (!em)
		return 1;

4535 4536 4537 4538 4539
	if (btrfs_test_opt(root, DEGRADED)) {
		free_extent_map(em);
		return 0;
	}

Y
Yan Zheng 已提交
4540 4541 4542 4543 4544 4545 4546
	map = (struct map_lookup *)em->bdev;
	for (i = 0; i < map->num_stripes; i++) {
		if (!map->stripes[i].dev->writeable) {
			readonly = 1;
			break;
		}
	}
4547
	free_extent_map(em);
Y
Yan Zheng 已提交
4548
	return readonly;
4549 4550 4551 4552
}

void btrfs_mapping_init(struct btrfs_mapping_tree *tree)
{
4553
	extent_map_tree_init(&tree->map_tree);
4554 4555 4556 4557 4558 4559
}

void btrfs_mapping_tree_free(struct btrfs_mapping_tree *tree)
{
	struct extent_map *em;

4560
	while (1) {
4561
		write_lock(&tree->map_tree.lock);
4562 4563 4564
		em = lookup_extent_mapping(&tree->map_tree, 0, (u64)-1);
		if (em)
			remove_extent_mapping(&tree->map_tree, em);
4565
		write_unlock(&tree->map_tree.lock);
4566 4567 4568 4569 4570 4571 4572 4573 4574
		if (!em)
			break;
		/* once for us */
		free_extent_map(em);
		/* once for the tree */
		free_extent_map(em);
	}
}

4575
int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len)
4576
{
4577
	struct btrfs_mapping_tree *map_tree = &fs_info->mapping_tree;
4578 4579 4580 4581 4582
	struct extent_map *em;
	struct map_lookup *map;
	struct extent_map_tree *em_tree = &map_tree->map_tree;
	int ret;

4583
	read_lock(&em_tree->lock);
4584
	em = lookup_extent_mapping(em_tree, logical, len);
4585
	read_unlock(&em_tree->lock);
4586

4587 4588 4589 4590 4591 4592
	/*
	 * We could return errors for these cases, but that could get ugly and
	 * we'd probably do the same thing which is just not do anything else
	 * and exit, so return 1 so the callers don't try to use other copies.
	 */
	if (!em) {
4593
		btrfs_crit(fs_info, "No mapping for %Lu-%Lu", logical,
4594 4595 4596 4597 4598
			    logical+len);
		return 1;
	}

	if (em->start > logical || em->start + em->len < logical) {
4599
		btrfs_crit(fs_info, "Invalid mapping for %Lu-%Lu, got "
4600
			    "%Lu-%Lu", logical, logical+len, em->start,
4601
			    em->start + em->len);
4602
		free_extent_map(em);
4603 4604 4605
		return 1;
	}

4606 4607 4608
	map = (struct map_lookup *)em->bdev;
	if (map->type & (BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID1))
		ret = map->num_stripes;
C
Chris Mason 已提交
4609 4610
	else if (map->type & BTRFS_BLOCK_GROUP_RAID10)
		ret = map->sub_stripes;
D
David Woodhouse 已提交
4611 4612 4613 4614
	else if (map->type & BTRFS_BLOCK_GROUP_RAID5)
		ret = 2;
	else if (map->type & BTRFS_BLOCK_GROUP_RAID6)
		ret = 3;
4615 4616 4617
	else
		ret = 1;
	free_extent_map(em);
4618 4619 4620 4621 4622 4623

	btrfs_dev_replace_lock(&fs_info->dev_replace);
	if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace))
		ret++;
	btrfs_dev_replace_unlock(&fs_info->dev_replace);

4624 4625 4626
	return ret;
}

D
David Woodhouse 已提交
4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672
unsigned long btrfs_full_stripe_len(struct btrfs_root *root,
				    struct btrfs_mapping_tree *map_tree,
				    u64 logical)
{
	struct extent_map *em;
	struct map_lookup *map;
	struct extent_map_tree *em_tree = &map_tree->map_tree;
	unsigned long len = root->sectorsize;

	read_lock(&em_tree->lock);
	em = lookup_extent_mapping(em_tree, logical, len);
	read_unlock(&em_tree->lock);
	BUG_ON(!em);

	BUG_ON(em->start > logical || em->start + em->len < logical);
	map = (struct map_lookup *)em->bdev;
	if (map->type & (BTRFS_BLOCK_GROUP_RAID5 |
			 BTRFS_BLOCK_GROUP_RAID6)) {
		len = map->stripe_len * nr_data_stripes(map);
	}
	free_extent_map(em);
	return len;
}

int btrfs_is_parity_mirror(struct btrfs_mapping_tree *map_tree,
			   u64 logical, u64 len, int mirror_num)
{
	struct extent_map *em;
	struct map_lookup *map;
	struct extent_map_tree *em_tree = &map_tree->map_tree;
	int ret = 0;

	read_lock(&em_tree->lock);
	em = lookup_extent_mapping(em_tree, logical, len);
	read_unlock(&em_tree->lock);
	BUG_ON(!em);

	BUG_ON(em->start > logical || em->start + em->len < logical);
	map = (struct map_lookup *)em->bdev;
	if (map->type & (BTRFS_BLOCK_GROUP_RAID5 |
			 BTRFS_BLOCK_GROUP_RAID6))
		ret = 1;
	free_extent_map(em);
	return ret;
}

4673 4674 4675
static int find_live_mirror(struct btrfs_fs_info *fs_info,
			    struct map_lookup *map, int first, int num,
			    int optimal, int dev_replace_is_ongoing)
4676 4677
{
	int i;
4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701
	int tolerance;
	struct btrfs_device *srcdev;

	if (dev_replace_is_ongoing &&
	    fs_info->dev_replace.cont_reading_from_srcdev_mode ==
	     BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_AVOID)
		srcdev = fs_info->dev_replace.srcdev;
	else
		srcdev = NULL;

	/*
	 * try to avoid the drive that is the source drive for a
	 * dev-replace procedure, only choose it if no other non-missing
	 * mirror is available
	 */
	for (tolerance = 0; tolerance < 2; tolerance++) {
		if (map->stripes[optimal].dev->bdev &&
		    (tolerance || map->stripes[optimal].dev != srcdev))
			return optimal;
		for (i = first; i < first + num; i++) {
			if (map->stripes[i].dev->bdev &&
			    (tolerance || map->stripes[i].dev != srcdev))
				return i;
		}
4702
	}
4703

4704 4705 4706 4707 4708 4709
	/* we couldn't find one that doesn't fail.  Just return something
	 * and the io error handling code will clean up eventually
	 */
	return optimal;
}

D
David Woodhouse 已提交
4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738
static inline int parity_smaller(u64 a, u64 b)
{
	return a > b;
}

/* Bubble-sort the stripe set to put the parity/syndrome stripes last */
static void sort_parity_stripes(struct btrfs_bio *bbio, u64 *raid_map)
{
	struct btrfs_bio_stripe s;
	int i;
	u64 l;
	int again = 1;

	while (again) {
		again = 0;
		for (i = 0; i < bbio->num_stripes - 1; i++) {
			if (parity_smaller(raid_map[i], raid_map[i+1])) {
				s = bbio->stripes[i];
				l = raid_map[i];
				bbio->stripes[i] = bbio->stripes[i+1];
				raid_map[i] = raid_map[i+1];
				bbio->stripes[i+1] = s;
				raid_map[i+1] = l;
				again = 1;
			}
		}
	}
}

4739
static int __btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
4740
			     u64 logical, u64 *length,
4741
			     struct btrfs_bio **bbio_ret,
D
David Woodhouse 已提交
4742
			     int mirror_num, u64 **raid_map_ret)
4743 4744 4745
{
	struct extent_map *em;
	struct map_lookup *map;
4746
	struct btrfs_mapping_tree *map_tree = &fs_info->mapping_tree;
4747 4748
	struct extent_map_tree *em_tree = &map_tree->map_tree;
	u64 offset;
4749
	u64 stripe_offset;
4750
	u64 stripe_end_offset;
4751
	u64 stripe_nr;
4752 4753
	u64 stripe_nr_orig;
	u64 stripe_nr_end;
D
David Woodhouse 已提交
4754 4755
	u64 stripe_len;
	u64 *raid_map = NULL;
4756
	int stripe_index;
4757
	int i;
4758
	int ret = 0;
4759
	int num_stripes;
4760
	int max_errors = 0;
4761
	struct btrfs_bio *bbio = NULL;
4762 4763 4764
	struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
	int dev_replace_is_ongoing = 0;
	int num_alloc_stripes;
4765 4766
	int patch_the_first_stripe_for_dev_replace = 0;
	u64 physical_to_patch_in_first_stripe = 0;
D
David Woodhouse 已提交
4767
	u64 raid56_full_stripe_start = (u64)-1;
4768

4769
	read_lock(&em_tree->lock);
4770
	em = lookup_extent_mapping(em_tree, logical, *length);
4771
	read_unlock(&em_tree->lock);
4772

4773
	if (!em) {
4774
		btrfs_crit(fs_info, "unable to find logical %llu len %llu",
4775
			logical, *length);
4776 4777 4778 4779 4780
		return -EINVAL;
	}

	if (em->start > logical || em->start + em->len < logical) {
		btrfs_crit(fs_info, "found a bad mapping, wanted %Lu, "
4781
			   "found %Lu-%Lu", logical, em->start,
4782
			   em->start + em->len);
4783
		free_extent_map(em);
4784
		return -EINVAL;
4785
	}
4786 4787 4788

	map = (struct map_lookup *)em->bdev;
	offset = logical - em->start;
4789

D
David Woodhouse 已提交
4790
	stripe_len = map->stripe_len;
4791 4792 4793 4794 4795
	stripe_nr = offset;
	/*
	 * stripe_nr counts the total number of stripes we have to stride
	 * to get to this block
	 */
D
David Woodhouse 已提交
4796
	do_div(stripe_nr, stripe_len);
4797

D
David Woodhouse 已提交
4798
	stripe_offset = stripe_nr * stripe_len;
4799 4800 4801 4802 4803
	BUG_ON(offset < stripe_offset);

	/* stripe_offset is the offset of this block in its stripe*/
	stripe_offset = offset - stripe_offset;

D
David Woodhouse 已提交
4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822
	/* if we're here for raid56, we need to know the stripe aligned start */
	if (map->type & (BTRFS_BLOCK_GROUP_RAID5 | BTRFS_BLOCK_GROUP_RAID6)) {
		unsigned long full_stripe_len = stripe_len * nr_data_stripes(map);
		raid56_full_stripe_start = offset;

		/* allow a write of a full stripe, but make sure we don't
		 * allow straddling of stripes
		 */
		do_div(raid56_full_stripe_start, full_stripe_len);
		raid56_full_stripe_start *= full_stripe_len;
	}

	if (rw & REQ_DISCARD) {
		/* we don't discard raid56 yet */
		if (map->type &
		    (BTRFS_BLOCK_GROUP_RAID5 | BTRFS_BLOCK_GROUP_RAID6)) {
			ret = -EOPNOTSUPP;
			goto out;
		}
4823
		*length = min_t(u64, em->len - offset, *length);
D
David Woodhouse 已提交
4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837
	} else if (map->type & BTRFS_BLOCK_GROUP_PROFILE_MASK) {
		u64 max_len;
		/* For writes to RAID[56], allow a full stripeset across all disks.
		   For other RAID types and for RAID[56] reads, just allow a single
		   stripe (on a single disk). */
		if (map->type & (BTRFS_BLOCK_GROUP_RAID5 | BTRFS_BLOCK_GROUP_RAID6) &&
		    (rw & REQ_WRITE)) {
			max_len = stripe_len * nr_data_stripes(map) -
				(offset - raid56_full_stripe_start);
		} else {
			/* we limit the length of each bio to what fits in a stripe */
			max_len = stripe_len - stripe_offset;
		}
		*length = min_t(u64, em->len - offset, max_len);
4838 4839 4840
	} else {
		*length = em->len - offset;
	}
4841

D
David Woodhouse 已提交
4842 4843
	/* This is for when we're called from btrfs_merge_bio_hook() and all
	   it cares about is the length */
4844
	if (!bbio_ret)
4845 4846
		goto out;

4847 4848 4849 4850 4851
	btrfs_dev_replace_lock(dev_replace);
	dev_replace_is_ongoing = btrfs_dev_replace_is_ongoing(dev_replace);
	if (!dev_replace_is_ongoing)
		btrfs_dev_replace_unlock(dev_replace);

4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875
	if (dev_replace_is_ongoing && mirror_num == map->num_stripes + 1 &&
	    !(rw & (REQ_WRITE | REQ_DISCARD | REQ_GET_READ_MIRRORS)) &&
	    dev_replace->tgtdev != NULL) {
		/*
		 * in dev-replace case, for repair case (that's the only
		 * case where the mirror is selected explicitly when
		 * calling btrfs_map_block), blocks left of the left cursor
		 * can also be read from the target drive.
		 * For REQ_GET_READ_MIRRORS, the target drive is added as
		 * the last one to the array of stripes. For READ, it also
		 * needs to be supported using the same mirror number.
		 * If the requested block is not left of the left cursor,
		 * EIO is returned. This can happen because btrfs_num_copies()
		 * returns one more in the dev-replace case.
		 */
		u64 tmp_length = *length;
		struct btrfs_bio *tmp_bbio = NULL;
		int tmp_num_stripes;
		u64 srcdev_devid = dev_replace->srcdev->devid;
		int index_srcdev = 0;
		int found = 0;
		u64 physical_of_found = 0;

		ret = __btrfs_map_block(fs_info, REQ_GET_READ_MIRRORS,
D
David Woodhouse 已提交
4876
			     logical, &tmp_length, &tmp_bbio, 0, NULL);
4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907 4908 4909 4910 4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933
		if (ret) {
			WARN_ON(tmp_bbio != NULL);
			goto out;
		}

		tmp_num_stripes = tmp_bbio->num_stripes;
		if (mirror_num > tmp_num_stripes) {
			/*
			 * REQ_GET_READ_MIRRORS does not contain this
			 * mirror, that means that the requested area
			 * is not left of the left cursor
			 */
			ret = -EIO;
			kfree(tmp_bbio);
			goto out;
		}

		/*
		 * process the rest of the function using the mirror_num
		 * of the source drive. Therefore look it up first.
		 * At the end, patch the device pointer to the one of the
		 * target drive.
		 */
		for (i = 0; i < tmp_num_stripes; i++) {
			if (tmp_bbio->stripes[i].dev->devid == srcdev_devid) {
				/*
				 * In case of DUP, in order to keep it
				 * simple, only add the mirror with the
				 * lowest physical address
				 */
				if (found &&
				    physical_of_found <=
				     tmp_bbio->stripes[i].physical)
					continue;
				index_srcdev = i;
				found = 1;
				physical_of_found =
					tmp_bbio->stripes[i].physical;
			}
		}

		if (found) {
			mirror_num = index_srcdev + 1;
			patch_the_first_stripe_for_dev_replace = 1;
			physical_to_patch_in_first_stripe = physical_of_found;
		} else {
			WARN_ON(1);
			ret = -EIO;
			kfree(tmp_bbio);
			goto out;
		}

		kfree(tmp_bbio);
	} else if (mirror_num > map->num_stripes) {
		mirror_num = 0;
	}

4934
	num_stripes = 1;
4935
	stripe_index = 0;
4936
	stripe_nr_orig = stripe_nr;
4937
	stripe_nr_end = ALIGN(offset + *length, map->stripe_len);
4938 4939 4940
	do_div(stripe_nr_end, map->stripe_len);
	stripe_end_offset = stripe_nr_end * map->stripe_len -
			    (offset + *length);
D
David Woodhouse 已提交
4941

4942 4943 4944 4945 4946 4947
	if (map->type & BTRFS_BLOCK_GROUP_RAID0) {
		if (rw & REQ_DISCARD)
			num_stripes = min_t(u64, map->num_stripes,
					    stripe_nr_end - stripe_nr_orig);
		stripe_index = do_div(stripe_nr, map->num_stripes);
	} else if (map->type & BTRFS_BLOCK_GROUP_RAID1) {
4948
		if (rw & (REQ_WRITE | REQ_DISCARD | REQ_GET_READ_MIRRORS))
4949
			num_stripes = map->num_stripes;
4950
		else if (mirror_num)
4951
			stripe_index = mirror_num - 1;
4952
		else {
4953
			stripe_index = find_live_mirror(fs_info, map, 0,
4954
					    map->num_stripes,
4955 4956
					    current->pid % map->num_stripes,
					    dev_replace_is_ongoing);
4957
			mirror_num = stripe_index + 1;
4958
		}
4959

4960
	} else if (map->type & BTRFS_BLOCK_GROUP_DUP) {
4961
		if (rw & (REQ_WRITE | REQ_DISCARD | REQ_GET_READ_MIRRORS)) {
4962
			num_stripes = map->num_stripes;
4963
		} else if (mirror_num) {
4964
			stripe_index = mirror_num - 1;
4965 4966 4967
		} else {
			mirror_num = 1;
		}
4968

C
Chris Mason 已提交
4969 4970 4971 4972 4973 4974
	} else if (map->type & BTRFS_BLOCK_GROUP_RAID10) {
		int factor = map->num_stripes / map->sub_stripes;

		stripe_index = do_div(stripe_nr, factor);
		stripe_index *= map->sub_stripes;

4975
		if (rw & (REQ_WRITE | REQ_GET_READ_MIRRORS))
4976
			num_stripes = map->sub_stripes;
4977 4978 4979 4980
		else if (rw & REQ_DISCARD)
			num_stripes = min_t(u64, map->sub_stripes *
					    (stripe_nr_end - stripe_nr_orig),
					    map->num_stripes);
C
Chris Mason 已提交
4981 4982
		else if (mirror_num)
			stripe_index += mirror_num - 1;
4983
		else {
4984
			int old_stripe_index = stripe_index;
4985 4986
			stripe_index = find_live_mirror(fs_info, map,
					      stripe_index,
4987
					      map->sub_stripes, stripe_index +
4988 4989
					      current->pid % map->sub_stripes,
					      dev_replace_is_ongoing);
4990
			mirror_num = stripe_index - old_stripe_index + 1;
4991
		}
D
David Woodhouse 已提交
4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010

	} else if (map->type & (BTRFS_BLOCK_GROUP_RAID5 |
				BTRFS_BLOCK_GROUP_RAID6)) {
		u64 tmp;

		if (bbio_ret && ((rw & REQ_WRITE) || mirror_num > 1)
		    && raid_map_ret) {
			int i, rot;

			/* push stripe_nr back to the start of the full stripe */
			stripe_nr = raid56_full_stripe_start;
			do_div(stripe_nr, stripe_len);

			stripe_index = do_div(stripe_nr, nr_data_stripes(map));

			/* RAID[56] write or recovery. Return all stripes */
			num_stripes = map->num_stripes;
			max_errors = nr_parity_stripes(map);

5011
			raid_map = kmalloc_array(num_stripes, sizeof(u64),
D
David Woodhouse 已提交
5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050
					   GFP_NOFS);
			if (!raid_map) {
				ret = -ENOMEM;
				goto out;
			}

			/* Work out the disk rotation on this stripe-set */
			tmp = stripe_nr;
			rot = do_div(tmp, num_stripes);

			/* Fill in the logical address of each stripe */
			tmp = stripe_nr * nr_data_stripes(map);
			for (i = 0; i < nr_data_stripes(map); i++)
				raid_map[(i+rot) % num_stripes] =
					em->start + (tmp + i) * map->stripe_len;

			raid_map[(i+rot) % map->num_stripes] = RAID5_P_STRIPE;
			if (map->type & BTRFS_BLOCK_GROUP_RAID6)
				raid_map[(i+rot+1) % num_stripes] =
					RAID6_Q_STRIPE;

			*length = map->stripe_len;
			stripe_index = 0;
			stripe_offset = 0;
		} else {
			/*
			 * Mirror #0 or #1 means the original data block.
			 * Mirror #2 is RAID5 parity block.
			 * Mirror #3 is RAID6 Q block.
			 */
			stripe_index = do_div(stripe_nr, nr_data_stripes(map));
			if (mirror_num > 1)
				stripe_index = nr_data_stripes(map) +
						mirror_num - 2;

			/* We distribute the parity blocks across stripes */
			tmp = stripe_nr + stripe_index;
			stripe_index = do_div(tmp, map->num_stripes);
		}
5051 5052 5053 5054 5055 5056 5057
	} else {
		/*
		 * after this do_div call, stripe_nr is the number of stripes
		 * on this device we have to walk to find the data, and
		 * stripe_index is the number of our device in the stripe array
		 */
		stripe_index = do_div(stripe_nr, map->num_stripes);
5058
		mirror_num = stripe_index + 1;
5059
	}
5060
	BUG_ON(stripe_index >= map->num_stripes);
5061

5062
	num_alloc_stripes = num_stripes;
5063 5064 5065 5066 5067 5068
	if (dev_replace_is_ongoing) {
		if (rw & (REQ_WRITE | REQ_DISCARD))
			num_alloc_stripes <<= 1;
		if (rw & REQ_GET_READ_MIRRORS)
			num_alloc_stripes++;
	}
5069
	bbio = kzalloc(btrfs_bio_size(num_alloc_stripes), GFP_NOFS);
5070
	if (!bbio) {
5071
		kfree(raid_map);
5072 5073 5074 5075 5076
		ret = -ENOMEM;
		goto out;
	}
	atomic_set(&bbio->error, 0);

5077
	if (rw & REQ_DISCARD) {
5078 5079 5080 5081
		int factor = 0;
		int sub_stripes = 0;
		u64 stripes_per_dev = 0;
		u32 remaining_stripes = 0;
5082
		u32 last_stripe = 0;
5083 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095

		if (map->type &
		    (BTRFS_BLOCK_GROUP_RAID0 | BTRFS_BLOCK_GROUP_RAID10)) {
			if (map->type & BTRFS_BLOCK_GROUP_RAID0)
				sub_stripes = 1;
			else
				sub_stripes = map->sub_stripes;

			factor = map->num_stripes / sub_stripes;
			stripes_per_dev = div_u64_rem(stripe_nr_end -
						      stripe_nr_orig,
						      factor,
						      &remaining_stripes);
5096 5097
			div_u64_rem(stripe_nr_end - 1, factor, &last_stripe);
			last_stripe *= sub_stripes;
5098 5099
		}

5100
		for (i = 0; i < num_stripes; i++) {
5101
			bbio->stripes[i].physical =
5102 5103
				map->stripes[stripe_index].physical +
				stripe_offset + stripe_nr * map->stripe_len;
5104
			bbio->stripes[i].dev = map->stripes[stripe_index].dev;
5105

5106 5107 5108 5109
			if (map->type & (BTRFS_BLOCK_GROUP_RAID0 |
					 BTRFS_BLOCK_GROUP_RAID10)) {
				bbio->stripes[i].length = stripes_per_dev *
							  map->stripe_len;
5110

5111 5112 5113
				if (i / sub_stripes < remaining_stripes)
					bbio->stripes[i].length +=
						map->stripe_len;
5114 5115 5116 5117 5118 5119 5120 5121 5122

				/*
				 * Special for the first stripe and
				 * the last stripe:
				 *
				 * |-------|...|-------|
				 *     |----------|
				 *    off     end_off
				 */
5123
				if (i < sub_stripes)
5124
					bbio->stripes[i].length -=
5125
						stripe_offset;
5126 5127 5128 5129

				if (stripe_index >= last_stripe &&
				    stripe_index <= (last_stripe +
						     sub_stripes - 1))
5130
					bbio->stripes[i].length -=
5131
						stripe_end_offset;
5132

5133 5134
				if (i == sub_stripes - 1)
					stripe_offset = 0;
5135
			} else
5136
				bbio->stripes[i].length = *length;
5137 5138 5139 5140 5141 5142 5143 5144 5145 5146

			stripe_index++;
			if (stripe_index == map->num_stripes) {
				/* This could only happen for RAID0/10 */
				stripe_index = 0;
				stripe_nr++;
			}
		}
	} else {
		for (i = 0; i < num_stripes; i++) {
5147
			bbio->stripes[i].physical =
5148 5149 5150
				map->stripes[stripe_index].physical +
				stripe_offset +
				stripe_nr * map->stripe_len;
5151
			bbio->stripes[i].dev =
5152
				map->stripes[stripe_index].dev;
5153
			stripe_index++;
5154
		}
5155
	}
5156

5157
	if (rw & (REQ_WRITE | REQ_GET_READ_MIRRORS)) {
5158 5159
		if (map->type & (BTRFS_BLOCK_GROUP_RAID1 |
				 BTRFS_BLOCK_GROUP_RAID10 |
D
David Woodhouse 已提交
5160
				 BTRFS_BLOCK_GROUP_RAID5 |
5161 5162
				 BTRFS_BLOCK_GROUP_DUP)) {
			max_errors = 1;
D
David Woodhouse 已提交
5163 5164
		} else if (map->type & BTRFS_BLOCK_GROUP_RAID6) {
			max_errors = 2;
5165
		}
5166
	}
5167

5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200
	if (dev_replace_is_ongoing && (rw & (REQ_WRITE | REQ_DISCARD)) &&
	    dev_replace->tgtdev != NULL) {
		int index_where_to_add;
		u64 srcdev_devid = dev_replace->srcdev->devid;

		/*
		 * duplicate the write operations while the dev replace
		 * procedure is running. Since the copying of the old disk
		 * to the new disk takes place at run time while the
		 * filesystem is mounted writable, the regular write
		 * operations to the old disk have to be duplicated to go
		 * to the new disk as well.
		 * Note that device->missing is handled by the caller, and
		 * that the write to the old disk is already set up in the
		 * stripes array.
		 */
		index_where_to_add = num_stripes;
		for (i = 0; i < num_stripes; i++) {
			if (bbio->stripes[i].dev->devid == srcdev_devid) {
				/* write to new disk, too */
				struct btrfs_bio_stripe *new =
					bbio->stripes + index_where_to_add;
				struct btrfs_bio_stripe *old =
					bbio->stripes + i;

				new->physical = old->physical;
				new->length = old->length;
				new->dev = dev_replace->tgtdev;
				index_where_to_add++;
				max_errors++;
			}
		}
		num_stripes = index_where_to_add;
5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243 5244 5245 5246
	} else if (dev_replace_is_ongoing && (rw & REQ_GET_READ_MIRRORS) &&
		   dev_replace->tgtdev != NULL) {
		u64 srcdev_devid = dev_replace->srcdev->devid;
		int index_srcdev = 0;
		int found = 0;
		u64 physical_of_found = 0;

		/*
		 * During the dev-replace procedure, the target drive can
		 * also be used to read data in case it is needed to repair
		 * a corrupt block elsewhere. This is possible if the
		 * requested area is left of the left cursor. In this area,
		 * the target drive is a full copy of the source drive.
		 */
		for (i = 0; i < num_stripes; i++) {
			if (bbio->stripes[i].dev->devid == srcdev_devid) {
				/*
				 * In case of DUP, in order to keep it
				 * simple, only add the mirror with the
				 * lowest physical address
				 */
				if (found &&
				    physical_of_found <=
				     bbio->stripes[i].physical)
					continue;
				index_srcdev = i;
				found = 1;
				physical_of_found = bbio->stripes[i].physical;
			}
		}
		if (found) {
			u64 length = map->stripe_len;

			if (physical_of_found + length <=
			    dev_replace->cursor_left) {
				struct btrfs_bio_stripe *tgtdev_stripe =
					bbio->stripes + num_stripes;

				tgtdev_stripe->physical = physical_of_found;
				tgtdev_stripe->length =
					bbio->stripes[index_srcdev].length;
				tgtdev_stripe->dev = dev_replace->tgtdev;

				num_stripes++;
			}
		}
5247 5248
	}

5249 5250 5251 5252
	*bbio_ret = bbio;
	bbio->num_stripes = num_stripes;
	bbio->max_errors = max_errors;
	bbio->mirror_num = mirror_num;
5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264

	/*
	 * this is the case that REQ_READ && dev_replace_is_ongoing &&
	 * mirror_num == num_stripes + 1 && dev_replace target drive is
	 * available as a mirror
	 */
	if (patch_the_first_stripe_for_dev_replace && num_stripes > 0) {
		WARN_ON(num_stripes > 1);
		bbio->stripes[0].dev = dev_replace->tgtdev;
		bbio->stripes[0].physical = physical_to_patch_in_first_stripe;
		bbio->mirror_num = map->num_stripes + 1;
	}
D
David Woodhouse 已提交
5265 5266 5267 5268
	if (raid_map) {
		sort_parity_stripes(bbio, raid_map);
		*raid_map_ret = raid_map;
	}
5269
out:
5270 5271
	if (dev_replace_is_ongoing)
		btrfs_dev_replace_unlock(dev_replace);
5272
	free_extent_map(em);
5273
	return ret;
5274 5275
}

5276
int btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
5277
		      u64 logical, u64 *length,
5278
		      struct btrfs_bio **bbio_ret, int mirror_num)
5279
{
5280
	return __btrfs_map_block(fs_info, rw, logical, length, bbio_ret,
D
David Woodhouse 已提交
5281
				 mirror_num, NULL);
5282 5283
}

Y
Yan Zheng 已提交
5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294
int btrfs_rmap_block(struct btrfs_mapping_tree *map_tree,
		     u64 chunk_start, u64 physical, u64 devid,
		     u64 **logical, int *naddrs, int *stripe_len)
{
	struct extent_map_tree *em_tree = &map_tree->map_tree;
	struct extent_map *em;
	struct map_lookup *map;
	u64 *buf;
	u64 bytenr;
	u64 length;
	u64 stripe_nr;
D
David Woodhouse 已提交
5295
	u64 rmap_len;
Y
Yan Zheng 已提交
5296 5297
	int i, j, nr = 0;

5298
	read_lock(&em_tree->lock);
Y
Yan Zheng 已提交
5299
	em = lookup_extent_mapping(em_tree, chunk_start, 1);
5300
	read_unlock(&em_tree->lock);
Y
Yan Zheng 已提交
5301

5302
	if (!em) {
5303
		printk(KERN_ERR "BTRFS: couldn't find em for chunk %Lu\n",
5304 5305 5306 5307 5308
		       chunk_start);
		return -EIO;
	}

	if (em->start != chunk_start) {
5309
		printk(KERN_ERR "BTRFS: bad chunk start, em=%Lu, wanted=%Lu\n",
5310 5311 5312 5313
		       em->start, chunk_start);
		free_extent_map(em);
		return -EIO;
	}
Y
Yan Zheng 已提交
5314 5315 5316
	map = (struct map_lookup *)em->bdev;

	length = em->len;
D
David Woodhouse 已提交
5317 5318
	rmap_len = map->stripe_len;

Y
Yan Zheng 已提交
5319 5320 5321 5322
	if (map->type & BTRFS_BLOCK_GROUP_RAID10)
		do_div(length, map->num_stripes / map->sub_stripes);
	else if (map->type & BTRFS_BLOCK_GROUP_RAID0)
		do_div(length, map->num_stripes);
D
David Woodhouse 已提交
5323 5324 5325 5326 5327
	else if (map->type & (BTRFS_BLOCK_GROUP_RAID5 |
			      BTRFS_BLOCK_GROUP_RAID6)) {
		do_div(length, nr_data_stripes(map));
		rmap_len = map->stripe_len * nr_data_stripes(map);
	}
Y
Yan Zheng 已提交
5328 5329

	buf = kzalloc(sizeof(u64) * map->num_stripes, GFP_NOFS);
5330
	BUG_ON(!buf); /* -ENOMEM */
Y
Yan Zheng 已提交
5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346

	for (i = 0; i < map->num_stripes; i++) {
		if (devid && map->stripes[i].dev->devid != devid)
			continue;
		if (map->stripes[i].physical > physical ||
		    map->stripes[i].physical + length <= physical)
			continue;

		stripe_nr = physical - map->stripes[i].physical;
		do_div(stripe_nr, map->stripe_len);

		if (map->type & BTRFS_BLOCK_GROUP_RAID10) {
			stripe_nr = stripe_nr * map->num_stripes + i;
			do_div(stripe_nr, map->sub_stripes);
		} else if (map->type & BTRFS_BLOCK_GROUP_RAID0) {
			stripe_nr = stripe_nr * map->num_stripes + i;
D
David Woodhouse 已提交
5347 5348 5349 5350 5351
		} /* else if RAID[56], multiply by nr_data_stripes().
		   * Alternatively, just use rmap_len below instead of
		   * map->stripe_len */

		bytenr = chunk_start + stripe_nr * rmap_len;
5352
		WARN_ON(nr >= map->num_stripes);
Y
Yan Zheng 已提交
5353 5354 5355 5356
		for (j = 0; j < nr; j++) {
			if (buf[j] == bytenr)
				break;
		}
5357 5358
		if (j == nr) {
			WARN_ON(nr >= map->num_stripes);
Y
Yan Zheng 已提交
5359
			buf[nr++] = bytenr;
5360
		}
Y
Yan Zheng 已提交
5361 5362 5363 5364
	}

	*logical = buf;
	*naddrs = nr;
D
David Woodhouse 已提交
5365
	*stripe_len = rmap_len;
Y
Yan Zheng 已提交
5366 5367 5368

	free_extent_map(em);
	return 0;
5369 5370
}

5371 5372 5373 5374 5375 5376 5377 5378 5379
static inline void btrfs_end_bbio(struct btrfs_bio *bbio, struct bio *bio, int err)
{
	if (likely(bbio->flags & BTRFS_BIO_ORIG_BIO_SUBMITTED))
		bio_endio_nodec(bio, err);
	else
		bio_endio(bio, err);
	kfree(bbio);
}

5380
static void btrfs_end_bio(struct bio *bio, int err)
5381
{
5382
	struct btrfs_bio *bbio = bio->bi_private;
5383
	struct btrfs_device *dev = bbio->stripes[0].dev;
5384
	int is_orig_bio = 0;
5385

5386
	if (err) {
5387
		atomic_inc(&bbio->error);
5388 5389
		if (err == -EIO || err == -EREMOTEIO) {
			unsigned int stripe_index =
5390
				btrfs_io_bio(bio)->stripe_index;
5391 5392 5393

			BUG_ON(stripe_index >= bbio->num_stripes);
			dev = bbio->stripes[stripe_index].dev;
5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405
			if (dev->bdev) {
				if (bio->bi_rw & WRITE)
					btrfs_dev_stat_inc(dev,
						BTRFS_DEV_STAT_WRITE_ERRS);
				else
					btrfs_dev_stat_inc(dev,
						BTRFS_DEV_STAT_READ_ERRS);
				if ((bio->bi_rw & WRITE_FLUSH) == WRITE_FLUSH)
					btrfs_dev_stat_inc(dev,
						BTRFS_DEV_STAT_FLUSH_ERRS);
				btrfs_dev_stat_print_on_error(dev);
			}
5406 5407
		}
	}
5408

5409
	if (bio == bbio->orig_bio)
5410 5411
		is_orig_bio = 1;

5412 5413
	btrfs_bio_counter_dec(bbio->fs_info);

5414
	if (atomic_dec_and_test(&bbio->stripes_pending)) {
5415 5416
		if (!is_orig_bio) {
			bio_put(bio);
5417
			bio = bbio->orig_bio;
5418
		}
5419

5420 5421
		bio->bi_private = bbio->private;
		bio->bi_end_io = bbio->end_io;
5422
		btrfs_io_bio(bio)->mirror_num = bbio->mirror_num;
5423
		/* only send an error to the higher layers if it is
D
David Woodhouse 已提交
5424
		 * beyond the tolerance of the btrfs bio
5425
		 */
5426
		if (atomic_read(&bbio->error) > bbio->max_errors) {
5427
			err = -EIO;
5428
		} else {
5429 5430 5431 5432 5433
			/*
			 * this bio is actually up to date, we didn't
			 * go over the max number of errors
			 */
			set_bit(BIO_UPTODATE, &bio->bi_flags);
5434
			err = 0;
5435
		}
5436

5437
		btrfs_end_bbio(bbio, bio, err);
5438
	} else if (!is_orig_bio) {
5439 5440 5441 5442
		bio_put(bio);
	}
}

5443 5444 5445 5446 5447 5448 5449
/*
 * see run_scheduled_bios for a description of why bios are collected for
 * async submit.
 *
 * This will add one bio to the pending list for a device and make sure
 * the work struct is scheduled.
 */
5450 5451 5452
static noinline void btrfs_schedule_bio(struct btrfs_root *root,
					struct btrfs_device *device,
					int rw, struct bio *bio)
5453 5454
{
	int should_queue = 1;
5455
	struct btrfs_pending_bios *pending_bios;
5456

D
David Woodhouse 已提交
5457 5458 5459 5460 5461
	if (device->missing || !device->bdev) {
		bio_endio(bio, -EIO);
		return;
	}

5462
	/* don't bother with additional async steps for reads, right now */
5463
	if (!(rw & REQ_WRITE)) {
5464
		bio_get(bio);
5465
		btrfsic_submit_bio(rw, bio);
5466
		bio_put(bio);
5467
		return;
5468 5469 5470
	}

	/*
5471
	 * nr_async_bios allows us to reliably return congestion to the
5472 5473 5474 5475
	 * higher layers.  Otherwise, the async bio makes it appear we have
	 * made progress against dirty pages when we've really just put it
	 * on a queue for later
	 */
5476
	atomic_inc(&root->fs_info->nr_async_bios);
5477
	WARN_ON(bio->bi_next);
5478 5479 5480 5481
	bio->bi_next = NULL;
	bio->bi_rw |= rw;

	spin_lock(&device->io_lock);
5482
	if (bio->bi_rw & REQ_SYNC)
5483 5484 5485
		pending_bios = &device->pending_sync_bios;
	else
		pending_bios = &device->pending_bios;
5486

5487 5488
	if (pending_bios->tail)
		pending_bios->tail->bi_next = bio;
5489

5490 5491 5492
	pending_bios->tail = bio;
	if (!pending_bios->head)
		pending_bios->head = bio;
5493 5494 5495 5496 5497 5498
	if (device->running_pending)
		should_queue = 0;

	spin_unlock(&device->io_lock);

	if (should_queue)
5499 5500
		btrfs_queue_work(root->fs_info->submit_workers,
				 &device->work);
5501 5502
}

5503 5504 5505 5506 5507
static int bio_size_ok(struct block_device *bdev, struct bio *bio,
		       sector_t sector)
{
	struct bio_vec *prev;
	struct request_queue *q = bdev_get_queue(bdev);
5508
	unsigned int max_sectors = queue_max_sectors(q);
5509 5510 5511 5512 5513 5514
	struct bvec_merge_data bvm = {
		.bi_bdev = bdev,
		.bi_sector = sector,
		.bi_rw = bio->bi_rw,
	};

5515
	if (WARN_ON(bio->bi_vcnt == 0))
5516 5517 5518
		return 1;

	prev = &bio->bi_io_vec[bio->bi_vcnt - 1];
5519
	if (bio_sectors(bio) > max_sectors)
5520 5521 5522 5523 5524
		return 0;

	if (!q->merge_bvec_fn)
		return 1;

5525
	bvm.bi_size = bio->bi_iter.bi_size - prev->bv_len;
5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537
	if (q->merge_bvec_fn(q, &bvm, prev) < prev->bv_len)
		return 0;
	return 1;
}

static void submit_stripe_bio(struct btrfs_root *root, struct btrfs_bio *bbio,
			      struct bio *bio, u64 physical, int dev_nr,
			      int rw, int async)
{
	struct btrfs_device *dev = bbio->stripes[dev_nr].dev;

	bio->bi_private = bbio;
5538
	btrfs_io_bio(bio)->stripe_index = dev_nr;
5539
	bio->bi_end_io = btrfs_end_bio;
5540
	bio->bi_iter.bi_sector = physical >> 9;
5541 5542 5543 5544 5545 5546
#ifdef DEBUG
	{
		struct rcu_string *name;

		rcu_read_lock();
		name = rcu_dereference(dev->name);
5547
		pr_debug("btrfs_map_bio: rw %d, sector=%llu, dev=%lu "
5548 5549 5550 5551 5552 5553 5554
			 "(%s id %llu), size=%u\n", rw,
			 (u64)bio->bi_sector, (u_long)dev->bdev->bd_dev,
			 name->str, dev->devid, bio->bi_size);
		rcu_read_unlock();
	}
#endif
	bio->bi_bdev = dev->bdev;
5555 5556 5557

	btrfs_bio_counter_inc_noblocked(root->fs_info);

5558
	if (async)
D
David Woodhouse 已提交
5559
		btrfs_schedule_bio(root, dev, rw, bio);
5560 5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580
	else
		btrfsic_submit_bio(rw, bio);
}

static int breakup_stripe_bio(struct btrfs_root *root, struct btrfs_bio *bbio,
			      struct bio *first_bio, struct btrfs_device *dev,
			      int dev_nr, int rw, int async)
{
	struct bio_vec *bvec = first_bio->bi_io_vec;
	struct bio *bio;
	int nr_vecs = bio_get_nr_vecs(dev->bdev);
	u64 physical = bbio->stripes[dev_nr].physical;

again:
	bio = btrfs_bio_alloc(dev->bdev, physical >> 9, nr_vecs, GFP_NOFS);
	if (!bio)
		return -ENOMEM;

	while (bvec <= (first_bio->bi_io_vec + first_bio->bi_vcnt - 1)) {
		if (bio_add_page(bio, bvec->bv_page, bvec->bv_len,
				 bvec->bv_offset) < bvec->bv_len) {
5581
			u64 len = bio->bi_iter.bi_size;
5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599

			atomic_inc(&bbio->stripes_pending);
			submit_stripe_bio(root, bbio, bio, physical, dev_nr,
					  rw, async);
			physical += len;
			goto again;
		}
		bvec++;
	}

	submit_stripe_bio(root, bbio, bio, physical, dev_nr, rw, async);
	return 0;
}

static void bbio_error(struct btrfs_bio *bbio, struct bio *bio, u64 logical)
{
	atomic_inc(&bbio->error);
	if (atomic_dec_and_test(&bbio->stripes_pending)) {
5600 5601 5602
		/* Shoud be the original bio. */
		WARN_ON(bio != bbio->orig_bio);

5603 5604
		bio->bi_private = bbio->private;
		bio->bi_end_io = bbio->end_io;
5605
		btrfs_io_bio(bio)->mirror_num = bbio->mirror_num;
5606
		bio->bi_iter.bi_sector = logical >> 9;
5607 5608

		btrfs_end_bbio(bbio, bio, -EIO);
5609 5610 5611
	}
}

5612
int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
5613
		  int mirror_num, int async_submit)
5614 5615
{
	struct btrfs_device *dev;
5616
	struct bio *first_bio = bio;
5617
	u64 logical = (u64)bio->bi_iter.bi_sector << 9;
5618 5619
	u64 length = 0;
	u64 map_length;
D
David Woodhouse 已提交
5620
	u64 *raid_map = NULL;
5621
	int ret;
5622 5623
	int dev_nr = 0;
	int total_devs = 1;
5624
	struct btrfs_bio *bbio = NULL;
5625

5626
	length = bio->bi_iter.bi_size;
5627
	map_length = length;
5628

5629
	btrfs_bio_counter_inc_blocked(root->fs_info);
D
David Woodhouse 已提交
5630 5631
	ret = __btrfs_map_block(root->fs_info, rw, logical, &map_length, &bbio,
			      mirror_num, &raid_map);
5632 5633
	if (ret) {
		btrfs_bio_counter_dec(root->fs_info);
5634
		return ret;
5635
	}
5636

5637
	total_devs = bbio->num_stripes;
D
David Woodhouse 已提交
5638 5639 5640
	bbio->orig_bio = first_bio;
	bbio->private = first_bio->bi_private;
	bbio->end_io = first_bio->bi_end_io;
5641
	bbio->fs_info = root->fs_info;
D
David Woodhouse 已提交
5642 5643 5644 5645 5646 5647
	atomic_set(&bbio->stripes_pending, bbio->num_stripes);

	if (raid_map) {
		/* In this case, map_length has been set to the length of
		   a single stripe; not the whole write */
		if (rw & WRITE) {
5648 5649
			ret = raid56_parity_write(root, bio, bbio,
						  raid_map, map_length);
D
David Woodhouse 已提交
5650
		} else {
5651 5652 5653
			ret = raid56_parity_recover(root, bio, bbio,
						    raid_map, map_length,
						    mirror_num);
D
David Woodhouse 已提交
5654
		}
5655 5656 5657 5658 5659 5660
		/*
		 * FIXME, replace dosen't support raid56 yet, please fix
		 * it in the future.
		 */
		btrfs_bio_counter_dec(root->fs_info);
		return ret;
D
David Woodhouse 已提交
5661 5662
	}

5663
	if (map_length < length) {
5664
		btrfs_crit(root->fs_info, "mapping failed logical %llu bio len %llu len %llu",
5665
			logical, length, map_length);
5666 5667
		BUG();
	}
5668

5669
	while (dev_nr < total_devs) {
5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689
		dev = bbio->stripes[dev_nr].dev;
		if (!dev || !dev->bdev || (rw & WRITE && !dev->writeable)) {
			bbio_error(bbio, first_bio, logical);
			dev_nr++;
			continue;
		}

		/*
		 * Check and see if we're ok with this bio based on it's size
		 * and offset with the given device.
		 */
		if (!bio_size_ok(dev->bdev, first_bio,
				 bbio->stripes[dev_nr].physical >> 9)) {
			ret = breakup_stripe_bio(root, bbio, first_bio, dev,
						 dev_nr, rw, async_submit);
			BUG_ON(ret);
			dev_nr++;
			continue;
		}

5690
		if (dev_nr < total_devs - 1) {
5691
			bio = btrfs_bio_clone(first_bio, GFP_NOFS);
5692
			BUG_ON(!bio); /* -ENOMEM */
5693 5694
		} else {
			bio = first_bio;
5695
			bbio->flags |= BTRFS_BIO_ORIG_BIO_SUBMITTED;
5696
		}
5697 5698 5699 5700

		submit_stripe_bio(root, bbio, bio,
				  bbio->stripes[dev_nr].physical, dev_nr, rw,
				  async_submit);
5701 5702
		dev_nr++;
	}
5703
	btrfs_bio_counter_dec(root->fs_info);
5704 5705 5706
	return 0;
}

5707
struct btrfs_device *btrfs_find_device(struct btrfs_fs_info *fs_info, u64 devid,
Y
Yan Zheng 已提交
5708
				       u8 *uuid, u8 *fsid)
5709
{
Y
Yan Zheng 已提交
5710 5711 5712
	struct btrfs_device *device;
	struct btrfs_fs_devices *cur_devices;

5713
	cur_devices = fs_info->fs_devices;
Y
Yan Zheng 已提交
5714 5715 5716 5717 5718 5719 5720 5721 5722 5723 5724
	while (cur_devices) {
		if (!fsid ||
		    !memcmp(cur_devices->fsid, fsid, BTRFS_UUID_SIZE)) {
			device = __find_device(&cur_devices->devices,
					       devid, uuid);
			if (device)
				return device;
		}
		cur_devices = cur_devices->seed;
	}
	return NULL;
5725 5726
}

5727 5728 5729 5730 5731 5732
static struct btrfs_device *add_missing_dev(struct btrfs_root *root,
					    u64 devid, u8 *dev_uuid)
{
	struct btrfs_device *device;
	struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;

5733 5734
	device = btrfs_alloc_device(NULL, &devid, dev_uuid);
	if (IS_ERR(device))
5735
		return NULL;
5736 5737

	list_add(&device->dev_list, &fs_devices->devices);
Y
Yan Zheng 已提交
5738
	device->fs_devices = fs_devices;
5739
	fs_devices->num_devices++;
5740 5741

	device->missing = 1;
5742
	fs_devices->missing_devices++;
5743

5744 5745 5746
	return device;
}

5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766
/**
 * btrfs_alloc_device - allocate struct btrfs_device
 * @fs_info:	used only for generating a new devid, can be NULL if
 *		devid is provided (i.e. @devid != NULL).
 * @devid:	a pointer to devid for this device.  If NULL a new devid
 *		is generated.
 * @uuid:	a pointer to UUID for this device.  If NULL a new UUID
 *		is generated.
 *
 * Return: a pointer to a new &struct btrfs_device on success; ERR_PTR()
 * on error.  Returned struct is not linked onto any lists and can be
 * destroyed with kfree() right away.
 */
struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info,
					const u64 *devid,
					const u8 *uuid)
{
	struct btrfs_device *dev;
	u64 tmp;

5767
	if (WARN_ON(!devid && !fs_info))
5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791
		return ERR_PTR(-EINVAL);

	dev = __alloc_device();
	if (IS_ERR(dev))
		return dev;

	if (devid)
		tmp = *devid;
	else {
		int ret;

		ret = find_next_devid(fs_info, &tmp);
		if (ret) {
			kfree(dev);
			return ERR_PTR(ret);
		}
	}
	dev->devid = tmp;

	if (uuid)
		memcpy(dev->uuid, uuid, BTRFS_UUID_SIZE);
	else
		generate_random_uuid(dev->uuid);

5792
	btrfs_init_work(&dev->work, pending_bios_fn, NULL, NULL);
5793 5794 5795 5796

	return dev;
}

5797 5798 5799 5800 5801 5802 5803 5804 5805 5806
static int read_one_chunk(struct btrfs_root *root, struct btrfs_key *key,
			  struct extent_buffer *leaf,
			  struct btrfs_chunk *chunk)
{
	struct btrfs_mapping_tree *map_tree = &root->fs_info->mapping_tree;
	struct map_lookup *map;
	struct extent_map *em;
	u64 logical;
	u64 length;
	u64 devid;
5807
	u8 uuid[BTRFS_UUID_SIZE];
5808
	int num_stripes;
5809
	int ret;
5810
	int i;
5811

5812 5813
	logical = key->offset;
	length = btrfs_chunk_length(leaf, chunk);
5814

5815
	read_lock(&map_tree->map_tree.lock);
5816
	em = lookup_extent_mapping(&map_tree->map_tree, logical, 1);
5817
	read_unlock(&map_tree->map_tree.lock);
5818 5819 5820 5821 5822 5823 5824 5825 5826

	/* already mapped? */
	if (em && em->start <= logical && em->start + em->len > logical) {
		free_extent_map(em);
		return 0;
	} else if (em) {
		free_extent_map(em);
	}

5827
	em = alloc_extent_map();
5828 5829
	if (!em)
		return -ENOMEM;
5830 5831
	num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
	map = kmalloc(map_lookup_size(num_stripes), GFP_NOFS);
5832 5833 5834 5835 5836
	if (!map) {
		free_extent_map(em);
		return -ENOMEM;
	}

5837
	set_bit(EXTENT_FLAG_FS_MAPPING, &em->flags);
5838 5839 5840
	em->bdev = (struct block_device *)map;
	em->start = logical;
	em->len = length;
5841
	em->orig_start = 0;
5842
	em->block_start = 0;
5843
	em->block_len = em->len;
5844

5845 5846 5847 5848 5849 5850
	map->num_stripes = num_stripes;
	map->io_width = btrfs_chunk_io_width(leaf, chunk);
	map->io_align = btrfs_chunk_io_align(leaf, chunk);
	map->sector_size = btrfs_chunk_sector_size(leaf, chunk);
	map->stripe_len = btrfs_chunk_stripe_len(leaf, chunk);
	map->type = btrfs_chunk_type(leaf, chunk);
C
Chris Mason 已提交
5851
	map->sub_stripes = btrfs_chunk_sub_stripes(leaf, chunk);
5852 5853 5854 5855
	for (i = 0; i < num_stripes; i++) {
		map->stripes[i].physical =
			btrfs_stripe_offset_nr(leaf, chunk, i);
		devid = btrfs_stripe_devid_nr(leaf, chunk, i);
5856 5857 5858
		read_extent_buffer(leaf, uuid, (unsigned long)
				   btrfs_stripe_dev_uuid_nr(chunk, i),
				   BTRFS_UUID_SIZE);
5859 5860
		map->stripes[i].dev = btrfs_find_device(root->fs_info, devid,
							uuid, NULL);
5861
		if (!map->stripes[i].dev && !btrfs_test_opt(root, DEGRADED)) {
5862 5863 5864
			free_extent_map(em);
			return -EIO;
		}
5865 5866 5867 5868 5869 5870 5871 5872 5873
		if (!map->stripes[i].dev) {
			map->stripes[i].dev =
				add_missing_dev(root, devid, uuid);
			if (!map->stripes[i].dev) {
				free_extent_map(em);
				return -EIO;
			}
		}
		map->stripes[i].dev->in_fs_metadata = 1;
5874 5875
	}

5876
	write_lock(&map_tree->map_tree.lock);
5877
	ret = add_extent_mapping(&map_tree->map_tree, em, 0);
5878
	write_unlock(&map_tree->map_tree.lock);
5879
	BUG_ON(ret); /* Tree corruption */
5880 5881 5882 5883 5884
	free_extent_map(em);

	return 0;
}

5885
static void fill_device_from_item(struct extent_buffer *leaf,
5886 5887 5888 5889 5890 5891
				 struct btrfs_dev_item *dev_item,
				 struct btrfs_device *device)
{
	unsigned long ptr;

	device->devid = btrfs_device_id(leaf, dev_item);
5892 5893
	device->disk_total_bytes = btrfs_device_total_bytes(leaf, dev_item);
	device->total_bytes = device->disk_total_bytes;
5894 5895 5896 5897 5898
	device->bytes_used = btrfs_device_bytes_used(leaf, dev_item);
	device->type = btrfs_device_type(leaf, dev_item);
	device->io_align = btrfs_device_io_align(leaf, dev_item);
	device->io_width = btrfs_device_io_width(leaf, dev_item);
	device->sector_size = btrfs_device_sector_size(leaf, dev_item);
5899
	WARN_ON(device->devid == BTRFS_DEV_REPLACE_DEVID);
5900
	device->is_tgtdev_for_dev_replace = 0;
5901

5902
	ptr = btrfs_device_uuid(dev_item);
5903
	read_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE);
5904 5905
}

Y
Yan Zheng 已提交
5906 5907 5908 5909 5910
static int open_seed_devices(struct btrfs_root *root, u8 *fsid)
{
	struct btrfs_fs_devices *fs_devices;
	int ret;

5911
	BUG_ON(!mutex_is_locked(&uuid_mutex));
Y
Yan Zheng 已提交
5912 5913 5914 5915 5916 5917 5918 5919 5920 5921 5922 5923 5924 5925 5926

	fs_devices = root->fs_info->fs_devices->seed;
	while (fs_devices) {
		if (!memcmp(fs_devices->fsid, fsid, BTRFS_UUID_SIZE)) {
			ret = 0;
			goto out;
		}
		fs_devices = fs_devices->seed;
	}

	fs_devices = find_fsid(fsid);
	if (!fs_devices) {
		ret = -ENOENT;
		goto out;
	}
Y
Yan Zheng 已提交
5927 5928 5929 5930

	fs_devices = clone_fs_devices(fs_devices);
	if (IS_ERR(fs_devices)) {
		ret = PTR_ERR(fs_devices);
Y
Yan Zheng 已提交
5931 5932 5933
		goto out;
	}

5934
	ret = __btrfs_open_devices(fs_devices, FMODE_READ,
5935
				   root->fs_info->bdev_holder);
5936 5937
	if (ret) {
		free_fs_devices(fs_devices);
Y
Yan Zheng 已提交
5938
		goto out;
5939
	}
Y
Yan Zheng 已提交
5940 5941 5942

	if (!fs_devices->seeding) {
		__btrfs_close_devices(fs_devices);
Y
Yan Zheng 已提交
5943
		free_fs_devices(fs_devices);
Y
Yan Zheng 已提交
5944 5945 5946 5947 5948 5949 5950 5951 5952 5953
		ret = -EINVAL;
		goto out;
	}

	fs_devices->seed = root->fs_info->fs_devices->seed;
	root->fs_info->fs_devices->seed = fs_devices;
out:
	return ret;
}

5954
static int read_one_dev(struct btrfs_root *root,
5955 5956 5957 5958 5959 5960
			struct extent_buffer *leaf,
			struct btrfs_dev_item *dev_item)
{
	struct btrfs_device *device;
	u64 devid;
	int ret;
Y
Yan Zheng 已提交
5961
	u8 fs_uuid[BTRFS_UUID_SIZE];
5962 5963
	u8 dev_uuid[BTRFS_UUID_SIZE];

5964
	devid = btrfs_device_id(leaf, dev_item);
5965
	read_extent_buffer(leaf, dev_uuid, btrfs_device_uuid(dev_item),
5966
			   BTRFS_UUID_SIZE);
5967
	read_extent_buffer(leaf, fs_uuid, btrfs_device_fsid(dev_item),
Y
Yan Zheng 已提交
5968 5969 5970 5971
			   BTRFS_UUID_SIZE);

	if (memcmp(fs_uuid, root->fs_info->fsid, BTRFS_UUID_SIZE)) {
		ret = open_seed_devices(root, fs_uuid);
Y
Yan Zheng 已提交
5972
		if (ret && !btrfs_test_opt(root, DEGRADED))
Y
Yan Zheng 已提交
5973 5974 5975
			return ret;
	}

5976
	device = btrfs_find_device(root->fs_info, devid, dev_uuid, fs_uuid);
Y
Yan Zheng 已提交
5977
	if (!device || !device->bdev) {
Y
Yan Zheng 已提交
5978
		if (!btrfs_test_opt(root, DEGRADED))
Y
Yan Zheng 已提交
5979 5980 5981
			return -EIO;

		if (!device) {
5982
			btrfs_warn(root->fs_info, "devid %llu missing", devid);
Y
Yan Zheng 已提交
5983 5984 5985
			device = add_missing_dev(root, devid, dev_uuid);
			if (!device)
				return -ENOMEM;
5986 5987 5988 5989 5990 5991 5992 5993 5994
		} else if (!device->missing) {
			/*
			 * this happens when a device that was properly setup
			 * in the device info lists suddenly goes bad.
			 * device->bdev is NULL, and so we have to set
			 * device->missing to one here
			 */
			root->fs_info->fs_devices->missing_devices++;
			device->missing = 1;
Y
Yan Zheng 已提交
5995 5996 5997 5998 5999 6000 6001 6002
		}
	}

	if (device->fs_devices != root->fs_info->fs_devices) {
		BUG_ON(device->writeable);
		if (device->generation !=
		    btrfs_device_generation(leaf, dev_item))
			return -EINVAL;
6003
	}
6004 6005

	fill_device_from_item(leaf, dev_item, device);
6006
	device->in_fs_metadata = 1;
6007
	if (device->writeable && !device->is_tgtdev_for_dev_replace) {
Y
Yan Zheng 已提交
6008
		device->fs_devices->total_rw_bytes += device->total_bytes;
6009 6010 6011 6012 6013
		spin_lock(&root->fs_info->free_chunk_lock);
		root->fs_info->free_chunk_space += device->total_bytes -
			device->bytes_used;
		spin_unlock(&root->fs_info->free_chunk_lock);
	}
6014 6015 6016 6017
	ret = 0;
	return ret;
}

Y
Yan Zheng 已提交
6018
int btrfs_read_sys_array(struct btrfs_root *root)
6019
{
6020
	struct btrfs_super_block *super_copy = root->fs_info->super_copy;
6021
	struct extent_buffer *sb;
6022 6023
	struct btrfs_disk_key *disk_key;
	struct btrfs_chunk *chunk;
6024 6025 6026
	u8 *ptr;
	unsigned long sb_ptr;
	int ret = 0;
6027 6028 6029 6030
	u32 num_stripes;
	u32 array_size;
	u32 len = 0;
	u32 cur;
6031
	struct btrfs_key key;
6032

Y
Yan Zheng 已提交
6033
	sb = btrfs_find_create_tree_block(root, BTRFS_SUPER_INFO_OFFSET,
6034 6035 6036 6037
					  BTRFS_SUPER_INFO_SIZE);
	if (!sb)
		return -ENOMEM;
	btrfs_set_buffer_uptodate(sb);
6038
	btrfs_set_buffer_lockdep_class(root->root_key.objectid, sb, 0);
6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051
	/*
	 * The sb extent buffer is artifical and just used to read the system array.
	 * btrfs_set_buffer_uptodate() call does not properly mark all it's
	 * pages up-to-date when the page is larger: extent does not cover the
	 * whole page and consequently check_page_uptodate does not find all
	 * the page's extents up-to-date (the hole beyond sb),
	 * write_extent_buffer then triggers a WARN_ON.
	 *
	 * Regular short extents go through mark_extent_buffer_dirty/writeback cycle,
	 * but sb spans only this function. Add an explicit SetPageUptodate call
	 * to silence the warning eg. on PowerPC 64.
	 */
	if (PAGE_CACHE_SIZE > BTRFS_SUPER_INFO_SIZE)
6052
		SetPageUptodate(sb->pages[0]);
6053

6054
	write_extent_buffer(sb, super_copy, 0, BTRFS_SUPER_INFO_SIZE);
6055 6056 6057 6058 6059 6060 6061 6062 6063 6064
	array_size = btrfs_super_sys_array_size(super_copy);

	ptr = super_copy->sys_chunk_array;
	sb_ptr = offsetof(struct btrfs_super_block, sys_chunk_array);
	cur = 0;

	while (cur < array_size) {
		disk_key = (struct btrfs_disk_key *)ptr;
		btrfs_disk_key_to_cpu(&key, disk_key);

6065
		len = sizeof(*disk_key); ptr += len;
6066 6067 6068
		sb_ptr += len;
		cur += len;

6069
		if (key.type == BTRFS_CHUNK_ITEM_KEY) {
6070
			chunk = (struct btrfs_chunk *)sb_ptr;
6071
			ret = read_one_chunk(root, &key, sb, chunk);
6072 6073
			if (ret)
				break;
6074 6075 6076
			num_stripes = btrfs_chunk_num_stripes(sb, chunk);
			len = btrfs_chunk_item_size(num_stripes);
		} else {
6077 6078
			ret = -EIO;
			break;
6079 6080 6081 6082 6083
		}
		ptr += len;
		sb_ptr += len;
		cur += len;
	}
6084
	free_extent_buffer(sb);
6085
	return ret;
6086 6087 6088 6089 6090 6091 6092 6093 6094 6095 6096 6097 6098 6099 6100 6101 6102
}

int btrfs_read_chunk_tree(struct btrfs_root *root)
{
	struct btrfs_path *path;
	struct extent_buffer *leaf;
	struct btrfs_key key;
	struct btrfs_key found_key;
	int ret;
	int slot;

	root = root->fs_info->chunk_root;

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

6103 6104 6105
	mutex_lock(&uuid_mutex);
	lock_chunks(root);

6106 6107 6108 6109 6110
	/*
	 * Read all device items, and then all the chunk items. All
	 * device items are found before any chunk item (their object id
	 * is smaller than the lowest possible object id for a chunk
	 * item - BTRFS_FIRST_CHUNK_TREE_OBJECTID).
6111 6112 6113 6114 6115
	 */
	key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
	key.offset = 0;
	key.type = 0;
	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
6116 6117
	if (ret < 0)
		goto error;
6118
	while (1) {
6119 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129
		leaf = path->nodes[0];
		slot = path->slots[0];
		if (slot >= btrfs_header_nritems(leaf)) {
			ret = btrfs_next_leaf(root, path);
			if (ret == 0)
				continue;
			if (ret < 0)
				goto error;
			break;
		}
		btrfs_item_key_to_cpu(leaf, &found_key, slot);
6130 6131 6132
		if (found_key.type == BTRFS_DEV_ITEM_KEY) {
			struct btrfs_dev_item *dev_item;
			dev_item = btrfs_item_ptr(leaf, slot,
6133
						  struct btrfs_dev_item);
6134 6135 6136
			ret = read_one_dev(root, leaf, dev_item);
			if (ret)
				goto error;
6137 6138 6139 6140
		} else if (found_key.type == BTRFS_CHUNK_ITEM_KEY) {
			struct btrfs_chunk *chunk;
			chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);
			ret = read_one_chunk(root, &found_key, leaf, chunk);
Y
Yan Zheng 已提交
6141 6142
			if (ret)
				goto error;
6143 6144 6145 6146 6147
		}
		path->slots[0]++;
	}
	ret = 0;
error:
6148 6149 6150
	unlock_chunks(root);
	mutex_unlock(&uuid_mutex);

Y
Yan Zheng 已提交
6151
	btrfs_free_path(path);
6152 6153
	return ret;
}
6154

6155 6156 6157 6158 6159
void btrfs_init_devices_late(struct btrfs_fs_info *fs_info)
{
	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
	struct btrfs_device *device;

6160 6161 6162 6163 6164 6165 6166 6167
	while (fs_devices) {
		mutex_lock(&fs_devices->device_list_mutex);
		list_for_each_entry(device, &fs_devices->devices, dev_list)
			device->dev_root = fs_info->dev_root;
		mutex_unlock(&fs_devices->device_list_mutex);

		fs_devices = fs_devices->seed;
	}
6168 6169
}

6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214 6215 6216 6217 6218 6219 6220 6221 6222 6223 6224 6225 6226 6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239 6240 6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257
static void __btrfs_reset_dev_stats(struct btrfs_device *dev)
{
	int i;

	for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++)
		btrfs_dev_stat_reset(dev, i);
}

int btrfs_init_dev_stats(struct btrfs_fs_info *fs_info)
{
	struct btrfs_key key;
	struct btrfs_key found_key;
	struct btrfs_root *dev_root = fs_info->dev_root;
	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
	struct extent_buffer *eb;
	int slot;
	int ret = 0;
	struct btrfs_device *device;
	struct btrfs_path *path = NULL;
	int i;

	path = btrfs_alloc_path();
	if (!path) {
		ret = -ENOMEM;
		goto out;
	}

	mutex_lock(&fs_devices->device_list_mutex);
	list_for_each_entry(device, &fs_devices->devices, dev_list) {
		int item_size;
		struct btrfs_dev_stats_item *ptr;

		key.objectid = 0;
		key.type = BTRFS_DEV_STATS_KEY;
		key.offset = device->devid;
		ret = btrfs_search_slot(NULL, dev_root, &key, path, 0, 0);
		if (ret) {
			__btrfs_reset_dev_stats(device);
			device->dev_stats_valid = 1;
			btrfs_release_path(path);
			continue;
		}
		slot = path->slots[0];
		eb = path->nodes[0];
		btrfs_item_key_to_cpu(eb, &found_key, slot);
		item_size = btrfs_item_size_nr(eb, slot);

		ptr = btrfs_item_ptr(eb, slot,
				     struct btrfs_dev_stats_item);

		for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++) {
			if (item_size >= (1 + i) * sizeof(__le64))
				btrfs_dev_stat_set(device, i,
					btrfs_dev_stats_value(eb, ptr, i));
			else
				btrfs_dev_stat_reset(device, i);
		}

		device->dev_stats_valid = 1;
		btrfs_dev_stat_print_on_load(device);
		btrfs_release_path(path);
	}
	mutex_unlock(&fs_devices->device_list_mutex);

out:
	btrfs_free_path(path);
	return ret < 0 ? ret : 0;
}

static int update_dev_stat_item(struct btrfs_trans_handle *trans,
				struct btrfs_root *dev_root,
				struct btrfs_device *device)
{
	struct btrfs_path *path;
	struct btrfs_key key;
	struct extent_buffer *eb;
	struct btrfs_dev_stats_item *ptr;
	int ret;
	int i;

	key.objectid = 0;
	key.type = BTRFS_DEV_STATS_KEY;
	key.offset = device->devid;

	path = btrfs_alloc_path();
	BUG_ON(!path);
	ret = btrfs_search_slot(trans, dev_root, &key, path, -1, 1);
	if (ret < 0) {
6258 6259
		printk_in_rcu(KERN_WARNING "BTRFS: "
			"error %d while searching for dev_stats item for device %s!\n",
6260
			      ret, rcu_str_deref(device->name));
6261 6262 6263 6264 6265 6266 6267 6268
		goto out;
	}

	if (ret == 0 &&
	    btrfs_item_size_nr(path->nodes[0], path->slots[0]) < sizeof(*ptr)) {
		/* need to delete old one and insert a new one */
		ret = btrfs_del_item(trans, dev_root, path);
		if (ret != 0) {
6269 6270
			printk_in_rcu(KERN_WARNING "BTRFS: "
				"delete too small dev_stats item for device %s failed %d!\n",
6271
				      rcu_str_deref(device->name), ret);
6272 6273 6274 6275 6276 6277 6278 6279 6280 6281 6282
			goto out;
		}
		ret = 1;
	}

	if (ret == 1) {
		/* need to insert a new item */
		btrfs_release_path(path);
		ret = btrfs_insert_empty_item(trans, dev_root, path,
					      &key, sizeof(*ptr));
		if (ret < 0) {
6283 6284
			printk_in_rcu(KERN_WARNING "BTRFS: "
					  "insert dev_stats item for device %s failed %d!\n",
6285
				      rcu_str_deref(device->name), ret);
6286 6287 6288 6289 6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306 6307 6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326
			goto out;
		}
	}

	eb = path->nodes[0];
	ptr = btrfs_item_ptr(eb, path->slots[0], struct btrfs_dev_stats_item);
	for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++)
		btrfs_set_dev_stats_value(eb, ptr, i,
					  btrfs_dev_stat_read(device, i));
	btrfs_mark_buffer_dirty(eb);

out:
	btrfs_free_path(path);
	return ret;
}

/*
 * called from commit_transaction. Writes all changed device stats to disk.
 */
int btrfs_run_dev_stats(struct btrfs_trans_handle *trans,
			struct btrfs_fs_info *fs_info)
{
	struct btrfs_root *dev_root = fs_info->dev_root;
	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
	struct btrfs_device *device;
	int ret = 0;

	mutex_lock(&fs_devices->device_list_mutex);
	list_for_each_entry(device, &fs_devices->devices, dev_list) {
		if (!device->dev_stats_valid || !device->dev_stats_dirty)
			continue;

		ret = update_dev_stat_item(trans, dev_root, device);
		if (!ret)
			device->dev_stats_dirty = 0;
	}
	mutex_unlock(&fs_devices->device_list_mutex);

	return ret;
}

6327 6328 6329 6330 6331 6332
void btrfs_dev_stat_inc_and_print(struct btrfs_device *dev, int index)
{
	btrfs_dev_stat_inc(dev, index);
	btrfs_dev_stat_print_on_error(dev);
}

6333
static void btrfs_dev_stat_print_on_error(struct btrfs_device *dev)
6334
{
6335 6336
	if (!dev->dev_stats_valid)
		return;
6337 6338
	printk_ratelimited_in_rcu(KERN_ERR "BTRFS: "
			   "bdev %s errs: wr %u, rd %u, flush %u, corrupt %u, gen %u\n",
6339
			   rcu_str_deref(dev->name),
6340 6341 6342
			   btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_WRITE_ERRS),
			   btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_READ_ERRS),
			   btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_FLUSH_ERRS),
6343 6344
			   btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_CORRUPTION_ERRS),
			   btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_GENERATION_ERRS));
6345
}
6346

6347 6348
static void btrfs_dev_stat_print_on_load(struct btrfs_device *dev)
{
6349 6350 6351 6352 6353 6354 6355 6356
	int i;

	for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++)
		if (btrfs_dev_stat_read(dev, i) != 0)
			break;
	if (i == BTRFS_DEV_STAT_VALUES_MAX)
		return; /* all values == 0, suppress message */

6357 6358
	printk_in_rcu(KERN_INFO "BTRFS: "
		   "bdev %s errs: wr %u, rd %u, flush %u, corrupt %u, gen %u\n",
6359
	       rcu_str_deref(dev->name),
6360 6361 6362 6363 6364 6365 6366
	       btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_WRITE_ERRS),
	       btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_READ_ERRS),
	       btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_FLUSH_ERRS),
	       btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_CORRUPTION_ERRS),
	       btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_GENERATION_ERRS));
}

6367
int btrfs_get_dev_stats(struct btrfs_root *root,
6368
			struct btrfs_ioctl_get_dev_stats *stats)
6369 6370 6371 6372 6373 6374
{
	struct btrfs_device *dev;
	struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
	int i;

	mutex_lock(&fs_devices->device_list_mutex);
6375
	dev = btrfs_find_device(root->fs_info, stats->devid, NULL, NULL);
6376 6377 6378
	mutex_unlock(&fs_devices->device_list_mutex);

	if (!dev) {
6379
		btrfs_warn(root->fs_info, "get dev_stats failed, device not found");
6380
		return -ENODEV;
6381
	} else if (!dev->dev_stats_valid) {
6382
		btrfs_warn(root->fs_info, "get dev_stats failed, not yet valid");
6383
		return -ENODEV;
6384
	} else if (stats->flags & BTRFS_DEV_STATS_RESET) {
6385 6386 6387 6388 6389 6390 6391 6392 6393 6394 6395 6396 6397 6398 6399 6400
		for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++) {
			if (stats->nr_items > i)
				stats->values[i] =
					btrfs_dev_stat_read_and_reset(dev, i);
			else
				btrfs_dev_stat_reset(dev, i);
		}
	} else {
		for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++)
			if (stats->nr_items > i)
				stats->values[i] = btrfs_dev_stat_read(dev, i);
	}
	if (stats->nr_items > BTRFS_DEV_STAT_VALUES_MAX)
		stats->nr_items = BTRFS_DEV_STAT_VALUES_MAX;
	return 0;
}
6401 6402 6403 6404 6405 6406 6407 6408 6409 6410 6411 6412 6413 6414 6415 6416 6417 6418

int btrfs_scratch_superblock(struct btrfs_device *device)
{
	struct buffer_head *bh;
	struct btrfs_super_block *disk_super;

	bh = btrfs_read_dev_super(device->bdev);
	if (!bh)
		return -EINVAL;
	disk_super = (struct btrfs_super_block *)bh->b_data;

	memset(&disk_super->magic, 0, sizeof(disk_super->magic));
	set_buffer_dirty(bh);
	sync_dirty_buffer(bh);
	brelse(bh);

	return 0;
}
反馈
建议
客服 返回
顶部