volumes.c 112.3 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>
I
Ilya Dryomov 已提交
26
#include <linux/kthread.h>
27
#include <asm/div64.h>
C
Chris Mason 已提交
28
#include "compat.h"
29 30 31 32 33 34
#include "ctree.h"
#include "extent_map.h"
#include "disk-io.h"
#include "transaction.h"
#include "print-tree.h"
#include "volumes.h"
35
#include "async-thread.h"
36
#include "check-integrity.h"
37

Y
Yan Zheng 已提交
38 39 40 41 42
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);

43 44 45
static DEFINE_MUTEX(uuid_mutex);
static LIST_HEAD(fs_uuids);

46 47 48 49 50 51 52 53 54 55
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);
}

Y
Yan Zheng 已提交
56 57 58 59 60 61 62 63 64 65 66 67 68 69
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);
		kfree(device->name);
		kfree(device);
	}
	kfree(fs_devices);
}

70
void btrfs_cleanup_fs_uuids(void)
71 72 73
{
	struct btrfs_fs_devices *fs_devices;

Y
Yan Zheng 已提交
74 75 76 77
	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 已提交
78
		free_fs_devices(fs_devices);
79 80 81
	}
}

82 83
static noinline struct btrfs_device *__find_device(struct list_head *head,
						   u64 devid, u8 *uuid)
84 85 86
{
	struct btrfs_device *dev;

Q
Qinghuang Feng 已提交
87
	list_for_each_entry(dev, head, dev_list) {
88
		if (dev->devid == devid &&
89
		    (!uuid || !memcmp(dev->uuid, uuid, BTRFS_UUID_SIZE))) {
90
			return dev;
91
		}
92 93 94 95
	}
	return NULL;
}

96
static noinline struct btrfs_fs_devices *find_fsid(u8 *fsid)
97 98 99
{
	struct btrfs_fs_devices *fs_devices;

Q
Qinghuang Feng 已提交
100
	list_for_each_entry(fs_devices, &fs_uuids, list) {
101 102 103 104 105 106
		if (memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE) == 0)
			return fs_devices;
	}
	return NULL;
}

107 108 109 110 111 112 113 114 115 116 117 118 119 120
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;
}

121 122 123 124 125 126 127 128 129 130 131
/*
 * 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.
 */
132
static noinline void run_scheduled_bios(struct btrfs_device *device)
133 134 135
{
	struct bio *pending;
	struct backing_dev_info *bdi;
136
	struct btrfs_fs_info *fs_info;
137
	struct btrfs_pending_bios *pending_bios;
138 139 140
	struct bio *tail;
	struct bio *cur;
	int again = 0;
141
	unsigned long num_run;
142
	unsigned long batch_run = 0;
143
	unsigned long limit;
144
	unsigned long last_waited = 0;
145
	int force_reg = 0;
M
Miao Xie 已提交
146
	int sync_pending = 0;
147 148 149 150 151 152 153 154 155
	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);
156

157
	bdi = blk_get_backing_dev_info(device->bdev);
158 159 160 161
	fs_info = device->dev_root->fs_info;
	limit = btrfs_async_submit_limit(fs_info);
	limit = limit * 2 / 3;

162 163 164
loop:
	spin_lock(&device->io_lock);

165
loop_lock:
166
	num_run = 0;
167

168 169 170 171 172
	/* 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
	 */
173
	if (!force_reg && device->pending_sync_bios.head) {
174
		pending_bios = &device->pending_sync_bios;
175 176
		force_reg = 1;
	} else {
177
		pending_bios = &device->pending_bios;
178 179
		force_reg = 0;
	}
180 181 182

	pending = pending_bios->head;
	tail = pending_bios->tail;
183 184 185 186 187 188 189 190 191 192
	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.
	 */
193 194
	if (device->pending_sync_bios.head == NULL &&
	    device->pending_bios.head == NULL) {
195 196
		again = 0;
		device->running_pending = 0;
197 198 199
	} else {
		again = 1;
		device->running_pending = 1;
200
	}
201 202 203 204

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

205 206
	spin_unlock(&device->io_lock);

C
Chris Mason 已提交
207
	while (pending) {
208 209

		rmb();
210 211 212 213 214 215 216 217
		/* 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)) {
218 219 220 221 222
			spin_lock(&device->io_lock);
			requeue_list(pending_bios, pending, tail);
			goto loop_lock;
		}

223 224 225
		cur = pending;
		pending = pending->bi_next;
		cur->bi_next = NULL;
226 227 228 229 230
		atomic_dec(&fs_info->nr_async_bios);

		if (atomic_read(&fs_info->nr_async_bios) < limit &&
		    waitqueue_active(&fs_info->async_submit_wait))
			wake_up(&fs_info->async_submit_wait);
231 232

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

234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249
		/*
		 * 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;
		}

250
		btrfsic_submit_bio(cur->bi_rw, cur);
251 252
		num_run++;
		batch_run++;
J
Jens Axboe 已提交
253
		if (need_resched())
254
			cond_resched();
255 256 257 258 259 260

		/*
		 * we made progress, there is more work to do and the bdi
		 * is now congested.  Back off and let other work structs
		 * run instead
		 */
C
Chris Mason 已提交
261
		if (pending && bdi_write_congested(bdi) && batch_run > 8 &&
262
		    fs_info->fs_devices->open_devices > 1) {
263
			struct io_context *ioc;
264

265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286
			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;
J
Jens Axboe 已提交
287
				if (need_resched())
288
					cond_resched();
289 290
				continue;
			}
291
			spin_lock(&device->io_lock);
292
			requeue_list(pending_bios, pending, tail);
293
			device->running_pending = 1;
294 295 296 297 298

			spin_unlock(&device->io_lock);
			btrfs_requeue_work(&device->work);
			goto done;
		}
C
Chris Mason 已提交
299 300 301 302 303 304
		/* unplug every 64 requests just for good measure */
		if (batch_run % 64 == 0) {
			blk_finish_plug(&plug);
			blk_start_plug(&plug);
			sync_pending = 0;
		}
305
	}
306

307 308 309 310 311 312 313 314 315
	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);

316
done:
317
	blk_finish_plug(&plug);
318 319
}

320
static void pending_bios_fn(struct btrfs_work *work)
321 322 323 324 325 326 327
{
	struct btrfs_device *device;

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

328
static noinline int device_list_add(const char *path,
329 330 331 332 333 334
			   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;
	u64 found_transid = btrfs_super_generation(disk_super);
335
	char *name;
336 337 338

	fs_devices = find_fsid(disk_super->fsid);
	if (!fs_devices) {
339
		fs_devices = kzalloc(sizeof(*fs_devices), GFP_NOFS);
340 341 342
		if (!fs_devices)
			return -ENOMEM;
		INIT_LIST_HEAD(&fs_devices->devices);
343
		INIT_LIST_HEAD(&fs_devices->alloc_list);
344 345 346 347
		list_add(&fs_devices->list, &fs_uuids);
		memcpy(fs_devices->fsid, disk_super->fsid, BTRFS_FSID_SIZE);
		fs_devices->latest_devid = devid;
		fs_devices->latest_trans = found_transid;
348
		mutex_init(&fs_devices->device_list_mutex);
349 350
		device = NULL;
	} else {
351 352
		device = __find_device(&fs_devices->devices, devid,
				       disk_super->dev_item.uuid);
353 354
	}
	if (!device) {
Y
Yan Zheng 已提交
355 356 357
		if (fs_devices->opened)
			return -EBUSY;

358 359 360 361 362 363
		device = kzalloc(sizeof(*device), GFP_NOFS);
		if (!device) {
			/* we can safely leave the fs_devices entry around */
			return -ENOMEM;
		}
		device->devid = devid;
364
		device->work.func = pending_bios_fn;
365 366
		memcpy(device->uuid, disk_super->dev_item.uuid,
		       BTRFS_UUID_SIZE);
367
		spin_lock_init(&device->io_lock);
368 369 370 371 372
		device->name = kstrdup(path, GFP_NOFS);
		if (!device->name) {
			kfree(device);
			return -ENOMEM;
		}
Y
Yan Zheng 已提交
373
		INIT_LIST_HEAD(&device->dev_alloc_list);
374

375 376 377 378 379 380 381 382
		/* init readahead state */
		spin_lock_init(&device->reada_lock);
		device->reada_curr_zone = NULL;
		atomic_set(&device->reada_in_flight, 0);
		device->reada_next = 0;
		INIT_RADIX_TREE(&device->reada_zones, GFP_NOFS & ~__GFP_WAIT);
		INIT_RADIX_TREE(&device->reada_extents, GFP_NOFS & ~__GFP_WAIT);

383
		mutex_lock(&fs_devices->device_list_mutex);
384
		list_add_rcu(&device->dev_list, &fs_devices->devices);
385 386
		mutex_unlock(&fs_devices->device_list_mutex);

Y
Yan Zheng 已提交
387
		device->fs_devices = fs_devices;
388
		fs_devices->num_devices++;
389
	} else if (!device->name || strcmp(device->name, path)) {
390 391 392 393 394
		name = kstrdup(path, GFP_NOFS);
		if (!name)
			return -ENOMEM;
		kfree(device->name);
		device->name = name;
395 396 397 398
		if (device->missing) {
			fs_devices->missing_devices--;
			device->missing = 0;
		}
399 400 401 402 403 404 405 406 407 408
	}

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

Y
Yan Zheng 已提交
409 410 411 412 413 414 415 416 417 418 419 420 421
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;

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

	INIT_LIST_HEAD(&fs_devices->devices);
	INIT_LIST_HEAD(&fs_devices->alloc_list);
	INIT_LIST_HEAD(&fs_devices->list);
422
	mutex_init(&fs_devices->device_list_mutex);
Y
Yan Zheng 已提交
423 424 425 426
	fs_devices->latest_devid = orig->latest_devid;
	fs_devices->latest_trans = orig->latest_trans;
	memcpy(fs_devices->fsid, orig->fsid, sizeof(fs_devices->fsid));

427
	/* We have held the volume lock, it is safe to get the devices. */
Y
Yan Zheng 已提交
428 429 430 431 432 433
	list_for_each_entry(orig_dev, &orig->devices, dev_list) {
		device = kzalloc(sizeof(*device), GFP_NOFS);
		if (!device)
			goto error;

		device->name = kstrdup(orig_dev->name, GFP_NOFS);
J
Julia Lawall 已提交
434 435
		if (!device->name) {
			kfree(device);
Y
Yan Zheng 已提交
436
			goto error;
J
Julia Lawall 已提交
437
		}
Y
Yan Zheng 已提交
438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455

		device->devid = orig_dev->devid;
		device->work.func = pending_bios_fn;
		memcpy(device->uuid, orig_dev->uuid, sizeof(device->uuid));
		spin_lock_init(&device->io_lock);
		INIT_LIST_HEAD(&device->dev_list);
		INIT_LIST_HEAD(&device->dev_alloc_list);

		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);
}

456
void btrfs_close_extra_devices(struct btrfs_fs_devices *fs_devices)
457
{
Q
Qinghuang Feng 已提交
458
	struct btrfs_device *device, *next;
459

460 461 462 463
	struct block_device *latest_bdev = NULL;
	u64 latest_devid = 0;
	u64 latest_transid = 0;

464 465
	mutex_lock(&uuid_mutex);
again:
466
	/* This is the initialized path, it is safe to release the devices. */
Q
Qinghuang Feng 已提交
467
	list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) {
468 469 470 471 472 473 474
		if (device->in_fs_metadata) {
			if (!latest_transid ||
			    device->generation > latest_transid) {
				latest_devid = device->devid;
				latest_transid = device->generation;
				latest_bdev = device->bdev;
			}
Y
Yan Zheng 已提交
475
			continue;
476
		}
Y
Yan Zheng 已提交
477 478

		if (device->bdev) {
479
			blkdev_put(device->bdev, device->mode);
Y
Yan Zheng 已提交
480 481 482 483 484 485 486 487
			device->bdev = NULL;
			fs_devices->open_devices--;
		}
		if (device->writeable) {
			list_del_init(&device->dev_alloc_list);
			device->writeable = 0;
			fs_devices->rw_devices--;
		}
Y
Yan Zheng 已提交
488 489 490 491
		list_del_init(&device->dev_list);
		fs_devices->num_devices--;
		kfree(device->name);
		kfree(device);
492
	}
Y
Yan Zheng 已提交
493 494 495 496 497 498

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

499 500 501 502
	fs_devices->latest_bdev = latest_bdev;
	fs_devices->latest_devid = latest_devid;
	fs_devices->latest_trans = latest_transid;

503 504
	mutex_unlock(&uuid_mutex);
}
505

506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528
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);

	kfree(device->name);
	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 已提交
529
static int __btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
530 531
{
	struct btrfs_device *device;
Y
Yan Zheng 已提交
532

Y
Yan Zheng 已提交
533 534
	if (--fs_devices->opened > 0)
		return 0;
535

536
	mutex_lock(&fs_devices->device_list_mutex);
Q
Qinghuang Feng 已提交
537
	list_for_each_entry(device, &fs_devices->devices, dev_list) {
538 539 540
		struct btrfs_device *new_device;

		if (device->bdev)
541
			fs_devices->open_devices--;
542

Y
Yan Zheng 已提交
543 544 545 546 547
		if (device->writeable) {
			list_del_init(&device->dev_alloc_list);
			fs_devices->rw_devices--;
		}

548 549 550
		if (device->can_discard)
			fs_devices->num_can_discard--;

551 552 553 554
		new_device = kmalloc(sizeof(*new_device), GFP_NOFS);
		BUG_ON(!new_device);
		memcpy(new_device, device, sizeof(*new_device));
		new_device->name = kstrdup(device->name, GFP_NOFS);
A
Arne Jansen 已提交
555
		BUG_ON(device->name && !new_device->name);
556 557 558
		new_device->bdev = NULL;
		new_device->writeable = 0;
		new_device->in_fs_metadata = 0;
559
		new_device->can_discard = 0;
560 561 562
		list_replace_rcu(&device->dev_list, &new_device->dev_list);

		call_rcu(&device->rcu, free_device);
563
	}
564 565
	mutex_unlock(&fs_devices->device_list_mutex);

Y
Yan Zheng 已提交
566 567
	WARN_ON(fs_devices->open_devices);
	WARN_ON(fs_devices->rw_devices);
Y
Yan Zheng 已提交
568 569 570
	fs_devices->opened = 0;
	fs_devices->seeding = 0;

571 572 573
	return 0;
}

