6a72f88f77b60c422fb9481e5f0b77316ba20179
[muen/linux.git] / fs / btrfs / volumes.c
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/iocontext.h>
24 #include <linux/capability.h>
25 #include <linux/ratelimit.h>
26 #include <linux/kthread.h>
27 #include <linux/raid/pq.h>
28 #include <linux/semaphore.h>
29 #include <linux/uuid.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 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 /*
122  * Table to convert BTRFS_RAID_* to the error code if minimum number of devices
123  * condition is not met. Zero means there's no corresponding
124  * BTRFS_ERROR_DEV_*_NOT_MET value.
125  */
126 const int btrfs_raid_mindev_error[BTRFS_NR_RAID_TYPES] = {
127         [BTRFS_RAID_RAID10] = BTRFS_ERROR_DEV_RAID10_MIN_NOT_MET,
128         [BTRFS_RAID_RAID1]  = BTRFS_ERROR_DEV_RAID1_MIN_NOT_MET,
129         [BTRFS_RAID_DUP]    = 0,
130         [BTRFS_RAID_RAID0]  = 0,
131         [BTRFS_RAID_SINGLE] = 0,
132         [BTRFS_RAID_RAID5]  = BTRFS_ERROR_DEV_RAID5_MIN_NOT_MET,
133         [BTRFS_RAID_RAID6]  = BTRFS_ERROR_DEV_RAID6_MIN_NOT_MET,
134 };
135
136 static int init_first_rw_device(struct btrfs_trans_handle *trans,
137                                 struct btrfs_fs_info *fs_info);
138 static int btrfs_relocate_sys_chunks(struct btrfs_fs_info *fs_info);
139 static void __btrfs_reset_dev_stats(struct btrfs_device *dev);
140 static void btrfs_dev_stat_print_on_error(struct btrfs_device *dev);
141 static void btrfs_dev_stat_print_on_load(struct btrfs_device *device);
142 static int __btrfs_map_block(struct btrfs_fs_info *fs_info,
143                              enum btrfs_map_op op,
144                              u64 logical, u64 *length,
145                              struct btrfs_bio **bbio_ret,
146                              int mirror_num, int need_raid_map);
147
148 DEFINE_MUTEX(uuid_mutex);
149 static LIST_HEAD(fs_uuids);
150 struct list_head *btrfs_get_fs_uuids(void)
151 {
152         return &fs_uuids;
153 }
154
155 /*
156  * alloc_fs_devices - allocate struct btrfs_fs_devices
157  * @fsid:       if not NULL, copy the uuid to fs_devices::fsid
158  *
159  * Return a pointer to a new struct btrfs_fs_devices on success, or ERR_PTR().
160  * The returned struct is not linked onto any lists and can be destroyed with
161  * kfree() right away.
162  */
163 static struct btrfs_fs_devices *alloc_fs_devices(const u8 *fsid)
164 {
165         struct btrfs_fs_devices *fs_devs;
166
167         fs_devs = kzalloc(sizeof(*fs_devs), GFP_KERNEL);
168         if (!fs_devs)
169                 return ERR_PTR(-ENOMEM);
170
171         mutex_init(&fs_devs->device_list_mutex);
172
173         INIT_LIST_HEAD(&fs_devs->devices);
174         INIT_LIST_HEAD(&fs_devs->resized_devices);
175         INIT_LIST_HEAD(&fs_devs->alloc_list);
176         INIT_LIST_HEAD(&fs_devs->list);
177         if (fsid)
178                 memcpy(fs_devs->fsid, fsid, BTRFS_FSID_SIZE);
179
180         return fs_devs;
181 }
182
183 static void free_fs_devices(struct btrfs_fs_devices *fs_devices)
184 {
185         struct btrfs_device *device;
186         WARN_ON(fs_devices->opened);
187         while (!list_empty(&fs_devices->devices)) {
188                 device = list_entry(fs_devices->devices.next,
189                                     struct btrfs_device, dev_list);
190                 list_del(&device->dev_list);
191                 rcu_string_free(device->name);
192                 kfree(device);
193         }
194         kfree(fs_devices);
195 }
196
197 static void btrfs_kobject_uevent(struct block_device *bdev,
198                                  enum kobject_action action)
199 {
200         int ret;
201
202         ret = kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, action);
203         if (ret)
204                 pr_warn("BTRFS: Sending event '%d' to kobject: '%s' (%p): failed\n",
205                         action,
206                         kobject_name(&disk_to_dev(bdev->bd_disk)->kobj),
207                         &disk_to_dev(bdev->bd_disk)->kobj);
208 }
209
210 void btrfs_cleanup_fs_uuids(void)
211 {
212         struct btrfs_fs_devices *fs_devices;
213
214         while (!list_empty(&fs_uuids)) {
215                 fs_devices = list_entry(fs_uuids.next,
216                                         struct btrfs_fs_devices, list);
217                 list_del(&fs_devices->list);
218                 free_fs_devices(fs_devices);
219         }
220 }
221
222 static struct btrfs_device *__alloc_device(void)
223 {
224         struct btrfs_device *dev;
225
226         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
227         if (!dev)
228                 return ERR_PTR(-ENOMEM);
229
230         /*
231          * Preallocate a bio that's always going to be used for flushing device
232          * barriers and matches the device lifespan
233          */
234         dev->flush_bio = bio_alloc_bioset(GFP_KERNEL, 0, NULL);
235         if (!dev->flush_bio) {
236                 kfree(dev);
237                 return ERR_PTR(-ENOMEM);
238         }
239         bio_get(dev->flush_bio);
240
241         INIT_LIST_HEAD(&dev->dev_list);
242         INIT_LIST_HEAD(&dev->dev_alloc_list);
243         INIT_LIST_HEAD(&dev->resized_list);
244
245         spin_lock_init(&dev->io_lock);
246
247         spin_lock_init(&dev->reada_lock);
248         atomic_set(&dev->reada_in_flight, 0);
249         atomic_set(&dev->dev_stats_ccnt, 0);
250         btrfs_device_data_ordered_init(dev);
251         INIT_RADIX_TREE(&dev->reada_zones, GFP_NOFS & ~__GFP_DIRECT_RECLAIM);
252         INIT_RADIX_TREE(&dev->reada_extents, GFP_NOFS & ~__GFP_DIRECT_RECLAIM);
253
254         return dev;
255 }
256
257 /*
258  * Find a device specified by @devid or @uuid in the list of @fs_devices, or
259  * return NULL.
260  *
261  * If devid and uuid are both specified, the match must be exact, otherwise
262  * only devid is used.
263  */
264 static struct btrfs_device *find_device(struct btrfs_fs_devices *fs_devices,
265                 u64 devid, const u8 *uuid)
266 {
267         struct list_head *head = &fs_devices->devices;
268         struct btrfs_device *dev;
269
270         list_for_each_entry(dev, head, dev_list) {
271                 if (dev->devid == devid &&
272                     (!uuid || !memcmp(dev->uuid, uuid, BTRFS_UUID_SIZE))) {
273                         return dev;
274                 }
275         }
276         return NULL;
277 }
278
279 static noinline struct btrfs_fs_devices *find_fsid(u8 *fsid)
280 {
281         struct btrfs_fs_devices *fs_devices;
282
283         list_for_each_entry(fs_devices, &fs_uuids, list) {
284                 if (memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE) == 0)
285                         return fs_devices;
286         }
287         return NULL;
288 }
289
290 static int
291 btrfs_get_bdev_and_sb(const char *device_path, fmode_t flags, void *holder,
292                       int flush, struct block_device **bdev,
293                       struct buffer_head **bh)
294 {
295         int ret;
296
297         *bdev = blkdev_get_by_path(device_path, flags, holder);
298
299         if (IS_ERR(*bdev)) {
300                 ret = PTR_ERR(*bdev);
301                 goto error;
302         }
303
304         if (flush)
305                 filemap_write_and_wait((*bdev)->bd_inode->i_mapping);
306         ret = set_blocksize(*bdev, BTRFS_BDEV_BLOCKSIZE);
307         if (ret) {
308                 blkdev_put(*bdev, flags);
309                 goto error;
310         }
311         invalidate_bdev(*bdev);
312         *bh = btrfs_read_dev_super(*bdev);
313         if (IS_ERR(*bh)) {
314                 ret = PTR_ERR(*bh);
315                 blkdev_put(*bdev, flags);
316                 goto error;
317         }
318
319         return 0;
320
321 error:
322         *bdev = NULL;
323         *bh = NULL;
324         return ret;
325 }
326
327 static void requeue_list(struct btrfs_pending_bios *pending_bios,
328                         struct bio *head, struct bio *tail)
329 {
330
331         struct bio *old_head;
332
333         old_head = pending_bios->head;
334         pending_bios->head = head;
335         if (pending_bios->tail)
336                 tail->bi_next = old_head;
337         else
338                 pending_bios->tail = tail;
339 }
340
341 /*
342  * we try to collect pending bios for a device so we don't get a large
343  * number of procs sending bios down to the same device.  This greatly
344  * improves the schedulers ability to collect and merge the bios.
345  *
346  * But, it also turns into a long list of bios to process and that is sure
347  * to eventually make the worker thread block.  The solution here is to
348  * make some progress and then put this work struct back at the end of
349  * the list if the block device is congested.  This way, multiple devices
350  * can make progress from a single worker thread.
351  */
352 static noinline void run_scheduled_bios(struct btrfs_device *device)
353 {
354         struct btrfs_fs_info *fs_info = device->fs_info;
355         struct bio *pending;
356         struct backing_dev_info *bdi;
357         struct btrfs_pending_bios *pending_bios;
358         struct bio *tail;
359         struct bio *cur;
360         int again = 0;
361         unsigned long num_run;
362         unsigned long batch_run = 0;
363         unsigned long limit;
364         unsigned long last_waited = 0;
365         int force_reg = 0;
366         int sync_pending = 0;
367         struct blk_plug plug;
368
369         /*
370          * this function runs all the bios we've collected for
371          * a particular device.  We don't want to wander off to
372          * another device without first sending all of these down.
373          * So, setup a plug here and finish it off before we return
374          */
375         blk_start_plug(&plug);
376
377         bdi = device->bdev->bd_bdi;
378         limit = btrfs_async_submit_limit(fs_info);
379         limit = limit * 2 / 3;
380
381 loop:
382         spin_lock(&device->io_lock);
383
384 loop_lock:
385         num_run = 0;
386
387         /* take all the bios off the list at once and process them
388          * later on (without the lock held).  But, remember the
389          * tail and other pointers so the bios can be properly reinserted
390          * into the list if we hit congestion
391          */
392         if (!force_reg && device->pending_sync_bios.head) {
393                 pending_bios = &device->pending_sync_bios;
394                 force_reg = 1;
395         } else {
396                 pending_bios = &device->pending_bios;
397                 force_reg = 0;
398         }
399
400         pending = pending_bios->head;
401         tail = pending_bios->tail;
402         WARN_ON(pending && !tail);
403
404         /*
405          * if pending was null this time around, no bios need processing
406          * at all and we can stop.  Otherwise it'll loop back up again
407          * and do an additional check so no bios are missed.
408          *
409          * device->running_pending is used to synchronize with the
410          * schedule_bio code.
411          */
412         if (device->pending_sync_bios.head == NULL &&
413             device->pending_bios.head == NULL) {
414                 again = 0;
415                 device->running_pending = 0;
416         } else {
417                 again = 1;
418                 device->running_pending = 1;
419         }
420
421         pending_bios->head = NULL;
422         pending_bios->tail = NULL;
423
424         spin_unlock(&device->io_lock);
425
426         while (pending) {
427
428                 rmb();
429                 /* we want to work on both lists, but do more bios on the
430                  * sync list than the regular list
431                  */
432                 if ((num_run > 32 &&
433                     pending_bios != &device->pending_sync_bios &&
434                     device->pending_sync_bios.head) ||
435                    (num_run > 64 && pending_bios == &device->pending_sync_bios &&
436                     device->pending_bios.head)) {
437                         spin_lock(&device->io_lock);
438                         requeue_list(pending_bios, pending, tail);
439                         goto loop_lock;
440                 }
441
442                 cur = pending;
443                 pending = pending->bi_next;
444                 cur->bi_next = NULL;
445
446                 /*
447                  * atomic_dec_return implies a barrier for waitqueue_active
448                  */
449                 if (atomic_dec_return(&fs_info->nr_async_bios) < limit &&
450                     waitqueue_active(&fs_info->async_submit_wait))
451                         wake_up(&fs_info->async_submit_wait);
452
453                 BUG_ON(atomic_read(&cur->__bi_cnt) == 0);
454
455                 /*
456                  * if we're doing the sync list, record that our
457                  * plug has some sync requests on it
458                  *
459                  * If we're doing the regular list and there are
460                  * sync requests sitting around, unplug before
461                  * we add more
462                  */
463                 if (pending_bios == &device->pending_sync_bios) {
464                         sync_pending = 1;
465                 } else if (sync_pending) {
466                         blk_finish_plug(&plug);
467                         blk_start_plug(&plug);
468                         sync_pending = 0;
469                 }
470
471                 btrfsic_submit_bio(cur);
472                 num_run++;
473                 batch_run++;
474
475                 cond_resched();
476
477                 /*
478                  * we made progress, there is more work to do and the bdi
479                  * is now congested.  Back off and let other work structs
480                  * run instead
481                  */
482                 if (pending && bdi_write_congested(bdi) && batch_run > 8 &&
483                     fs_info->fs_devices->open_devices > 1) {
484                         struct io_context *ioc;
485
486                         ioc = current->io_context;
487
488                         /*
489                          * the main goal here is that we don't want to
490                          * block if we're going to be able to submit
491                          * more requests without blocking.
492                          *
493                          * This code does two great things, it pokes into
494                          * the elevator code from a filesystem _and_
495                          * it makes assumptions about how batching works.
496                          */
497                         if (ioc && ioc->nr_batch_requests > 0 &&
498                             time_before(jiffies, ioc->last_waited + HZ/50UL) &&
499                             (last_waited == 0 ||
500                              ioc->last_waited == last_waited)) {
501                                 /*
502                                  * we want to go through our batch of
503                                  * requests and stop.  So, we copy out
504                                  * the ioc->last_waited time and test
505                                  * against it before looping
506                                  */
507                                 last_waited = ioc->last_waited;
508                                 cond_resched();
509                                 continue;
510                         }
511                         spin_lock(&device->io_lock);
512                         requeue_list(pending_bios, pending, tail);
513                         device->running_pending = 1;
514
515                         spin_unlock(&device->io_lock);
516                         btrfs_queue_work(fs_info->submit_workers,
517                                          &device->work);
518                         goto done;
519                 }
520                 /* unplug every 64 requests just for good measure */
521                 if (batch_run % 64 == 0) {
522                         blk_finish_plug(&plug);
523                         blk_start_plug(&plug);
524                         sync_pending = 0;
525                 }
526         }
527
528         cond_resched();
529         if (again)
530                 goto loop;
531
532         spin_lock(&device->io_lock);
533         if (device->pending_bios.head || device->pending_sync_bios.head)
534                 goto loop_lock;
535         spin_unlock(&device->io_lock);
536
537 done:
538         blk_finish_plug(&plug);
539 }
540
541 static void pending_bios_fn(struct btrfs_work *work)
542 {
543         struct btrfs_device *device;
544
545         device = container_of(work, struct btrfs_device, work);
546         run_scheduled_bios(device);
547 }
548
549
550 void btrfs_free_stale_device(struct btrfs_device *cur_dev)
551 {
552         struct btrfs_fs_devices *fs_devs;
553         struct btrfs_device *dev;
554
555         if (!cur_dev->name)
556                 return;
557
558         list_for_each_entry(fs_devs, &fs_uuids, list) {
559                 int del = 1;
560
561                 if (fs_devs->opened)
562                         continue;
563                 if (fs_devs->seeding)
564                         continue;
565
566                 list_for_each_entry(dev, &fs_devs->devices, dev_list) {
567
568                         if (dev == cur_dev)
569                                 continue;
570                         if (!dev->name)
571                                 continue;
572
573                         /*
574                          * Todo: This won't be enough. What if the same device
575                          * comes back (with new uuid and) with its mapper path?
576                          * But for now, this does help as mostly an admin will
577                          * either use mapper or non mapper path throughout.
578                          */
579                         rcu_read_lock();
580                         del = strcmp(rcu_str_deref(dev->name),
581                                                 rcu_str_deref(cur_dev->name));
582                         rcu_read_unlock();
583                         if (!del)
584                                 break;
585                 }
586
587                 if (!del) {
588                         /* delete the stale device */
589                         if (fs_devs->num_devices == 1) {
590                                 btrfs_sysfs_remove_fsid(fs_devs);
591                                 list_del(&fs_devs->list);
592                                 free_fs_devices(fs_devs);
593                         } else {
594                                 fs_devs->num_devices--;
595                                 list_del(&dev->dev_list);
596                                 rcu_string_free(dev->name);
597                                 kfree(dev);
598                         }
599                         break;
600                 }
601         }
602 }
603
604 /*
605  * Add new device to list of registered devices
606  *
607  * Returns:
608  * 1   - first time device is seen
609  * 0   - device already known
610  * < 0 - error
611  */
612 static noinline int device_list_add(const char *path,
613                            struct btrfs_super_block *disk_super,
614                            u64 devid, struct btrfs_fs_devices **fs_devices_ret)
615 {
616         struct btrfs_device *device;
617         struct btrfs_fs_devices *fs_devices;
618         struct rcu_string *name;
619         int ret = 0;
620         u64 found_transid = btrfs_super_generation(disk_super);
621
622         fs_devices = find_fsid(disk_super->fsid);
623         if (!fs_devices) {
624                 fs_devices = alloc_fs_devices(disk_super->fsid);
625                 if (IS_ERR(fs_devices))
626                         return PTR_ERR(fs_devices);
627
628                 list_add(&fs_devices->list, &fs_uuids);
629
630                 device = NULL;
631         } else {
632                 device = find_device(fs_devices, devid,
633                                 disk_super->dev_item.uuid);
634         }
635
636         if (!device) {
637                 if (fs_devices->opened)
638                         return -EBUSY;
639
640                 device = btrfs_alloc_device(NULL, &devid,
641                                             disk_super->dev_item.uuid);
642                 if (IS_ERR(device)) {
643                         /* we can safely leave the fs_devices entry around */
644                         return PTR_ERR(device);
645                 }
646
647                 name = rcu_string_strdup(path, GFP_NOFS);
648                 if (!name) {
649                         kfree(device);
650                         return -ENOMEM;
651                 }
652                 rcu_assign_pointer(device->name, name);
653
654                 mutex_lock(&fs_devices->device_list_mutex);
655                 list_add_rcu(&device->dev_list, &fs_devices->devices);
656                 fs_devices->num_devices++;
657                 mutex_unlock(&fs_devices->device_list_mutex);
658
659                 ret = 1;
660                 device->fs_devices = fs_devices;
661         } else if (!device->name || strcmp(device->name->str, path)) {
662                 /*
663                  * When FS is already mounted.
664                  * 1. If you are here and if the device->name is NULL that
665                  *    means this device was missing at time of FS mount.
666                  * 2. If you are here and if the device->name is different
667                  *    from 'path' that means either
668                  *      a. The same device disappeared and reappeared with
669                  *         different name. or
670                  *      b. The missing-disk-which-was-replaced, has
671                  *         reappeared now.
672                  *
673                  * We must allow 1 and 2a above. But 2b would be a spurious
674                  * and unintentional.
675                  *
676                  * Further in case of 1 and 2a above, the disk at 'path'
677                  * would have missed some transaction when it was away and
678                  * in case of 2a the stale bdev has to be updated as well.
679                  * 2b must not be allowed at all time.
680                  */
681
682                 /*
683                  * For now, we do allow update to btrfs_fs_device through the
684                  * btrfs dev scan cli after FS has been mounted.  We're still
685                  * tracking a problem where systems fail mount by subvolume id
686                  * when we reject replacement on a mounted FS.
687                  */
688                 if (!fs_devices->opened && found_transid < device->generation) {
689                         /*
690                          * That is if the FS is _not_ mounted and if you
691                          * are here, that means there is more than one
692                          * disk with same uuid and devid.We keep the one
693                          * with larger generation number or the last-in if
694                          * generation are equal.
695                          */
696                         return -EEXIST;
697                 }
698
699                 name = rcu_string_strdup(path, GFP_NOFS);
700                 if (!name)
701                         return -ENOMEM;
702                 rcu_string_free(device->name);
703                 rcu_assign_pointer(device->name, name);
704                 if (device->missing) {
705                         fs_devices->missing_devices--;
706                         device->missing = 0;
707                 }
708         }
709
710         /*
711          * Unmount does not free the btrfs_device struct but would zero
712          * generation along with most of the other members. So just update
713          * it back. We need it to pick the disk with largest generation
714          * (as above).
715          */
716         if (!fs_devices->opened)
717                 device->generation = found_transid;
718
719         /*
720          * if there is new btrfs on an already registered device,
721          * then remove the stale device entry.
722          */
723         if (ret > 0)
724                 btrfs_free_stale_device(device);
725
726         *fs_devices_ret = fs_devices;
727
728         return ret;
729 }
730
731 static struct btrfs_fs_devices *clone_fs_devices(struct btrfs_fs_devices *orig)
732 {
733         struct btrfs_fs_devices *fs_devices;
734         struct btrfs_device *device;
735         struct btrfs_device *orig_dev;
736
737         fs_devices = alloc_fs_devices(orig->fsid);
738         if (IS_ERR(fs_devices))
739                 return fs_devices;
740
741         mutex_lock(&orig->device_list_mutex);
742         fs_devices->total_devices = orig->total_devices;
743
744         /* We have held the volume lock, it is safe to get the devices. */
745         list_for_each_entry(orig_dev, &orig->devices, dev_list) {
746                 struct rcu_string *name;
747
748                 device = btrfs_alloc_device(NULL, &orig_dev->devid,
749                                             orig_dev->uuid);
750                 if (IS_ERR(device))
751                         goto error;
752
753                 /*
754                  * This is ok to do without rcu read locked because we hold the
755                  * uuid mutex so nothing we touch in here is going to disappear.
756                  */
757                 if (orig_dev->name) {
758                         name = rcu_string_strdup(orig_dev->name->str,
759                                         GFP_KERNEL);
760                         if (!name) {
761                                 kfree(device);
762                                 goto error;
763                         }
764                         rcu_assign_pointer(device->name, name);
765                 }
766
767                 list_add(&device->dev_list, &fs_devices->devices);
768                 device->fs_devices = fs_devices;
769                 fs_devices->num_devices++;
770         }
771         mutex_unlock(&orig->device_list_mutex);
772         return fs_devices;
773 error:
774         mutex_unlock(&orig->device_list_mutex);
775         free_fs_devices(fs_devices);
776         return ERR_PTR(-ENOMEM);
777 }
778
779 void btrfs_close_extra_devices(struct btrfs_fs_devices *fs_devices, int step)
780 {
781         struct btrfs_device *device, *next;
782         struct btrfs_device *latest_dev = NULL;
783
784         mutex_lock(&uuid_mutex);
785 again:
786         /* This is the initialized path, it is safe to release the devices. */
787         list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) {
788                 if (device->in_fs_metadata) {
789                         if (!device->is_tgtdev_for_dev_replace &&
790                             (!latest_dev ||
791                              device->generation > latest_dev->generation)) {
792                                 latest_dev = device;
793                         }
794                         continue;
795                 }
796
797                 if (device->devid == BTRFS_DEV_REPLACE_DEVID) {
798                         /*
799                          * In the first step, keep the device which has
800                          * the correct fsid and the devid that is used
801                          * for the dev_replace procedure.
802                          * In the second step, the dev_replace state is
803                          * read from the device tree and it is known
804                          * whether the procedure is really active or
805                          * not, which means whether this device is
806                          * used or whether it should be removed.
807                          */
808                         if (step == 0 || device->is_tgtdev_for_dev_replace) {
809                                 continue;
810                         }
811                 }
812                 if (device->bdev) {
813                         blkdev_put(device->bdev, device->mode);
814                         device->bdev = NULL;
815                         fs_devices->open_devices--;
816                 }
817                 if (device->writeable) {
818                         list_del_init(&device->dev_alloc_list);
819                         device->writeable = 0;
820                         if (!device->is_tgtdev_for_dev_replace)
821                                 fs_devices->rw_devices--;
822                 }
823                 list_del_init(&device->dev_list);
824                 fs_devices->num_devices--;
825                 rcu_string_free(device->name);
826                 kfree(device);
827         }
828
829         if (fs_devices->seed) {
830                 fs_devices = fs_devices->seed;
831                 goto again;
832         }
833
834         fs_devices->latest_bdev = latest_dev->bdev;
835
836         mutex_unlock(&uuid_mutex);
837 }
838
839 static void __free_device(struct work_struct *work)
840 {
841         struct btrfs_device *device;
842
843         device = container_of(work, struct btrfs_device, rcu_work);
844         rcu_string_free(device->name);
845         bio_put(device->flush_bio);
846         kfree(device);
847 }
848
849 static void free_device(struct rcu_head *head)
850 {
851         struct btrfs_device *device;
852
853         device = container_of(head, struct btrfs_device, rcu);
854
855         INIT_WORK(&device->rcu_work, __free_device);
856         schedule_work(&device->rcu_work);
857 }
858
859 static void btrfs_close_bdev(struct btrfs_device *device)
860 {
861         if (device->bdev && device->writeable) {
862                 sync_blockdev(device->bdev);
863                 invalidate_bdev(device->bdev);
864         }
865
866         if (device->bdev)
867                 blkdev_put(device->bdev, device->mode);
868 }
869
870 static void btrfs_prepare_close_one_device(struct btrfs_device *device)
871 {
872         struct btrfs_fs_devices *fs_devices = device->fs_devices;
873         struct btrfs_device *new_device;
874         struct rcu_string *name;
875
876         if (device->bdev)
877                 fs_devices->open_devices--;
878
879         if (device->writeable &&
880             device->devid != BTRFS_DEV_REPLACE_DEVID) {
881                 list_del_init(&device->dev_alloc_list);
882                 fs_devices->rw_devices--;
883         }
884
885         if (device->missing)
886                 fs_devices->missing_devices--;
887
888         new_device = btrfs_alloc_device(NULL, &device->devid,
889                                         device->uuid);
890         BUG_ON(IS_ERR(new_device)); /* -ENOMEM */
891
892         /* Safe because we are under uuid_mutex */
893         if (device->name) {
894                 name = rcu_string_strdup(device->name->str, GFP_NOFS);
895                 BUG_ON(!name); /* -ENOMEM */
896                 rcu_assign_pointer(new_device->name, name);
897         }
898
899         list_replace_rcu(&device->dev_list, &new_device->dev_list);
900         new_device->fs_devices = device->fs_devices;
901 }
902
903 static int __btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
904 {
905         struct btrfs_device *device, *tmp;
906         struct list_head pending_put;
907
908         INIT_LIST_HEAD(&pending_put);
909
910         if (--fs_devices->opened > 0)
911                 return 0;
912
913         mutex_lock(&fs_devices->device_list_mutex);
914         list_for_each_entry_safe(device, tmp, &fs_devices->devices, dev_list) {
915                 btrfs_prepare_close_one_device(device);
916                 list_add(&device->dev_list, &pending_put);
917         }
918         mutex_unlock(&fs_devices->device_list_mutex);
919
920         /*
921          * btrfs_show_devname() is using the device_list_mutex,
922          * sometimes call to blkdev_put() leads vfs calling
923          * into this func. So do put outside of device_list_mutex,
924          * as of now.
925          */
926         while (!list_empty(&pending_put)) {
927                 device = list_first_entry(&pending_put,
928                                 struct btrfs_device, dev_list);
929                 list_del(&device->dev_list);
930                 btrfs_close_bdev(device);
931                 call_rcu(&device->rcu, free_device);
932         }
933
934         WARN_ON(fs_devices->open_devices);
935         WARN_ON(fs_devices->rw_devices);
936         fs_devices->opened = 0;
937         fs_devices->seeding = 0;
938
939         return 0;
940 }
941
942 int btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
943 {
944         struct btrfs_fs_devices *seed_devices = NULL;
945         int ret;
946
947         mutex_lock(&uuid_mutex);
948         ret = __btrfs_close_devices(fs_devices);
949         if (!fs_devices->opened) {
950                 seed_devices = fs_devices->seed;
951                 fs_devices->seed = NULL;
952         }
953         mutex_unlock(&uuid_mutex);
954
955         while (seed_devices) {
956                 fs_devices = seed_devices;
957                 seed_devices = fs_devices->seed;
958                 __btrfs_close_devices(fs_devices);
959                 free_fs_devices(fs_devices);
960         }
961         /*
962          * Wait for rcu kworkers under __btrfs_close_devices
963          * to finish all blkdev_puts so device is really
964          * free when umount is done.
965          */
966         rcu_barrier();
967         return ret;
968 }
969
970 static int __btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
971                                 fmode_t flags, void *holder)
972 {
973         struct request_queue *q;
974         struct block_device *bdev;
975         struct list_head *head = &fs_devices->devices;
976         struct btrfs_device *device;
977         struct btrfs_device *latest_dev = NULL;
978         struct buffer_head *bh;
979         struct btrfs_super_block *disk_super;
980         u64 devid;
981         int seeding = 1;
982         int ret = 0;
983
984         flags |= FMODE_EXCL;
985
986         list_for_each_entry(device, head, dev_list) {
987                 if (device->bdev)
988                         continue;
989                 if (!device->name)
990                         continue;
991
992                 /* Just open everything we can; ignore failures here */
993                 if (btrfs_get_bdev_and_sb(device->name->str, flags, holder, 1,
994                                             &bdev, &bh))
995                         continue;
996
997                 disk_super = (struct btrfs_super_block *)bh->b_data;
998                 devid = btrfs_stack_device_id(&disk_super->dev_item);
999                 if (devid != device->devid)
1000                         goto error_brelse;
1001
1002                 if (memcmp(device->uuid, disk_super->dev_item.uuid,
1003                            BTRFS_UUID_SIZE))
1004                         goto error_brelse;
1005
1006                 device->generation = btrfs_super_generation(disk_super);
1007                 if (!latest_dev ||
1008                     device->generation > latest_dev->generation)
1009                         latest_dev = device;
1010
1011                 if (btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_SEEDING) {
1012                         device->writeable = 0;
1013                 } else {
1014                         device->writeable = !bdev_read_only(bdev);
1015                         seeding = 0;
1016                 }
1017
1018                 q = bdev_get_queue(bdev);
1019                 if (blk_queue_discard(q))
1020                         device->can_discard = 1;
1021                 if (!blk_queue_nonrot(q))
1022                         fs_devices->rotating = 1;
1023
1024                 device->bdev = bdev;
1025                 device->in_fs_metadata = 0;
1026                 device->mode = flags;
1027
1028                 fs_devices->open_devices++;
1029                 if (device->writeable &&
1030                     device->devid != BTRFS_DEV_REPLACE_DEVID) {
1031                         fs_devices->rw_devices++;
1032                         list_add(&device->dev_alloc_list,
1033                                  &fs_devices->alloc_list);
1034                 }
1035                 brelse(bh);
1036                 continue;
1037
1038 error_brelse:
1039                 brelse(bh);
1040                 blkdev_put(bdev, flags);
1041                 continue;
1042         }
1043         if (fs_devices->open_devices == 0) {
1044                 ret = -EINVAL;
1045                 goto out;
1046         }
1047         fs_devices->seeding = seeding;
1048         fs_devices->opened = 1;
1049         fs_devices->latest_bdev = latest_dev->bdev;
1050         fs_devices->total_rw_bytes = 0;
1051 out:
1052         return ret;
1053 }
1054
1055 int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
1056                        fmode_t flags, void *holder)
1057 {
1058         int ret;
1059
1060         mutex_lock(&uuid_mutex);
1061         if (fs_devices->opened) {
1062                 fs_devices->opened++;
1063                 ret = 0;
1064         } else {
1065                 ret = __btrfs_open_devices(fs_devices, flags, holder);
1066         }
1067         mutex_unlock(&uuid_mutex);
1068         return ret;
1069 }
1070
1071 void btrfs_release_disk_super(struct page *page)
1072 {
1073         kunmap(page);
1074         put_page(page);
1075 }
1076
1077 int btrfs_read_disk_super(struct block_device *bdev, u64 bytenr,
1078                 struct page **page, struct btrfs_super_block **disk_super)
1079 {
1080         void *p;
1081         pgoff_t index;
1082
1083         /* make sure our super fits in the device */
1084         if (bytenr + PAGE_SIZE >= i_size_read(bdev->bd_inode))
1085                 return 1;
1086
1087         /* make sure our super fits in the page */
1088         if (sizeof(**disk_super) > PAGE_SIZE)
1089                 return 1;
1090
1091         /* make sure our super doesn't straddle pages on disk */
1092         index = bytenr >> PAGE_SHIFT;
1093         if ((bytenr + sizeof(**disk_super) - 1) >> PAGE_SHIFT != index)
1094                 return 1;
1095
1096         /* pull in the page with our super */
1097         *page = read_cache_page_gfp(bdev->bd_inode->i_mapping,
1098                                    index, GFP_KERNEL);
1099
1100         if (IS_ERR_OR_NULL(*page))
1101                 return 1;
1102
1103         p = kmap(*page);
1104
1105         /* align our pointer to the offset of the super block */
1106         *disk_super = p + (bytenr & ~PAGE_MASK);
1107
1108         if (btrfs_super_bytenr(*disk_super) != bytenr ||
1109             btrfs_super_magic(*disk_super) != BTRFS_MAGIC) {
1110                 btrfs_release_disk_super(*page);
1111                 return 1;
1112         }
1113
1114         if ((*disk_super)->label[0] &&
1115                 (*disk_super)->label[BTRFS_LABEL_SIZE - 1])
1116                 (*disk_super)->label[BTRFS_LABEL_SIZE - 1] = '\0';
1117
1118         return 0;
1119 }
1120
1121 /*
1122  * Look for a btrfs signature on a device. This may be called out of the mount path
1123  * and we are not allowed to call set_blocksize during the scan. The superblock
1124  * is read via pagecache
1125  */
1126 int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
1127                           struct btrfs_fs_devices **fs_devices_ret)
1128 {
1129         struct btrfs_super_block *disk_super;
1130         struct block_device *bdev;
1131         struct page *page;
1132         int ret = -EINVAL;
1133         u64 devid;
1134         u64 transid;
1135         u64 total_devices;
1136         u64 bytenr;
1137
1138         /*
1139          * we would like to check all the supers, but that would make
1140          * a btrfs mount succeed after a mkfs from a different FS.
1141          * So, we need to add a special mount option to scan for
1142          * later supers, using BTRFS_SUPER_MIRROR_MAX instead
1143          */
1144         bytenr = btrfs_sb_offset(0);
1145         flags |= FMODE_EXCL;
1146         mutex_lock(&uuid_mutex);
1147
1148         bdev = blkdev_get_by_path(path, flags, holder);
1149         if (IS_ERR(bdev)) {
1150                 ret = PTR_ERR(bdev);
1151                 goto error;
1152         }
1153
1154         if (btrfs_read_disk_super(bdev, bytenr, &page, &disk_super))
1155                 goto error_bdev_put;
1156
1157         devid = btrfs_stack_device_id(&disk_super->dev_item);
1158         transid = btrfs_super_generation(disk_super);
1159         total_devices = btrfs_super_num_devices(disk_super);
1160
1161         ret = device_list_add(path, disk_super, devid, fs_devices_ret);
1162         if (ret > 0) {
1163                 if (disk_super->label[0]) {
1164                         pr_info("BTRFS: device label %s ", disk_super->label);
1165                 } else {
1166                         pr_info("BTRFS: device fsid %pU ", disk_super->fsid);
1167                 }
1168
1169                 pr_cont("devid %llu transid %llu %s\n", devid, transid, path);
1170                 ret = 0;
1171         }
1172         if (!ret && fs_devices_ret)
1173                 (*fs_devices_ret)->total_devices = total_devices;
1174
1175         btrfs_release_disk_super(page);
1176
1177 error_bdev_put:
1178         blkdev_put(bdev, flags);
1179 error:
1180         mutex_unlock(&uuid_mutex);
1181         return ret;
1182 }
1183
1184 /* helper to account the used device space in the range */
1185 int btrfs_account_dev_extents_size(struct btrfs_device *device, u64 start,
1186                                    u64 end, u64 *length)
1187 {
1188         struct btrfs_key key;
1189         struct btrfs_root *root = device->fs_info->dev_root;
1190         struct btrfs_dev_extent *dev_extent;
1191         struct btrfs_path *path;
1192         u64 extent_end;
1193         int ret;
1194         int slot;
1195         struct extent_buffer *l;
1196
1197         *length = 0;
1198
1199         if (start >= device->total_bytes || device->is_tgtdev_for_dev_replace)
1200                 return 0;
1201
1202         path = btrfs_alloc_path();
1203         if (!path)
1204                 return -ENOMEM;
1205         path->reada = READA_FORWARD;
1206
1207         key.objectid = device->devid;
1208         key.offset = start;
1209         key.type = BTRFS_DEV_EXTENT_KEY;
1210
1211         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1212         if (ret < 0)
1213                 goto out;
1214         if (ret > 0) {
1215                 ret = btrfs_previous_item(root, path, key.objectid, key.type);
1216                 if (ret < 0)
1217                         goto out;
1218         }
1219
1220         while (1) {
1221                 l = path->nodes[0];
1222                 slot = path->slots[0];
1223                 if (slot >= btrfs_header_nritems(l)) {
1224                         ret = btrfs_next_leaf(root, path);
1225                         if (ret == 0)
1226                                 continue;
1227                         if (ret < 0)
1228                                 goto out;
1229
1230                         break;
1231                 }
1232                 btrfs_item_key_to_cpu(l, &key, slot);
1233
1234                 if (key.objectid < device->devid)
1235                         goto next;
1236
1237                 if (key.objectid > device->devid)
1238                         break;
1239
1240                 if (key.type != BTRFS_DEV_EXTENT_KEY)
1241                         goto next;
1242
1243                 dev_extent = btrfs_item_ptr(l, slot, struct btrfs_dev_extent);
1244                 extent_end = key.offset + btrfs_dev_extent_length(l,
1245                                                                   dev_extent);
1246                 if (key.offset <= start && extent_end > end) {
1247                         *length = end - start + 1;
1248                         break;
1249                 } else if (key.offset <= start && extent_end > start)
1250                         *length += extent_end - start;
1251                 else if (key.offset > start && extent_end <= end)
1252                         *length += extent_end - key.offset;
1253                 else if (key.offset > start && key.offset <= end) {
1254                         *length += end - key.offset + 1;
1255                         break;
1256                 } else if (key.offset > end)
1257                         break;
1258
1259 next:
1260                 path->slots[0]++;
1261         }
1262         ret = 0;
1263 out:
1264         btrfs_free_path(path);
1265         return ret;
1266 }
1267
1268 static int contains_pending_extent(struct btrfs_transaction *transaction,
1269                                    struct btrfs_device *device,
1270                                    u64 *start, u64 len)
1271 {
1272         struct btrfs_fs_info *fs_info = device->fs_info;
1273         struct extent_map *em;
1274         struct list_head *search_list = &fs_info->pinned_chunks;
1275         int ret = 0;
1276         u64 physical_start = *start;
1277
1278         if (transaction)
1279                 search_list = &transaction->pending_chunks;
1280 again:
1281         list_for_each_entry(em, search_list, list) {
1282                 struct map_lookup *map;
1283                 int i;
1284
1285                 map = em->map_lookup;
1286                 for (i = 0; i < map->num_stripes; i++) {
1287                         u64 end;
1288
1289                         if (map->stripes[i].dev != device)
1290                                 continue;
1291                         if (map->stripes[i].physical >= physical_start + len ||
1292                             map->stripes[i].physical + em->orig_block_len <=
1293                             physical_start)
1294                                 continue;
1295                         /*
1296                          * Make sure that while processing the pinned list we do
1297                          * not override our *start with a lower value, because
1298                          * we can have pinned chunks that fall within this
1299                          * device hole and that have lower physical addresses
1300                          * than the pending chunks we processed before. If we
1301                          * do not take this special care we can end up getting
1302                          * 2 pending chunks that start at the same physical
1303                          * device offsets because the end offset of a pinned
1304                          * chunk can be equal to the start offset of some
1305                          * pending chunk.
1306                          */
1307                         end = map->stripes[i].physical + em->orig_block_len;
1308                         if (end > *start) {
1309                                 *start = end;
1310                                 ret = 1;
1311                         }
1312                 }
1313         }
1314         if (search_list != &fs_info->pinned_chunks) {
1315                 search_list = &fs_info->pinned_chunks;
1316                 goto again;
1317         }
1318
1319         return ret;
1320 }
1321
1322
1323 /*
1324  * find_free_dev_extent_start - find free space in the specified device
1325  * @device:       the device which we search the free space in
1326  * @num_bytes:    the size of the free space that we need
1327  * @search_start: the position from which to begin the search
1328  * @start:        store the start of the free space.
1329  * @len:          the size of the free space. that we find, or the size
1330  *                of the max free space if we don't find suitable free space
1331  *
1332  * this uses a pretty simple search, the expectation is that it is
1333  * called very infrequently and that a given device has a small number
1334  * of extents
1335  *
1336  * @start is used to store the start of the free space if we find. But if we
1337  * don't find suitable free space, it will be used to store the start position
1338  * of the max free space.
1339  *
1340  * @len is used to store the size of the free space that we find.
1341  * But if we don't find suitable free space, it is used to store the size of
1342  * the max free space.
1343  */
1344 int find_free_dev_extent_start(struct btrfs_transaction *transaction,
1345                                struct btrfs_device *device, u64 num_bytes,
1346                                u64 search_start, u64 *start, u64 *len)
1347 {
1348         struct btrfs_fs_info *fs_info = device->fs_info;
1349         struct btrfs_root *root = fs_info->dev_root;
1350         struct btrfs_key key;
1351         struct btrfs_dev_extent *dev_extent;
1352         struct btrfs_path *path;
1353         u64 hole_size;
1354         u64 max_hole_start;
1355         u64 max_hole_size;
1356         u64 extent_end;
1357         u64 search_end = device->total_bytes;
1358         int ret;
1359         int slot;
1360         struct extent_buffer *l;
1361
1362         /*
1363          * We don't want to overwrite the superblock on the drive nor any area
1364          * used by the boot loader (grub for example), so we make sure to start
1365          * at an offset of at least 1MB.
1366          */
1367         search_start = max_t(u64, search_start, SZ_1M);
1368
1369         path = btrfs_alloc_path();
1370         if (!path)
1371                 return -ENOMEM;
1372
1373         max_hole_start = search_start;
1374         max_hole_size = 0;
1375
1376 again:
1377         if (search_start >= search_end || device->is_tgtdev_for_dev_replace) {
1378                 ret = -ENOSPC;
1379                 goto out;
1380         }
1381
1382         path->reada = READA_FORWARD;
1383         path->search_commit_root = 1;
1384         path->skip_locking = 1;
1385
1386         key.objectid = device->devid;
1387         key.offset = search_start;
1388         key.type = BTRFS_DEV_EXTENT_KEY;
1389
1390         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1391         if (ret < 0)
1392                 goto out;
1393         if (ret > 0) {
1394                 ret = btrfs_previous_item(root, path, key.objectid, key.type);
1395                 if (ret < 0)
1396                         goto out;
1397         }
1398
1399         while (1) {
1400                 l = path->nodes[0];
1401                 slot = path->slots[0];
1402                 if (slot >= btrfs_header_nritems(l)) {
1403                         ret = btrfs_next_leaf(root, path);
1404                         if (ret == 0)
1405                                 continue;
1406                         if (ret < 0)
1407                                 goto out;
1408
1409                         break;
1410                 }
1411                 btrfs_item_key_to_cpu(l, &key, slot);
1412
1413                 if (key.objectid < device->devid)
1414                         goto next;
1415
1416                 if (key.objectid > device->devid)
1417                         break;
1418
1419                 if (key.type != BTRFS_DEV_EXTENT_KEY)
1420                         goto next;
1421
1422                 if (key.offset > search_start) {
1423                         hole_size = key.offset - search_start;
1424
1425                         /*
1426                          * Have to check before we set max_hole_start, otherwise
1427                          * we could end up sending back this offset anyway.
1428                          */
1429                         if (contains_pending_extent(transaction, device,
1430                                                     &search_start,
1431                                                     hole_size)) {
1432                                 if (key.offset >= search_start) {
1433                                         hole_size = key.offset - search_start;
1434                                 } else {
1435                                         WARN_ON_ONCE(1);
1436                                         hole_size = 0;
1437                                 }
1438                         }
1439
1440                         if (hole_size > max_hole_size) {
1441                                 max_hole_start = search_start;
1442                                 max_hole_size = hole_size;
1443                         }
1444
1445                         /*
1446                          * If this free space is greater than which we need,
1447                          * it must be the max free space that we have found
1448                          * until now, so max_hole_start must point to the start
1449                          * of this free space and the length of this free space
1450                          * is stored in max_hole_size. Thus, we return
1451                          * max_hole_start and max_hole_size and go back to the
1452                          * caller.
1453                          */
1454                         if (hole_size >= num_bytes) {
1455                                 ret = 0;
1456                                 goto out;
1457                         }
1458                 }
1459
1460                 dev_extent = btrfs_item_ptr(l, slot, struct btrfs_dev_extent);
1461                 extent_end = key.offset + btrfs_dev_extent_length(l,
1462                                                                   dev_extent);
1463                 if (extent_end > search_start)
1464                         search_start = extent_end;
1465 next:
1466                 path->slots[0]++;
1467                 cond_resched();
1468         }
1469
1470         /*
1471          * At this point, search_start should be the end of
1472          * allocated dev extents, and when shrinking the device,
1473          * search_end may be smaller than search_start.
1474          */
1475         if (search_end > search_start) {
1476                 hole_size = search_end - search_start;
1477
1478                 if (contains_pending_extent(transaction, device, &search_start,
1479                                             hole_size)) {
1480                         btrfs_release_path(path);
1481                         goto again;
1482                 }
1483
1484                 if (hole_size > max_hole_size) {
1485                         max_hole_start = search_start;
1486                         max_hole_size = hole_size;
1487                 }
1488         }
1489
1490         /* See above. */
1491         if (max_hole_size < num_bytes)
1492                 ret = -ENOSPC;
1493         else
1494                 ret = 0;
1495
1496 out:
1497         btrfs_free_path(path);
1498         *start = max_hole_start;
1499         if (len)
1500                 *len = max_hole_size;
1501         return ret;
1502 }
1503
1504 int find_free_dev_extent(struct btrfs_trans_handle *trans,
1505                          struct btrfs_device *device, u64 num_bytes,
1506                          u64 *start, u64 *len)
1507 {
1508         /* FIXME use last free of some kind */
1509         return find_free_dev_extent_start(trans->transaction, device,
1510                                           num_bytes, 0, start, len);
1511 }
1512
1513 static int btrfs_free_dev_extent(struct btrfs_trans_handle *trans,
1514                           struct btrfs_device *device,
1515                           u64 start, u64 *dev_extent_len)
1516 {
1517         struct btrfs_fs_info *fs_info = device->fs_info;
1518         struct btrfs_root *root = fs_info->dev_root;
1519         int ret;
1520         struct btrfs_path *path;
1521         struct btrfs_key key;
1522         struct btrfs_key found_key;
1523         struct extent_buffer *leaf = NULL;
1524         struct btrfs_dev_extent *extent = NULL;
1525
1526         path = btrfs_alloc_path();
1527         if (!path)
1528                 return -ENOMEM;
1529
1530         key.objectid = device->devid;
1531         key.offset = start;
1532         key.type = BTRFS_DEV_EXTENT_KEY;
1533 again:
1534         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1535         if (ret > 0) {
1536                 ret = btrfs_previous_item(root, path, key.objectid,
1537                                           BTRFS_DEV_EXTENT_KEY);
1538                 if (ret)
1539                         goto out;
1540                 leaf = path->nodes[0];
1541                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
1542                 extent = btrfs_item_ptr(leaf, path->slots[0],
1543                                         struct btrfs_dev_extent);
1544                 BUG_ON(found_key.offset > start || found_key.offset +
1545                        btrfs_dev_extent_length(leaf, extent) < start);
1546                 key = found_key;
1547                 btrfs_release_path(path);
1548                 goto again;
1549         } else if (ret == 0) {
1550                 leaf = path->nodes[0];
1551                 extent = btrfs_item_ptr(leaf, path->slots[0],
1552                                         struct btrfs_dev_extent);
1553         } else {
1554                 btrfs_handle_fs_error(fs_info, ret, "Slot search failed");
1555                 goto out;
1556         }
1557
1558         *dev_extent_len = btrfs_dev_extent_length(leaf, extent);
1559
1560         ret = btrfs_del_item(trans, root, path);
1561         if (ret) {
1562                 btrfs_handle_fs_error(fs_info, ret,
1563                                       "Failed to remove dev extent item");
1564         } else {
1565                 set_bit(BTRFS_TRANS_HAVE_FREE_BGS, &trans->transaction->flags);
1566         }
1567 out:
1568         btrfs_free_path(path);
1569         return ret;
1570 }
1571
1572 static int btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans,
1573                                   struct btrfs_device *device,
1574                                   u64 chunk_offset, u64 start, u64 num_bytes)
1575 {
1576         int ret;
1577         struct btrfs_path *path;
1578         struct btrfs_fs_info *fs_info = device->fs_info;
1579         struct btrfs_root *root = fs_info->dev_root;
1580         struct btrfs_dev_extent *extent;
1581         struct extent_buffer *leaf;
1582         struct btrfs_key key;
1583
1584         WARN_ON(!device->in_fs_metadata);
1585         WARN_ON(device->is_tgtdev_for_dev_replace);
1586         path = btrfs_alloc_path();
1587         if (!path)
1588                 return -ENOMEM;
1589
1590         key.objectid = device->devid;
1591         key.offset = start;
1592         key.type = BTRFS_DEV_EXTENT_KEY;
1593         ret = btrfs_insert_empty_item(trans, root, path, &key,
1594                                       sizeof(*extent));
1595         if (ret)
1596                 goto out;
1597
1598         leaf = path->nodes[0];
1599         extent = btrfs_item_ptr(leaf, path->slots[0],
1600                                 struct btrfs_dev_extent);
1601         btrfs_set_dev_extent_chunk_tree(leaf, extent,
1602                                         BTRFS_CHUNK_TREE_OBJECTID);
1603         btrfs_set_dev_extent_chunk_objectid(leaf, extent,
1604                                             BTRFS_FIRST_CHUNK_TREE_OBJECTID);
1605         btrfs_set_dev_extent_chunk_offset(leaf, extent, chunk_offset);
1606
1607         btrfs_set_dev_extent_length(leaf, extent, num_bytes);
1608         btrfs_mark_buffer_dirty(leaf);
1609 out:
1610         btrfs_free_path(path);
1611         return ret;
1612 }
1613
1614 static u64 find_next_chunk(struct btrfs_fs_info *fs_info)
1615 {
1616         struct extent_map_tree *em_tree;
1617         struct extent_map *em;
1618         struct rb_node *n;
1619         u64 ret = 0;
1620
1621         em_tree = &fs_info->mapping_tree.map_tree;
1622         read_lock(&em_tree->lock);
1623         n = rb_last(&em_tree->map);
1624         if (n) {
1625                 em = rb_entry(n, struct extent_map, rb_node);
1626                 ret = em->start + em->len;
1627         }
1628         read_unlock(&em_tree->lock);
1629
1630         return ret;
1631 }
1632
1633 static noinline int find_next_devid(struct btrfs_fs_info *fs_info,
1634                                     u64 *devid_ret)
1635 {
1636         int ret;
1637         struct btrfs_key key;
1638         struct btrfs_key found_key;
1639         struct btrfs_path *path;
1640
1641         path = btrfs_alloc_path();
1642         if (!path)
1643                 return -ENOMEM;
1644
1645         key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
1646         key.type = BTRFS_DEV_ITEM_KEY;
1647         key.offset = (u64)-1;
1648
1649         ret = btrfs_search_slot(NULL, fs_info->chunk_root, &key, path, 0, 0);
1650         if (ret < 0)
1651                 goto error;
1652
1653         BUG_ON(ret == 0); /* Corruption */
1654
1655         ret = btrfs_previous_item(fs_info->chunk_root, path,
1656                                   BTRFS_DEV_ITEMS_OBJECTID,
1657                                   BTRFS_DEV_ITEM_KEY);
1658         if (ret) {
1659                 *devid_ret = 1;
1660         } else {
1661                 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
1662                                       path->slots[0]);
1663                 *devid_ret = found_key.offset + 1;
1664         }
1665         ret = 0;
1666 error:
1667         btrfs_free_path(path);
1668         return ret;
1669 }
1670
1671 /*
1672  * the device information is stored in the chunk root
1673  * the btrfs_device struct should be fully filled in
1674  */
1675 static int btrfs_add_device(struct btrfs_trans_handle *trans,
1676                             struct btrfs_fs_info *fs_info,
1677                             struct btrfs_device *device)
1678 {
1679         struct btrfs_root *root = fs_info->chunk_root;
1680         int ret;
1681         struct btrfs_path *path;
1682         struct btrfs_dev_item *dev_item;
1683         struct extent_buffer *leaf;
1684         struct btrfs_key key;
1685         unsigned long ptr;
1686
1687         path = btrfs_alloc_path();
1688         if (!path)
1689                 return -ENOMEM;
1690
1691         key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
1692         key.type = BTRFS_DEV_ITEM_KEY;
1693         key.offset = device->devid;
1694
1695         ret = btrfs_insert_empty_item(trans, root, path, &key,
1696                                       sizeof(*dev_item));
1697         if (ret)
1698                 goto out;
1699
1700         leaf = path->nodes[0];
1701         dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item);
1702
1703         btrfs_set_device_id(leaf, dev_item, device->devid);
1704         btrfs_set_device_generation(leaf, dev_item, 0);
1705         btrfs_set_device_type(leaf, dev_item, device->type);
1706         btrfs_set_device_io_align(leaf, dev_item, device->io_align);
1707         btrfs_set_device_io_width(leaf, dev_item, device->io_width);
1708         btrfs_set_device_sector_size(leaf, dev_item, device->sector_size);
1709         btrfs_set_device_total_bytes(leaf, dev_item,
1710                                      btrfs_device_get_disk_total_bytes(device));
1711         btrfs_set_device_bytes_used(leaf, dev_item,
1712                                     btrfs_device_get_bytes_used(device));
1713         btrfs_set_device_group(leaf, dev_item, 0);
1714         btrfs_set_device_seek_speed(leaf, dev_item, 0);
1715         btrfs_set_device_bandwidth(leaf, dev_item, 0);
1716         btrfs_set_device_start_offset(leaf, dev_item, 0);
1717
1718         ptr = btrfs_device_uuid(dev_item);
1719         write_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE);
1720         ptr = btrfs_device_fsid(dev_item);
1721         write_extent_buffer(leaf, fs_info->fsid, ptr, BTRFS_FSID_SIZE);
1722         btrfs_mark_buffer_dirty(leaf);
1723
1724         ret = 0;
1725 out:
1726         btrfs_free_path(path);
1727         return ret;
1728 }
1729
1730 /*
1731  * Function to update ctime/mtime for a given device path.
1732  * Mainly used for ctime/mtime based probe like libblkid.
1733  */
1734 static void update_dev_time(const char *path_name)
1735 {
1736         struct file *filp;
1737
1738         filp = filp_open(path_name, O_RDWR, 0);
1739         if (IS_ERR(filp))
1740                 return;
1741         file_update_time(filp);
1742         filp_close(filp, NULL);
1743 }
1744
1745 static int btrfs_rm_dev_item(struct btrfs_fs_info *fs_info,
1746                              struct btrfs_device *device)
1747 {
1748         struct btrfs_root *root = fs_info->chunk_root;
1749         int ret;
1750         struct btrfs_path *path;
1751         struct btrfs_key key;
1752         struct btrfs_trans_handle *trans;
1753
1754         path = btrfs_alloc_path();
1755         if (!path)
1756                 return -ENOMEM;
1757
1758         trans = btrfs_start_transaction(root, 0);
1759         if (IS_ERR(trans)) {
1760                 btrfs_free_path(path);
1761                 return PTR_ERR(trans);
1762         }
1763         key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
1764         key.type = BTRFS_DEV_ITEM_KEY;
1765         key.offset = device->devid;
1766
1767         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1768         if (ret < 0)
1769                 goto out;
1770
1771         if (ret > 0) {
1772                 ret = -ENOENT;
1773                 goto out;
1774         }
1775
1776         ret = btrfs_del_item(trans, root, path);
1777         if (ret)
1778                 goto out;
1779 out:
1780         btrfs_free_path(path);
1781         btrfs_commit_transaction(trans);
1782         return ret;
1783 }
1784
1785 /*
1786  * Verify that @num_devices satisfies the RAID profile constraints in the whole
1787  * filesystem. It's up to the caller to adjust that number regarding eg. device
1788  * replace.
1789  */
1790 static int btrfs_check_raid_min_devices(struct btrfs_fs_info *fs_info,
1791                 u64 num_devices)
1792 {
1793         u64 all_avail;
1794         unsigned seq;
1795         int i;
1796
1797         do {
1798                 seq = read_seqbegin(&fs_info->profiles_lock);
1799
1800                 all_avail = fs_info->avail_data_alloc_bits |
1801                             fs_info->avail_system_alloc_bits |
1802                             fs_info->avail_metadata_alloc_bits;
1803         } while (read_seqretry(&fs_info->profiles_lock, seq));
1804
1805         for (i = 0; i < BTRFS_NR_RAID_TYPES; i++) {
1806                 if (!(all_avail & btrfs_raid_group[i]))
1807                         continue;
1808
1809                 if (num_devices < btrfs_raid_array[i].devs_min) {
1810                         int ret = btrfs_raid_mindev_error[i];
1811
1812                         if (ret)
1813                                 return ret;
1814                 }
1815         }
1816
1817         return 0;
1818 }
1819
1820 struct btrfs_device *btrfs_find_next_active_device(struct btrfs_fs_devices *fs_devs,
1821                                         struct btrfs_device *device)
1822 {
1823         struct btrfs_device *next_device;
1824
1825         list_for_each_entry(next_device, &fs_devs->devices, dev_list) {
1826                 if (next_device != device &&
1827                         !next_device->missing && next_device->bdev)
1828                         return next_device;
1829         }
1830
1831         return NULL;
1832 }
1833
1834 /*
1835  * Helper function to check if the given device is part of s_bdev / latest_bdev
1836  * and replace it with the provided or the next active device, in the context
1837  * where this function called, there should be always be another device (or
1838  * this_dev) which is active.
1839  */
1840 void btrfs_assign_next_active_device(struct btrfs_fs_info *fs_info,
1841                 struct btrfs_device *device, struct btrfs_device *this_dev)
1842 {
1843         struct btrfs_device *next_device;
1844
1845         if (this_dev)
1846                 next_device = this_dev;
1847         else
1848                 next_device = btrfs_find_next_active_device(fs_info->fs_devices,
1849                                                                 device);
1850         ASSERT(next_device);
1851
1852         if (fs_info->sb->s_bdev &&
1853                         (fs_info->sb->s_bdev == device->bdev))
1854                 fs_info->sb->s_bdev = next_device->bdev;
1855
1856         if (fs_info->fs_devices->latest_bdev == device->bdev)
1857                 fs_info->fs_devices->latest_bdev = next_device->bdev;
1858 }
1859
1860 int btrfs_rm_device(struct btrfs_fs_info *fs_info, const char *device_path,
1861                 u64 devid)
1862 {
1863         struct btrfs_device *device;
1864         struct btrfs_fs_devices *cur_devices;
1865         u64 num_devices;
1866         int ret = 0;
1867
1868         mutex_lock(&uuid_mutex);
1869
1870         num_devices = fs_info->fs_devices->num_devices;
1871         btrfs_dev_replace_lock(&fs_info->dev_replace, 0);
1872         if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace)) {
1873                 WARN_ON(num_devices < 1);
1874                 num_devices--;
1875         }
1876         btrfs_dev_replace_unlock(&fs_info->dev_replace, 0);
1877
1878         ret = btrfs_check_raid_min_devices(fs_info, num_devices - 1);
1879         if (ret)
1880                 goto out;
1881
1882         ret = btrfs_find_device_by_devspec(fs_info, devid, device_path,
1883                                            &device);
1884         if (ret)
1885                 goto out;
1886
1887         if (device->is_tgtdev_for_dev_replace) {
1888                 ret = BTRFS_ERROR_DEV_TGT_REPLACE;
1889                 goto out;
1890         }
1891
1892         if (device->writeable && fs_info->fs_devices->rw_devices == 1) {
1893                 ret = BTRFS_ERROR_DEV_ONLY_WRITABLE;
1894                 goto out;
1895         }
1896
1897         if (device->writeable) {
1898                 mutex_lock(&fs_info->chunk_mutex);
1899                 list_del_init(&device->dev_alloc_list);
1900                 device->fs_devices->rw_devices--;
1901                 mutex_unlock(&fs_info->chunk_mutex);
1902         }
1903
1904         mutex_unlock(&uuid_mutex);
1905         ret = btrfs_shrink_device(device, 0);
1906         mutex_lock(&uuid_mutex);
1907         if (ret)
1908                 goto error_undo;
1909
1910         /*
1911          * TODO: the superblock still includes this device in its num_devices
1912          * counter although write_all_supers() is not locked out. This
1913          * could give a filesystem state which requires a degraded mount.
1914          */
1915         ret = btrfs_rm_dev_item(fs_info, device);
1916         if (ret)
1917                 goto error_undo;
1918
1919         device->in_fs_metadata = 0;
1920         btrfs_scrub_cancel_dev(fs_info, device);
1921
1922         /*
1923          * the device list mutex makes sure that we don't change
1924          * the device list while someone else is writing out all
1925          * the device supers. Whoever is writing all supers, should
1926          * lock the device list mutex before getting the number of
1927          * devices in the super block (super_copy). Conversely,
1928          * whoever updates the number of devices in the super block
1929          * (super_copy) should hold the device list mutex.
1930          */
1931
1932         cur_devices = device->fs_devices;
1933         mutex_lock(&fs_info->fs_devices->device_list_mutex);
1934         list_del_rcu(&device->dev_list);
1935
1936         device->fs_devices->num_devices--;
1937         device->fs_devices->total_devices--;
1938
1939         if (device->missing)
1940                 device->fs_devices->missing_devices--;
1941
1942         btrfs_assign_next_active_device(fs_info, device, NULL);
1943
1944         if (device->bdev) {
1945                 device->fs_devices->open_devices--;
1946                 /* remove sysfs entry */
1947                 btrfs_sysfs_rm_device_link(fs_info->fs_devices, device);
1948         }
1949
1950         num_devices = btrfs_super_num_devices(fs_info->super_copy) - 1;
1951         btrfs_set_super_num_devices(fs_info->super_copy, num_devices);
1952         mutex_unlock(&fs_info->fs_devices->device_list_mutex);
1953
1954         /*
1955          * at this point, the device is zero sized and detached from
1956          * the devices list.  All that's left is to zero out the old
1957          * supers and free the device.
1958          */
1959         if (device->writeable)
1960                 btrfs_scratch_superblocks(device->bdev, device->name->str);
1961
1962         btrfs_close_bdev(device);
1963         call_rcu(&device->rcu, free_device);
1964
1965         if (cur_devices->open_devices == 0) {
1966                 struct btrfs_fs_devices *fs_devices;
1967                 fs_devices = fs_info->fs_devices;
1968                 while (fs_devices) {
1969                         if (fs_devices->seed == cur_devices) {
1970                                 fs_devices->seed = cur_devices->seed;
1971                                 break;
1972                         }
1973                         fs_devices = fs_devices->seed;
1974                 }
1975                 cur_devices->seed = NULL;
1976                 __btrfs_close_devices(cur_devices);
1977                 free_fs_devices(cur_devices);
1978         }
1979
1980 out:
1981         mutex_unlock(&uuid_mutex);
1982         return ret;
1983
1984 error_undo:
1985         if (device->writeable) {
1986                 mutex_lock(&fs_info->chunk_mutex);
1987                 list_add(&device->dev_alloc_list,
1988                          &fs_info->fs_devices->alloc_list);
1989                 device->fs_devices->rw_devices++;
1990                 mutex_unlock(&fs_info->chunk_mutex);
1991         }
1992         goto out;
1993 }
1994
1995 void btrfs_rm_dev_replace_remove_srcdev(struct btrfs_fs_info *fs_info,
1996                                         struct btrfs_device *srcdev)
1997 {
1998         struct btrfs_fs_devices *fs_devices;
1999
2000         WARN_ON(!mutex_is_locked(&fs_info->fs_devices->device_list_mutex));
2001
2002         /*
2003          * in case of fs with no seed, srcdev->fs_devices will point
2004          * to fs_devices of fs_info. However when the dev being replaced is
2005          * a seed dev it will point to the seed's local fs_devices. In short
2006          * srcdev will have its correct fs_devices in both the cases.
2007          */
2008         fs_devices = srcdev->fs_devices;
2009
2010         list_del_rcu(&srcdev->dev_list);
2011         list_del_rcu(&srcdev->dev_alloc_list);
2012         fs_devices->num_devices--;
2013         if (srcdev->missing)
2014                 fs_devices->missing_devices--;
2015
2016         if (srcdev->writeable)
2017                 fs_devices->rw_devices--;
2018
2019         if (srcdev->bdev)
2020                 fs_devices->open_devices--;
2021 }
2022
2023 void btrfs_rm_dev_replace_free_srcdev(struct btrfs_fs_info *fs_info,
2024                                       struct btrfs_device *srcdev)
2025 {
2026         struct btrfs_fs_devices *fs_devices = srcdev->fs_devices;
2027
2028         if (srcdev->writeable) {
2029                 /* zero out the old super if it is writable */
2030                 btrfs_scratch_superblocks(srcdev->bdev, srcdev->name->str);
2031         }
2032
2033         btrfs_close_bdev(srcdev);
2034
2035         call_rcu(&srcdev->rcu, free_device);
2036
2037         /*
2038          * unless fs_devices is seed fs, num_devices shouldn't go
2039          * zero
2040          */
2041         BUG_ON(!fs_devices->num_devices && !fs_devices->seeding);
2042
2043         /* if this is no devs we rather delete the fs_devices */
2044         if (!fs_devices->num_devices) {
2045                 struct btrfs_fs_devices *tmp_fs_devices;
2046
2047                 tmp_fs_devices = fs_info->fs_devices;
2048                 while (tmp_fs_devices) {
2049                         if (tmp_fs_devices->seed == fs_devices) {
2050                                 tmp_fs_devices->seed = fs_devices->seed;
2051                                 break;
2052                         }
2053                         tmp_fs_devices = tmp_fs_devices->seed;
2054                 }
2055                 fs_devices->seed = NULL;
2056                 __btrfs_close_devices(fs_devices);
2057                 free_fs_devices(fs_devices);
2058         }
2059 }
2060
2061 void btrfs_destroy_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
2062                                       struct btrfs_device *tgtdev)
2063 {
2064         mutex_lock(&uuid_mutex);
2065         WARN_ON(!tgtdev);
2066         mutex_lock(&fs_info->fs_devices->device_list_mutex);
2067
2068         btrfs_sysfs_rm_device_link(fs_info->fs_devices, tgtdev);
2069
2070         if (tgtdev->bdev)
2071                 fs_info->fs_devices->open_devices--;
2072
2073         fs_info->fs_devices->num_devices--;
2074
2075         btrfs_assign_next_active_device(fs_info, tgtdev, NULL);
2076
2077         list_del_rcu(&tgtdev->dev_list);
2078
2079         mutex_unlock(&fs_info->fs_devices->device_list_mutex);
2080         mutex_unlock(&uuid_mutex);
2081
2082         /*
2083          * The update_dev_time() with in btrfs_scratch_superblocks()
2084          * may lead to a call to btrfs_show_devname() which will try
2085          * to hold device_list_mutex. And here this device
2086          * is already out of device list, so we don't have to hold
2087          * the device_list_mutex lock.
2088          */
2089         btrfs_scratch_superblocks(tgtdev->bdev, tgtdev->name->str);
2090
2091         btrfs_close_bdev(tgtdev);
2092         call_rcu(&tgtdev->rcu, free_device);
2093 }
2094
2095 static int btrfs_find_device_by_path(struct btrfs_fs_info *fs_info,
2096                                      const char *device_path,
2097                                      struct btrfs_device **device)
2098 {
2099         int ret = 0;
2100         struct btrfs_super_block *disk_super;
2101         u64 devid;
2102         u8 *dev_uuid;
2103         struct block_device *bdev;
2104         struct buffer_head *bh;
2105
2106         *device = NULL;
2107         ret = btrfs_get_bdev_and_sb(device_path, FMODE_READ,
2108                                     fs_info->bdev_holder, 0, &bdev, &bh);
2109         if (ret)
2110                 return ret;
2111         disk_super = (struct btrfs_super_block *)bh->b_data;
2112         devid = btrfs_stack_device_id(&disk_super->dev_item);
2113         dev_uuid = disk_super->dev_item.uuid;
2114         *device = btrfs_find_device(fs_info, devid, dev_uuid, disk_super->fsid);
2115         brelse(bh);
2116         if (!*device)
2117                 ret = -ENOENT;
2118         blkdev_put(bdev, FMODE_READ);
2119         return ret;
2120 }
2121
2122 int btrfs_find_device_missing_or_by_path(struct btrfs_fs_info *fs_info,
2123                                          const char *device_path,
2124                                          struct btrfs_device **device)
2125 {
2126         *device = NULL;
2127         if (strcmp(device_path, "missing") == 0) {
2128                 struct list_head *devices;
2129                 struct btrfs_device *tmp;
2130
2131                 devices = &fs_info->fs_devices->devices;
2132                 /*
2133                  * It is safe to read the devices since the volume_mutex
2134                  * is held by the caller.
2135                  */
2136                 list_for_each_entry(tmp, devices, dev_list) {
2137                         if (tmp->in_fs_metadata && !tmp->bdev) {
2138                                 *device = tmp;
2139                                 break;
2140                         }
2141                 }
2142
2143                 if (!*device)
2144                         return BTRFS_ERROR_DEV_MISSING_NOT_FOUND;
2145
2146                 return 0;
2147         } else {
2148                 return btrfs_find_device_by_path(fs_info, device_path, device);
2149         }
2150 }
2151
2152 /*
2153  * Lookup a device given by device id, or the path if the id is 0.
2154  */
2155 int btrfs_find_device_by_devspec(struct btrfs_fs_info *fs_info, u64 devid,
2156                                  const char *devpath,
2157                                  struct btrfs_device **device)
2158 {
2159         int ret;
2160
2161         if (devid) {
2162                 ret = 0;
2163                 *device = btrfs_find_device(fs_info, devid, NULL, NULL);
2164                 if (!*device)
2165                         ret = -ENOENT;
2166         } else {
2167                 if (!devpath || !devpath[0])
2168                         return -EINVAL;
2169
2170                 ret = btrfs_find_device_missing_or_by_path(fs_info, devpath,
2171                                                            device);
2172         }
2173         return ret;
2174 }
2175
2176 /*
2177  * does all the dirty work required for changing file system's UUID.
2178  */
2179 static int btrfs_prepare_sprout(struct btrfs_fs_info *fs_info)
2180 {
2181         struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
2182         struct btrfs_fs_devices *old_devices;
2183         struct btrfs_fs_devices *seed_devices;
2184         struct btrfs_super_block *disk_super = fs_info->super_copy;
2185         struct btrfs_device *device;
2186         u64 super_flags;
2187
2188         BUG_ON(!mutex_is_locked(&uuid_mutex));
2189         if (!fs_devices->seeding)
2190                 return -EINVAL;
2191
2192         seed_devices = alloc_fs_devices(NULL);
2193         if (IS_ERR(seed_devices))
2194                 return PTR_ERR(seed_devices);
2195
2196         old_devices = clone_fs_devices(fs_devices);
2197         if (IS_ERR(old_devices)) {
2198                 kfree(seed_devices);
2199                 return PTR_ERR(old_devices);
2200         }
2201
2202         list_add(&old_devices->list, &fs_uuids);
2203
2204         memcpy(seed_devices, fs_devices, sizeof(*seed_devices));
2205         seed_devices->opened = 1;
2206         INIT_LIST_HEAD(&seed_devices->devices);
2207         INIT_LIST_HEAD(&seed_devices->alloc_list);
2208         mutex_init(&seed_devices->device_list_mutex);
2209
2210         mutex_lock(&fs_info->fs_devices->device_list_mutex);
2211         list_splice_init_rcu(&fs_devices->devices, &seed_devices->devices,
2212                               synchronize_rcu);
2213         list_for_each_entry(device, &seed_devices->devices, dev_list)
2214                 device->fs_devices = seed_devices;
2215
2216         mutex_lock(&fs_info->chunk_mutex);
2217         list_splice_init(&fs_devices->alloc_list, &seed_devices->alloc_list);
2218         mutex_unlock(&fs_info->chunk_mutex);
2219
2220         fs_devices->seeding = 0;
2221         fs_devices->num_devices = 0;
2222         fs_devices->open_devices = 0;
2223         fs_devices->missing_devices = 0;
2224         fs_devices->rotating = 0;
2225         fs_devices->seed = seed_devices;
2226
2227         generate_random_uuid(fs_devices->fsid);
2228         memcpy(fs_info->fsid, fs_devices->fsid, BTRFS_FSID_SIZE);
2229         memcpy(disk_super->fsid, fs_devices->fsid, BTRFS_FSID_SIZE);
2230         mutex_unlock(&fs_info->fs_devices->device_list_mutex);
2231
2232         super_flags = btrfs_super_flags(disk_super) &
2233                       ~BTRFS_SUPER_FLAG_SEEDING;
2234         btrfs_set_super_flags(disk_super, super_flags);
2235
2236         return 0;
2237 }
2238
2239 /*
2240  * Store the expected generation for seed devices in device items.
2241  */
2242 static int btrfs_finish_sprout(struct btrfs_trans_handle *trans,
2243                                struct btrfs_fs_info *fs_info)
2244 {
2245         struct btrfs_root *root = fs_info->chunk_root;
2246         struct btrfs_path *path;
2247         struct extent_buffer *leaf;
2248         struct btrfs_dev_item *dev_item;
2249         struct btrfs_device *device;
2250         struct btrfs_key key;
2251         u8 fs_uuid[BTRFS_FSID_SIZE];
2252         u8 dev_uuid[BTRFS_UUID_SIZE];
2253         u64 devid;
2254         int ret;
2255
2256         path = btrfs_alloc_path();
2257         if (!path)
2258                 return -ENOMEM;
2259
2260         key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
2261         key.offset = 0;
2262         key.type = BTRFS_DEV_ITEM_KEY;
2263
2264         while (1) {
2265                 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2266                 if (ret < 0)
2267                         goto error;
2268
2269                 leaf = path->nodes[0];
2270 next_slot:
2271                 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
2272                         ret = btrfs_next_leaf(root, path);
2273                         if (ret > 0)
2274                                 break;
2275                         if (ret < 0)
2276                                 goto error;
2277                         leaf = path->nodes[0];
2278                         btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
2279                         btrfs_release_path(path);
2280                         continue;
2281                 }
2282
2283                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
2284                 if (key.objectid != BTRFS_DEV_ITEMS_OBJECTID ||
2285                     key.type != BTRFS_DEV_ITEM_KEY)
2286                         break;
2287
2288                 dev_item = btrfs_item_ptr(leaf, path->slots[0],
2289                                           struct btrfs_dev_item);
2290                 devid = btrfs_device_id(leaf, dev_item);
2291                 read_extent_buffer(leaf, dev_uuid, btrfs_device_uuid(dev_item),
2292                                    BTRFS_UUID_SIZE);
2293                 read_extent_buffer(leaf, fs_uuid, btrfs_device_fsid(dev_item),
2294                                    BTRFS_FSID_SIZE);
2295                 device = btrfs_find_device(fs_info, devid, dev_uuid, fs_uuid);
2296                 BUG_ON(!device); /* Logic error */
2297
2298                 if (device->fs_devices->seeding) {
2299                         btrfs_set_device_generation(leaf, dev_item,
2300                                                     device->generation);
2301                         btrfs_mark_buffer_dirty(leaf);
2302                 }
2303
2304                 path->slots[0]++;
2305                 goto next_slot;
2306         }
2307         ret = 0;
2308 error:
2309         btrfs_free_path(path);
2310         return ret;
2311 }
2312
2313 int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path)
2314 {
2315         struct btrfs_root *root = fs_info->dev_root;
2316         struct request_queue *q;
2317         struct btrfs_trans_handle *trans;
2318         struct btrfs_device *device;
2319         struct block_device *bdev;
2320         struct list_head *devices;
2321         struct super_block *sb = fs_info->sb;
2322         struct rcu_string *name;
2323         u64 tmp;
2324         int seeding_dev = 0;
2325         int ret = 0;
2326
2327         if ((sb->s_flags & MS_RDONLY) && !fs_info->fs_devices->seeding)
2328                 return -EROFS;
2329
2330         bdev = blkdev_get_by_path(device_path, FMODE_WRITE | FMODE_EXCL,
2331                                   fs_info->bdev_holder);
2332         if (IS_ERR(bdev))
2333                 return PTR_ERR(bdev);
2334
2335         if (fs_info->fs_devices->seeding) {
2336                 seeding_dev = 1;
2337                 down_write(&sb->s_umount);
2338                 mutex_lock(&uuid_mutex);
2339         }
2340
2341         filemap_write_and_wait(bdev->bd_inode->i_mapping);
2342
2343         devices = &fs_info->fs_devices->devices;
2344
2345         mutex_lock(&fs_info->fs_devices->device_list_mutex);
2346         list_for_each_entry(device, devices, dev_list) {
2347                 if (device->bdev == bdev) {
2348                         ret = -EEXIST;
2349                         mutex_unlock(
2350                                 &fs_info->fs_devices->device_list_mutex);
2351                         goto error;
2352                 }
2353         }
2354         mutex_unlock(&fs_info->fs_devices->device_list_mutex);
2355
2356         device = btrfs_alloc_device(fs_info, NULL, NULL);
2357         if (IS_ERR(device)) {
2358                 /* we can safely leave the fs_devices entry around */
2359                 ret = PTR_ERR(device);
2360                 goto error;
2361         }
2362
2363         name = rcu_string_strdup(device_path, GFP_KERNEL);
2364         if (!name) {
2365                 kfree(device);
2366                 ret = -ENOMEM;
2367                 goto error;
2368         }
2369         rcu_assign_pointer(device->name, name);
2370
2371         trans = btrfs_start_transaction(root, 0);
2372         if (IS_ERR(trans)) {
2373                 rcu_string_free(device->name);
2374                 kfree(device);
2375                 ret = PTR_ERR(trans);
2376                 goto error;
2377         }
2378
2379         q = bdev_get_queue(bdev);
2380         if (blk_queue_discard(q))
2381                 device->can_discard = 1;
2382         device->writeable = 1;
2383         device->generation = trans->transid;
2384         device->io_width = fs_info->sectorsize;
2385         device->io_align = fs_info->sectorsize;
2386         device->sector_size = fs_info->sectorsize;
2387         device->total_bytes = round_down(i_size_read(bdev->bd_inode),
2388                                          fs_info->sectorsize);
2389         device->disk_total_bytes = device->total_bytes;
2390         device->commit_total_bytes = device->total_bytes;
2391         device->fs_info = fs_info;
2392         device->bdev = bdev;
2393         device->in_fs_metadata = 1;
2394         device->is_tgtdev_for_dev_replace = 0;
2395         device->mode = FMODE_EXCL;
2396         device->dev_stats_valid = 1;
2397         set_blocksize(device->bdev, BTRFS_BDEV_BLOCKSIZE);
2398
2399         if (seeding_dev) {
2400                 sb->s_flags &= ~MS_RDONLY;
2401                 ret = btrfs_prepare_sprout(fs_info);
2402                 BUG_ON(ret); /* -ENOMEM */
2403         }
2404
2405         device->fs_devices = fs_info->fs_devices;
2406
2407         mutex_lock(&fs_info->fs_devices->device_list_mutex);
2408         mutex_lock(&fs_info->chunk_mutex);
2409         list_add_rcu(&device->dev_list, &fs_info->fs_devices->devices);
2410         list_add(&device->dev_alloc_list,
2411                  &fs_info->fs_devices->alloc_list);
2412         fs_info->fs_devices->num_devices++;
2413         fs_info->fs_devices->open_devices++;
2414         fs_info->fs_devices->rw_devices++;
2415         fs_info->fs_devices->total_devices++;
2416         fs_info->fs_devices->total_rw_bytes += device->total_bytes;
2417
2418         atomic64_add(device->total_bytes, &fs_info->free_chunk_space);
2419
2420         if (!blk_queue_nonrot(q))
2421                 fs_info->fs_devices->rotating = 1;
2422
2423         tmp = btrfs_super_total_bytes(fs_info->super_copy);
2424         btrfs_set_super_total_bytes(fs_info->super_copy,
2425                 round_down(tmp + device->total_bytes, fs_info->sectorsize));
2426
2427         tmp = btrfs_super_num_devices(fs_info->super_copy);
2428         btrfs_set_super_num_devices(fs_info->super_copy, tmp + 1);
2429
2430         /* add sysfs device entry */
2431         btrfs_sysfs_add_device_link(fs_info->fs_devices, device);
2432
2433         /*
2434          * we've got more storage, clear any full flags on the space
2435          * infos
2436          */
2437         btrfs_clear_space_info_full(fs_info);
2438
2439         mutex_unlock(&fs_info->chunk_mutex);
2440         mutex_unlock(&fs_info->fs_devices->device_list_mutex);
2441
2442         if (seeding_dev) {
2443                 mutex_lock(&fs_info->chunk_mutex);
2444                 ret = init_first_rw_device(trans, fs_info);
2445                 mutex_unlock(&fs_info->chunk_mutex);
2446                 if (ret) {
2447                         btrfs_abort_transaction(trans, ret);
2448                         goto error_trans;
2449                 }
2450         }
2451
2452         ret = btrfs_add_device(trans, fs_info, device);
2453         if (ret) {
2454                 btrfs_abort_transaction(trans, ret);
2455                 goto error_trans;
2456         }
2457
2458         if (seeding_dev) {
2459                 char fsid_buf[BTRFS_UUID_UNPARSED_SIZE];
2460
2461                 ret = btrfs_finish_sprout(trans, fs_info);
2462                 if (ret) {
2463                         btrfs_abort_transaction(trans, ret);
2464                         goto error_trans;
2465                 }
2466
2467                 /* Sprouting would change fsid of the mounted root,
2468                  * so rename the fsid on the sysfs
2469                  */
2470                 snprintf(fsid_buf, BTRFS_UUID_UNPARSED_SIZE, "%pU",
2471                                                 fs_info->fsid);
2472                 if (kobject_rename(&fs_info->fs_devices->fsid_kobj, fsid_buf))
2473                         btrfs_warn(fs_info,
2474                                    "sysfs: failed to create fsid for sprout");
2475         }
2476
2477         ret = btrfs_commit_transaction(trans);
2478
2479         if (seeding_dev) {
2480                 mutex_unlock(&uuid_mutex);
2481                 up_write(&sb->s_umount);
2482
2483                 if (ret) /* transaction commit */
2484                         return ret;
2485
2486                 ret = btrfs_relocate_sys_chunks(fs_info);
2487                 if (ret < 0)
2488                         btrfs_handle_fs_error(fs_info, ret,
2489                                     "Failed to relocate sys chunks after device initialization. This can be fixed using the \"btrfs balance\" command.");
2490                 trans = btrfs_attach_transaction(root);
2491                 if (IS_ERR(trans)) {
2492                         if (PTR_ERR(trans) == -ENOENT)
2493                                 return 0;
2494                         return PTR_ERR(trans);
2495                 }
2496                 ret = btrfs_commit_transaction(trans);
2497         }
2498
2499         /* Update ctime/mtime for libblkid */
2500         update_dev_time(device_path);
2501         return ret;
2502
2503 error_trans:
2504         btrfs_end_transaction(trans);
2505         rcu_string_free(device->name);
2506         btrfs_sysfs_rm_device_link(fs_info->fs_devices, device);
2507         kfree(device);
2508 error:
2509         blkdev_put(bdev, FMODE_EXCL);
2510         if (seeding_dev) {
2511                 mutex_unlock(&uuid_mutex);
2512                 up_write(&sb->s_umount);
2513         }
2514         return ret;
2515 }
2516
2517 int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
2518                                   const char *device_path,
2519                                   struct btrfs_device *srcdev,
2520                                   struct btrfs_device **device_out)
2521 {
2522         struct request_queue *q;
2523         struct btrfs_device *device;
2524         struct block_device *bdev;
2525         struct list_head *devices;
2526         struct rcu_string *name;
2527         u64 devid = BTRFS_DEV_REPLACE_DEVID;
2528         int ret = 0;
2529
2530         *device_out = NULL;
2531         if (fs_info->fs_devices->seeding) {
2532                 btrfs_err(fs_info, "the filesystem is a seed filesystem!");
2533                 return -EINVAL;
2534         }
2535
2536         bdev = blkdev_get_by_path(device_path, FMODE_WRITE | FMODE_EXCL,
2537                                   fs_info->bdev_holder);
2538         if (IS_ERR(bdev)) {
2539                 btrfs_err(fs_info, "target device %s is invalid!", device_path);
2540                 return PTR_ERR(bdev);
2541         }
2542
2543         filemap_write_and_wait(bdev->bd_inode->i_mapping);
2544
2545         devices = &fs_info->fs_devices->devices;
2546         list_for_each_entry(device, devices, dev_list) {
2547                 if (device->bdev == bdev) {
2548                         btrfs_err(fs_info,
2549                                   "target device is in the filesystem!");
2550                         ret = -EEXIST;
2551                         goto error;
2552                 }
2553         }
2554
2555
2556         if (i_size_read(bdev->bd_inode) <
2557             btrfs_device_get_total_bytes(srcdev)) {
2558                 btrfs_err(fs_info,
2559                           "target device is smaller than source device!");
2560                 ret = -EINVAL;
2561                 goto error;
2562         }
2563
2564
2565         device = btrfs_alloc_device(NULL, &devid, NULL);
2566         if (IS_ERR(device)) {
2567                 ret = PTR_ERR(device);
2568                 goto error;
2569         }
2570
2571         name = rcu_string_strdup(device_path, GFP_KERNEL);
2572         if (!name) {
2573                 kfree(device);
2574                 ret = -ENOMEM;
2575                 goto error;
2576         }
2577         rcu_assign_pointer(device->name, name);
2578
2579         q = bdev_get_queue(bdev);
2580         if (blk_queue_discard(q))
2581                 device->can_discard = 1;
2582         mutex_lock(&fs_info->fs_devices->device_list_mutex);
2583         device->writeable = 1;
2584         device->generation = 0;
2585         device->io_width = fs_info->sectorsize;
2586         device->io_align = fs_info->sectorsize;
2587         device->sector_size = fs_info->sectorsize;
2588         device->total_bytes = btrfs_device_get_total_bytes(srcdev);
2589         device->disk_total_bytes = btrfs_device_get_disk_total_bytes(srcdev);
2590         device->bytes_used = btrfs_device_get_bytes_used(srcdev);
2591         ASSERT(list_empty(&srcdev->resized_list));
2592         device->commit_total_bytes = srcdev->commit_total_bytes;
2593         device->commit_bytes_used = device->bytes_used;
2594         device->fs_info = fs_info;
2595         device->bdev = bdev;
2596         device->in_fs_metadata = 1;
2597         device->is_tgtdev_for_dev_replace = 1;
2598         device->mode = FMODE_EXCL;
2599         device->dev_stats_valid = 1;
2600         set_blocksize(device->bdev, BTRFS_BDEV_BLOCKSIZE);
2601         device->fs_devices = fs_info->fs_devices;
2602         list_add(&device->dev_list, &fs_info->fs_devices->devices);
2603         fs_info->fs_devices->num_devices++;
2604         fs_info->fs_devices->open_devices++;
2605         mutex_unlock(&fs_info->fs_devices->device_list_mutex);
2606
2607         *device_out = device;
2608         return ret;
2609
2610 error:
2611         blkdev_put(bdev, FMODE_EXCL);
2612         return ret;
2613 }
2614
2615 void btrfs_init_dev_replace_tgtdev_for_resume(struct btrfs_fs_info *fs_info,
2616                                               struct btrfs_device *tgtdev)
2617 {
2618         u32 sectorsize = fs_info->sectorsize;
2619
2620         WARN_ON(fs_info->fs_devices->rw_devices == 0);
2621         tgtdev->io_width = sectorsize;
2622         tgtdev->io_align = sectorsize;
2623         tgtdev->sector_size = sectorsize;
2624         tgtdev->fs_info = fs_info;
2625         tgtdev->in_fs_metadata = 1;
2626 }
2627
2628 static noinline int btrfs_update_device(struct btrfs_trans_handle *trans,
2629                                         struct btrfs_device *device)
2630 {
2631         int ret;
2632         struct btrfs_path *path;
2633         struct btrfs_root *root = device->fs_info->chunk_root;
2634         struct btrfs_dev_item *dev_item;
2635         struct extent_buffer *leaf;
2636         struct btrfs_key key;
2637
2638         path = btrfs_alloc_path();
2639         if (!path)
2640                 return -ENOMEM;
2641
2642         key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
2643         key.type = BTRFS_DEV_ITEM_KEY;
2644         key.offset = device->devid;
2645
2646         ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2647         if (ret < 0)
2648                 goto out;
2649
2650         if (ret > 0) {
2651                 ret = -ENOENT;
2652                 goto out;
2653         }
2654
2655         leaf = path->nodes[0];
2656         dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item);
2657
2658         btrfs_set_device_id(leaf, dev_item, device->devid);
2659         btrfs_set_device_type(leaf, dev_item, device->type);
2660         btrfs_set_device_io_align(leaf, dev_item, device->io_align);
2661         btrfs_set_device_io_width(leaf, dev_item, device->io_width);
2662         btrfs_set_device_sector_size(leaf, dev_item, device->sector_size);
2663         btrfs_set_device_total_bytes(leaf, dev_item,
2664                                      btrfs_device_get_disk_total_bytes(device));
2665         btrfs_set_device_bytes_used(leaf, dev_item,
2666                                     btrfs_device_get_bytes_used(device));
2667         btrfs_mark_buffer_dirty(leaf);
2668
2669 out:
2670         btrfs_free_path(path);
2671         return ret;
2672 }
2673
2674 int btrfs_grow_device(struct btrfs_trans_handle *trans,
2675                       struct btrfs_device *device, u64 new_size)
2676 {
2677         struct btrfs_fs_info *fs_info = device->fs_info;
2678         struct btrfs_super_block *super_copy = fs_info->super_copy;
2679         struct btrfs_fs_devices *fs_devices;
2680         u64 old_total;
2681         u64 diff;
2682
2683         if (!device->writeable)
2684                 return -EACCES;
2685
2686         new_size = round_down(new_size, fs_info->sectorsize);
2687
2688         mutex_lock(&fs_info->chunk_mutex);
2689         old_total = btrfs_super_total_bytes(super_copy);
2690         diff = round_down(new_size - device->total_bytes, fs_info->sectorsize);
2691
2692         if (new_size <= device->total_bytes ||
2693             device->is_tgtdev_for_dev_replace) {
2694                 mutex_unlock(&fs_info->chunk_mutex);
2695                 return -EINVAL;
2696         }
2697
2698         fs_devices = fs_info->fs_devices;
2699
2700         btrfs_set_super_total_bytes(super_copy,
2701                         round_down(old_total + diff, fs_info->sectorsize));
2702         device->fs_devices->total_rw_bytes += diff;
2703
2704         btrfs_device_set_total_bytes(device, new_size);
2705         btrfs_device_set_disk_total_bytes(device, new_size);
2706         btrfs_clear_space_info_full(device->fs_info);
2707         if (list_empty(&device->resized_list))
2708                 list_add_tail(&device->resized_list,
2709                               &fs_devices->resized_devices);
2710         mutex_unlock(&fs_info->chunk_mutex);
2711
2712         return btrfs_update_device(trans, device);
2713 }
2714
2715 static int btrfs_free_chunk(struct btrfs_trans_handle *trans,
2716                             struct btrfs_fs_info *fs_info, u64 chunk_offset)
2717 {
2718         struct btrfs_root *root = fs_info->chunk_root;
2719         int ret;
2720         struct btrfs_path *path;
2721         struct btrfs_key key;
2722
2723         path = btrfs_alloc_path();
2724         if (!path)
2725                 return -ENOMEM;
2726
2727         key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
2728         key.offset = chunk_offset;
2729         key.type = BTRFS_CHUNK_ITEM_KEY;
2730
2731         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
2732         if (ret < 0)
2733                 goto out;
2734         else if (ret > 0) { /* Logic error or corruption */
2735                 btrfs_handle_fs_error(fs_info, -ENOENT,
2736                                       "Failed lookup while freeing chunk.");
2737                 ret = -ENOENT;
2738                 goto out;
2739         }
2740
2741         ret = btrfs_del_item(trans, root, path);
2742         if (ret < 0)
2743                 btrfs_handle_fs_error(fs_info, ret,
2744                                       "Failed to delete chunk item.");
2745 out:
2746         btrfs_free_path(path);
2747         return ret;
2748 }
2749
2750 static int btrfs_del_sys_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset)
2751 {
2752         struct btrfs_super_block *super_copy = fs_info->super_copy;
2753         struct btrfs_disk_key *disk_key;
2754         struct btrfs_chunk *chunk;
2755         u8 *ptr;
2756         int ret = 0;
2757         u32 num_stripes;
2758         u32 array_size;
2759         u32 len = 0;
2760         u32 cur;
2761         struct btrfs_key key;
2762
2763         mutex_lock(&fs_info->chunk_mutex);
2764         array_size = btrfs_super_sys_array_size(super_copy);
2765
2766         ptr = super_copy->sys_chunk_array;
2767         cur = 0;
2768
2769         while (cur < array_size) {
2770                 disk_key = (struct btrfs_disk_key *)ptr;
2771                 btrfs_disk_key_to_cpu(&key, disk_key);
2772
2773                 len = sizeof(*disk_key);
2774
2775                 if (key.type == BTRFS_CHUNK_ITEM_KEY) {
2776                         chunk = (struct btrfs_chunk *)(ptr + len);
2777                         num_stripes = btrfs_stack_chunk_num_stripes(chunk);
2778                         len += btrfs_chunk_item_size(num_stripes);
2779                 } else {
2780                         ret = -EIO;
2781                         break;
2782                 }
2783                 if (key.objectid == BTRFS_FIRST_CHUNK_TREE_OBJECTID &&
2784                     key.offset == chunk_offset) {
2785                         memmove(ptr, ptr + len, array_size - (cur + len));
2786                         array_size -= len;
2787                         btrfs_set_super_sys_array_size(super_copy, array_size);
2788                 } else {
2789                         ptr += len;
2790                         cur += len;
2791                 }
2792         }
2793         mutex_unlock(&fs_info->chunk_mutex);
2794         return ret;
2795 }
2796
2797 static struct extent_map *get_chunk_map(struct btrfs_fs_info *fs_info,
2798                                         u64 logical, u64 length)
2799 {
2800         struct extent_map_tree *em_tree;
2801         struct extent_map *em;
2802
2803         em_tree = &fs_info->mapping_tree.map_tree;
2804         read_lock(&em_tree->lock);
2805         em = lookup_extent_mapping(em_tree, logical, length);
2806         read_unlock(&em_tree->lock);
2807
2808         if (!em) {
2809                 btrfs_crit(fs_info, "unable to find logical %llu length %llu",
2810                            logical, length);
2811                 return ERR_PTR(-EINVAL);
2812         }
2813
2814         if (em->start > logical || em->start + em->len < logical) {
2815                 btrfs_crit(fs_info,
2816                            "found a bad mapping, wanted %llu-%llu, found %llu-%llu",
2817                            logical, length, em->start, em->start + em->len);
2818                 free_extent_map(em);
2819                 return ERR_PTR(-EINVAL);
2820         }
2821
2822         /* callers are responsible for dropping em's ref. */
2823         return em;
2824 }
2825
2826 int btrfs_remove_chunk(struct btrfs_trans_handle *trans,
2827                        struct btrfs_fs_info *fs_info, u64 chunk_offset)
2828 {
2829         struct extent_map *em;
2830         struct map_lookup *map;
2831         u64 dev_extent_len = 0;
2832         int i, ret = 0;
2833         struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
2834
2835         em = get_chunk_map(fs_info, chunk_offset, 1);
2836         if (IS_ERR(em)) {
2837                 /*
2838                  * This is a logic error, but we don't want to just rely on the
2839                  * user having built with ASSERT enabled, so if ASSERT doesn't
2840                  * do anything we still error out.
2841                  */
2842                 ASSERT(0);
2843                 return PTR_ERR(em);
2844         }
2845         map = em->map_lookup;
2846         mutex_lock(&fs_info->chunk_mutex);
2847         check_system_chunk(trans, fs_info, map->type);
2848         mutex_unlock(&fs_info->chunk_mutex);
2849
2850         /*
2851          * Take the device list mutex to prevent races with the final phase of
2852          * a device replace operation that replaces the device object associated
2853          * with map stripes (dev-replace.c:btrfs_dev_replace_finishing()).
2854          */
2855         mutex_lock(&fs_devices->device_list_mutex);
2856         for (i = 0; i < map->num_stripes; i++) {
2857                 struct btrfs_device *device = map->stripes[i].dev;
2858                 ret = btrfs_free_dev_extent(trans, device,
2859                                             map->stripes[i].physical,
2860                                             &dev_extent_len);
2861                 if (ret) {
2862                         mutex_unlock(&fs_devices->device_list_mutex);
2863                         btrfs_abort_transaction(trans, ret);
2864                         goto out;
2865                 }
2866
2867                 if (device->bytes_used > 0) {
2868                         mutex_lock(&fs_info->chunk_mutex);
2869                         btrfs_device_set_bytes_used(device,
2870                                         device->bytes_used - dev_extent_len);
2871                         atomic64_add(dev_extent_len, &fs_info->free_chunk_space);
2872                         btrfs_clear_space_info_full(fs_info);
2873                         mutex_unlock(&fs_info->chunk_mutex);
2874                 }
2875
2876                 if (map->stripes[i].dev) {
2877                         ret = btrfs_update_device(trans, map->stripes[i].dev);
2878                         if (ret) {
2879                                 mutex_unlock(&fs_devices->device_list_mutex);
2880                                 btrfs_abort_transaction(trans, ret);
2881                                 goto out;
2882                         }
2883                 }
2884         }
2885         mutex_unlock(&fs_devices->device_list_mutex);
2886
2887         ret = btrfs_free_chunk(trans, fs_info, chunk_offset);
2888         if (ret) {
2889                 btrfs_abort_transaction(trans, ret);
2890                 goto out;
2891         }
2892
2893         trace_btrfs_chunk_free(fs_info, map, chunk_offset, em->len);
2894
2895         if (map->type & BTRFS_BLOCK_GROUP_SYSTEM) {
2896                 ret = btrfs_del_sys_chunk(fs_info, chunk_offset);
2897                 if (ret) {
2898                         btrfs_abort_transaction(trans, ret);
2899                         goto out;
2900                 }
2901         }
2902
2903         ret = btrfs_remove_block_group(trans, fs_info, chunk_offset, em);
2904         if (ret) {
2905                 btrfs_abort_transaction(trans, ret);
2906                 goto out;
2907         }
2908
2909 out:
2910         /* once for us */
2911         free_extent_map(em);
2912         return ret;
2913 }
2914
2915 static int btrfs_relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset)
2916 {
2917         struct btrfs_root *root = fs_info->chunk_root;
2918         struct btrfs_trans_handle *trans;
2919         int ret;
2920
2921         /*
2922          * Prevent races with automatic removal of unused block groups.
2923          * After we relocate and before we remove the chunk with offset
2924          * chunk_offset, automatic removal of the block group can kick in,
2925          * resulting in a failure when calling btrfs_remove_chunk() below.
2926          *
2927          * Make sure to acquire this mutex before doing a tree search (dev
2928          * or chunk trees) to find chunks. Otherwise the cleaner kthread might
2929          * call btrfs_remove_chunk() (through btrfs_delete_unused_bgs()) after
2930          * we release the path used to search the chunk/dev tree and before
2931          * the current task acquires this mutex and calls us.
2932          */
2933         ASSERT(mutex_is_locked(&fs_info->delete_unused_bgs_mutex));
2934
2935         ret = btrfs_can_relocate(fs_info, chunk_offset);
2936         if (ret)
2937                 return -ENOSPC;
2938
2939         /* step one, relocate all the extents inside this chunk */
2940         btrfs_scrub_pause(fs_info);
2941         ret = btrfs_relocate_block_group(fs_info, chunk_offset);
2942         btrfs_scrub_continue(fs_info);
2943         if (ret)
2944                 return ret;
2945
2946         trans = btrfs_start_trans_remove_block_group(root->fs_info,
2947                                                      chunk_offset);
2948         if (IS_ERR(trans)) {
2949                 ret = PTR_ERR(trans);
2950                 btrfs_handle_fs_error(root->fs_info, ret, NULL);
2951                 return ret;
2952         }
2953
2954         /*
2955          * step two, delete the device extents and the
2956          * chunk tree entries
2957          */
2958         ret = btrfs_remove_chunk(trans, fs_info, chunk_offset);
2959         btrfs_end_transaction(trans);
2960         return ret;
2961 }
2962
2963 static int btrfs_relocate_sys_chunks(struct btrfs_fs_info *fs_info)
2964 {
2965         struct btrfs_root *chunk_root = fs_info->chunk_root;
2966         struct btrfs_path *path;
2967         struct extent_buffer *leaf;
2968         struct btrfs_chunk *chunk;
2969         struct btrfs_key key;
2970         struct btrfs_key found_key;
2971         u64 chunk_type;
2972         bool retried = false;
2973         int failed = 0;
2974         int ret;
2975
2976         path = btrfs_alloc_path();
2977         if (!path)
2978                 return -ENOMEM;
2979
2980 again:
2981         key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
2982         key.offset = (u64)-1;
2983         key.type = BTRFS_CHUNK_ITEM_KEY;
2984
2985         while (1) {
2986                 mutex_lock(&fs_info->delete_unused_bgs_mutex);
2987                 ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0);
2988                 if (ret < 0) {
2989                         mutex_unlock(&fs_info->delete_unused_bgs_mutex);
2990                         goto error;
2991                 }
2992                 BUG_ON(ret == 0); /* Corruption */
2993
2994                 ret = btrfs_previous_item(chunk_root, path, key.objectid,
2995                                           key.type);
2996                 if (ret)
2997                         mutex_unlock(&fs_info->delete_unused_bgs_mutex);
2998                 if (ret < 0)
2999                         goto error;
3000                 if (ret > 0)
3001                         break;
3002
3003                 leaf = path->nodes[0];
3004                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
3005
3006                 chunk = btrfs_item_ptr(leaf, path->slots[0],
3007                                        struct btrfs_chunk);
3008                 chunk_type = btrfs_chunk_type(leaf, chunk);
3009                 btrfs_release_path(path);
3010
3011                 if (chunk_type & BTRFS_BLOCK_GROUP_SYSTEM) {
3012                         ret = btrfs_relocate_chunk(fs_info, found_key.offset);
3013                         if (ret == -ENOSPC)
3014                                 failed++;
3015                         else
3016                                 BUG_ON(ret);
3017                 }
3018                 mutex_unlock(&fs_info->delete_unused_bgs_mutex);
3019
3020                 if (found_key.offset == 0)
3021                         break;
3022                 key.offset = found_key.offset - 1;
3023         }
3024         ret = 0;
3025         if (failed && !retried) {
3026                 failed = 0;
3027                 retried = true;
3028                 goto again;
3029         } else if (WARN_ON(failed && retried)) {
3030                 ret = -ENOSPC;
3031         }
3032 error:
3033         btrfs_free_path(path);
3034         return ret;
3035 }
3036
3037 static int insert_balance_item(struct btrfs_fs_info *fs_info,
3038                                struct btrfs_balance_control *bctl)
3039 {
3040         struct btrfs_root *root = fs_info->tree_root;
3041         struct btrfs_trans_handle *trans;
3042         struct btrfs_balance_item *item;
3043         struct btrfs_disk_balance_args disk_bargs;
3044         struct btrfs_path *path;
3045         struct extent_buffer *leaf;
3046         struct btrfs_key key;
3047         int ret, err;
3048
3049         path = btrfs_alloc_path();
3050         if (!path)
3051                 return -ENOMEM;
3052
3053         trans = btrfs_start_transaction(root, 0);
3054         if (IS_ERR(trans)) {
3055                 btrfs_free_path(path);
3056                 return PTR_ERR(trans);
3057         }
3058
3059         key.objectid = BTRFS_BALANCE_OBJECTID;
3060         key.type = BTRFS_TEMPORARY_ITEM_KEY;
3061         key.offset = 0;
3062
3063         ret = btrfs_insert_empty_item(trans, root, path, &key,
3064                                       sizeof(*item));
3065         if (ret)
3066                 goto out;
3067
3068         leaf = path->nodes[0];
3069         item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item);
3070
3071         memzero_extent_buffer(leaf, (unsigned long)item, sizeof(*item));
3072
3073         btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->data);
3074         btrfs_set_balance_data(leaf, item, &disk_bargs);
3075         btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->meta);
3076         btrfs_set_balance_meta(leaf, item, &disk_bargs);
3077         btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->sys);
3078         btrfs_set_balance_sys(leaf, item, &disk_bargs);
3079
3080         btrfs_set_balance_flags(leaf, item, bctl->flags);
3081
3082         btrfs_mark_buffer_dirty(leaf);
3083 out:
3084         btrfs_free_path(path);
3085         err = btrfs_commit_transaction(trans);
3086         if (err && !ret)
3087                 ret = err;
3088         return ret;
3089 }
3090
3091 static int del_balance_item(struct btrfs_fs_info *fs_info)
3092 {
3093         struct btrfs_root *root = fs_info->tree_root;
3094         struct btrfs_trans_handle *trans;
3095         struct btrfs_path *path;
3096         struct btrfs_key key;
3097         int ret, err;
3098
3099         path = btrfs_alloc_path();
3100         if (!path)
3101                 return -ENOMEM;
3102
3103         trans = btrfs_start_transaction(root, 0);
3104         if (IS_ERR(trans)) {
3105                 btrfs_free_path(path);
3106                 return PTR_ERR(trans);
3107         }
3108
3109         key.objectid = BTRFS_BALANCE_OBJECTID;
3110         key.type = BTRFS_TEMPORARY_ITEM_KEY;
3111         key.offset = 0;
3112
3113         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
3114         if (ret < 0)
3115                 goto out;
3116         if (ret > 0) {
3117                 ret = -ENOENT;
3118                 goto out;
3119         }
3120
3121         ret = btrfs_del_item(trans, root, path);
3122 out:
3123         btrfs_free_path(path);
3124         err = btrfs_commit_transaction(trans);
3125         if (err && !ret)
3126                 ret = err;
3127         return ret;
3128 }
3129
3130 /*
3131  * This is a heuristic used to reduce the number of chunks balanced on
3132  * resume after balance was interrupted.
3133  */
3134 static void update_balance_args(struct btrfs_balance_control *bctl)
3135 {
3136         /*
3137          * Turn on soft mode for chunk types that were being converted.
3138          */
3139         if (bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT)
3140                 bctl->data.flags |= BTRFS_BALANCE_ARGS_SOFT;
3141         if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT)
3142                 bctl->sys.flags |= BTRFS_BALANCE_ARGS_SOFT;
3143         if (bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT)
3144                 bctl->meta.flags |= BTRFS_BALANCE_ARGS_SOFT;
3145
3146         /*
3147          * Turn on usage filter if is not already used.  The idea is
3148          * that chunks that we have already balanced should be
3149          * reasonably full.  Don't do it for chunks that are being
3150          * converted - that will keep us from relocating unconverted
3151          * (albeit full) chunks.
3152          */
3153         if (!(bctl->data.flags & BTRFS_BALANCE_ARGS_USAGE) &&
3154             !(bctl->data.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) &&
3155             !(bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT)) {
3156                 bctl->data.flags |= BTRFS_BALANCE_ARGS_USAGE;
3157                 bctl->data.usage = 90;
3158         }
3159         if (!(bctl->sys.flags & BTRFS_BALANCE_ARGS_USAGE) &&
3160             !(bctl->sys.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) &&
3161             !(bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT)) {
3162                 bctl->sys.flags |= BTRFS_BALANCE_ARGS_USAGE;
3163                 bctl->sys.usage = 90;
3164         }
3165         if (!(bctl->meta.flags & BTRFS_BALANCE_ARGS_USAGE) &&
3166             !(bctl->meta.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) &&
3167             !(bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT)) {
3168                 bctl->meta.flags |= BTRFS_BALANCE_ARGS_USAGE;
3169                 bctl->meta.usage = 90;
3170         }
3171 }
3172
3173 /*
3174  * Should be called with both balance and volume mutexes held to
3175  * serialize other volume operations (add_dev/rm_dev/resize) with
3176  * restriper.  Same goes for unset_balance_control.
3177  */
3178 static void set_balance_control(struct btrfs_balance_control *bctl)
3179 {
3180         struct btrfs_fs_info *fs_info = bctl->fs_info;
3181
3182         BUG_ON(fs_info->balance_ctl);
3183
3184         spin_lock(&fs_info->balance_lock);
3185         fs_info->balance_ctl = bctl;
3186         spin_unlock(&fs_info->balance_lock);
3187 }
3188
3189 static void unset_balance_control(struct btrfs_fs_info *fs_info)
3190 {
3191         struct btrfs_balance_control *bctl = fs_info->balance_ctl;
3192
3193         BUG_ON(!fs_info->balance_ctl);
3194
3195         spin_lock(&fs_info->balance_lock);
3196         fs_info->balance_ctl = NULL;
3197         spin_unlock(&fs_info->balance_lock);
3198
3199         kfree(bctl);
3200 }
3201
3202 /*
3203  * Balance filters.  Return 1 if chunk should be filtered out
3204  * (should not be balanced).
3205  */
3206 static int chunk_profiles_filter(u64 chunk_type,
3207                                  struct btrfs_balance_args *bargs)
3208 {
3209         chunk_type = chunk_to_extended(chunk_type) &
3210                                 BTRFS_EXTENDED_PROFILE_MASK;
3211
3212         if (bargs->profiles & chunk_type)
3213                 return 0;
3214
3215         return 1;
3216 }
3217
3218 static int chunk_usage_range_filter(struct btrfs_fs_info *fs_info, u64 chunk_offset,
3219                               struct btrfs_balance_args *bargs)
3220 {
3221         struct btrfs_block_group_cache *cache;
3222         u64 chunk_used;
3223         u64 user_thresh_min;
3224         u64 user_thresh_max;
3225         int ret = 1;
3226
3227         cache = btrfs_lookup_block_group(fs_info, chunk_offset);
3228         chunk_used = btrfs_block_group_used(&cache->item);
3229
3230         if (bargs->usage_min == 0)
3231                 user_thresh_min = 0;
3232         else
3233                 user_thresh_min = div_factor_fine(cache->key.offset,
3234                                         bargs->usage_min);
3235
3236         if (bargs->usage_max == 0)
3237                 user_thresh_max = 1;
3238         else if (bargs->usage_max > 100)
3239                 user_thresh_max = cache->key.offset;
3240         else
3241                 user_thresh_max = div_factor_fine(cache->key.offset,
3242                                         bargs->usage_max);
3243
3244         if (user_thresh_min <= chunk_used && chunk_used < user_thresh_max)
3245                 ret = 0;
3246
3247         btrfs_put_block_group(cache);
3248         return ret;
3249 }
3250
3251 static int chunk_usage_filter(struct btrfs_fs_info *fs_info,
3252                 u64 chunk_offset, struct btrfs_balance_args *bargs)
3253 {
3254         struct btrfs_block_group_cache *cache;
3255         u64 chunk_used, user_thresh;
3256         int ret = 1;
3257
3258         cache = btrfs_lookup_block_group(fs_info, chunk_offset);
3259         chunk_used = btrfs_block_group_used(&cache->item);
3260
3261         if (bargs->usage_min == 0)
3262                 user_thresh = 1;
3263         else if (bargs->usage > 100)
3264                 user_thresh = cache->key.offset;
3265         else
3266                 user_thresh = div_factor_fine(cache->key.offset,
3267                                               bargs->usage);
3268
3269         if (chunk_used < user_thresh)
3270                 ret = 0;
3271
3272         btrfs_put_block_group(cache);
3273         return ret;
3274 }
3275
3276 static int chunk_devid_filter(struct extent_buffer *leaf,
3277                               struct btrfs_chunk *chunk,
3278                               struct btrfs_balance_args *bargs)
3279 {
3280         struct btrfs_stripe *stripe;
3281         int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
3282         int i;
3283
3284         for (i = 0; i < num_stripes; i++) {
3285                 stripe = btrfs_stripe_nr(chunk, i);
3286                 if (btrfs_stripe_devid(leaf, stripe) == bargs->devid)
3287                         return 0;
3288         }
3289
3290         return 1;
3291 }
3292
3293 /* [pstart, pend) */
3294 static int chunk_drange_filter(struct extent_buffer *leaf,
3295                                struct btrfs_chunk *chunk,
3296                                struct btrfs_balance_args *bargs)
3297 {
3298         struct btrfs_stripe *stripe;
3299         int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
3300         u64 stripe_offset;
3301         u64 stripe_length;
3302         int factor;
3303         int i;
3304
3305         if (!(bargs->flags & BTRFS_BALANCE_ARGS_DEVID))
3306                 return 0;
3307
3308         if (btrfs_chunk_type(leaf, chunk) & (BTRFS_BLOCK_GROUP_DUP |
3309              BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID10)) {
3310                 factor = num_stripes / 2;
3311         } else if (btrfs_chunk_type(leaf, chunk) & BTRFS_BLOCK_GROUP_RAID5) {
3312                 factor = num_stripes - 1;
3313         } else if (btrfs_chunk_type(leaf, chunk) & BTRFS_BLOCK_GROUP_RAID6) {
3314                 factor = num_stripes - 2;
3315         } else {
3316                 factor = num_stripes;
3317         }
3318
3319         for (i = 0; i < num_stripes; i++) {
3320                 stripe = btrfs_stripe_nr(chunk, i);
3321                 if (btrfs_stripe_devid(leaf, stripe) != bargs->devid)
3322                         continue;
3323
3324                 stripe_offset = btrfs_stripe_offset(leaf, stripe);
3325                 stripe_length = btrfs_chunk_length(leaf, chunk);
3326                 stripe_length = div_u64(stripe_length, factor);
3327
3328                 if (stripe_offset < bargs->pend &&
3329                     stripe_offset + stripe_length > bargs->pstart)
3330                         return 0;
3331         }
3332
3333         return 1;
3334 }
3335
3336 /* [vstart, vend) */
3337 static int chunk_vrange_filter(struct extent_buffer *leaf,
3338                                struct btrfs_chunk *chunk,
3339                                u64 chunk_offset,
3340                                struct btrfs_balance_args *bargs)
3341 {
3342         if (chunk_offset < bargs->vend &&
3343             chunk_offset + btrfs_chunk_length(leaf, chunk) > bargs->vstart)
3344                 /* at least part of the chunk is inside this vrange */
3345                 return 0;
3346
3347         return 1;
3348 }
3349
3350 static int chunk_stripes_range_filter(struct extent_buffer *leaf,
3351                                struct btrfs_chunk *chunk,
3352                                struct btrfs_balance_args *bargs)
3353 {
3354         int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
3355
3356         if (bargs->stripes_min <= num_stripes
3357                         && num_stripes <= bargs->stripes_max)
3358                 return 0;
3359
3360         return 1;
3361 }
3362
3363 static int chunk_soft_convert_filter(u64 chunk_type,
3364                                      struct btrfs_balance_args *bargs)
3365 {
3366         if (!(bargs->flags & BTRFS_BALANCE_ARGS_CONVERT))
3367                 return 0;
3368
3369         chunk_type = chunk_to_extended(chunk_type) &
3370                                 BTRFS_EXTENDED_PROFILE_MASK;
3371
3372         if (bargs->target == chunk_type)
3373                 return 1;
3374
3375         return 0;
3376 }
3377
3378 static int should_balance_chunk(struct btrfs_fs_info *fs_info,
3379                                 struct extent_buffer *leaf,
3380                                 struct btrfs_chunk *chunk, u64 chunk_offset)
3381 {
3382         struct btrfs_balance_control *bctl = fs_info->balance_ctl;
3383         struct btrfs_balance_args *bargs = NULL;
3384         u64 chunk_type = btrfs_chunk_type(leaf, chunk);
3385
3386         /* type filter */
3387         if (!((chunk_type & BTRFS_BLOCK_GROUP_TYPE_MASK) &
3388               (bctl->flags & BTRFS_BALANCE_TYPE_MASK))) {
3389                 return 0;
3390         }
3391
3392         if (chunk_type & BTRFS_BLOCK_GROUP_DATA)
3393                 bargs = &bctl->data;
3394         else if (chunk_type & BTRFS_BLOCK_GROUP_SYSTEM)
3395                 bargs = &bctl->sys;
3396         else if (chunk_type & BTRFS_BLOCK_GROUP_METADATA)
3397                 bargs = &bctl->meta;
3398
3399         /* profiles filter */
3400         if ((bargs->flags & BTRFS_BALANCE_ARGS_PROFILES) &&
3401             chunk_profiles_filter(chunk_type, bargs)) {
3402                 return 0;
3403         }
3404
3405         /* usage filter */
3406         if ((bargs->flags & BTRFS_BALANCE_ARGS_USAGE) &&
3407             chunk_usage_filter(fs_info, chunk_offset, bargs)) {
3408                 return 0;
3409         } else if ((bargs->flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) &&
3410             chunk_usage_range_filter(fs_info, chunk_offset, bargs)) {
3411                 return 0;
3412         }
3413
3414         /* devid filter */
3415         if ((bargs->flags & BTRFS_BALANCE_ARGS_DEVID) &&
3416             chunk_devid_filter(leaf, chunk, bargs)) {
3417                 return 0;
3418         }