1 /*
2  * Copyright (C) 2007 Oracle.  All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public
6  * License v2 as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11  * General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public
14  * License along with this program; if not, write to the
15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16  * Boston, MA 021110-1307, USA.
17  */
18 #include <linux/sched.h>
19 #include <linux/bio.h>
20 #include <linux/slab.h>
21 #include <linux/buffer_head.h>
22 #include <linux/blkdev.h>
23 #include <linux/random.h>
24 #include <linux/iocontext.h>
25 #include <linux/capability.h>
26 #include <linux/ratelimit.h>
27 #include <linux/kthread.h>
28 #include <linux/raid/pq.h>
29 #include <linux/semaphore.h>
30 #include <asm/div64.h>
31 #include "ctree.h"
32 #include "extent_map.h"
33 #include "disk-io.h"
34 #include "transaction.h"
35 #include "print-tree.h"
36 #include "volumes.h"
37 #include "raid56.h"
38 #include "async-thread.h"
39 #include "check-integrity.h"
40 #include "rcu-string.h"
41 #include "math.h"
42 #include "dev-replace.h"
43 #include "sysfs.h"
44 
45 const struct btrfs_raid_attr btrfs_raid_array[BTRFS_NR_RAID_TYPES] = {
46 	[BTRFS_RAID_RAID10] = {
47 		.sub_stripes	= 2,
48 		.dev_stripes	= 1,
49 		.devs_max	= 0,	/* 0 == as many as possible */
50 		.devs_min	= 4,
51 		.tolerated_failures = 1,
52 		.devs_increment	= 2,
53 		.ncopies	= 2,
54 	},
55 	[BTRFS_RAID_RAID1] = {
56 		.sub_stripes	= 1,
57 		.dev_stripes	= 1,
58 		.devs_max	= 2,
59 		.devs_min	= 2,
60 		.tolerated_failures = 1,
61 		.devs_increment	= 2,
62 		.ncopies	= 2,
63 	},
64 	[BTRFS_RAID_DUP] = {
65 		.sub_stripes	= 1,
66 		.dev_stripes	= 2,
67 		.devs_max	= 1,
68 		.devs_min	= 1,
69 		.tolerated_failures = 0,
70 		.devs_increment	= 1,
71 		.ncopies	= 2,
72 	},
73 	[BTRFS_RAID_RAID0] = {
74 		.sub_stripes	= 1,
75 		.dev_stripes	= 1,
76 		.devs_max	= 0,
77 		.devs_min	= 2,
78 		.tolerated_failures = 0,
79 		.devs_increment	= 1,
80 		.ncopies	= 1,
81 	},
82 	[BTRFS_RAID_SINGLE] = {
83 		.sub_stripes	= 1,
84 		.dev_stripes	= 1,
85 		.devs_max	= 1,
86 		.devs_min	= 1,
87 		.tolerated_failures = 0,
88 		.devs_increment	= 1,
89 		.ncopies	= 1,
90 	},
91 	[BTRFS_RAID_RAID5] = {
92 		.sub_stripes	= 1,
93 		.dev_stripes	= 1,
94 		.devs_max	= 0,
95 		.devs_min	= 2,
96 		.tolerated_failures = 1,
97 		.devs_increment	= 1,
98 		.ncopies	= 2,
99 	},
100 	[BTRFS_RAID_RAID6] = {
101 		.sub_stripes	= 1,
102 		.dev_stripes	= 1,
103 		.devs_max	= 0,
104 		.devs_min	= 3,
105 		.tolerated_failures = 2,
106 		.devs_increment	= 1,
107 		.ncopies	= 3,
108 	},
109 };
110 
111 const u64 const btrfs_raid_group[BTRFS_NR_RAID_TYPES] = {
112 	[BTRFS_RAID_RAID10] = BTRFS_BLOCK_GROUP_RAID10,
113 	[BTRFS_RAID_RAID1]  = BTRFS_BLOCK_GROUP_RAID1,
114 	[BTRFS_RAID_DUP]    = BTRFS_BLOCK_GROUP_DUP,
115 	[BTRFS_RAID_RAID0]  = BTRFS_BLOCK_GROUP_RAID0,
116 	[BTRFS_RAID_SINGLE] = 0,
117 	[BTRFS_RAID_RAID5]  = BTRFS_BLOCK_GROUP_RAID5,
118 	[BTRFS_RAID_RAID6]  = BTRFS_BLOCK_GROUP_RAID6,
119 };
120 
121 static int init_first_rw_device(struct btrfs_trans_handle *trans,
122 				struct btrfs_root *root,
123 				struct btrfs_device *device);
124 static int btrfs_relocate_sys_chunks(struct btrfs_root *root);
125 static void __btrfs_reset_dev_stats(struct btrfs_device *dev);
126 static void btrfs_dev_stat_print_on_error(struct btrfs_device *dev);
127 static void btrfs_dev_stat_print_on_load(struct btrfs_device *device);
128 
129 DEFINE_MUTEX(uuid_mutex);
130 static LIST_HEAD(fs_uuids);
btrfs_get_fs_uuids(void)131 struct list_head *btrfs_get_fs_uuids(void)
132 {
133 	return &fs_uuids;
134 }
135 
__alloc_fs_devices(void)136 static struct btrfs_fs_devices *__alloc_fs_devices(void)
137 {
138 	struct btrfs_fs_devices *fs_devs;
139 
140 	fs_devs = kzalloc(sizeof(*fs_devs), GFP_NOFS);
141 	if (!fs_devs)
142 		return ERR_PTR(-ENOMEM);
143 
144 	mutex_init(&fs_devs->device_list_mutex);
145 
146 	INIT_LIST_HEAD(&fs_devs->devices);
147 	INIT_LIST_HEAD(&fs_devs->resized_devices);
148 	INIT_LIST_HEAD(&fs_devs->alloc_list);
149 	INIT_LIST_HEAD(&fs_devs->list);
150 
151 	return fs_devs;
152 }
153 
154 /**
155  * alloc_fs_devices - allocate struct btrfs_fs_devices
156  * @fsid:	a pointer to UUID for this FS.  If NULL a new UUID is
157  *		generated.
158  *
159  * Return: a pointer to a new &struct btrfs_fs_devices on success;
160  * ERR_PTR() on error.  Returned struct is not linked onto any lists and
161  * can be destroyed with kfree() right away.
162  */
alloc_fs_devices(const u8 * fsid)163 static struct btrfs_fs_devices *alloc_fs_devices(const u8 *fsid)
164 {
165 	struct btrfs_fs_devices *fs_devs;
166 
167 	fs_devs = __alloc_fs_devices();
168 	if (IS_ERR(fs_devs))
169 		return fs_devs;
170 
171 	if (fsid)
172 		memcpy(fs_devs->fsid, fsid, BTRFS_FSID_SIZE);
173 	else
174 		generate_random_uuid(fs_devs->fsid);
175 
176 	return fs_devs;
177 }
178 
free_fs_devices(struct btrfs_fs_devices * fs_devices)179 static void free_fs_devices(struct btrfs_fs_devices *fs_devices)
180 {
181 	struct btrfs_device *device;
182 	WARN_ON(fs_devices->opened);
183 	while (!list_empty(&fs_devices->devices)) {
184 		device = list_entry(fs_devices->devices.next,
185 				    struct btrfs_device, dev_list);
186 		list_del(&device->dev_list);
187 		rcu_string_free(device->name);
188 		kfree(device);
189 	}
190 	kfree(fs_devices);
191 }
192 
btrfs_kobject_uevent(struct block_device * bdev,enum kobject_action action)193 static void btrfs_kobject_uevent(struct block_device *bdev,
194 				 enum kobject_action action)
195 {
196 	int ret;
197 
198 	ret = kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, action);
199 	if (ret)
200 		pr_warn("BTRFS: Sending event '%d' to kobject: '%s' (%p): failed\n",
201 			action,
202 			kobject_name(&disk_to_dev(bdev->bd_disk)->kobj),
203 			&disk_to_dev(bdev->bd_disk)->kobj);
204 }
205 
btrfs_cleanup_fs_uuids(void)206 void btrfs_cleanup_fs_uuids(void)
207 {
208 	struct btrfs_fs_devices *fs_devices;
209 
210 	while (!list_empty(&fs_uuids)) {
211 		fs_devices = list_entry(fs_uuids.next,
212 					struct btrfs_fs_devices, list);
213 		list_del(&fs_devices->list);
214 		free_fs_devices(fs_devices);
215 	}
216 }
217 
__alloc_device(void)218 static struct btrfs_device *__alloc_device(void)
219 {
220 	struct btrfs_device *dev;
221 
222 	dev = kzalloc(sizeof(*dev), GFP_NOFS);
223 	if (!dev)
224 		return ERR_PTR(-ENOMEM);
225 
226 	INIT_LIST_HEAD(&dev->dev_list);
227 	INIT_LIST_HEAD(&dev->dev_alloc_list);
228 	INIT_LIST_HEAD(&dev->resized_list);
229 
230 	spin_lock_init(&dev->io_lock);
231 
232 	spin_lock_init(&dev->reada_lock);
233 	atomic_set(&dev->reada_in_flight, 0);
234 	atomic_set(&dev->dev_stats_ccnt, 0);
235 	btrfs_device_data_ordered_init(dev);
236 	INIT_RADIX_TREE(&dev->reada_zones, GFP_NOFS & ~__GFP_DIRECT_RECLAIM);
237 	INIT_RADIX_TREE(&dev->reada_extents, GFP_NOFS & ~__GFP_DIRECT_RECLAIM);
238 
239 	return dev;
240 }
241 
__find_device(struct list_head * head,u64 devid,u8 * uuid)242 static noinline struct btrfs_device *__find_device(struct list_head *head,
243 						   u64 devid, u8 *uuid)
244 {
245 	struct btrfs_device *dev;
246 
247 	list_for_each_entry(dev, head, dev_list) {
248 		if (dev->devid == devid &&
249 		    (!uuid || !memcmp(dev->uuid, uuid, BTRFS_UUID_SIZE))) {
250 			return dev;
251 		}
252 	}
253 	return NULL;
254 }
255 
find_fsid(u8 * fsid)256 static noinline struct btrfs_fs_devices *find_fsid(u8 *fsid)
257 {
258 	struct btrfs_fs_devices *fs_devices;
259 
260 	list_for_each_entry(fs_devices, &fs_uuids, list) {
261 		if (memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE) == 0)
262 			return fs_devices;
263 	}
264 	return NULL;
265 }
266 
267 static int
btrfs_get_bdev_and_sb(const char * device_path,fmode_t flags,void * holder,int flush,struct block_device ** bdev,struct buffer_head ** bh)268 btrfs_get_bdev_and_sb(const char *device_path, fmode_t flags, void *holder,
269 		      int flush, struct block_device **bdev,
270 		      struct buffer_head **bh)
271 {
272 	int ret;
273 
274 	*bdev = blkdev_get_by_path(device_path, flags, holder);
275 
276 	if (IS_ERR(*bdev)) {
277 		ret = PTR_ERR(*bdev);
278 		goto error;
279 	}
280 
281 	if (flush)
282 		filemap_write_and_wait((*bdev)->bd_inode->i_mapping);
283 	ret = set_blocksize(*bdev, 4096);
284 	if (ret) {
285 		blkdev_put(*bdev, flags);
286 		goto error;
287 	}
288 	invalidate_bdev(*bdev);
289 	*bh = btrfs_read_dev_super(*bdev);
290 	if (IS_ERR(*bh)) {
291 		ret = PTR_ERR(*bh);
292 		blkdev_put(*bdev, flags);
293 		goto error;
294 	}
295 
296 	return 0;
297 
298 error:
299 	*bdev = NULL;
300 	*bh = NULL;
301 	return ret;
302 }
303 
requeue_list(struct btrfs_pending_bios * pending_bios,struct bio * head,struct bio * tail)304 static void requeue_list(struct btrfs_pending_bios *pending_bios,
305 			struct bio *head, struct bio *tail)
306 {
307 
308 	struct bio *old_head;
309 
310 	old_head = pending_bios->head;
311 	pending_bios->head = head;
312 	if (pending_bios->tail)
313 		tail->bi_next = old_head;
314 	else
315 		pending_bios->tail = tail;
316 }
317 
318 /*
319  * we try to collect pending bios for a device so we don't get a large
320  * number of procs sending bios down to the same device.  This greatly
321  * improves the schedulers ability to collect and merge the bios.
322  *
323  * But, it also turns into a long list of bios to process and that is sure
324  * to eventually make the worker thread block.  The solution here is to
325  * make some progress and then put this work struct back at the end of
326  * the list if the block device is congested.  This way, multiple devices
327  * can make progress from a single worker thread.
328  */
run_scheduled_bios(struct btrfs_device * device)329 static noinline void run_scheduled_bios(struct btrfs_device *device)
330 {
331 	struct bio *pending;
332 	struct backing_dev_info *bdi;
333 	struct btrfs_fs_info *fs_info;
334 	struct btrfs_pending_bios *pending_bios;
335 	struct bio *tail;
336 	struct bio *cur;
337 	int again = 0;
338 	unsigned long num_run;
339 	unsigned long batch_run = 0;
340 	unsigned long limit;
341 	unsigned long last_waited = 0;
342 	int force_reg = 0;
343 	int sync_pending = 0;
344 	struct blk_plug plug;
345 
346 	/*
347 	 * this function runs all the bios we've collected for
348 	 * a particular device.  We don't want to wander off to
349 	 * another device without first sending all of these down.
350 	 * So, setup a plug here and finish it off before we return
351 	 */
352 	blk_start_plug(&plug);
353 
354 	bdi = blk_get_backing_dev_info(device->bdev);
355 	fs_info = device->dev_root->fs_info;
356 	limit = btrfs_async_submit_limit(fs_info);
357 	limit = limit * 2 / 3;
358 
359 loop:
360 	spin_lock(&device->io_lock);
361 
362 loop_lock:
363 	num_run = 0;
364 
365 	/* take all the bios off the list at once and process them
366 	 * later on (without the lock held).  But, remember the
367 	 * tail and other pointers so the bios can be properly reinserted
368 	 * into the list if we hit congestion
369 	 */
370 	if (!force_reg && device->pending_sync_bios.head) {
371 		pending_bios = &device->pending_sync_bios;
372 		force_reg = 1;
373 	} else {
374 		pending_bios = &device->pending_bios;
375 		force_reg = 0;
376 	}
377 
378 	pending = pending_bios->head;
379 	tail = pending_bios->tail;
380 	WARN_ON(pending && !tail);
381 
382 	/*
383 	 * if pending was null this time around, no bios need processing
384 	 * at all and we can stop.  Otherwise it'll loop back up again
385 	 * and do an additional check so no bios are missed.
386 	 *
387 	 * device->running_pending is used to synchronize with the
388 	 * schedule_bio code.
389 	 */
390 	if (device->pending_sync_bios.head == NULL &&
391 	    device->pending_bios.head == NULL) {
392 		again = 0;
393 		device->running_pending = 0;
394 	} else {
395 		again = 1;
396 		device->running_pending = 1;
397 	}
398 
399 	pending_bios->head = NULL;
400 	pending_bios->tail = NULL;
401 
402 	spin_unlock(&device->io_lock);
403 
404 	while (pending) {
405 
406 		rmb();
407 		/* we want to work on both lists, but do more bios on the
408 		 * sync list than the regular list
409 		 */
410 		if ((num_run > 32 &&
411 		    pending_bios != &device->pending_sync_bios &&
412 		    device->pending_sync_bios.head) ||
413 		   (num_run > 64 && pending_bios == &device->pending_sync_bios &&
414 		    device->pending_bios.head)) {
415 			spin_lock(&device->io_lock);
416 			requeue_list(pending_bios, pending, tail);
417 			goto loop_lock;
418 		}
419 
420 		cur = pending;
421 		pending = pending->bi_next;
422 		cur->bi_next = NULL;
423 
424 		/*
425 		 * atomic_dec_return implies a barrier for waitqueue_active
426 		 */
427 		if (atomic_dec_return(&fs_info->nr_async_bios) < limit &&
428 		    waitqueue_active(&fs_info->async_submit_wait))
429 			wake_up(&fs_info->async_submit_wait);
430 
431 		BUG_ON(atomic_read(&cur->__bi_cnt) == 0);
432 
433 		/*
434 		 * if we're doing the sync list, record that our
435 		 * plug has some sync requests on it
436 		 *
437 		 * If we're doing the regular list and there are
438 		 * sync requests sitting around, unplug before
439 		 * we add more
440 		 */
441 		if (pending_bios == &device->pending_sync_bios) {
442 			sync_pending = 1;
443 		} else if (sync_pending) {
444 			blk_finish_plug(&plug);
445 			blk_start_plug(&plug);
446 			sync_pending = 0;
447 		}
448 
449 		btrfsic_submit_bio(cur->bi_rw, cur);
450 		num_run++;
451 		batch_run++;
452 
453 		cond_resched();
454 
455 		/*
456 		 * we made progress, there is more work to do and the bdi
457 		 * is now congested.  Back off and let other work structs
458 		 * run instead
459 		 */
460 		if (pending && bdi_write_congested(bdi) && batch_run > 8 &&
461 		    fs_info->fs_devices->open_devices > 1) {
462 			struct io_context *ioc;
463 
464 			ioc = current->io_context;
465 
466 			/*
467 			 * the main goal here is that we don't want to
468 			 * block if we're going to be able to submit
469 			 * more requests without blocking.
470 			 *
471 			 * This code does two great things, it pokes into
472 			 * the elevator code from a filesystem _and_
473 			 * it makes assumptions about how batching works.
474 			 */
475 			if (ioc && ioc->nr_batch_requests > 0 &&
476 			    time_before(jiffies, ioc->last_waited + HZ/50UL) &&
477 			    (last_waited == 0 ||
478 			     ioc->last_waited == last_waited)) {
479 				/*
480 				 * we want to go through our batch of
481 				 * requests and stop.  So, we copy out
482 				 * the ioc->last_waited time and test
483 				 * against it before looping
484 				 */
485 				last_waited = ioc->last_waited;
486 				cond_resched();
487 				continue;
488 			}
489 			spin_lock(&device->io_lock);
490 			requeue_list(pending_bios, pending, tail);
491 			device->running_pending = 1;
492 
493 			spin_unlock(&device->io_lock);
494 			btrfs_queue_work(fs_info->submit_workers,
495 					 &device->work);
496 			goto done;
497 		}
498 		/* unplug every 64 requests just for good measure */
499 		if (batch_run % 64 == 0) {
500 			blk_finish_plug(&plug);
501 			blk_start_plug(&plug);
502 			sync_pending = 0;
503 		}
504 	}
505 
506 	cond_resched();
507 	if (again)
508 		goto loop;
509 
510 	spin_lock(&device->io_lock);
511 	if (device->pending_bios.head || device->pending_sync_bios.head)
512 		goto loop_lock;
513 	spin_unlock(&device->io_lock);
514 
515 done:
516 	blk_finish_plug(&plug);
517 }
518 
pending_bios_fn(struct btrfs_work * work)519 static void pending_bios_fn(struct btrfs_work *work)
520 {
521 	struct btrfs_device *device;
522 
523 	device = container_of(work, struct btrfs_device, work);
524 	run_scheduled_bios(device);
525 }
526 
527 
btrfs_free_stale_device(struct btrfs_device * cur_dev)528 void btrfs_free_stale_device(struct btrfs_device *cur_dev)
529 {
530 	struct btrfs_fs_devices *fs_devs;
531 	struct btrfs_device *dev;
532 
533 	if (!cur_dev->name)
534 		return;
535 
536 	list_for_each_entry(fs_devs, &fs_uuids, list) {
537 		int del = 1;
538 
539 		if (fs_devs->opened)
540 			continue;
541 		if (fs_devs->seeding)
542 			continue;
543 
544 		list_for_each_entry(dev, &fs_devs->devices, dev_list) {
545 
546 			if (dev == cur_dev)
547 				continue;
548 			if (!dev->name)
549 				continue;
550 
551 			/*
552 			 * Todo: This won't be enough. What if the same device
553 			 * comes back (with new uuid and) with its mapper path?
554 			 * But for now, this does help as mostly an admin will
555 			 * either use mapper or non mapper path throughout.
556 			 */
557 			rcu_read_lock();
558 			del = strcmp(rcu_str_deref(dev->name),
559 						rcu_str_deref(cur_dev->name));
560 			rcu_read_unlock();
561 			if (!del)
562 				break;
563 		}
564 
565 		if (!del) {
566 			/* delete the stale device */
567 			if (fs_devs->num_devices == 1) {
568 				btrfs_sysfs_remove_fsid(fs_devs);
569 				list_del(&fs_devs->list);
570 				free_fs_devices(fs_devs);
571 			} else {
572 				fs_devs->num_devices--;
573 				list_del(&dev->dev_list);
574 				rcu_string_free(dev->name);
575 				kfree(dev);
576 			}
577 			break;
578 		}
579 	}
580 }
581 
582 /*
583  * Add new device to list of registered devices
584  *
585  * Returns:
586  * 1   - first time device is seen
587  * 0   - device already known
588  * < 0 - error
589  */
device_list_add(const char * path,struct btrfs_super_block * disk_super,u64 devid,struct btrfs_fs_devices ** fs_devices_ret)590 static noinline int device_list_add(const char *path,
591 			   struct btrfs_super_block *disk_super,
592 			   u64 devid, struct btrfs_fs_devices **fs_devices_ret)
593 {
594 	struct btrfs_device *device;
595 	struct btrfs_fs_devices *fs_devices;
596 	struct rcu_string *name;
597 	int ret = 0;
598 	u64 found_transid = btrfs_super_generation(disk_super);
599 
600 	fs_devices = find_fsid(disk_super->fsid);
601 	if (!fs_devices) {
602 		fs_devices = alloc_fs_devices(disk_super->fsid);
603 		if (IS_ERR(fs_devices))
604 			return PTR_ERR(fs_devices);
605 
606 		list_add(&fs_devices->list, &fs_uuids);
607 
608 		device = NULL;
609 	} else {
610 		device = __find_device(&fs_devices->devices, devid,
611 				       disk_super->dev_item.uuid);
612 	}
613 
614 	if (!device) {
615 		if (fs_devices->opened)
616 			return -EBUSY;
617 
618 		device = btrfs_alloc_device(NULL, &devid,
619 					    disk_super->dev_item.uuid);
620 		if (IS_ERR(device)) {
621 			/* we can safely leave the fs_devices entry around */
622 			return PTR_ERR(device);
623 		}
624 
625 		name = rcu_string_strdup(path, GFP_NOFS);
626 		if (!name) {
627 			kfree(device);
628 			return -ENOMEM;
629 		}
630 		rcu_assign_pointer(device->name, name);
631 
632 		mutex_lock(&fs_devices->device_list_mutex);
633 		list_add_rcu(&device->dev_list, &fs_devices->devices);
634 		fs_devices->num_devices++;
635 		mutex_unlock(&fs_devices->device_list_mutex);
636 
637 		ret = 1;
638 		device->fs_devices = fs_devices;
639 	} else if (!device->name || strcmp(device->name->str, path)) {
640 		/*
641 		 * When FS is already mounted.
642 		 * 1. If you are here and if the device->name is NULL that
643 		 *    means this device was missing at time of FS mount.
644 		 * 2. If you are here and if the device->name is different
645 		 *    from 'path' that means either
646 		 *      a. The same device disappeared and reappeared with
647 		 *         different name. or
648 		 *      b. The missing-disk-which-was-replaced, has
649 		 *         reappeared now.
650 		 *
651 		 * We must allow 1 and 2a above. But 2b would be a spurious
652 		 * and unintentional.
653 		 *
654 		 * Further in case of 1 and 2a above, the disk at 'path'
655 		 * would have missed some transaction when it was away and
656 		 * in case of 2a the stale bdev has to be updated as well.
657 		 * 2b must not be allowed at all time.
658 		 */
659 
660 		/*
661 		 * For now, we do allow update to btrfs_fs_device through the
662 		 * btrfs dev scan cli after FS has been mounted.  We're still
663 		 * tracking a problem where systems fail mount by subvolume id
664 		 * when we reject replacement on a mounted FS.
665 		 */
666 		if (!fs_devices->opened && found_transid < device->generation) {
667 			/*
668 			 * That is if the FS is _not_ mounted and if you
669 			 * are here, that means there is more than one
670 			 * disk with same uuid and devid.We keep the one
671 			 * with larger generation number or the last-in if
672 			 * generation are equal.
673 			 */
674 			return -EEXIST;
675 		}
676 
677 		name = rcu_string_strdup(path, GFP_NOFS);
678 		if (!name)
679 			return -ENOMEM;
680 		rcu_string_free(device->name);
681 		rcu_assign_pointer(device->name, name);
682 		if (device->missing) {
683 			fs_devices->missing_devices--;
684 			device->missing = 0;
685 		}
686 	}
687 
688 	/*
689 	 * Unmount does not free the btrfs_device struct but would zero
690 	 * generation along with most of the other members. So just update
691 	 * it back. We need it to pick the disk with largest generation
692 	 * (as above).
693 	 */
694 	if (!fs_devices->opened)
695 		device->generation = found_transid;
696 
697 	/*
698 	 * if there is new btrfs on an already registered device,
699 	 * then remove the stale device entry.
700 	 */
701 	btrfs_free_stale_device(device);
702 
703 	*fs_devices_ret = fs_devices;
704 
705 	return ret;
706 }
707 
clone_fs_devices(struct btrfs_fs_devices * orig)708 static struct btrfs_fs_devices *clone_fs_devices(struct btrfs_fs_devices *orig)
709 {
710 	struct btrfs_fs_devices *fs_devices;
711 	struct btrfs_device *device;
712 	struct btrfs_device *orig_dev;
713 
714 	fs_devices = alloc_fs_devices(orig->fsid);
715 	if (IS_ERR(fs_devices))
716 		return fs_devices;
717 
718 	mutex_lock(&orig->device_list_mutex);
719 	fs_devices->total_devices = orig->total_devices;
720 
721 	/* We have held the volume lock, it is safe to get the devices. */
722 	list_for_each_entry(orig_dev, &orig->devices, dev_list) {
723 		struct rcu_string *name;
724 
725 		device = btrfs_alloc_device(NULL, &orig_dev->devid,
726 					    orig_dev->uuid);
727 		if (IS_ERR(device))
728 			goto error;
729 
730 		/*
731 		 * This is ok to do without rcu read locked because we hold the
732 		 * uuid mutex so nothing we touch in here is going to disappear.
733 		 */
734 		if (orig_dev->name) {
735 			name = rcu_string_strdup(orig_dev->name->str, GFP_NOFS);
736 			if (!name) {
737 				kfree(device);
738 				goto error;
739 			}
740 			rcu_assign_pointer(device->name, name);
741 		}
742 
743 		list_add(&device->dev_list, &fs_devices->devices);
744 		device->fs_devices = fs_devices;
745 		fs_devices->num_devices++;
746 	}
747 	mutex_unlock(&orig->device_list_mutex);
748 	return fs_devices;
749 error:
750 	mutex_unlock(&orig->device_list_mutex);
751 	free_fs_devices(fs_devices);
752 	return ERR_PTR(-ENOMEM);
753 }
754 
btrfs_close_extra_devices(struct btrfs_fs_devices * fs_devices,int step)755 void btrfs_close_extra_devices(struct btrfs_fs_devices *fs_devices, int step)
756 {
757 	struct btrfs_device *device, *next;
758 	struct btrfs_device *latest_dev = NULL;
759 
760 	mutex_lock(&uuid_mutex);
761 again:
762 	/* This is the initialized path, it is safe to release the devices. */
763 	list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) {
764 		if (device->in_fs_metadata) {
765 			if (!device->is_tgtdev_for_dev_replace &&
766 			    (!latest_dev ||
767 			     device->generation > latest_dev->generation)) {
768 				latest_dev = device;
769 			}
770 			continue;
771 		}
772 
773 		if (device->devid == BTRFS_DEV_REPLACE_DEVID) {
774 			/*
775 			 * In the first step, keep the device which has
776 			 * the correct fsid and the devid that is used
777 			 * for the dev_replace procedure.
778 			 * In the second step, the dev_replace state is
779 			 * read from the device tree and it is known
780 			 * whether the procedure is really active or
781 			 * not, which means whether this device is
782 			 * used or whether it should be removed.
783 			 */
784 			if (step == 0 || device->is_tgtdev_for_dev_replace) {
785 				continue;
786 			}
787 		}
788 		if (device->bdev) {
789 			blkdev_put(device->bdev, device->mode);
790 			device->bdev = NULL;
791 			fs_devices->open_devices--;
792 		}
793 		if (device->writeable) {
794 			list_del_init(&device->dev_alloc_list);
795 			device->writeable = 0;
796 			if (!device->is_tgtdev_for_dev_replace)
797 				fs_devices->rw_devices--;
798 		}
799 		list_del_init(&device->dev_list);
800 		fs_devices->num_devices--;
801 		rcu_string_free(device->name);
802 		kfree(device);
803 	}
804 
805 	if (fs_devices->seed) {
806 		fs_devices = fs_devices->seed;
807 		goto again;
808 	}
809 
810 	fs_devices->latest_bdev = latest_dev->bdev;
811 
812 	mutex_unlock(&uuid_mutex);
813 }
814 
__free_device(struct work_struct * work)815 static void __free_device(struct work_struct *work)
816 {
817 	struct btrfs_device *device;
818 
819 	device = container_of(work, struct btrfs_device, rcu_work);
820 
821 	if (device->bdev)
822 		blkdev_put(device->bdev, device->mode);
823 
824 	rcu_string_free(device->name);
825 	kfree(device);
826 }
827 
free_device(struct rcu_head * head)828 static void free_device(struct rcu_head *head)
829 {
830 	struct btrfs_device *device;
831 
832 	device = container_of(head, struct btrfs_device, rcu);
833 
834 	INIT_WORK(&device->rcu_work, __free_device);
835 	schedule_work(&device->rcu_work);
836 }
837 
__btrfs_close_devices(struct btrfs_fs_devices * fs_devices)838 static int __btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
839 {
840 	struct btrfs_device *device, *tmp;
841 
842 	if (--fs_devices->opened > 0)
843 		return 0;
844 
845 	mutex_lock(&fs_devices->device_list_mutex);
846 	list_for_each_entry_safe(device, tmp, &fs_devices->devices, dev_list) {
847 		btrfs_close_one_device(device);
848 	}
849 	mutex_unlock(&fs_devices->device_list_mutex);
850 
851 	WARN_ON(fs_devices->open_devices);
852 	WARN_ON(fs_devices->rw_devices);
853 	fs_devices->opened = 0;
854 	fs_devices->seeding = 0;
855 
856 	return 0;
857 }
858 
btrfs_close_devices(struct btrfs_fs_devices * fs_devices)859 int btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
860 {
861 	struct btrfs_fs_devices *seed_devices = NULL;
862 	int ret;
863 
864 	mutex_lock(&uuid_mutex);
865 	ret = __btrfs_close_devices(fs_devices);
866 	if (!fs_devices->opened) {
867 		seed_devices = fs_devices->seed;
868 		fs_devices->seed = NULL;
869 	}
870 	mutex_unlock(&uuid_mutex);
871 
872 	while (seed_devices) {
873 		fs_devices = seed_devices;
874 		seed_devices = fs_devices->seed;
875 		__btrfs_close_devices(fs_devices);
876 		free_fs_devices(fs_devices);
877 	}
878 	/*
879 	 * Wait for rcu kworkers under __btrfs_close_devices
880 	 * to finish all blkdev_puts so device is really
881 	 * free when umount is done.
882 	 */
883 	rcu_barrier();
884 	return ret;
885 }
886 
__btrfs_open_devices(struct btrfs_fs_devices * fs_devices,fmode_t flags,void * holder)887 static int __btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
888 				fmode_t flags, void *holder)
889 {
890 	struct request_queue *q;
891 	struct block_device *bdev;
892 	struct list_head *head = &fs_devices->devices;
893 	struct btrfs_device *device;
894 	struct btrfs_device *latest_dev = NULL;
895 	struct buffer_head *bh;
896 	struct btrfs_super_block *disk_super;
897 	u64 devid;
898 	int seeding = 1;
899 	int ret = 0;
900 
901 	flags |= FMODE_EXCL;
902 
903 	list_for_each_entry(device, head, dev_list) {
904 		if (device->bdev)
905 			continue;
906 		if (!device->name)
907 			continue;
908 
909 		/* Just open everything we can; ignore failures here */
910 		if (btrfs_get_bdev_and_sb(device->name->str, flags, holder, 1,
911 					    &bdev, &bh))
912 			continue;
913 
914 		disk_super = (struct btrfs_super_block *)bh->b_data;
915 		devid = btrfs_stack_device_id(&disk_super->dev_item);
916 		if (devid != device->devid)
917 			goto error_brelse;
918 
919 		if (memcmp(device->uuid, disk_super->dev_item.uuid,
920 			   BTRFS_UUID_SIZE))
921 			goto error_brelse;
922 
923 		device->generation = btrfs_super_generation(disk_super);
924 		if (!latest_dev ||
925 		    device->generation > latest_dev->generation)
926 			latest_dev = device;
927 
928 		if (btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_SEEDING) {
929 			device->writeable = 0;
930 		} else {
931 			device->writeable = !bdev_read_only(bdev);
932 			seeding = 0;
933 		}
934 
935 		q = bdev_get_queue(bdev);
936 		if (blk_queue_discard(q))
937 			device->can_discard = 1;
938 
939 		device->bdev = bdev;
940 		device->in_fs_metadata = 0;
941 		device->mode = flags;
942 
943 		if (!blk_queue_nonrot(bdev_get_queue(bdev)))
944 			fs_devices->rotating = 1;
945 
946 		fs_devices->open_devices++;
947 		if (device->writeable &&
948 		    device->devid != BTRFS_DEV_REPLACE_DEVID) {
949 			fs_devices->rw_devices++;
950 			list_add(&device->dev_alloc_list,
951 				 &fs_devices->alloc_list);
952 		}
953 		brelse(bh);
954 		continue;
955 
956 error_brelse:
957 		brelse(bh);
958 		blkdev_put(bdev, flags);
959 		continue;
960 	}
961 	if (fs_devices->open_devices == 0) {
962 		ret = -EINVAL;
963 		goto out;
964 	}
965 	fs_devices->seeding = seeding;
966 	fs_devices->opened = 1;
967 	fs_devices->latest_bdev = latest_dev->bdev;
968 	fs_devices->total_rw_bytes = 0;
969 out:
970 	return ret;
971 }
972 
btrfs_open_devices(struct btrfs_fs_devices * fs_devices,fmode_t flags,void * holder)973 int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
974 		       fmode_t flags, void *holder)
975 {
976 	int ret;
977 
978 	mutex_lock(&uuid_mutex);
979 	if (fs_devices->opened) {
980 		fs_devices->opened++;
981 		ret = 0;
982 	} else {
983 		ret = __btrfs_open_devices(fs_devices, flags, holder);
984 	}
985 	mutex_unlock(&uuid_mutex);
986 	return ret;
987 }
988 
989 /*
990  * Look for a btrfs signature on a device. This may be called out of the mount path
991  * and we are not allowed to call set_blocksize during the scan. The superblock
992  * is read via pagecache
993  */
btrfs_scan_one_device(const char * path,fmode_t flags,void * holder,struct btrfs_fs_devices ** fs_devices_ret)994 int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
995 			  struct btrfs_fs_devices **fs_devices_ret)
996 {
997 	struct btrfs_super_block *disk_super;
998 	struct block_device *bdev;
999 	struct page *page;
1000 	void *p;
1001 	int ret = -EINVAL;
1002 	u64 devid;
1003 	u64 transid;
1004 	u64 total_devices;
1005 	u64 bytenr;
1006 	pgoff_t index;
1007 
1008 	/*
1009 	 * we would like to check all the supers, but that would make
1010 	 * a btrfs mount succeed after a mkfs from a different FS.
1011 	 * So, we need to add a special mount option to scan for
1012 	 * later supers, using BTRFS_SUPER_MIRROR_MAX instead
1013 	 */
1014 	bytenr = btrfs_sb_offset(0);
1015 	flags |= FMODE_EXCL;
1016 	mutex_lock(&uuid_mutex);
1017 
1018 	bdev = blkdev_get_by_path(path, flags, holder);
1019 
1020 	if (IS_ERR(bdev)) {
1021 		ret = PTR_ERR(bdev);
1022 		goto error;
1023 	}
1024 
1025 	/* make sure our super fits in the device */
1026 	if (bytenr + PAGE_CACHE_SIZE >= i_size_read(bdev->bd_inode))
1027 		goto error_bdev_put;
1028 
1029 	/* make sure our super fits in the page */
1030 	if (sizeof(*disk_super) > PAGE_CACHE_SIZE)
1031 		goto error_bdev_put;
1032 
1033 	/* make sure our super doesn't straddle pages on disk */
1034 	index = bytenr >> PAGE_CACHE_SHIFT;
1035 	if ((bytenr + sizeof(*disk_super) - 1) >> PAGE_CACHE_SHIFT != index)
1036 		goto error_bdev_put;
1037 
1038 	/* pull in the page with our super */
1039 	page = read_cache_page_gfp(bdev->bd_inode->i_mapping,
1040 				   index, GFP_NOFS);
1041 
1042 	if (IS_ERR_OR_NULL(page))
1043 		goto error_bdev_put;
1044 
1045 	p = kmap(page);
1046 
1047 	/* align our pointer to the offset of the super block */
1048 	disk_super = p + (bytenr & ~PAGE_CACHE_MASK);
1049 
1050 	if (btrfs_super_bytenr(disk_super) != bytenr ||
1051 	    btrfs_super_magic(disk_super) != BTRFS_MAGIC)
1052 		goto error_unmap;
1053 
1054 	devid = btrfs_stack_device_id(&disk_super->dev_item);
1055 	transid = btrfs_super_generation(disk_super);
1056 	total_devices = btrfs_super_num_devices(disk_super);
1057 
1058 	ret = device_list_add(path, disk_super, devid, fs_devices_ret);
1059 	if (ret > 0) {
1060 		if (disk_super->label[0]) {
1061 			if (disk_super->label[BTRFS_LABEL_SIZE - 1])
1062 				disk_super->label[BTRFS_LABEL_SIZE - 1] = '\0';
1063 			printk(KERN_INFO "BTRFS: device label %s ", disk_super->label);
1064 		} else {
1065 			printk(KERN_INFO "BTRFS: device fsid %pU ", disk_super->fsid);
1066 		}
1067 
1068 		printk(KERN_CONT "devid %llu transid %llu %s\n", devid, transid, path);
1069 		ret = 0;
1070 	}
1071 	if (!ret && fs_devices_ret)
1072 		(*fs_devices_ret)->total_devices = total_devices;
1073 
1074 error_unmap:
1075 	kunmap(page);
1076 	page_cache_release(page);
1077 
1078 error_bdev_put:
1079 	blkdev_put(bdev, flags);
1080 error:
1081 	mutex_unlock(&uuid_mutex);
1082 	return ret;
1083 }
1084 
1085 /* helper to account the used device space in the range */
btrfs_account_dev_extents_size(struct btrfs_device * device,u64 start,u64 end,u64 * length)1086 int btrfs_account_dev_extents_size(struct btrfs_device *device, u64 start,
1087 				   u64 end, u64 *length)
1088 {
1089 	struct btrfs_key key;
1090 	struct btrfs_root *root = device->dev_root;
1091 	struct btrfs_dev_extent *dev_extent;
1092 	struct btrfs_path *path;
1093 	u64 extent_end;
1094 	int ret;
1095 	int slot;
1096 	struct extent_buffer *l;
1097 
1098 	*length = 0;
1099 
1100 	if (start >= device->total_bytes || device->is_tgtdev_for_dev_replace)
1101 		return 0;
1102 
1103 	path = btrfs_alloc_path();
1104 	if (!path)
1105 		return -ENOMEM;
1106 	path->reada = 2;
1107 
1108 	key.objectid = device->devid;
1109 	key.offset = start;
1110 	key.type = BTRFS_DEV_EXTENT_KEY;
1111 
1112 	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1113 	if (ret < 0)
1114 		goto out;
1115 	if (ret > 0) {
1116 		ret = btrfs_previous_item(root, path, key.objectid, key.type);
1117 		if (ret < 0)
1118 			goto out;
1119 	}
1120 
1121 	while (1) {
1122 		l = path->nodes[0];
1123 		slot = path->slots[0];
1124 		if (slot >= btrfs_header_nritems(l)) {
1125 			ret = btrfs_next_leaf(root, path);
1126 			if (ret == 0)
1127 				continue;
1128 			if (ret < 0)
1129 				goto out;
1130 
1131 			break;
1132 		}
1133 		btrfs_item_key_to_cpu(l, &key, slot);
1134 
1135 		if (key.objectid < device->devid)
1136 			goto next;
1137 
1138 		if (key.objectid > device->devid)
1139 			break;
1140 
1141 		if (key.type != BTRFS_DEV_EXTENT_KEY)
1142 			goto next;
1143 
1144 		dev_extent = btrfs_item_ptr(l, slot, struct btrfs_dev_extent);
1145 		extent_end = key.offset + btrfs_dev_extent_length(l,
1146 								  dev_extent);
1147 		if (key.offset <= start && extent_end > end) {
1148 			*length = end - start + 1;
1149 			break;
1150 		} else if (key.offset <= start && extent_end > start)
1151 			*length += extent_end - start;
1152 		else if (key.offset > start && extent_end <= end)
1153 			*length += extent_end - key.offset;
1154 		else if (key.offset > start && key.offset <= end) {
1155 			*length += end - key.offset + 1;
1156 			break;
1157 		} else if (key.offset > end)
1158 			break;
1159 
1160 next:
1161 		path->slots[0]++;
1162 	}
1163 	ret = 0;
1164 out:
1165 	btrfs_free_path(path);
1166 	return ret;
1167 }
1168 
contains_pending_extent(struct btrfs_transaction * transaction,struct btrfs_device * device,u64 * start,u64 len)1169 static int contains_pending_extent(struct btrfs_transaction *transaction,
1170 				   struct btrfs_device *device,
1171 				   u64 *start, u64 len)
1172 {
1173 	struct btrfs_fs_info *fs_info = device->dev_root->fs_info;
1174 	struct extent_map *em;
1175 	struct list_head *search_list = &fs_info->pinned_chunks;
1176 	int ret = 0;
1177 	u64 physical_start = *start;
1178 
1179 	if (transaction)
1180 		search_list = &transaction->pending_chunks;
1181 again:
1182 	list_for_each_entry(em, search_list, list) {
1183 		struct map_lookup *map;
1184 		int i;
1185 
1186 		map = (struct map_lookup *)em->bdev;
1187 		for (i = 0; i < map->num_stripes; i++) {
1188 			u64 end;
1189 
1190 			if (map->stripes[i].dev != device)
1191 				continue;
1192 			if (map->stripes[i].physical >= physical_start + len ||
1193 			    map->stripes[i].physical + em->orig_block_len <=
1194 			    physical_start)
1195 				continue;
1196 			/*
1197 			 * Make sure that while processing the pinned list we do
1198 			 * not override our *start with a lower value, because
1199 			 * we can have pinned chunks that fall within this
1200 			 * device hole and that have lower physical addresses
1201 			 * than the pending chunks we processed before. If we
1202 			 * do not take this special care we can end up getting
1203 			 * 2 pending chunks that start at the same physical
1204 			 * device offsets because the end offset of a pinned
1205 			 * chunk can be equal to the start offset of some
1206 			 * pending chunk.
1207 			 */
1208 			end = map->stripes[i].physical + em->orig_block_len;
1209 			if (end > *start) {
1210 				*start = end;
1211 				ret = 1;
1212 			}
1213 		}
1214 	}
1215 	if (search_list != &fs_info->pinned_chunks) {
1216 		search_list = &fs_info->pinned_chunks;
1217 		goto again;
1218 	}
1219 
1220 	return ret;
1221 }
1222 
1223 
1224 /*
1225  * find_free_dev_extent_start - find free space in the specified device
1226  * @device:	  the device which we search the free space in
1227  * @num_bytes:	  the size of the free space that we need
1228  * @search_start: the position from which to begin the search
1229  * @start:	  store the start of the free space.
1230  * @len:	  the size of the free space. that we find, or the size
1231  *		  of the max free space if we don't find suitable free space
1232  *
1233  * this uses a pretty simple search, the expectation is that it is
1234  * called very infrequently and that a given device has a small number
1235  * of extents
1236  *
1237  * @start is used to store the start of the free space if we find. But if we
1238  * don't find suitable free space, it will be used to store the start position
1239  * of the max free space.
1240  *
1241  * @len is used to store the size of the free space that we find.
1242  * But if we don't find suitable free space, it is used to store the size of
1243  * the max free space.
1244  */
find_free_dev_extent_start(struct btrfs_transaction * transaction,struct btrfs_device * device,u64 num_bytes,u64 search_start,u64 * start,u64 * len)1245 int find_free_dev_extent_start(struct btrfs_transaction *transaction,
1246 			       struct btrfs_device *device, u64 num_bytes,
1247 			       u64 search_start, u64 *start, u64 *len)
1248 {
1249 	struct btrfs_key key;
1250 	struct btrfs_root *root = device->dev_root;
1251 	struct btrfs_dev_extent *dev_extent;
1252 	struct btrfs_path *path;
1253 	u64 hole_size;
1254 	u64 max_hole_start;
1255 	u64 max_hole_size;
1256 	u64 extent_end;
1257 	u64 search_end = device->total_bytes;
1258 	int ret;
1259 	int slot;
1260 	struct extent_buffer *l;
1261 	u64 min_search_start;
1262 
1263 	/*
1264 	 * We don't want to overwrite the superblock on the drive nor any area
1265 	 * used by the boot loader (grub for example), so we make sure to start
1266 	 * at an offset of at least 1MB.
1267 	 */
1268 	min_search_start = max(root->fs_info->alloc_start, 1024ull * 1024);
1269 	search_start = max(search_start, min_search_start);
1270 
1271 	path = btrfs_alloc_path();
1272 	if (!path)
1273 		return -ENOMEM;
1274 
1275 	max_hole_start = search_start;
1276 	max_hole_size = 0;
1277 
1278 again:
1279 	if (search_start >= search_end || device->is_tgtdev_for_dev_replace) {
1280 		ret = -ENOSPC;
1281 		goto out;
1282 	}
1283 
1284 	path->reada = 2;
1285 	path->search_commit_root = 1;
1286 	path->skip_locking = 1;
1287 
1288 	key.objectid = device->devid;
1289 	key.offset = search_start;
1290 	key.type = BTRFS_DEV_EXTENT_KEY;
1291 
1292 	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1293 	if (ret < 0)
1294 		goto out;
1295 	if (ret > 0) {
1296 		ret = btrfs_previous_item(root, path, key.objectid, key.type);
1297 		if (ret < 0)
1298 			goto out;
1299 	}
1300 
1301 	while (1) {
1302 		l = path->nodes[0];
1303 		slot = path->slots[0];
1304 		if (slot >= btrfs_header_nritems(l)) {
1305 			ret = btrfs_next_leaf(root, path);
1306 			if (ret == 0)
1307 				continue;
1308 			if (ret < 0)
1309 				goto out;
1310 
1311 			break;
1312 		}
1313 		btrfs_item_key_to_cpu(l, &key, slot);
1314 
1315 		if (key.objectid < device->devid)
1316 			goto next;
1317 
1318 		if (key.objectid > device->devid)
1319 			break;
1320 
1321 		if (key.type != BTRFS_DEV_EXTENT_KEY)
1322 			goto next;
1323 
1324 		if (key.offset > search_start) {
1325 			hole_size = key.offset - search_start;
1326 
1327 			/*
1328 			 * Have to check before we set max_hole_start, otherwise
1329 			 * we could end up sending back this offset anyway.
1330 			 */
1331 			if (contains_pending_extent(transaction, device,
1332 						    &search_start,
1333 						    hole_size)) {
1334 				if (key.offset >= search_start) {
1335 					hole_size = key.offset - search_start;
1336 				} else {
1337 					WARN_ON_ONCE(1);
1338 					hole_size = 0;
1339 				}
1340 			}
1341 
1342 			if (hole_size > max_hole_size) {
1343 				max_hole_start = search_start;
1344 				max_hole_size = hole_size;
1345 			}
1346 
1347 			/*
1348 			 * If this free space is greater than which we need,
1349 			 * it must be the max free space that we have found
1350 			 * until now, so max_hole_start must point to the start
1351 			 * of this free space and the length of this free space
1352 			 * is stored in max_hole_size. Thus, we return
1353 			 * max_hole_start and max_hole_size and go back to the
1354 			 * caller.
1355 			 */
1356 			if (hole_size >= num_bytes) {
1357 				ret = 0;
1358 				goto out;
1359 			}
1360 		}
1361 
1362 		dev_extent = btrfs_item_ptr(l, slot, struct btrfs_dev_extent);
1363 		extent_end = key.offset + btrfs_dev_extent_length(l,
1364 								  dev_extent);
1365 		if (extent_end > search_start)
1366 			search_start = extent_end;
1367 next:
1368 		path->slots[0]++;
1369 		cond_resched();
1370 	}
1371 
1372 	/*
1373 	 * At this point, search_start should be the end of
1374 	 * allocated dev extents, and when shrinking the device,
1375 	 * search_end may be smaller than search_start.
1376 	 */
1377 	if (search_end > search_start) {
1378 		hole_size = search_end - search_start;
1379 
1380 		if (contains_pending_extent(transaction, device, &search_start,
1381 					    hole_size)) {
1382 			btrfs_release_path(path);
1383 			goto again;
1384 		}
1385 
1386 		if (hole_size > max_hole_size) {
1387 			max_hole_start = search_start;
1388 			max_hole_size = hole_size;
1389 		}
1390 	}
1391 
1392 	/* See above. */
1393 	if (max_hole_size < num_bytes)
1394 		ret = -ENOSPC;
1395 	else
1396 		ret = 0;
1397 
1398 out:
1399 	btrfs_free_path(path);
1400 	*start = max_hole_start;
1401 	if (len)
1402 		*len = max_hole_size;
1403 	return ret;
1404 }
1405 
find_free_dev_extent(struct btrfs_trans_handle * trans,struct btrfs_device * device,u64 num_bytes,u64 * start,u64 * len)1406 int find_free_dev_extent(struct btrfs_trans_handle *trans,
1407 			 struct btrfs_device *device, u64 num_bytes,
1408 			 u64 *start, u64 *len)
1409 {
1410 	/* FIXME use last free of some kind */
1411 	return find_free_dev_extent_start(trans->transaction, device,
1412 					  num_bytes, 0, start, len);
1413 }
1414 
btrfs_free_dev_extent(struct btrfs_trans_handle * trans,struct btrfs_device * device,u64 start,u64 * dev_extent_len)1415 static int btrfs_free_dev_extent(struct btrfs_trans_handle *trans,
1416 			  struct btrfs_device *device,
1417 			  u64 start, u64 *dev_extent_len)
1418 {
1419 	int ret;
1420 	struct btrfs_path *path;
1421 	struct btrfs_root *root = device->dev_root;
1422 	struct btrfs_key key;
1423 	struct btrfs_key found_key;
1424 	struct extent_buffer *leaf = NULL;
1425 	struct btrfs_dev_extent *extent = NULL;
1426 
1427 	path = btrfs_alloc_path();
1428 	if (!path)
1429 		return -ENOMEM;
1430 
1431 	key.objectid = device->devid;
1432 	key.offset = start;
1433 	key.type = BTRFS_DEV_EXTENT_KEY;
1434 again:
1435 	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1436 	if (ret > 0) {
1437 		ret = btrfs_previous_item(root, path, key.objectid,
1438 					  BTRFS_DEV_EXTENT_KEY);
1439 		if (ret)
1440 			goto out;
1441 		leaf = path->nodes[0];
1442 		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
1443 		extent = btrfs_item_ptr(leaf, path->slots[0],
1444 					struct btrfs_dev_extent);
1445 		BUG_ON(found_key.offset > start || found_key.offset +
1446 		       btrfs_dev_extent_length(leaf, extent) < start);
1447 		key = found_key;
1448 		btrfs_release_path(path);
1449 		goto again;
1450 	} else if (ret == 0) {
1451 		leaf = path->nodes[0];
1452 		extent = btrfs_item_ptr(leaf, path->slots[0],
1453 					struct btrfs_dev_extent);
1454 	} else {
1455 		btrfs_std_error(root->fs_info, ret, "Slot search failed");
1456 		goto out;
1457 	}
1458 
1459 	*dev_extent_len = btrfs_dev_extent_length(leaf, extent);
1460 
1461 	ret = btrfs_del_item(trans, root, path);
1462 	if (ret) {
1463 		btrfs_std_error(root->fs_info, ret,
1464 			    "Failed to remove dev extent item");
1465 	} else {
1466 		set_bit(BTRFS_TRANS_HAVE_FREE_BGS, &trans->transaction->flags);
1467 	}
1468 out:
1469 	btrfs_free_path(path);
1470 	return ret;
1471 }
1472 
btrfs_alloc_dev_extent(struct btrfs_trans_handle * trans,struct btrfs_device * device,u64 chunk_tree,u64 chunk_objectid,u64 chunk_offset,u64 start,u64 num_bytes)1473 static int btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans,
1474 				  struct btrfs_device *device,
1475 				  u64 chunk_tree, u64 chunk_objectid,
1476 				  u64 chunk_offset, u64 start, u64 num_bytes)
1477 {
1478 	int ret;
1479 	struct btrfs_path *path;
1480 	struct btrfs_root *root = device->dev_root;
1481 	struct btrfs_dev_extent *extent;
1482 	struct extent_buffer *leaf;
1483 	struct btrfs_key key;
1484 
1485 	WARN_ON(!device->in_fs_metadata);
1486 	WARN_ON(device->is_tgtdev_for_dev_replace);
1487 	path = btrfs_alloc_path();
1488 	if (!path)
1489 		return -ENOMEM;
1490 
1491 	key.objectid = device->devid;
1492 	key.offset = start;
1493 	key.type = BTRFS_DEV_EXTENT_KEY;
1494 	ret = btrfs_insert_empty_item(trans, root, path, &key,
1495 				      sizeof(*extent));
1496 	if (ret)
1497 		goto out;
1498 
1499 	leaf = path->nodes[0];
1500 	extent = btrfs_item_ptr(leaf, path->slots[0],
1501 				struct btrfs_dev_extent);
1502 	btrfs_set_dev_extent_chunk_tree(leaf, extent, chunk_tree);
1503 	btrfs_set_dev_extent_chunk_objectid(leaf, extent, chunk_objectid);
1504 	btrfs_set_dev_extent_chunk_offset(leaf, extent, chunk_offset);
1505 
1506 	write_extent_buffer(leaf, root->fs_info->chunk_tree_uuid,
1507 		    btrfs_dev_extent_chunk_tree_uuid(extent), BTRFS_UUID_SIZE);
1508 
1509 	btrfs_set_dev_extent_length(leaf, extent, num_bytes);
1510 	btrfs_mark_buffer_dirty(leaf);
1511 out:
1512 	btrfs_free_path(path);
1513 	return ret;
1514 }
1515 
find_next_chunk(struct btrfs_fs_info * fs_info)1516 static u64 find_next_chunk(struct btrfs_fs_info *fs_info)
1517 {
1518 	struct extent_map_tree *em_tree;
1519 	struct extent_map *em;
1520 	struct rb_node *n;
1521 	u64 ret = 0;
1522 
1523 	em_tree = &fs_info->mapping_tree.map_tree;
1524 	read_lock(&em_tree->lock);
1525 	n = rb_last(&em_tree->map);
1526 	if (n) {
1527 		em = rb_entry(n, struct extent_map, rb_node);
1528 		ret = em->start + em->len;
1529 	}
1530 	read_unlock(&em_tree->lock);
1531 
1532 	return ret;
1533 }
1534 
find_next_devid(struct btrfs_fs_info * fs_info,u64 * devid_ret)1535 static noinline int find_next_devid(struct btrfs_fs_info *fs_info,
1536 				    u64 *devid_ret)
1537 {
1538 	int ret;
1539 	struct btrfs_key key;
1540 	struct btrfs_key found_key;
1541 	struct btrfs_path *path;
1542 
1543 	path = btrfs_alloc_path();
1544 	if (!path)
1545 		return -ENOMEM;
1546 
1547 	key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
1548 	key.type = BTRFS_DEV_ITEM_KEY;
1549 	key.offset = (u64)-1;
1550 
1551 	ret = btrfs_search_slot(NULL, fs_info->chunk_root, &key, path, 0, 0);
1552 	if (ret < 0)
1553 		goto error;
1554 
1555 	BUG_ON(ret == 0); /* Corruption */
1556 
1557 	ret = btrfs_previous_item(fs_info->chunk_root, path,
1558 				  BTRFS_DEV_ITEMS_OBJECTID,
1559 				  BTRFS_DEV_ITEM_KEY);
1560 	if (ret) {
1561 		*devid_ret = 1;
1562 	} else {
1563 		btrfs_item_key_to_cpu(path->nodes[0], &found_key,
1564 				      path->slots[0]);
1565 		*devid_ret = found_key.offset + 1;
1566 	}
1567 	ret = 0;
1568 error:
1569 	btrfs_free_path(path);
1570 	return ret;
1571 }
1572 
1573 /*
1574  * the device information is stored in the chunk root
1575  * the btrfs_device struct should be fully filled in
1576  */
btrfs_add_device(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct btrfs_device * device)1577 static int btrfs_add_device(struct btrfs_trans_handle *trans,
1578 			    struct btrfs_root *root,
1579 			    struct btrfs_device *device)
1580 {
1581 	int ret;
1582 	struct btrfs_path *path;
1583 	struct btrfs_dev_item *dev_item;
1584 	struct extent_buffer *leaf;
1585 	struct btrfs_key key;
1586 	unsigned long ptr;
1587 
1588 	root = root->fs_info->chunk_root;
1589 
1590 	path = btrfs_alloc_path();
1591 	if (!path)
1592 		return -ENOMEM;
1593 
1594 	key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
1595 	key.type = BTRFS_DEV_ITEM_KEY;
1596 	key.offset = device->devid;
1597 
1598 	ret = btrfs_insert_empty_item(trans, root, path, &key,
1599 				      sizeof(*dev_item));
1600 	if (ret)
1601 		goto out;
1602 
1603 	leaf = path->nodes[0];
1604 	dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item);
1605 
1606 	btrfs_set_device_id(leaf, dev_item, device->devid);
1607 	btrfs_set_device_generation(leaf, dev_item, 0);
1608 	btrfs_set_device_type(leaf, dev_item, device->type);
1609 	btrfs_set_device_io_align(leaf, dev_item, device->io_align);
1610 	btrfs_set_device_io_width(leaf, dev_item, device->io_width);
1611 	btrfs_set_device_sector_size(leaf, dev_item, device->sector_size);
1612 	btrfs_set_device_total_bytes(leaf, dev_item,
1613 				     btrfs_device_get_disk_total_bytes(device));
1614 	btrfs_set_device_bytes_used(leaf, dev_item,
1615 				    btrfs_device_get_bytes_used(device));
1616 	btrfs_set_device_group(leaf, dev_item, 0);
1617 	btrfs_set_device_seek_speed(leaf, dev_item, 0);
1618 	btrfs_set_device_bandwidth(leaf, dev_item, 0);
1619 	btrfs_set_device_start_offset(leaf, dev_item, 0);
1620 
1621 	ptr = btrfs_device_uuid(dev_item);
1622 	write_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE);
1623 	ptr = btrfs_device_fsid(dev_item);
1624 	write_extent_buffer(leaf, root->fs_info->fsid, ptr, BTRFS_UUID_SIZE);
1625 	btrfs_mark_buffer_dirty(leaf);
1626 
1627 	ret = 0;
1628 out:
1629 	btrfs_free_path(path);
1630 	return ret;
1631 }
1632 
1633 /*
1634  * Function to update ctime/mtime for a given device path.
1635  * Mainly used for ctime/mtime based probe like libblkid.
1636  */
update_dev_time(char * path_name)1637 static void update_dev_time(char *path_name)
1638 {
1639 	struct file *filp;
1640 
1641 	filp = filp_open(path_name, O_RDWR, 0);
1642 	if (IS_ERR(filp))
1643 		return;
1644 	file_update_time(filp);
1645 	filp_close(filp, NULL);
1646 	return;
1647 }
1648 
btrfs_rm_dev_item(struct btrfs_root * root,struct btrfs_device * device)1649 static int btrfs_rm_dev_item(struct btrfs_root *root,
1650 			     struct btrfs_device *device)
1651 {
1652 	int ret;
1653 	struct btrfs_path *path;
1654 	struct btrfs_key key;
1655 	struct btrfs_trans_handle *trans;
1656 
1657 	root = root->fs_info->chunk_root;
1658 
1659 	path = btrfs_alloc_path();
1660 	if (!path)
1661 		return -ENOMEM;
1662 
1663 	trans = btrfs_start_transaction(root, 0);
1664 	if (IS_ERR(trans)) {
1665 		btrfs_free_path(path);
1666 		return PTR_ERR(trans);
1667 	}
1668 	key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
1669 	key.type = BTRFS_DEV_ITEM_KEY;
1670 	key.offset = device->devid;
1671 
1672 	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1673 	if (ret < 0)
1674 		goto out;
1675 
1676 	if (ret > 0) {
1677 		ret = -ENOENT;
1678 		goto out;
1679 	}
1680 
1681 	ret = btrfs_del_item(trans, root, path);
1682 	if (ret)
1683 		goto out;
1684 out:
1685 	btrfs_free_path(path);
1686 	btrfs_commit_transaction(trans, root);
1687 	return ret;
1688 }
1689 
btrfs_rm_device(struct btrfs_root * root,char * device_path)1690 int btrfs_rm_device(struct btrfs_root *root, char *device_path)
1691 {
1692 	struct btrfs_device *device;
1693 	struct btrfs_device *next_device;
1694 	struct block_device *bdev;
1695 	struct buffer_head *bh = NULL;
1696 	struct btrfs_super_block *disk_super;
1697 	struct btrfs_fs_devices *cur_devices;
1698 	u64 all_avail;
1699 	u64 devid;
1700 	u64 num_devices;
1701 	u8 *dev_uuid;
1702 	unsigned seq;
1703 	int ret = 0;
1704 	bool clear_super = false;
1705 
1706 	mutex_lock(&uuid_mutex);
1707 
1708 	do {
1709 		seq = read_seqbegin(&root->fs_info->profiles_lock);
1710 
1711 		all_avail = root->fs_info->avail_data_alloc_bits |
1712 			    root->fs_info->avail_system_alloc_bits |
1713 			    root->fs_info->avail_metadata_alloc_bits;
1714 	} while (read_seqretry(&root->fs_info->profiles_lock, seq));
1715 
1716 	num_devices = root->fs_info->fs_devices->num_devices;
1717 	btrfs_dev_replace_lock(&root->fs_info->dev_replace);
1718 	if (btrfs_dev_replace_is_ongoing(&root->fs_info->dev_replace)) {
1719 		WARN_ON(num_devices < 1);
1720 		num_devices--;
1721 	}
1722 	btrfs_dev_replace_unlock(&root->fs_info->dev_replace);
1723 
1724 	if ((all_avail & BTRFS_BLOCK_GROUP_RAID10) && num_devices <= 4) {
1725 		ret = BTRFS_ERROR_DEV_RAID10_MIN_NOT_MET;
1726 		goto out;
1727 	}
1728 
1729 	if ((all_avail & BTRFS_BLOCK_GROUP_RAID1) && num_devices <= 2) {
1730 		ret = BTRFS_ERROR_DEV_RAID1_MIN_NOT_MET;
1731 		goto out;
1732 	}
1733 
1734 	if ((all_avail & BTRFS_BLOCK_GROUP_RAID5) &&
1735 	    root->fs_info->fs_devices->rw_devices <= 2) {
1736 		ret = BTRFS_ERROR_DEV_RAID5_MIN_NOT_MET;
1737 		goto out;
1738 	}
1739 	if ((all_avail & BTRFS_BLOCK_GROUP_RAID6) &&
1740 	    root->fs_info->fs_devices->rw_devices <= 3) {
1741 		ret = BTRFS_ERROR_DEV_RAID6_MIN_NOT_MET;
1742 		goto out;
1743 	}
1744 
1745 	if (strcmp(device_path, "missing") == 0) {
1746 		struct list_head *devices;
1747 		struct btrfs_device *tmp;
1748 
1749 		device = NULL;
1750 		devices = &root->fs_info->fs_devices->devices;
1751 		/*
1752 		 * It is safe to read the devices since the volume_mutex
1753 		 * is held.
1754 		 */
1755 		list_for_each_entry(tmp, devices, dev_list) {
1756 			if (tmp->in_fs_metadata &&
1757 			    !tmp->is_tgtdev_for_dev_replace &&
1758 			    !tmp->bdev) {
1759 				device = tmp;
1760 				break;
1761 			}
1762 		}
1763 		bdev = NULL;
1764 		bh = NULL;
1765 		disk_super = NULL;
1766 		if (!device) {
1767 			ret = BTRFS_ERROR_DEV_MISSING_NOT_FOUND;
1768 			goto out;
1769 		}
1770 	} else {
1771 		ret = btrfs_get_bdev_and_sb(device_path,
1772 					    FMODE_WRITE | FMODE_EXCL,
1773 					    root->fs_info->bdev_holder, 0,
1774 					    &bdev, &bh);
1775 		if (ret)
1776 			goto out;
1777 		disk_super = (struct btrfs_super_block *)bh->b_data;
1778 		devid = btrfs_stack_device_id(&disk_super->dev_item);
1779 		dev_uuid = disk_super->dev_item.uuid;
1780 		device = btrfs_find_device(root->fs_info, devid, dev_uuid,
1781 					   disk_super->fsid);
1782 		if (!device) {
1783 			ret = -ENOENT;
1784 			goto error_brelse;
1785 		}
1786 	}
1787 
1788 	if (device->is_tgtdev_for_dev_replace) {
1789 		ret = BTRFS_ERROR_DEV_TGT_REPLACE;
1790 		goto error_brelse;
1791 	}
1792 
1793 	if (device->writeable && root->fs_info->fs_devices->rw_devices == 1) {
1794 		ret = BTRFS_ERROR_DEV_ONLY_WRITABLE;
1795 		goto error_brelse;
1796 	}
1797 
1798 	if (device->writeable) {
1799 		lock_chunks(root);
1800 		list_del_init(&device->dev_alloc_list);
1801 		device->fs_devices->rw_devices--;
1802 		unlock_chunks(root);
1803 		clear_super = true;
1804 	}
1805 
1806 	mutex_unlock(&uuid_mutex);
1807 	ret = btrfs_shrink_device(device, 0);
1808 	mutex_lock(&uuid_mutex);
1809 	if (ret)
1810 		goto error_undo;
1811 
1812 	/*
1813 	 * TODO: the superblock still includes this device in its num_devices
1814 	 * counter although write_all_supers() is not locked out. This
1815 	 * could give a filesystem state which requires a degraded mount.
1816 	 */
1817 	ret = btrfs_rm_dev_item(root->fs_info->chunk_root, device);
1818 	if (ret)
1819 		goto error_undo;
1820 
1821 	device->in_fs_metadata = 0;
1822 	btrfs_scrub_cancel_dev(root->fs_info, device);
1823 
1824 	/*
1825 	 * the device list mutex makes sure that we don't change
1826 	 * the device list while someone else is writing out all
1827 	 * the device supers. Whoever is writing all supers, should
1828 	 * lock the device list mutex before getting the number of
1829 	 * devices in the super block (super_copy). Conversely,
1830 	 * whoever updates the number of devices in the super block
1831 	 * (super_copy) should hold the device list mutex.
1832 	 */
1833 
1834 	cur_devices = device->fs_devices;
1835 	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
1836 	list_del_rcu(&device->dev_list);
1837 
1838 	device->fs_devices->num_devices--;
1839 	device->fs_devices->total_devices--;
1840 
1841 	if (device->missing)
1842 		device->fs_devices->missing_devices--;
1843 
1844 	next_device = list_entry(root->fs_info->fs_devices->devices.next,
1845 				 struct btrfs_device, dev_list);
1846 	if (device->bdev == root->fs_info->sb->s_bdev)
1847 		root->fs_info->sb->s_bdev = next_device->bdev;
1848 	if (device->bdev == root->fs_info->fs_devices->latest_bdev)
1849 		root->fs_info->fs_devices->latest_bdev = next_device->bdev;
1850 
1851 	if (device->bdev) {
1852 		device->fs_devices->open_devices--;
1853 		/* remove sysfs entry */
1854 		btrfs_sysfs_rm_device_link(root->fs_info->fs_devices, device);
1855 	}
1856 
1857 	call_rcu(&device->rcu, free_device);
1858 
1859 	num_devices = btrfs_super_num_devices(root->fs_info->super_copy) - 1;
1860 	btrfs_set_super_num_devices(root->fs_info->super_copy, num_devices);
1861 	mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
1862 
1863 	if (cur_devices->open_devices == 0) {
1864 		struct btrfs_fs_devices *fs_devices;
1865 		fs_devices = root->fs_info->fs_devices;
1866 		while (fs_devices) {
1867 			if (fs_devices->seed == cur_devices) {
1868 				fs_devices->seed = cur_devices->seed;
1869 				break;
1870 			}
1871 			fs_devices = fs_devices->seed;
1872 		}
1873 		cur_devices->seed = NULL;
1874 		__btrfs_close_devices(cur_devices);
1875 		free_fs_devices(cur_devices);
1876 	}
1877 
1878 	root->fs_info->num_tolerated_disk_barrier_failures =
1879 		btrfs_calc_num_tolerated_disk_barrier_failures(root->fs_info);
1880 
1881 	/*
1882 	 * at this point, the device is zero sized.  We want to
1883 	 * remove it from the devices list and zero out the old super
1884 	 */
1885 	if (clear_super && disk_super) {
1886 		u64 bytenr;
1887 		int i;
1888 
1889 		/* make sure this device isn't detected as part of
1890 		 * the FS anymore
1891 		 */
1892 		memset(&disk_super->magic, 0, sizeof(disk_super->magic));
1893 		set_buffer_dirty(bh);
1894 		sync_dirty_buffer(bh);
1895 
1896 		/* clear the mirror copies of super block on the disk
1897 		 * being removed, 0th copy is been taken care above and
1898 		 * the below would take of the rest
1899 		 */
1900 		for (i = 1; i < BTRFS_SUPER_MIRROR_MAX; i++) {
1901 			bytenr = btrfs_sb_offset(i);
1902 			if (bytenr + BTRFS_SUPER_INFO_SIZE >=
1903 					i_size_read(bdev->bd_inode))
1904 				break;
1905 
1906 			brelse(bh);
1907 			bh = __bread(bdev, bytenr / 4096,
1908 					BTRFS_SUPER_INFO_SIZE);
1909 			if (!bh)
1910 				continue;
1911 
1912 			disk_super = (struct btrfs_super_block *)bh->b_data;
1913 
1914 			if (btrfs_super_bytenr(disk_super) != bytenr ||
1915 				btrfs_super_magic(disk_super) != BTRFS_MAGIC) {
1916 				continue;
1917 			}
1918 			memset(&disk_super->magic, 0,
1919 						sizeof(disk_super->magic));
1920 			set_buffer_dirty(bh);
1921 			sync_dirty_buffer(bh);
1922 		}
1923 	}
1924 
1925 	ret = 0;
1926 
1927 	if (bdev) {
1928 		/* Notify udev that device has changed */
1929 		btrfs_kobject_uevent(bdev, KOBJ_CHANGE);
1930 
1931 		/* Update ctime/mtime for device path for libblkid */
1932 		update_dev_time(device_path);
1933 	}
1934 
1935 error_brelse:
1936 	brelse(bh);
1937 	if (bdev)
1938 		blkdev_put(bdev, FMODE_READ | FMODE_EXCL);
1939 out:
1940 	mutex_unlock(&uuid_mutex);
1941 	return ret;
1942 error_undo:
1943 	if (device->writeable) {
1944 		lock_chunks(root);
1945 		list_add(&device->dev_alloc_list,
1946 			 &root->fs_info->fs_devices->alloc_list);
1947 		device->fs_devices->rw_devices++;
1948 		unlock_chunks(root);
1949 	}
1950 	goto error_brelse;
1951 }
1952 
btrfs_rm_dev_replace_remove_srcdev(struct btrfs_fs_info * fs_info,struct btrfs_device * srcdev)1953 void btrfs_rm_dev_replace_remove_srcdev(struct btrfs_fs_info *fs_info,
1954 					struct btrfs_device *srcdev)
1955 {
1956 	struct btrfs_fs_devices *fs_devices;
1957 
1958 	WARN_ON(!mutex_is_locked(&fs_info->fs_devices->device_list_mutex));
1959 
1960 	/*
1961 	 * in case of fs with no seed, srcdev->fs_devices will point
1962 	 * to fs_devices of fs_info. However when the dev being replaced is
1963 	 * a seed dev it will point to the seed's local fs_devices. In short
1964 	 * srcdev will have its correct fs_devices in both the cases.
1965 	 */
1966 	fs_devices = srcdev->fs_devices;
1967 
1968 	list_del_rcu(&srcdev->dev_list);
1969 	list_del_rcu(&srcdev->dev_alloc_list);
1970 	fs_devices->num_devices--;
1971 	if (srcdev->missing)
1972 		fs_devices->missing_devices--;
1973 
1974 	if (srcdev->writeable) {
1975 		fs_devices->rw_devices--;
1976 		/* zero out the old super if it is writable */
1977 		btrfs_scratch_superblocks(srcdev->bdev, srcdev->name->str);
1978 	}
1979 
1980 	if (srcdev->bdev)
1981 		fs_devices->open_devices--;
1982 }
1983 
btrfs_rm_dev_replace_free_srcdev(struct btrfs_fs_info * fs_info,struct btrfs_device * srcdev)1984 void btrfs_rm_dev_replace_free_srcdev(struct btrfs_fs_info *fs_info,
1985 				      struct btrfs_device *srcdev)
1986 {
1987 	struct btrfs_fs_devices *fs_devices = srcdev->fs_devices;
1988 
1989 	call_rcu(&srcdev->rcu, free_device);
1990 
1991 	/*
1992 	 * unless fs_devices is seed fs, num_devices shouldn't go
1993 	 * zero
1994 	 */
1995 	BUG_ON(!fs_devices->num_devices && !fs_devices->seeding);
1996 
1997 	/* if this is no devs we rather delete the fs_devices */
1998 	if (!fs_devices->num_devices) {
1999 		struct btrfs_fs_devices *tmp_fs_devices;
2000 
2001 		tmp_fs_devices = fs_info->fs_devices;
2002 		while (tmp_fs_devices) {
2003 			if (tmp_fs_devices->seed == fs_devices) {
2004 				tmp_fs_devices->seed = fs_devices->seed;
2005 				break;
2006 			}
2007 			tmp_fs_devices = tmp_fs_devices->seed;
2008 		}
2009 		fs_devices->seed = NULL;
2010 		__btrfs_close_devices(fs_devices);
2011 		free_fs_devices(fs_devices);
2012 	}
2013 }
2014 
btrfs_destroy_dev_replace_tgtdev(struct btrfs_fs_info * fs_info,struct btrfs_device * tgtdev)2015 void btrfs_destroy_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
2016 				      struct btrfs_device *tgtdev)
2017 {
2018 	struct btrfs_device *next_device;
2019 
2020 	mutex_lock(&uuid_mutex);
2021 	WARN_ON(!tgtdev);
2022 	mutex_lock(&fs_info->fs_devices->device_list_mutex);
2023 
2024 	btrfs_sysfs_rm_device_link(fs_info->fs_devices, tgtdev);
2025 
2026 	if (tgtdev->bdev) {
2027 		btrfs_scratch_superblocks(tgtdev->bdev, tgtdev->name->str);
2028 		fs_info->fs_devices->open_devices--;
2029 	}
2030 	fs_info->fs_devices->num_devices--;
2031 
2032 	next_device = list_entry(fs_info->fs_devices->devices.next,
2033 				 struct btrfs_device, dev_list);
2034 	if (tgtdev->bdev == fs_info->sb->s_bdev)
2035 		fs_info->sb->s_bdev = next_device->bdev;
2036 	if (tgtdev->bdev == fs_info->fs_devices->latest_bdev)
2037 		fs_info->fs_devices->latest_bdev = next_device->bdev;
2038 	list_del_rcu(&tgtdev->dev_list);
2039 
2040 	call_rcu(&tgtdev->rcu, free_device);
2041 
2042 	mutex_unlock(&fs_info->fs_devices->device_list_mutex);
2043 	mutex_unlock(&uuid_mutex);
2044 }
2045 
btrfs_find_device_by_path(struct btrfs_root * root,char * device_path,struct btrfs_device ** device)2046 static int btrfs_find_device_by_path(struct btrfs_root *root, char *device_path,
2047 				     struct btrfs_device **device)
2048 {
2049 	int ret = 0;
2050 	struct btrfs_super_block *disk_super;
2051 	u64 devid;
2052 	u8 *dev_uuid;
2053 	struct block_device *bdev;
2054 	struct buffer_head *bh;
2055 
2056 	*device = NULL;
2057 	ret = btrfs_get_bdev_and_sb(device_path, FMODE_READ,
2058 				    root->fs_info->bdev_holder, 0, &bdev, &bh);
2059 	if (ret)
2060 		return ret;
2061 	disk_super = (struct btrfs_super_block *)bh->b_data;
2062 	devid = btrfs_stack_device_id(&disk_super->dev_item);
2063 	dev_uuid = disk_super->dev_item.uuid;
2064 	*device = btrfs_find_device(root->fs_info, devid, dev_uuid,
2065 				    disk_super->fsid);
2066 	brelse(bh);
2067 	if (!*device)
2068 		ret = -ENOENT;
2069 	blkdev_put(bdev, FMODE_READ);
2070 	return ret;
2071 }
2072 
btrfs_find_device_missing_or_by_path(struct btrfs_root * root,char * device_path,struct btrfs_device ** device)2073 int btrfs_find_device_missing_or_by_path(struct btrfs_root *root,
2074 					 char *device_path,
2075 					 struct btrfs_device **device)
2076 {
2077 	*device = NULL;
2078 	if (strcmp(device_path, "missing") == 0) {
2079 		struct list_head *devices;
2080 		struct btrfs_device *tmp;
2081 
2082 		devices = &root->fs_info->fs_devices->devices;
2083 		/*
2084 		 * It is safe to read the devices since the volume_mutex
2085 		 * is held by the caller.
2086 		 */
2087 		list_for_each_entry(tmp, devices, dev_list) {
2088 			if (tmp->in_fs_metadata && !tmp->bdev) {
2089 				*device = tmp;
2090 				break;
2091 			}
2092 		}
2093 
2094 		if (!*device)
2095 			return BTRFS_ERROR_DEV_MISSING_NOT_FOUND;
2096 
2097 		return 0;
2098 	} else {
2099 		return btrfs_find_device_by_path(root, device_path, device);
2100 	}
2101 }
2102 
2103 /*
2104  * does all the dirty work required for changing file system's UUID.
2105  */
btrfs_prepare_sprout(struct btrfs_root * root)2106 static int btrfs_prepare_sprout(struct btrfs_root *root)
2107 {
2108 	struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
2109 	struct btrfs_fs_devices *old_devices;
2110 	struct btrfs_fs_devices *seed_devices;
2111 	struct btrfs_super_block *disk_super = root->fs_info->super_copy;
2112 	struct btrfs_device *device;
2113 	u64 super_flags;
2114 
2115 	BUG_ON(!mutex_is_locked(&uuid_mutex));
2116 	if (!fs_devices->seeding)
2117 		return -EINVAL;
2118 
2119 	seed_devices = __alloc_fs_devices();
2120 	if (IS_ERR(seed_devices))
2121 		return PTR_ERR(seed_devices);
2122 
2123 	old_devices = clone_fs_devices(fs_devices);
2124 	if (IS_ERR(old_devices)) {
2125 		kfree(seed_devices);
2126 		return PTR_ERR(old_devices);
2127 	}
2128 
2129 	list_add(&old_devices->list, &fs_uuids);
2130 
2131 	memcpy(seed_devices, fs_devices, sizeof(*seed_devices));
2132 	seed_devices->opened = 1;
2133 	INIT_LIST_HEAD(&seed_devices->devices);
2134 	INIT_LIST_HEAD(&seed_devices->alloc_list);
2135 	mutex_init(&seed_devices->device_list_mutex);
2136 
2137 	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
2138 	list_splice_init_rcu(&fs_devices->devices, &seed_devices->devices,
2139 			      synchronize_rcu);
2140 	list_for_each_entry(device, &seed_devices->devices, dev_list)
2141 		device->fs_devices = seed_devices;
2142 
2143 	lock_chunks(root);
2144 	list_splice_init(&fs_devices->alloc_list, &seed_devices->alloc_list);
2145 	unlock_chunks(root);
2146 
2147 	fs_devices->seeding = 0;
2148 	fs_devices->num_devices = 0;
2149 	fs_devices->open_devices = 0;
2150 	fs_devices->missing_devices = 0;
2151 	fs_devices->rotating = 0;
2152 	fs_devices->seed = seed_devices;
2153 
2154 	generate_random_uuid(fs_devices->fsid);
2155 	memcpy(root->fs_info->fsid, fs_devices->fsid, BTRFS_FSID_SIZE);
2156 	memcpy(disk_super->fsid, fs_devices->fsid, BTRFS_FSID_SIZE);
2157 	mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
2158 
2159 	super_flags = btrfs_super_flags(disk_super) &
2160 		      ~BTRFS_SUPER_FLAG_SEEDING;
2161 	btrfs_set_super_flags(disk_super, super_flags);
2162 
2163 	return 0;
2164 }
2165 
2166 /*
2167  * strore the expected generation for seed devices in device items.
2168  */
btrfs_finish_sprout(struct btrfs_trans_handle * trans,struct btrfs_root * root)2169 static int btrfs_finish_sprout(struct btrfs_trans_handle *trans,
2170 			       struct btrfs_root *root)
2171 {
2172 	struct btrfs_path *path;
2173 	struct extent_buffer *leaf;
2174 	struct btrfs_dev_item *dev_item;
2175 	struct btrfs_device *device;
2176 	struct btrfs_key key;
2177 	u8 fs_uuid[BTRFS_UUID_SIZE];
2178 	u8 dev_uuid[BTRFS_UUID_SIZE];
2179 	u64 devid;
2180 	int ret;
2181 
2182 	path = btrfs_alloc_path();
2183 	if (!path)
2184 		return -ENOMEM;
2185 
2186 	root = root->fs_info->chunk_root;
2187 	key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
2188 	key.offset = 0;
2189 	key.type = BTRFS_DEV_ITEM_KEY;
2190 
2191 	while (1) {
2192 		ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2193 		if (ret < 0)
2194 			goto error;
2195 
2196 		leaf = path->nodes[0];
2197 next_slot:
2198 		if (path->slots[0] >= btrfs_header_nritems(leaf)) {
2199 			ret = btrfs_next_leaf(root, path);
2200 			if (ret > 0)
2201 				break;
2202 			if (ret < 0)
2203 				goto error;
2204 			leaf = path->nodes[0];
2205 			btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
2206 			btrfs_release_path(path);
2207 			continue;
2208 		}
2209 
2210 		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
2211 		if (key.objectid != BTRFS_DEV_ITEMS_OBJECTID ||
2212 		    key.type != BTRFS_DEV_ITEM_KEY)
2213 			break;
2214 
2215 		dev_item = btrfs_item_ptr(leaf, path->slots[0],
2216 					  struct btrfs_dev_item);
2217 		devid = btrfs_device_id(leaf, dev_item);
2218 		read_extent_buffer(leaf, dev_uuid, btrfs_device_uuid(dev_item),
2219 				   BTRFS_UUID_SIZE);
2220 		read_extent_buffer(leaf, fs_uuid, btrfs_device_fsid(dev_item),
2221 				   BTRFS_UUID_SIZE);
2222 		device = btrfs_find_device(root->fs_info, devid, dev_uuid,
2223 					   fs_uuid);
2224 		BUG_ON(!device); /* Logic error */
2225 
2226 		if (device->fs_devices->seeding) {
2227 			btrfs_set_device_generation(leaf, dev_item,
2228 						    device->generation);
2229 			btrfs_mark_buffer_dirty(leaf);
2230 		}
2231 
2232 		path->slots[0]++;
2233 		goto next_slot;
2234 	}
2235 	ret = 0;
2236 error:
2237 	btrfs_free_path(path);
2238 	return ret;
2239 }
2240 
btrfs_init_new_device(struct btrfs_root * root,char * device_path)2241 int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
2242 {
2243 	struct request_queue *q;
2244 	struct btrfs_trans_handle *trans;
2245 	struct btrfs_device *device;
2246 	struct block_device *bdev;
2247 	struct list_head *devices;
2248 	struct super_block *sb = root->fs_info->sb;
2249 	struct rcu_string *name;
2250 	u64 tmp;
2251 	int seeding_dev = 0;
2252 	int ret = 0;
2253 
2254 	if ((sb->s_flags & MS_RDONLY) && !root->fs_info->fs_devices->seeding)
2255 		return -EROFS;
2256 
2257 	bdev = blkdev_get_by_path(device_path, FMODE_WRITE | FMODE_EXCL,
2258 				  root->fs_info->bdev_holder);
2259 	if (IS_ERR(bdev))
2260 		return PTR_ERR(bdev);
2261 
2262 	if (root->fs_info->fs_devices->seeding) {
2263 		seeding_dev = 1;
2264 		down_write(&sb->s_umount);
2265 		mutex_lock(&uuid_mutex);
2266 	}
2267 
2268 	filemap_write_and_wait(bdev->bd_inode->i_mapping);
2269 
2270 	devices = &root->fs_info->fs_devices->devices;
2271 
2272 	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
2273 	list_for_each_entry(device, devices, dev_list) {
2274 		if (device->bdev == bdev) {
2275 			ret = -EEXIST;
2276 			mutex_unlock(
2277 				&root->fs_info->fs_devices->device_list_mutex);
2278 			goto error;
2279 		}
2280 	}
2281 	mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
2282 
2283 	device = btrfs_alloc_device(root->fs_info, NULL, NULL);
2284 	if (IS_ERR(device)) {
2285 		/* we can safely leave the fs_devices entry around */
2286 		ret = PTR_ERR(device);
2287 		goto error;
2288 	}
2289 
2290 	name = rcu_string_strdup(device_path, GFP_NOFS);
2291 	if (!name) {
2292 		kfree(device);
2293 		ret = -ENOMEM;
2294 		goto error;
2295 	}
2296 	rcu_assign_pointer(device->name, name);
2297 
2298 	trans = btrfs_start_transaction(root, 0);
2299 	if (IS_ERR(trans)) {
2300 		rcu_string_free(device->name);
2301 		kfree(device);
2302 		ret = PTR_ERR(trans);
2303 		goto error;
2304 	}
2305 
2306 	q = bdev_get_queue(bdev);
2307 	if (blk_queue_discard(q))
2308 		device->can_discard = 1;
2309 	device->writeable = 1;
2310 	device->generation = trans->transid;
2311 	device->io_width = root->sectorsize;
2312 	device->io_align = root->sectorsize;
2313 	device->sector_size = root->sectorsize;
2314 	device->total_bytes = i_size_read(bdev->bd_inode);
2315 	device->disk_total_bytes = device->total_bytes;
2316 	device->commit_total_bytes = device->total_bytes;
2317 	device->dev_root = root->fs_info->dev_root;
2318 	device->bdev = bdev;
2319 	device->in_fs_metadata = 1;
2320 	device->is_tgtdev_for_dev_replace = 0;
2321 	device->mode = FMODE_EXCL;
2322 	device->dev_stats_valid = 1;
2323 	set_blocksize(device->bdev, 4096);
2324 
2325 	if (seeding_dev) {
2326 		sb->s_flags &= ~MS_RDONLY;
2327 		ret = btrfs_prepare_sprout(root);
2328 		BUG_ON(ret); /* -ENOMEM */
2329 	}
2330 
2331 	device->fs_devices = root->fs_info->fs_devices;
2332 
2333 	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
2334 	lock_chunks(root);
2335 	list_add_rcu(&device->dev_list, &root->fs_info->fs_devices->devices);
2336 	list_add(&device->dev_alloc_list,
2337 		 &root->fs_info->fs_devices->alloc_list);
2338 	root->fs_info->fs_devices->num_devices++;
2339 	root->fs_info->fs_devices->open_devices++;
2340 	root->fs_info->fs_devices->rw_devices++;
2341 	root->fs_info->fs_devices->total_devices++;
2342 	root->fs_info->fs_devices->total_rw_bytes += device->total_bytes;
2343 
2344 	spin_lock(&root->fs_info->free_chunk_lock);
2345 	root->fs_info->free_chunk_space += device->total_bytes;
2346 	spin_unlock(&root->fs_info->free_chunk_lock);
2347 
2348 	if (!blk_queue_nonrot(bdev_get_queue(bdev)))
2349 		root->fs_info->fs_devices->rotating = 1;
2350 
2351 	tmp = btrfs_super_total_bytes(root->fs_info->super_copy);
2352 	btrfs_set_super_total_bytes(root->fs_info->super_copy,
2353 				    tmp + device->total_bytes);
2354 
2355 	tmp = btrfs_super_num_devices(root->fs_info->super_copy);
2356 	btrfs_set_super_num_devices(root->fs_info->super_copy,
2357 				    tmp + 1);
2358 
2359 	/* add sysfs device entry */
2360 	btrfs_sysfs_add_device_link(root->fs_info->fs_devices, device);
2361 
2362 	/*
2363 	 * we've got more storage, clear any full flags on the space
2364 	 * infos
2365 	 */
2366 	btrfs_clear_space_info_full(root->fs_info);
2367 
2368 	unlock_chunks(root);
2369 	mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
2370 
2371 	if (seeding_dev) {
2372 		lock_chunks(root);
2373 		ret = init_first_rw_device(trans, root, device);
2374 		unlock_chunks(root);
2375 		if (ret) {
2376 			btrfs_abort_transaction(trans, root, ret);
2377 			goto error_trans;
2378 		}
2379 	}
2380 
2381 	ret = btrfs_add_device(trans, root, device);
2382 	if (ret) {
2383 		btrfs_abort_transaction(trans, root, ret);
2384 		goto error_trans;
2385 	}
2386 
2387 	if (seeding_dev) {
2388 		char fsid_buf[BTRFS_UUID_UNPARSED_SIZE];
2389 
2390 		ret = btrfs_finish_sprout(trans, root);
2391 		if (ret) {
2392 			btrfs_abort_transaction(trans, root, ret);
2393 			goto error_trans;
2394 		}
2395 
2396 		/* Sprouting would change fsid of the mounted root,
2397 		 * so rename the fsid on the sysfs
2398 		 */
2399 		snprintf(fsid_buf, BTRFS_UUID_UNPARSED_SIZE, "%pU",
2400 						root->fs_info->fsid);
2401 		if (kobject_rename(&root->fs_info->fs_devices->fsid_kobj,
2402 								fsid_buf))
2403 			btrfs_warn(root->fs_info,
2404 				"sysfs: failed to create fsid for sprout");
2405 	}
2406 
2407 	root->fs_info->num_tolerated_disk_barrier_failures =
2408 		btrfs_calc_num_tolerated_disk_barrier_failures(root->fs_info);
2409 	ret = btrfs_commit_transaction(trans, root);
2410 
2411 	if (seeding_dev) {
2412 		mutex_unlock(&uuid_mutex);
2413 		up_write(&sb->s_umount);
2414 
2415 		if (ret) /* transaction commit */
2416 			return ret;
2417 
2418 		ret = btrfs_relocate_sys_chunks(root);
2419 		if (ret < 0)
2420 			btrfs_std_error(root->fs_info, ret,
2421 				    "Failed to relocate sys chunks after "
2422 				    "device initialization. This can be fixed "
2423 				    "using the \"btrfs balance\" command.");
2424 		trans = btrfs_attach_transaction(root);
2425 		if (IS_ERR(trans)) {
2426 			if (PTR_ERR(trans) == -ENOENT)
2427 				return 0;
2428 			return PTR_ERR(trans);
2429 		}
2430 		ret = btrfs_commit_transaction(trans, root);
2431 	}
2432 
2433 	/* Update ctime/mtime for libblkid */
2434 	update_dev_time(device_path);
2435 	return ret;
2436 
2437 error_trans:
2438 	btrfs_end_transaction(trans, root);
2439 	rcu_string_free(device->name);
2440 	btrfs_sysfs_rm_device_link(root->fs_info->fs_devices, device);
2441 	kfree(device);
2442 error:
2443 	blkdev_put(bdev, FMODE_EXCL);
2444 	if (seeding_dev) {
2445 		mutex_unlock(&uuid_mutex);
2446 		up_write(&sb->s_umount);
2447 	}
2448 	return ret;
2449 }
2450 
btrfs_init_dev_replace_tgtdev(struct btrfs_root * root,char * device_path,struct btrfs_device * srcdev,struct btrfs_device ** device_out)2451 int btrfs_init_dev_replace_tgtdev(struct btrfs_root *root, char *device_path,
2452 				  struct btrfs_device *srcdev,
2453 				  struct btrfs_device **device_out)
2454 {
2455 	struct request_queue *q;
2456 	struct btrfs_device *device;
2457 	struct block_device *bdev;
2458 	struct btrfs_fs_info *fs_info = root->fs_info;
2459 	struct list_head *devices;
2460 	struct rcu_string *name;
2461 	u64 devid = BTRFS_DEV_REPLACE_DEVID;
2462 	int ret = 0;
2463 
2464 	*device_out = NULL;
2465 	if (fs_info->fs_devices->seeding) {
2466 		btrfs_err(fs_info, "the filesystem is a seed filesystem!");
2467 		return -EINVAL;
2468 	}
2469 
2470 	bdev = blkdev_get_by_path(device_path, FMODE_WRITE | FMODE_EXCL,
2471 				  fs_info->bdev_holder);
2472 	if (IS_ERR(bdev)) {
2473 		btrfs_err(fs_info, "target device %s is invalid!", device_path);
2474 		return PTR_ERR(bdev);
2475 	}
2476 
2477 	filemap_write_and_wait(bdev->bd_inode->i_mapping);
2478 
2479 	devices = &fs_info->fs_devices->devices;
2480 	list_for_each_entry(device, devices, dev_list) {
2481 		if (device->bdev == bdev) {
2482 			btrfs_err(fs_info, "target device is in the filesystem!");
2483 			ret = -EEXIST;
2484 			goto error;
2485 		}
2486 	}
2487 
2488 
2489 	if (i_size_read(bdev->bd_inode) <
2490 	    btrfs_device_get_total_bytes(srcdev)) {
2491 		btrfs_err(fs_info, "target device is smaller than source device!");
2492 		ret = -EINVAL;
2493 		goto error;
2494 	}
2495 
2496 
2497 	device = btrfs_alloc_device(NULL, &devid, NULL);
2498 	if (IS_ERR(device)) {
2499 		ret = PTR_ERR(device);
2500 		goto error;
2501 	}
2502 
2503 	name = rcu_string_strdup(device_path, GFP_NOFS);
2504 	if (!name) {
2505 		kfree(device);
2506 		ret = -ENOMEM;
2507 		goto error;
2508 	}
2509 	rcu_assign_pointer(device->name, name);
2510 
2511 	q = bdev_get_queue(bdev);
2512 	if (blk_queue_discard(q))
2513 		device->can_discard = 1;
2514 	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
2515 	device->writeable = 1;
2516 	device->generation = 0;
2517 	device->io_width = root->sectorsize;
2518 	device->io_align = root->sectorsize;
2519 	device->sector_size = root->sectorsize;
2520 	device->total_bytes = btrfs_device_get_total_bytes(srcdev);
2521 	device->disk_total_bytes = btrfs_device_get_disk_total_bytes(srcdev);
2522 	device->bytes_used = btrfs_device_get_bytes_used(srcdev);
2523 	ASSERT(list_empty(&srcdev->resized_list));
2524 	device->commit_total_bytes = srcdev->commit_total_bytes;
2525 	device->commit_bytes_used = device->bytes_used;
2526 	device->dev_root = fs_info->dev_root;
2527 	device->bdev = bdev;
2528 	device->in_fs_metadata = 1;
2529 	device->is_tgtdev_for_dev_replace = 1;
2530 	device->mode = FMODE_EXCL;
2531 	device->dev_stats_valid = 1;
2532 	set_blocksize(device->bdev, 4096);
2533 	device->fs_devices = fs_info->fs_devices;
2534 	list_add(&device->dev_list, &fs_info->fs_devices->devices);
2535 	fs_info->fs_devices->num_devices++;
2536 	fs_info->fs_devices->open_devices++;
2537 	mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
2538 
2539 	*device_out = device;
2540 	return ret;
2541 
2542 error:
2543 	blkdev_put(bdev, FMODE_EXCL);
2544 	return ret;
2545 }
2546 
btrfs_init_dev_replace_tgtdev_for_resume(struct btrfs_fs_info * fs_info,struct btrfs_device * tgtdev)2547 void btrfs_init_dev_replace_tgtdev_for_resume(struct btrfs_fs_info *fs_info,
2548 					      struct btrfs_device *tgtdev)
2549 {
2550 	WARN_ON(fs_info->fs_devices->rw_devices == 0);
2551 	tgtdev->io_width = fs_info->dev_root->sectorsize;
2552 	tgtdev->io_align = fs_info->dev_root->sectorsize;
2553 	tgtdev->sector_size = fs_info->dev_root->sectorsize;
2554 	tgtdev->dev_root = fs_info->dev_root;
2555 	tgtdev->in_fs_metadata = 1;
2556 }
2557 
btrfs_update_device(struct btrfs_trans_handle * trans,struct btrfs_device * device)2558 static noinline int btrfs_update_device(struct btrfs_trans_handle *trans,
2559 					struct btrfs_device *device)
2560 {
2561 	int ret;
2562 	struct btrfs_path *path;
2563 	struct btrfs_root *root;
2564 	struct btrfs_dev_item *dev_item;
2565 	struct extent_buffer *leaf;
2566 	struct btrfs_key key;
2567 
2568 	root = device->dev_root->fs_info->chunk_root;
2569 
2570 	path = btrfs_alloc_path();
2571 	if (!path)
2572 		return -ENOMEM;
2573 
2574 	key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
2575 	key.type = BTRFS_DEV_ITEM_KEY;
2576 	key.offset = device->devid;
2577 
2578 	ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2579 	if (ret < 0)
2580 		goto out;
2581 
2582 	if (ret > 0) {
2583 		ret = -ENOENT;
2584 		goto out;
2585 	}
2586 
2587 	leaf = path->nodes[0];
2588 	dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item);
2589 
2590 	btrfs_set_device_id(leaf, dev_item, device->devid);
2591 	btrfs_set_device_type(leaf, dev_item, device->type);
2592 	btrfs_set_device_io_align(leaf, dev_item, device->io_align);
2593 	btrfs_set_device_io_width(leaf, dev_item, device->io_width);
2594 	btrfs_set_device_sector_size(leaf, dev_item, device->sector_size);
2595 	btrfs_set_device_total_bytes(leaf, dev_item,
2596 				     btrfs_device_get_disk_total_bytes(device));
2597 	btrfs_set_device_bytes_used(leaf, dev_item,
2598 				    btrfs_device_get_bytes_used(device));
2599 	btrfs_mark_buffer_dirty(leaf);
2600 
2601 out:
2602 	btrfs_free_path(path);
2603 	return ret;
2604 }
2605 
btrfs_grow_device(struct btrfs_trans_handle * trans,struct btrfs_device * device,u64 new_size)2606 int btrfs_grow_device(struct btrfs_trans_handle *trans,
2607 		      struct btrfs_device *device, u64 new_size)
2608 {
2609 	struct btrfs_super_block *super_copy =
2610 		device->dev_root->fs_info->super_copy;
2611 	struct btrfs_fs_devices *fs_devices;
2612 	u64 old_total;
2613 	u64 diff;
2614 
2615 	if (!device->writeable)
2616 		return -EACCES;
2617 
2618 	lock_chunks(device->dev_root);
2619 	old_total = btrfs_super_total_bytes(super_copy);
2620 	diff = new_size - device->total_bytes;
2621 
2622 	if (new_size <= device->total_bytes ||
2623 	    device->is_tgtdev_for_dev_replace) {
2624 		unlock_chunks(device->dev_root);
2625 		return -EINVAL;
2626 	}
2627 
2628 	fs_devices = device->dev_root->fs_info->fs_devices;
2629 
2630 	btrfs_set_super_total_bytes(super_copy, old_total + diff);
2631 	device->fs_devices->total_rw_bytes += diff;
2632 
2633 	btrfs_device_set_total_bytes(device, new_size);
2634 	btrfs_device_set_disk_total_bytes(device, new_size);
2635 	btrfs_clear_space_info_full(device->dev_root->fs_info);
2636 	if (list_empty(&device->resized_list))
2637 		list_add_tail(&device->resized_list,
2638 			      &fs_devices->resized_devices);
2639 	unlock_chunks(device->dev_root);
2640 
2641 	return btrfs_update_device(trans, device);
2642 }
2643 
btrfs_free_chunk(struct btrfs_trans_handle * trans,struct btrfs_root * root,u64 chunk_objectid,u64 chunk_offset)2644 static int btrfs_free_chunk(struct btrfs_trans_handle *trans,
2645 			    struct btrfs_root *root, u64 chunk_objectid,
2646 			    u64 chunk_offset)
2647 {
2648 	int ret;
2649 	struct btrfs_path *path;
2650 	struct btrfs_key key;
2651 
2652 	root = root->fs_info->chunk_root;
2653 	path = btrfs_alloc_path();
2654 	if (!path)
2655 		return -ENOMEM;
2656 
2657 	key.objectid = chunk_objectid;
2658 	key.offset = chunk_offset;
2659 	key.type = BTRFS_CHUNK_ITEM_KEY;
2660 
2661 	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
2662 	if (ret < 0)
2663 		goto out;
2664 	else if (ret > 0) { /* Logic error or corruption */
2665 		btrfs_std_error(root->fs_info, -ENOENT,
2666 			    "Failed lookup while freeing chunk.");
2667 		ret = -ENOENT;
2668 		goto out;
2669 	}
2670 
2671 	ret = btrfs_del_item(trans, root, path);
2672 	if (ret < 0)
2673 		btrfs_std_error(root->fs_info, ret,
2674 			    "Failed to delete chunk item.");
2675 out:
2676 	btrfs_free_path(path);
2677 	return ret;
2678 }
2679 
btrfs_del_sys_chunk(struct btrfs_root * root,u64 chunk_objectid,u64 chunk_offset)2680 static int btrfs_del_sys_chunk(struct btrfs_root *root, u64 chunk_objectid, u64
2681 			chunk_offset)
2682 {
2683 	struct btrfs_super_block *super_copy = root->fs_info->super_copy;
2684 	struct btrfs_disk_key *disk_key;
2685 	struct btrfs_chunk *chunk;
2686 	u8 *ptr;
2687 	int ret = 0;
2688 	u32 num_stripes;
2689 	u32 array_size;
2690 	u32 len = 0;
2691 	u32 cur;
2692 	struct btrfs_key key;
2693 
2694 	lock_chunks(root);
2695 	array_size = btrfs_super_sys_array_size(super_copy);
2696 
2697 	ptr = super_copy->sys_chunk_array;
2698 	cur = 0;
2699 
2700 	while (cur < array_size) {
2701 		disk_key = (struct btrfs_disk_key *)ptr;
2702 		btrfs_disk_key_to_cpu(&key, disk_key);
2703 
2704 		len = sizeof(*disk_key);
2705 
2706 		if (key.type == BTRFS_CHUNK_ITEM_KEY) {
2707 			chunk = (struct btrfs_chunk *)(ptr + len);
2708 			num_stripes = btrfs_stack_chunk_num_stripes(chunk);
2709 			len += btrfs_chunk_item_size(num_stripes);
2710 		} else {
2711 			ret = -EIO;
2712 			break;
2713 		}
2714 		if (key.objectid == chunk_objectid &&
2715 		    key.offset == chunk_offset) {
2716 			memmove(ptr, ptr + len, array_size - (cur + len));
2717 			array_size -= len;
2718 			btrfs_set_super_sys_array_size(super_copy, array_size);
2719 		} else {
2720 			ptr += len;
2721 			cur += len;
2722 		}
2723 	}
2724 	unlock_chunks(root);
2725 	return ret;
2726 }
2727 
btrfs_remove_chunk(struct btrfs_trans_handle * trans,struct btrfs_root * root,u64 chunk_offset)2728 int btrfs_remove_chunk(struct btrfs_trans_handle *trans,
2729 		       struct btrfs_root *root, u64 chunk_offset)
2730 {
2731 	struct extent_map_tree *em_tree;
2732 	struct extent_map *em;
2733 	struct btrfs_root *extent_root = root->fs_info->extent_root;
2734 	struct map_lookup *map;
2735 	u64 dev_extent_len = 0;
2736 	u64 chunk_objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
2737 	int i, ret = 0;
2738 
2739 	/* Just in case */
2740 	root = root->fs_info->chunk_root;
2741 	em_tree = &root->fs_info->mapping_tree.map_tree;
2742 
2743 	read_lock(&em_tree->lock);
2744 	em = lookup_extent_mapping(em_tree, chunk_offset, 1);
2745 	read_unlock(&em_tree->lock);
2746 
2747 	if (!em || em->start > chunk_offset ||
2748 	    em->start + em->len < chunk_offset) {
2749 		/*
2750 		 * This is a logic error, but we don't want to just rely on the
2751 		 * user having built with ASSERT enabled, so if ASSERT doens't
2752 		 * do anything we still error out.
2753 		 */
2754 		ASSERT(0);
2755 		if (em)
2756 			free_extent_map(em);
2757 		return -EINVAL;
2758 	}
2759 	map = (struct map_lookup *)em->bdev;
2760 	lock_chunks(root->fs_info->chunk_root);
2761 	check_system_chunk(trans, extent_root, map->type);
2762 	unlock_chunks(root->fs_info->chunk_root);
2763 
2764 	for (i = 0; i < map->num_stripes; i++) {
2765 		struct btrfs_device *device = map->stripes[i].dev;
2766 		ret = btrfs_free_dev_extent(trans, device,
2767 					    map->stripes[i].physical,
2768 					    &dev_extent_len);
2769 		if (ret) {
2770 			btrfs_abort_transaction(trans, root, ret);
2771 			goto out;
2772 		}
2773 
2774 		if (device->bytes_used > 0) {
2775 			lock_chunks(root);
2776 			btrfs_device_set_bytes_used(device,
2777 					device->bytes_used - dev_extent_len);
2778 			spin_lock(&root->fs_info->free_chunk_lock);
2779 			root->fs_info->free_chunk_space += dev_extent_len;
2780 			spin_unlock(&root->fs_info->free_chunk_lock);
2781 			btrfs_clear_space_info_full(root->fs_info);
2782 			unlock_chunks(root);
2783 		}
2784 
2785 		if (map->stripes[i].dev) {
2786 			ret = btrfs_update_device(trans, map->stripes[i].dev);
2787 			if (ret) {
2788 				btrfs_abort_transaction(trans, root, ret);
2789 				goto out;
2790 			}
2791 		}
2792 	}
2793 	ret = btrfs_free_chunk(trans, root, chunk_objectid, chunk_offset);
2794 	if (ret) {
2795 		btrfs_abort_transaction(trans, root, ret);
2796 		goto out;
2797 	}
2798 
2799 	trace_btrfs_chunk_free(root, map, chunk_offset, em->len);
2800 
2801 	if (map->type & BTRFS_BLOCK_GROUP_SYSTEM) {
2802 		ret = btrfs_del_sys_chunk(root, chunk_objectid, chunk_offset);
2803 		if (ret) {
2804 			btrfs_abort_transaction(trans, root, ret);
2805 			goto out;
2806 		}
2807 	}
2808 
2809 	ret = btrfs_remove_block_group(trans, extent_root, chunk_offset, em);
2810 	if (ret) {
2811 		btrfs_abort_transaction(trans, extent_root, ret);
2812 		goto out;
2813 	}
2814 
2815 out:
2816 	/* once for us */
2817 	free_extent_map(em);
2818 	return ret;
2819 }
2820 
btrfs_relocate_chunk(struct btrfs_root * root,u64 chunk_offset)2821 static int btrfs_relocate_chunk(struct btrfs_root *root, u64 chunk_offset)
2822 {
2823 	struct btrfs_root *extent_root;
2824 	struct btrfs_trans_handle *trans;
2825 	int ret;
2826 
2827 	root = root->fs_info->chunk_root;
2828 	extent_root = root->fs_info->extent_root;
2829 
2830 	/*
2831 	 * Prevent races with automatic removal of unused block groups.
2832 	 * After we relocate and before we remove the chunk with offset
2833 	 * chunk_offset, automatic removal of the block group can kick in,
2834 	 * resulting in a failure when calling btrfs_remove_chunk() below.
2835 	 *
2836 	 * Make sure to acquire this mutex before doing a tree search (dev
2837 	 * or chunk trees) to find chunks. Otherwise the cleaner kthread might
2838 	 * call btrfs_remove_chunk() (through btrfs_delete_unused_bgs()) after
2839 	 * we release the path used to search the chunk/dev tree and before
2840 	 * the current task acquires this mutex and calls us.
2841 	 */
2842 	ASSERT(mutex_is_locked(&root->fs_info->delete_unused_bgs_mutex));
2843 
2844 	ret = btrfs_can_relocate(extent_root, chunk_offset);
2845 	if (ret)
2846 		return -ENOSPC;
2847 
2848 	/* step one, relocate all the extents inside this chunk */
2849 	btrfs_scrub_pause(root);
2850 	ret = btrfs_relocate_block_group(extent_root, chunk_offset);
2851 	btrfs_scrub_continue(root);
2852 	if (ret)
2853 		return ret;
2854 
2855 	trans = btrfs_start_trans_remove_block_group(root->fs_info,
2856 						     chunk_offset);
2857 	if (IS_ERR(trans)) {
2858 		ret = PTR_ERR(trans);
2859 		btrfs_std_error(root->fs_info, ret, NULL);
2860 		return ret;
2861 	}
2862 
2863 	/*
2864 	 * step two, delete the device extents and the
2865 	 * chunk tree entries
2866 	 */
2867 	ret = btrfs_remove_chunk(trans, root, chunk_offset);
2868 	btrfs_end_transaction(trans, root);
2869 	return ret;
2870 }
2871 
btrfs_relocate_sys_chunks(struct btrfs_root * root)2872 static int btrfs_relocate_sys_chunks(struct btrfs_root *root)
2873 {
2874 	struct btrfs_root *chunk_root = root->fs_info->chunk_root;
2875 	struct btrfs_path *path;
2876 	struct extent_buffer *leaf;
2877 	struct btrfs_chunk *chunk;
2878 	struct btrfs_key key;
2879 	struct btrfs_key found_key;
2880 	u64 chunk_type;
2881 	bool retried = false;
2882 	int failed = 0;
2883 	int ret;
2884 
2885 	path = btrfs_alloc_path();
2886 	if (!path)
2887 		return -ENOMEM;
2888 
2889 again:
2890 	key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
2891 	key.offset = (u64)-1;
2892 	key.type = BTRFS_CHUNK_ITEM_KEY;
2893 
2894 	while (1) {
2895 		mutex_lock(&root->fs_info->delete_unused_bgs_mutex);
2896 		ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0);
2897 		if (ret < 0) {
2898 			mutex_unlock(&root->fs_info->delete_unused_bgs_mutex);
2899 			goto error;
2900 		}
2901 		BUG_ON(ret == 0); /* Corruption */
2902 
2903 		ret = btrfs_previous_item(chunk_root, path, key.objectid,
2904 					  key.type);
2905 		if (ret)
2906 			mutex_unlock(&root->fs_info->delete_unused_bgs_mutex);
2907 		if (ret < 0)
2908 			goto error;
2909 		if (ret > 0)
2910 			break;
2911 
2912 		leaf = path->nodes[0];
2913 		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
2914 
2915 		chunk = btrfs_item_ptr(leaf, path->slots[0],
2916 				       struct btrfs_chunk);
2917 		chunk_type = btrfs_chunk_type(leaf, chunk);
2918 		btrfs_release_path(path);
2919 
2920 		if (chunk_type & BTRFS_BLOCK_GROUP_SYSTEM) {
2921 			ret = btrfs_relocate_chunk(chunk_root,
2922 						   found_key.offset);
2923 			if (ret == -ENOSPC)
2924 				failed++;
2925 			else
2926 				BUG_ON(ret);
2927 		}
2928 		mutex_unlock(&root->fs_info->delete_unused_bgs_mutex);
2929 
2930 		if (found_key.offset == 0)
2931 			break;
2932 		key.offset = found_key.offset - 1;
2933 	}
2934 	ret = 0;
2935 	if (failed && !retried) {
2936 		failed = 0;
2937 		retried = true;
2938 		goto again;
2939 	} else if (WARN_ON(failed && retried)) {
2940 		ret = -ENOSPC;
2941 	}
2942 error:
2943 	btrfs_free_path(path);
2944 	return ret;
2945 }
2946 
insert_balance_item(struct btrfs_root * root,struct btrfs_balance_control * bctl)2947 static int insert_balance_item(struct btrfs_root *root,
2948 			       struct btrfs_balance_control *bctl)
2949 {
2950 	struct btrfs_trans_handle *trans;
2951 	struct btrfs_balance_item *item;
2952 	struct btrfs_disk_balance_args disk_bargs;
2953 	struct btrfs_path *path;
2954 	struct extent_buffer *leaf;
2955 	struct btrfs_key key;
2956 	int ret, err;
2957 
2958 	path = btrfs_alloc_path();
2959 	if (!path)
2960 		return -ENOMEM;
2961 
2962 	trans = btrfs_start_transaction(root, 0);
2963 	if (IS_ERR(trans)) {
2964 		btrfs_free_path(path);
2965 		return PTR_ERR(trans);
2966 	}
2967 
2968 	key.objectid = BTRFS_BALANCE_OBJECTID;
2969 	key.type = BTRFS_BALANCE_ITEM_KEY;
2970 	key.offset = 0;
2971 
2972 	ret = btrfs_insert_empty_item(trans, root, path, &key,
2973 				      sizeof(*item));
2974 	if (ret)
2975 		goto out;
2976 
2977 	leaf = path->nodes[0];
2978 	item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item);
2979 
2980 	memset_extent_buffer(leaf, 0, (unsigned long)item, sizeof(*item));
2981 
2982 	btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->data);
2983 	btrfs_set_balance_data(leaf, item, &disk_bargs);
2984 	btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->meta);
2985 	btrfs_set_balance_meta(leaf, item, &disk_bargs);
2986 	btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->sys);
2987 	btrfs_set_balance_sys(leaf, item, &disk_bargs);
2988 
2989 	btrfs_set_balance_flags(leaf, item, bctl->flags);
2990 
2991 	btrfs_mark_buffer_dirty(leaf);
2992 out:
2993 	btrfs_free_path(path);
2994 	err = btrfs_commit_transaction(trans, root);
2995 	if (err && !ret)
2996 		ret = err;
2997 	return ret;
2998 }
2999 
del_balance_item(struct btrfs_root * root)3000 static int del_balance_item(struct btrfs_root *root)
3001 {
3002 	struct btrfs_trans_handle *trans;
3003 	struct btrfs_path *path;
3004 	struct btrfs_key key;
3005 	int ret, err;
3006 
3007 	path = btrfs_alloc_path();
3008 	if (!path)
3009 		return -ENOMEM;
3010 
3011 	trans = btrfs_start_transaction(root, 0);
3012 	if (IS_ERR(trans)) {
3013 		btrfs_free_path(path);
3014 		return PTR_ERR(trans);
3015 	}
3016 
3017 	key.objectid = BTRFS_BALANCE_OBJECTID;
3018 	key.type = BTRFS_BALANCE_ITEM_KEY;
3019 	key.offset = 0;
3020 
3021 	ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
3022 	if (ret < 0)
3023 		goto out;
3024 	if (ret > 0) {
3025 		ret = -ENOENT;
3026 		goto out;
3027 	}
3028 
3029 	ret = btrfs_del_item(trans, root, path);
3030 out:
3031 	btrfs_free_path(path);
3032 	err = btrfs_commit_transaction(trans, root);
3033 	if (err && !ret)
3034 		ret = err;
3035 	return ret;
3036 }
3037 
3038 /*
3039  * This is a heuristic used to reduce the number of chunks balanced on
3040  * resume after balance was interrupted.
3041  */
update_balance_args(struct btrfs_balance_control * bctl)3042 static void update_balance_args(struct btrfs_balance_control *bctl)
3043 {
3044 	/*
3045 	 * Turn on soft mode for chunk types that were being converted.
3046 	 */
3047 	if (bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT)
3048 		bctl->data.flags |= BTRFS_BALANCE_ARGS_SOFT;
3049 	if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT)
3050 		bctl->sys.flags |= BTRFS_BALANCE_ARGS_SOFT;
3051 	if (bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT)
3052 		bctl->meta.flags |= BTRFS_BALANCE_ARGS_SOFT;
3053 
3054 	/*
3055 	 * Turn on usage filter if is not already used.  The idea is
3056 	 * that chunks that we have already balanced should be
3057 	 * reasonably full.  Don't do it for chunks that are being
3058 	 * converted - that will keep us from relocating unconverted
3059 	 * (albeit full) chunks.
3060 	 */
3061 	if (!(bctl->data.flags & BTRFS_BALANCE_ARGS_USAGE) &&
3062 	    !(bctl->data.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) &&
3063 	    !(bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT)) {
3064 		bctl->data.flags |= BTRFS_BALANCE_ARGS_USAGE;
3065 		bctl->data.usage = 90;
3066 	}
3067 	if (!(bctl->sys.flags & BTRFS_BALANCE_ARGS_USAGE) &&
3068 	    !(bctl->sys.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) &&
3069 	    !(bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT)) {
3070 		bctl->sys.flags |= BTRFS_BALANCE_ARGS_USAGE;
3071 		bctl->sys.usage = 90;
3072 	}
3073 	if (!(bctl->meta.flags & BTRFS_BALANCE_ARGS_USAGE) &&
3074 	    !(bctl->meta.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) &&
3075 	    !(bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT)) {
3076 		bctl->meta.flags |= BTRFS_BALANCE_ARGS_USAGE;
3077 		bctl->meta.usage = 90;
3078 	}
3079 }
3080 
3081 /*
3082  * Should be called with both balance and volume mutexes held to
3083  * serialize other volume operations (add_dev/rm_dev/resize) with
3084  * restriper.  Same goes for unset_balance_control.
3085  */
set_balance_control(struct btrfs_balance_control * bctl)3086 static void set_balance_control(struct btrfs_balance_control *bctl)
3087 {
3088 	struct btrfs_fs_info *fs_info = bctl->fs_info;
3089 
3090 	BUG_ON(fs_info->balance_ctl);
3091 
3092 	spin_lock(&fs_info->balance_lock);
3093 	fs_info->balance_ctl = bctl;
3094 	spin_unlock(&fs_info->balance_lock);
3095 }
3096 
unset_balance_control(struct btrfs_fs_info * fs_info)3097 static void unset_balance_control(struct btrfs_fs_info *fs_info)
3098 {
3099 	struct btrfs_balance_control *bctl = fs_info->balance_ctl;
3100 
3101 	BUG_ON(!fs_info->balance_ctl);
3102 
3103 	spin_lock(&fs_info->balance_lock);
3104 	fs_info->balance_ctl = NULL;
3105 	spin_unlock(&fs_info->balance_lock);
3106 
3107 	kfree(bctl);
3108 }
3109 
3110 /*
3111  * Balance filters.  Return 1 if chunk should be filtered out
3112  * (should not be balanced).
3113  */
chunk_profiles_filter(u64 chunk_type,struct btrfs_balance_args * bargs)3114 static int chunk_profiles_filter(u64 chunk_type,
3115 				 struct btrfs_balance_args *bargs)
3116 {
3117 	chunk_type = chunk_to_extended(chunk_type) &
3118 				BTRFS_EXTENDED_PROFILE_MASK;
3119 
3120 	if (bargs->profiles & chunk_type)
3121 		return 0;
3122 
3123 	return 1;
3124 }
3125 
chunk_usage_range_filter(struct btrfs_fs_info * fs_info,u64 chunk_offset,struct btrfs_balance_args * bargs)3126 static int chunk_usage_range_filter(struct btrfs_fs_info *fs_info, u64 chunk_offset,
3127 			      struct btrfs_balance_args *bargs)
3128 {
3129 	struct btrfs_block_group_cache *cache;
3130 	u64 chunk_used;
3131 	u64 user_thresh_min;
3132 	u64 user_thresh_max;
3133 	int ret = 1;
3134 
3135 	cache = btrfs_lookup_block_group(fs_info, chunk_offset);
3136 	chunk_used = btrfs_block_group_used(&cache->item);
3137 
3138 	if (bargs->usage_min == 0)
3139 		user_thresh_min = 0;
3140 	else
3141 		user_thresh_min = div_factor_fine(cache->key.offset,
3142 					bargs->usage_min);
3143 
3144 	if (bargs->usage_max == 0)
3145 		user_thresh_max = 1;
3146 	else if (bargs->usage_max > 100)
3147 		user_thresh_max = cache->key.offset;
3148 	else
3149 		user_thresh_max = div_factor_fine(cache->key.offset,
3150 					bargs->usage_max);
3151 
3152 	if (user_thresh_min <= chunk_used && chunk_used < user_thresh_max)
3153 		ret = 0;
3154 
3155 	btrfs_put_block_group(cache);
3156 	return ret;
3157 }
3158 
chunk_usage_filter(struct btrfs_fs_info * fs_info,u64 chunk_offset,struct btrfs_balance_args * bargs)3159 static int chunk_usage_filter(struct btrfs_fs_info *fs_info,
3160 		u64 chunk_offset, struct btrfs_balance_args *bargs)
3161 {
3162 	struct btrfs_block_group_cache *cache;
3163 	u64 chunk_used, user_thresh;
3164 	int ret = 1;
3165 
3166 	cache = btrfs_lookup_block_group(fs_info, chunk_offset);
3167 	chunk_used = btrfs_block_group_used(&cache->item);
3168 
3169 	if (bargs->usage_min == 0)
3170 		user_thresh = 1;
3171 	else if (bargs->usage > 100)
3172 		user_thresh = cache->key.offset;
3173 	else
3174 		user_thresh = div_factor_fine(cache->key.offset,
3175 					      bargs->usage);
3176 
3177 	if (chunk_used < user_thresh)
3178 		ret = 0;
3179 
3180 	btrfs_put_block_group(cache);
3181 	return ret;
3182 }
3183 
chunk_devid_filter(struct extent_buffer * leaf,struct btrfs_chunk * chunk,struct btrfs_balance_args * bargs)3184 static int chunk_devid_filter(struct extent_buffer *leaf,
3185 			      struct btrfs_chunk *chunk,
3186 			      struct btrfs_balance_args *bargs)
3187 {
3188 	struct btrfs_stripe *stripe;
3189 	int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
3190 	int i;
3191 
3192 	for (i = 0; i < num_stripes; i++) {
3193 		stripe = btrfs_stripe_nr(chunk, i);
3194 		if (btrfs_stripe_devid(leaf, stripe) == bargs->devid)
3195 			return 0;
3196 	}
3197 
3198 	return 1;
3199 }
3200 
3201 /* [pstart, pend) */
chunk_drange_filter(struct extent_buffer * leaf,struct btrfs_chunk * chunk,u64 chunk_offset,struct btrfs_balance_args * bargs)3202 static int chunk_drange_filter(struct extent_buffer *leaf,
3203 			       struct btrfs_chunk *chunk,
3204 			       u64 chunk_offset,
3205 			       struct btrfs_balance_args *bargs)
3206 {
3207 	struct btrfs_stripe *stripe;
3208 	int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
3209 	u64 stripe_offset;
3210 	u64 stripe_length;
3211 	int factor;
3212 	int i;
3213 
3214 	if (!(bargs->flags & BTRFS_BALANCE_ARGS_DEVID))
3215 		return 0;
3216 
3217 	if (btrfs_chunk_type(leaf, chunk) & (BTRFS_BLOCK_GROUP_DUP |
3218 	     BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID10)) {
3219 		factor = num_stripes / 2;
3220 	} else if (btrfs_chunk_type(leaf, chunk) & BTRFS_BLOCK_GROUP_RAID5) {
3221 		factor = num_stripes - 1;
3222 	} else if (btrfs_chunk_type(leaf, chunk) & BTRFS_BLOCK_GROUP_RAID6) {
3223 		factor = num_stripes - 2;
3224 	} else {
3225 		factor = num_stripes;
3226 	}
3227 
3228 	for (i = 0; i < num_stripes; i++) {
3229 		stripe = btrfs_stripe_nr(chunk, i);
3230 		if (btrfs_stripe_devid(leaf, stripe) != bargs->devid)
3231 			continue;
3232 
3233 		stripe_offset = btrfs_stripe_offset(leaf, stripe);
3234 		stripe_length = btrfs_chunk_length(leaf, chunk);
3235 		stripe_length = div_u64(stripe_length, factor);
3236 
3237 		if (stripe_offset < bargs->pend &&
3238 		    stripe_offset + stripe_length > bargs->pstart)
3239 			return 0;
3240 	}
3241 
3242 	return 1;
3243 }
3244 
3245 /* [vstart, vend) */
chunk_vrange_filter(struct extent_buffer * leaf,struct btrfs_chunk * chunk,u64 chunk_offset,struct btrfs_balance_args * bargs)3246 static int chunk_vrange_filter(struct extent_buffer *leaf,
3247 			       struct btrfs_chunk *chunk,
3248 			       u64 chunk_offset,
3249 			       struct btrfs_balance_args *bargs)
3250 {
3251 	if (chunk_offset < bargs->vend &&
3252 	    chunk_offset + btrfs_chunk_length(leaf, chunk) > bargs->vstart)
3253 		/* at least part of the chunk is inside this vrange */
3254 		return 0;
3255 
3256 	return 1;
3257 }
3258 
chunk_stripes_range_filter(struct extent_buffer * leaf,struct btrfs_chunk * chunk,struct btrfs_balance_args * bargs)3259 static int chunk_stripes_range_filter(struct extent_buffer *leaf,
3260 			       struct btrfs_chunk *chunk,
3261 			       struct btrfs_balance_args *bargs)
3262 {
3263 	int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
3264 
3265 	if (bargs->stripes_min <= num_stripes
3266 			&& num_stripes <= bargs->stripes_max)
3267 		return 0;
3268 
3269 	return 1;
3270 }
3271 
chunk_soft_convert_filter(u64 chunk_type,struct btrfs_balance_args * bargs)3272 static int chunk_soft_convert_filter(u64 chunk_type,
3273 				     struct btrfs_balance_args *bargs)
3274 {
3275 	if (!(bargs->flags & BTRFS_BALANCE_ARGS_CONVERT))
3276 		return 0;
3277 
3278 	chunk_type = chunk_to_extended(chunk_type) &
3279 				BTRFS_EXTENDED_PROFILE_MASK;
3280 
3281 	if (bargs->target == chunk_type)
3282 		return 1;
3283 
3284 	return 0;
3285 }
3286 
should_balance_chunk(struct btrfs_root * root,struct extent_buffer * leaf,struct btrfs_chunk * chunk,u64 chunk_offset)3287 static int should_balance_chunk(struct btrfs_root *root,
3288 				struct extent_buffer *leaf,
3289 				struct btrfs_chunk *chunk, u64 chunk_offset)
3290 {
3291 	struct btrfs_balance_control *bctl = root->fs_info->balance_ctl;
3292 	struct btrfs_balance_args *bargs = NULL;
3293 	u64 chunk_type = btrfs_chunk_type(leaf, chunk);
3294 
3295 	/* type filter */
3296 	if (!((chunk_type & BTRFS_BLOCK_GROUP_TYPE_MASK) &
3297 	      (bctl->flags & BTRFS_BALANCE_TYPE_MASK))) {
3298 		return 0;
3299 	}
3300 
3301 	if (chunk_type & BTRFS_BLOCK_GROUP_DATA)
3302 		bargs = &bctl->data;
3303 	else if (chunk_type & BTRFS_BLOCK_GROUP_SYSTEM)
3304 		bargs = &bctl->sys;
3305 	else if (chunk_type & BTRFS_BLOCK_GROUP_METADATA)
3306 		bargs = &bctl->meta;
3307 
3308 	/* profiles filter */
3309 	if ((bargs->flags & BTRFS_BALANCE_ARGS_PROFILES) &&
3310 	    chunk_profiles_filter(chunk_type, bargs)) {
3311 		return 0;
3312 	}
3313 
3314 	/* usage filter */
3315 	if ((bargs->flags & BTRFS_BALANCE_ARGS_USAGE) &&
3316 	    chunk_usage_filter(bctl->fs_info, chunk_offset, bargs)) {
3317 		return 0;
3318 	} else if ((bargs->flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) &&
3319 	    chunk_usage_range_filter(bctl->fs_info, chunk_offset, bargs)) {
3320 		return 0;
3321 	}
3322 
3323 	/* devid filter */
3324 	if ((bargs->flags & BTRFS_BALANCE_ARGS_DEVID) &&
3325 	    chunk_devid_filter(leaf, chunk, bargs)) {
3326 		return 0;
3327 	}
3328 
3329 	/* drange filter, makes sense only with devid filter */
3330 	if ((bargs->flags & BTRFS_BALANCE_ARGS_DRANGE) &&
3331 	    chunk_drange_filter(leaf, chunk, chunk_offset, bargs)) {
3332 		return 0;
3333 	}
3334 
3335 	/* vrange filter */
3336 	if ((bargs->flags & BTRFS_BALANCE_ARGS_VRANGE) &&
3337 	    chunk_vrange_filter(leaf, chunk, chunk_offset, bargs)) {
3338 		return 0;
3339 	}
3340 
3341 	/* stripes filter */
3342 	if ((bargs->flags & BTRFS_BALANCE_ARGS_STRIPES_RANGE) &&
3343 	    chunk_stripes_range_filter(leaf, chunk, bargs)) {
3344 		return 0;
3345 	}
3346 
3347 	/* soft profile changing mode */
3348 	if ((bargs->flags & BTRFS_BALANCE_ARGS_SOFT) &&
3349 	    chunk_soft_convert_filter(chunk_type, bargs)) {
3350 		return 0;
3351 	}
3352 
3353 	/*
3354 	 * limited by count, must be the last filter
3355 	 */
3356 	if ((bargs->flags & BTRFS_BALANCE_ARGS_LIMIT)) {
3357 		if (bargs->limit == 0)
3358 			return 0;
3359 		else
3360 			bargs->limit--;
3361 	} else if ((bargs->flags & BTRFS_BALANCE_ARGS_LIMIT_RANGE)) {
3362 		/*
3363 		 * Same logic as the 'limit' filter; the minimum cannot be
3364 		 * determined here because we do not have the global informatoin
3365 		 * about the count of all chunks that satisfy the filters.
3366 		 */
3367 		if (bargs->limit_max == 0)
3368 			return 0;
3369 		else
3370 			bargs->limit_max--;
3371 	}
3372 
3373 	return 1;
3374 }
3375 
__btrfs_balance(struct btrfs_fs_info * fs_info)3376 static int __btrfs_balance(struct btrfs_fs_info *fs_info)
3377 {
3378 	struct btrfs_balance_control *bctl = fs_info->balance_ctl;
3379 	struct btrfs_root *chunk_root = fs_info->chunk_root;
3380 	struct btrfs_root *dev_root = fs_info->dev_root;
3381 	struct list_head *devices;
3382 	struct btrfs_device *device;
3383 	u64 old_size;
3384 	u64 size_to_free;
3385 	u64 chunk_type;
3386 	struct btrfs_chunk *chunk;
3387 	struct btrfs_path *path;
3388 	struct btrfs_key key;
3389 	struct btrfs_key found_key;
3390 	struct btrfs_trans_handle *trans;
3391 	struct extent_buffer *leaf;
3392 	int slot;
3393 	int ret;
3394 	int enospc_errors = 0;
3395 	bool counting = true;
3396 	/* The single value limit and min/max limits use the same bytes in the */
3397 	u64 limit_data = bctl->data.limit;
3398 	u64 limit_meta = bctl->meta.limit;
3399 	u64 limit_sys = bctl->sys.limit;
3400 	u32 count_data = 0;
3401 	u32 count_meta = 0;
3402 	u32 count_sys = 0;
3403 	int chunk_reserved = 0;
3404 
3405 	/* step one make some room on all the devices */
3406 	devices = &fs_info->fs_devices->devices;
3407 	list_for_each_entry(device, devices, dev_list) {
3408 		old_size = btrfs_device_get_total_bytes(device);
3409 		size_to_free = div_factor(old_size, 1);
3410 		size_to_free = min(size_to_free, (u64)1 * 1024 * 1024);
3411 		if (!device->writeable ||
3412 		    btrfs_device_get_total_bytes(device) -
3413 		    btrfs_device_get_bytes_used(device) > size_to_free ||
3414 		    device->is_tgtdev_for_dev_replace)
3415 			continue;
3416 
3417 		ret = btrfs_shrink_device(device, old_size - size_to_free);
3418 		if (ret == -ENOSPC)
3419 			break;
3420 		BUG_ON(ret);
3421 
3422 		trans = btrfs_start_transaction(dev_root, 0);
3423 		BUG_ON(IS_ERR(trans));
3424 
3425 		ret = btrfs_grow_device(trans, device, old_size);
3426 		BUG_ON(ret);
3427 
3428 		btrfs_end_transaction(trans, dev_root);
3429 	}
3430 
3431 	/* step two, relocate all the chunks */
3432 	path = btrfs_alloc_path();
3433 	if (!path) {
3434 		ret = -ENOMEM;
3435 		goto error;
3436 	}
3437 
3438 	/* zero out stat counters */
3439 	spin_lock(&fs_info->balance_lock);
3440 	memset(&bctl->stat, 0, sizeof(bctl->stat));
3441 	spin_unlock(&fs_info->balance_lock);
3442 again:
3443 	if (!counting) {
3444 		/*
3445 		 * The single value limit and min/max limits use the same bytes
3446 		 * in the
3447 		 */
3448 		bctl->data.limit = limit_data;
3449 		bctl->meta.limit = limit_meta;
3450 		bctl->sys.limit = limit_sys;
3451 	}
3452 	key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
3453 	key.offset = (u64)-1;
3454 	key.type = BTRFS_CHUNK_ITEM_KEY;
3455 
3456 	while (1) {
3457 		if ((!counting && atomic_read(&fs_info->balance_pause_req)) ||
3458 		    atomic_read(&fs_info->balance_cancel_req)) {
3459 			ret = -ECANCELED;
3460 			goto error;
3461 		}
3462 
3463 		mutex_lock(&fs_info->delete_unused_bgs_mutex);
3464 		ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0);
3465 		if (ret < 0) {
3466 			mutex_unlock(&fs_info->delete_unused_bgs_mutex);
3467 			goto error;
3468 		}
3469 
3470 		/*
3471 		 * this shouldn't happen, it means the last relocate
3472 		 * failed
3473 		 */
3474 		if (ret == 0)
3475 			BUG(); /* FIXME break ? */
3476 
3477 		ret = btrfs_previous_item(chunk_root, path, 0,
3478 					  BTRFS_CHUNK_ITEM_KEY);
3479 		if (ret) {
3480 			mutex_unlock(&fs_info->delete_unused_bgs_mutex);
3481 			ret = 0;
3482 			break;
3483 		}
3484 
3485 		leaf = path->nodes[0];
3486 		slot = path->slots[0];
3487 		btrfs_item_key_to_cpu(leaf, &found_key, slot);
3488 
3489 		if (found_key.objectid != key.objectid) {
3490 			mutex_unlock(&fs_info->delete_unused_bgs_mutex);
3491 			break;
3492 		}
3493 
3494 		chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);
3495 		chunk_type = btrfs_chunk_type(leaf, chunk);
3496 
3497 		if (!counting) {
3498 			spin_lock(&fs_info->balance_lock);
3499 			bctl->stat.considered++;
3500 			spin_unlock(&fs_info->balance_lock);
3501 		}
3502 
3503 		ret = should_balance_chunk(chunk_root, leaf, chunk,
3504 					   found_key.offset);
3505 
3506 		btrfs_release_path(path);
3507 		if (!ret) {
3508 			mutex_unlock(&fs_info->delete_unused_bgs_mutex);
3509 			goto loop;
3510 		}
3511 
3512 		if (counting) {
3513 			mutex_unlock(&fs_info->delete_unused_bgs_mutex);
3514 			spin_lock(&fs_info->balance_lock);
3515 			bctl->stat.expected++;
3516 			spin_unlock(&fs_info->balance_lock);
3517 
3518 			if (chunk_type & BTRFS_BLOCK_GROUP_DATA)
3519 				count_data++;
3520 			else if (chunk_type & BTRFS_BLOCK_GROUP_SYSTEM)
3521 				count_sys++;
3522 			else if (chunk_type & BTRFS_BLOCK_GROUP_METADATA)
3523 				count_meta++;
3524 
3525 			goto loop;
3526 		}
3527 
3528 		/*
3529 		 * Apply limit_min filter, no need to check if the LIMITS
3530 		 * filter is used, limit_min is 0 by default
3531 		 */
3532 		if (((chunk_type & BTRFS_BLOCK_GROUP_DATA) &&
3533 					count_data < bctl->data.limit_min)
3534 				|| ((chunk_type & BTRFS_BLOCK_GROUP_METADATA) &&
3535 					count_meta < bctl->meta.limit_min)
3536 				|| ((chunk_type & BTRFS_BLOCK_GROUP_SYSTEM) &&
3537 					count_sys < bctl->sys.limit_min)) {
3538 			mutex_unlock(&fs_info->delete_unused_bgs_mutex);
3539 			goto loop;
3540 		}
3541 
3542 		if ((chunk_type & BTRFS_BLOCK_GROUP_DATA) && !chunk_reserved) {
3543 			trans = btrfs_start_transaction(chunk_root, 0);
3544 			if (IS_ERR(trans)) {
3545 				mutex_unlock(&fs_info->delete_unused_bgs_mutex);
3546 				ret = PTR_ERR(trans);
3547 				goto error;
3548 			}
3549 
3550 			ret = btrfs_force_chunk_alloc(trans, chunk_root,
3551 						      BTRFS_BLOCK_GROUP_DATA);
3552 			btrfs_end_transaction(trans, chunk_root);
3553 			if (ret < 0) {
3554 				mutex_unlock(&fs_info->delete_unused_bgs_mutex);
3555 				goto error;
3556 			}
3557 			chunk_reserved = 1;
3558 		}
3559 
3560 		ret = btrfs_relocate_chunk(chunk_root,
3561 					   found_key.offset);
3562 		mutex_unlock(&fs_info->delete_unused_bgs_mutex);
3563 		if (ret && ret != -ENOSPC)
3564 			goto error;
3565 		if (ret == -ENOSPC) {
3566 			enospc_errors++;
3567 		} else {
3568 			spin_lock(&fs_info->balance_lock);
3569 			bctl->stat.completed++;
3570 			spin_unlock(&fs_info->balance_lock);
3571 		}
3572 loop:
3573 		if (found_key.offset == 0)
3574 			break;
3575 		key.offset = found_key.offset - 1;
3576 	}
3577 
3578 	if (counting) {
3579 		btrfs_release_path(path);
3580 		counting = false;
3581 		goto again;
3582 	}
3583 error:
3584 	btrfs_free_path(path);
3585 	if (enospc_errors) {
3586 		btrfs_info(fs_info, "%d enospc errors during balance",
3587 		       enospc_errors);
3588 		if (!ret)
3589 			ret = -ENOSPC;
3590 	}
3591 
3592 	return ret;
3593 }
3594 
3595 /**
3596  * alloc_profile_is_valid - see if a given profile is valid and reduced
3597  * @flags: profile to validate
3598  * @extended: if true @flags is treated as an extended profile
3599  */
alloc_profile_is_valid(u64 flags,int extended)3600 static int alloc_profile_is_valid(u64 flags, int extended)
3601 {
3602 	u64 mask = (extended ? BTRFS_EXTENDED_PROFILE_MASK :
3603 			       BTRFS_BLOCK_GROUP_PROFILE_MASK);
3604 
3605 	flags &= ~BTRFS_BLOCK_GROUP_TYPE_MASK;
3606 
3607 	/* 1) check that all other bits are zeroed */
3608 	if (flags & ~mask)
3609 		return 0;
3610 
3611 	/* 2) see if profile is reduced */
3612 	if (flags == 0)
3613 		return !extended; /* "0" is valid for usual profiles */
3614 
3615 	/* true if exactly one bit set */
3616 	return (flags & (flags - 1)) == 0;
3617 }
3618 
balance_need_close(struct btrfs_fs_info * fs_info)3619 static inline int balance_need_close(struct btrfs_fs_info *fs_info)
3620 {
3621 	/* cancel requested || normal exit path */
3622 	return atomic_read(&fs_info->balance_cancel_req) ||
3623 		(atomic_read(&fs_info->balance_pause_req) == 0 &&
3624 		 atomic_read(&fs_info->balance_cancel_req) == 0);
3625 }
3626 
__cancel_balance(struct btrfs_fs_info * fs_info)3627 static void __cancel_balance(struct btrfs_fs_info *fs_info)
3628 {
3629 	int ret;
3630 
3631 	unset_balance_control(fs_info);
3632 	ret = del_balance_item(fs_info->tree_root);
3633 	if (ret)
3634 		btrfs_std_error(fs_info, ret, NULL);
3635 
3636 	atomic_set(&fs_info->mutually_exclusive_operation_running, 0);
3637 }
3638 
3639 /* Non-zero return value signifies invalidity */
validate_convert_profile(struct btrfs_balance_args * bctl_arg,u64 allowed)3640 static inline int validate_convert_profile(struct btrfs_balance_args *bctl_arg,
3641 		u64 allowed)
3642 {
3643 	return ((bctl_arg->flags & BTRFS_BALANCE_ARGS_CONVERT) &&
3644 		(!alloc_profile_is_valid(bctl_arg->target, 1) ||
3645 		 (bctl_arg->target & ~allowed)));
3646 }
3647 
3648 /*
3649  * Should be called with both balance and volume mutexes held
3650  */
btrfs_balance(struct btrfs_balance_control * bctl,struct btrfs_ioctl_balance_args * bargs)3651 int btrfs_balance(struct btrfs_balance_control *bctl,
3652 		  struct btrfs_ioctl_balance_args *bargs)
3653 {
3654 	struct btrfs_fs_info *fs_info = bctl->fs_info;
3655 	u64 allowed;
3656 	int mixed = 0;
3657 	int ret;
3658 	u64 num_devices;
3659 	unsigned seq;
3660 
3661 	if (btrfs_fs_closing(fs_info) ||
3662 	    atomic_read(&fs_info->balance_pause_req) ||
3663 	    atomic_read(&fs_info->balance_cancel_req)) {
3664 		ret = -EINVAL;
3665 		goto out;
3666 	}
3667 
3668 	allowed = btrfs_super_incompat_flags(fs_info->super_copy);
3669 	if (allowed & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS)
3670 		mixed = 1;
3671 
3672 	/*
3673 	 * In case of mixed groups both data and meta should be picked,
3674 	 * and identical options should be given for both of them.
3675 	 */
3676 	allowed = BTRFS_BALANCE_DATA | BTRFS_BALANCE_METADATA;
3677 	if (mixed && (bctl->flags & allowed)) {
3678 		if (!(bctl->flags & BTRFS_BALANCE_DATA) ||
3679 		    !(bctl->flags & BTRFS_BALANCE_METADATA) ||
3680 		    memcmp(&bctl->data, &bctl->meta, sizeof(bctl->data))) {
3681 			btrfs_err(fs_info, "with mixed groups data and "
3682 				   "metadata balance options must be the same");
3683 			ret = -EINVAL;
3684 			goto out;
3685 		}
3686 	}
3687 
3688 	num_devices = fs_info->fs_devices->num_devices;
3689 	btrfs_dev_replace_lock(&fs_info->dev_replace);
3690 	if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace)) {
3691 		BUG_ON(num_devices < 1);
3692 		num_devices--;
3693 	}
3694 	btrfs_dev_replace_unlock(&fs_info->dev_replace);
3695 	allowed = BTRFS_AVAIL_ALLOC_BIT_SINGLE;
3696 	if (num_devices == 1)
3697 		allowed |= BTRFS_BLOCK_GROUP_DUP;
3698 	else if (num_devices > 1)
3699 		allowed |= (BTRFS_BLOCK_GROUP_RAID0 | BTRFS_BLOCK_GROUP_RAID1);
3700 	if (num_devices > 2)
3701 		allowed |= BTRFS_BLOCK_GROUP_RAID5;
3702 	if (num_devices > 3)
3703 		allowed |= (BTRFS_BLOCK_GROUP_RAID10 |
3704 			    BTRFS_BLOCK_GROUP_RAID6);
3705 	if (validate_convert_profile(&bctl->data, allowed)) {
3706 		btrfs_err(fs_info, "unable to start balance with target "
3707 			   "data profile %llu",
3708 		       bctl->data.target);
3709 		ret = -EINVAL;
3710 		goto out;
3711 	}
3712 	if (validate_convert_profile(&bctl->meta, allowed)) {
3713 		btrfs_err(fs_info,
3714 			   "unable to start balance with target metadata profile %llu",
3715 		       bctl->meta.target);
3716 		ret = -EINVAL;
3717 		goto out;
3718 	}
3719 	if (validate_convert_profile(&bctl->sys, allowed)) {
3720 		btrfs_err(fs_info,
3721 			   "unable to start balance with target system profile %llu",
3722 		       bctl->sys.target);
3723 		ret = -EINVAL;
3724 		goto out;
3725 	}
3726 
3727 	/* allow dup'ed data chunks only in mixed mode */
3728 	if (!mixed && (bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
3729 	    (bctl->data.target & BTRFS_BLOCK_GROUP_DUP)) {
3730 		btrfs_err(fs_info, "dup for data is not allowed");
3731 		ret = -EINVAL;
3732 		goto out;
3733 	}
3734 
3735 	/* allow to reduce meta or sys integrity only if force set */
3736 	allowed = BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID1 |
3737 			BTRFS_BLOCK_GROUP_RAID10 |
3738 			BTRFS_BLOCK_GROUP_RAID5 |
3739 			BTRFS_BLOCK_GROUP_RAID6;
3740 	do {
3741 		seq = read_seqbegin(&fs_info->profiles_lock);
3742 
3743 		if (((bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
3744 		     (fs_info->avail_system_alloc_bits & allowed) &&
3745 		     !(bctl->sys.target & allowed)) ||
3746 		    ((bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
3747 		     (fs_info->avail_metadata_alloc_bits & allowed) &&
3748 		     !(bctl->meta.target & allowed))) {
3749 			if (bctl->flags & BTRFS_BALANCE_FORCE) {
3750 				btrfs_info(fs_info, "force reducing metadata integrity");
3751 			} else {
3752 				btrfs_err(fs_info, "balance will reduce metadata "
3753 					   "integrity, use force if you want this");
3754 				ret = -EINVAL;
3755 				goto out;
3756 			}
3757 		}
3758 	} while (read_seqretry(&fs_info->profiles_lock, seq));
3759 
3760 	if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) {
3761 		fs_info->num_tolerated_disk_barrier_failures = min(
3762 			btrfs_calc_num_tolerated_disk_barrier_failures(fs_info),
3763 			btrfs_get_num_tolerated_disk_barrier_failures(
3764 				bctl->sys.target));
3765 	}
3766 
3767 	ret = insert_balance_item(fs_info->tree_root, bctl);
3768 	if (ret && ret != -EEXIST)
3769 		goto out;
3770 
3771 	if (!(bctl->flags & BTRFS_BALANCE_RESUME)) {
3772 		BUG_ON(ret == -EEXIST);
3773 		set_balance_control(bctl);
3774 	} else {
3775 		BUG_ON(ret != -EEXIST);
3776 		spin_lock(&fs_info->balance_lock);
3777 		update_balance_args(bctl);
3778 		spin_unlock(&fs_info->balance_lock);
3779 	}
3780 
3781 	atomic_inc(&fs_info->balance_running);
3782 	mutex_unlock(&fs_info->balance_mutex);
3783 
3784 	ret = __btrfs_balance(fs_info);
3785 
3786 	mutex_lock(&fs_info->balance_mutex);
3787 	atomic_dec(&fs_info->balance_running);
3788 
3789 	if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) {
3790 		fs_info->num_tolerated_disk_barrier_failures =
3791 			btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
3792 	}
3793 
3794 	if (bargs) {
3795 		memset(bargs, 0, sizeof(*bargs));
3796 		update_ioctl_balance_args(fs_info, 0, bargs);
3797 	}
3798 
3799 	if ((ret && ret != -ECANCELED && ret != -ENOSPC) ||
3800 	    balance_need_close(fs_info)) {
3801 		__cancel_balance(fs_info);
3802 	}
3803 
3804 	wake_up(&fs_info->balance_wait_q);
3805 
3806 	return ret;
3807 out:
3808 	if (bctl->flags & BTRFS_BALANCE_RESUME)
3809 		__cancel_balance(fs_info);
3810 	else {
3811 		kfree(bctl);
3812 		atomic_set(&fs_info->mutually_exclusive_operation_running, 0);
3813 	}
3814 	return ret;
3815 }
3816 
balance_kthread(void * data)3817 static int balance_kthread(void *data)
3818 {
3819 	struct btrfs_fs_info *fs_info = data;
3820 	int ret = 0;
3821 
3822 	mutex_lock(&fs_info->volume_mutex);
3823 	mutex_lock(&fs_info->balance_mutex);
3824 
3825 	if (fs_info->balance_ctl) {
3826 		btrfs_info(fs_info, "continuing balance");
3827 		ret = btrfs_balance(fs_info->balance_ctl, NULL);
3828 	}
3829 
3830 	mutex_unlock(&fs_info->balance_mutex);
3831 	mutex_unlock(&fs_info->volume_mutex);
3832 
3833 	return ret;
3834 }
3835 
btrfs_resume_balance_async(struct btrfs_fs_info * fs_info)3836 int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info)
3837 {
3838 	struct task_struct *tsk;
3839 
3840 	spin_lock(&fs_info->balance_lock);
3841 	if (!fs_info->balance_ctl) {
3842 		spin_unlock(&fs_info->balance_lock);
3843 		return 0;
3844 	}
3845 	spin_unlock(&fs_info->balance_lock);
3846 
3847 	if (btrfs_test_opt(fs_info->tree_root, SKIP_BALANCE)) {
3848 		btrfs_info(fs_info, "force skipping balance");
3849 		return 0;
3850 	}
3851 
3852 	tsk = kthread_run(balance_kthread, fs_info, "btrfs-balance");
3853 	return PTR_ERR_OR_ZERO(tsk);
3854 }
3855 
btrfs_recover_balance(struct btrfs_fs_info * fs_info)3856 int btrfs_recover_balance(struct btrfs_fs_info *fs_info)
3857 {
3858 	struct btrfs_balance_control *bctl;
3859 	struct btrfs_balance_item *item;
3860 	struct btrfs_disk_balance_args disk_bargs;
3861 	struct btrfs_path *path;
3862 	struct extent_buffer *leaf;
3863 	struct btrfs_key key;
3864 	int ret;
3865 
3866 	path = btrfs_alloc_path();
3867 	if (!path)
3868 		return -ENOMEM;
3869 
3870 	key.objectid = BTRFS_BALANCE_OBJECTID;
3871 	key.type = BTRFS_BALANCE_ITEM_KEY;
3872 	key.offset = 0;
3873 
3874 	ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);
3875 	if (ret < 0)
3876 		goto out;
3877 	if (ret > 0) { /* ret = -ENOENT; */
3878 		ret = 0;
3879 		goto out;
3880 	}
3881 
3882 	bctl = kzalloc(sizeof(*bctl), GFP_NOFS);
3883 	if (!bctl) {
3884 		ret = -ENOMEM;
3885 		goto out;
3886 	}
3887 
3888 	leaf = path->nodes[0];
3889 	item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item);
3890 
3891 	bctl->fs_info = fs_info;
3892 	bctl->flags = btrfs_balance_flags(leaf, item);
3893 	bctl->flags |= BTRFS_BALANCE_RESUME;
3894 
3895 	btrfs_balance_data(leaf, item, &disk_bargs);
3896 	btrfs_disk_balance_args_to_cpu(&bctl->data, &disk_bargs);
3897 	btrfs_balance_meta(leaf, item, &disk_bargs);
3898 	btrfs_disk_balance_args_to_cpu(&bctl->meta, &disk_bargs);
3899 	btrfs_balance_sys(leaf, item, &disk_bargs);
3900 	btrfs_disk_balance_args_to_cpu(&bctl->sys, &disk_bargs);
3901 
3902 	WARN_ON(atomic_xchg(&fs_info->mutually_exclusive_operation_running, 1));
3903 
3904 	mutex_lock(&fs_info->volume_mutex);
3905 	mutex_lock(&fs_info->balance_mutex);
3906 
3907 	set_balance_control(bctl);
3908 
3909 	mutex_unlock(&fs_info->balance_mutex);
3910 	mutex_unlock(&fs_info->volume_mutex);
3911 out:
3912 	btrfs_free_path(path);
3913 	return ret;
3914 }
3915 
btrfs_pause_balance(struct btrfs_fs_info * fs_info)3916 int btrfs_pause_balance(struct btrfs_fs_info *fs_info)
3917 {
3918 	int ret = 0;
3919 
3920 	mutex_lock(&fs_info->balance_mutex);
3921 	if (!fs_info->balance_ctl) {
3922 		mutex_unlock(&fs_info->balance_mutex);
3923 		return -ENOTCONN;
3924 	}
3925 
3926 	if (atomic_read(&fs_info->balance_running)) {
3927 		atomic_inc(&fs_info->balance_pause_req);
3928 		mutex_unlock(&fs_info->balance_mutex);
3929 
3930 		wait_event(fs_info->balance_wait_q,
3931 			   atomic_read(&fs_info->balance_running) == 0);
3932 
3933 		mutex_lock(&fs_info->balance_mutex);
3934 		/* we are good with balance_ctl ripped off from under us */
3935 		BUG_ON(atomic_read(&fs_info->balance_running));
3936 		atomic_dec(&fs_info->balance_pause_req);
3937 	} else {
3938 		ret = -ENOTCONN;
3939 	}
3940 
3941 	mutex_unlock(&fs_info->balance_mutex);
3942 	return ret;
3943 }
3944 
btrfs_cancel_balance(struct btrfs_fs_info * fs_info)3945 int btrfs_cancel_balance(struct btrfs_fs_info *fs_info)
3946 {
3947 	if (fs_info->sb->s_flags & MS_RDONLY)
3948 		return -EROFS;
3949 
3950 	mutex_lock(&fs_info->balance_mutex);
3951 	if (!fs_info->balance_ctl) {
3952 		mutex_unlock(&fs_info->balance_mutex);
3953 		return -ENOTCONN;
3954 	}
3955 
3956 	atomic_inc(&fs_info->balance_cancel_req);
3957 	/*
3958 	 * if we are running just wait and return, balance item is
3959 	 * deleted in btrfs_balance in this case
3960 	 */
3961 	if (atomic_read(&fs_info->balance_running)) {
3962 		mutex_unlock(&fs_info->balance_mutex);
3963 		wait_event(fs_info->balance_wait_q,
3964 			   atomic_read(&fs_info->balance_running) == 0);
3965 		mutex_lock(&fs_info->balance_mutex);
3966 	} else {
3967 		/* __cancel_balance needs volume_mutex */
3968 		mutex_unlock(&fs_info->balance_mutex);
3969 		mutex_lock(&fs_info->volume_mutex);
3970 		mutex_lock(&fs_info->balance_mutex);
3971 
3972 		if (fs_info->balance_ctl)
3973 			__cancel_balance(fs_info);
3974 
3975 		mutex_unlock(&fs_info->volume_mutex);
3976 	}
3977 
3978 	BUG_ON(fs_info->balance_ctl || atomic_read(&fs_info->balance_running));
3979 	atomic_dec(&fs_info->balance_cancel_req);
3980 	mutex_unlock(&fs_info->balance_mutex);
3981 	return 0;
3982 }
3983 
btrfs_uuid_scan_kthread(void * data)3984 static int btrfs_uuid_scan_kthread(void *data)
3985 {
3986 	struct btrfs_fs_info *fs_info = data;
3987 	struct btrfs_root *root = fs_info->tree_root;
3988 	struct btrfs_key key;
3989 	struct btrfs_key max_key;
3990 	struct btrfs_path *path = NULL;
3991 	int ret = 0;
3992 	struct extent_buffer *eb;
3993 	int slot;
3994 	struct btrfs_root_item root_item;
3995 	u32 item_size;
3996 	struct btrfs_trans_handle *trans = NULL;
3997 
3998 	path = btrfs_alloc_path();
3999 	if (!path) {
4000 		ret = -ENOMEM;
4001 		goto out;
4002 	}
4003 
4004 	key.objectid = 0;
4005 	key.type = BTRFS_ROOT_ITEM_KEY;
4006 	key.offset = 0;
4007 
4008 	max_key.objectid = (u64)-1;
4009 	max_key.type = BTRFS_ROOT_ITEM_KEY;
4010 	max_key.offset = (u64)-1;
4011 
4012 	while (1) {
4013 		ret = btrfs_search_forward(root, &key, path, 0);
4014 		if (ret) {
4015 			if (ret > 0)
4016 				ret = 0;
4017 			break;
4018 		}
4019 
4020 		if (key.type != BTRFS_ROOT_ITEM_KEY ||
4021 		    (key.objectid < BTRFS_FIRST_FREE_OBJECTID &&
4022 		     key.objectid != BTRFS_FS_TREE_OBJECTID) ||
4023 		    key.objectid > BTRFS_LAST_FREE_OBJECTID)
4024 			goto skip;
4025 
4026 		eb = path->nodes[0];
4027 		slot = path->slots[0];
4028 		item_size = btrfs_item_size_nr(eb, slot);
4029 		if (item_size < sizeof(root_item))
4030 			goto skip;
4031 
4032 		read_extent_buffer(eb, &root_item,
4033 				   btrfs_item_ptr_offset(eb, slot),
4034 				   (int)sizeof(root_item));
4035 		if (btrfs_root_refs(&root_item) == 0)
4036 			goto skip;
4037 
4038 		if (!btrfs_is_empty_uuid(root_item.uuid) ||
4039 		    !btrfs_is_empty_uuid(root_item.received_uuid)) {
4040 			if (trans)
4041 				goto update_tree;
4042 
4043 			btrfs_release_path(path);
4044 			/*
4045 			 * 1 - subvol uuid item
4046 			 * 1 - received_subvol uuid item
4047 			 */
4048 			trans = btrfs_start_transaction(fs_info->uuid_root, 2);
4049 			if (IS_ERR(trans)) {
4050 				ret = PTR_ERR(trans);
4051 				break;
4052 			}
4053 			continue;
4054 		} else {
4055 			goto skip;
4056 		}
4057 update_tree:
4058 		if (!btrfs_is_empty_uuid(root_item.uuid)) {
4059 			ret = btrfs_uuid_tree_add(trans, fs_info->uuid_root,
4060 						  root_item.uuid,
4061 						  BTRFS_UUID_KEY_SUBVOL,
4062 						  key.objectid);
4063 			if (ret < 0) {
4064 				btrfs_warn(fs_info, "uuid_tree_add failed %d",
4065 					ret);
4066 				break;
4067 			}
4068 		}
4069 
4070 		if (!btrfs_is_empty_uuid(root_item.received_uuid)) {
4071 			ret = btrfs_uuid_tree_add(trans, fs_info->uuid_root,
4072 						  root_item.received_uuid,
4073 						 BTRFS_UUID_KEY_RECEIVED_SUBVOL,
4074 						  key.objectid);
4075 			if (ret < 0) {
4076 				btrfs_warn(fs_info, "uuid_tree_add failed %d",
4077 					ret);
4078 				break;
4079 			}
4080 		}
4081 
4082 skip:
4083 		if (trans) {
4084 			ret = btrfs_end_transaction(trans, fs_info->uuid_root);
4085 			trans = NULL;
4086 			if (ret)
4087 				break;
4088 		}
4089 
4090 		btrfs_release_path(path);
4091 		if (key.offset < (u64)-1) {
4092 			key.offset++;
4093 		} else if (key.type < BTRFS_ROOT_ITEM_KEY) {
4094 			key.offset = 0;
4095 			key.type = BTRFS_ROOT_ITEM_KEY;
4096 		} else if (key.objectid < (u64)-1) {
4097 			key.offset = 0;
4098 			key.type = BTRFS_ROOT_ITEM_KEY;
4099 			key.objectid++;
4100 		} else {
4101 			break;
4102 		}
4103 		cond_resched();
4104 	}
4105 
4106 out:
4107 	btrfs_free_path(path);
4108 	if (trans && !IS_ERR(trans))
4109 		btrfs_end_transaction(trans, fs_info->uuid_root);
4110 	if (ret)
4111 		btrfs_warn(fs_info, "btrfs_uuid_scan_kthread failed %d", ret);
4112 	else
4113 		fs_info->update_uuid_tree_gen = 1;
4114 	up(&fs_info->uuid_tree_rescan_sem);
4115 	return 0;
4116 }
4117 
4118 /*
4119  * Callback for btrfs_uuid_tree_iterate().
4120  * returns:
4121  * 0	check succeeded, the entry is not outdated.
4122  * < 0	if an error occured.
4123  * > 0	if the check failed, which means the caller shall remove the entry.
4124  */
btrfs_check_uuid_tree_entry(struct btrfs_fs_info * fs_info,u8 * uuid,u8 type,u64 subid)4125 static int btrfs_check_uuid_tree_entry(struct btrfs_fs_info *fs_info,
4126 				       u8 *uuid, u8 type, u64 subid)
4127 {
4128 	struct btrfs_key key;
4129 	int ret = 0;
4130 	struct btrfs_root *subvol_root;
4131 
4132 	if (type != BTRFS_UUID_KEY_SUBVOL &&
4133 	    type != BTRFS_UUID_KEY_RECEIVED_SUBVOL)
4134 		goto out;
4135 
4136 	key.objectid = subid;
4137 	key.type = BTRFS_ROOT_ITEM_KEY;
4138 	key.offset = (u64)-1;
4139 	subvol_root = btrfs_read_fs_root_no_name(fs_info, &key);
4140 	if (IS_ERR(subvol_root)) {
4141 		ret = PTR_ERR(subvol_root);
4142 		if (ret == -ENOENT)
4143 			ret = 1;
4144 		goto out;
4145 	}
4146 
4147 	switch (type) {
4148 	case BTRFS_UUID_KEY_SUBVOL:
4149 		if (memcmp(uuid, subvol_root->root_item.uuid, BTRFS_UUID_SIZE))
4150 			ret = 1;
4151 		break;
4152 	case BTRFS_UUID_KEY_RECEIVED_SUBVOL:
4153 		if (memcmp(uuid, subvol_root->root_item.received_uuid,
4154 			   BTRFS_UUID_SIZE))
4155 			ret = 1;
4156 		break;
4157 	}
4158 
4159 out:
4160 	return ret;
4161 }
4162 
btrfs_uuid_rescan_kthread(void * data)4163 static int btrfs_uuid_rescan_kthread(void *data)
4164 {
4165 	struct btrfs_fs_info *fs_info = (struct btrfs_fs_info *)data;
4166 	int ret;
4167 
4168 	/*
4169 	 * 1st step is to iterate through the existing UUID tree and
4170 	 * to delete all entries that contain outdated data.
4171 	 * 2nd step is to add all missing entries to the UUID tree.
4172 	 */
4173 	ret = btrfs_uuid_tree_iterate(fs_info, btrfs_check_uuid_tree_entry);
4174 	if (ret < 0) {
4175 		btrfs_warn(fs_info, "iterating uuid_tree failed %d", ret);
4176 		up(&fs_info->uuid_tree_rescan_sem);
4177 		return ret;
4178 	}
4179 	return btrfs_uuid_scan_kthread(data);
4180 }
4181 
btrfs_create_uuid_tree(struct btrfs_fs_info * fs_info)4182 int btrfs_create_uuid_tree(struct btrfs_fs_info *fs_info)
4183 {
4184 	struct btrfs_trans_handle *trans;
4185 	struct btrfs_root *tree_root = fs_info->tree_root;
4186 	struct btrfs_root *uuid_root;
4187 	struct task_struct *task;
4188 	int ret;
4189 
4190 	/*
4191 	 * 1 - root node
4192 	 * 1 - root item
4193 	 */
4194 	trans = btrfs_start_transaction(tree_root, 2);
4195 	if (IS_ERR(trans))
4196 		return PTR_ERR(trans);
4197 
4198 	uuid_root = btrfs_create_tree(trans, fs_info,
4199 				      BTRFS_UUID_TREE_OBJECTID);
4200 	if (IS_ERR(uuid_root)) {
4201 		ret = PTR_ERR(uuid_root);
4202 		btrfs_abort_transaction(trans, tree_root, ret);
4203 		return ret;
4204 	}
4205 
4206 	fs_info->uuid_root = uuid_root;
4207 
4208 	ret = btrfs_commit_transaction(trans, tree_root);
4209 	if (ret)
4210 		return ret;
4211 
4212 	down(&fs_info->uuid_tree_rescan_sem);
4213 	task = kthread_run(btrfs_uuid_scan_kthread, fs_info, "btrfs-uuid");
4214 	if (IS_ERR(task)) {
4215 		/* fs_info->update_uuid_tree_gen remains 0 in all error case */
4216 		btrfs_warn(fs_info, "failed to start uuid_scan task");
4217 		up(&fs_info->uuid_tree_rescan_sem);
4218 		return PTR_ERR(task);
4219 	}
4220 
4221 	return 0;
4222 }
4223 
btrfs_check_uuid_tree(struct btrfs_fs_info * fs_info)4224 int btrfs_check_uuid_tree(struct btrfs_fs_info *fs_info)
4225 {
4226 	struct task_struct *task;
4227 
4228 	down(&fs_info->uuid_tree_rescan_sem);
4229 	task = kthread_run(btrfs_uuid_rescan_kthread, fs_info, "btrfs-uuid");
4230 	if (IS_ERR(task)) {
4231 		/* fs_info->update_uuid_tree_gen remains 0 in all error case */
4232 		btrfs_warn(fs_info, "failed to start uuid_rescan task");
4233 		up(&fs_info->uuid_tree_rescan_sem);
4234 		return PTR_ERR(task);
4235 	}
4236 
4237 	return 0;
4238 }
4239 
4240 /*
4241  * shrinking a device means finding all of the device extents past
4242  * the new size, and then following the back refs to the chunks.
4243  * The chunk relocation code actually frees the device extent
4244  */
btrfs_shrink_device(struct btrfs_device * device,u64 new_size)4245 int btrfs_shrink_device(struct btrfs_device *device, u64 new_size)
4246 {
4247 	struct btrfs_trans_handle *trans;
4248 	struct btrfs_root *root = device->dev_root;
4249 	struct btrfs_dev_extent *dev_extent = NULL;
4250 	struct btrfs_path *path;
4251 	u64 length;
4252 	u64 chunk_offset;
4253 	int ret;
4254 	int slot;
4255 	int failed = 0;
4256 	bool retried = false;
4257 	bool checked_pending_chunks = false;
4258 	struct extent_buffer *l;
4259 	struct btrfs_key key;
4260 	struct btrfs_super_block *super_copy = root->fs_info->super_copy;
4261 	u64 old_total = btrfs_super_total_bytes(super_copy);
4262 	u64 old_size = btrfs_device_get_total_bytes(device);
4263 	u64 diff = old_size - new_size;
4264 
4265 	if (device->is_tgtdev_for_dev_replace)
4266 		return -EINVAL;
4267 
4268 	path = btrfs_alloc_path();
4269 	if (!path)
4270 		return -ENOMEM;
4271 
4272 	path->reada = 2;
4273 
4274 	lock_chunks(root);
4275 
4276 	btrfs_device_set_total_bytes(device, new_size);
4277 	if (device->writeable) {
4278 		device->fs_devices->total_rw_bytes -= diff;
4279 		spin_lock(&root->fs_info->free_chunk_lock);
4280 		root->fs_info->free_chunk_space -= diff;
4281 		spin_unlock(&root->fs_info->free_chunk_lock);
4282 	}
4283 	unlock_chunks(root);
4284 
4285 again:
4286 	key.objectid = device->devid;
4287 	key.offset = (u64)-1;
4288 	key.type = BTRFS_DEV_EXTENT_KEY;
4289 
4290 	do {
4291 		mutex_lock(&root->fs_info->delete_unused_bgs_mutex);
4292 		ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4293 		if (ret < 0) {
4294 			mutex_unlock(&root->fs_info->delete_unused_bgs_mutex);
4295 			goto done;
4296 		}
4297 
4298 		ret = btrfs_previous_item(root, path, 0, key.type);
4299 		if (ret)
4300 			mutex_unlock(&root->fs_info->delete_unused_bgs_mutex);
4301 		if (ret < 0)
4302 			goto done;
4303 		if (ret) {
4304 			ret = 0;
4305 			btrfs_release_path(path);
4306 			break;
4307 		}
4308 
4309 		l = path->nodes[0];
4310 		slot = path->slots[0];
4311 		btrfs_item_key_to_cpu(l, &key, path->slots[0]);
4312 
4313 		if (key.objectid != device->devid) {
4314 			mutex_unlock(&root->fs_info->delete_unused_bgs_mutex);
4315 			btrfs_release_path(path);
4316 			break;
4317 		}
4318 
4319 		dev_extent = btrfs_item_ptr(l, slot, struct btrfs_dev_extent);
4320 		length = btrfs_dev_extent_length(l, dev_extent);
4321 
4322 		if (key.offset + length <= new_size) {
4323 			mutex_unlock(&root->fs_info->delete_unused_bgs_mutex);
4324 			btrfs_release_path(path);
4325 			break;
4326 		}
4327 
4328 		chunk_offset = btrfs_dev_extent_chunk_offset(l, dev_extent);
4329 		btrfs_release_path(path);
4330 
4331 		ret = btrfs_relocate_chunk(root, chunk_offset);
4332 		mutex_unlock(&root->fs_info->delete_unused_bgs_mutex);
4333 		if (ret && ret != -ENOSPC)
4334 			goto done;
4335 		if (ret == -ENOSPC)
4336 			failed++;
4337 	} while (key.offset-- > 0);
4338 
4339 	if (failed && !retried) {
4340 		failed = 0;
4341 		retried = true;
4342 		goto again;
4343 	} else if (failed && retried) {
4344 		ret = -ENOSPC;
4345 		goto done;
4346 	}
4347 
4348 	/* Shrinking succeeded, else we would be at "done". */
4349 	trans = btrfs_start_transaction(root, 0);
4350 	if (IS_ERR(trans)) {
4351 		ret = PTR_ERR(trans);
4352 		goto done;
4353 	}
4354 
4355 	lock_chunks(root);
4356 
4357 	/*
4358 	 * We checked in the above loop all device extents that were already in
4359 	 * the device tree. However before we have updated the device's
4360 	 * total_bytes to the new size, we might have had chunk allocations that
4361 	 * have not complete yet (new block groups attached to transaction
4362 	 * handles), and therefore their device extents were not yet in the
4363 	 * device tree and we missed them in the loop above. So if we have any
4364 	 * pending chunk using a device extent that overlaps the device range
4365 	 * that we can not use anymore, commit the current transaction and
4366 	 * repeat the search on the device tree - this way we guarantee we will
4367 	 * not have chunks using device extents that end beyond 'new_size'.
4368 	 */
4369 	if (!checked_pending_chunks) {
4370 		u64 start = new_size;
4371 		u64 len = old_size - new_size;
4372 
4373 		if (contains_pending_extent(trans->transaction, device,
4374 					    &start, len)) {
4375 			unlock_chunks(root);
4376 			checked_pending_chunks = true;
4377 			failed = 0;
4378 			retried = false;
4379 			ret = btrfs_commit_transaction(trans, root);
4380 			if (ret)
4381 				goto done;
4382 			goto again;
4383 		}
4384 	}
4385 
4386 	btrfs_device_set_disk_total_bytes(device, new_size);
4387 	if (list_empty(&device->resized_list))
4388 		list_add_tail(&device->resized_list,
4389 			      &root->fs_info->fs_devices->resized_devices);
4390 
4391 	WARN_ON(diff > old_total);
4392 	btrfs_set_super_total_bytes(super_copy, old_total - diff);
4393 	unlock_chunks(root);
4394 
4395 	/* Now btrfs_update_device() will change the on-disk size. */
4396 	ret = btrfs_update_device(trans, device);
4397 	btrfs_end_transaction(trans, root);
4398 done:
4399 	btrfs_free_path(path);
4400 	if (ret) {
4401 		lock_chunks(root);
4402 		btrfs_device_set_total_bytes(device, old_size);
4403 		if (device->writeable)
4404 			device->fs_devices->total_rw_bytes += diff;
4405 		spin_lock(&root->fs_info->free_chunk_lock);
4406 		root->fs_info->free_chunk_space += diff;
4407 		spin_unlock(&root->fs_info->free_chunk_lock);
4408 		unlock_chunks(root);
4409 	}
4410 	return ret;
4411 }
4412 
btrfs_add_system_chunk(struct btrfs_root * root,struct btrfs_key * key,struct btrfs_chunk * chunk,int item_size)4413 static int btrfs_add_system_chunk(struct btrfs_root *root,
4414 			   struct btrfs_key *key,
4415 			   struct btrfs_chunk *chunk, int item_size)
4416 {
4417 	struct btrfs_super_block *super_copy = root->fs_info->super_copy;
4418 	struct btrfs_disk_key disk_key;
4419 	u32 array_size;
4420 	u8 *ptr;
4421 
4422 	lock_chunks(root);
4423 	array_size = btrfs_super_sys_array_size(super_copy);
4424 	if (array_size + item_size + sizeof(disk_key)
4425 			> BTRFS_SYSTEM_CHUNK_ARRAY_SIZE) {
4426 		unlock_chunks(root);
4427 		return -EFBIG;
4428 	}
4429 
4430 	ptr = super_copy->sys_chunk_array + array_size;
4431 	btrfs_cpu_key_to_disk(&disk_key, key);
4432 	memcpy(ptr, &disk_key, sizeof(disk_key));
4433 	ptr += sizeof(disk_key);
4434 	memcpy(ptr, chunk, item_size);
4435 	item_size += sizeof(disk_key);
4436 	btrfs_set_super_sys_array_size(super_copy, array_size + item_size);
4437 	unlock_chunks(root);
4438 
4439 	return 0;
4440 }
4441 
4442 /*
4443  * sort the devices in descending order by max_avail, total_avail
4444  */
btrfs_cmp_device_info(const void * a,const void * b)4445 static int btrfs_cmp_device_info(const void *a, const void *b)
4446 {
4447 	const struct btrfs_device_info *di_a = a;
4448 	const struct btrfs_device_info *di_b = b;
4449 
4450 	if (di_a->max_avail > di_b->max_avail)
4451 		return -1;
4452 	if (di_a->max_avail < di_b->max_avail)
4453 		return 1;
4454 	if (di_a->total_avail > di_b->total_avail)
4455 		return -1;
4456 	if (di_a->total_avail < di_b->total_avail)
4457 		return 1;
4458 	return 0;
4459 }
4460 
find_raid56_stripe_len(u32 data_devices,u32 dev_stripe_target)4461 static u32 find_raid56_stripe_len(u32 data_devices, u32 dev_stripe_target)
4462 {
4463 	/* TODO allow them to set a preferred stripe size */
4464 	return 64 * 1024;
4465 }
4466 
check_raid56_incompat_flag(struct btrfs_fs_info * info,u64 type)4467 static void check_raid56_incompat_flag(struct btrfs_fs_info *info, u64 type)
4468 {
4469 	if (!(type & BTRFS_BLOCK_GROUP_RAID56_MASK))
4470 		return;
4471 
4472 	btrfs_set_fs_incompat(info, RAID56);
4473 }
4474 
4475 #define BTRFS_MAX_DEVS(r) ((BTRFS_LEAF_DATA_SIZE(r)		\
4476 			- sizeof(struct btrfs_item)		\
4477 			- sizeof(struct btrfs_chunk))		\
4478 			/ sizeof(struct btrfs_stripe) + 1)
4479 
4480 #define BTRFS_MAX_DEVS_SYS_CHUNK ((BTRFS_SYSTEM_CHUNK_ARRAY_SIZE	\
4481 				- 2 * sizeof(struct btrfs_disk_key)	\
4482 				- 2 * sizeof(struct btrfs_chunk))	\
4483 				/ sizeof(struct btrfs_stripe) + 1)
4484 
__btrfs_alloc_chunk(struct btrfs_trans_handle * trans,struct btrfs_root * extent_root,u64 start,u64 type)4485 static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
4486 			       struct btrfs_root *extent_root, u64 start,
4487 			       u64 type)
4488 {
4489 	struct btrfs_fs_info *info = extent_root->fs_info;
4490 	struct btrfs_fs_devices *fs_devices = info->fs_devices;
4491 	struct list_head *cur;
4492 	struct map_lookup *map = NULL;
4493 	struct extent_map_tree *em_tree;
4494 	struct extent_map *em;
4495 	struct btrfs_device_info *devices_info = NULL;
4496 	u64 total_avail;
4497 	int num_stripes;	/* total number of stripes to allocate */
4498 	int data_stripes;	/* number of stripes that count for
4499 				   block group size */
4500 	int sub_stripes;	/* sub_stripes info for map */
4501 	int dev_stripes;	/* stripes per dev */
4502 	int devs_max;		/* max devs to use */
4503 	int devs_min;		/* min devs needed */
4504 	int devs_increment;	/* ndevs has to be a multiple of this */
4505 	int ncopies;		/* how many copies to data has */
4506 	int ret;
4507 	u64 max_stripe_size;
4508 	u64 max_chunk_size;
4509 	u64 stripe_size;
4510 	u64 num_bytes;
4511 	u64 raid_stripe_len = BTRFS_STRIPE_LEN;
4512 	int ndevs;
4513 	int i;
4514 	int j;
4515 	int index;
4516 
4517 	BUG_ON(!alloc_profile_is_valid(type, 0));
4518 
4519 	if (list_empty(&fs_devices->alloc_list))
4520 		return -ENOSPC;
4521 
4522 	index = __get_raid_index(type);
4523 
4524 	sub_stripes = btrfs_raid_array[index].sub_stripes;
4525 	dev_stripes = btrfs_raid_array[index].dev_stripes;
4526 	devs_max = btrfs_raid_array[index].devs_max;
4527 	devs_min = btrfs_raid_array[index].devs_min;
4528 	devs_increment = btrfs_raid_array[index].devs_increment;
4529 	ncopies = btrfs_raid_array[index].ncopies;
4530 
4531 	if (type & BTRFS_BLOCK_GROUP_DATA) {
4532 		max_stripe_size = 1024 * 1024 * 1024;
4533 		max_chunk_size = 10 * max_stripe_size;
4534 		if (!devs_max)
4535 			devs_max = BTRFS_MAX_DEVS(info->chunk_root);
4536 	} else if (type & BTRFS_BLOCK_GROUP_METADATA) {
4537 		/* for larger filesystems, use larger metadata chunks */
4538 		if (fs_devices->total_rw_bytes > 50ULL * 1024 * 1024 * 1024)
4539 			max_stripe_size = 1024 * 1024 * 1024;
4540 		else
4541 			max_stripe_size = 256 * 1024 * 1024;
4542 		max_chunk_size = max_stripe_size;
4543 		if (!devs_max)
4544 			devs_max = BTRFS_MAX_DEVS(info->chunk_root);
4545 	} else if (type & BTRFS_BLOCK_GROUP_SYSTEM) {
4546 		max_stripe_size = 32 * 1024 * 1024;
4547 		max_chunk_size = 2 * max_stripe_size;
4548 		if (!devs_max)
4549 			devs_max = BTRFS_MAX_DEVS_SYS_CHUNK;
4550 	} else {
4551 		btrfs_err(info, "invalid chunk type 0x%llx requested",
4552 		       type);
4553 		BUG_ON(1);
4554 	}
4555 
4556 	/* we don't want a chunk larger than 10% of writeable space */
4557 	max_chunk_size = min(div_factor(fs_devices->total_rw_bytes, 1),
4558 			     max_chunk_size);
4559 
4560 	devices_info = kcalloc(fs_devices->rw_devices, sizeof(*devices_info),
4561 			       GFP_NOFS);
4562 	if (!devices_info)
4563 		return -ENOMEM;
4564 
4565 	cur = fs_devices->alloc_list.next;
4566 
4567 	/*
4568 	 * in the first pass through the devices list, we gather information
4569 	 * about the available holes on each device.
4570 	 */
4571 	ndevs = 0;
4572 	while (cur != &fs_devices->alloc_list) {
4573 		struct btrfs_device *device;
4574 		u64 max_avail;
4575 		u64 dev_offset;
4576 
4577 		device = list_entry(cur, struct btrfs_device, dev_alloc_list);
4578 
4579 		cur = cur->next;
4580 
4581 		if (!device->writeable) {
4582 			WARN(1, KERN_ERR
4583 			       "BTRFS: read-only device in alloc_list\n");
4584 			continue;
4585 		}
4586 
4587 		if (!device->in_fs_metadata ||
4588 		    device->is_tgtdev_for_dev_replace)
4589 			continue;
4590 
4591 		if (device->total_bytes > device->bytes_used)
4592 			total_avail = device->total_bytes - device->bytes_used;
4593 		else
4594 			total_avail = 0;
4595 
4596 		/* If there is no space on this device, skip it. */
4597 		if (total_avail == 0)
4598 			continue;
4599 
4600 		ret = find_free_dev_extent(trans, device,
4601 					   max_stripe_size * dev_stripes,
4602 					   &dev_offset, &max_avail);
4603 		if (ret && ret != -ENOSPC)
4604 			goto error;
4605 
4606 		if (ret == 0)
4607 			max_avail = max_stripe_size * dev_stripes;
4608 
4609 		if (max_avail < BTRFS_STRIPE_LEN * dev_stripes)
4610 			continue;
4611 
4612 		if (ndevs == fs_devices->rw_devices) {
4613 			WARN(1, "%s: found more than %llu devices\n",
4614 			     __func__, fs_devices->rw_devices);
4615 			break;
4616 		}
4617 		devices_info[ndevs].dev_offset = dev_offset;
4618 		devices_info[ndevs].max_avail = max_avail;
4619 		devices_info[ndevs].total_avail = total_avail;
4620 		devices_info[ndevs].dev = device;
4621 		++ndevs;
4622 	}
4623 
4624 	/*
4625 	 * now sort the devices by hole size / available space
4626 	 */
4627 	sort(devices_info, ndevs, sizeof(struct btrfs_device_info),
4628 	     btrfs_cmp_device_info, NULL);
4629 
4630 	/* round down to number of usable stripes */
4631 	ndevs -= ndevs % devs_increment;
4632 
4633 	if (ndevs < devs_increment * sub_stripes || ndevs < devs_min) {
4634 		ret = -ENOSPC;
4635 		goto error;
4636 	}
4637 
4638 	if (devs_max && ndevs > devs_max)
4639 		ndevs = devs_max;
4640 	/*
4641 	 * the primary goal is to maximize the number of stripes, so use as many
4642 	 * devices as possible, even if the stripes are not maximum sized.
4643 	 */
4644 	stripe_size = devices_info[ndevs-1].max_avail;
4645 	num_stripes = ndevs * dev_stripes;
4646 
4647 	/*
4648 	 * this will have to be fixed for RAID1 and RAID10 over
4649 	 * more drives
4650 	 */
4651 	data_stripes = num_stripes / ncopies;
4652 
4653 	if (type & BTRFS_BLOCK_GROUP_RAID5) {
4654 		raid_stripe_len = find_raid56_stripe_len(ndevs - 1,
4655 				 btrfs_super_stripesize(info->super_copy));
4656 		data_stripes = num_stripes - 1;
4657 	}
4658 	if (type & BTRFS_BLOCK_GROUP_RAID6) {
4659 		raid_stripe_len = find_raid56_stripe_len(ndevs - 2,
4660 				 btrfs_super_stripesize(info->super_copy));
4661 		data_stripes = num_stripes - 2;
4662 	}
4663 
4664 	/*
4665 	 * Use the number of data stripes to figure out how big this chunk
4666 	 * is really going to be in terms of logical address space,
4667 	 * and compare that answer with the max chunk size
4668 	 */
4669 	if (stripe_size * data_stripes > max_chunk_size) {
4670 		u64 mask = (1ULL << 24) - 1;
4671 
4672 		stripe_size = div_u64(max_chunk_size, data_stripes);
4673 
4674 		/* bump the answer up to a 16MB boundary */
4675 		stripe_size = (stripe_size + mask) & ~mask;
4676 
4677 		/* but don't go higher than the limits we found
4678 		 * while searching for free extents
4679 		 */
4680 		if (stripe_size > devices_info[ndevs-1].max_avail)
4681 			stripe_size = devices_info[ndevs-1].max_avail;
4682 	}
4683 
4684 	stripe_size = div_u64(stripe_size, dev_stripes);
4685 
4686 	/* align to BTRFS_STRIPE_LEN */
4687 	stripe_size = div_u64(stripe_size, raid_stripe_len);
4688 	stripe_size *= raid_stripe_len;
4689 
4690 	map = kmalloc(map_lookup_size(num_stripes), GFP_NOFS);
4691 	if (!map) {
4692 		ret = -ENOMEM;
4693 		goto error;
4694 	}
4695 	map->num_stripes = num_stripes;
4696 
4697 	for (i = 0; i < ndevs; ++i) {
4698 		for (j = 0; j < dev_stripes; ++j) {
4699 			int s = i * dev_stripes + j;
4700 			map->stripes[s].dev = devices_info[i].dev;
4701 			map->stripes[s].physical = devices_info[i].dev_offset +
4702 						   j * stripe_size;
4703 		}
4704 	}
4705 	map->sector_size = extent_root->sectorsize;
4706 	map->stripe_len = raid_stripe_len;
4707 	map->io_align = raid_stripe_len;
4708 	map->io_width = raid_stripe_len;
4709 	map->type = type;
4710 	map->sub_stripes = sub_stripes;
4711 
4712 	num_bytes = stripe_size * data_stripes;
4713 
4714 	trace_btrfs_chunk_alloc(info->chunk_root, map, start, num_bytes);
4715 
4716 	em = alloc_extent_map();
4717 	if (!em) {
4718 		kfree(map);
4719 		ret = -ENOMEM;
4720 		goto error;
4721 	}
4722 	set_bit(EXTENT_FLAG_FS_MAPPING, &em->flags);
4723 	em->bdev = (struct block_device *)map;
4724 	em->start = start;
4725 	em->len = num_bytes;
4726 	em->block_start = 0;
4727 	em->block_len = em->len;
4728 	em->orig_block_len = stripe_size;
4729 
4730 	em_tree = &extent_root->fs_info->mapping_tree.map_tree;
4731 	write_lock(&em_tree->lock);
4732 	ret = add_extent_mapping(em_tree, em, 0);
4733 	if (!ret) {
4734 		list_add_tail(&em->list, &trans->transaction->pending_chunks);
4735 		atomic_inc(&em->refs);
4736 	}
4737 	write_unlock(&em_tree->lock);
4738 	if (ret) {
4739 		free_extent_map(em);
4740 		goto error;
4741 	}
4742 
4743 	ret = btrfs_make_block_group(trans, extent_root, 0, type,
4744 				     BTRFS_FIRST_CHUNK_TREE_OBJECTID,
4745 				     start, num_bytes);
4746 	if (ret)
4747 		goto error_del_extent;
4748 
4749 	for (i = 0; i < map->num_stripes; i++) {
4750 		num_bytes = map->stripes[i].dev->bytes_used + stripe_size;
4751 		btrfs_device_set_bytes_used(map->stripes[i].dev, num_bytes);
4752 	}
4753 
4754 	spin_lock(&extent_root->fs_info->free_chunk_lock);
4755 	extent_root->fs_info->free_chunk_space -= (stripe_size *
4756 						   map->num_stripes);
4757 	spin_unlock(&extent_root->fs_info->free_chunk_lock);
4758 
4759 	free_extent_map(em);
4760 	check_raid56_incompat_flag(extent_root->fs_info, type);
4761 
4762 	kfree(devices_info);
4763 	return 0;
4764 
4765 error_del_extent:
4766 	write_lock(&em_tree->lock);
4767 	remove_extent_mapping(em_tree, em);
4768 	write_unlock(&em_tree->lock);
4769 
4770 	/* One for our allocation */
4771 	free_extent_map(em);
4772 	/* One for the tree reference */
4773 	free_extent_map(em);
4774 	/* One for the pending_chunks list reference */
4775 	free_extent_map(em);
4776 error:
4777 	kfree(devices_info);
4778 	return ret;
4779 }
4780 
btrfs_finish_chunk_alloc(struct btrfs_trans_handle * trans,struct btrfs_root * extent_root,u64 chunk_offset,u64 chunk_size)4781 int btrfs_finish_chunk_alloc(struct btrfs_trans_handle *trans,
4782 				struct btrfs_root *extent_root,
4783 				u64 chunk_offset, u64 chunk_size)
4784 {
4785 	struct btrfs_key key;
4786 	struct btrfs_root *chunk_root = extent_root->fs_info->chunk_root;
4787 	struct btrfs_device *device;
4788 	struct btrfs_chunk *chunk;
4789 	struct btrfs_stripe *stripe;
4790 	struct extent_map_tree *em_tree;
4791 	struct extent_map *em;
4792 	struct map_lookup *map;
4793 	size_t item_size;
4794 	u64 dev_offset;
4795 	u64 stripe_size;
4796 	int i = 0;
4797 	int ret;
4798 
4799 	em_tree = &extent_root->fs_info->mapping_tree.map_tree;
4800 	read_lock(&em_tree->lock);
4801 	em = lookup_extent_mapping(em_tree, chunk_offset, chunk_size);
4802 	read_unlock(&em_tree->lock);
4803 
4804 	if (!em) {
4805 		btrfs_crit(extent_root->fs_info, "unable to find logical "
4806 			   "%Lu len %Lu", chunk_offset, chunk_size);
4807 		return -EINVAL;
4808 	}
4809 
4810 	if (em->start != chunk_offset || em->len != chunk_size) {
4811 		btrfs_crit(extent_root->fs_info, "found a bad mapping, wanted"
4812 			  " %Lu-%Lu, found %Lu-%Lu", chunk_offset,
4813 			  chunk_size, em->start, em->len);
4814 		free_extent_map(em);
4815 		return -EINVAL;
4816 	}
4817 
4818 	map = (struct map_lookup *)em->bdev;
4819 	item_size = btrfs_chunk_item_size(map->num_stripes);
4820 	stripe_size = em->orig_block_len;
4821 
4822 	chunk = kzalloc(item_size, GFP_NOFS);
4823 	if (!chunk) {
4824 		ret = -ENOMEM;
4825 		goto out;
4826 	}
4827 
4828 	for (i = 0; i < map->num_stripes; i++) {
4829 		device = map->stripes[i].dev;
4830 		dev_offset = map->stripes[i].physical;
4831 
4832 		ret = btrfs_update_device(trans, device);
4833 		if (ret)
4834 			goto out;
4835 		ret = btrfs_alloc_dev_extent(trans, device,
4836 					     chunk_root->root_key.objectid,
4837 					     BTRFS_FIRST_CHUNK_TREE_OBJECTID,
4838 					     chunk_offset, dev_offset,
4839 					     stripe_size);
4840 		if (ret)
4841 			goto out;
4842 	}
4843 
4844 	stripe = &chunk->stripe;
4845 	for (i = 0; i < map->num_stripes; i++) {
4846 		device = map->stripes[i].dev;
4847 		dev_offset = map->stripes[i].physical;
4848 
4849 		btrfs_set_stack_stripe_devid(stripe, device->devid);
4850 		btrfs_set_stack_stripe_offset(stripe, dev_offset);
4851 		memcpy(stripe->dev_uuid, device->uuid, BTRFS_UUID_SIZE);
4852 		stripe++;
4853 	}
4854 
4855 	btrfs_set_stack_chunk_length(chunk, chunk_size);
4856 	btrfs_set_stack_chunk_owner(chunk, extent_root->root_key.objectid);
4857 	btrfs_set_stack_chunk_stripe_len(chunk, map->stripe_len);
4858 	btrfs_set_stack_chunk_type(chunk, map->type);
4859 	btrfs_set_stack_chunk_num_stripes(chunk, map->num_stripes);
4860 	btrfs_set_stack_chunk_io_align(chunk, map->stripe_len);
4861 	btrfs_set_stack_chunk_io_width(chunk, map->stripe_len);
4862 	btrfs_set_stack_chunk_sector_size(chunk, extent_root->sectorsize);
4863 	btrfs_set_stack_chunk_sub_stripes(chunk, map->sub_stripes);
4864 
4865 	key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
4866 	key.type = BTRFS_CHUNK_ITEM_KEY;
4867 	key.offset = chunk_offset;
4868 
4869 	ret = btrfs_insert_item(trans, chunk_root, &key, chunk, item_size);
4870 	if (ret == 0 && map->type & BTRFS_BLOCK_GROUP_SYSTEM) {
4871 		/*
4872 		 * TODO: Cleanup of inserted chunk root in case of
4873 		 * failure.
4874 		 */
4875 		ret = btrfs_add_system_chunk(chunk_root, &key, chunk,
4876 					     item_size);
4877 	}
4878 
4879 out:
4880 	kfree(chunk);
4881 	free_extent_map(em);
4882 	return ret;
4883 }
4884 
4885 /*
4886  * Chunk allocation falls into two parts. The first part does works
4887  * that make the new allocated chunk useable, but not do any operation
4888  * that modifies the chunk tree. The second part does the works that
4889  * require modifying the chunk tree. This division is important for the
4890  * bootstrap process of adding storage to a seed btrfs.
4891  */
btrfs_alloc_chunk(struct btrfs_trans_handle * trans,struct btrfs_root * extent_root,u64 type)4892 int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
4893 		      struct btrfs_root *extent_root, u64 type)
4894 {
4895 	u64 chunk_offset;
4896 
4897 	ASSERT(mutex_is_locked(&extent_root->fs_info->chunk_mutex));
4898 	chunk_offset = find_next_chunk(extent_root->fs_info);
4899 	return __btrfs_alloc_chunk(trans, extent_root, chunk_offset, type);
4900 }
4901 
init_first_rw_device(struct btrfs_trans_handle * trans,struct btrfs_root * root,struct btrfs_device * device)4902 static noinline int init_first_rw_device(struct btrfs_trans_handle *trans,
4903 					 struct btrfs_root *root,
4904 					 struct btrfs_device *device)
4905 {
4906 	u64 chunk_offset;
4907 	u64 sys_chunk_offset;
4908 	u64 alloc_profile;
4909 	struct btrfs_fs_info *fs_info = root->fs_info;
4910 	struct btrfs_root *extent_root = fs_info->extent_root;
4911 	int ret;
4912 
4913 	chunk_offset = find_next_chunk(fs_info);
4914 	alloc_profile = btrfs_get_alloc_profile(extent_root, 0);
4915 	ret = __btrfs_alloc_chunk(trans, extent_root, chunk_offset,
4916 				  alloc_profile);
4917 	if (ret)
4918 		return ret;
4919 
4920 	sys_chunk_offset = find_next_chunk(root->fs_info);
4921 	alloc_profile = btrfs_get_alloc_profile(fs_info->chunk_root, 0);
4922 	ret = __btrfs_alloc_chunk(trans, extent_root, sys_chunk_offset,
4923 				  alloc_profile);
4924 	return ret;
4925 }
4926 
btrfs_chunk_max_errors(struct map_lookup * map)4927 static inline int btrfs_chunk_max_errors(struct map_lookup *map)
4928 {
4929 	int max_errors;
4930 
4931 	if (map->type & (BTRFS_BLOCK_GROUP_RAID1 |
4932 			 BTRFS_BLOCK_GROUP_RAID10 |
4933 			 BTRFS_BLOCK_GROUP_RAID5 |
4934 			 BTRFS_BLOCK_GROUP_DUP)) {
4935 		max_errors = 1;
4936 	} else if (map->type & BTRFS_BLOCK_GROUP_RAID6) {
4937 		max_errors = 2;
4938 	} else {
4939 		max_errors = 0;
4940 	}
4941 
4942 	return max_errors;
4943 }
4944 
btrfs_chunk_readonly(struct btrfs_root * root,u64 chunk_offset)4945 int btrfs_chunk_readonly(struct btrfs_root *root, u64 chunk_offset)
4946 {
4947 	struct extent_map *em;
4948 	struct map_lookup *map;
4949 	struct btrfs_mapping_tree *map_tree = &root->fs_info->mapping_tree;
4950 	int readonly = 0;
4951 	int miss_ndevs = 0;
4952 	int i;
4953 
4954 	read_lock(&map_tree->map_tree.lock);
4955 	em = lookup_extent_mapping(&map_tree->map_tree, chunk_offset, 1);
4956 	read_unlock(&map_tree->map_tree.lock);
4957 	if (!em)
4958 		return 1;
4959 
4960 	map = (struct map_lookup *)em->bdev;
4961 	for (i = 0; i < map->num_stripes; i++) {
4962 		if (map->stripes[i].dev->missing) {
4963 			miss_ndevs++;
4964 			continue;
4965 		}
4966 
4967 		if (!map->stripes[i].dev->writeable) {
4968 			readonly = 1;
4969 			goto end;
4970 		}
4971 	}
4972 
4973 	/*
4974 	 * If the number of missing devices is larger than max errors,
4975 	 * we can not write the data into that chunk successfully, so
4976 	 * set it readonly.
4977 	 */
4978 	if (miss_ndevs > btrfs_chunk_max_errors(map))
4979 		readonly = 1;
4980 end:
4981 	free_extent_map(em);
4982 	return readonly;
4983 }
4984 
btrfs_mapping_init(struct btrfs_mapping_tree * tree)4985 void btrfs_mapping_init(struct btrfs_mapping_tree *tree)
4986 {
4987 	extent_map_tree_init(&tree->map_tree);
4988 }
4989 
btrfs_mapping_tree_free(struct btrfs_mapping_tree * tree)4990 void btrfs_mapping_tree_free(struct btrfs_mapping_tree *tree)
4991 {
4992 	struct extent_map *em;
4993 
4994 	while (1) {
4995 		write_lock(&tree->map_tree.lock);
4996 		em = lookup_extent_mapping(&tree->map_tree, 0, (u64)-1);
4997 		if (em)
4998 			remove_extent_mapping(&tree->map_tree, em);
4999 		write_unlock(&tree->map_tree.lock);
5000 		if (!em)
5001 			break;
5002 		/* once for us */
5003 		free_extent_map(em);
5004 		/* once for the tree */
5005 		free_extent_map(em);
5006 	}
5007 }
5008 
btrfs_num_copies(struct btrfs_fs_info * fs_info,u64 logical,u64 len)5009 int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len)
5010 {
5011 	struct btrfs_mapping_tree *map_tree = &fs_info->mapping_tree;
5012 	struct extent_map *em;
5013 	struct map_lookup *map;
5014 	struct extent_map_tree *em_tree = &map_tree->map_tree;
5015 	int ret;
5016 
5017 	read_lock(&em_tree->lock);
5018 	em = lookup_extent_mapping(em_tree, logical, len);
5019 	read_unlock(&em_tree->lock);
5020 
5021 	/*
5022 	 * We could return errors for these cases, but that could get ugly and
5023 	 * we'd probably do the same thing which is just not do anything else
5024 	 * and exit, so return 1 so the callers don't try to use other copies.
5025 	 */
5026 	if (!em) {
5027 		btrfs_crit(fs_info, "No mapping for %Lu-%Lu", logical,
5028 			    logical+len);
5029 		return 1;
5030 	}
5031 
5032 	if (em->start > logical || em->start + em->len < logical) {
5033 		btrfs_crit(fs_info, "Invalid mapping for %Lu-%Lu, got "
5034 			    "%Lu-%Lu", logical, logical+len, em->start,
5035 			    em->start + em->len);
5036 		free_extent_map(em);
5037 		return 1;
5038 	}
5039 
5040 	map = (struct map_lookup *)em->bdev;
5041 	if (map->type & (BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID1))
5042 		ret = map->num_stripes;
5043 	else if (map->type & BTRFS_BLOCK_GROUP_RAID10)
5044 		ret = map->sub_stripes;
5045 	else if (map->type & BTRFS_BLOCK_GROUP_RAID5)
5046 		ret = 2;
5047 	else if (map->type & BTRFS_BLOCK_GROUP_RAID6)
5048 		ret = 3;
5049 	else
5050 		ret = 1;
5051 	free_extent_map(em);
5052 
5053 	btrfs_dev_replace_lock(&fs_info->dev_replace);
5054 	if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace))
5055 		ret++;
5056 	btrfs_dev_replace_unlock(&fs_info->dev_replace);
5057 
5058 	return ret;
5059 }
5060 
btrfs_full_stripe_len(struct btrfs_root * root,struct btrfs_mapping_tree * map_tree,u64 logical)5061 unsigned long btrfs_full_stripe_len(struct btrfs_root *root,
5062 				    struct btrfs_mapping_tree *map_tree,
5063 				    u64 logical)
5064 {
5065 	struct extent_map *em;
5066 	struct map_lookup *map;
5067 	struct extent_map_tree *em_tree = &map_tree->map_tree;
5068 	unsigned long len = root->sectorsize;
5069 
5070 	read_lock(&em_tree->lock);
5071 	em = lookup_extent_mapping(em_tree, logical, len);
5072 	read_unlock(&em_tree->lock);
5073 	BUG_ON(!em);
5074 
5075 	BUG_ON(em->start > logical || em->start + em->len < logical);
5076 	map = (struct map_lookup *)em->bdev;
5077 	if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK)
5078 		len = map->stripe_len * nr_data_stripes(map);
5079 	free_extent_map(em);
5080 	return len;
5081 }
5082 
btrfs_is_parity_mirror(struct btrfs_mapping_tree * map_tree,u64 logical,u64 len,int mirror_num)5083 int btrfs_is_parity_mirror(struct btrfs_mapping_tree *map_tree,
5084 			   u64 logical, u64 len, int mirror_num)
5085 {
5086 	struct extent_map *em;
5087 	struct map_lookup *map;
5088 	struct extent_map_tree *em_tree = &map_tree->map_tree;
5089 	int ret = 0;
5090 
5091 	read_lock(&em_tree->lock);
5092 	em = lookup_extent_mapping(em_tree, logical, len);
5093 	read_unlock(&em_tree->lock);
5094 	BUG_ON(!em);
5095 
5096 	BUG_ON(em->start > logical || em->start + em->len < logical);
5097 	map = (struct map_lookup *)em->bdev;
5098 	if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK)
5099 		ret = 1;
5100 	free_extent_map(em);
5101 	return ret;
5102 }
5103 
find_live_mirror(struct btrfs_fs_info * fs_info,struct map_lookup * map,int first,int num,int optimal,int dev_replace_is_ongoing)5104 static int find_live_mirror(struct btrfs_fs_info *fs_info,
5105 			    struct map_lookup *map, int first, int num,
5106 			    int optimal, int dev_replace_is_ongoing)
5107 {
5108 	int i;
5109 	int tolerance;
5110 	struct btrfs_device *srcdev;
5111 
5112 	if (dev_replace_is_ongoing &&
5113 	    fs_info->dev_replace.cont_reading_from_srcdev_mode ==
5114 	     BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_AVOID)
5115 		srcdev = fs_info->dev_replace.srcdev;
5116 	else
5117 		srcdev = NULL;
5118 
5119 	/*
5120 	 * try to avoid the drive that is the source drive for a
5121 	 * dev-replace procedure, only choose it if no other non-missing
5122 	 * mirror is available
5123 	 */
5124 	for (tolerance = 0; tolerance < 2; tolerance++) {
5125 		if (map->stripes[optimal].dev->bdev &&
5126 		    (tolerance || map->stripes[optimal].dev != srcdev))
5127 			return optimal;
5128 		for (i = first; i < first + num; i++) {
5129 			if (map->stripes[i].dev->bdev &&
5130 			    (tolerance || map->stripes[i].dev != srcdev))
5131 				return i;
5132 		}
5133 	}
5134 
5135 	/* we couldn't find one that doesn't fail.  Just return something
5136 	 * and the io error handling code will clean up eventually
5137 	 */
5138 	return optimal;
5139 }
5140 
parity_smaller(u64 a,u64 b)5141 static inline int parity_smaller(u64 a, u64 b)
5142 {
5143 	return a > b;
5144 }
5145 
5146 /* Bubble-sort the stripe set to put the parity/syndrome stripes last */
sort_parity_stripes(struct btrfs_bio * bbio,int num_stripes)5147 static void sort_parity_stripes(struct btrfs_bio *bbio, int num_stripes)
5148 {
5149 	struct btrfs_bio_stripe s;
5150 	int i;
5151 	u64 l;
5152 	int again = 1;
5153 
5154 	while (again) {
5155 		again = 0;
5156 		for (i = 0; i < num_stripes - 1; i++) {
5157 			if (parity_smaller(bbio->raid_map[i],
5158 					   bbio->raid_map[i+1])) {
5159 				s = bbio->stripes[i];
5160 				l = bbio->raid_map[i];
5161 				bbio->stripes[i] = bbio->stripes[i+1];
5162 				bbio->raid_map[i] = bbio->raid_map[i+1];
5163 				bbio->stripes[i+1] = s;
5164 				bbio->raid_map[i+1] = l;
5165 
5166 				again = 1;
5167 			}
5168 		}
5169 	}
5170 }
5171 
alloc_btrfs_bio(int total_stripes,int real_stripes)5172 static struct btrfs_bio *alloc_btrfs_bio(int total_stripes, int real_stripes)
5173 {
5174 	struct btrfs_bio *bbio = kzalloc(
5175 		 /* the size of the btrfs_bio */
5176 		sizeof(struct btrfs_bio) +
5177 		/* plus the variable array for the stripes */
5178 		sizeof(struct btrfs_bio_stripe) * (total_stripes) +
5179 		/* plus the variable array for the tgt dev */
5180 		sizeof(int) * (real_stripes) +
5181 		/*
5182 		 * plus the raid_map, which includes both the tgt dev
5183 		 * and the stripes
5184 		 */
5185 		sizeof(u64) * (total_stripes),
5186 		GFP_NOFS|__GFP_NOFAIL);
5187 
5188 	atomic_set(&bbio->error, 0);
5189 	atomic_set(&bbio->refs, 1);
5190 
5191 	return bbio;
5192 }
5193 
btrfs_get_bbio(struct btrfs_bio * bbio)5194 void btrfs_get_bbio(struct btrfs_bio *bbio)
5195 {
5196 	WARN_ON(!atomic_read(&bbio->refs));
5197 	atomic_inc(&bbio->refs);
5198 }
5199 
btrfs_put_bbio(struct btrfs_bio * bbio)5200 void btrfs_put_bbio(struct btrfs_bio *bbio)
5201 {
5202 	if (!bbio)
5203 		return;
5204 	if (atomic_dec_and_test(&bbio->refs))
5205 		kfree(bbio);
5206 }
5207 
__btrfs_map_block(struct btrfs_fs_info * fs_info,int rw,u64 logical,u64 * length,struct btrfs_bio ** bbio_ret,int mirror_num,int need_raid_map)5208 static int __btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
5209 			     u64 logical, u64 *length,
5210 			     struct btrfs_bio **bbio_ret,
5211 			     int mirror_num, int need_raid_map)
5212 {
5213 	struct extent_map *em;
5214 	struct map_lookup *map;
5215 	struct btrfs_mapping_tree *map_tree = &fs_info->mapping_tree;
5216 	struct extent_map_tree *em_tree = &map_tree->map_tree;
5217 	u64 offset;
5218 	u64 stripe_offset;
5219 	u64 stripe_end_offset;
5220 	u64 stripe_nr;
5221 	u64 stripe_nr_orig;
5222 	u64 stripe_nr_end;
5223 	u64 stripe_len;
5224 	u32 stripe_index;
5225 	int i;
5226 	int ret = 0;
5227 	int num_stripes;
5228 	int max_errors = 0;
5229 	int tgtdev_indexes = 0;
5230 	struct btrfs_bio *bbio = NULL;
5231 	struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
5232 	int dev_replace_is_ongoing = 0;
5233 	int num_alloc_stripes;
5234 	int patch_the_first_stripe_for_dev_replace = 0;
5235 	u64 physical_to_patch_in_first_stripe = 0;
5236 	u64 raid56_full_stripe_start = (u64)-1;
5237 
5238 	read_lock(&em_tree->lock);
5239 	em = lookup_extent_mapping(em_tree, logical, *length);
5240 	read_unlock(&em_tree->lock);
5241 
5242 	if (!em) {
5243 		btrfs_crit(fs_info, "unable to find logical %llu len %llu",
5244 			logical, *length);
5245 		return -EINVAL;
5246 	}
5247 
5248 	if (em->start > logical || em->start + em->len < logical) {
5249 		btrfs_crit(fs_info, "found a bad mapping, wanted %Lu, "
5250 			   "found %Lu-%Lu", logical, em->start,
5251 			   em->start + em->len);
5252 		free_extent_map(em);
5253 		return -EINVAL;
5254 	}
5255 
5256 	map = (struct map_lookup *)em->bdev;
5257 	offset = logical - em->start;
5258 
5259 	stripe_len = map->stripe_len;
5260 	stripe_nr = offset;
5261 	/*
5262 	 * stripe_nr counts the total number of stripes we have to stride
5263 	 * to get to this block
5264 	 */
5265 	stripe_nr = div64_u64(stripe_nr, stripe_len);
5266 
5267 	stripe_offset = stripe_nr * stripe_len;
5268 	BUG_ON(offset < stripe_offset);
5269 
5270 	/* stripe_offset is the offset of this block in its stripe*/
5271 	stripe_offset = offset - stripe_offset;
5272 
5273 	/* if we're here for raid56, we need to know the stripe aligned start */
5274 	if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) {
5275 		unsigned long full_stripe_len = stripe_len * nr_data_stripes(map);
5276 		raid56_full_stripe_start = offset;
5277 
5278 		/* allow a write of a full stripe, but make sure we don't
5279 		 * allow straddling of stripes
5280 		 */
5281 		raid56_full_stripe_start = div64_u64(raid56_full_stripe_start,
5282 				full_stripe_len);
5283 		raid56_full_stripe_start *= full_stripe_len;
5284 	}
5285 
5286 	if (rw & REQ_DISCARD) {
5287 		/* we don't discard raid56 yet */
5288 		if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) {
5289 			ret = -EOPNOTSUPP;
5290 			goto out;
5291 		}
5292 		*length = min_t(u64, em->len - offset, *length);
5293 	} else if (map->type & BTRFS_BLOCK_GROUP_PROFILE_MASK) {
5294 		u64 max_len;
5295 		/* For writes to RAID[56], allow a full stripeset across all disks.
5296 		   For other RAID types and for RAID[56] reads, just allow a single
5297 		   stripe (on a single disk). */
5298 		if ((map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) &&
5299 		    (rw & REQ_WRITE)) {
5300 			max_len = stripe_len * nr_data_stripes(map) -
5301 				(offset - raid56_full_stripe_start);
5302 		} else {
5303 			/* we limit the length of each bio to what fits in a stripe */
5304 			max_len = stripe_len - stripe_offset;
5305 		}
5306 		*length = min_t(u64, em->len - offset, max_len);
5307 	} else {
5308 		*length = em->len - offset;
5309 	}
5310 
5311 	/* This is for when we're called from btrfs_merge_bio_hook() and all
5312 	   it cares about is the length */
5313 	if (!bbio_ret)
5314 		goto out;
5315 
5316 	btrfs_dev_replace_lock(dev_replace);
5317 	dev_replace_is_ongoing = btrfs_dev_replace_is_ongoing(dev_replace);
5318 	if (!dev_replace_is_ongoing)
5319 		btrfs_dev_replace_unlock(dev_replace);
5320 
5321 	if (dev_replace_is_ongoing && mirror_num == map->num_stripes + 1 &&
5322 	    !(rw & (REQ_WRITE | REQ_DISCARD | REQ_GET_READ_MIRRORS)) &&
5323 	    dev_replace->tgtdev != NULL) {
5324 		/*
5325 		 * in dev-replace case, for repair case (that's the only
5326 		 * case where the mirror is selected explicitly when
5327 		 * calling btrfs_map_block), blocks left of the left cursor
5328 		 * can also be read from the target drive.
5329 		 * For REQ_GET_READ_MIRRORS, the target drive is added as
5330 		 * the last one to the array of stripes. For READ, it also
5331 		 * needs to be supported using the same mirror number.
5332 		 * If the requested block is not left of the left cursor,
5333 		 * EIO is returned. This can happen because btrfs_num_copies()
5334 		 * returns one more in the dev-replace case.
5335 		 */
5336 		u64 tmp_length = *length;
5337 		struct btrfs_bio *tmp_bbio = NULL;
5338 		int tmp_num_stripes;
5339 		u64 srcdev_devid = dev_replace->srcdev->devid;
5340 		int index_srcdev = 0;
5341 		int found = 0;
5342 		u64 physical_of_found = 0;
5343 
5344 		ret = __btrfs_map_block(fs_info, REQ_GET_READ_MIRRORS,
5345 			     logical, &tmp_length, &tmp_bbio, 0, 0);
5346 		if (ret) {
5347 			WARN_ON(tmp_bbio != NULL);
5348 			goto out;
5349 		}
5350 
5351 		tmp_num_stripes = tmp_bbio->num_stripes;
5352 		if (mirror_num > tmp_num_stripes) {
5353 			/*
5354 			 * REQ_GET_READ_MIRRORS does not contain this
5355 			 * mirror, that means that the requested area
5356 			 * is not left of the left cursor
5357 			 */
5358 			ret = -EIO;
5359 			btrfs_put_bbio(tmp_bbio);
5360 			goto out;
5361 		}
5362 
5363 		/*
5364 		 * process the rest of the function using the mirror_num
5365 		 * of the source drive. Therefore look it up first.
5366 		 * At the end, patch the device pointer to the one of the
5367 		 * target drive.
5368 		 */
5369 		for (i = 0; i < tmp_num_stripes; i++) {
5370 			if (tmp_bbio->stripes[i].dev->devid == srcdev_devid) {
5371 				/*
5372 				 * In case of DUP, in order to keep it
5373 				 * simple, only add the mirror with the
5374 				 * lowest physical address
5375 				 */
5376 				if (found &&
5377 				    physical_of_found <=
5378 				     tmp_bbio->stripes[i].physical)
5379 					continue;
5380 				index_srcdev = i;
5381 				found = 1;
5382 				physical_of_found =
5383 					tmp_bbio->stripes[i].physical;
5384 			}
5385 		}
5386 
5387 		if (found) {
5388 			mirror_num = index_srcdev + 1;
5389 			patch_the_first_stripe_for_dev_replace = 1;
5390 			physical_to_patch_in_first_stripe = physical_of_found;
5391 		} else {
5392 			WARN_ON(1);
5393 			ret = -EIO;
5394 			btrfs_put_bbio(tmp_bbio);
5395 			goto out;
5396 		}
5397 
5398 		btrfs_put_bbio(tmp_bbio);
5399 	} else if (mirror_num > map->num_stripes) {
5400 		mirror_num = 0;
5401 	}
5402 
5403 	num_stripes = 1;
5404 	stripe_index = 0;
5405 	stripe_nr_orig = stripe_nr;
5406 	stripe_nr_end = ALIGN(offset + *length, map->stripe_len);
5407 	stripe_nr_end = div_u64(stripe_nr_end, map->stripe_len);
5408 	stripe_end_offset = stripe_nr_end * map->stripe_len -
5409 			    (offset + *length);
5410 
5411 	if (map->type & BTRFS_BLOCK_GROUP_RAID0) {
5412 		if (rw & REQ_DISCARD)
5413 			num_stripes = min_t(u64, map->num_stripes,
5414 					    stripe_nr_end - stripe_nr_orig);
5415 		stripe_nr = div_u64_rem(stripe_nr, map->num_stripes,
5416 				&stripe_index);
5417 		if (!(rw & (REQ_WRITE | REQ_DISCARD | REQ_GET_READ_MIRRORS)))
5418 			mirror_num = 1;
5419 	} else if (map->type & BTRFS_BLOCK_GROUP_RAID1) {
5420 		if (rw & (REQ_WRITE | REQ_DISCARD | REQ_GET_READ_MIRRORS))
5421 			num_stripes = map->num_stripes;
5422 		else if (mirror_num)
5423 			stripe_index = mirror_num - 1;
5424 		else {
5425 			stripe_index = find_live_mirror(fs_info, map, 0,
5426 					    map->num_stripes,
5427 					    current->pid % map->num_stripes,
5428 					    dev_replace_is_ongoing);
5429 			mirror_num = stripe_index + 1;
5430 		}
5431 
5432 	} else if (map->type & BTRFS_BLOCK_GROUP_DUP) {
5433 		if (rw & (REQ_WRITE | REQ_DISCARD | REQ_GET_READ_MIRRORS)) {
5434 			num_stripes = map->num_stripes;
5435 		} else if (mirror_num) {
5436 			stripe_index = mirror_num - 1;
5437 		} else {
5438 			mirror_num = 1;
5439 		}
5440 
5441 	} else if (map->type & BTRFS_BLOCK_GROUP_RAID10) {
5442 		u32 factor = map->num_stripes / map->sub_stripes;
5443 
5444 		stripe_nr = div_u64_rem(stripe_nr, factor, &stripe_index);
5445 		stripe_index *= map->sub_stripes;
5446 
5447 		if (rw & (REQ_WRITE | REQ_GET_READ_MIRRORS))
5448 			num_stripes = map->sub_stripes;
5449 		else if (rw & REQ_DISCARD)
5450 			num_stripes = min_t(u64, map->sub_stripes *
5451 					    (stripe_nr_end - stripe_nr_orig),
5452 					    map->num_stripes);
5453 		else if (mirror_num)
5454 			stripe_index += mirror_num - 1;
5455 		else {
5456 			int old_stripe_index = stripe_index;
5457 			stripe_index = find_live_mirror(fs_info, map,
5458 					      stripe_index,
5459 					      map->sub_stripes, stripe_index +
5460 					      current->pid % map->sub_stripes,
5461 					      dev_replace_is_ongoing);
5462 			mirror_num = stripe_index - old_stripe_index + 1;
5463 		}
5464 
5465 	} else if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) {
5466 		if (need_raid_map &&
5467 		    ((rw & (REQ_WRITE | REQ_GET_READ_MIRRORS)) ||
5468 		     mirror_num > 1)) {
5469 			/* push stripe_nr back to the start of the full stripe */
5470 			stripe_nr = div_u64(raid56_full_stripe_start,
5471 					stripe_len * nr_data_stripes(map));
5472 
5473 			/* RAID[56] write or recovery. Return all stripes */
5474 			num_stripes = map->num_stripes;
5475 			max_errors = nr_parity_stripes(map);
5476 
5477 			*length = map->stripe_len;
5478 			stripe_index = 0;
5479 			stripe_offset = 0;
5480 		} else {
5481 			/*
5482 			 * Mirror #0 or #1 means the original data block.
5483 			 * Mirror #2 is RAID5 parity block.
5484 			 * Mirror #3 is RAID6 Q block.
5485 			 */
5486 			stripe_nr = div_u64_rem(stripe_nr,
5487 					nr_data_stripes(map), &stripe_index);
5488 			if (mirror_num > 1)
5489 				stripe_index = nr_data_stripes(map) +
5490 						mirror_num - 2;
5491 
5492 			/* We distribute the parity blocks across stripes */
5493 			div_u64_rem(stripe_nr + stripe_index, map->num_stripes,
5494 					&stripe_index);
5495 			if (!(rw & (REQ_WRITE | REQ_DISCARD |
5496 				    REQ_GET_READ_MIRRORS)) && mirror_num <= 1)
5497 				mirror_num = 1;
5498 		}
5499 	} else {
5500 		/*
5501 		 * after this, stripe_nr is the number of stripes on this
5502 		 * device we have to walk to find the data, and stripe_index is
5503 		 * the number of our device in the stripe array
5504 		 */
5505 		stripe_nr = div_u64_rem(stripe_nr, map->num_stripes,
5506 				&stripe_index);
5507 		mirror_num = stripe_index + 1;
5508 	}
5509 	BUG_ON(stripe_index >= map->num_stripes);
5510 
5511 	num_alloc_stripes = num_stripes;
5512 	if (dev_replace_is_ongoing) {
5513 		if (rw & (REQ_WRITE | REQ_DISCARD))
5514 			num_alloc_stripes <<= 1;
5515 		if (rw & REQ_GET_READ_MIRRORS)
5516 			num_alloc_stripes++;
5517 		tgtdev_indexes = num_stripes;
5518 	}
5519 
5520 	bbio = alloc_btrfs_bio(num_alloc_stripes, tgtdev_indexes);
5521 	if (!bbio) {
5522 		ret = -ENOMEM;
5523 		goto out;
5524 	}
5525 	if (dev_replace_is_ongoing)
5526 		bbio->tgtdev_map = (int *)(bbio->stripes + num_alloc_stripes);
5527 
5528 	/* build raid_map */
5529 	if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK &&
5530 	    need_raid_map && ((rw & (REQ_WRITE | REQ_GET_READ_MIRRORS)) ||
5531 	    mirror_num > 1)) {
5532 		u64 tmp;
5533 		unsigned rot;
5534 
5535 		bbio->raid_map = (u64 *)((void *)bbio->stripes +
5536 				 sizeof(struct btrfs_bio_stripe) *
5537 				 num_alloc_stripes +
5538 				 sizeof(int) * tgtdev_indexes);
5539 
5540 		/* Work out the disk rotation on this stripe-set */
5541 		div_u64_rem(stripe_nr, num_stripes, &rot);
5542 
5543 		/* Fill in the logical address of each stripe */
5544 		tmp = stripe_nr * nr_data_stripes(map);
5545 		for (i = 0; i < nr_data_stripes(map); i++)
5546 			bbio->raid_map[(i+rot) % num_stripes] =
5547 				em->start + (tmp + i) * map->stripe_len;
5548 
5549 		bbio->raid_map[(i+rot) % map->num_stripes] = RAID5_P_STRIPE;
5550 		if (map->type & BTRFS_BLOCK_GROUP_RAID6)
5551 			bbio->raid_map[(i+rot+1) % num_stripes] =
5552 				RAID6_Q_STRIPE;
5553 	}
5554 
5555 	if (rw & REQ_DISCARD) {
5556 		u32 factor = 0;
5557 		u32 sub_stripes = 0;
5558 		u64 stripes_per_dev = 0;
5559 		u32 remaining_stripes = 0;
5560 		u32 last_stripe = 0;
5561 
5562 		if (map->type &
5563 		    (BTRFS_BLOCK_GROUP_RAID0 | BTRFS_BLOCK_GROUP_RAID10)) {
5564 			if (map->type & BTRFS_BLOCK_GROUP_RAID0)
5565 				sub_stripes = 1;
5566 			else
5567 				sub_stripes = map->sub_stripes;
5568 
5569 			factor = map->num_stripes / sub_stripes;
5570 			stripes_per_dev = div_u64_rem(stripe_nr_end -
5571 						      stripe_nr_orig,
5572 						      factor,
5573 						      &remaining_stripes);
5574 			div_u64_rem(stripe_nr_end - 1, factor, &last_stripe);
5575 			last_stripe *= sub_stripes;
5576 		}
5577 
5578 		for (i = 0; i < num_stripes; i++) {
5579 			bbio->stripes[i].physical =
5580 				map->stripes[stripe_index].physical +
5581 				stripe_offset + stripe_nr * map->stripe_len;
5582 			bbio->stripes[i].dev = map->stripes[stripe_index].dev;
5583 
5584 			if (map->type & (BTRFS_BLOCK_GROUP_RAID0 |
5585 					 BTRFS_BLOCK_GROUP_RAID10)) {
5586 				bbio->stripes[i].length = stripes_per_dev *
5587 							  map->stripe_len;
5588 
5589 				if (i / sub_stripes < remaining_stripes)
5590 					bbio->stripes[i].length +=
5591 						map->stripe_len;
5592 
5593 				/*
5594 				 * Special for the first stripe and
5595 				 * the last stripe:
5596 				 *
5597 				 * |-------|...|-------|
5598 				 *     |----------|
5599 				 *    off     end_off
5600 				 */
5601 				if (i < sub_stripes)
5602 					bbio->stripes[i].length -=
5603 						stripe_offset;
5604 
5605 				if (stripe_index >= last_stripe &&
5606 				    stripe_index <= (last_stripe +
5607 						     sub_stripes - 1))
5608 					bbio->stripes[i].length -=
5609 						stripe_end_offset;
5610 
5611 				if (i == sub_stripes - 1)
5612 					stripe_offset = 0;
5613 			} else
5614 				bbio->stripes[i].length = *length;
5615 
5616 			stripe_index++;
5617 			if (stripe_index == map->num_stripes) {
5618 				/* This could only happen for RAID0/10 */
5619 				stripe_index = 0;
5620 				stripe_nr++;
5621 			}
5622 		}
5623 	} else {
5624 		for (i = 0; i < num_stripes; i++) {
5625 			bbio->stripes[i].physical =
5626 				map->stripes[stripe_index].physical +
5627 				stripe_offset +
5628 				stripe_nr * map->stripe_len;
5629 			bbio->stripes[i].dev =
5630 				map->stripes[stripe_index].dev;
5631 			stripe_index++;
5632 		}
5633 	}
5634 
5635 	if (rw & (REQ_WRITE | REQ_GET_READ_MIRRORS))
5636 		max_errors = btrfs_chunk_max_errors(map);
5637 
5638 	if (bbio->raid_map)
5639 		sort_parity_stripes(bbio, num_stripes);
5640 
5641 	tgtdev_indexes = 0;
5642 	if (dev_replace_is_ongoing && (rw & (REQ_WRITE | REQ_DISCARD)) &&
5643 	    dev_replace->tgtdev != NULL) {
5644 		int index_where_to_add;
5645 		u64 srcdev_devid = dev_replace->srcdev->devid;
5646 
5647 		/*
5648 		 * duplicate the write operations while the dev replace
5649 		 * procedure is running. Since the copying of the old disk
5650 		 * to the new disk takes place at run time while the
5651 		 * filesystem is mounted writable, the regular write
5652 		 * operations to the old disk have to be duplicated to go
5653 		 * to the new disk as well.
5654 		 * Note that device->missing is handled by the caller, and
5655 		 * that the write to the old disk is already set up in the
5656 		 * stripes array.
5657 		 */
5658 		index_where_to_add = num_stripes;
5659 		for (i = 0; i < num_stripes; i++) {
5660 			if (bbio->stripes[i].dev->devid == srcdev_devid) {
5661 				/* write to new disk, too */
5662 				struct btrfs_bio_stripe *new =
5663 					bbio->stripes + index_where_to_add;
5664 				struct btrfs_bio_stripe *old =
5665 					bbio->stripes + i;
5666 
5667 				new->physical = old->physical;
5668 				new->length = old->length;
5669 				new->dev = dev_replace->tgtdev;
5670 				bbio->tgtdev_map[i] = index_where_to_add;
5671 				index_where_to_add++;
5672 				max_errors++;
5673 				tgtdev_indexes++;
5674 			}
5675 		}
5676 		num_stripes = index_where_to_add;
5677 	} else if (dev_replace_is_ongoing && (rw & REQ_GET_READ_MIRRORS) &&
5678 		   dev_replace->tgtdev != NULL) {
5679 		u64 srcdev_devid = dev_replace->srcdev->devid;
5680 		int index_srcdev = 0;
5681 		int found = 0;
5682 		u64 physical_of_found = 0;
5683 
5684 		/*
5685 		 * During the dev-replace procedure, the target drive can
5686 		 * also be used to read data in case it is needed to repair
5687 		 * a corrupt block elsewhere. This is possible if the
5688 		 * requested area is left of the left cursor. In this area,
5689 		 * the target drive is a full copy of the source drive.
5690 		 */
5691 		for (i = 0; i < num_stripes; i++) {
5692 			if (bbio->stripes[i].dev->devid == srcdev_devid) {
5693 				/*
5694 				 * In case of DUP, in order to keep it
5695 				 * simple, only add the mirror with the
5696 				 * lowest physical address
5697 				 */
5698 				if (found &&
5699 				    physical_of_found <=
5700 				     bbio->stripes[i].physical)
5701 					continue;
5702 				index_srcdev = i;
5703 				found = 1;
5704 				physical_of_found = bbio->stripes[i].physical;
5705 			}
5706 		}
5707 		if (found) {
5708 			if (physical_of_found + map->stripe_len <=
5709 			    dev_replace->cursor_left) {
5710 				struct btrfs_bio_stripe *tgtdev_stripe =
5711 					bbio->stripes + num_stripes;
5712 
5713 				tgtdev_stripe->physical = physical_of_found;
5714 				tgtdev_stripe->length =
5715 					bbio->stripes[index_srcdev].length;
5716 				tgtdev_stripe->dev = dev_replace->tgtdev;
5717 				bbio->tgtdev_map[index_srcdev] = num_stripes;
5718 
5719 				tgtdev_indexes++;
5720 				num_stripes++;
5721 			}
5722 		}
5723 	}
5724 
5725 	*bbio_ret = bbio;
5726 	bbio->map_type = map->type;
5727 	bbio->num_stripes = num_stripes;
5728 	bbio->max_errors = max_errors;
5729 	bbio->mirror_num = mirror_num;
5730 	bbio->num_tgtdevs = tgtdev_indexes;
5731 
5732 	/*
5733 	 * this is the case that REQ_READ && dev_replace_is_ongoing &&
5734 	 * mirror_num == num_stripes + 1 && dev_replace target drive is
5735 	 * available as a mirror
5736 	 */
5737 	if (patch_the_first_stripe_for_dev_replace && num_stripes > 0) {
5738 		WARN_ON(num_stripes > 1);
5739 		bbio->stripes[0].dev = dev_replace->tgtdev;
5740 		bbio->stripes[0].physical = physical_to_patch_in_first_stripe;
5741 		bbio->mirror_num = map->num_stripes + 1;
5742 	}
5743 out:
5744 	if (dev_replace_is_ongoing)
5745 		btrfs_dev_replace_unlock(dev_replace);
5746 	free_extent_map(em);
5747 	return ret;
5748 }
5749 
btrfs_map_block(struct btrfs_fs_info * fs_info,int rw,u64 logical,u64 * length,struct btrfs_bio ** bbio_ret,int mirror_num)5750 int btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
5751 		      u64 logical, u64 *length,
5752 		      struct btrfs_bio **bbio_ret, int mirror_num)
5753 {
5754 	return __btrfs_map_block(fs_info, rw, logical, length, bbio_ret,
5755 				 mirror_num, 0);
5756 }
5757 
5758 /* For Scrub/replace */
btrfs_map_sblock(struct btrfs_fs_info * fs_info,int rw,u64 logical,u64 * length,struct btrfs_bio ** bbio_ret,int mirror_num,int need_raid_map)5759 int btrfs_map_sblock(struct btrfs_fs_info *fs_info, int rw,
5760 		     u64 logical, u64 *length,
5761 		     struct btrfs_bio **bbio_ret, int mirror_num,
5762 		     int need_raid_map)
5763 {
5764 	return __btrfs_map_block(fs_info, rw, logical, length, bbio_ret,
5765 				 mirror_num, need_raid_map);
5766 }
5767 
btrfs_rmap_block(struct btrfs_mapping_tree * map_tree,u64 chunk_start,u64 physical,u64 devid,u64 ** logical,int * naddrs,int * stripe_len)5768 int btrfs_rmap_block(struct btrfs_mapping_tree *map_tree,
5769 		     u64 chunk_start, u64 physical, u64 devid,
5770 		     u64 **logical, int *naddrs, int *stripe_len)
5771 {
5772 	struct extent_map_tree *em_tree = &map_tree->map_tree;
5773 	struct extent_map *em;
5774 	struct map_lookup *map;
5775 	u64 *buf;
5776 	u64 bytenr;
5777 	u64 length;
5778 	u64 stripe_nr;
5779 	u64 rmap_len;
5780 	int i, j, nr = 0;
5781 
5782 	read_lock(&em_tree->lock);
5783 	em = lookup_extent_mapping(em_tree, chunk_start, 1);
5784 	read_unlock(&em_tree->lock);
5785 
5786 	if (!em) {
5787 		printk(KERN_ERR "BTRFS: couldn't find em for chunk %Lu\n",
5788 		       chunk_start);
5789 		return -EIO;
5790 	}
5791 
5792 	if (em->start != chunk_start) {
5793 		printk(KERN_ERR "BTRFS: bad chunk start, em=%Lu, wanted=%Lu\n",
5794 		       em->start, chunk_start);
5795 		free_extent_map(em);
5796 		return -EIO;
5797 	}
5798 	map = (struct map_lookup *)em->bdev;
5799 
5800 	length = em->len;
5801 	rmap_len = map->stripe_len;
5802 
5803 	if (map->type & BTRFS_BLOCK_GROUP_RAID10)
5804 		length = div_u64(length, map->num_stripes / map->sub_stripes);
5805 	else if (map->type & BTRFS_BLOCK_GROUP_RAID0)
5806 		length = div_u64(length, map->num_stripes);
5807 	else if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) {
5808 		length = div_u64(length, nr_data_stripes(map));
5809 		rmap_len = map->stripe_len * nr_data_stripes(map);
5810 	}
5811 
5812 	buf = kcalloc(map->num_stripes, sizeof(u64), GFP_NOFS);
5813 	BUG_ON(!buf); /* -ENOMEM */
5814 
5815 	for (i = 0; i < map->num_stripes; i++) {
5816 		if (devid && map->stripes[i].dev->devid != devid)
5817 			continue;
5818 		if (map->stripes[i].physical > physical ||
5819 		    map->stripes[i].physical + length <= physical)
5820 			continue;
5821 
5822 		stripe_nr = physical - map->stripes[i].physical;
5823 		stripe_nr = div_u64(stripe_nr, map->stripe_len);
5824 
5825 		if (map->type & BTRFS_BLOCK_GROUP_RAID10) {
5826 			stripe_nr = stripe_nr * map->num_stripes + i;
5827 			stripe_nr = div_u64(stripe_nr, map->sub_stripes);
5828 		} else if (map->type & BTRFS_BLOCK_GROUP_RAID0) {
5829 			stripe_nr = stripe_nr * map->num_stripes + i;
5830 		} /* else if RAID[56], multiply by nr_data_stripes().
5831 		   * Alternatively, just use rmap_len below instead of
5832 		   * map->stripe_len */
5833 
5834 		bytenr = chunk_start + stripe_nr * rmap_len;
5835 		WARN_ON(nr >= map->num_stripes);
5836 		for (j = 0; j < nr; j++) {
5837 			if (buf[j] == bytenr)
5838 				break;
5839 		}
5840 		if (j == nr) {
5841 			WARN_ON(nr >= map->num_stripes);
5842 			buf[nr++] = bytenr;
5843 		}
5844 	}
5845 
5846 	*logical = buf;
5847 	*naddrs = nr;
5848 	*stripe_len = rmap_len;
5849 
5850 	free_extent_map(em);
5851 	return 0;
5852 }
5853 
btrfs_end_bbio(struct btrfs_bio * bbio,struct bio * bio)5854 static inline void btrfs_end_bbio(struct btrfs_bio *bbio, struct bio *bio)
5855 {
5856 	bio->bi_private = bbio->private;
5857 	bio->bi_end_io = bbio->end_io;
5858 	bio_endio(bio);
5859 
5860 	btrfs_put_bbio(bbio);
5861 }
5862 
btrfs_end_bio(struct bio * bio)5863 static void btrfs_end_bio(struct bio *bio)
5864 {
5865 	struct btrfs_bio *bbio = bio->bi_private;
5866 	int is_orig_bio = 0;
5867 
5868 	if (bio->bi_error) {
5869 		atomic_inc(&bbio->error);
5870 		if (bio->bi_error == -EIO || bio->bi_error == -EREMOTEIO) {
5871 			unsigned int stripe_index =
5872 				btrfs_io_bio(bio)->stripe_index;
5873 			struct btrfs_device *dev;
5874 
5875 			BUG_ON(stripe_index >= bbio->num_stripes);
5876 			dev = bbio->stripes[stripe_index].dev;
5877 			if (dev->bdev) {
5878 				if (bio->bi_rw & WRITE)
5879 					btrfs_dev_stat_inc(dev,
5880 						BTRFS_DEV_STAT_WRITE_ERRS);
5881 				else
5882 					btrfs_dev_stat_inc(dev,
5883 						BTRFS_DEV_STAT_READ_ERRS);
5884 				if ((bio->bi_rw & WRITE_FLUSH) == WRITE_FLUSH)
5885 					btrfs_dev_stat_inc(dev,
5886 						BTRFS_DEV_STAT_FLUSH_ERRS);
5887 				btrfs_dev_stat_print_on_error(dev);
5888 			}
5889 		}
5890 	}
5891 
5892 	if (bio == bbio->orig_bio)
5893 		is_orig_bio = 1;
5894 
5895 	btrfs_bio_counter_dec(bbio->fs_info);
5896 
5897 	if (atomic_dec_and_test(&bbio->stripes_pending)) {
5898 		if (!is_orig_bio) {
5899 			bio_put(bio);
5900 			bio = bbio->orig_bio;
5901 		}
5902 
5903 		btrfs_io_bio(bio)->mirror_num = bbio->mirror_num;
5904 		/* only send an error to the higher layers if it is
5905 		 * beyond the tolerance of the btrfs bio
5906 		 */
5907 		if (atomic_read(&bbio->error) > bbio->max_errors) {
5908 			bio->bi_error = -EIO;
5909 		} else {
5910 			/*
5911 			 * this bio is actually up to date, we didn't
5912 			 * go over the max number of errors
5913 			 */
5914 			bio->bi_error = 0;
5915 		}
5916 
5917 		btrfs_end_bbio(bbio, bio);
5918 	} else if (!is_orig_bio) {
5919 		bio_put(bio);
5920 	}
5921 }
5922 
5923 /*
5924  * see run_scheduled_bios for a description of why bios are collected for
5925  * async submit.
5926  *
5927  * This will add one bio to the pending list for a device and make sure
5928  * the work struct is scheduled.
5929  */
btrfs_schedule_bio(struct btrfs_root * root,struct btrfs_device * device,int rw,struct bio * bio)5930 static noinline void btrfs_schedule_bio(struct btrfs_root *root,
5931 					struct btrfs_device *device,
5932 					int rw, struct bio *bio)
5933 {
5934 	int should_queue = 1;
5935 	struct btrfs_pending_bios *pending_bios;
5936 
5937 	if (device->missing || !device->bdev) {
5938 		bio_io_error(bio);
5939 		return;
5940 	}
5941 
5942 	/* don't bother with additional async steps for reads, right now */
5943 	if (!(rw & REQ_WRITE)) {
5944 		bio_get(bio);
5945 		btrfsic_submit_bio(rw, bio);
5946 		bio_put(bio);
5947 		return;
5948 	}
5949 
5950 	/*
5951 	 * nr_async_bios allows us to reliably return congestion to the
5952 	 * higher layers.  Otherwise, the async bio makes it appear we have
5953 	 * made progress against dirty pages when we've really just put it
5954 	 * on a queue for later
5955 	 */
5956 	atomic_inc(&root->fs_info->nr_async_bios);
5957 	WARN_ON(bio->bi_next);
5958 	bio->bi_next = NULL;
5959 	bio->bi_rw |= rw;
5960 
5961 	spin_lock(&device->io_lock);
5962 	if (bio->bi_rw & REQ_SYNC)
5963 		pending_bios = &device->pending_sync_bios;
5964 	else
5965 		pending_bios = &device->pending_bios;
5966 
5967 	if (pending_bios->tail)
5968 		pending_bios->tail->bi_next = bio;
5969 
5970 	pending_bios->tail = bio;
5971 	if (!pending_bios->head)
5972 		pending_bios->head = bio;
5973 	if (device->running_pending)
5974 		should_queue = 0;
5975 
5976 	spin_unlock(&device->io_lock);
5977 
5978 	if (should_queue)
5979 		btrfs_queue_work(root->fs_info->submit_workers,
5980 				 &device->work);
5981 }
5982 
submit_stripe_bio(struct btrfs_root * root,struct btrfs_bio * bbio,struct bio * bio,u64 physical,int dev_nr,int rw,int async)5983 static void submit_stripe_bio(struct btrfs_root *root, struct btrfs_bio *bbio,
5984 			      struct bio *bio, u64 physical, int dev_nr,
5985 			      int rw, int async)
5986 {
5987 	struct btrfs_device *dev = bbio->stripes[dev_nr].dev;
5988 
5989 	bio->bi_private = bbio;
5990 	btrfs_io_bio(bio)->stripe_index = dev_nr;
5991 	bio->bi_end_io = btrfs_end_bio;
5992 	bio->bi_iter.bi_sector = physical >> 9;
5993 #ifdef DEBUG
5994 	{
5995 		struct rcu_string *name;
5996 
5997 		rcu_read_lock();
5998 		name = rcu_dereference(dev->name);
5999 		pr_debug("btrfs_map_bio: rw %d, sector=%llu, dev=%lu "
6000 			 "(%s id %llu), size=%u\n", rw,
6001 			 (u64)bio->bi_iter.bi_sector, (u_long)dev->bdev->bd_dev,
6002 			 name->str, dev->devid, bio->bi_iter.bi_size);
6003 		rcu_read_unlock();
6004 	}
6005 #endif
6006 	bio->bi_bdev = dev->bdev;
6007 
6008 	btrfs_bio_counter_inc_noblocked(root->fs_info);
6009 
6010 	if (async)
6011 		btrfs_schedule_bio(root, dev, rw, bio);
6012 	else
6013 		btrfsic_submit_bio(rw, bio);
6014 }
6015 
bbio_error(struct btrfs_bio * bbio,struct bio * bio,u64 logical)6016 static void bbio_error(struct btrfs_bio *bbio, struct bio *bio, u64 logical)
6017 {
6018 	atomic_inc(&bbio->error);
6019 	if (atomic_dec_and_test(&bbio->stripes_pending)) {
6020 		/* Shoud be the original bio. */
6021 		WARN_ON(bio != bbio->orig_bio);
6022 
6023 		btrfs_io_bio(bio)->mirror_num = bbio->mirror_num;
6024 		bio->bi_iter.bi_sector = logical >> 9;
6025 		bio->bi_error = -EIO;
6026 		btrfs_end_bbio(bbio, bio);
6027 	}
6028 }
6029 
btrfs_map_bio(struct btrfs_root * root,int rw,struct bio * bio,int mirror_num,int async_submit)6030 int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
6031 		  int mirror_num, int async_submit)
6032 {
6033 	struct btrfs_device *dev;
6034 	struct bio *first_bio = bio;
6035 	u64 logical = (u64)bio->bi_iter.bi_sector << 9;
6036 	u64 length = 0;
6037 	u64 map_length;
6038 	int ret;
6039 	int dev_nr;
6040 	int total_devs;
6041 	struct btrfs_bio *bbio = NULL;
6042 
6043 	length = bio->bi_iter.bi_size;
6044 	map_length = length;
6045 
6046 	btrfs_bio_counter_inc_blocked(root->fs_info);
6047 	ret = __btrfs_map_block(root->fs_info, rw, logical, &map_length, &bbio,
6048 			      mirror_num, 1);
6049 	if (ret) {
6050 		btrfs_bio_counter_dec(root->fs_info);
6051 		return ret;
6052 	}
6053 
6054 	total_devs = bbio->num_stripes;
6055 	bbio->orig_bio = first_bio;
6056 	bbio->private = first_bio->bi_private;
6057 	bbio->end_io = first_bio->bi_end_io;
6058 	bbio->fs_info = root->fs_info;
6059 	atomic_set(&bbio->stripes_pending, bbio->num_stripes);
6060 
6061 	if (bbio->raid_map) {
6062 		/* In this case, map_length has been set to the length of
6063 		   a single stripe; not the whole write */
6064 		if (rw & WRITE) {
6065 			ret = raid56_parity_write(root, bio, bbio, map_length);
6066 		} else {
6067 			ret = raid56_parity_recover(root, bio, bbio, map_length,
6068 						    mirror_num, 1);
6069 		}
6070 
6071 		btrfs_bio_counter_dec(root->fs_info);
6072 		return ret;
6073 	}
6074 
6075 	if (map_length < length) {
6076 		btrfs_crit(root->fs_info, "mapping failed logical %llu bio len %llu len %llu",
6077 			logical, length, map_length);
6078 		BUG();
6079 	}
6080 
6081 	for (dev_nr = 0; dev_nr < total_devs; dev_nr++) {
6082 		dev = bbio->stripes[dev_nr].dev;
6083 		if (!dev || !dev->bdev || (rw & WRITE && !dev->writeable)) {
6084 			bbio_error(bbio, first_bio, logical);
6085 			continue;
6086 		}
6087 
6088 		if (dev_nr < total_devs - 1) {
6089 			bio = btrfs_bio_clone(first_bio, GFP_NOFS);
6090 			BUG_ON(!bio); /* -ENOMEM */
6091 		} else
6092 			bio = first_bio;
6093 
6094 		submit_stripe_bio(root, bbio, bio,
6095 				  bbio->stripes[dev_nr].physical, dev_nr, rw,
6096 				  async_submit);
6097 	}
6098 	btrfs_bio_counter_dec(root->fs_info);
6099 	return 0;
6100 }
6101 
btrfs_find_device(struct btrfs_fs_info * fs_info,u64 devid,u8 * uuid,u8 * fsid)6102 struct btrfs_device *btrfs_find_device(struct btrfs_fs_info *fs_info, u64 devid,
6103 				       u8 *uuid, u8 *fsid)
6104 {
6105 	struct btrfs_device *device;
6106 	struct btrfs_fs_devices *cur_devices;
6107 
6108 	cur_devices = fs_info->fs_devices;
6109 	while (cur_devices) {
6110 		if (!fsid ||
6111 		    !memcmp(cur_devices->fsid, fsid, BTRFS_UUID_SIZE)) {
6112 			device = __find_device(&cur_devices->devices,
6113 					       devid, uuid);
6114 			if (device)
6115 				return device;
6116 		}
6117 		cur_devices = cur_devices->seed;
6118 	}
6119 	return NULL;
6120 }
6121 
add_missing_dev(struct btrfs_root * root,struct btrfs_fs_devices * fs_devices,u64 devid,u8 * dev_uuid)6122 static struct btrfs_device *add_missing_dev(struct btrfs_root *root,
6123 					    struct btrfs_fs_devices *fs_devices,
6124 					    u64 devid, u8 *dev_uuid)
6125 {
6126 	struct btrfs_device *device;
6127 
6128 	device = btrfs_alloc_device(NULL, &devid, dev_uuid);
6129 	if (IS_ERR(device))
6130 		return NULL;
6131 
6132 	list_add(&device->dev_list, &fs_devices->devices);
6133 	device->fs_devices = fs_devices;
6134 	fs_devices->num_devices++;
6135 
6136 	device->missing = 1;
6137 	fs_devices->missing_devices++;
6138 
6139 	return device;
6140 }
6141 
6142 /**
6143  * btrfs_alloc_device - allocate struct btrfs_device
6144  * @fs_info:	used only for generating a new devid, can be NULL if
6145  *		devid is provided (i.e. @devid != NULL).
6146  * @devid:	a pointer to devid for this device.  If NULL a new devid
6147  *		is generated.
6148  * @uuid:	a pointer to UUID for this device.  If NULL a new UUID
6149  *		is generated.
6150  *
6151  * Return: a pointer to a new &struct btrfs_device on success; ERR_PTR()
6152  * on error.  Returned struct is not linked onto any lists and can be
6153  * destroyed with kfree() right away.
6154  */
btrfs_alloc_device(struct btrfs_fs_info * fs_info,const u64 * devid,const u8 * uuid)6155 struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info,
6156 					const u64 *devid,
6157 					const u8 *uuid)
6158 {
6159 	struct btrfs_device *dev;
6160 	u64 tmp;
6161 
6162 	if (WARN_ON(!devid && !fs_info))
6163 		return ERR_PTR(-EINVAL);
6164 
6165 	dev = __alloc_device();
6166 	if (IS_ERR(dev))
6167 		return dev;
6168 
6169 	if (devid)
6170 		tmp = *devid;
6171 	else {
6172 		int ret;
6173 
6174 		ret = find_next_devid(fs_info, &tmp);
6175 		if (ret) {
6176 			kfree(dev);
6177 			return ERR_PTR(ret);
6178 		}
6179 	}
6180 	dev->devid = tmp;
6181 
6182 	if (uuid)
6183 		memcpy(dev->uuid, uuid, BTRFS_UUID_SIZE);
6184 	else
6185 		generate_random_uuid(dev->uuid);
6186 
6187 	btrfs_init_work(&dev->work, btrfs_submit_helper,
6188 			pending_bios_fn, NULL, NULL);
6189 
6190 	return dev;
6191 }
6192 
read_one_chunk(struct btrfs_root * root,struct btrfs_key * key,struct extent_buffer * leaf,struct btrfs_chunk * chunk)6193 static int read_one_chunk(struct btrfs_root *root, struct btrfs_key *key,
6194 			  struct extent_buffer *leaf,
6195 			  struct btrfs_chunk *chunk)
6196 {
6197 	struct btrfs_mapping_tree *map_tree = &root->fs_info->mapping_tree;
6198 	struct map_lookup *map;
6199 	struct extent_map *em;
6200 	u64 logical;
6201 	u64 length;
6202 	u64 devid;
6203 	u8 uuid[BTRFS_UUID_SIZE];
6204 	int num_stripes;
6205 	int ret;
6206 	int i;
6207 
6208 	logical = key->offset;
6209 	length = btrfs_chunk_length(leaf, chunk);
6210 
6211 	read_lock(&map_tree->map_tree.lock);
6212 	em = lookup_extent_mapping(&map_tree->map_tree, logical, 1);
6213 	read_unlock(&map_tree->map_tree.lock);
6214 
6215 	/* already mapped? */
6216 	if (em && em->start <= logical && em->start + em->len > logical) {
6217 		free_extent_map(em);
6218 		return 0;
6219 	} else if (em) {
6220 		free_extent_map(em);
6221 	}
6222 
6223 	em = alloc_extent_map();
6224 	if (!em)
6225 		return -ENOMEM;
6226 	num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
6227 	map = kmalloc(map_lookup_size(num_stripes), GFP_NOFS);
6228 	if (!map) {
6229 		free_extent_map(em);
6230 		return -ENOMEM;
6231 	}
6232 
6233 	set_bit(EXTENT_FLAG_FS_MAPPING, &em->flags);
6234 	em->bdev = (struct block_device *)map;
6235 	em->start = logical;
6236 	em->len = length;
6237 	em->orig_start = 0;
6238 	em->block_start = 0;
6239 	em->block_len = em->len;
6240 
6241 	map->num_stripes = num_stripes;
6242 	map->io_width = btrfs_chunk_io_width(leaf, chunk);
6243 	map->io_align = btrfs_chunk_io_align(leaf, chunk);
6244 	map->sector_size = btrfs_chunk_sector_size(leaf, chunk);
6245 	map->stripe_len = btrfs_chunk_stripe_len(leaf, chunk);
6246 	map->type = btrfs_chunk_type(leaf, chunk);
6247 	map->sub_stripes = btrfs_chunk_sub_stripes(leaf, chunk);
6248 	for (i = 0; i < num_stripes; i++) {
6249 		map->stripes[i].physical =
6250 			btrfs_stripe_offset_nr(leaf, chunk, i);
6251 		devid = btrfs_stripe_devid_nr(leaf, chunk, i);
6252 		read_extent_buffer(leaf, uuid, (unsigned long)
6253 				   btrfs_stripe_dev_uuid_nr(chunk, i),
6254 				   BTRFS_UUID_SIZE);
6255 		map->stripes[i].dev = btrfs_find_device(root->fs_info, devid,
6256 							uuid, NULL);
6257 		if (!map->stripes[i].dev && !btrfs_test_opt(root, DEGRADED)) {
6258 			free_extent_map(em);
6259 			return -EIO;
6260 		}
6261 		if (!map->stripes[i].dev) {
6262 			map->stripes[i].dev =
6263 				add_missing_dev(root, root->fs_info->fs_devices,
6264 						devid, uuid);
6265 			if (!map->stripes[i].dev) {
6266 				free_extent_map(em);
6267 				return -EIO;
6268 			}
6269 			btrfs_warn(root->fs_info, "devid %llu uuid %pU is missing",
6270 						devid, uuid);
6271 		}
6272 		map->stripes[i].dev->in_fs_metadata = 1;
6273 	}
6274 
6275 	write_lock(&map_tree->map_tree.lock);
6276 	ret = add_extent_mapping(&map_tree->map_tree, em, 0);
6277 	write_unlock(&map_tree->map_tree.lock);
6278 	BUG_ON(ret); /* Tree corruption */
6279 	free_extent_map(em);
6280 
6281 	return 0;
6282 }
6283 
fill_device_from_item(struct extent_buffer * leaf,struct btrfs_dev_item * dev_item,struct btrfs_device * device)6284 static void fill_device_from_item(struct extent_buffer *leaf,
6285 				 struct btrfs_dev_item *dev_item,
6286 				 struct btrfs_device *device)
6287 {
6288 	unsigned long ptr;
6289 
6290 	device->devid = btrfs_device_id(leaf, dev_item);
6291 	device->disk_total_bytes = btrfs_device_total_bytes(leaf, dev_item);
6292 	device->total_bytes = device->disk_total_bytes;
6293 	device->commit_total_bytes = device->disk_total_bytes;
6294 	device->bytes_used = btrfs_device_bytes_used(leaf, dev_item);
6295 	device->commit_bytes_used = device->bytes_used;
6296 	device->type = btrfs_device_type(leaf, dev_item);
6297 	device->io_align = btrfs_device_io_align(leaf, dev_item);
6298 	device->io_width = btrfs_device_io_width(leaf, dev_item);
6299 	device->sector_size = btrfs_device_sector_size(leaf, dev_item);
6300 	WARN_ON(device->devid == BTRFS_DEV_REPLACE_DEVID);
6301 	device->is_tgtdev_for_dev_replace = 0;
6302 
6303 	ptr = btrfs_device_uuid(dev_item);
6304 	read_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE);
6305 }
6306 
open_seed_devices(struct btrfs_root * root,u8 * fsid)6307 static struct btrfs_fs_devices *open_seed_devices(struct btrfs_root *root,
6308 						  u8 *fsid)
6309 {
6310 	struct btrfs_fs_devices *fs_devices;
6311 	int ret;
6312 
6313 	BUG_ON(!mutex_is_locked(&uuid_mutex));
6314 
6315 	fs_devices = root->fs_info->fs_devices->seed;
6316 	while (fs_devices) {
6317 		if (!memcmp(fs_devices->fsid, fsid, BTRFS_UUID_SIZE))
6318 			return fs_devices;
6319 
6320 		fs_devices = fs_devices->seed;
6321 	}
6322 
6323 	fs_devices = find_fsid(fsid);
6324 	if (!fs_devices) {
6325 		if (!btrfs_test_opt(root, DEGRADED))
6326 			return ERR_PTR(-ENOENT);
6327 
6328 		fs_devices = alloc_fs_devices(fsid);
6329 		if (IS_ERR(fs_devices))
6330 			return fs_devices;
6331 
6332 		fs_devices->seeding = 1;
6333 		fs_devices->opened = 1;
6334 		return fs_devices;
6335 	}
6336 
6337 	fs_devices = clone_fs_devices(fs_devices);
6338 	if (IS_ERR(fs_devices))
6339 		return fs_devices;
6340 
6341 	ret = __btrfs_open_devices(fs_devices, FMODE_READ,
6342 				   root->fs_info->bdev_holder);
6343 	if (ret) {
6344 		free_fs_devices(fs_devices);
6345 		fs_devices = ERR_PTR(ret);
6346 		goto out;
6347 	}
6348 
6349 	if (!fs_devices->seeding) {
6350 		__btrfs_close_devices(fs_devices);
6351 		free_fs_devices(fs_devices);
6352 		fs_devices = ERR_PTR(-EINVAL);
6353 		goto out;
6354 	}
6355 
6356 	fs_devices->seed = root->fs_info->fs_devices->seed;
6357 	root->fs_info->fs_devices->seed = fs_devices;
6358 out:
6359 	return fs_devices;
6360 }
6361 
read_one_dev(struct btrfs_root * root,struct extent_buffer * leaf,struct btrfs_dev_item * dev_item)6362 static int read_one_dev(struct btrfs_root *root,
6363 			struct extent_buffer *leaf,
6364 			struct btrfs_dev_item *dev_item)
6365 {
6366 	struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
6367 	struct btrfs_device *device;
6368 	u64 devid;
6369 	int ret;
6370 	u8 fs_uuid[BTRFS_UUID_SIZE];
6371 	u8 dev_uuid[BTRFS_UUID_SIZE];
6372 
6373 	devid = btrfs_device_id(leaf, dev_item);
6374 	read_extent_buffer(leaf, dev_uuid, btrfs_device_uuid(dev_item),
6375 			   BTRFS_UUID_SIZE);
6376 	read_extent_buffer(leaf, fs_uuid, btrfs_device_fsid(dev_item),
6377 			   BTRFS_UUID_SIZE);
6378 
6379 	if (memcmp(fs_uuid, root->fs_info->fsid, BTRFS_UUID_SIZE)) {
6380 		fs_devices = open_seed_devices(root, fs_uuid);
6381 		if (IS_ERR(fs_devices))
6382 			return PTR_ERR(fs_devices);
6383 	}
6384 
6385 	device = btrfs_find_device(root->fs_info, devid, dev_uuid, fs_uuid);
6386 	if (!device) {
6387 		if (!btrfs_test_opt(root, DEGRADED))
6388 			return -EIO;
6389 
6390 		device = add_missing_dev(root, fs_devices, devid, dev_uuid);
6391 		if (!device)
6392 			return -ENOMEM;
6393 		btrfs_warn(root->fs_info, "devid %llu uuid %pU missing",
6394 				devid, dev_uuid);
6395 	} else {
6396 		if (!device->bdev && !btrfs_test_opt(root, DEGRADED))
6397 			return -EIO;
6398 
6399 		if(!device->bdev && !device->missing) {
6400 			/*
6401 			 * this happens when a device that was properly setup
6402 			 * in the device info lists suddenly goes bad.
6403 			 * device->bdev is NULL, and so we have to set
6404 			 * device->missing to one here
6405 			 */
6406 			device->fs_devices->missing_devices++;
6407 			device->missing = 1;
6408 		}
6409 
6410 		/* Move the device to its own fs_devices */
6411 		if (device->fs_devices != fs_devices) {
6412 			ASSERT(device->missing);
6413 
6414 			list_move(&device->dev_list, &fs_devices->devices);
6415 			device->fs_devices->num_devices--;
6416 			fs_devices->num_devices++;
6417 
6418 			device->fs_devices->missing_devices--;
6419 			fs_devices->missing_devices++;
6420 
6421 			device->fs_devices = fs_devices;
6422 		}
6423 	}
6424 
6425 	if (device->fs_devices != root->fs_info->fs_devices) {
6426 		BUG_ON(device->writeable);
6427 		if (device->generation !=
6428 		    btrfs_device_generation(leaf, dev_item))
6429 			return -EINVAL;
6430 	}
6431 
6432 	fill_device_from_item(leaf, dev_item, device);
6433 	device->in_fs_metadata = 1;
6434 	if (device->writeable && !device->is_tgtdev_for_dev_replace) {
6435 		device->fs_devices->total_rw_bytes += device->total_bytes;
6436 		spin_lock(&root->fs_info->free_chunk_lock);
6437 		root->fs_info->free_chunk_space += device->total_bytes -
6438 			device->bytes_used;
6439 		spin_unlock(&root->fs_info->free_chunk_lock);
6440 	}
6441 	ret = 0;
6442 	return ret;
6443 }
6444 
btrfs_read_sys_array(struct btrfs_root * root)6445 int btrfs_read_sys_array(struct btrfs_root *root)
6446 {
6447 	struct btrfs_super_block *super_copy = root->fs_info->super_copy;
6448 	struct extent_buffer *sb;
6449 	struct btrfs_disk_key *disk_key;
6450 	struct btrfs_chunk *chunk;
6451 	u8 *array_ptr;
6452 	unsigned long sb_array_offset;
6453 	int ret = 0;
6454 	u32 num_stripes;
6455 	u32 array_size;
6456 	u32 len = 0;
6457 	u32 cur_offset;
6458 	struct btrfs_key key;
6459 
6460 	ASSERT(BTRFS_SUPER_INFO_SIZE <= root->nodesize);
6461 	/*
6462 	 * This will create extent buffer of nodesize, superblock size is
6463 	 * fixed to BTRFS_SUPER_INFO_SIZE. If nodesize > sb size, this will
6464 	 * overallocate but we can keep it as-is, only the first page is used.
6465 	 */
6466 	sb = btrfs_find_create_tree_block(root, BTRFS_SUPER_INFO_OFFSET);
6467 	if (!sb)
6468 		return -ENOMEM;
6469 	btrfs_set_buffer_uptodate(sb);
6470 	btrfs_set_buffer_lockdep_class(root->root_key.objectid, sb, 0);
6471 	/*
6472 	 * The sb extent buffer is artifical and just used to read the system array.
6473 	 * btrfs_set_buffer_uptodate() call does not properly mark all it's
6474 	 * pages up-to-date when the page is larger: extent does not cover the
6475 	 * whole page and consequently check_page_uptodate does not find all
6476 	 * the page's extents up-to-date (the hole beyond sb),
6477 	 * write_extent_buffer then triggers a WARN_ON.
6478 	 *
6479 	 * Regular short extents go through mark_extent_buffer_dirty/writeback cycle,
6480 	 * but sb spans only this function. Add an explicit SetPageUptodate call
6481 	 * to silence the warning eg. on PowerPC 64.
6482 	 */
6483 	if (PAGE_CACHE_SIZE > BTRFS_SUPER_INFO_SIZE)
6484 		SetPageUptodate(sb->pages[0]);
6485 
6486 	write_extent_buffer(sb, super_copy, 0, BTRFS_SUPER_INFO_SIZE);
6487 	array_size = btrfs_super_sys_array_size(super_copy);
6488 
6489 	array_ptr = super_copy->sys_chunk_array;
6490 	sb_array_offset = offsetof(struct btrfs_super_block, sys_chunk_array);
6491 	cur_offset = 0;
6492 
6493 	while (cur_offset < array_size) {
6494 		disk_key = (struct btrfs_disk_key *)array_ptr;
6495 		len = sizeof(*disk_key);
6496 		if (cur_offset + len > array_size)
6497 			goto out_short_read;
6498 
6499 		btrfs_disk_key_to_cpu(&key, disk_key);
6500 
6501 		array_ptr += len;
6502 		sb_array_offset += len;
6503 		cur_offset += len;
6504 
6505 		if (key.type == BTRFS_CHUNK_ITEM_KEY) {
6506 			chunk = (struct btrfs_chunk *)sb_array_offset;
6507 			/*
6508 			 * At least one btrfs_chunk with one stripe must be
6509 			 * present, exact stripe count check comes afterwards
6510 			 */
6511 			len = btrfs_chunk_item_size(1);
6512 			if (cur_offset + len > array_size)
6513 				goto out_short_read;
6514 
6515 			num_stripes = btrfs_chunk_num_stripes(sb, chunk);
6516 			if (!num_stripes) {
6517 				printk(KERN_ERR
6518 	    "BTRFS: invalid number of stripes %u in sys_array at offset %u\n",
6519 					num_stripes, cur_offset);
6520 				ret = -EIO;
6521 				break;
6522 			}
6523 
6524 			len = btrfs_chunk_item_size(num_stripes);
6525 			if (cur_offset + len > array_size)
6526 				goto out_short_read;
6527 
6528 			ret = read_one_chunk(root, &key, sb, chunk);
6529 			if (ret)
6530 				break;
6531 		} else {
6532 			ret = -EIO;
6533 			break;
6534 		}
6535 		array_ptr += len;
6536 		sb_array_offset += len;
6537 		cur_offset += len;
6538 	}
6539 	free_extent_buffer(sb);
6540 	return ret;
6541 
6542 out_short_read:
6543 	printk(KERN_ERR "BTRFS: sys_array too short to read %u bytes at offset %u\n",
6544 			len, cur_offset);
6545 	free_extent_buffer(sb);
6546 	return -EIO;
6547 }
6548 
btrfs_read_chunk_tree(struct btrfs_root * root)6549 int btrfs_read_chunk_tree(struct btrfs_root *root)
6550 {
6551 	struct btrfs_path *path;
6552 	struct extent_buffer *leaf;
6553 	struct btrfs_key key;
6554 	struct btrfs_key found_key;
6555 	int ret;
6556 	int slot;
6557 
6558 	root = root->fs_info->chunk_root;
6559 
6560 	path = btrfs_alloc_path();
6561 	if (!path)
6562 		return -ENOMEM;
6563 
6564 	mutex_lock(&uuid_mutex);
6565 	lock_chunks(root);
6566 
6567 	/*
6568 	 * Read all device items, and then all the chunk items. All
6569 	 * device items are found before any chunk item (their object id
6570 	 * is smaller than the lowest possible object id for a chunk
6571 	 * item - BTRFS_FIRST_CHUNK_TREE_OBJECTID).
6572 	 */
6573 	key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
6574 	key.offset = 0;
6575 	key.type = 0;
6576 	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
6577 	if (ret < 0)
6578 		goto error;
6579 	while (1) {
6580 		leaf = path->nodes[0];
6581 		slot = path->slots[0];
6582 		if (slot >= btrfs_header_nritems(leaf)) {
6583 			ret = btrfs_next_leaf(root, path);
6584 			if (ret == 0)
6585 				continue;
6586 			if (ret < 0)
6587 				goto error;
6588 			break;
6589 		}
6590 		btrfs_item_key_to_cpu(leaf, &found_key, slot);
6591 		if (found_key.type == BTRFS_DEV_ITEM_KEY) {
6592 			struct btrfs_dev_item *dev_item;
6593 			dev_item = btrfs_item_ptr(leaf, slot,
6594 						  struct btrfs_dev_item);
6595 			ret = read_one_dev(root, leaf, dev_item);
6596 			if (ret)
6597 				goto error;
6598 		} else if (found_key.type == BTRFS_CHUNK_ITEM_KEY) {
6599 			struct btrfs_chunk *chunk;
6600 			chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);
6601 			ret = read_one_chunk(root, &found_key, leaf, chunk);
6602 			if (ret)
6603 				goto error;
6604 		}
6605 		path->slots[0]++;
6606 	}
6607 	ret = 0;
6608 error:
6609 	unlock_chunks(root);
6610 	mutex_unlock(&uuid_mutex);
6611 
6612 	btrfs_free_path(path);
6613 	return ret;
6614 }
6615 
btrfs_init_devices_late(struct btrfs_fs_info * fs_info)6616 void btrfs_init_devices_late(struct btrfs_fs_info *fs_info)
6617 {
6618 	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
6619 	struct btrfs_device *device;
6620 
6621 	while (fs_devices) {
6622 		mutex_lock(&fs_devices->device_list_mutex);
6623 		list_for_each_entry(device, &fs_devices->devices, dev_list)
6624 			device->dev_root = fs_info->dev_root;
6625 		mutex_unlock(&fs_devices->device_list_mutex);
6626 
6627 		fs_devices = fs_devices->seed;
6628 	}
6629 }
6630 
__btrfs_reset_dev_stats(struct btrfs_device * dev)6631 static void __btrfs_reset_dev_stats(struct btrfs_device *dev)
6632 {
6633 	int i;
6634 
6635 	for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++)
6636 		btrfs_dev_stat_reset(dev, i);
6637 }
6638 
btrfs_init_dev_stats(struct btrfs_fs_info * fs_info)6639 int btrfs_init_dev_stats(struct btrfs_fs_info *fs_info)
6640 {
6641 	struct btrfs_key key;
6642 	struct btrfs_key found_key;
6643 	struct btrfs_root *dev_root = fs_info->dev_root;
6644 	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
6645 	struct extent_buffer *eb;
6646 	int slot;
6647 	int ret = 0;
6648 	struct btrfs_device *device;
6649 	struct btrfs_path *path = NULL;
6650 	int i;
6651 
6652 	path = btrfs_alloc_path();
6653 	if (!path) {
6654 		ret = -ENOMEM;
6655 		goto out;
6656 	}
6657 
6658 	mutex_lock(&fs_devices->device_list_mutex);
6659 	list_for_each_entry(device, &fs_devices->devices, dev_list) {
6660 		int item_size;
6661 		struct btrfs_dev_stats_item *ptr;
6662 
6663 		key.objectid = 0;
6664 		key.type = BTRFS_DEV_STATS_KEY;
6665 		key.offset = device->devid;
6666 		ret = btrfs_search_slot(NULL, dev_root, &key, path, 0, 0);
6667 		if (ret) {
6668 			__btrfs_reset_dev_stats(device);
6669 			device->dev_stats_valid = 1;
6670 			btrfs_release_path(path);
6671 			continue;
6672 		}
6673 		slot = path->slots[0];
6674 		eb = path->nodes[0];
6675 		btrfs_item_key_to_cpu(eb, &found_key, slot);
6676 		item_size = btrfs_item_size_nr(eb, slot);
6677 
6678 		ptr = btrfs_item_ptr(eb, slot,
6679 				     struct btrfs_dev_stats_item);
6680 
6681 		for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++) {
6682 			if (item_size >= (1 + i) * sizeof(__le64))
6683 				btrfs_dev_stat_set(device, i,
6684 					btrfs_dev_stats_value(eb, ptr, i));
6685 			else
6686 				btrfs_dev_stat_reset(device, i);
6687 		}
6688 
6689 		device->dev_stats_valid = 1;
6690 		btrfs_dev_stat_print_on_load(device);
6691 		btrfs_release_path(path);
6692 	}
6693 	mutex_unlock(&fs_devices->device_list_mutex);
6694 
6695 out:
6696 	btrfs_free_path(path);
6697 	return ret < 0 ? ret : 0;
6698 }
6699 
update_dev_stat_item(struct btrfs_trans_handle * trans,struct btrfs_root * dev_root,struct btrfs_device * device)6700 static int update_dev_stat_item(struct btrfs_trans_handle *trans,
6701 				struct btrfs_root *dev_root,
6702 				struct btrfs_device *device)
6703 {
6704 	struct btrfs_path *path;
6705 	struct btrfs_key key;
6706 	struct extent_buffer *eb;
6707 	struct btrfs_dev_stats_item *ptr;
6708 	int ret;
6709 	int i;
6710 
6711 	key.objectid = 0;
6712 	key.type = BTRFS_DEV_STATS_KEY;
6713 	key.offset = device->devid;
6714 
6715 	path = btrfs_alloc_path();
6716 	BUG_ON(!path);
6717 	ret = btrfs_search_slot(trans, dev_root, &key, path, -1, 1);
6718 	if (ret < 0) {
6719 		btrfs_warn_in_rcu(dev_root->fs_info,
6720 			"error %d while searching for dev_stats item for device %s",
6721 			      ret, rcu_str_deref(device->name));
6722 		goto out;
6723 	}
6724 
6725 	if (ret == 0 &&
6726 	    btrfs_item_size_nr(path->nodes[0], path->slots[0]) < sizeof(*ptr)) {
6727 		/* need to delete old one and insert a new one */
6728 		ret = btrfs_del_item(trans, dev_root, path);
6729 		if (ret != 0) {
6730 			btrfs_warn_in_rcu(dev_root->fs_info,
6731 				"delete too small dev_stats item for device %s failed %d",
6732 				      rcu_str_deref(device->name), ret);
6733 			goto out;
6734 		}
6735 		ret = 1;
6736 	}
6737 
6738 	if (ret == 1) {
6739 		/* need to insert a new item */
6740 		btrfs_release_path(path);
6741 		ret = btrfs_insert_empty_item(trans, dev_root, path,
6742 					      &key, sizeof(*ptr));
6743 		if (ret < 0) {
6744 			btrfs_warn_in_rcu(dev_root->fs_info,
6745 				"insert dev_stats item for device %s failed %d",
6746 				rcu_str_deref(device->name), ret);
6747 			goto out;
6748 		}
6749 	}
6750 
6751 	eb = path->nodes[0];
6752 	ptr = btrfs_item_ptr(eb, path->slots[0], struct btrfs_dev_stats_item);
6753 	for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++)
6754 		btrfs_set_dev_stats_value(eb, ptr, i,
6755 					  btrfs_dev_stat_read(device, i));
6756 	btrfs_mark_buffer_dirty(eb);
6757 
6758 out:
6759 	btrfs_free_path(path);
6760 	return ret;
6761 }
6762 
6763 /*
6764  * called from commit_transaction. Writes all changed device stats to disk.
6765  */
btrfs_run_dev_stats(struct btrfs_trans_handle * trans,struct btrfs_fs_info * fs_info)6766 int btrfs_run_dev_stats(struct btrfs_trans_handle *trans,
6767 			struct btrfs_fs_info *fs_info)
6768 {
6769 	struct btrfs_root *dev_root = fs_info->dev_root;
6770 	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
6771 	struct btrfs_device *device;
6772 	int stats_cnt;
6773 	int ret = 0;
6774 
6775 	mutex_lock(&fs_devices->device_list_mutex);
6776 	list_for_each_entry(device, &fs_devices->devices, dev_list) {
6777 		if (!device->dev_stats_valid || !btrfs_dev_stats_dirty(device))
6778 			continue;
6779 
6780 		stats_cnt = atomic_read(&device->dev_stats_ccnt);
6781 		ret = update_dev_stat_item(trans, dev_root, device);
6782 		if (!ret)
6783 			atomic_sub(stats_cnt, &device->dev_stats_ccnt);
6784 	}
6785 	mutex_unlock(&fs_devices->device_list_mutex);
6786 
6787 	return ret;
6788 }
6789 
btrfs_dev_stat_inc_and_print(struct btrfs_device * dev,int index)6790 void btrfs_dev_stat_inc_and_print(struct btrfs_device *dev, int index)
6791 {
6792 	btrfs_dev_stat_inc(dev, index);
6793 	btrfs_dev_stat_print_on_error(dev);
6794 }
6795 
btrfs_dev_stat_print_on_error(struct btrfs_device * dev)6796 static void btrfs_dev_stat_print_on_error(struct btrfs_device *dev)
6797 {
6798 	if (!dev->dev_stats_valid)
6799 		return;
6800 	btrfs_err_rl_in_rcu(dev->dev_root->fs_info,
6801 		"bdev %s errs: wr %u, rd %u, flush %u, corrupt %u, gen %u",
6802 			   rcu_str_deref(dev->name),
6803 			   btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_WRITE_ERRS),
6804 			   btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_READ_ERRS),
6805 			   btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_FLUSH_ERRS),
6806 			   btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_CORRUPTION_ERRS),
6807 			   btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_GENERATION_ERRS));
6808 }
6809 
btrfs_dev_stat_print_on_load(struct btrfs_device * dev)6810 static void btrfs_dev_stat_print_on_load(struct btrfs_device *dev)
6811 {
6812 	int i;
6813 
6814 	for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++)
6815 		if (btrfs_dev_stat_read(dev, i) != 0)
6816 			break;
6817 	if (i == BTRFS_DEV_STAT_VALUES_MAX)
6818 		return; /* all values == 0, suppress message */
6819 
6820 	btrfs_info_in_rcu(dev->dev_root->fs_info,
6821 		"bdev %s errs: wr %u, rd %u, flush %u, corrupt %u, gen %u",
6822 	       rcu_str_deref(dev->name),
6823 	       btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_WRITE_ERRS),
6824 	       btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_READ_ERRS),
6825 	       btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_FLUSH_ERRS),
6826 	       btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_CORRUPTION_ERRS),
6827 	       btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_GENERATION_ERRS));
6828 }
6829 
btrfs_get_dev_stats(struct btrfs_root * root,struct btrfs_ioctl_get_dev_stats * stats)6830 int btrfs_get_dev_stats(struct btrfs_root *root,
6831 			struct btrfs_ioctl_get_dev_stats *stats)
6832 {
6833 	struct btrfs_device *dev;
6834 	struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
6835 	int i;
6836 
6837 	mutex_lock(&fs_devices->device_list_mutex);
6838 	dev = btrfs_find_device(root->fs_info, stats->devid, NULL, NULL);
6839 	mutex_unlock(&fs_devices->device_list_mutex);
6840 
6841 	if (!dev) {
6842 		btrfs_warn(root->fs_info, "get dev_stats failed, device not found");
6843 		return -ENODEV;
6844 	} else if (!dev->dev_stats_valid) {
6845 		btrfs_warn(root->fs_info, "get dev_stats failed, not yet valid");
6846 		return -ENODEV;
6847 	} else if (stats->flags & BTRFS_DEV_STATS_RESET) {
6848 		for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++) {
6849 			if (stats->nr_items > i)
6850 				stats->values[i] =
6851 					btrfs_dev_stat_read_and_reset(dev, i);
6852 			else
6853 				btrfs_dev_stat_reset(dev, i);
6854 		}
6855 	} else {
6856 		for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++)
6857 			if (stats->nr_items > i)
6858 				stats->values[i] = btrfs_dev_stat_read(dev, i);
6859 	}
6860 	if (stats->nr_items > BTRFS_DEV_STAT_VALUES_MAX)
6861 		stats->nr_items = BTRFS_DEV_STAT_VALUES_MAX;
6862 	return 0;
6863 }
6864 
btrfs_scratch_superblocks(struct block_device * bdev,char * device_path)6865 void btrfs_scratch_superblocks(struct block_device *bdev, char *device_path)
6866 {
6867 	struct buffer_head *bh;
6868 	struct btrfs_super_block *disk_super;
6869 	int copy_num;
6870 
6871 	if (!bdev)
6872 		return;
6873 
6874 	for (copy_num = 0; copy_num < BTRFS_SUPER_MIRROR_MAX;
6875 		copy_num++) {
6876 
6877 		if (btrfs_read_dev_one_super(bdev, copy_num, &bh))
6878 			continue;
6879 
6880 		disk_super = (struct btrfs_super_block *)bh->b_data;
6881 
6882 		memset(&disk_super->magic, 0, sizeof(disk_super->magic));
6883 		set_buffer_dirty(bh);
6884 		sync_dirty_buffer(bh);
6885 		brelse(bh);
6886 	}
6887 
6888 	/* Notify udev that device has changed */
6889 	btrfs_kobject_uevent(bdev, KOBJ_CHANGE);
6890 
6891 	/* Update ctime/mtime for device path for libblkid */
6892 	update_dev_time(device_path);
6893 }
6894 
6895 /*
6896  * Update the size of all devices, which is used for writing out the
6897  * super blocks.
6898  */
btrfs_update_commit_device_size(struct btrfs_fs_info * fs_info)6899 void btrfs_update_commit_device_size(struct btrfs_fs_info *fs_info)
6900 {
6901 	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
6902 	struct btrfs_device *curr, *next;
6903 
6904 	if (list_empty(&fs_devices->resized_devices))
6905 		return;
6906 
6907 	mutex_lock(&fs_devices->device_list_mutex);
6908 	lock_chunks(fs_info->dev_root);
6909 	list_for_each_entry_safe(curr, next, &fs_devices->resized_devices,
6910 				 resized_list) {
6911 		list_del_init(&curr->resized_list);
6912 		curr->commit_total_bytes = curr->disk_total_bytes;
6913 	}
6914 	unlock_chunks(fs_info->dev_root);
6915 	mutex_unlock(&fs_devices->device_list_mutex);
6916 }
6917 
6918 /* Must be invoked during the transaction commit */
btrfs_update_commit_device_bytes_used(struct btrfs_root * root,struct btrfs_transaction * transaction)6919 void btrfs_update_commit_device_bytes_used(struct btrfs_root *root,
6920 					struct btrfs_transaction *transaction)
6921 {
6922 	struct extent_map *em;
6923 	struct map_lookup *map;
6924 	struct btrfs_device *dev;
6925 	int i;
6926 
6927 	if (list_empty(&transaction->pending_chunks))
6928 		return;
6929 
6930 	/* In order to kick the device replace finish process */
6931 	lock_chunks(root);
6932 	list_for_each_entry(em, &transaction->pending_chunks, list) {
6933 		map = (struct map_lookup *)em->bdev;
6934 
6935 		for (i = 0; i < map->num_stripes; i++) {
6936 			dev = map->stripes[i].dev;
6937 			dev->commit_bytes_used = dev->bytes_used;
6938 		}
6939 	}
6940 	unlock_chunks(root);
6941 }
6942 
btrfs_set_fs_info_ptr(struct btrfs_fs_info * fs_info)6943 void btrfs_set_fs_info_ptr(struct btrfs_fs_info *fs_info)
6944 {
6945 	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
6946 	while (fs_devices) {
6947 		fs_devices->fs_info = fs_info;
6948 		fs_devices = fs_devices->seed;
6949 	}
6950 }
6951 
btrfs_reset_fs_info_ptr(struct btrfs_fs_info * fs_info)6952 void btrfs_reset_fs_info_ptr(struct btrfs_fs_info *fs_info)
6953 {
6954 	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
6955 	while (fs_devices) {
6956 		fs_devices->fs_info = NULL;
6957 		fs_devices = fs_devices->seed;
6958 	}
6959 }
6960 
btrfs_close_one_device(struct btrfs_device * device)6961 void btrfs_close_one_device(struct btrfs_device *device)
6962 {
6963 	struct btrfs_fs_devices *fs_devices = device->fs_devices;
6964 	struct btrfs_device *new_device;
6965 	struct rcu_string *name;
6966 
6967 	if (device->bdev)
6968 		fs_devices->open_devices--;
6969 
6970 	if (device->writeable &&
6971 	    device->devid != BTRFS_DEV_REPLACE_DEVID) {
6972 		list_del_init(&device->dev_alloc_list);
6973 		fs_devices->rw_devices--;
6974 	}
6975 
6976 	if (device->missing)
6977 		fs_devices->missing_devices--;
6978 
6979 	new_device = btrfs_alloc_device(NULL, &device->devid,
6980 					device->uuid);
6981 	BUG_ON(IS_ERR(new_device)); /* -ENOMEM */
6982 
6983 	/* Safe because we are under uuid_mutex */
6984 	if (device->name) {
6985 		name = rcu_string_strdup(device->name->str, GFP_NOFS);
6986 		BUG_ON(!name); /* -ENOMEM */
6987 		rcu_assign_pointer(new_device->name, name);
6988 	}
6989 
6990 	list_replace_rcu(&device->dev_list, &new_device->dev_list);
6991 	new_device->fs_devices = device->fs_devices;
6992 
6993 	call_rcu(&device->rcu, free_device);
6994 }
6995