Y
Yan Zheng 已提交
574 575
int btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
{
Y
Yan Zheng 已提交
576
	struct btrfs_fs_devices *seed_devices = NULL;
Y
Yan Zheng 已提交
577 578 579 580
	int ret;

	mutex_lock(&uuid_mutex);
	ret = __btrfs_close_devices(fs_devices);
Y
Yan Zheng 已提交
581 582 583 584
	if (!fs_devices->opened) {
		seed_devices = fs_devices->seed;
		fs_devices->seed = NULL;
	}
Y
Yan Zheng 已提交
585
	mutex_unlock(&uuid_mutex);
Y
Yan Zheng 已提交
586 587 588 589 590 591 592

	while (seed_devices) {
		fs_devices = seed_devices;
		seed_devices = fs_devices->seed;
		__btrfs_close_devices(fs_devices);
		free_fs_devices(fs_devices);
	}
Y
Yan Zheng 已提交
593 594 595
	return ret;
}

Y
Yan Zheng 已提交
596 597
static int __btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
				fmode_t flags, void *holder)
598
{
599
	struct request_queue *q;
600 601 602
	struct block_device *bdev;
	struct list_head *head = &fs_devices->devices;
	struct btrfs_device *device;
603 604 605 606 607 608
	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 已提交
609
	int seeding = 1;
610
	int ret = 0;
611

612 613
	flags |= FMODE_EXCL;

Q
Qinghuang Feng 已提交
614
	list_for_each_entry(device, head, dev_list) {
615 616
		if (device->bdev)
			continue;
617 618 619
		if (!device->name)
			continue;

620
		bdev = blkdev_get_by_path(device->name, flags, holder);
621
		if (IS_ERR(bdev)) {
C
Chris Mason 已提交
622
			printk(KERN_INFO "open %s failed\n", device->name);
623
			goto error;
624
		}
625
		set_blocksize(bdev, 4096);
626

Y
Yan Zheng 已提交
627
		bh = btrfs_read_dev_super(bdev);
628
		if (!bh)
629 630 631
			goto error_close;

		disk_super = (struct btrfs_super_block *)bh->b_data;
632
		devid = btrfs_stack_device_id(&disk_super->dev_item);
633 634 635
		if (devid != device->devid)
			goto error_brelse;

Y
Yan Zheng 已提交
636 637 638 639 640 641
		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) {
642
			latest_devid = devid;
Y
Yan Zheng 已提交
643
			latest_transid = device->generation;
644 645 646
			latest_bdev = bdev;
		}

Y
Yan Zheng 已提交
647 648 649 650 651 652 653
		if (btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_SEEDING) {
			device->writeable = 0;
		} else {
			device->writeable = !bdev_read_only(bdev);
			seeding = 0;
		}

654 655 656 657 658 659
		q = bdev_get_queue(bdev);
		if (blk_queue_discard(q)) {
			device->can_discard = 1;
			fs_devices->num_can_discard++;
		}

660
		device->bdev = bdev;
661
		device->in_fs_metadata = 0;
662 663
		device->mode = flags;

C
Chris Mason 已提交
664 665 666
		if (!blk_queue_nonrot(bdev_get_queue(bdev)))
			fs_devices->rotating = 1;

667
		fs_devices->open_devices++;
Y
Yan Zheng 已提交
668 669 670 671 672
		if (device->writeable) {
			fs_devices->rw_devices++;
			list_add(&device->dev_alloc_list,
				 &fs_devices->alloc_list);
		}
673
		brelse(bh);
674
		continue;
675

676 677 678
error_brelse:
		brelse(bh);
error_close:
679
		blkdev_put(bdev, flags);
680 681
error:
		continue;
682
	}
683
	if (fs_devices->open_devices == 0) {
684
		ret = -EINVAL;
685 686
		goto out;
	}
Y
Yan Zheng 已提交
687 688
	fs_devices->seeding = seeding;
	fs_devices->opened = 1;
689 690 691
	fs_devices->latest_bdev = latest_bdev;
	fs_devices->latest_devid = latest_devid;
	fs_devices->latest_trans = latest_transid;
Y
Yan Zheng 已提交
692
	fs_devices->total_rw_bytes = 0;
693
out:
Y
Yan Zheng 已提交
694 695 696 697
	return ret;
}

int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
698
		       fmode_t flags, void *holder)
Y
Yan Zheng 已提交
699 700 701 702 703
{
	int ret;

	mutex_lock(&uuid_mutex);
	if (fs_devices->opened) {
Y
Yan Zheng 已提交
704 705
		fs_devices->opened++;
		ret = 0;
Y
Yan Zheng 已提交
706
	} else {
707
		ret = __btrfs_open_devices(fs_devices, flags, holder);
Y
Yan Zheng 已提交
708
	}
709 710 711 712
	mutex_unlock(&uuid_mutex);
	return ret;
}

713
int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
714 715 716 717 718 719 720
			  struct btrfs_fs_devices **fs_devices_ret)
{
	struct btrfs_super_block *disk_super;
	struct block_device *bdev;
	struct buffer_head *bh;
	int ret;
	u64 devid;
721
	u64 transid;
722

723 724
	flags |= FMODE_EXCL;
	bdev = blkdev_get_by_path(path, flags, holder);
725 726 727 728 729 730

	if (IS_ERR(bdev)) {
		ret = PTR_ERR(bdev);
		goto error;
	}

731
	mutex_lock(&uuid_mutex);
732 733 734
	ret = set_blocksize(bdev, 4096);
	if (ret)
		goto error_close;
Y
Yan Zheng 已提交
735
	bh = btrfs_read_dev_super(bdev);
736
	if (!bh) {
737
		ret = -EINVAL;
738 739 740
		goto error_close;
	}
	disk_super = (struct btrfs_super_block *)bh->b_data;
741
	devid = btrfs_stack_device_id(&disk_super->dev_item);
742
	transid = btrfs_super_generation(disk_super);
743
	if (disk_super->label[0])
C
Chris Mason 已提交
744
		printk(KERN_INFO "device label %s ", disk_super->label);
I
Ilya Dryomov 已提交
745 746
	else
		printk(KERN_INFO "device fsid %pU ", disk_super->fsid);
747
	printk(KERN_CONT "devid %llu transid %llu %s\n",
C
Chris Mason 已提交
748
	       (unsigned long long)devid, (unsigned long long)transid, path);
749 750 751 752
	ret = device_list_add(path, disk_super, devid, fs_devices_ret);

	brelse(bh);
error_close:
753
	mutex_unlock(&uuid_mutex);
754
	blkdev_put(bdev, flags);
755 756 757
error:
	return ret;
}
758

759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842
/* 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;

	if (start >= device->total_bytes)
		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;
}

843
/*
844 845 846 847 848 849 850
 * 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
 *
851 852 853
 * 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
854 855 856 857 858 859 860 861
 *
 * @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.
862
 */
863
int find_free_dev_extent(struct btrfs_device *device, u64 num_bytes,
864
			 u64 *start, u64 *len)
865 866 867
{
	struct btrfs_key key;
	struct btrfs_root *root = device->dev_root;
868
	struct btrfs_dev_extent *dev_extent;
Y
Yan Zheng 已提交
869
	struct btrfs_path *path;
870 871 872 873 874
	u64 hole_size;
	u64 max_hole_start;
	u64 max_hole_size;
	u64 extent_end;
	u64 search_start;
875 876
	u64 search_end = device->total_bytes;
	int ret;
877
	int slot;
878 879 880 881
	struct extent_buffer *l;

	/* FIXME use last free of some kind */

882 883 884
	/* 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 已提交
885
	search_start = max(root->fs_info->alloc_start, 1024ull * 1024);
886

887 888
	max_hole_start = search_start;
	max_hole_size = 0;
889
	hole_size = 0;
890 891 892 893 894 895 896 897 898 899 900 901 902

	if (search_start >= search_end) {
		ret = -ENOSPC;
		goto error;
	}

	path = btrfs_alloc_path();
	if (!path) {
		ret = -ENOMEM;
		goto error;
	}
	path->reada = 2;

903 904 905
	key.objectid = device->devid;
	key.offset = search_start;
	key.type = BTRFS_DEV_EXTENT_KEY;
906

907
	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
908
	if (ret < 0)
909
		goto out;
910 911 912
	if (ret > 0) {
		ret = btrfs_previous_item(root, path, key.objectid, key.type);
		if (ret < 0)
913
			goto out;
914
	}
915

916 917 918 919 920 921 922 923
	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)
924 925 926
				goto out;

			break;
927 928 929 930 931 932 933
		}
		btrfs_item_key_to_cpu(l, &key, slot);

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

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

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

939 940
		if (key.offset > search_start) {
			hole_size = key.offset - search_start;
941

942 943 944 945
			if (hole_size > max_hole_size) {
				max_hole_start = search_start;
				max_hole_size = hole_size;
			}
946

947 948 949 950 951 952 953 954 955 956 957 958
			/*
			 * 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;
959 960 961 962
			}
		}

		dev_extent = btrfs_item_ptr(l, slot, struct btrfs_dev_extent);
963 964 965 966
		extent_end = key.offset + btrfs_dev_extent_length(l,
								  dev_extent);
		if (extent_end > search_start)
			search_start = extent_end;
967 968 969 970 971
next:
		path->slots[0]++;
		cond_resched();
	}

972 973 974 975 976 977 978 979
	/*
	 * 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;

980 981 982
	if (hole_size > max_hole_size) {
		max_hole_start = search_start;
		max_hole_size = hole_size;
983 984
	}

985 986 987 988 989 990 991
	/* See above. */
	if (hole_size < num_bytes)
		ret = -ENOSPC;
	else
		ret = 0;

out:
Y
Yan Zheng 已提交
992
	btrfs_free_path(path);
993 994
error:
	*start = max_hole_start;
995
	if (len)
996
		*len = max_hole_size;
997 998 999
	return ret;
}

1000
static int btrfs_free_dev_extent(struct btrfs_trans_handle *trans,
1001 1002 1003 1004 1005 1006 1007
			  struct btrfs_device *device,
			  u64 start)
{
	int ret;
	struct btrfs_path *path;
	struct btrfs_root *root = device->dev_root;
	struct btrfs_key key;
1008 1009 1010
	struct btrfs_key found_key;
	struct extent_buffer *leaf = NULL;
	struct btrfs_dev_extent *extent = NULL;
1011 1012 1013 1014 1015 1016 1017 1018

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

	key.objectid = device->devid;
	key.offset = start;
	key.type = BTRFS_DEV_EXTENT_KEY;
M
Miao Xie 已提交
1019
again:
1020
	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1021 1022 1023
	if (ret > 0) {
		ret = btrfs_previous_item(root, path, key.objectid,
					  BTRFS_DEV_EXTENT_KEY);
1024 1025
		if (ret)
			goto out;
1026 1027 1028 1029 1030 1031
		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);
M
Miao Xie 已提交
1032 1033 1034
		key = found_key;
		btrfs_release_path(path);
		goto again;
1035 1036 1037 1038 1039
	} else if (ret == 0) {
		leaf = path->nodes[0];
		extent = btrfs_item_ptr(leaf, path->slots[0],
					struct btrfs_dev_extent);
	}
1040 1041
	BUG_ON(ret);

1042 1043 1044 1045 1046 1047 1048
	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);
	}
1049 1050
	ret = btrfs_del_item(trans, root, path);

1051
out:
1052 1053 1054 1055
	btrfs_free_path(path);
	return ret;
}

Y
Yan Zheng 已提交
1056
int btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans,
1057
			   struct btrfs_device *device,
1058
			   u64 chunk_tree, u64 chunk_objectid,
Y
Yan Zheng 已提交
1059
			   u64 chunk_offset, u64 start, u64 num_bytes)
1060 1061 1062 1063 1064 1065 1066 1067
{
	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;

1068
	WARN_ON(!device->in_fs_metadata);
1069 1070 1071 1072 1073
	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

	key.objectid = device->devid;
Y
Yan Zheng 已提交
1074
	key.offset = start;
1075 1076 1077 1078 1079 1080 1081 1082
	key.type = BTRFS_DEV_EXTENT_KEY;
	ret = btrfs_insert_empty_item(trans, root, path, &key,
				      sizeof(*extent));
	BUG_ON(ret);

	leaf = path->nodes[0];
	extent = btrfs_item_ptr(leaf, path->slots[0],
				struct btrfs_dev_extent);
1083 1084 1085 1086 1087 1088 1089 1090
	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,
		    (unsigned long)btrfs_dev_extent_chunk_tree_uuid(extent),
		    BTRFS_UUID_SIZE);

1091 1092 1093 1094 1095 1096
	btrfs_set_dev_extent_length(leaf, extent, num_bytes);
	btrfs_mark_buffer_dirty(leaf);
	btrfs_free_path(path);
	return ret;
}

1097 1098
static noinline int find_next_chunk(struct btrfs_root *root,
				    u64 objectid, u64 *offset)
1099 1100 1101 1102
{
	struct btrfs_path *path;
	int ret;
	struct btrfs_key key;
1103
	struct btrfs_chunk *chunk;
1104 1105 1106
	struct btrfs_key found_key;

	path = btrfs_alloc_path();
1107 1108
	if (!path)
		return -ENOMEM;
1109

1110
	key.objectid = objectid;
1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
	key.offset = (u64)-1;
	key.type = BTRFS_CHUNK_ITEM_KEY;

	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
	if (ret < 0)
		goto error;

	BUG_ON(ret == 0);

	ret = btrfs_previous_item(root, path, 0, BTRFS_CHUNK_ITEM_KEY);
	if (ret) {
1122
		*offset = 0;
1123 1124 1125
	} else {
		btrfs_item_key_to_cpu(path->nodes[0], &found_key,
				      path->slots[0]);
1126 1127 1128 1129 1130 1131 1132 1133
		if (found_key.objectid != objectid)
			*offset = 0;
		else {
			chunk = btrfs_item_ptr(path->nodes[0], path->slots[0],
					       struct btrfs_chunk);
			*offset = found_key.offset +
				btrfs_chunk_length(path->nodes[0], chunk);
		}
1134 1135 1136 1137 1138 1139 1140
	}
	ret = 0;
error:
	btrfs_free_path(path);
	return ret;
}

Y
Yan Zheng 已提交
1141
static noinline int find_next_devid(struct btrfs_root *root, u64 *objectid)
1142 1143 1144 1145
{
	int ret;
	struct btrfs_key key;
	struct btrfs_key found_key;
Y
Yan Zheng 已提交
1146 1147 1148 1149 1150 1151 1152
	struct btrfs_path *path;

	root = root->fs_info->chunk_root;

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;
1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174

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

	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
	if (ret < 0)
		goto error;

	BUG_ON(ret == 0);

	ret = btrfs_previous_item(root, path, BTRFS_DEV_ITEMS_OBJECTID,
				  BTRFS_DEV_ITEM_KEY);
	if (ret) {
		*objectid = 1;
	} else {
		btrfs_item_key_to_cpu(path->nodes[0], &found_key,
				      path->slots[0]);
		*objectid = found_key.offset + 1;
	}
	ret = 0;
error:
Y
Yan Zheng 已提交
1175
	btrfs_free_path(path);
1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201
	return ret;
}

/*
 * the device information is stored in the chunk root
 * the btrfs_device struct should be fully filled in
 */
int btrfs_add_device(struct btrfs_trans_handle *trans,
		     struct btrfs_root *root,
		     struct btrfs_device *device)
{
	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 已提交
1202
	key.offset = device->devid;
1203 1204

	ret = btrfs_insert_empty_item(trans, root, path, &key,
1205
				      sizeof(*dev_item));
1206 1207 1208 1209 1210 1211 1212
	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 已提交
1213
	btrfs_set_device_generation(leaf, dev_item, 0);
1214 1215 1216 1217 1218 1219
	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);
1220 1221 1222
	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);
1223
	btrfs_set_device_start_offset(leaf, dev_item, 0);
1224 1225

	ptr = (unsigned long)btrfs_device_uuid(dev_item);
1226
	write_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE);
Y
Yan Zheng 已提交
1227 1228
	ptr = (unsigned long)btrfs_device_fsid(dev_item);
	write_extent_buffer(leaf, root->fs_info->fsid, ptr, BTRFS_UUID_SIZE);
1229 1230
	btrfs_mark_buffer_dirty(leaf);

Y
Yan Zheng 已提交
1231
	ret = 0;
1232 1233 1234 1235
out:
	btrfs_free_path(path);
	return ret;
}
1236

1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250
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;

1251
	trans = btrfs_start_transaction(root, 0);
1252 1253 1254 1255
	if (IS_ERR(trans)) {
		btrfs_free_path(path);
		return PTR_ERR(trans);
	}
1256 1257 1258
	key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
	key.type = BTRFS_DEV_ITEM_KEY;
	key.offset = device->devid;
1259
	lock_chunks(root);
1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274

	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);
1275
	unlock_chunks(root);
1276 1277 1278 1279 1280 1281 1282
	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 已提交
1283
	struct btrfs_device *next_device;
1284
	struct block_device *bdev;
1285
	struct buffer_head *bh = NULL;
1286
	struct btrfs_super_block *disk_super;
1287
	struct btrfs_fs_devices *cur_devices;
1288 1289
	u64 all_avail;
	u64 devid;
Y
Yan Zheng 已提交
1290 1291
	u64 num_devices;
	u8 *dev_uuid;
1292
	int ret = 0;
1293
	bool clear_super = false;
1294 1295 1296 1297 1298 1299 1300 1301

	mutex_lock(&uuid_mutex);

	all_avail = root->fs_info->avail_data_alloc_bits |
		root->fs_info->avail_system_alloc_bits |
		root->fs_info->avail_metadata_alloc_bits;

	if ((all_avail & BTRFS_BLOCK_GROUP_RAID10) &&
1302
	    root->fs_info->fs_devices->num_devices <= 4) {
C
Chris Mason 已提交
1303 1304
		printk(KERN_ERR "btrfs: unable to go below four devices "
		       "on raid10\n");
1305 1306 1307 1308 1309
		ret = -EINVAL;
		goto out;
	}

	if ((all_avail & BTRFS_BLOCK_GROUP_RAID1) &&
1310
	    root->fs_info->fs_devices->num_devices <= 2) {
C
Chris Mason 已提交
1311 1312
		printk(KERN_ERR "btrfs: unable to go below two "
		       "devices on raid1\n");
1313 1314 1315 1316
		ret = -EINVAL;
		goto out;
	}

1317 1318 1319
	if (strcmp(device_path, "missing") == 0) {
		struct list_head *devices;
		struct btrfs_device *tmp;
1320

1321 1322
		device = NULL;
		devices = &root->fs_info->fs_devices->devices;
1323 1324 1325 1326
		/*
		 * It is safe to read the devices since the volume_mutex
		 * is held.
		 */
Q
Qinghuang Feng 已提交
1327
		list_for_each_entry(tmp, devices, dev_list) {
1328 1329 1330 1331 1332 1333 1334 1335 1336
			if (tmp->in_fs_metadata && !tmp->bdev) {
				device = tmp;
				break;
			}
		}
		bdev = NULL;
		bh = NULL;
		disk_super = NULL;
		if (!device) {
C
Chris Mason 已提交
1337 1338
			printk(KERN_ERR "btrfs: no missing devices found to "
			       "remove\n");
1339 1340 1341
			goto out;
		}
	} else {
1342 1343
		bdev = blkdev_get_by_path(device_path, FMODE_READ | FMODE_EXCL,
					  root->fs_info->bdev_holder);
1344 1345 1346 1347
		if (IS_ERR(bdev)) {
			ret = PTR_ERR(bdev);
			goto out;
		}
1348

Y
Yan Zheng 已提交
1349
		set_blocksize(bdev, 4096);
Y
Yan Zheng 已提交
1350
		bh = btrfs_read_dev_super(bdev);
1351
		if (!bh) {
1352
			ret = -EINVAL;
1353 1354 1355
			goto error_close;
		}
		disk_super = (struct btrfs_super_block *)bh->b_data;
1356
		devid = btrfs_stack_device_id(&disk_super->dev_item);
Y
Yan Zheng 已提交
1357 1358 1359
		dev_uuid = disk_super->dev_item.uuid;
		device = btrfs_find_device(root, devid, dev_uuid,
					   disk_super->fsid);
1360 1361 1362 1363
		if (!device) {
			ret = -ENOENT;
			goto error_brelse;
		}
Y
Yan Zheng 已提交
1364
	}
1365

Y
Yan Zheng 已提交
1366
	if (device->writeable && root->fs_info->fs_devices->rw_devices == 1) {
C
Chris Mason 已提交
1367 1368
		printk(KERN_ERR "btrfs: unable to remove the only writeable "
		       "device\n");
Y
Yan Zheng 已提交
1369 1370 1371 1372 1373
		ret = -EINVAL;
		goto error_brelse;
	}

	if (device->writeable) {
1374
		lock_chunks(root);
Y
Yan Zheng 已提交
1375
		list_del_init(&device->dev_alloc_list);
1376
		unlock_chunks(root);
Y
Yan Zheng 已提交
1377
		root->fs_info->fs_devices->rw_devices--;
1378
		clear_super = true;
1379
	}
1380 1381 1382

	ret = btrfs_shrink_device(device, 0);
	if (ret)
1383
		goto error_undo;
1384 1385 1386

	ret = btrfs_rm_dev_item(root->fs_info->chunk_root, device);
	if (ret)
1387
		goto error_undo;
1388

1389 1390 1391 1392 1393
	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 已提交
1394
	device->in_fs_metadata = 0;
A
Arne Jansen 已提交
1395
	btrfs_scrub_cancel_dev(root, device);
1396 1397 1398 1399 1400 1401

	/*
	 * the device list mutex makes sure that we don't change
	 * the device list while someone else is writing out all
	 * the device supers.
	 */
1402 1403

	cur_devices = device->fs_devices;
1404
	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
1405
	list_del_rcu(&device->dev_list);
1406

Y
Yan Zheng 已提交
1407
	device->fs_devices->num_devices--;
Y
Yan Zheng 已提交
1408

1409 1410 1411
	if (device->missing)
		root->fs_info->fs_devices->missing_devices--;

Y
Yan Zheng 已提交
1412 1413 1414 1415 1416 1417 1418
	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;

1419
	if (device->bdev)
Y
Yan Zheng 已提交
1420
		device->fs_devices->open_devices--;
1421 1422 1423

	call_rcu(&device->rcu, free_device);
	mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
Y
Yan Zheng 已提交
1424

1425 1426
	num_devices = btrfs_super_num_devices(root->fs_info->super_copy) - 1;
	btrfs_set_super_num_devices(root->fs_info->super_copy, num_devices);
Y
Yan Zheng 已提交
1427

1428
	if (cur_devices->open_devices == 0) {
Y
Yan Zheng 已提交
1429 1430 1431
		struct btrfs_fs_devices *fs_devices;
		fs_devices = root->fs_info->fs_devices;
		while (fs_devices) {
1432
			if (fs_devices->seed == cur_devices)
Y
Yan Zheng 已提交
1433 1434
				break;
			fs_devices = fs_devices->seed;
Y
Yan Zheng 已提交
1435
		}
1436 1437
		fs_devices->seed = cur_devices->seed;
		cur_devices->seed = NULL;
1438
		lock_chunks(root);
1439
		__btrfs_close_devices(cur_devices);
1440
		unlock_chunks(root);
1441
		free_fs_devices(cur_devices);
Y
Yan Zheng 已提交
1442 1443 1444 1445 1446 1447
	}

	/*
	 * at this point, the device is zero sized.  We want to
	 * remove it from the devices list and zero out the old super
	 */
1448
	if (clear_super) {
1449 1450 1451 1452 1453 1454 1455
		/* 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);
	}
1456 1457 1458 1459 1460 1461

	ret = 0;

error_brelse:
	brelse(bh);
error_close:
1462
	if (bdev)
1463
		blkdev_put(bdev, FMODE_READ | FMODE_EXCL);
1464 1465 1466
out:
	mutex_unlock(&uuid_mutex);
	return ret;
1467 1468
error_undo:
	if (device->writeable) {
1469
		lock_chunks(root);
1470 1471
		list_add(&device->dev_alloc_list,
			 &root->fs_info->fs_devices->alloc_list);
1472
		unlock_chunks(root);
1473 1474 1475
		root->fs_info->fs_devices->rw_devices++;
	}
	goto error_brelse;
1476 1477
}

Y
Yan Zheng 已提交
1478 1479 1480
/*
 * does all the dirty work required for changing file system's UUID.
 */
1481
static int btrfs_prepare_sprout(struct btrfs_root *root)
Y
Yan Zheng 已提交
1482 1483 1484
{
	struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
	struct btrfs_fs_devices *old_devices;
Y
Yan Zheng 已提交
1485
	struct btrfs_fs_devices *seed_devices;
1486
	struct btrfs_super_block *disk_super = root->fs_info->super_copy;
Y
Yan Zheng 已提交
1487 1488 1489 1490
	struct btrfs_device *device;
	u64 super_flags;

	BUG_ON(!mutex_is_locked(&uuid_mutex));
Y
Yan Zheng 已提交
1491
	if (!fs_devices->seeding)
Y
Yan Zheng 已提交
1492 1493
		return -EINVAL;

Y
Yan Zheng 已提交
1494 1495
	seed_devices = kzalloc(sizeof(*fs_devices), GFP_NOFS);
	if (!seed_devices)
Y
Yan Zheng 已提交
1496 1497
		return -ENOMEM;

Y
Yan Zheng 已提交
1498 1499 1500 1501
	old_devices = clone_fs_devices(fs_devices);
	if (IS_ERR(old_devices)) {
		kfree(seed_devices);
		return PTR_ERR(old_devices);
Y
Yan Zheng 已提交
1502
	}
Y
Yan Zheng 已提交
1503

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

Y
Yan Zheng 已提交
1506 1507 1508 1509
	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);
1510
	mutex_init(&seed_devices->device_list_mutex);
1511 1512

	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
1513 1514
	list_splice_init_rcu(&fs_devices->devices, &seed_devices->devices,
			      synchronize_rcu);
1515 1516
	mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);

Y
Yan Zheng 已提交
1517 1518 1519 1520 1521
	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 已提交
1522 1523 1524
	fs_devices->seeding = 0;
	fs_devices->num_devices = 0;
	fs_devices->open_devices = 0;
Y
Yan Zheng 已提交
1525
	fs_devices->seed = seed_devices;
Y
Yan Zheng 已提交
1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576

	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);
	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]);
1577
			btrfs_release_path(path);
Y
Yan Zheng 已提交
1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612
			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);
		read_extent_buffer(leaf, dev_uuid,
				   (unsigned long)btrfs_device_uuid(dev_item),
				   BTRFS_UUID_SIZE);
		read_extent_buffer(leaf, fs_uuid,
				   (unsigned long)btrfs_device_fsid(dev_item),
				   BTRFS_UUID_SIZE);
		device = btrfs_find_device(root, devid, dev_uuid, fs_uuid);
		BUG_ON(!device);

		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;
}

1613 1614
int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
{
1615
	struct request_queue *q;
1616 1617 1618 1619
	struct btrfs_trans_handle *trans;
	struct btrfs_device *device;
	struct block_device *bdev;
	struct list_head *devices;
Y
Yan Zheng 已提交
1620
	struct super_block *sb = root->fs_info->sb;
1621
	u64 total_bytes;
Y
Yan Zheng 已提交
1622
	int seeding_dev = 0;
1623 1624
	int ret = 0;

Y
Yan Zheng 已提交
1625 1626
	if ((sb->s_flags & MS_RDONLY) && !root->fs_info->fs_devices->seeding)
		return -EINVAL;
1627

1628
	bdev = blkdev_get_by_path(device_path, FMODE_WRITE | FMODE_EXCL,
1629
				  root->fs_info->bdev_holder);
1630 1631
	if (IS_ERR(bdev))
		return PTR_ERR(bdev);
1632

Y
Yan Zheng 已提交
1633 1634 1635 1636 1637 1638
	if (root->fs_info->fs_devices->seeding) {
		seeding_dev = 1;
		down_write(&sb->s_umount);
		mutex_lock(&uuid_mutex);
	}

1639
	filemap_write_and_wait(bdev->bd_inode->i_mapping);
1640

1641
	devices = &root->fs_info->fs_devices->devices;
1642 1643 1644 1645
	/*
	 * we have the volume lock, so we don't need the extra
	 * device list mutex while reading the list here.
	 */
Q
Qinghuang Feng 已提交
1646
	list_for_each_entry(device, devices, dev_list) {
1647 1648
		if (device->bdev == bdev) {
			ret = -EEXIST;
Y
Yan Zheng 已提交
1649
			goto error;
1650 1651 1652 1653 1654 1655 1656
		}
	}

	device = kzalloc(sizeof(*device), GFP_NOFS);
	if (!device) {
		/* we can safely leave the fs_devices entry around */
		ret = -ENOMEM;
Y
Yan Zheng 已提交
1657
		goto error;
1658 1659 1660 1661 1662
	}

	device->name = kstrdup(device_path, GFP_NOFS);
	if (!device->name) {
		kfree(device);
Y
Yan Zheng 已提交
1663 1664
		ret = -ENOMEM;
		goto error;
1665
	}
Y
Yan Zheng 已提交
1666 1667 1668

	ret = find_next_devid(root, &device->devid);
	if (ret) {
1669
		kfree(device->name);
Y
Yan Zheng 已提交
1670 1671 1672 1673
		kfree(device);
		goto error;
	}

1674
	trans = btrfs_start_transaction(root, 0);
1675
	if (IS_ERR(trans)) {
1676
		kfree(device->name);
1677 1678 1679 1680 1681
		kfree(device);
		ret = PTR_ERR(trans);
		goto error;
	}

Y
Yan Zheng 已提交
1682 1683
	lock_chunks(root);

1684 1685 1686
	q = bdev_get_queue(bdev);
	if (blk_queue_discard(q))
		device->can_discard = 1;
Y
Yan Zheng 已提交
1687 1688 1689 1690 1691
	device->writeable = 1;
	device->work.func = pending_bios_fn;
	generate_random_uuid(device->uuid);
	spin_lock_init(&device->io_lock);
	device->generation = trans->transid;
1692 1693 1694 1695
	device->io_width = root->sectorsize;
	device->io_align = root->sectorsize;
	device->sector_size = root->sectorsize;
	device->total_bytes = i_size_read(bdev->bd_inode);
1696
	device->disk_total_bytes = device->total_bytes;
1697 1698
	device->dev_root = root->fs_info->dev_root;
	device->bdev = bdev;
1699
	device->in_fs_metadata = 1;
1700
	device->mode = FMODE_EXCL;
Y
Yan Zheng 已提交
1701
	set_blocksize(device->bdev, 4096);
1702

Y
Yan Zheng 已提交
1703 1704
	if (seeding_dev) {
		sb->s_flags &= ~MS_RDONLY;
1705
		ret = btrfs_prepare_sprout(root);
Y
Yan Zheng 已提交
1706 1707
		BUG_ON(ret);
	}
1708

Y
Yan Zheng 已提交
1709
	device->fs_devices = root->fs_info->fs_devices;
1710 1711 1712 1713 1714 1715

	/*
	 * we don't want write_supers to jump in here with our device
	 * half setup
	 */
	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
1716
	list_add_rcu(&device->dev_list, &root->fs_info->fs_devices->devices);
Y
Yan Zheng 已提交
1717 1718 1719 1720 1721
	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++;
1722 1723
	if (device->can_discard)
		root->fs_info->fs_devices->num_can_discard++;
Y
Yan Zheng 已提交
1724
	root->fs_info->fs_devices->total_rw_bytes += device->total_bytes;
1725

1726 1727 1728 1729
	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);

C
Chris Mason 已提交
1730 1731 1732
	if (!blk_queue_nonrot(bdev_get_queue(bdev)))
		root->fs_info->fs_devices->rotating = 1;

1733 1734
	total_bytes = btrfs_super_total_bytes(root->fs_info->super_copy);
	btrfs_set_super_total_bytes(root->fs_info->super_copy,
1735 1736
				    total_bytes + device->total_bytes);

1737 1738
	total_bytes = btrfs_super_num_devices(root->fs_info->super_copy);
	btrfs_set_super_num_devices(root->fs_info->super_copy,
1739
				    total_bytes + 1);
1740
	mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
1741

Y
Yan Zheng 已提交
1742 1743 1744 1745 1746 1747 1748 1749 1750
	if (seeding_dev) {
		ret = init_first_rw_device(trans, root, device);
		BUG_ON(ret);
		ret = btrfs_finish_sprout(trans, root);
		BUG_ON(ret);
	} else {
		ret = btrfs_add_device(trans, root, device);
	}

1751 1752 1753 1754 1755 1756
	/*
	 * we've got more storage, clear any full flags on the space
	 * infos
	 */
	btrfs_clear_space_info_full(root->fs_info);

1757
	unlock_chunks(root);
Y
Yan Zheng 已提交
1758
	btrfs_commit_transaction(trans, root);
1759

Y
Yan Zheng 已提交
1760 1761 1762
	if (seeding_dev) {
		mutex_unlock(&uuid_mutex);
		up_write(&sb->s_umount);
1763

Y
Yan Zheng 已提交
1764 1765 1766
		ret = btrfs_relocate_sys_chunks(root);
		BUG_ON(ret);
	}
1767

Y
Yan Zheng 已提交
1768 1769
	return ret;
error:
1770
	blkdev_put(bdev, FMODE_EXCL);
Y
Yan Zheng 已提交
1771 1772 1773 1774
	if (seeding_dev) {
		mutex_unlock(&uuid_mutex);
		up_write(&sb->s_umount);
	}
1775
	return ret;
1776 1777
}

C
Chris Mason 已提交
1778 1779
static noinline int btrfs_update_device(struct btrfs_trans_handle *trans,
					struct btrfs_device *device)
1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814
{
	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);
1815
	btrfs_set_device_total_bytes(leaf, dev_item, device->disk_total_bytes);
1816 1817 1818 1819 1820 1821 1822 1823
	btrfs_set_device_bytes_used(leaf, dev_item, device->bytes_used);
	btrfs_mark_buffer_dirty(leaf);

out:
	btrfs_free_path(path);
	return ret;
}

1824
static int __btrfs_grow_device(struct btrfs_trans_handle *trans,
1825 1826 1827
		      struct btrfs_device *device, u64 new_size)
{
	struct btrfs_super_block *super_copy =
1828
		device->dev_root->fs_info->super_copy;
1829 1830 1831
	u64 old_total = btrfs_super_total_bytes(super_copy);
	u64 diff = new_size - device->total_bytes;

Y
Yan Zheng 已提交
1832 1833 1834 1835 1836
	if (!device->writeable)
		return -EACCES;
	if (new_size <= device->total_bytes)
		return -EINVAL;

1837
	btrfs_set_super_total_bytes(super_copy, old_total + diff);
Y
Yan Zheng 已提交
1838 1839 1840
	device->fs_devices->total_rw_bytes += diff;

	device->total_bytes = new_size;
1841
	device->disk_total_bytes = new_size;
1842 1843
	btrfs_clear_space_info_full(device->dev_root->fs_info);

1844 1845 1846
	return btrfs_update_device(trans, device);
}

1847 1848 1849 1850 1851 1852 1853 1854 1855 1856
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;
}

1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880
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);
	BUG_ON(ret);

	ret = btrfs_del_item(trans, root, path);

	btrfs_free_path(path);
1881
	return ret;
1882 1883
}

1884
static int btrfs_del_sys_chunk(struct btrfs_root *root, u64 chunk_objectid, u64
1885 1886
			chunk_offset)
{
1887
	struct btrfs_super_block *super_copy = root->fs_info->super_copy;
1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929
	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;
}

1930
static int btrfs_relocate_chunk(struct btrfs_root *root,
1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945
			 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;

1946 1947 1948 1949
	ret = btrfs_can_relocate(extent_root, chunk_offset);
	if (ret)
		return -ENOSPC;

1950
	/* step one, relocate all the extents inside this chunk */
Z
Zheng Yan 已提交
1951
	ret = btrfs_relocate_block_group(extent_root, chunk_offset);
1952 1953
	if (ret)
		return ret;
1954

1955
	trans = btrfs_start_transaction(root, 0);
1956
	BUG_ON(IS_ERR(trans));
1957

1958 1959
	lock_chunks(root);

1960 1961 1962 1963
	/*
	 * step two, delete the device extents and the
	 * chunk tree entries
	 */
1964
	read_lock(&em_tree->lock);
1965
	em = lookup_extent_mapping(em_tree, chunk_offset, 1);
1966
	read_unlock(&em_tree->lock);
1967

1968
	BUG_ON(!em || em->start > chunk_offset ||
1969
	       em->start + em->len < chunk_offset);
1970 1971 1972 1973 1974 1975
	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);
1976

1977 1978 1979 1980
		if (map->stripes[i].dev) {
			ret = btrfs_update_device(trans, map->stripes[i].dev);
			BUG_ON(ret);
		}
1981 1982 1983 1984 1985 1986
	}
	ret = btrfs_free_chunk(trans, root, chunk_tree, chunk_objectid,
			       chunk_offset);

	BUG_ON(ret);

1987 1988
	trace_btrfs_chunk_free(root, map, chunk_offset, em->len);

1989 1990 1991 1992 1993
	if (map->type & BTRFS_BLOCK_GROUP_SYSTEM) {
		ret = btrfs_del_sys_chunk(root, chunk_objectid, chunk_offset);
		BUG_ON(ret);
	}

Y
Yan Zheng 已提交
1994 1995 1996
	ret = btrfs_remove_block_group(trans, extent_root, chunk_offset);
	BUG_ON(ret);

1997
	write_lock(&em_tree->lock);
Y
Yan Zheng 已提交
1998
	remove_extent_mapping(em_tree, em);
1999
	write_unlock(&em_tree->lock);
Y
Yan Zheng 已提交
2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023

	kfree(map);
	em->bdev = NULL;

	/* 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;
2024 2025
	bool retried = false;
	int failed = 0;
Y
Yan Zheng 已提交
2026 2027 2028 2029 2030 2031
	int ret;

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

2032
again:
Y
Yan Zheng 已提交
2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048
	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;
		BUG_ON(ret == 0);

		ret = btrfs_previous_item(chunk_root, path, key.objectid,
					  key.type);
		if (ret < 0)
			goto error;
		if (ret > 0)
			break;
Z
Zheng Yan 已提交
2049

Y
Yan Zheng 已提交
2050 2051
		leaf = path->nodes[0];
		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
Z
Zheng Yan 已提交
2052

Y
Yan Zheng 已提交
2053 2054 2055
		chunk = btrfs_item_ptr(leaf, path->slots[0],
				       struct btrfs_chunk);
		chunk_type = btrfs_chunk_type(leaf, chunk);
2056
		btrfs_release_path(path);
2057

Y
Yan Zheng 已提交
2058 2059 2060 2061
		if (chunk_type & BTRFS_BLOCK_GROUP_SYSTEM) {
			ret = btrfs_relocate_chunk(chunk_root, chunk_tree,
						   found_key.objectid,
						   found_key.offset);
2062 2063 2064 2065
			if (ret == -ENOSPC)
				failed++;
			else if (ret)
				BUG();
Y
Yan Zheng 已提交
2066
		}
2067

Y
Yan Zheng 已提交
2068 2069 2070 2071 2072
		if (found_key.offset == 0)
			break;
		key.offset = found_key.offset - 1;
	}
	ret = 0;
2073 2074 2075 2076 2077 2078 2079 2080
	if (failed && !retried) {
		failed = 0;
		retried = true;
		goto again;
	} else if (failed && retried) {
		WARN_ON(1);
		ret = -ENOSPC;
	}
Y
Yan Zheng 已提交
2081 2082 2083
error:
	btrfs_free_path(path);
	return ret;
2084 2085
}

2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176
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;
}

I
Ilya Dryomov 已提交
2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216
/*
 * 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;
	}
}

2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245
/*
 * 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 已提交
2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263
/*
 * Balance filters.  Return 1 if chunk should be filtered out
 * (should not be balanced).
 */
static int chunk_profiles_filter(u64 chunk_profile,
				 struct btrfs_balance_args *bargs)
{
	chunk_profile &= BTRFS_BLOCK_GROUP_PROFILE_MASK;

	if (chunk_profile == 0)
		chunk_profile = BTRFS_AVAIL_ALLOC_BIT_SINGLE;

	if (bargs->profiles & chunk_profile)
		return 0;

	return 1;
}

I
Ilya Dryomov 已提交
2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293
static u64 div_factor_fine(u64 num, int factor)
{
	if (factor <= 0)
		return 0;
	if (factor >= 100)
		return num;

	num *= factor;
	do_div(num, 100);
	return num;
}

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);

	user_thresh = div_factor_fine(cache->key.offset, bargs->usage);
	if (chunk_used < user_thresh)
		ret = 0;

	btrfs_put_block_group(cache);
	return ret;
}

I
Ilya Dryomov 已提交
2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310
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 已提交
2311 2312 2313 2314 2315 2316 2317 2318 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
/* [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 |
	     BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID10))
		factor = 2;
	else
		factor = 1;
	factor = num_stripes / factor;

	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;
}

2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364
/* [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;
}

2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381
static int chunk_soft_convert_filter(u64 chunk_profile,
				     struct btrfs_balance_args *bargs)
{
	if (!(bargs->flags & BTRFS_BALANCE_ARGS_CONVERT))
		return 0;

	chunk_profile &= BTRFS_BLOCK_GROUP_PROFILE_MASK;

	if (chunk_profile == 0)
		chunk_profile = BTRFS_AVAIL_ALLOC_BIT_SINGLE;

	if (bargs->target & chunk_profile)
		return 1;

	return 0;
}

2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402
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 已提交
2403 2404 2405 2406
	/* profiles filter */
	if ((bargs->flags & BTRFS_BALANCE_ARGS_PROFILES) &&
	    chunk_profiles_filter(chunk_type, bargs)) {
		return 0;
I
Ilya Dryomov 已提交
2407 2408 2409 2410 2411 2412
	}

	/* usage filter */
	if ((bargs->flags & BTRFS_BALANCE_ARGS_USAGE) &&
	    chunk_usage_filter(bctl->fs_info, chunk_offset, bargs)) {
		return 0;
I
Ilya Dryomov 已提交
2413 2414 2415 2416 2417 2418
	}

	/* devid filter */
	if ((bargs->flags & BTRFS_BALANCE_ARGS_DEVID) &&
	    chunk_devid_filter(leaf, chunk, bargs)) {
		return 0;
I
Ilya Dryomov 已提交
2419 2420 2421 2422 2423 2424
	}

	/* 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;
2425 2426 2427 2428 2429 2430
	}

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

2433 2434 2435 2436 2437 2438
	/* soft profile changing mode */
	if ((bargs->flags & BTRFS_BALANCE_ARGS_SOFT) &&
	    chunk_soft_convert_filter(chunk_type, bargs)) {
		return 0;
	}

2439 2440 2441
	return 1;
}

2442 2443 2444 2445 2446 2447 2448 2449 2450
static u64 div_factor(u64 num, int factor)
{
	if (factor == 10)
		return num;
	num *= factor;
	do_div(num, 10);
	return num;
}

2451
static int __btrfs_balance(struct btrfs_fs_info *fs_info)
2452
{
2453
	struct btrfs_balance_control *bctl = fs_info->balance_ctl;
2454 2455 2456
	struct btrfs_root *chunk_root = fs_info->chunk_root;
	struct btrfs_root *dev_root = fs_info->dev_root;
	struct list_head *devices;
2457 2458 2459
	struct btrfs_device *device;
	u64 old_size;
	u64 size_to_free;
2460
	struct btrfs_chunk *chunk;
2461 2462 2463
	struct btrfs_path *path;
	struct btrfs_key key;
	struct btrfs_key found_key;
2464
	struct btrfs_trans_handle *trans;
2465 2466
	struct extent_buffer *leaf;
	int slot;
2467 2468
	int ret;
	int enospc_errors = 0;
2469
	bool counting = true;
2470 2471

	/* step one make some room on all the devices */
2472
	devices = &fs_info->fs_devices->devices;
Q
Qinghuang Feng 已提交
2473
	list_for_each_entry(device, devices, dev_list) {
2474 2475 2476
		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 已提交
2477 2478
		if (!device->writeable ||
		    device->total_bytes - device->bytes_used > size_to_free)
2479 2480 2481
			continue;

		ret = btrfs_shrink_device(device, old_size - size_to_free);
2482 2483
		if (ret == -ENOSPC)
			break;
2484 2485
		BUG_ON(ret);

2486
		trans = btrfs_start_transaction(dev_root, 0);
2487
		BUG_ON(IS_ERR(trans));
2488 2489 2490 2491 2492 2493 2494 2495 2496

		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();
2497 2498 2499 2500
	if (!path) {
		ret = -ENOMEM;
		goto error;
	}
2501 2502 2503 2504 2505 2506

	/* zero out stat counters */
	spin_lock(&fs_info->balance_lock);
	memset(&bctl->stat, 0, sizeof(bctl->stat));
	spin_unlock(&fs_info->balance_lock);
again:
2507 2508 2509 2510
	key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
	key.offset = (u64)-1;
	key.type = BTRFS_CHUNK_ITEM_KEY;

C
Chris Mason 已提交
2511
	while (1) {
2512
		if ((!counting && atomic_read(&fs_info->balance_pause_req)) ||
2513
		    atomic_read(&fs_info->balance_cancel_req)) {
2514 2515 2516 2517
			ret = -ECANCELED;
			goto error;
		}

2518 2519 2520 2521 2522 2523 2524 2525 2526
		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)
2527
			BUG(); /* FIXME break ? */
2528 2529 2530

		ret = btrfs_previous_item(chunk_root, path, 0,
					  BTRFS_CHUNK_ITEM_KEY);
2531 2532
		if (ret) {
			ret = 0;
2533
			break;
2534
		}
2535

2536 2537 2538
		leaf = path->nodes[0];
		slot = path->slots[0];
		btrfs_item_key_to_cpu(leaf, &found_key, slot);
2539

2540 2541
		if (found_key.objectid != key.objectid)
			break;
2542

2543
		/* chunk zero is special */
2544
		if (found_key.offset == 0)
2545 2546
			break;

2547 2548
		chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);

2549 2550 2551 2552 2553 2554
		if (!counting) {
			spin_lock(&fs_info->balance_lock);
			bctl->stat.considered++;
			spin_unlock(&fs_info->balance_lock);
		}

2555 2556
		ret = should_balance_chunk(chunk_root, leaf, chunk,
					   found_key.offset);
2557
		btrfs_release_path(path);
2558 2559 2560
		if (!ret)
			goto loop;

2561 2562 2563 2564 2565 2566 2567
		if (counting) {
			spin_lock(&fs_info->balance_lock);
			bctl->stat.expected++;
			spin_unlock(&fs_info->balance_lock);
			goto loop;
		}

2568 2569 2570 2571
		ret = btrfs_relocate_chunk(chunk_root,
					   chunk_root->root_key.objectid,
					   found_key.objectid,
					   found_key.offset);
2572 2573
		if (ret && ret != -ENOSPC)
			goto error;
2574
		if (ret == -ENOSPC) {
2575
			enospc_errors++;
2576 2577 2578 2579 2580
		} else {
			spin_lock(&fs_info->balance_lock);
			bctl->stat.completed++;
			spin_unlock(&fs_info->balance_lock);
		}
2581
loop:
2582
		key.offset = found_key.offset - 1;
2583
	}
2584

2585 2586 2587 2588 2589
	if (counting) {
		btrfs_release_path(path);
		counting = false;
		goto again;
	}
2590 2591
error:
	btrfs_free_path(path);
2592 2593 2594 2595 2596 2597 2598
	if (enospc_errors) {
		printk(KERN_INFO "btrfs: %d enospc errors during balance\n",
		       enospc_errors);
		if (!ret)
			ret = -ENOSPC;
	}

2599 2600 2601
	return ret;
}

2602 2603
static inline int balance_need_close(struct btrfs_fs_info *fs_info)
{
2604 2605 2606 2607
	/* 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);
2608 2609
}

2610 2611
static void __cancel_balance(struct btrfs_fs_info *fs_info)
{
2612 2613
	int ret;

2614
	unset_balance_control(fs_info);
2615 2616
	ret = del_balance_item(fs_info->tree_root);
	BUG_ON(ret);
2617 2618
}

2619
void update_ioctl_balance_args(struct btrfs_fs_info *fs_info, int lock,
2620 2621 2622 2623 2624 2625 2626 2627 2628
			       struct btrfs_ioctl_balance_args *bargs);

/*
 * 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;
2629
	u64 allowed;
2630 2631
	int ret;

2632
	if (btrfs_fs_closing(fs_info) ||
2633 2634
	    atomic_read(&fs_info->balance_pause_req) ||
	    atomic_read(&fs_info->balance_cancel_req)) {
2635 2636 2637 2638
		ret = -EINVAL;
		goto out;
	}

2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655
	/*
	 * In case of mixed groups both data and meta should be picked,
	 * and identical options should be given for both of them.
	 */
	allowed = btrfs_super_incompat_flags(fs_info->super_copy);
	if ((allowed & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS) &&
	    (bctl->flags & (BTRFS_BALANCE_DATA | BTRFS_BALANCE_METADATA))) {
		if (!(bctl->flags & BTRFS_BALANCE_DATA) ||
		    !(bctl->flags & BTRFS_BALANCE_METADATA) ||
		    memcmp(&bctl->data, &bctl->meta, sizeof(bctl->data))) {
			printk(KERN_ERR "btrfs: with mixed groups data and "
			       "metadata balance options must be the same\n");
			ret = -EINVAL;
			goto out;
		}
	}

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
	/*
	 * Profile changing sanity checks.  Skip them if a simple
	 * balance is requested.
	 */
	if (!((bctl->data.flags | bctl->sys.flags | bctl->meta.flags) &
	      BTRFS_BALANCE_ARGS_CONVERT))
		goto do_balance;

	allowed = BTRFS_AVAIL_ALLOC_BIT_SINGLE;
	if (fs_info->fs_devices->num_devices == 1)
		allowed |= BTRFS_BLOCK_GROUP_DUP;
	else if (fs_info->fs_devices->num_devices < 4)
		allowed |= (BTRFS_BLOCK_GROUP_RAID0 | BTRFS_BLOCK_GROUP_RAID1);
	else
		allowed |= (BTRFS_BLOCK_GROUP_RAID0 | BTRFS_BLOCK_GROUP_RAID1 |
				BTRFS_BLOCK_GROUP_RAID10);

	if (!profile_is_valid(bctl->data.target, 1) ||
	    bctl->data.target & ~allowed) {
		printk(KERN_ERR "btrfs: unable to start balance with target "
		       "data profile %llu\n",
		       (unsigned long long)bctl->data.target);
		ret = -EINVAL;
		goto out;
	}
	if (!profile_is_valid(bctl->meta.target, 1) ||
	    bctl->meta.target & ~allowed) {
		printk(KERN_ERR "btrfs: unable to start balance with target "
		       "metadata profile %llu\n",
		       (unsigned long long)bctl->meta.target);
		ret = -EINVAL;
		goto out;
	}
	if (!profile_is_valid(bctl->sys.target, 1) ||
	    bctl->sys.target & ~allowed) {
		printk(KERN_ERR "btrfs: unable to start balance with target "
		       "system profile %llu\n",
		       (unsigned long long)bctl->sys.target);
		ret = -EINVAL;
		goto out;
	}

	if (bctl->data.target & BTRFS_BLOCK_GROUP_DUP) {
		printk(KERN_ERR "btrfs: dup for data is not allowed\n");
		ret = -EINVAL;
		goto out;
	}

	/* allow to reduce meta or sys integrity only if force set */
	allowed = BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID1 |
			BTRFS_BLOCK_GROUP_RAID10;
	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) {
			printk(KERN_INFO "btrfs: force reducing metadata "
			       "integrity\n");
		} else {
			printk(KERN_ERR "btrfs: balance will reduce metadata "
			       "integrity, use force if you want this\n");
			ret = -EINVAL;
			goto out;
		}
	}

do_balance:
2725
	ret = insert_balance_item(fs_info->tree_root, bctl);
I
Ilya Dryomov 已提交
2726
	if (ret && ret != -EEXIST)
2727 2728
		goto out;

I
Ilya Dryomov 已提交
2729 2730 2731 2732 2733 2734 2735 2736 2737
	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);
	}
2738

2739
	atomic_inc(&fs_info->balance_running);
2740 2741 2742 2743 2744
	mutex_unlock(&fs_info->balance_mutex);

	ret = __btrfs_balance(fs_info);

	mutex_lock(&fs_info->balance_mutex);
2745
	atomic_dec(&fs_info->balance_running);
2746 2747 2748

	if (bargs) {
		memset(bargs, 0, sizeof(*bargs));
2749
		update_ioctl_balance_args(fs_info, 0, bargs);
2750 2751
	}

2752 2753 2754 2755 2756 2757
	if ((ret && ret != -ECANCELED && ret != -ENOSPC) ||
	    balance_need_close(fs_info)) {
		__cancel_balance(fs_info);
	}

	wake_up(&fs_info->balance_wait_q);
2758 2759 2760

	return ret;
out:
I
Ilya Dryomov 已提交
2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772
	if (bctl->flags & BTRFS_BALANCE_RESUME)
		__cancel_balance(fs_info);
	else
		kfree(bctl);
	return ret;
}

static int balance_kthread(void *data)
{
	struct btrfs_balance_control *bctl =
			(struct btrfs_balance_control *)data;
	struct btrfs_fs_info *fs_info = bctl->fs_info;
2773
	int ret = 0;
I
Ilya Dryomov 已提交
2774 2775 2776 2777 2778 2779

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

	set_balance_control(bctl);

2780 2781 2782 2783 2784 2785
	if (btrfs_test_opt(fs_info->tree_root, SKIP_BALANCE)) {
		printk(KERN_INFO "btrfs: force skipping balance\n");
	} else {
		printk(KERN_INFO "btrfs: continuing balance\n");
		ret = btrfs_balance(bctl, NULL);
	}
I
Ilya Dryomov 已提交
2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844

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

int btrfs_recover_balance(struct btrfs_root *tree_root)
{
	struct task_struct *tsk;
	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;

	bctl = kzalloc(sizeof(*bctl), GFP_NOFS);
	if (!bctl) {
		ret = -ENOMEM;
		goto out;
	}

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

	ret = btrfs_search_slot(NULL, tree_root, &key, path, 0, 0);
	if (ret < 0)
		goto out_bctl;
	if (ret > 0) { /* ret = -ENOENT; */
		ret = 0;
		goto out_bctl;
	}

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

	bctl->fs_info = tree_root->fs_info;
	bctl->flags = btrfs_balance_flags(leaf, item) | BTRFS_BALANCE_RESUME;

	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);

	tsk = kthread_run(balance_kthread, bctl, "btrfs-balance");
	if (IS_ERR(tsk))
		ret = PTR_ERR(tsk);
	else
		goto out;

out_bctl:
2845
	kfree(bctl);
I
Ilya Dryomov 已提交
2846 2847
out:
	btrfs_free_path(path);
2848 2849 2850
	return ret;
}

2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879
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;
}

2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915
int btrfs_cancel_balance(struct btrfs_fs_info *fs_info)
{
	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;
}

2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932
/*
 * 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;
2933 2934
	int failed = 0;
	bool retried = false;
2935 2936
	struct extent_buffer *l;
	struct btrfs_key key;
2937
	struct btrfs_super_block *super_copy = root->fs_info->super_copy;
2938
	u64 old_total = btrfs_super_total_bytes(super_copy);
2939
	u64 old_size = device->total_bytes;
2940 2941
	u64 diff = device->total_bytes - new_size;

Y
Yan Zheng 已提交
2942 2943
	if (new_size >= device->total_bytes)
		return -EINVAL;
2944 2945 2946 2947 2948 2949 2950

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

	path->reada = 2;

2951 2952
	lock_chunks(root);

2953
	device->total_bytes = new_size;
2954
	if (device->writeable) {
Y
Yan Zheng 已提交
2955
		device->fs_devices->total_rw_bytes -= diff;
2956 2957 2958 2959
		spin_lock(&root->fs_info->free_chunk_lock);
		root->fs_info->free_chunk_space -= diff;
		spin_unlock(&root->fs_info->free_chunk_lock);
	}
2960
	unlock_chunks(root);
2961

2962
again:
2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976
	key.objectid = device->devid;
	key.offset = (u64)-1;
	key.type = BTRFS_DEV_EXTENT_KEY;

	while (1) {
		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;
2977
			btrfs_release_path(path);
2978
			break;
2979 2980 2981 2982 2983 2984
		}

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

2985
		if (key.objectid != device->devid) {
2986
			btrfs_release_path(path);
2987
			break;
2988
		}
2989 2990 2991 2992

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

2993
		if (key.offset + length <= new_size) {
2994
			btrfs_release_path(path);
2995
			break;
2996
		}
2997 2998 2999 3000

		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);
3001
		btrfs_release_path(path);
3002 3003 3004

		ret = btrfs_relocate_chunk(root, chunk_tree, chunk_objectid,
					   chunk_offset);
3005
		if (ret && ret != -ENOSPC)
3006
			goto done;
3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022
		if (ret == -ENOSPC)
			failed++;
		key.offset -= 1;
	}

	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;
3023 3024 3025
		spin_lock(&root->fs_info->free_chunk_lock);
		root->fs_info->free_chunk_space += diff;
		spin_unlock(&root->fs_info->free_chunk_lock);
3026 3027
		unlock_chunks(root);
		goto done;
3028 3029
	}

3030
	/* Shrinking succeeded, else we would be at "done". */
3031
	trans = btrfs_start_transaction(root, 0);
3032 3033 3034 3035 3036
	if (IS_ERR(trans)) {
		ret = PTR_ERR(trans);
		goto done;
	}

3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050
	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);
3051 3052 3053 3054 3055
done:
	btrfs_free_path(path);
	return ret;
}

3056
static int btrfs_add_system_chunk(struct btrfs_root *root,
3057 3058 3059
			   struct btrfs_key *key,
			   struct btrfs_chunk *chunk, int item_size)
{
3060
	struct btrfs_super_block *super_copy = root->fs_info->super_copy;
3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078
	struct btrfs_disk_key disk_key;
	u32 array_size;
	u8 *ptr;

	array_size = btrfs_super_sys_array_size(super_copy);
	if (array_size + item_size > BTRFS_SYSTEM_CHUNK_ARRAY_SIZE)
		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;
}

3079 3080 3081 3082
/*
 * sort the devices in descending order by max_avail, total_avail
 */
static int btrfs_cmp_device_info(const void *a, const void *b)
3083
{
3084 3085
	const struct btrfs_device_info *di_a = a;
	const struct btrfs_device_info *di_b = b;
3086

3087
	if (di_a->max_avail > di_b->max_avail)
3088
		return -1;
3089
	if (di_a->max_avail < di_b->max_avail)
3090
		return 1;
3091 3092 3093 3094 3095
	if (di_a->total_avail > di_b->total_avail)
		return -1;
	if (di_a->total_avail < di_b->total_avail)
		return 1;
	return 0;
3096
}
3097

3098 3099 3100 3101 3102
static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
			       struct btrfs_root *extent_root,
			       struct map_lookup **map_ret,
			       u64 *num_bytes_out, u64 *stripe_size_out,
			       u64 start, u64 type)
3103
{
3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126
	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 */
	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;
	int ndevs;
	int i;
	int j;
3127

3128 3129 3130 3131
	if ((type & BTRFS_BLOCK_GROUP_RAID1) &&
	    (type & BTRFS_BLOCK_GROUP_DUP)) {
		WARN_ON(1);
		type &= ~BTRFS_BLOCK_GROUP_DUP;
C
Chris Mason 已提交
3132
	}
3133

3134 3135
	if (list_empty(&fs_devices->alloc_list))
		return -ENOSPC;
3136

3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150
	sub_stripes = 1;
	dev_stripes = 1;
	devs_increment = 1;
	ncopies = 1;
	devs_max = 0;	/* 0 == as many as possible */
	devs_min = 1;

	/*
	 * define the properties of each RAID type.
	 * FIXME: move this to a global table and use it in all RAID
	 * calculation code
	 */
	if (type & (BTRFS_BLOCK_GROUP_DUP)) {
		dev_stripes = 2;
3151
		ncopies = 2;
3152 3153 3154 3155 3156
		devs_max = 1;
	} else if (type & (BTRFS_BLOCK_GROUP_RAID0)) {
		devs_min = 2;
	} else if (type & (BTRFS_BLOCK_GROUP_RAID1)) {
		devs_increment = 2;
3157
		ncopies = 2;
3158 3159 3160 3161 3162 3163 3164 3165 3166 3167
		devs_max = 2;
		devs_min = 2;
	} else if (type & (BTRFS_BLOCK_GROUP_RAID10)) {
		sub_stripes = 2;
		devs_increment = 2;
		ncopies = 2;
		devs_min = 4;
	} else {
		devs_max = 1;
	}
3168

3169
	if (type & BTRFS_BLOCK_GROUP_DATA) {
3170 3171
		max_stripe_size = 1024 * 1024 * 1024;
		max_chunk_size = 10 * max_stripe_size;
3172
	} else if (type & BTRFS_BLOCK_GROUP_METADATA) {
3173 3174 3175 3176 3177
		/* 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;
3178
		max_chunk_size = max_stripe_size;
3179
	} else if (type & BTRFS_BLOCK_GROUP_SYSTEM) {
C
Chris Mason 已提交
3180
		max_stripe_size = 32 * 1024 * 1024;
3181 3182 3183 3184 3185
		max_chunk_size = 2 * max_stripe_size;
	} else {
		printk(KERN_ERR "btrfs: invalid chunk type 0x%llx requested\n",
		       type);
		BUG_ON(1);
3186 3187
	}

Y
Yan Zheng 已提交
3188 3189 3190
	/* 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);
3191

3192 3193 3194 3195
	devices_info = kzalloc(sizeof(*devices_info) * fs_devices->rw_devices,
			       GFP_NOFS);
	if (!devices_info)
		return -ENOMEM;
3196

3197
	cur = fs_devices->alloc_list.next;
3198

3199
	/*
3200 3201
	 * in the first pass through the devices list, we gather information
	 * about the available holes on each device.
3202
	 */
3203 3204 3205 3206 3207
	ndevs = 0;
	while (cur != &fs_devices->alloc_list) {
		struct btrfs_device *device;
		u64 max_avail;
		u64 dev_offset;
3208

3209
		device = list_entry(cur, struct btrfs_device, dev_alloc_list);
3210

3211
		cur = cur->next;
3212

3213 3214 3215 3216 3217 3218
		if (!device->writeable) {
			printk(KERN_ERR
			       "btrfs: read-only device in alloc_list\n");
			WARN_ON(1);
			continue;
		}
3219

3220 3221
		if (!device->in_fs_metadata)
			continue;
3222

3223 3224 3225 3226
		if (device->total_bytes > device->bytes_used)
			total_avail = device->total_bytes - device->bytes_used;
		else
			total_avail = 0;
3227 3228 3229 3230

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

3232
		ret = find_free_dev_extent(device,
3233 3234 3235 3236
					   max_stripe_size * dev_stripes,
					   &dev_offset, &max_avail);
		if (ret && ret != -ENOSPC)
			goto error;
3237

3238 3239
		if (ret == 0)
			max_avail = max_stripe_size * dev_stripes;
3240

3241 3242
		if (max_avail < BTRFS_STRIPE_LEN * dev_stripes)
			continue;
3243

3244 3245 3246 3247 3248 3249
		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;
	}
3250

3251 3252 3253 3254 3255
	/*
	 * now sort the devices by hole size / available space
	 */
	sort(devices_info, ndevs, sizeof(struct btrfs_device_info),
	     btrfs_cmp_device_info, NULL);
3256

3257 3258
	/* round down to number of usable stripes */
	ndevs -= ndevs % devs_increment;
3259

3260 3261 3262
	if (ndevs < devs_increment * sub_stripes || ndevs < devs_min) {
		ret = -ENOSPC;
		goto error;
3263
	}
3264

3265 3266 3267 3268 3269 3270 3271 3272
	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;
3273

3274 3275 3276
	if (stripe_size * num_stripes > max_chunk_size * ncopies) {
		stripe_size = max_chunk_size * ncopies;
		do_div(stripe_size, num_stripes);
3277 3278
	}

3279 3280 3281
	do_div(stripe_size, dev_stripes);
	do_div(stripe_size, BTRFS_STRIPE_LEN);
	stripe_size *= BTRFS_STRIPE_LEN;
3282 3283 3284 3285 3286 3287 3288

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

3290 3291 3292 3293 3294 3295
	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;
3296 3297
		}
	}
Y
Yan Zheng 已提交
3298
	map->sector_size = extent_root->sectorsize;
3299 3300 3301
	map->stripe_len = BTRFS_STRIPE_LEN;
	map->io_align = BTRFS_STRIPE_LEN;
	map->io_width = BTRFS_STRIPE_LEN;
Y
Yan Zheng 已提交
3302 3303
	map->type = type;
	map->sub_stripes = sub_stripes;
3304

Y
Yan Zheng 已提交
3305
	*map_ret = map;
3306
	num_bytes = stripe_size * (num_stripes / ncopies);
3307

3308 3309
	*stripe_size_out = stripe_size;
	*num_bytes_out = num_bytes;
3310

3311
	trace_btrfs_chunk_alloc(info->chunk_root, map, start, num_bytes);
3312

3313
	em = alloc_extent_map();
Y
Yan Zheng 已提交
3314
	if (!em) {
3315 3316
		ret = -ENOMEM;
		goto error;
3317
	}
Y
Yan Zheng 已提交
3318 3319
	em->bdev = (struct block_device *)map;
	em->start = start;
3320
	em->len = num_bytes;
Y
Yan Zheng 已提交
3321 3322
	em->block_start = 0;
	em->block_len = em->len;
3323

Y
Yan Zheng 已提交
3324
	em_tree = &extent_root->fs_info->mapping_tree.map_tree;
3325
	write_lock(&em_tree->lock);
Y
Yan Zheng 已提交
3326
	ret = add_extent_mapping(em_tree, em);
3327
	write_unlock(&em_tree->lock);
Y
Yan Zheng 已提交
3328 3329
	BUG_ON(ret);
	free_extent_map(em);
3330

Y
Yan Zheng 已提交
3331 3332
	ret = btrfs_make_block_group(trans, extent_root, 0, type,
				     BTRFS_FIRST_CHUNK_TREE_OBJECTID,
3333
				     start, num_bytes);
Y
Yan Zheng 已提交
3334
	BUG_ON(ret);
3335

3336 3337 3338 3339 3340 3341
	for (i = 0; i < map->num_stripes; ++i) {
		struct btrfs_device *device;
		u64 dev_offset;

		device = map->stripes[i].dev;
		dev_offset = map->stripes[i].physical;
3342 3343

		ret = btrfs_alloc_dev_extent(trans, device,
Y
Yan Zheng 已提交
3344 3345
				info->chunk_root->root_key.objectid,
				BTRFS_FIRST_CHUNK_TREE_OBJECTID,
3346
				start, dev_offset, stripe_size);
3347
		BUG_ON(ret);
Y
Yan Zheng 已提交
3348 3349
	}

3350
	kfree(devices_info);
Y
Yan Zheng 已提交
3351
	return 0;
3352 3353 3354 3355 3356

error:
	kfree(map);
	kfree(devices_info);
	return ret;
Y
Yan Zheng 已提交
3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381
}

static int __finish_chunk_alloc(struct btrfs_trans_handle *trans,
				struct btrfs_root *extent_root,
				struct map_lookup *map, u64 chunk_offset,
				u64 chunk_size, u64 stripe_size)
{
	u64 dev_offset;
	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;
	size_t item_size = btrfs_chunk_item_size(map->num_stripes);
	int index = 0;
	int ret;

	chunk = kzalloc(item_size, GFP_NOFS);
	if (!chunk)
		return -ENOMEM;

	index = 0;
	while (index < map->num_stripes) {
		device = map->stripes[index].dev;
		device->bytes_used += stripe_size;
3382 3383
		ret = btrfs_update_device(trans, device);
		BUG_ON(ret);
Y
Yan Zheng 已提交
3384 3385 3386
		index++;
	}

3387 3388 3389 3390 3391
	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 已提交
3392 3393 3394 3395 3396
	index = 0;
	stripe = &chunk->stripe;
	while (index < map->num_stripes) {
		device = map->stripes[index].dev;
		dev_offset = map->stripes[index].physical;
3397

3398 3399 3400
		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 已提交
3401
		stripe++;
3402 3403 3404
		index++;
	}

Y
Yan Zheng 已提交
3405
	btrfs_set_stack_chunk_length(chunk, chunk_size);
3406
	btrfs_set_stack_chunk_owner(chunk, extent_root->root_key.objectid);
Y
Yan Zheng 已提交
3407 3408 3409 3410 3411
	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);
3412
	btrfs_set_stack_chunk_sector_size(chunk, extent_root->sectorsize);
Y
Yan Zheng 已提交
3413
	btrfs_set_stack_chunk_sub_stripes(chunk, map->sub_stripes);
3414

Y
Yan Zheng 已提交
3415 3416 3417
	key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
	key.type = BTRFS_CHUNK_ITEM_KEY;
	key.offset = chunk_offset;
3418

Y
Yan Zheng 已提交
3419 3420
	ret = btrfs_insert_item(trans, chunk_root, &key, chunk, item_size);
	BUG_ON(ret);
3421

Y
Yan Zheng 已提交
3422
	if (map->type & BTRFS_BLOCK_GROUP_SYSTEM) {
3423
		ret = btrfs_add_system_chunk(chunk_root, &key, chunk,
Y
Yan Zheng 已提交
3424
					     item_size);
3425 3426
		BUG_ON(ret);
	}
3427

3428
	kfree(chunk);
Y
Yan Zheng 已提交
3429 3430
	return 0;
}
3431

Y
Yan Zheng 已提交
3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464
/*
 * 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;
	u64 chunk_size;
	u64 stripe_size;
	struct map_lookup *map;
	struct btrfs_root *chunk_root = extent_root->fs_info->chunk_root;
	int ret;

	ret = find_next_chunk(chunk_root, BTRFS_FIRST_CHUNK_TREE_OBJECTID,
			      &chunk_offset);
	if (ret)
		return ret;

	ret = __btrfs_alloc_chunk(trans, extent_root, &map, &chunk_size,
				  &stripe_size, chunk_offset, type);
	if (ret)
		return ret;

	ret = __finish_chunk_alloc(trans, extent_root, map, chunk_offset,
				   chunk_size, stripe_size);
	BUG_ON(ret);
	return 0;
}

C
Chris Mason 已提交
3465
static noinline int init_first_rw_device(struct btrfs_trans_handle *trans,
Y
Yan Zheng 已提交
3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483
					 struct btrfs_root *root,
					 struct btrfs_device *device)
{
	u64 chunk_offset;
	u64 sys_chunk_offset;
	u64 chunk_size;
	u64 sys_chunk_size;
	u64 stripe_size;
	u64 sys_stripe_size;
	u64 alloc_profile;
	struct map_lookup *map;
	struct map_lookup *sys_map;
	struct btrfs_fs_info *fs_info = root->fs_info;
	struct btrfs_root *extent_root = fs_info->extent_root;
	int ret;

	ret = find_next_chunk(fs_info->chunk_root,
			      BTRFS_FIRST_CHUNK_TREE_OBJECTID, &chunk_offset);
3484 3485
	if (ret)
		return ret;
Y
Yan Zheng 已提交
3486 3487

	alloc_profile = BTRFS_BLOCK_GROUP_METADATA |
3488
				fs_info->avail_metadata_alloc_bits;
Y
Yan Zheng 已提交
3489 3490 3491 3492 3493 3494 3495 3496 3497
	alloc_profile = btrfs_reduce_alloc_profile(root, alloc_profile);

	ret = __btrfs_alloc_chunk(trans, extent_root, &map, &chunk_size,
				  &stripe_size, chunk_offset, alloc_profile);
	BUG_ON(ret);

	sys_chunk_offset = chunk_offset + chunk_size;

	alloc_profile = BTRFS_BLOCK_GROUP_SYSTEM |
3498
				fs_info->avail_system_alloc_bits;
Y
Yan Zheng 已提交
3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521
	alloc_profile = btrfs_reduce_alloc_profile(root, alloc_profile);

	ret = __btrfs_alloc_chunk(trans, extent_root, &sys_map,
				  &sys_chunk_size, &sys_stripe_size,
				  sys_chunk_offset, alloc_profile);
	BUG_ON(ret);

	ret = btrfs_add_device(trans, fs_info->chunk_root, device);
	BUG_ON(ret);

	/*
	 * Modifying chunk tree needs allocating new blocks from both
	 * system block group and metadata block group. So we only can
	 * do operations require modifying the chunk tree after both
	 * block groups were created.
	 */
	ret = __finish_chunk_alloc(trans, extent_root, map, chunk_offset,
				   chunk_size, stripe_size);
	BUG_ON(ret);

	ret = __finish_chunk_alloc(trans, extent_root, sys_map,
				   sys_chunk_offset, sys_chunk_size,
				   sys_stripe_size);
3522
	BUG_ON(ret);
Y
Yan Zheng 已提交
3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533
	return 0;
}

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;

3534
	read_lock(&map_tree->map_tree.lock);
Y
Yan Zheng 已提交
3535
	em = lookup_extent_mapping(&map_tree->map_tree, chunk_offset, 1);
3536
	read_unlock(&map_tree->map_tree.lock);
Y
Yan Zheng 已提交
3537 3538 3539
	if (!em)
		return 1;

3540 3541 3542 3543 3544
	if (btrfs_test_opt(root, DEGRADED)) {
		free_extent_map(em);
		return 0;
	}

Y
Yan Zheng 已提交
3545 3546 3547 3548 3549 3550 3551
	map = (struct map_lookup *)em->bdev;
	for (i = 0; i < map->num_stripes; i++) {
		if (!map->stripes[i].dev->writeable) {
			readonly = 1;
			break;
		}
	}
3552
	free_extent_map(em);
Y
Yan Zheng 已提交
3553
	return readonly;
3554 3555 3556 3557
}

void btrfs_mapping_init(struct btrfs_mapping_tree *tree)
{
3558
	extent_map_tree_init(&tree->map_tree);
3559 3560 3561 3562 3563 3564
}

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

C
Chris Mason 已提交
3565
	while (1) {
3566
		write_lock(&tree->map_tree.lock);
3567 3568 3569
		em = lookup_extent_mapping(&tree->map_tree, 0, (u64)-1);
		if (em)
			remove_extent_mapping(&tree->map_tree, em);
3570
		write_unlock(&tree->map_tree.lock);
3571 3572 3573 3574 3575 3576 3577 3578 3579 3580
		if (!em)
			break;
		kfree(em->bdev);
		/* once for us */
		free_extent_map(em);
		/* once for the tree */
		free_extent_map(em);
	}
}

3581 3582 3583 3584 3585 3586 3587
int btrfs_num_copies(struct btrfs_mapping_tree *map_tree, u64 logical, u64 len)
{
	struct extent_map *em;
	struct map_lookup *map;
	struct extent_map_tree *em_tree = &map_tree->map_tree;
	int ret;

3588
	read_lock(&em_tree->lock);
3589
	em = lookup_extent_mapping(em_tree, logical, len);
3590
	read_unlock(&em_tree->lock);
3591 3592 3593 3594 3595 3596
	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_DUP | BTRFS_BLOCK_GROUP_RAID1))
		ret = map->num_stripes;
C
Chris Mason 已提交
3597 3598
	else if (map->type & BTRFS_BLOCK_GROUP_RAID10)
		ret = map->sub_stripes;
3599 3600 3601 3602 3603 3604
	else
		ret = 1;
	free_extent_map(em);
	return ret;
}

3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620
static int find_live_mirror(struct map_lookup *map, int first, int num,
			    int optimal)
{
	int i;
	if (map->stripes[optimal].dev->bdev)
		return optimal;
	for (i = first; i < first + num; i++) {
		if (map->stripes[i].dev->bdev)
			return i;
	}
	/* we couldn't find one that doesn't fail.  Just return something
	 * and the io error handling code will clean up eventually
	 */
	return optimal;
}

3621 3622
static int __btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
			     u64 logical, u64 *length,
3623
			     struct btrfs_bio **bbio_ret,
J
Jens Axboe 已提交
3624
			     int mirror_num)
3625 3626 3627 3628 3629
{
	struct extent_map *em;
	struct map_lookup *map;
	struct extent_map_tree *em_tree = &map_tree->map_tree;
	u64 offset;
3630
	u64 stripe_offset;
3631
	u64 stripe_end_offset;
3632
	u64 stripe_nr;
3633 3634
	u64 stripe_nr_orig;
	u64 stripe_nr_end;
3635
	int stripe_index;
3636
	int i;
L
Li Zefan 已提交
3637
	int ret = 0;
3638
	int num_stripes;
3639
	int max_errors = 0;
3640
	struct btrfs_bio *bbio = NULL;
3641

3642
	read_lock(&em_tree->lock);
3643
	em = lookup_extent_mapping(em_tree, logical, *length);
3644
	read_unlock(&em_tree->lock);
3645

3646
	if (!em) {
C
Chris Mason 已提交
3647 3648 3649
		printk(KERN_CRIT "unable to find logical %llu len %llu\n",
		       (unsigned long long)logical,
		       (unsigned long long)*length);
3650
		BUG();
3651
	}
3652 3653 3654 3655

	BUG_ON(em->start > logical || em->start + em->len < logical);
	map = (struct map_lookup *)em->bdev;
	offset = logical - em->start;
3656

3657 3658 3659
	if (mirror_num > map->num_stripes)
		mirror_num = 0;

3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672
	stripe_nr = offset;
	/*
	 * stripe_nr counts the total number of stripes we have to stride
	 * to get to this block
	 */
	do_div(stripe_nr, map->stripe_len);

	stripe_offset = stripe_nr * map->stripe_len;
	BUG_ON(offset < stripe_offset);

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

3673 3674
	if (rw & REQ_DISCARD)
		*length = min_t(u64, em->len - offset, *length);
3675
	else if (map->type & BTRFS_BLOCK_GROUP_PROFILE_MASK) {
3676 3677
		/* we limit the length of each bio to what fits in a stripe */
		*length = min_t(u64, em->len - offset,
3678
				map->stripe_len - stripe_offset);
3679 3680 3681
	} else {
		*length = em->len - offset;
	}
3682

3683
	if (!bbio_ret)
3684 3685
		goto out;

3686
	num_stripes = 1;
3687
	stripe_index = 0;
3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699
	stripe_nr_orig = stripe_nr;
	stripe_nr_end = (offset + *length + map->stripe_len - 1) &
			(~(map->stripe_len - 1));
	do_div(stripe_nr_end, map->stripe_len);
	stripe_end_offset = stripe_nr_end * map->stripe_len -
			    (offset + *length);
	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) {
3700
		if (rw & (REQ_WRITE | REQ_DISCARD))
3701
			num_stripes = map->num_stripes;
3702
		else if (mirror_num)
3703
			stripe_index = mirror_num - 1;
3704 3705 3706 3707
		else {
			stripe_index = find_live_mirror(map, 0,
					    map->num_stripes,
					    current->pid % map->num_stripes);
3708
			mirror_num = stripe_index + 1;
3709
		}
3710

3711
	} else if (map->type & BTRFS_BLOCK_GROUP_DUP) {
3712
		if (rw & (REQ_WRITE | REQ_DISCARD)) {
3713
			num_stripes = map->num_stripes;
3714
		} else if (mirror_num) {
3715
			stripe_index = mirror_num - 1;
3716 3717 3718
		} else {
			mirror_num = 1;
		}
3719

C
Chris Mason 已提交
3720 3721 3722 3723 3724 3725
	} 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;

J
Jens Axboe 已提交
3726
		if (rw & REQ_WRITE)
3727
			num_stripes = map->sub_stripes;
3728 3729 3730 3731
		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 已提交
3732 3733
		else if (mirror_num)
			stripe_index += mirror_num - 1;
3734 3735 3736 3737
		else {
			stripe_index = find_live_mirror(map, stripe_index,
					      map->sub_stripes, stripe_index +
					      current->pid % map->sub_stripes);
3738
			mirror_num = stripe_index + 1;
3739
		}
3740 3741 3742 3743 3744 3745 3746
	} 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);
3747
		mirror_num = stripe_index + 1;
3748
	}
3749
	BUG_ON(stripe_index >= map->num_stripes);
3750

L
Li Zefan 已提交
3751 3752 3753 3754 3755 3756 3757
	bbio = kzalloc(btrfs_bio_size(num_stripes), GFP_NOFS);
	if (!bbio) {
		ret = -ENOMEM;
		goto out;
	}
	atomic_set(&bbio->error, 0);

3758
	if (rw & REQ_DISCARD) {
3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777
		int factor = 0;
		int sub_stripes = 0;
		u64 stripes_per_dev = 0;
		u32 remaining_stripes = 0;

		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);
		}

3778
		for (i = 0; i < num_stripes; i++) {
3779
			bbio->stripes[i].physical =
3780 3781
				map->stripes[stripe_index].physical +
				stripe_offset + stripe_nr * map->stripe_len;
3782
			bbio->stripes[i].dev = map->stripes[stripe_index].dev;
3783

3784 3785 3786 3787 3788 3789 3790 3791
			if (map->type & (BTRFS_BLOCK_GROUP_RAID0 |
					 BTRFS_BLOCK_GROUP_RAID10)) {
				bbio->stripes[i].length = stripes_per_dev *
							  map->stripe_len;
				if (i / sub_stripes < remaining_stripes)
					bbio->stripes[i].length +=
						map->stripe_len;
				if (i < sub_stripes)
3792
					bbio->stripes[i].length -=
3793
						stripe_offset;
3794 3795
				if ((i / sub_stripes + 1) %
				    sub_stripes == remaining_stripes)
3796
					bbio->stripes[i].length -=
3797
						stripe_end_offset;
3798 3799
				if (i == sub_stripes - 1)
					stripe_offset = 0;
3800
			} else
3801
				bbio->stripes[i].length = *length;
3802 3803 3804 3805 3806 3807 3808 3809 3810 3811

			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++) {
3812
			bbio->stripes[i].physical =
3813 3814 3815
				map->stripes[stripe_index].physical +
				stripe_offset +
				stripe_nr * map->stripe_len;
3816
			bbio->stripes[i].dev =
3817
				map->stripes[stripe_index].dev;
3818
			stripe_index++;
3819
		}
3820
	}
L
Li Zefan 已提交
3821 3822 3823 3824 3825 3826 3827

	if (rw & REQ_WRITE) {
		if (map->type & (BTRFS_BLOCK_GROUP_RAID1 |
				 BTRFS_BLOCK_GROUP_RAID10 |
				 BTRFS_BLOCK_GROUP_DUP)) {
			max_errors = 1;
		}
3828
	}
L
Li Zefan 已提交
3829 3830 3831 3832 3833

	*bbio_ret = bbio;
	bbio->num_stripes = num_stripes;
	bbio->max_errors = max_errors;
	bbio->mirror_num = mirror_num;
3834
out:
3835
	free_extent_map(em);
L
Li Zefan 已提交
3836
	return ret;
3837 3838
}

3839 3840
int btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
		      u64 logical, u64 *length,
3841
		      struct btrfs_bio **bbio_ret, int mirror_num)
3842
{
3843
	return __btrfs_map_block(map_tree, rw, logical, length, bbio_ret,
J
Jens Axboe 已提交
3844
				 mirror_num);
3845 3846
}

Y
Yan Zheng 已提交
3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859
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;
	int i, j, nr = 0;

3860
	read_lock(&em_tree->lock);
Y
Yan Zheng 已提交
3861
	em = lookup_extent_mapping(em_tree, chunk_start, 1);
3862
	read_unlock(&em_tree->lock);
Y
Yan Zheng 已提交
3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892

	BUG_ON(!em || em->start != chunk_start);
	map = (struct map_lookup *)em->bdev;

	length = em->len;
	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);

	buf = kzalloc(sizeof(u64) * map->num_stripes, GFP_NOFS);
	BUG_ON(!buf);

	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;
		}
		bytenr = chunk_start + stripe_nr * map->stripe_len;
3893
		WARN_ON(nr >= map->num_stripes);
Y
Yan Zheng 已提交
3894 3895 3896 3897
		for (j = 0; j < nr; j++) {
			if (buf[j] == bytenr)
				break;
		}
3898 3899
		if (j == nr) {
			WARN_ON(nr >= map->num_stripes);
Y
Yan Zheng 已提交
3900
			buf[nr++] = bytenr;
3901
		}
Y
Yan Zheng 已提交
3902 3903 3904 3905 3906 3907 3908 3909
	}

	*logical = buf;
	*naddrs = nr;
	*stripe_len = map->stripe_len;

	free_extent_map(em);
	return 0;
3910 3911
}

3912
static void btrfs_end_bio(struct bio *bio, int err)
3913
{
3914
	struct btrfs_bio *bbio = bio->bi_private;
3915
	int is_orig_bio = 0;
3916 3917

	if (err)
3918
		atomic_inc(&bbio->error);
3919

3920
	if (bio == bbio->orig_bio)
3921 3922
		is_orig_bio = 1;

3923
	if (atomic_dec_and_test(&bbio->stripes_pending)) {
3924 3925
		if (!is_orig_bio) {
			bio_put(bio);
3926
			bio = bbio->orig_bio;
3927
		}
3928 3929
		bio->bi_private = bbio->private;
		bio->bi_end_io = bbio->end_io;
J
Jan Schmidt 已提交
3930 3931
		bio->bi_bdev = (struct block_device *)
					(unsigned long)bbio->mirror_num;
3932 3933 3934
		/* only send an error to the higher layers if it is
		 * beyond the tolerance of the multi-bio
		 */
3935
		if (atomic_read(&bbio->error) > bbio->max_errors) {
3936
			err = -EIO;
3937
		} else {
3938 3939 3940 3941 3942
			/*
			 * this bio is actually up to date, we didn't
			 * go over the max number of errors
			 */
			set_bit(BIO_UPTODATE, &bio->bi_flags);
3943
			err = 0;
3944
		}
3945
		kfree(bbio);
3946 3947

		bio_endio(bio, err);
3948
	} else if (!is_orig_bio) {
3949 3950 3951 3952
		bio_put(bio);
	}
}

3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966
struct async_sched {
	struct bio *bio;
	int rw;
	struct btrfs_fs_info *info;
	struct btrfs_work work;
};

/*
 * 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.
 */
3967
static noinline void schedule_bio(struct btrfs_root *root,
3968 3969
				 struct btrfs_device *device,
				 int rw, struct bio *bio)
3970 3971
{
	int should_queue = 1;
3972
	struct btrfs_pending_bios *pending_bios;
3973 3974

	/* don't bother with additional async steps for reads, right now */
3975
	if (!(rw & REQ_WRITE)) {
3976
		bio_get(bio);
3977
		btrfsic_submit_bio(rw, bio);
3978
		bio_put(bio);
3979
		return;
3980 3981 3982
	}

	/*
3983
	 * nr_async_bios allows us to reliably return congestion to the
3984 3985 3986 3987
	 * 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
	 */
3988
	atomic_inc(&root->fs_info->nr_async_bios);
3989
	WARN_ON(bio->bi_next);
3990 3991 3992 3993
	bio->bi_next = NULL;
	bio->bi_rw |= rw;

	spin_lock(&device->io_lock);
3994
	if (bio->bi_rw & REQ_SYNC)
3995 3996 3997
		pending_bios = &device->pending_sync_bios;
	else
		pending_bios = &device->pending_bios;
3998

3999 4000
	if (pending_bios->tail)
		pending_bios->tail->bi_next = bio;
4001

4002 4003 4004
	pending_bios->tail = bio;
	if (!pending_bios->head)
		pending_bios->head = bio;
4005 4006 4007 4008 4009 4010
	if (device->running_pending)
		should_queue = 0;

	spin_unlock(&device->io_lock);

	if (should_queue)
4011 4012
		btrfs_queue_worker(&root->fs_info->submit_workers,
				   &device->work);
4013 4014
}

4015
int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
4016
		  int mirror_num, int async_submit)
4017 4018 4019
{
	struct btrfs_mapping_tree *map_tree;
	struct btrfs_device *dev;
4020
	struct bio *first_bio = bio;
4021
	u64 logical = (u64)bio->bi_sector << 9;
4022 4023 4024
	u64 length = 0;
	u64 map_length;
	int ret;
4025 4026
	int dev_nr = 0;
	int total_devs = 1;
4027
	struct btrfs_bio *bbio = NULL;
4028

4029
	length = bio->bi_size;
4030 4031
	map_tree = &root->fs_info->mapping_tree;
	map_length = length;
4032

4033
	ret = btrfs_map_block(map_tree, rw, logical, &map_length, &bbio,
4034
			      mirror_num);
4035 4036
	BUG_ON(ret);

4037
	total_devs = bbio->num_stripes;
4038
	if (map_length < length) {
C
Chris Mason 已提交
4039 4040 4041 4042
		printk(KERN_CRIT "mapping failed logical %llu bio len %llu "
		       "len %llu\n", (unsigned long long)logical,
		       (unsigned long long)length,
		       (unsigned long long)map_length);
4043 4044
		BUG();
	}
4045 4046 4047 4048 4049

	bbio->orig_bio = first_bio;
	bbio->private = first_bio->bi_private;
	bbio->end_io = first_bio->bi_end_io;
	atomic_set(&bbio->stripes_pending, bbio->num_stripes);
4050

C
Chris Mason 已提交
4051
	while (dev_nr < total_devs) {
4052 4053 4054 4055 4056
		if (dev_nr < total_devs - 1) {
			bio = bio_clone(first_bio, GFP_NOFS);
			BUG_ON(!bio);
		} else {
			bio = first_bio;
4057
		}
4058 4059 4060 4061
		bio->bi_private = bbio;
		bio->bi_end_io = btrfs_end_bio;
		bio->bi_sector = bbio->stripes[dev_nr].physical >> 9;
		dev = bbio->stripes[dev_nr].dev;
4062
		if (dev && dev->bdev && (rw != WRITE || dev->writeable)) {
4063 4064 4065 4066
			pr_debug("btrfs_map_bio: rw %d, secor=%llu, dev=%lu "
				 "(%s id %llu), size=%u\n", rw,
				 (u64)bio->bi_sector, (u_long)dev->bdev->bd_dev,
				 dev->name, dev->devid, bio->bi_size);
4067
			bio->bi_bdev = dev->bdev;
4068 4069 4070
			if (async_submit)
				schedule_bio(root, dev, rw, bio);
			else
4071
				btrfsic_submit_bio(rw, bio);
4072 4073 4074 4075 4076
		} else {
			bio->bi_bdev = root->fs_info->fs_devices->latest_bdev;
			bio->bi_sector = logical >> 9;
			bio_endio(bio, -EIO);
		}
4077 4078
		dev_nr++;
	}
4079 4080 4081
	return 0;
}

4082
struct btrfs_device *btrfs_find_device(struct btrfs_root *root, u64 devid,
Y
Yan Zheng 已提交
4083
				       u8 *uuid, u8 *fsid)
4084
{
Y
Yan Zheng 已提交
4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099
	struct btrfs_device *device;
	struct btrfs_fs_devices *cur_devices;

	cur_devices = root->fs_info->fs_devices;
	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;
4100 4101
}

4102 4103 4104 4105 4106 4107 4108
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;

	device = kzalloc(sizeof(*device), GFP_NOFS);
4109 4110
	if (!device)
		return NULL;
4111 4112 4113 4114
	list_add(&device->dev_list,
		 &fs_devices->devices);
	device->dev_root = root->fs_info->dev_root;
	device->devid = devid;
4115
	device->work.func = pending_bios_fn;
Y
Yan Zheng 已提交
4116
	device->fs_devices = fs_devices;
4117
	device->missing = 1;
4118
	fs_devices->num_devices++;
4119
	fs_devices->missing_devices++;
4120
	spin_lock_init(&device->io_lock);
4121
	INIT_LIST_HEAD(&device->dev_alloc_list);
4122 4123 4124 4125
	memcpy(device->uuid, dev_uuid, BTRFS_UUID_SIZE);
	return device;
}

4126 4127 4128 4129 4130 4131 4132 4133 4134 4135
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;
4136
	u8 uuid[BTRFS_UUID_SIZE];
4137
	int num_stripes;
4138
	int ret;
4139
	int i;
4140

4141 4142
	logical = key->offset;
	length = btrfs_chunk_length(leaf, chunk);
4143

4144
	read_lock(&map_tree->map_tree.lock);
4145
	em = lookup_extent_mapping(&map_tree->map_tree, logical, 1);
4146
	read_unlock(&map_tree->map_tree.lock);
4147 4148 4149 4150 4151 4152 4153 4154 4155

	/* 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);
	}

4156
	em = alloc_extent_map();
4157 4158
	if (!em)
		return -ENOMEM;
4159 4160
	num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
	map = kmalloc(map_lookup_size(num_stripes), GFP_NOFS);
4161 4162 4163 4164 4165 4166 4167 4168 4169
	if (!map) {
		free_extent_map(em);
		return -ENOMEM;
	}

	em->bdev = (struct block_device *)map;
	em->start = logical;
	em->len = length;
	em->block_start = 0;
C
Chris Mason 已提交
4170
	em->block_len = em->len;
4171

4172 4173 4174 4175 4176 4177
	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 已提交
4178
	map->sub_stripes = btrfs_chunk_sub_stripes(leaf, chunk);
4179 4180 4181 4182
	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);
4183 4184 4185
		read_extent_buffer(leaf, uuid, (unsigned long)
				   btrfs_stripe_dev_uuid_nr(chunk, i),
				   BTRFS_UUID_SIZE);
Y
Yan Zheng 已提交
4186 4187
		map->stripes[i].dev = btrfs_find_device(root, devid, uuid,
							NULL);
4188
		if (!map->stripes[i].dev && !btrfs_test_opt(root, DEGRADED)) {
4189 4190 4191 4192
			kfree(map);
			free_extent_map(em);
			return -EIO;
		}
4193 4194 4195 4196 4197 4198 4199 4200 4201 4202
		if (!map->stripes[i].dev) {
			map->stripes[i].dev =
				add_missing_dev(root, devid, uuid);
			if (!map->stripes[i].dev) {
				kfree(map);
				free_extent_map(em);
				return -EIO;
			}
		}
		map->stripes[i].dev->in_fs_metadata = 1;
4203 4204
	}

4205
	write_lock(&map_tree->map_tree.lock);
4206
	ret = add_extent_mapping(&map_tree->map_tree, em);
4207
	write_unlock(&map_tree->map_tree.lock);
4208
	BUG_ON(ret);
4209 4210 4211 4212 4213
	free_extent_map(em);

	return 0;
}

4214
static void fill_device_from_item(struct extent_buffer *leaf,
4215 4216 4217 4218 4219 4220
				 struct btrfs_dev_item *dev_item,
				 struct btrfs_device *device)
{
	unsigned long ptr;

	device->devid = btrfs_device_id(leaf, dev_item);
4221 4222
	device->disk_total_bytes = btrfs_device_total_bytes(leaf, dev_item);
	device->total_bytes = device->disk_total_bytes;
4223 4224 4225 4226 4227 4228 4229
	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);

	ptr = (unsigned long)btrfs_device_uuid(dev_item);
4230
	read_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE);
4231 4232
}

Y
Yan Zheng 已提交
4233 4234 4235 4236 4237
static int open_seed_devices(struct btrfs_root *root, u8 *fsid)
{
	struct btrfs_fs_devices *fs_devices;
	int ret;

4238
	BUG_ON(!mutex_is_locked(&uuid_mutex));
Y
Yan Zheng 已提交
4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253

	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 已提交
4254 4255 4256 4257

	fs_devices = clone_fs_devices(fs_devices);
	if (IS_ERR(fs_devices)) {
		ret = PTR_ERR(fs_devices);
Y
Yan Zheng 已提交
4258 4259 4260
		goto out;
	}

4261
	ret = __btrfs_open_devices(fs_devices, FMODE_READ,
4262
				   root->fs_info->bdev_holder);
Y
Yan Zheng 已提交
4263 4264 4265 4266 4267
	if (ret)
		goto out;

	if (!fs_devices->seeding) {
		__btrfs_close_devices(fs_devices);
Y
Yan Zheng 已提交
4268
		free_fs_devices(fs_devices);
Y
Yan Zheng 已提交
4269 4270 4271 4272 4273 4274 4275 4276 4277 4278
		ret = -EINVAL;
		goto out;
	}

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

4279
static int read_one_dev(struct btrfs_root *root,
4280 4281 4282 4283 4284 4285
			struct extent_buffer *leaf,
			struct btrfs_dev_item *dev_item)
{
	struct btrfs_device *device;
	u64 devid;
	int ret;
Y
Yan Zheng 已提交
4286
	u8 fs_uuid[BTRFS_UUID_SIZE];
4287 4288
	u8 dev_uuid[BTRFS_UUID_SIZE];

4289
	devid = btrfs_device_id(leaf, dev_item);
4290 4291 4292
	read_extent_buffer(leaf, dev_uuid,
			   (unsigned long)btrfs_device_uuid(dev_item),
			   BTRFS_UUID_SIZE);
Y
Yan Zheng 已提交
4293 4294 4295 4296 4297 4298
	read_extent_buffer(leaf, fs_uuid,
			   (unsigned long)btrfs_device_fsid(dev_item),
			   BTRFS_UUID_SIZE);

	if (memcmp(fs_uuid, root->fs_info->fsid, BTRFS_UUID_SIZE)) {
		ret = open_seed_devices(root, fs_uuid);
Y
Yan Zheng 已提交
4299
		if (ret && !btrfs_test_opt(root, DEGRADED))
Y
Yan Zheng 已提交
4300 4301 4302 4303 4304
			return ret;
	}

	device = btrfs_find_device(root, devid, dev_uuid, fs_uuid);
	if (!device || !device->bdev) {
Y
Yan Zheng 已提交
4305
		if (!btrfs_test_opt(root, DEGRADED))
Y
Yan Zheng 已提交
4306 4307 4308
			return -EIO;

		if (!device) {
C
Chris Mason 已提交
4309 4310
			printk(KERN_WARNING "warning devid %llu missing\n",
			       (unsigned long long)devid);
Y
Yan Zheng 已提交
4311 4312 4313
			device = add_missing_dev(root, devid, dev_uuid);
			if (!device)
				return -ENOMEM;
4314 4315 4316 4317 4318 4319 4320 4321 4322
		} 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 已提交
4323 4324 4325 4326 4327 4328 4329 4330
		}
	}

	if (device->fs_devices != root->fs_info->fs_devices) {
		BUG_ON(device->writeable);
		if (device->generation !=
		    btrfs_device_generation(leaf, dev_item))
			return -EINVAL;
4331
	}
4332 4333 4334

	fill_device_from_item(leaf, dev_item, device);
	device->dev_root = root->fs_info->dev_root;
4335
	device->in_fs_metadata = 1;
4336
	if (device->writeable) {
Y
Yan Zheng 已提交
4337
		device->fs_devices->total_rw_bytes += device->total_bytes;
4338 4339 4340 4341 4342
		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);
	}
4343 4344 4345 4346
	ret = 0;
	return ret;
}

Y
Yan Zheng 已提交
4347
int btrfs_read_sys_array(struct btrfs_root *root)
4348
{
4349
	struct btrfs_super_block *super_copy = root->fs_info->super_copy;
4350
	struct extent_buffer *sb;
4351 4352
	struct btrfs_disk_key *disk_key;
	struct btrfs_chunk *chunk;
4353 4354 4355
	u8 *ptr;
	unsigned long sb_ptr;
	int ret = 0;
4356 4357 4358 4359
	u32 num_stripes;
	u32 array_size;
	u32 len = 0;
	u32 cur;
4360
	struct btrfs_key key;
4361

Y
Yan Zheng 已提交
4362
	sb = btrfs_find_create_tree_block(root, BTRFS_SUPER_INFO_OFFSET,
4363 4364 4365 4366
					  BTRFS_SUPER_INFO_SIZE);
	if (!sb)
		return -ENOMEM;
	btrfs_set_buffer_uptodate(sb);
4367
	btrfs_set_buffer_lockdep_class(root->root_key.objectid, sb, 0);
4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381
	/*
	 * 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)
		SetPageUptodate(sb->first_page);
4382

4383
	write_extent_buffer(sb, super_copy, 0, BTRFS_SUPER_INFO_SIZE);
4384 4385 4386 4387 4388 4389 4390 4391 4392 4393
	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);

4394
		len = sizeof(*disk_key); ptr += len;
4395 4396 4397
		sb_ptr += len;
		cur += len;

4398
		if (key.type == BTRFS_CHUNK_ITEM_KEY) {
4399
			chunk = (struct btrfs_chunk *)sb_ptr;
4400
			ret = read_one_chunk(root, &key, sb, chunk);
4401 4402
			if (ret)
				break;
4403 4404 4405
			num_stripes = btrfs_chunk_num_stripes(sb, chunk);
			len = btrfs_chunk_item_size(num_stripes);
		} else {
4406 4407
			ret = -EIO;
			break;
4408 4409 4410 4411 4412
		}
		ptr += len;
		sb_ptr += len;
		cur += len;
	}
4413
	free_extent_buffer(sb);
4414
	return ret;
4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431
}

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;

4432 4433 4434
	mutex_lock(&uuid_mutex);
	lock_chunks(root);

4435 4436 4437 4438 4439 4440 4441 4442 4443
	/* first we search for all of the device items, and then we
	 * read in all of the chunk items.  This way we can create chunk
	 * mappings that reference all of the devices that are afound
	 */
	key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
	key.offset = 0;
	key.type = 0;
again:
	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4444 4445
	if (ret < 0)
		goto error;
C
Chris Mason 已提交
4446
	while (1) {
4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464
		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);
		if (key.objectid == BTRFS_DEV_ITEMS_OBJECTID) {
			if (found_key.objectid != BTRFS_DEV_ITEMS_OBJECTID)
				break;
			if (found_key.type == BTRFS_DEV_ITEM_KEY) {
				struct btrfs_dev_item *dev_item;
				dev_item = btrfs_item_ptr(leaf, slot,
						  struct btrfs_dev_item);
4465
				ret = read_one_dev(root, leaf, dev_item);
Y
Yan Zheng 已提交
4466 4467
				if (ret)
					goto error;
4468 4469 4470 4471 4472
			}
		} 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 已提交
4473 4474
			if (ret)
				goto error;
4475 4476 4477 4478 4479
		}
		path->slots[0]++;
	}
	if (key.objectid == BTRFS_DEV_ITEMS_OBJECTID) {
		key.objectid = 0;
4480
		btrfs_release_path(path);
4481 4482 4483 4484
		goto again;
	}
	ret = 0;
error:
4485 4486 4487
	unlock_chunks(root);
	mutex_unlock(&uuid_mutex);

Y
Yan Zheng 已提交
4488
	btrfs_free_path(path);
4489 4490
	return ret;
}