projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Btrfs: allow repair code to include target disk when searching mirrors
[deliverable/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/random.h>
24 #include <linux/iocontext.h>
25 #include <linux/capability.h>
26 #include <linux/ratelimit.h>
27 #include <linux/kthread.h>
28 #include "compat.h"
29 #include "ctree.h"
30 #include "extent_map.h"
31 #include "disk-io.h"
32 #include "transaction.h"
33 #include "print-tree.h"
34 #include "volumes.h"
35 #include "async-thread.h"
36 #include "check-integrity.h"
37 #include "rcu-string.h"
38 #include "math.h"
39 #include "dev-replace.h"
40
41 static int init_first_rw_device(struct btrfs_trans_handle *trans,
42 struct btrfs_root *root,
43 struct btrfs_device *device);
44 static int btrfs_relocate_sys_chunks(struct btrfs_root *root);
45 static void __btrfs_reset_dev_stats(struct btrfs_device *dev);
46 static void btrfs_dev_stat_print_on_load(struct btrfs_device *device);
47
48 static DEFINE_MUTEX(uuid_mutex);
49 static LIST_HEAD(fs_uuids);
50
51 static void lock_chunks(struct btrfs_root *root)
52 {
53 mutex_lock(&root->fs_info->chunk_mutex);
54 }
55
56 static void unlock_chunks(struct btrfs_root *root)
57 {
58 mutex_unlock(&root->fs_info->chunk_mutex);
59 }
60
61 static void free_fs_devices(struct btrfs_fs_devices *fs_devices)
62 {
63 struct btrfs_device *device;
64 WARN_ON(fs_devices->opened);
65 while (!list_empty(&fs_devices->devices)) {
66 device = list_entry(fs_devices->devices.next,
67 struct btrfs_device, dev_list);
68 list_del(&device->dev_list);
69 rcu_string_free(device->name);
70 kfree(device);
71 }
72 kfree(fs_devices);
73 }
74
75 void btrfs_cleanup_fs_uuids(void)
76 {
77 struct btrfs_fs_devices *fs_devices;
78
79 while (!list_empty(&fs_uuids)) {
80 fs_devices = list_entry(fs_uuids.next,
81 struct btrfs_fs_devices, list);
82 list_del(&fs_devices->list);
83 free_fs_devices(fs_devices);
84 }
85 }
86
87 static noinline struct btrfs_device *__find_device(struct list_head *head,
88 u64 devid, u8 *uuid)
89 {
90 struct btrfs_device *dev;
91
92 list_for_each_entry(dev, head, dev_list) {
93 if (dev->devid == devid &&
94 (!uuid || !memcmp(dev->uuid, uuid, BTRFS_UUID_SIZE))) {
95 return dev;
96 }
97 }
98 return NULL;
99 }
100
101 static noinline struct btrfs_fs_devices *find_fsid(u8 *fsid)
102 {
103 struct btrfs_fs_devices *fs_devices;
104
105 list_for_each_entry(fs_devices, &fs_uuids, list) {
106 if (memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE) == 0)
107 return fs_devices;
108 }
109 return NULL;
110 }
111
112 static int
113 btrfs_get_bdev_and_sb(const char *device_path, fmode_t flags, void *holder,
114 int flush, struct block_device **bdev,
115 struct buffer_head **bh)
116 {
117 int ret;
118
119 *bdev = blkdev_get_by_path(device_path, flags, holder);
120
121 if (IS_ERR(*bdev)) {
122 ret = PTR_ERR(*bdev);
123 printk(KERN_INFO "btrfs: open %s failed\n", device_path);
124 goto error;
125 }
126
127 if (flush)
128 filemap_write_and_wait((*bdev)->bd_inode->i_mapping);
129 ret = set_blocksize(*bdev, 4096);
130 if (ret) {
131 blkdev_put(*bdev, flags);
132 goto error;
133 }
134 invalidate_bdev(*bdev);
135 *bh = btrfs_read_dev_super(*bdev);
136 if (!*bh) {
137 ret = -EINVAL;
138 blkdev_put(*bdev, flags);
139 goto error;
140 }
141
142 return 0;
143
144 error:
145 *bdev = NULL;
146 *bh = NULL;
147 return ret;
148 }
149
150 static void requeue_list(struct btrfs_pending_bios *pending_bios,
151 struct bio *head, struct bio *tail)
152 {
153
154 struct bio *old_head;
155
156 old_head = pending_bios->head;
157 pending_bios->head = head;
158 if (pending_bios->tail)
159 tail->bi_next = old_head;
160 else
161 pending_bios->tail = tail;
162 }
163
164 /*
165 * we try to collect pending bios for a device so we don't get a large
166 * number of procs sending bios down to the same device. This greatly
167 * improves the schedulers ability to collect and merge the bios.
168 *
169 * But, it also turns into a long list of bios to process and that is sure
170 * to eventually make the worker thread block. The solution here is to
171 * make some progress and then put this work struct back at the end of
172 * the list if the block device is congested. This way, multiple devices
173 * can make progress from a single worker thread.
174 */
175 static noinline void run_scheduled_bios(struct btrfs_device *device)
176 {
177 struct bio *pending;
178 struct backing_dev_info *bdi;
179 struct btrfs_fs_info *fs_info;
180 struct btrfs_pending_bios *pending_bios;
181 struct bio *tail;
182 struct bio *cur;
183 int again = 0;
184 unsigned long num_run;
185 unsigned long batch_run = 0;
186 unsigned long limit;
187 unsigned long last_waited = 0;
188 int force_reg = 0;
189 int sync_pending = 0;
190 struct blk_plug plug;
191
192 /*
193 * this function runs all the bios we've collected for
194 * a particular device. We don't want to wander off to
195 * another device without first sending all of these down.
196 * So, setup a plug here and finish it off before we return
197 */
198 blk_start_plug(&plug);
199
200 bdi = blk_get_backing_dev_info(device->bdev);
201 fs_info = device->dev_root->fs_info;
202 limit = btrfs_async_submit_limit(fs_info);
203 limit = limit * 2 / 3;
204
205 loop:
206 spin_lock(&device->io_lock);
207
208 loop_lock:
209 num_run = 0;
210
211 /* take all the bios off the list at once and process them
212 * later on (without the lock held). But, remember the
213 * tail and other pointers so the bios can be properly reinserted
214 * into the list if we hit congestion
215 */
216 if (!force_reg && device->pending_sync_bios.head) {
217 pending_bios = &device->pending_sync_bios;
218 force_reg = 1;
219 } else {
220 pending_bios = &device->pending_bios;
221 force_reg = 0;
222 }
223
224 pending = pending_bios->head;
225 tail = pending_bios->tail;
226 WARN_ON(pending && !tail);
227
228 /*
229 * if pending was null this time around, no bios need processing
230 * at all and we can stop. Otherwise it'll loop back up again
231 * and do an additional check so no bios are missed.
232 *
233 * device->running_pending is used to synchronize with the
234 * schedule_bio code.
235 */
236 if (device->pending_sync_bios.head == NULL &&
237 device->pending_bios.head == NULL) {
238 again = 0;
239 device->running_pending = 0;
240 } else {
241 again = 1;
242 device->running_pending = 1;
243 }
244
245 pending_bios->head = NULL;
246 pending_bios->tail = NULL;
247
248 spin_unlock(&device->io_lock);
249
250 while (pending) {
251
252 rmb();
253 /* we want to work on both lists, but do more bios on the
254 * sync list than the regular list
255 */
256 if ((num_run > 32 &&
257 pending_bios != &device->pending_sync_bios &&
258 device->pending_sync_bios.head) ||
259 (num_run > 64 && pending_bios == &device->pending_sync_bios &&
260 device->pending_bios.head)) {
261 spin_lock(&device->io_lock);
262 requeue_list(pending_bios, pending, tail);
263 goto loop_lock;
264 }
265
266 cur = pending;
267 pending = pending->bi_next;
268 cur->bi_next = NULL;
269
270 if (atomic_dec_return(&fs_info->nr_async_bios) < limit &&
271 waitqueue_active(&fs_info->async_submit_wait))
272 wake_up(&fs_info->async_submit_wait);
273
274 BUG_ON(atomic_read(&cur->bi_cnt) == 0);
275
276 /*
277 * if we're doing the sync list, record that our
278 * plug has some sync requests on it
279 *
280 * If we're doing the regular list and there are
281 * sync requests sitting around, unplug before
282 * we add more
283 */
284 if (pending_bios == &device->pending_sync_bios) {
285 sync_pending = 1;
286 } else if (sync_pending) {
287 blk_finish_plug(&plug);
288 blk_start_plug(&plug);
289 sync_pending = 0;
290 }
291
292 btrfsic_submit_bio(cur->bi_rw, cur);
293 num_run++;
294 batch_run++;
295 if (need_resched())
296 cond_resched();
297
298 /*
299 * we made progress, there is more work to do and the bdi
300 * is now congested. Back off and let other work structs
301 * run instead
302 */
303 if (pending && bdi_write_congested(bdi) && batch_run > 8 &&
304 fs_info->fs_devices->open_devices > 1) {
305 struct io_context *ioc;
306
307 ioc = current->io_context;
308
309 /*
310 * the main goal here is that we don't want to
311 * block if we're going to be able to submit
312 * more requests without blocking.
313 *
314 * This code does two great things, it pokes into
315 * the elevator code from a filesystem _and_
316 * it makes assumptions about how batching works.
317 */
318 if (ioc && ioc->nr_batch_requests > 0 &&
319 time_before(jiffies, ioc->last_waited + HZ/50UL) &&
320 (last_waited == 0 ||
321 ioc->last_waited == last_waited)) {
322 /*
323 * we want to go through our batch of
324 * requests and stop. So, we copy out
325 * the ioc->last_waited time and test
326 * against it before looping
327 */
328 last_waited = ioc->last_waited;
329 if (need_resched())
330 cond_resched();
331 continue;
332 }
333 spin_lock(&device->io_lock);
334 requeue_list(pending_bios, pending, tail);
335 device->running_pending = 1;
336
337 spin_unlock(&device->io_lock);
338 btrfs_requeue_work(&device->work);
339 goto done;
340 }
341 /* unplug every 64 requests just for good measure */
342 if (batch_run % 64 == 0) {
343 blk_finish_plug(&plug);
344 blk_start_plug(&plug);
345 sync_pending = 0;
346 }
347 }
348
349 cond_resched();
350 if (again)
351 goto loop;
352
353 spin_lock(&device->io_lock);
354 if (device->pending_bios.head || device->pending_sync_bios.head)
355 goto loop_lock;
356 spin_unlock(&device->io_lock);
357
358 done:
359 blk_finish_plug(&plug);
360 }
361
362 static void pending_bios_fn(struct btrfs_work *work)
363 {
364 struct btrfs_device *device;
365
366 device = container_of(work, struct btrfs_device, work);
367 run_scheduled_bios(device);
368 }
369
370 static noinline int device_list_add(const char *path,
371 struct btrfs_super_block *disk_super,
372 u64 devid, struct btrfs_fs_devices **fs_devices_ret)
373 {
374 struct btrfs_device *device;
375 struct btrfs_fs_devices *fs_devices;
376 struct rcu_string *name;
377 u64 found_transid = btrfs_super_generation(disk_super);
378
379 fs_devices = find_fsid(disk_super->fsid);
380 if (!fs_devices) {
381 fs_devices = kzalloc(sizeof(*fs_devices), GFP_NOFS);
382 if (!fs_devices)
383 return -ENOMEM;
384 INIT_LIST_HEAD(&fs_devices->devices);
385 INIT_LIST_HEAD(&fs_devices->alloc_list);
386 list_add(&fs_devices->list, &fs_uuids);
387 memcpy(fs_devices->fsid, disk_super->fsid, BTRFS_FSID_SIZE);
388 fs_devices->latest_devid = devid;
389 fs_devices->latest_trans = found_transid;
390 mutex_init(&fs_devices->device_list_mutex);
391 device = NULL;
392 } else {
393 device = __find_device(&fs_devices->devices, devid,
394 disk_super->dev_item.uuid);
395 }
396 if (!device) {
397 if (fs_devices->opened)
398 return -EBUSY;
399
400 device = kzalloc(sizeof(*device), GFP_NOFS);
401 if (!device) {
402 /* we can safely leave the fs_devices entry around */
403 return -ENOMEM;
404 }
405 device->devid = devid;
406 device->dev_stats_valid = 0;
407 device->work.func = pending_bios_fn;
408 memcpy(device->uuid, disk_super->dev_item.uuid,
409 BTRFS_UUID_SIZE);
410 spin_lock_init(&device->io_lock);
411
412 name = rcu_string_strdup(path, GFP_NOFS);
413 if (!name) {
414 kfree(device);
415 return -ENOMEM;
416 }
417 rcu_assign_pointer(device->name, name);
418 INIT_LIST_HEAD(&device->dev_alloc_list);
419
420 /* init readahead state */
421 spin_lock_init(&device->reada_lock);
422 device->reada_curr_zone = NULL;
423 atomic_set(&device->reada_in_flight, 0);
424 device->reada_next = 0;
425 INIT_RADIX_TREE(&device->reada_zones, GFP_NOFS & ~__GFP_WAIT);
426 INIT_RADIX_TREE(&device->reada_extents, GFP_NOFS & ~__GFP_WAIT);
427
428 mutex_lock(&fs_devices->device_list_mutex);
429 list_add_rcu(&device->dev_list, &fs_devices->devices);
430 mutex_unlock(&fs_devices->device_list_mutex);
431
432 device->fs_devices = fs_devices;
433 fs_devices->num_devices++;
434 } else if (!device->name || strcmp(device->name->str, path)) {
435 name = rcu_string_strdup(path, GFP_NOFS);
436 if (!name)
437 return -ENOMEM;
438 rcu_string_free(device->name);
439 rcu_assign_pointer(device->name, name);
440 if (device->missing) {
441 fs_devices->missing_devices--;
442 device->missing = 0;
443 }
444 }
445
446 if (found_transid > fs_devices->latest_trans) {
447 fs_devices->latest_devid = devid;
448 fs_devices->latest_trans = found_transid;
449 }
450 *fs_devices_ret = fs_devices;
451 return 0;
452 }
453
454 static struct btrfs_fs_devices *clone_fs_devices(struct btrfs_fs_devices *orig)
455 {
456 struct btrfs_fs_devices *fs_devices;
457 struct btrfs_device *device;
458 struct btrfs_device *orig_dev;
459
460 fs_devices = kzalloc(sizeof(*fs_devices), GFP_NOFS);
461 if (!fs_devices)
462 return ERR_PTR(-ENOMEM);
463
464 INIT_LIST_HEAD(&fs_devices->devices);
465 INIT_LIST_HEAD(&fs_devices->alloc_list);
466 INIT_LIST_HEAD(&fs_devices->list);
467 mutex_init(&fs_devices->device_list_mutex);
468 fs_devices->latest_devid = orig->latest_devid;
469 fs_devices->latest_trans = orig->latest_trans;
470 fs_devices->total_devices = orig->total_devices;
471 memcpy(fs_devices->fsid, orig->fsid, sizeof(fs_devices->fsid));
472
473 /* We have held the volume lock, it is safe to get the devices. */
474 list_for_each_entry(orig_dev, &orig->devices, dev_list) {
475 struct rcu_string *name;
476
477 device = kzalloc(sizeof(*device), GFP_NOFS);
478 if (!device)
479 goto error;
480
481 /*
482 * This is ok to do without rcu read locked because we hold the
483 * uuid mutex so nothing we touch in here is going to disappear.
484 */
485 name = rcu_string_strdup(orig_dev->name->str, GFP_NOFS);
486 if (!name) {
487 kfree(device);
488 goto error;
489 }
490 rcu_assign_pointer(device->name, name);
491
492 device->devid = orig_dev->devid;
493 device->work.func = pending_bios_fn;
494 memcpy(device->uuid, orig_dev->uuid, sizeof(device->uuid));
495 spin_lock_init(&device->io_lock);
496 INIT_LIST_HEAD(&device->dev_list);
497 INIT_LIST_HEAD(&device->dev_alloc_list);
498
499 list_add(&device->dev_list, &fs_devices->devices);
500 device->fs_devices = fs_devices;
501 fs_devices->num_devices++;
502 }
503 return fs_devices;
504 error:
505 free_fs_devices(fs_devices);
506 return ERR_PTR(-ENOMEM);
507 }
508
509 void btrfs_close_extra_devices(struct btrfs_fs_info *fs_info,
510 struct btrfs_fs_devices *fs_devices, int step)
511 {
512 struct btrfs_device *device, *next;
513
514 struct block_device *latest_bdev = NULL;
515 u64 latest_devid = 0;
516 u64 latest_transid = 0;
517
518 mutex_lock(&uuid_mutex);
519 again:
520 /* This is the initialized path, it is safe to release the devices. */
521 list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) {
522 if (device->in_fs_metadata) {
523 if (!device->is_tgtdev_for_dev_replace &&
524 (!latest_transid ||
525 device->generation > latest_transid)) {
526 latest_devid = device->devid;
527 latest_transid = device->generation;
528 latest_bdev = device->bdev;
529 }
530 continue;
531 }
532
533 if (device->devid == BTRFS_DEV_REPLACE_DEVID) {
534 /*
535 * In the first step, keep the device which has
536 * the correct fsid and the devid that is used
537 * for the dev_replace procedure.
538 * In the second step, the dev_replace state is
539 * read from the device tree and it is known
540 * whether the procedure is really active or
541 * not, which means whether this device is
542 * used or whether it should be removed.
543 */
544 if (step == 0 || device->is_tgtdev_for_dev_replace) {
545 continue;
546 }
547 }
548 if (device->bdev) {
549 blkdev_put(device->bdev, device->mode);
550 device->bdev = NULL;
551 fs_devices->open_devices--;
552 }
553 if (device->writeable) {
554 list_del_init(&device->dev_alloc_list);
555 device->writeable = 0;
556 if (!device->is_tgtdev_for_dev_replace)
557 fs_devices->rw_devices--;
558 }
559 list_del_init(&device->dev_list);
560 fs_devices->num_devices--;
561 rcu_string_free(device->name);
562 kfree(device);
563 }
564
565 if (fs_devices->seed) {
566 fs_devices = fs_devices->seed;
567 goto again;
568 }
569
570 fs_devices->latest_bdev = latest_bdev;
571 fs_devices->latest_devid = latest_devid;
572 fs_devices->latest_trans = latest_transid;
573
574 mutex_unlock(&uuid_mutex);
575 }
576
577 static void __free_device(struct work_struct *work)
578 {
579 struct btrfs_device *device;
580
581 device = container_of(work, struct btrfs_device, rcu_work);
582
583 if (device->bdev)
584 blkdev_put(device->bdev, device->mode);
585
586 rcu_string_free(device->name);
587 kfree(device);
588 }
589
590 static void free_device(struct rcu_head *head)
591 {
592 struct btrfs_device *device;
593
594 device = container_of(head, struct btrfs_device, rcu);
595
596 INIT_WORK(&device->rcu_work, __free_device);
597 schedule_work(&device->rcu_work);
598 }
599
600 static int __btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
601 {
602 struct btrfs_device *device;
603
604 if (--fs_devices->opened > 0)
605 return 0;
606
607 mutex_lock(&fs_devices->device_list_mutex);
608 list_for_each_entry(device, &fs_devices->devices, dev_list) {
609 struct btrfs_device *new_device;
610 struct rcu_string *name;
611
612 if (device->bdev)
613 fs_devices->open_devices--;
614
615 if (device->writeable && !device->is_tgtdev_for_dev_replace) {
616 list_del_init(&device->dev_alloc_list);
617 fs_devices->rw_devices--;
618 }
619
620 if (device->can_discard)
621 fs_devices->num_can_discard--;
622
623 new_device = kmalloc(sizeof(*new_device), GFP_NOFS);
624 BUG_ON(!new_device); /* -ENOMEM */
625 memcpy(new_device, device, sizeof(*new_device));
626
627 /* Safe because we are under uuid_mutex */
628 if (device->name) {
629 name = rcu_string_strdup(device->name->str, GFP_NOFS);
630 BUG_ON(device->name && !name); /* -ENOMEM */
631 rcu_assign_pointer(new_device->name, name);
632 }
633 new_device->bdev = NULL;
634 new_device->writeable = 0;
635 new_device->in_fs_metadata = 0;
636 new_device->can_discard = 0;
637 list_replace_rcu(&device->dev_list, &new_device->dev_list);
638
639 call_rcu(&device->rcu, free_device);
640 }
641 mutex_unlock(&fs_devices->device_list_mutex);
642
643 WARN_ON(fs_devices->open_devices);
644 WARN_ON(fs_devices->rw_devices);
645 fs_devices->opened = 0;
646 fs_devices->seeding = 0;
647
648 return 0;
649 }
650
651 int btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
652 {
653 struct btrfs_fs_devices *seed_devices = NULL;
654 int ret;
655
656 mutex_lock(&uuid_mutex);
657 ret = __btrfs_close_devices(fs_devices);
658 if (!fs_devices->opened) {
659 seed_devices = fs_devices->seed;
660 fs_devices->seed = NULL;
661 }
662 mutex_unlock(&uuid_mutex);
663
664 while (seed_devices) {
665 fs_devices = seed_devices;
666 seed_devices = fs_devices->seed;
667 __btrfs_close_devices(fs_devices);
668 free_fs_devices(fs_devices);
669 }
670 return ret;
671 }
672
673 static int __btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
674 fmode_t flags, void *holder)
675 {
676 struct request_queue *q;
677 struct block_device *bdev;
678 struct list_head *head = &fs_devices->devices;
679 struct btrfs_device *device;
680 struct block_device *latest_bdev = NULL;
681 struct buffer_head *bh;
682 struct btrfs_super_block *disk_super;
683 u64 latest_devid = 0;
684 u64 latest_transid = 0;
685 u64 devid;
686 int seeding = 1;
687 int ret = 0;
688
689 flags |= FMODE_EXCL;
690
691 list_for_each_entry(device, head, dev_list) {
692 if (device->bdev)
693 continue;
694 if (!device->name)
695 continue;
696
697 ret = btrfs_get_bdev_and_sb(device->name->str, flags, holder, 1,
698 &bdev, &bh);
699 if (ret)
700 continue;
701
702 disk_super = (struct btrfs_super_block *)bh->b_data;
703 devid = btrfs_stack_device_id(&disk_super->dev_item);
704 if (devid != device->devid)
705 goto error_brelse;
706
707 if (memcmp(device->uuid, disk_super->dev_item.uuid,
708 BTRFS_UUID_SIZE))
709 goto error_brelse;
710
711 device->generation = btrfs_super_generation(disk_super);
712 if (!latest_transid || device->generation > latest_transid) {
713 latest_devid = devid;
714 latest_transid = device->generation;
715 latest_bdev = bdev;
716 }
717
718 if (btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_SEEDING) {
719 device->writeable = 0;
720 } else {
721 device->writeable = !bdev_read_only(bdev);
722 seeding = 0;
723 }
724
725 q = bdev_get_queue(bdev);
726 if (blk_queue_discard(q)) {
727 device->can_discard = 1;
728 fs_devices->num_can_discard++;
729 }
730
731 device->bdev = bdev;
732 device->in_fs_metadata = 0;
733 device->mode = flags;
734
735 if (!blk_queue_nonrot(bdev_get_queue(bdev)))
736 fs_devices->rotating = 1;
737
738 fs_devices->open_devices++;
739 if (device->writeable && !device->is_tgtdev_for_dev_replace) {
740 fs_devices->rw_devices++;
741 list_add(&device->dev_alloc_list,
742 &fs_devices->alloc_list);
743 }
744 brelse(bh);
745 continue;
746
747 error_brelse:
748 brelse(bh);
749 blkdev_put(bdev, flags);
750 continue;
751 }
752 if (fs_devices->open_devices == 0) {
753 ret = -EINVAL;
754 goto out;
755 }
756 fs_devices->seeding = seeding;
757 fs_devices->opened = 1;
758 fs_devices->latest_bdev = latest_bdev;
759 fs_devices->latest_devid = latest_devid;
760 fs_devices->latest_trans = latest_transid;
761 fs_devices->total_rw_bytes = 0;
762 out:
763 return ret;
764 }
765
766 int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
767 fmode_t flags, void *holder)
768 {
769 int ret;
770
771 mutex_lock(&uuid_mutex);
772 if (fs_devices->opened) {
773 fs_devices->opened++;
774 ret = 0;
775 } else {
776 ret = __btrfs_open_devices(fs_devices, flags, holder);
777 }
778 mutex_unlock(&uuid_mutex);
779 return ret;
780 }
781
782 int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
783 struct btrfs_fs_devices **fs_devices_ret)
784 {
785 struct btrfs_super_block *disk_super;
786 struct block_device *bdev;
787 struct buffer_head *bh;
788 int ret;
789 u64 devid;
790 u64 transid;
791 u64 total_devices;
792
793 flags |= FMODE_EXCL;
794 mutex_lock(&uuid_mutex);
795 ret = btrfs_get_bdev_and_sb(path, flags, holder, 0, &bdev, &bh);
796 if (ret)
797 goto error;
798 disk_super = (struct btrfs_super_block *)bh->b_data;
799 devid = btrfs_stack_device_id(&disk_super->dev_item);
800 transid = btrfs_super_generation(disk_super);
801 total_devices = btrfs_super_num_devices(disk_super);
802 if (disk_super->label[0]) {
803 if (disk_super->label[BTRFS_LABEL_SIZE - 1])
804 disk_super->label[BTRFS_LABEL_SIZE - 1] = '\0';
805 printk(KERN_INFO "device label %s ", disk_super->label);
806 } else {
807 printk(KERN_INFO "device fsid %pU ", disk_super->fsid);
808 }
809 printk(KERN_CONT "devid %llu transid %llu %s\n",
810 (unsigned long long)devid, (unsigned long long)transid, path);
811 ret = device_list_add(path, disk_super, devid, fs_devices_ret);
812 if (!ret && fs_devices_ret)
813 (*fs_devices_ret)->total_devices = total_devices;
814 brelse(bh);
815 blkdev_put(bdev, flags);
816 error:
817 mutex_unlock(&uuid_mutex);
818 return ret;
819 }
820
821 /* helper to account the used device space in the range */
822 int btrfs_account_dev_extents_size(struct btrfs_device *device, u64 start,
823 u64 end, u64 *length)
824 {
825 struct btrfs_key key;
826 struct btrfs_root *root = device->dev_root;
827 struct btrfs_dev_extent *dev_extent;
828 struct btrfs_path *path;
829 u64 extent_end;
830 int ret;
831 int slot;
832 struct extent_buffer *l;
833
834 *length = 0;
835
836 if (start >= device->total_bytes || device->is_tgtdev_for_dev_replace)
837 return 0;
838
839 path = btrfs_alloc_path();
840 if (!path)
841 return -ENOMEM;
842 path->reada = 2;
843
844 key.objectid = device->devid;
845 key.offset = start;
846 key.type = BTRFS_DEV_EXTENT_KEY;
847
848 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
849 if (ret < 0)
850 goto out;
851 if (ret > 0) {
852 ret = btrfs_previous_item(root, path, key.objectid, key.type);
853 if (ret < 0)
854 goto out;
855 }
856
857 while (1) {
858 l = path->nodes[0];
859 slot = path->slots[0];
860 if (slot >= btrfs_header_nritems(l)) {
861 ret = btrfs_next_leaf(root, path);
862 if (ret == 0)
863 continue;
864 if (ret < 0)
865 goto out;
866
867 break;
868 }
869 btrfs_item_key_to_cpu(l, &key, slot);
870
871 if (key.objectid < device->devid)
872 goto next;
873
874 if (key.objectid > device->devid)
875 break;
876
877 if (btrfs_key_type(&key) != BTRFS_DEV_EXTENT_KEY)
878 goto next;
879
880 dev_extent = btrfs_item_ptr(l, slot, struct btrfs_dev_extent);
881 extent_end = key.offset + btrfs_dev_extent_length(l,
882 dev_extent);
883 if (key.offset <= start && extent_end > end) {
884 *length = end - start + 1;
885 break;
886 } else if (key.offset <= start && extent_end > start)
887 *length += extent_end - start;
888 else if (key.offset > start && extent_end <= end)
889 *length += extent_end - key.offset;
890 else if (key.offset > start && key.offset <= end) {
891 *length += end - key.offset + 1;
892 break;
893 } else if (key.offset > end)
894 break;
895
896 next:
897 path->slots[0]++;
898 }
899 ret = 0;
900 out:
901 btrfs_free_path(path);
902 return ret;
903 }
904
905 /*
906 * find_free_dev_extent - find free space in the specified device
907 * @device: the device which we search the free space in
908 * @num_bytes: the size of the free space that we need
909 * @start: store the start of the free space.
910 * @len: the size of the free space. that we find, or the size of the max
911 * free space if we don't find suitable free space
912 *
913 * this uses a pretty simple search, the expectation is that it is
914 * called very infrequently and that a given device has a small number
915 * of extents
916 *
917 * @start is used to store the start of the free space if we find. But if we
918 * don't find suitable free space, it will be used to store the start position
919 * of the max free space.
920 *
921 * @len is used to store the size of the free space that we find.
922 * But if we don't find suitable free space, it is used to store the size of
923 * the max free space.
924 */
925 int find_free_dev_extent(struct btrfs_device *device, u64 num_bytes,
926 u64 *start, u64 *len)
927 {
928 struct btrfs_key key;
929 struct btrfs_root *root = device->dev_root;
930 struct btrfs_dev_extent *dev_extent;
931 struct btrfs_path *path;
932 u64 hole_size;
933 u64 max_hole_start;
934 u64 max_hole_size;
935 u64 extent_end;
936 u64 search_start;
937 u64 search_end = device->total_bytes;
938 int ret;
939 int slot;
940 struct extent_buffer *l;
941
942 /* FIXME use last free of some kind */
943
944 /* we don't want to overwrite the superblock on the drive,
945 * so we make sure to start at an offset of at least 1MB
946 */
947 search_start = max(root->fs_info->alloc_start, 1024ull * 1024);
948
949 max_hole_start = search_start;
950 max_hole_size = 0;
951 hole_size = 0;
952
953 if (search_start >= search_end || device->is_tgtdev_for_dev_replace) {
954 ret = -ENOSPC;
955 goto error;
956 }
957
958 path = btrfs_alloc_path();
959 if (!path) {
960 ret = -ENOMEM;
961 goto error;
962 }
963 path->reada = 2;
964
965 key.objectid = device->devid;
966 key.offset = search_start;
967 key.type = BTRFS_DEV_EXTENT_KEY;
968
969 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
970 if (ret < 0)
971 goto out;
972 if (ret > 0) {
973 ret = btrfs_previous_item(root, path, key.objectid, key.type);
974 if (ret < 0)
975 goto out;
976 }
977
978 while (1) {
979 l = path->nodes[0];
980 slot = path->slots[0];
981 if (slot >= btrfs_header_nritems(l)) {
982 ret = btrfs_next_leaf(root, path);
983 if (ret == 0)
984 continue;
985 if (ret < 0)
986 goto out;
987
988 break;
989 }
990 btrfs_item_key_to_cpu(l, &key, slot);
991
992 if (key.objectid < device->devid)
993 goto next;
994
995 if (key.objectid > device->devid)
996 break;
997
998 if (btrfs_key_type(&key) != BTRFS_DEV_EXTENT_KEY)
999 goto next;
1000
1001 if (key.offset > search_start) {
1002 hole_size = key.offset - search_start;
1003
1004 if (hole_size > max_hole_size) {
1005 max_hole_start = search_start;
1006 max_hole_size = hole_size;
1007 }
1008
1009 /*
1010 * If this free space is greater than which we need,
1011 * it must be the max free space that we have found
1012 * until now, so max_hole_start must point to the start
1013 * of this free space and the length of this free space
1014 * is stored in max_hole_size. Thus, we return
1015 * max_hole_start and max_hole_size and go back to the
1016 * caller.
1017 */
1018 if (hole_size >= num_bytes) {
1019 ret = 0;
1020 goto out;
1021 }
1022 }
1023
1024 dev_extent = btrfs_item_ptr(l, slot, struct btrfs_dev_extent);
1025 extent_end = key.offset + btrfs_dev_extent_length(l,
1026 dev_extent);
1027 if (extent_end > search_start)
1028 search_start = extent_end;
1029 next:
1030 path->slots[0]++;
1031 cond_resched();
1032 }
1033
1034 /*
1035 * At this point, search_start should be the end of
1036 * allocated dev extents, and when shrinking the device,
1037 * search_end may be smaller than search_start.
1038 */
1039 if (search_end > search_start)
1040 hole_size = search_end - search_start;
1041
1042 if (hole_size > max_hole_size) {
1043 max_hole_start = search_start;
1044 max_hole_size = hole_size;
1045 }
1046
1047 /* See above. */
1048 if (hole_size < num_bytes)
1049 ret = -ENOSPC;
1050 else
1051 ret = 0;
1052
1053 out:
1054 btrfs_free_path(path);
1055 error:
1056 *start = max_hole_start;
1057 if (len)
1058 *len = max_hole_size;
1059 return ret;
1060 }
1061
1062 static int btrfs_free_dev_extent(struct btrfs_trans_handle *trans,
1063 struct btrfs_device *device,
1064 u64 start)
1065 {
1066 int ret;
1067 struct btrfs_path *path;
1068 struct btrfs_root *root = device->dev_root;
1069 struct btrfs_key key;
1070 struct btrfs_key found_key;
1071 struct extent_buffer *leaf = NULL;
1072 struct btrfs_dev_extent *extent = NULL;
1073
1074 path = btrfs_alloc_path();
1075 if (!path)
1076 return -ENOMEM;
1077
1078 key.objectid = device->devid;
1079 key.offset = start;
1080 key.type = BTRFS_DEV_EXTENT_KEY;
1081 again:
1082 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1083 if (ret > 0) {
1084 ret = btrfs_previous_item(root, path, key.objectid,
1085 BTRFS_DEV_EXTENT_KEY);
1086 if (ret)
1087 goto out;
1088 leaf = path->nodes[0];
1089 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
1090 extent = btrfs_item_ptr(leaf, path->slots[0],
1091 struct btrfs_dev_extent);
1092 BUG_ON(found_key.offset > start || found_key.offset +
1093 btrfs_dev_extent_length(leaf, extent) < start);
1094 key = found_key;
1095 btrfs_release_path(path);
1096 goto again;
1097 } else if (ret == 0) {
1098 leaf = path->nodes[0];
1099 extent = btrfs_item_ptr(leaf, path->slots[0],
1100 struct btrfs_dev_extent);
1101 } else {
1102 btrfs_error(root->fs_info, ret, "Slot search failed");
1103 goto out;
1104 }
1105
1106 if (device->bytes_used > 0) {
1107 u64 len = btrfs_dev_extent_length(leaf, extent);
1108 device->bytes_used -= len;
1109 spin_lock(&root->fs_info->free_chunk_lock);
1110 root->fs_info->free_chunk_space += len;
1111 spin_unlock(&root->fs_info->free_chunk_lock);
1112 }
1113 ret = btrfs_del_item(trans, root, path);
1114 if (ret) {
1115 btrfs_error(root->fs_info, ret,
1116 "Failed to remove dev extent item");
1117 }
1118 out:
1119 btrfs_free_path(path);
1120 return ret;
1121 }
1122
1123 int btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans,
1124 struct btrfs_device *device,
1125 u64 chunk_tree, u64 chunk_objectid,
1126 u64 chunk_offset, u64 start, u64 num_bytes)
1127 {
1128 int ret;
1129 struct btrfs_path *path;
1130 struct btrfs_root *root = device->dev_root;
1131 struct btrfs_dev_extent *extent;
1132 struct extent_buffer *leaf;
1133 struct btrfs_key key;
1134
1135 WARN_ON(!device->in_fs_metadata);
1136 WARN_ON(device->is_tgtdev_for_dev_replace);
1137 path = btrfs_alloc_path();
1138 if (!path)
1139 return -ENOMEM;
1140
1141 key.objectid = device->devid;
1142 key.offset = start;
1143 key.type = BTRFS_DEV_EXTENT_KEY;
1144 ret = btrfs_insert_empty_item(trans, root, path, &key,
1145 sizeof(*extent));
1146 if (ret)
1147 goto out;
1148
1149 leaf = path->nodes[0];
1150 extent = btrfs_item_ptr(leaf, path->slots[0],
1151 struct btrfs_dev_extent);
1152 btrfs_set_dev_extent_chunk_tree(leaf, extent, chunk_tree);
1153 btrfs_set_dev_extent_chunk_objectid(leaf, extent, chunk_objectid);
1154 btrfs_set_dev_extent_chunk_offset(leaf, extent, chunk_offset);
1155
1156 write_extent_buffer(leaf, root->fs_info->chunk_tree_uuid,
1157 (unsigned long)btrfs_dev_extent_chunk_tree_uuid(extent),
1158 BTRFS_UUID_SIZE);
1159
1160 btrfs_set_dev_extent_length(leaf, extent, num_bytes);
1161 btrfs_mark_buffer_dirty(leaf);
1162 out:
1163 btrfs_free_path(path);
1164 return ret;
1165 }
1166
1167 static noinline int find_next_chunk(struct btrfs_root *root,
1168 u64 objectid, u64 *offset)
1169 {
1170 struct btrfs_path *path;
1171 int ret;
1172 struct btrfs_key key;
1173 struct btrfs_chunk *chunk;
1174 struct btrfs_key found_key;
1175
1176 path = btrfs_alloc_path();
1177 if (!path)
1178 return -ENOMEM;
1179
1180 key.objectid = objectid;
1181 key.offset = (u64)-1;
1182 key.type = BTRFS_CHUNK_ITEM_KEY;
1183
1184 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1185 if (ret < 0)
1186 goto error;
1187
1188 BUG_ON(ret == 0); /* Corruption */
1189
1190 ret = btrfs_previous_item(root, path, 0, BTRFS_CHUNK_ITEM_KEY);
1191 if (ret) {
1192 *offset = 0;
1193 } else {
1194 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
1195 path->slots[0]);
1196 if (found_key.objectid != objectid)
1197 *offset = 0;
1198 else {
1199 chunk = btrfs_item_ptr(path->nodes[0], path->slots[0],
1200 struct btrfs_chunk);
1201 *offset = found_key.offset +
1202 btrfs_chunk_length(path->nodes[0], chunk);
1203 }
1204 }
1205 ret = 0;
1206 error:
1207 btrfs_free_path(path);
1208 return ret;
1209 }
1210
1211 static noinline int find_next_devid(struct btrfs_root *root, u64 *objectid)
1212 {
1213 int ret;
1214 struct btrfs_key key;
1215 struct btrfs_key found_key;
1216 struct btrfs_path *path;
1217
1218 root = root->fs_info->chunk_root;
1219
1220 path = btrfs_alloc_path();
1221 if (!path)
1222 return -ENOMEM;
1223
1224 key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
1225 key.type = BTRFS_DEV_ITEM_KEY;
1226 key.offset = (u64)-1;
1227
1228 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1229 if (ret < 0)
1230 goto error;
1231
1232 BUG_ON(ret == 0); /* Corruption */
1233
1234 ret = btrfs_previous_item(root, path, BTRFS_DEV_ITEMS_OBJECTID,
1235 BTRFS_DEV_ITEM_KEY);
1236 if (ret) {
1237 *objectid = 1;
1238 } else {
1239 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
1240 path->slots[0]);
1241 *objectid = found_key.offset + 1;
1242 }
1243 ret = 0;
1244 error:
1245 btrfs_free_path(path);
1246 return ret;
1247 }
1248
1249 /*
1250 * the device information is stored in the chunk root
1251 * the btrfs_device struct should be fully filled in
1252 */
1253 int btrfs_add_device(struct btrfs_trans_handle *trans,
1254 struct btrfs_root *root,
1255 struct btrfs_device *device)
1256 {
1257 int ret;
1258 struct btrfs_path *path;
1259 struct btrfs_dev_item *dev_item;
1260 struct extent_buffer *leaf;
1261 struct btrfs_key key;
1262 unsigned long ptr;
1263
1264 root = root->fs_info->chunk_root;
1265
1266 path = btrfs_alloc_path();
1267 if (!path)
1268 return -ENOMEM;
1269
1270 key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
1271 key.type = BTRFS_DEV_ITEM_KEY;
1272 key.offset = device->devid;
1273
1274 ret = btrfs_insert_empty_item(trans, root, path, &key,
1275 sizeof(*dev_item));
1276 if (ret)
1277 goto out;
1278
1279 leaf = path->nodes[0];
1280 dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item);
1281
1282 btrfs_set_device_id(leaf, dev_item, device->devid);
1283 btrfs_set_device_generation(leaf, dev_item, 0);
1284 btrfs_set_device_type(leaf, dev_item, device->type);
1285 btrfs_set_device_io_align(leaf, dev_item, device->io_align);
1286 btrfs_set_device_io_width(leaf, dev_item, device->io_width);
1287 btrfs_set_device_sector_size(leaf, dev_item, device->sector_size);
1288 btrfs_set_device_total_bytes(leaf, dev_item, device->total_bytes);
1289 btrfs_set_device_bytes_used(leaf, dev_item, device->bytes_used);
1290 btrfs_set_device_group(leaf, dev_item, 0);
1291 btrfs_set_device_seek_speed(leaf, dev_item, 0);
1292 btrfs_set_device_bandwidth(leaf, dev_item, 0);
1293 btrfs_set_device_start_offset(leaf, dev_item, 0);
1294
1295 ptr = (unsigned long)btrfs_device_uuid(dev_item);
1296 write_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE);
1297 ptr = (unsigned long)btrfs_device_fsid(dev_item);
1298 write_extent_buffer(leaf, root->fs_info->fsid, ptr, BTRFS_UUID_SIZE);
1299 btrfs_mark_buffer_dirty(leaf);
1300
1301 ret = 0;
1302 out:
1303 btrfs_free_path(path);
1304 return ret;
1305 }
1306
1307 static int btrfs_rm_dev_item(struct btrfs_root *root,
1308 struct btrfs_device *device)
1309 {
1310 int ret;
1311 struct btrfs_path *path;
1312 struct btrfs_key key;
1313 struct btrfs_trans_handle *trans;
1314
1315 root = root->fs_info->chunk_root;
1316
1317 path = btrfs_alloc_path();
1318 if (!path)
1319 return -ENOMEM;
1320
1321 trans = btrfs_start_transaction(root, 0);
1322 if (IS_ERR(trans)) {
1323 btrfs_free_path(path);
1324 return PTR_ERR(trans);
1325 }
1326 key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
1327 key.type = BTRFS_DEV_ITEM_KEY;
1328 key.offset = device->devid;
1329 lock_chunks(root);
1330
1331 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1332 if (ret < 0)
1333 goto out;
1334
1335 if (ret > 0) {
1336 ret = -ENOENT;
1337 goto out;
1338 }
1339
1340 ret = btrfs_del_item(trans, root, path);
1341 if (ret)
1342 goto out;
1343 out:
1344 btrfs_free_path(path);
1345 unlock_chunks(root);
1346 btrfs_commit_transaction(trans, root);
1347 return ret;
1348 }
1349
1350 int btrfs_rm_device(struct btrfs_root *root, char *device_path)
1351 {
1352 struct btrfs_device *device;
1353 struct btrfs_device *next_device;
1354 struct block_device *bdev;
1355 struct buffer_head *bh = NULL;
1356 struct btrfs_super_block *disk_super;
1357 struct btrfs_fs_devices *cur_devices;
1358 u64 all_avail;
1359 u64 devid;
1360 u64 num_devices;
1361 u8 *dev_uuid;
1362 int ret = 0;
1363 bool clear_super = false;
1364
1365 mutex_lock(&uuid_mutex);
1366
1367 all_avail = root->fs_info->avail_data_alloc_bits |
1368 root->fs_info->avail_system_alloc_bits |
1369 root->fs_info->avail_metadata_alloc_bits;
1370
1371 num_devices = root->fs_info->fs_devices->num_devices;
1372 btrfs_dev_replace_lock(&root->fs_info->dev_replace);
1373 if (btrfs_dev_replace_is_ongoing(&root->fs_info->dev_replace)) {
1374 WARN_ON(num_devices < 1);
1375 num_devices--;
1376 }
1377 btrfs_dev_replace_unlock(&root->fs_info->dev_replace);
1378
1379 if ((all_avail & BTRFS_BLOCK_GROUP_RAID10) && num_devices <= 4) {
1380 printk(KERN_ERR "btrfs: unable to go below four devices "
1381 "on raid10\n");
1382 ret = -EINVAL;
1383 goto out;
1384 }
1385
1386 if ((all_avail & BTRFS_BLOCK_GROUP_RAID1) && num_devices <= 2) {
1387 printk(KERN_ERR "btrfs: unable to go below two "
1388 "devices on raid1\n");
1389 ret = -EINVAL;
1390 goto out;
1391 }
1392
1393 if (strcmp(device_path, "missing") == 0) {
1394 struct list_head *devices;
1395 struct btrfs_device *tmp;
1396
1397 device = NULL;
1398 devices = &root->fs_info->fs_devices->devices;
1399 /*
1400 * It is safe to read the devices since the volume_mutex
1401 * is held.
1402 */
1403 list_for_each_entry(tmp, devices, dev_list) {
1404 if (tmp->in_fs_metadata &&
1405 !tmp->is_tgtdev_for_dev_replace &&
1406 !tmp->bdev) {
1407 device = tmp;
1408 break;
1409 }
1410 }
1411 bdev = NULL;
1412 bh = NULL;
1413 disk_super = NULL;
1414 if (!device) {
1415 printk(KERN_ERR "btrfs: no missing devices found to "
1416 "remove\n");
1417 goto out;
1418 }
1419 } else {
1420 ret = btrfs_get_bdev_and_sb(device_path,
1421 FMODE_READ | FMODE_EXCL,
1422 root->fs_info->bdev_holder, 0,
1423 &bdev, &bh);
1424 if (ret)
1425 goto out;
1426 disk_super = (struct btrfs_super_block *)bh->b_data;
1427 devid = btrfs_stack_device_id(&disk_super->dev_item);
1428 dev_uuid = disk_super->dev_item.uuid;
1429 device = btrfs_find_device(root->fs_info, devid, dev_uuid,
1430 disk_super->fsid);
1431 if (!device) {
1432 ret = -ENOENT;
1433 goto error_brelse;
1434 }
1435 }
1436
1437 if (device->is_tgtdev_for_dev_replace) {
1438 pr_err("btrfs: unable to remove the dev_replace target dev\n");
1439 ret = -EINVAL;
1440 goto error_brelse;
1441 }
1442
1443 if (device->writeable && root->fs_info->fs_devices->rw_devices == 1) {
1444 printk(KERN_ERR "btrfs: unable to remove the only writeable "
1445 "device\n");
1446 ret = -EINVAL;
1447 goto error_brelse;
1448 }
1449
1450 if (device->writeable) {
1451 lock_chunks(root);
1452 list_del_init(&device->dev_alloc_list);
1453 unlock_chunks(root);
1454 root->fs_info->fs_devices->rw_devices--;
1455 clear_super = true;
1456 }
1457
1458 ret = btrfs_shrink_device(device, 0);
1459 if (ret)
1460 goto error_undo;
1461
1462 /*
1463 * TODO: the superblock still includes this device in its num_devices
1464 * counter although write_all_supers() is not locked out. This
1465 * could give a filesystem state which requires a degraded mount.
1466 */
1467 ret = btrfs_rm_dev_item(root->fs_info->chunk_root, device);
1468 if (ret)
1469 goto error_undo;
1470
1471 spin_lock(&root->fs_info->free_chunk_lock);
1472 root->fs_info->free_chunk_space = device->total_bytes -
1473 device->bytes_used;
1474 spin_unlock(&root->fs_info->free_chunk_lock);
1475
1476 device->in_fs_metadata = 0;
1477 btrfs_scrub_cancel_dev(root->fs_info, device);
1478
1479 /*
1480 * the device list mutex makes sure that we don't change
1481 * the device list while someone else is writing out all
1482 * the device supers.
1483 */
1484
1485 cur_devices = device->fs_devices;
1486 mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
1487 list_del_rcu(&device->dev_list);
1488
1489 device->fs_devices->num_devices--;
1490 device->fs_devices->total_devices--;
1491
1492 if (device->missing)
1493 root->fs_info->fs_devices->missing_devices--;
1494
1495 next_device = list_entry(root->fs_info->fs_devices->devices.next,
1496 struct btrfs_device, dev_list);
1497 if (device->bdev == root->fs_info->sb->s_bdev)
1498 root->fs_info->sb->s_bdev = next_device->bdev;
1499 if (device->bdev == root->fs_info->fs_devices->latest_bdev)
1500 root->fs_info->fs_devices->latest_bdev = next_device->bdev;
1501
1502 if (device->bdev)
1503 device->fs_devices->open_devices--;
1504
1505 call_rcu(&device->rcu, free_device);
1506 mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
1507
1508 num_devices = btrfs_super_num_devices(root->fs_info->super_copy) - 1;
1509 btrfs_set_super_num_devices(root->fs_info->super_copy, num_devices);
1510
1511 if (cur_devices->open_devices == 0) {
1512 struct btrfs_fs_devices *fs_devices;
1513 fs_devices = root->fs_info->fs_devices;
1514 while (fs_devices) {
1515 if (fs_devices->seed == cur_devices)
1516 break;
1517 fs_devices = fs_devices->seed;
1518 }
1519 fs_devices->seed = cur_devices->seed;
1520 cur_devices->seed = NULL;
1521 lock_chunks(root);
1522 __btrfs_close_devices(cur_devices);
1523 unlock_chunks(root);
1524 free_fs_devices(cur_devices);
1525 }
1526
1527 root->fs_info->num_tolerated_disk_barrier_failures =
1528 btrfs_calc_num_tolerated_disk_barrier_failures(root->fs_info);
1529
1530 /*
1531 * at this point, the device is zero sized. We want to
1532 * remove it from the devices list and zero out the old super
1533 */
1534 if (clear_super && disk_super) {
1535 /* make sure this device isn't detected as part of
1536 * the FS anymore
1537 */
1538 memset(&disk_super->magic, 0, sizeof(disk_super->magic));
1539 set_buffer_dirty(bh);
1540 sync_dirty_buffer(bh);
1541 }
1542
1543 ret = 0;
1544
1545 error_brelse:
1546 brelse(bh);
1547 error_close:
1548 if (bdev)
1549 blkdev_put(bdev, FMODE_READ | FMODE_EXCL);
1550 out:
1551 mutex_unlock(&uuid_mutex);
1552 return ret;
1553 error_undo:
1554 if (device->writeable) {
1555 lock_chunks(root);
1556 list_add(&device->dev_alloc_list,
1557 &root->fs_info->fs_devices->alloc_list);
1558 unlock_chunks(root);
1559 root->fs_info->fs_devices->rw_devices++;
1560 }
1561 goto error_brelse;
1562 }
1563
1564 void btrfs_rm_dev_replace_srcdev(struct btrfs_fs_info *fs_info,
1565 struct btrfs_device *srcdev)
1566 {
1567 WARN_ON(!mutex_is_locked(&fs_info->fs_devices->device_list_mutex));
1568 list_del_rcu(&srcdev->dev_list);
1569 list_del_rcu(&srcdev->dev_alloc_list);
1570 fs_info->fs_devices->num_devices--;
1571 if (srcdev->missing) {
1572 fs_info->fs_devices->missing_devices--;
1573 fs_info->fs_devices->rw_devices++;
1574 }
1575 if (srcdev->can_discard)
1576 fs_info->fs_devices->num_can_discard--;
1577 if (srcdev->bdev)
1578 fs_info->fs_devices->open_devices--;
1579
1580 call_rcu(&srcdev->rcu, free_device);
1581 }
1582
1583 void btrfs_destroy_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
1584 struct btrfs_device *tgtdev)
1585 {
1586 struct btrfs_device *next_device;
1587
1588 WARN_ON(!tgtdev);
1589 mutex_lock(&fs_info->fs_devices->device_list_mutex);
1590 if (tgtdev->bdev) {
1591 btrfs_scratch_superblock(tgtdev);
1592 fs_info->fs_devices->open_devices--;
1593 }
1594 fs_info->fs_devices->num_devices--;
1595 if (tgtdev->can_discard)
1596 fs_info->fs_devices->num_can_discard++;
1597
1598 next_device = list_entry(fs_info->fs_devices->devices.next,
1599 struct btrfs_device, dev_list);
1600 if (tgtdev->bdev == fs_info->sb->s_bdev)
1601 fs_info->sb->s_bdev = next_device->bdev;
1602 if (tgtdev->bdev == fs_info->fs_devices->latest_bdev)
1603 fs_info->fs_devices->latest_bdev = next_device->bdev;
1604 list_del_rcu(&tgtdev->dev_list);
1605
1606 call_rcu(&tgtdev->rcu, free_device);
1607
1608 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
1609 }
1610
1611 int btrfs_find_device_by_path(struct btrfs_root *root, char *device_path,
1612 struct btrfs_device **device)
1613 {
1614 int ret = 0;
1615 struct btrfs_super_block *disk_super;
1616 u64 devid;
1617 u8 *dev_uuid;
1618 struct block_device *bdev;
1619 struct buffer_head *bh;
1620
1621 *device = NULL;
1622 ret = btrfs_get_bdev_and_sb(device_path, FMODE_READ,
1623 root->fs_info->bdev_holder, 0, &bdev, &bh);
1624 if (ret)
1625 return ret;
1626 disk_super = (struct btrfs_super_block *)bh->b_data;
1627 devid = btrfs_stack_device_id(&disk_super->dev_item);
1628 dev_uuid = disk_super->dev_item.uuid;
1629 *device = btrfs_find_device(root->fs_info, devid, dev_uuid,
1630 disk_super->fsid);
1631 brelse(bh);
1632 if (!*device)
1633 ret = -ENOENT;
1634 blkdev_put(bdev, FMODE_READ);
1635 return ret;
1636 }
1637
1638 int btrfs_find_device_missing_or_by_path(struct btrfs_root *root,
1639 char *device_path,
1640 struct btrfs_device **device)
1641 {
1642 *device = NULL;
1643 if (strcmp(device_path, "missing") == 0) {
1644 struct list_head *devices;
1645 struct btrfs_device *tmp;
1646
1647 devices = &root->fs_info->fs_devices->devices;
1648 /*
1649 * It is safe to read the devices since the volume_mutex
1650 * is held by the caller.
1651 */
1652 list_for_each_entry(tmp, devices, dev_list) {
1653 if (tmp->in_fs_metadata && !tmp->bdev) {
1654 *device = tmp;
1655 break;
1656 }
1657 }
1658
1659 if (!*device) {
1660 pr_err("btrfs: no missing device found\n");
1661 return -ENOENT;
1662 }
1663
1664 return 0;
1665 } else {
1666 return btrfs_find_device_by_path(root, device_path, device);
1667 }
1668 }
1669
1670 /*
1671 * does all the dirty work required for changing file system's UUID.
1672 */
1673 static int btrfs_prepare_sprout(struct btrfs_root *root)
1674 {
1675 struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
1676 struct btrfs_fs_devices *old_devices;
1677 struct btrfs_fs_devices *seed_devices;
1678 struct btrfs_super_block *disk_super = root->fs_info->super_copy;
1679 struct btrfs_device *device;
1680 u64 super_flags;
1681
1682 BUG_ON(!mutex_is_locked(&uuid_mutex));
1683 if (!fs_devices->seeding)
1684 return -EINVAL;
1685
1686 seed_devices = kzalloc(sizeof(*fs_devices), GFP_NOFS);
1687 if (!seed_devices)
1688 return -ENOMEM;
1689
1690 old_devices = clone_fs_devices(fs_devices);
1691 if (IS_ERR(old_devices)) {
1692 kfree(seed_devices);
1693 return PTR_ERR(old_devices);
1694 }
1695
1696 list_add(&old_devices->list, &fs_uuids);
1697
1698 memcpy(seed_devices, fs_devices, sizeof(*seed_devices));
1699 seed_devices->opened = 1;
1700 INIT_LIST_HEAD(&seed_devices->devices);
1701 INIT_LIST_HEAD(&seed_devices->alloc_list);
1702 mutex_init(&seed_devices->device_list_mutex);
1703
1704 mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
1705 list_splice_init_rcu(&fs_devices->devices, &seed_devices->devices,
1706 synchronize_rcu);
1707 mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
1708
1709 list_splice_init(&fs_devices->alloc_list, &seed_devices->alloc_list);
1710 list_for_each_entry(device, &seed_devices->devices, dev_list) {
1711 device->fs_devices = seed_devices;
1712 }
1713
1714 fs_devices->seeding = 0;
1715 fs_devices->num_devices = 0;
1716 fs_devices->open_devices = 0;
1717 fs_devices->total_devices = 0;
1718 fs_devices->seed = seed_devices;
1719
1720 generate_random_uuid(fs_devices->fsid);
1721 memcpy(root->fs_info->fsid, fs_devices->fsid, BTRFS_FSID_SIZE);
1722 memcpy(disk_super->fsid, fs_devices->fsid, BTRFS_FSID_SIZE);
1723 super_flags = btrfs_super_flags(disk_super) &
1724 ~BTRFS_SUPER_FLAG_SEEDING;
1725 btrfs_set_super_flags(disk_super, super_flags);
1726
1727 return 0;
1728 }
1729
1730 /*
1731 * strore the expected generation for seed devices in device items.
1732 */
1733 static int btrfs_finish_sprout(struct btrfs_trans_handle *trans,
1734 struct btrfs_root *root)
1735 {
1736 struct btrfs_path *path;
1737 struct extent_buffer *leaf;
1738 struct btrfs_dev_item *dev_item;
1739 struct btrfs_device *device;
1740 struct btrfs_key key;
1741 u8 fs_uuid[BTRFS_UUID_SIZE];
1742 u8 dev_uuid[BTRFS_UUID_SIZE];
1743 u64 devid;
1744 int ret;
1745
1746 path = btrfs_alloc_path();
1747 if (!path)
1748 return -ENOMEM;
1749
1750 root = root->fs_info->chunk_root;
1751 key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
1752 key.offset = 0;
1753 key.type = BTRFS_DEV_ITEM_KEY;
1754
1755 while (1) {
1756 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
1757 if (ret < 0)
1758 goto error;
1759
1760 leaf = path->nodes[0];
1761 next_slot:
1762 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
1763 ret = btrfs_next_leaf(root, path);
1764 if (ret > 0)
1765 break;
1766 if (ret < 0)
1767 goto error;
1768 leaf = path->nodes[0];
1769 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1770 btrfs_release_path(path);
1771 continue;
1772 }
1773
1774 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1775 if (key.objectid != BTRFS_DEV_ITEMS_OBJECTID ||
1776 key.type != BTRFS_DEV_ITEM_KEY)
1777 break;
1778
1779 dev_item = btrfs_item_ptr(leaf, path->slots[0],
1780 struct btrfs_dev_item);
1781 devid = btrfs_device_id(leaf, dev_item);
1782 read_extent_buffer(leaf, dev_uuid,
1783 (unsigned long)btrfs_device_uuid(dev_item),
1784 BTRFS_UUID_SIZE);
1785 read_extent_buffer(leaf, fs_uuid,
1786 (unsigned long)btrfs_device_fsid(dev_item),
1787 BTRFS_UUID_SIZE);
1788 device = btrfs_find_device(root->fs_info, devid, dev_uuid,
1789 fs_uuid);
1790 BUG_ON(!device); /* Logic error */
1791
1792 if (device->fs_devices->seeding) {
1793 btrfs_set_device_generation(leaf, dev_item,
1794 device->generation);
1795 btrfs_mark_buffer_dirty(leaf);
1796 }
1797
1798 path->slots[0]++;
1799 goto next_slot;
1800 }
1801 ret = 0;
1802 error:
1803 btrfs_free_path(path);
1804 return ret;
1805 }
1806
1807 int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
1808 {
1809 struct request_queue *q;
1810 struct btrfs_trans_handle *trans;
1811 struct btrfs_device *device;
1812 struct block_device *bdev;
1813 struct list_head *devices;
1814 struct super_block *sb = root->fs_info->sb;
1815 struct rcu_string *name;
1816 u64 total_bytes;
1817 int seeding_dev = 0;
1818 int ret = 0;
1819
1820 if ((sb->s_flags & MS_RDONLY) && !root->fs_info->fs_devices->seeding)
1821 return -EROFS;
1822
1823 bdev = blkdev_get_by_path(device_path, FMODE_WRITE | FMODE_EXCL,
1824 root->fs_info->bdev_holder);
1825 if (IS_ERR(bdev))
1826 return PTR_ERR(bdev);
1827
1828 if (root->fs_info->fs_devices->seeding) {
1829 seeding_dev = 1;
1830 down_write(&sb->s_umount);
1831 mutex_lock(&uuid_mutex);
1832 }
1833
1834 filemap_write_and_wait(bdev->bd_inode->i_mapping);
1835
1836 devices = &root->fs_info->fs_devices->devices;
1837
1838 mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
1839 list_for_each_entry(device, devices, dev_list) {
1840 if (device->bdev == bdev) {
1841 ret = -EEXIST;
1842 mutex_unlock(
1843 &root->fs_info->fs_devices->device_list_mutex);
1844 goto error;
1845 }
1846 }
1847 mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
1848
1849 device = kzalloc(sizeof(*device), GFP_NOFS);
1850 if (!device) {
1851 /* we can safely leave the fs_devices entry around */
1852 ret = -ENOMEM;
1853 goto error;
1854 }
1855
1856 name = rcu_string_strdup(device_path, GFP_NOFS);
1857 if (!name) {
1858 kfree(device);
1859 ret = -ENOMEM;
1860 goto error;
1861 }
1862 rcu_assign_pointer(device->name, name);
1863
1864 ret = find_next_devid(root, &device->devid);
1865 if (ret) {
1866 rcu_string_free(device->name);
1867 kfree(device);
1868 goto error;
1869 }
1870
1871 trans = btrfs_start_transaction(root, 0);
1872 if (IS_ERR(trans)) {
1873 rcu_string_free(device->name);
1874 kfree(device);
1875 ret = PTR_ERR(trans);
1876 goto error;
1877 }
1878
1879 lock_chunks(root);
1880
1881 q = bdev_get_queue(bdev);
1882 if (blk_queue_discard(q))
1883 device->can_discard = 1;
1884 device->writeable = 1;
1885 device->work.func = pending_bios_fn;
1886 generate_random_uuid(device->uuid);
1887 spin_lock_init(&device->io_lock);
1888 device->generation = trans->transid;
1889 device->io_width = root->sectorsize;
1890 device->io_align = root->sectorsize;
1891 device->sector_size = root->sectorsize;
1892 device->total_bytes = i_size_read(bdev->bd_inode);
1893 device->disk_total_bytes = device->total_bytes;
1894 device->dev_root = root->fs_info->dev_root;
1895 device->bdev = bdev;
1896 device->in_fs_metadata = 1;
1897 device->is_tgtdev_for_dev_replace = 0;
1898 device->mode = FMODE_EXCL;
1899 set_blocksize(device->bdev, 4096);
1900
1901 if (seeding_dev) {
1902 sb->s_flags &= ~MS_RDONLY;
1903 ret = btrfs_prepare_sprout(root);
1904 BUG_ON(ret); /* -ENOMEM */
1905 }
1906
1907 device->fs_devices = root->fs_info->fs_devices;
1908
1909 mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
1910 list_add_rcu(&device->dev_list, &root->fs_info->fs_devices->devices);
1911 list_add(&device->dev_alloc_list,
1912 &root->fs_info->fs_devices->alloc_list);
1913 root->fs_info->fs_devices->num_devices++;
1914 root->fs_info->fs_devices->open_devices++;
1915 root->fs_info->fs_devices->rw_devices++;
1916 root->fs_info->fs_devices->total_devices++;
1917 if (device->can_discard)
1918 root->fs_info->fs_devices->num_can_discard++;
1919 root->fs_info->fs_devices->total_rw_bytes += device->total_bytes;
1920
1921 spin_lock(&root->fs_info->free_chunk_lock);
1922 root->fs_info->free_chunk_space += device->total_bytes;
1923 spin_unlock(&root->fs_info->free_chunk_lock);
1924
1925 if (!blk_queue_nonrot(bdev_get_queue(bdev)))
1926 root->fs_info->fs_devices->rotating = 1;
1927
1928 total_bytes = btrfs_super_total_bytes(root->fs_info->super_copy);
1929 btrfs_set_super_total_bytes(root->fs_info->super_copy,
1930 total_bytes + device->total_bytes);
1931
1932 total_bytes = btrfs_super_num_devices(root->fs_info->super_copy);
1933 btrfs_set_super_num_devices(root->fs_info->super_copy,
1934 total_bytes + 1);
1935 mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
1936
1937 if (seeding_dev) {
1938 ret = init_first_rw_device(trans, root, device);
1939 if (ret) {
1940 btrfs_abort_transaction(trans, root, ret);
1941 goto error_trans;
1942 }
1943 ret = btrfs_finish_sprout(trans, root);
1944 if (ret) {
1945 btrfs_abort_transaction(trans, root, ret);
1946 goto error_trans;
1947 }
1948 } else {
1949 ret = btrfs_add_device(trans, root, device);
1950 if (ret) {
1951 btrfs_abort_transaction(trans, root, ret);
1952 goto error_trans;
1953 }
1954 }
1955
1956 /*
1957 * we've got more storage, clear any full flags on the space
1958 * infos
1959 */
1960 btrfs_clear_space_info_full(root->fs_info);
1961
1962 unlock_chunks(root);
1963 root->fs_info->num_tolerated_disk_barrier_failures =
1964 btrfs_calc_num_tolerated_disk_barrier_failures(root->fs_info);
1965 ret = btrfs_commit_transaction(trans, root);
1966
1967 if (seeding_dev) {
1968 mutex_unlock(&uuid_mutex);
1969 up_write(&sb->s_umount);
1970
1971 if (ret) /* transaction commit */
1972 return ret;
1973
1974 ret = btrfs_relocate_sys_chunks(root);
1975 if (ret < 0)
1976 btrfs_error(root->fs_info, ret,
1977 "Failed to relocate sys chunks after "
1978 "device initialization. This can be fixed "
1979 "using the \"btrfs balance\" command.");
1980 trans = btrfs_attach_transaction(root);
1981 if (IS_ERR(trans)) {
1982 if (PTR_ERR(trans) == -ENOENT)
1983 return 0;
1984 return PTR_ERR(trans);
1985 }
1986 ret = btrfs_commit_transaction(trans, root);
1987 }
1988
1989 return ret;
1990
1991 error_trans:
1992 unlock_chunks(root);
1993 btrfs_end_transaction(trans, root);
1994 rcu_string_free(device->name);
1995 kfree(device);
1996 error:
1997 blkdev_put(bdev, FMODE_EXCL);
1998 if (seeding_dev) {
1999 mutex_unlock(&uuid_mutex);
2000 up_write(&sb->s_umount);
2001 }
2002 return ret;
2003 }
2004
2005 int btrfs_init_dev_replace_tgtdev(struct btrfs_root *root, char *device_path,
2006 struct btrfs_device **device_out)
2007 {
2008 struct request_queue *q;
2009 struct btrfs_device *device;
2010 struct block_device *bdev;
2011 struct btrfs_fs_info *fs_info = root->fs_info;
2012 struct list_head *devices;
2013 struct rcu_string *name;
2014 int ret = 0;
2015
2016 *device_out = NULL;
2017 if (fs_info->fs_devices->seeding)
2018 return -EINVAL;
2019
2020 bdev = blkdev_get_by_path(device_path, FMODE_WRITE | FMODE_EXCL,
2021 fs_info->bdev_holder);
2022 if (IS_ERR(bdev))
2023 return PTR_ERR(bdev);
2024
2025 filemap_write_and_wait(bdev->bd_inode->i_mapping);
2026
2027 devices = &fs_info->fs_devices->devices;
2028 list_for_each_entry(device, devices, dev_list) {
2029 if (device->bdev == bdev) {
2030 ret = -EEXIST;
2031 goto error;
2032 }
2033 }
2034
2035 device = kzalloc(sizeof(*device), GFP_NOFS);
2036 if (!device) {
2037 ret = -ENOMEM;
2038 goto error;
2039 }
2040
2041 name = rcu_string_strdup(device_path, GFP_NOFS);
2042 if (!name) {
2043 kfree(device);
2044 ret = -ENOMEM;
2045 goto error;
2046 }
2047 rcu_assign_pointer(device->name, name);
2048
2049 q = bdev_get_queue(bdev);
2050 if (blk_queue_discard(q))
2051 device->can_discard = 1;
2052 mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
2053 device->writeable = 1;
2054 device->work.func = pending_bios_fn;
2055 generate_random_uuid(device->uuid);
2056 device->devid = BTRFS_DEV_REPLACE_DEVID;
2057 spin_lock_init(&device->io_lock);
2058 device->generation = 0;
2059 device->io_width = root->sectorsize;
2060 device->io_align = root->sectorsize;
2061 device->sector_size = root->sectorsize;
2062 device->total_bytes = i_size_read(bdev->bd_inode);
2063 device->disk_total_bytes = device->total_bytes;
2064 device->dev_root = fs_info->dev_root;
2065 device->bdev = bdev;
2066 device->in_fs_metadata = 1;
2067 device->is_tgtdev_for_dev_replace = 1;
2068 device->mode = FMODE_EXCL;
2069 set_blocksize(device->bdev, 4096);
2070 device->fs_devices = fs_info->fs_devices;
2071 list_add(&device->dev_list, &fs_info->fs_devices->devices);
2072 fs_info->fs_devices->num_devices++;
2073 fs_info->fs_devices->open_devices++;
2074 if (device->can_discard)
2075 fs_info->fs_devices->num_can_discard++;
2076 mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
2077
2078 *device_out = device;
2079 return ret;
2080
2081 error:
2082 blkdev_put(bdev, FMODE_EXCL);
2083 return ret;
2084 }
2085
2086 void btrfs_init_dev_replace_tgtdev_for_resume(struct btrfs_fs_info *fs_info,
2087 struct btrfs_device *tgtdev)
2088 {
2089 WARN_ON(fs_info->fs_devices->rw_devices == 0);
2090 tgtdev->io_width = fs_info->dev_root->sectorsize;
2091 tgtdev->io_align = fs_info->dev_root->sectorsize;
2092 tgtdev->sector_size = fs_info->dev_root->sectorsize;
2093 tgtdev->dev_root = fs_info->dev_root;
2094 tgtdev->in_fs_metadata = 1;
2095 }
2096
2097 static noinline int btrfs_update_device(struct btrfs_trans_handle *trans,
2098 struct btrfs_device *device)
2099 {
2100 int ret;
2101 struct btrfs_path *path;
2102 struct btrfs_root *root;
2103 struct btrfs_dev_item *dev_item;
2104 struct extent_buffer *leaf;
2105 struct btrfs_key key;
2106
2107 root = device->dev_root->fs_info->chunk_root;
2108
2109 path = btrfs_alloc_path();
2110 if (!path)
2111 return -ENOMEM;
2112
2113 key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
2114 key.type = BTRFS_DEV_ITEM_KEY;
2115 key.offset = device->devid;
2116
2117 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2118 if (ret < 0)
2119 goto out;
2120
2121 if (ret > 0) {
2122 ret = -ENOENT;
2123 goto out;
2124 }
2125
2126 leaf = path->nodes[0];
2127 dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item);
2128
2129 btrfs_set_device_id(leaf, dev_item, device->devid);
2130 btrfs_set_device_type(leaf, dev_item, device->type);
2131 btrfs_set_device_io_align(leaf, dev_item, device->io_align);
2132 btrfs_set_device_io_width(leaf, dev_item, device->io_width);
2133 btrfs_set_device_sector_size(leaf, dev_item, device->sector_size);
2134 btrfs_set_device_total_bytes(leaf, dev_item, device->disk_total_bytes);
2135 btrfs_set_device_bytes_used(leaf, dev_item, device->bytes_used);
2136 btrfs_mark_buffer_dirty(leaf);
2137
2138 out:
2139 btrfs_free_path(path);
2140 return ret;
2141 }
2142
2143 static int __btrfs_grow_device(struct btrfs_trans_handle *trans,
2144 struct btrfs_device *device, u64 new_size)
2145 {
2146 struct btrfs_super_block *super_copy =
2147 device->dev_root->fs_info->super_copy;
2148 u64 old_total = btrfs_super_total_bytes(super_copy);
2149 u64 diff = new_size - device->total_bytes;
2150
2151 if (!device->writeable)
2152 return -EACCES;
2153 if (new_size <= device->total_bytes ||
2154 device->is_tgtdev_for_dev_replace)
2155 return -EINVAL;
2156
2157 btrfs_set_super_total_bytes(super_copy, old_total + diff);
2158 device->fs_devices->total_rw_bytes += diff;
2159
2160 device->total_bytes = new_size;
2161 device->disk_total_bytes = new_size;
2162 btrfs_clear_space_info_full(device->dev_root->fs_info);
2163
2164 return btrfs_update_device(trans, device);
2165 }
2166
2167 int btrfs_grow_device(struct btrfs_trans_handle *trans,
2168 struct btrfs_device *device, u64 new_size)
2169 {
2170 int ret;
2171 lock_chunks(device->dev_root);
2172 ret = __btrfs_grow_device(trans, device, new_size);
2173 unlock_chunks(device->dev_root);
2174 return ret;
2175 }
2176
2177 static int btrfs_free_chunk(struct btrfs_trans_handle *trans,
2178 struct btrfs_root *root,
2179 u64 chunk_tree, u64 chunk_objectid,
2180 u64 chunk_offset)
2181 {
2182 int ret;
2183 struct btrfs_path *path;
2184 struct btrfs_key key;
2185
2186 root = root->fs_info->chunk_root;
2187 path = btrfs_alloc_path();
2188 if (!path)
2189 return -ENOMEM;
2190
2191 key.objectid = chunk_objectid;
2192 key.offset = chunk_offset;
2193 key.type = BTRFS_CHUNK_ITEM_KEY;
2194
2195 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
2196 if (ret < 0)
2197 goto out;
2198 else if (ret > 0) { /* Logic error or corruption */
2199 btrfs_error(root->fs_info, -ENOENT,
2200 "Failed lookup while freeing chunk.");
2201 ret = -ENOENT;
2202 goto out;
2203 }
2204
2205 ret = btrfs_del_item(trans, root, path);
2206 if (ret < 0)
2207 btrfs_error(root->fs_info, ret,
2208 "Failed to delete chunk item.");
2209 out:
2210 btrfs_free_path(path);
2211 return ret;
2212 }
2213
2214 static int btrfs_del_sys_chunk(struct btrfs_root *root, u64 chunk_objectid, u64
2215 chunk_offset)
2216 {
2217 struct btrfs_super_block *super_copy = root->fs_info->super_copy;
2218 struct btrfs_disk_key *disk_key;
2219 struct btrfs_chunk *chunk;
2220 u8 *ptr;
2221 int ret = 0;
2222 u32 num_stripes;
2223 u32 array_size;
2224 u32 len = 0;
2225 u32 cur;
2226 struct btrfs_key key;
2227
2228 array_size = btrfs_super_sys_array_size(super_copy);
2229
2230 ptr = super_copy->sys_chunk_array;
2231 cur = 0;
2232
2233 while (cur < array_size) {
2234 disk_key = (struct btrfs_disk_key *)ptr;
2235 btrfs_disk_key_to_cpu(&key, disk_key);
2236
2237 len = sizeof(*disk_key);
2238
2239 if (key.type == BTRFS_CHUNK_ITEM_KEY) {
2240 chunk = (struct btrfs_chunk *)(ptr + len);
2241 num_stripes = btrfs_stack_chunk_num_stripes(chunk);
2242 len += btrfs_chunk_item_size(num_stripes);
2243 } else {
2244 ret = -EIO;
2245 break;
2246 }
2247 if (key.objectid == chunk_objectid &&
2248 key.offset == chunk_offset) {
2249 memmove(ptr, ptr + len, array_size - (cur + len));
2250 array_size -= len;
2251 btrfs_set_super_sys_array_size(super_copy, array_size);
2252 } else {
2253 ptr += len;
2254 cur += len;
2255 }
2256 }
2257 return ret;
2258 }
2259
2260 static int btrfs_relocate_chunk(struct btrfs_root *root,
2261 u64 chunk_tree, u64 chunk_objectid,
2262 u64 chunk_offset)
2263 {
2264 struct extent_map_tree *em_tree;
2265 struct btrfs_root *extent_root;
2266 struct btrfs_trans_handle *trans;
2267 struct extent_map *em;
2268 struct map_lookup *map;
2269 int ret;
2270 int i;
2271
2272 root = root->fs_info->chunk_root;
2273 extent_root = root->fs_info->extent_root;
2274 em_tree = &root->fs_info->mapping_tree.map_tree;
2275
2276 ret = btrfs_can_relocate(extent_root, chunk_offset);
2277 if (ret)
2278 return -ENOSPC;
2279
2280 /* step one, relocate all the extents inside this chunk */
2281 ret = btrfs_relocate_block_group(extent_root, chunk_offset);
2282 if (ret)
2283 return ret;
2284
2285 trans = btrfs_start_transaction(root, 0);
2286 BUG_ON(IS_ERR(trans));
2287
2288 lock_chunks(root);
2289
2290 /*
2291 * step two, delete the device extents and the
2292 * chunk tree entries
2293 */
2294 read_lock(&em_tree->lock);
2295 em = lookup_extent_mapping(em_tree, chunk_offset, 1);
2296 read_unlock(&em_tree->lock);
2297
2298 BUG_ON(!em || em->start > chunk_offset ||
2299 em->start + em->len < chunk_offset);
2300 map = (struct map_lookup *)em->bdev;
2301
2302 for (i = 0; i < map->num_stripes; i++) {
2303 ret = btrfs_free_dev_extent(trans, map->stripes[i].dev,
2304 map->stripes[i].physical);
2305 BUG_ON(ret);
2306
2307 if (map->stripes[i].dev) {
2308 ret = btrfs_update_device(trans, map->stripes[i].dev);
2309 BUG_ON(ret);
2310 }
2311 }
2312 ret = btrfs_free_chunk(trans, root, chunk_tree, chunk_objectid,
2313 chunk_offset);
2314
2315 BUG_ON(ret);
2316
2317 trace_btrfs_chunk_free(root, map, chunk_offset, em->len);
2318
2319 if (map->type & BTRFS_BLOCK_GROUP_SYSTEM) {
2320 ret = btrfs_del_sys_chunk(root, chunk_objectid, chunk_offset);
2321 BUG_ON(ret);
2322 }
2323
2324 ret = btrfs_remove_block_group(trans, extent_root, chunk_offset);
2325 BUG_ON(ret);
2326
2327 write_lock(&em_tree->lock);
2328 remove_extent_mapping(em_tree, em);
2329 write_unlock(&em_tree->lock);
2330
2331 kfree(map);
2332 em->bdev = NULL;
2333
2334 /* once for the tree */
2335 free_extent_map(em);
2336 /* once for us */
2337 free_extent_map(em);
2338
2339 unlock_chunks(root);
2340 btrfs_end_transaction(trans, root);
2341 return 0;
2342 }
2343
2344 static int btrfs_relocate_sys_chunks(struct btrfs_root *root)
2345 {
2346 struct btrfs_root *chunk_root = root->fs_info->chunk_root;
2347 struct btrfs_path *path;
2348 struct extent_buffer *leaf;
2349 struct btrfs_chunk *chunk;
2350 struct btrfs_key key;
2351 struct btrfs_key found_key;
2352 u64 chunk_tree = chunk_root->root_key.objectid;
2353 u64 chunk_type;
2354 bool retried = false;
2355 int failed = 0;
2356 int ret;
2357
2358 path = btrfs_alloc_path();
2359 if (!path)
2360 return -ENOMEM;
2361
2362 again:
2363 key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
2364 key.offset = (u64)-1;
2365 key.type = BTRFS_CHUNK_ITEM_KEY;
2366
2367 while (1) {
2368 ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0);
2369 if (ret < 0)
2370 goto error;
2371 BUG_ON(ret == 0); /* Corruption */
2372
2373 ret = btrfs_previous_item(chunk_root, path, key.objectid,
2374 key.type);
2375 if (ret < 0)
2376 goto error;
2377 if (ret > 0)
2378 break;
2379
2380 leaf = path->nodes[0];
2381 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
2382
2383 chunk = btrfs_item_ptr(leaf, path->slots[0],
2384 struct btrfs_chunk);
2385 chunk_type = btrfs_chunk_type(leaf, chunk);
2386 btrfs_release_path(path);
2387
2388 if (chunk_type & BTRFS_BLOCK_GROUP_SYSTEM) {
2389 ret = btrfs_relocate_chunk(chunk_root, chunk_tree,
2390 found_key.objectid,
2391 found_key.offset);
2392 if (ret == -ENOSPC)
2393 failed++;
2394 else if (ret)
2395 BUG();
2396 }
2397
2398 if (found_key.offset == 0)
2399 break;
2400 key.offset = found_key.offset - 1;
2401 }
2402 ret = 0;
2403 if (failed && !retried) {
2404 failed = 0;
2405 retried = true;
2406 goto again;
2407 } else if (failed && retried) {
2408 WARN_ON(1);
2409 ret = -ENOSPC;
2410 }
2411 error:
2412 btrfs_free_path(path);
2413 return ret;
2414 }
2415
2416 static int insert_balance_item(struct btrfs_root *root,
2417 struct btrfs_balance_control *bctl)
2418 {
2419 struct btrfs_trans_handle *trans;
2420 struct btrfs_balance_item *item;
2421 struct btrfs_disk_balance_args disk_bargs;
2422 struct btrfs_path *path;
2423 struct extent_buffer *leaf;
2424 struct btrfs_key key;
2425 int ret, err;
2426
2427 path = btrfs_alloc_path();
2428 if (!path)
2429 return -ENOMEM;
2430
2431 trans = btrfs_start_transaction(root, 0);
2432 if (IS_ERR(trans)) {
2433 btrfs_free_path(path);
2434 return PTR_ERR(trans);
2435 }
2436
2437 key.objectid = BTRFS_BALANCE_OBJECTID;
2438 key.type = BTRFS_BALANCE_ITEM_KEY;
2439 key.offset = 0;
2440
2441 ret = btrfs_insert_empty_item(trans, root, path, &key,
2442 sizeof(*item));
2443 if (ret)
2444 goto out;
2445
2446 leaf = path->nodes[0];
2447 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item);
2448
2449 memset_extent_buffer(leaf, 0, (unsigned long)item, sizeof(*item));
2450
2451 btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->data);
2452 btrfs_set_balance_data(leaf, item, &disk_bargs);
2453 btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->meta);
2454 btrfs_set_balance_meta(leaf, item, &disk_bargs);
2455 btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->sys);
2456 btrfs_set_balance_sys(leaf, item, &disk_bargs);
2457
2458 btrfs_set_balance_flags(leaf, item, bctl->flags);
2459
2460 btrfs_mark_buffer_dirty(leaf);
2461 out:
2462 btrfs_free_path(path);
2463 err = btrfs_commit_transaction(trans, root);
2464 if (err && !ret)
2465 ret = err;
2466 return ret;
2467 }
2468
2469 static int del_balance_item(struct btrfs_root *root)
2470 {
2471 struct btrfs_trans_handle *trans;
2472 struct btrfs_path *path;
2473 struct btrfs_key key;
2474 int ret, err;
2475
2476 path = btrfs_alloc_path();
2477 if (!path)
2478 return -ENOMEM;
2479
2480 trans = btrfs_start_transaction(root, 0);
2481 if (IS_ERR(trans)) {
2482 btrfs_free_path(path);
2483 return PTR_ERR(trans);
2484 }
2485
2486 key.objectid = BTRFS_BALANCE_OBJECTID;
2487 key.type = BTRFS_BALANCE_ITEM_KEY;
2488 key.offset = 0;
2489
2490 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
2491 if (ret < 0)
2492 goto out;
2493 if (ret > 0) {
2494 ret = -ENOENT;
2495 goto out;
2496 }
2497
2498 ret = btrfs_del_item(trans, root, path);
2499 out:
2500 btrfs_free_path(path);
2501 err = btrfs_commit_transaction(trans, root);
2502 if (err && !ret)
2503 ret = err;
2504 return ret;
2505 }
2506
2507 /*
2508 * This is a heuristic used to reduce the number of chunks balanced on
2509 * resume after balance was interrupted.
2510 */
2511 static void update_balance_args(struct btrfs_balance_control *bctl)
2512 {
2513 /*
2514 * Turn on soft mode for chunk types that were being converted.
2515 */
2516 if (bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT)
2517 bctl->data.flags |= BTRFS_BALANCE_ARGS_SOFT;
2518 if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT)
2519 bctl->sys.flags |= BTRFS_BALANCE_ARGS_SOFT;
2520 if (bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT)
2521 bctl->meta.flags |= BTRFS_BALANCE_ARGS_SOFT;
2522
2523 /*
2524 * Turn on usage filter if is not already used. The idea is
2525 * that chunks that we have already balanced should be
2526 * reasonably full. Don't do it for chunks that are being
2527 * converted - that will keep us from relocating unconverted
2528 * (albeit full) chunks.
2529 */
2530 if (!(bctl->data.flags & BTRFS_BALANCE_ARGS_USAGE) &&
2531 !(bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT)) {
2532 bctl->data.flags |= BTRFS_BALANCE_ARGS_USAGE;
2533 bctl->data.usage = 90;
2534 }
2535 if (!(bctl->sys.flags & BTRFS_BALANCE_ARGS_USAGE) &&
2536 !(bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT)) {
2537 bctl->sys.flags |= BTRFS_BALANCE_ARGS_USAGE;
2538 bctl->sys.usage = 90;
2539 }
2540 if (!(bctl->meta.flags & BTRFS_BALANCE_ARGS_USAGE) &&
2541 !(bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT)) {
2542 bctl->meta.flags |= BTRFS_BALANCE_ARGS_USAGE;
2543 bctl->meta.usage = 90;
2544 }
2545 }
2546
2547 /*
2548 * Should be called with both balance and volume mutexes held to
2549 * serialize other volume operations (add_dev/rm_dev/resize) with
2550 * restriper. Same goes for unset_balance_control.
2551 */
2552 static void set_balance_control(struct btrfs_balance_control *bctl)
2553 {
2554 struct btrfs_fs_info *fs_info = bctl->fs_info;
2555
2556 BUG_ON(fs_info->balance_ctl);
2557
2558 spin_lock(&fs_info->balance_lock);
2559 fs_info->balance_ctl = bctl;
2560 spin_unlock(&fs_info->balance_lock);
2561 }
2562
2563 static void unset_balance_control(struct btrfs_fs_info *fs_info)
2564 {
2565 struct btrfs_balance_control *bctl = fs_info->balance_ctl;
2566
2567 BUG_ON(!fs_info->balance_ctl);
2568
2569 spin_lock(&fs_info->balance_lock);
2570 fs_info->balance_ctl = NULL;
2571 spin_unlock(&fs_info->balance_lock);
2572
2573 kfree(bctl);
2574 }
2575
2576 /*
2577 * Balance filters. Return 1 if chunk should be filtered out
2578 * (should not be balanced).
2579 */
2580 static int chunk_profiles_filter(u64 chunk_type,
2581 struct btrfs_balance_args *bargs)
2582 {
2583 chunk_type = chunk_to_extended(chunk_type) &
2584 BTRFS_EXTENDED_PROFILE_MASK;
2585
2586 if (bargs->profiles & chunk_type)
2587 return 0;
2588
2589 return 1;
2590 }
2591
2592 static int chunk_usage_filter(struct btrfs_fs_info *fs_info, u64 chunk_offset,
2593 struct btrfs_balance_args *bargs)
2594 {
2595 struct btrfs_block_group_cache *cache;
2596 u64 chunk_used, user_thresh;
2597 int ret = 1;
2598
2599 cache = btrfs_lookup_block_group(fs_info, chunk_offset);
2600 chunk_used = btrfs_block_group_used(&cache->item);
2601
2602 user_thresh = div_factor_fine(cache->key.offset, bargs->usage);
2603 if (chunk_used < user_thresh)
2604 ret = 0;
2605
2606 btrfs_put_block_group(cache);
2607 return ret;
2608 }
2609
2610 static int chunk_devid_filter(struct extent_buffer *leaf,
2611 struct btrfs_chunk *chunk,
2612 struct btrfs_balance_args *bargs)
2613 {
2614 struct btrfs_stripe *stripe;
2615 int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
2616 int i;
2617
2618 for (i = 0; i < num_stripes; i++) {
2619 stripe = btrfs_stripe_nr(chunk, i);
2620 if (btrfs_stripe_devid(leaf, stripe) == bargs->devid)
2621 return 0;
2622 }
2623
2624 return 1;
2625 }
2626
2627 /* [pstart, pend) */
2628 static int chunk_drange_filter(struct extent_buffer *leaf,
2629 struct btrfs_chunk *chunk,
2630 u64 chunk_offset,
2631 struct btrfs_balance_args *bargs)
2632 {
2633 struct btrfs_stripe *stripe;
2634 int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
2635 u64 stripe_offset;
2636 u64 stripe_length;
2637 int factor;
2638 int i;
2639
2640 if (!(bargs->flags & BTRFS_BALANCE_ARGS_DEVID))
2641 return 0;
2642
2643 if (btrfs_chunk_type(leaf, chunk) & (BTRFS_BLOCK_GROUP_DUP |
2644 BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID10))
2645 factor = 2;
2646 else
2647 factor = 1;
2648 factor = num_stripes / factor;
2649
2650 for (i = 0; i < num_stripes; i++) {
2651 stripe = btrfs_stripe_nr(chunk, i);
2652 if (btrfs_stripe_devid(leaf, stripe) != bargs->devid)
2653 continue;
2654
2655 stripe_offset = btrfs_stripe_offset(leaf, stripe);
2656 stripe_length = btrfs_chunk_length(leaf, chunk);
2657 do_div(stripe_length, factor);
2658
2659 if (stripe_offset < bargs->pend &&
2660 stripe_offset + stripe_length > bargs->pstart)
2661 return 0;
2662 }
2663
2664 return 1;
2665 }
2666
2667 /* [vstart, vend) */
2668 static int chunk_vrange_filter(struct extent_buffer *leaf,
2669 struct btrfs_chunk *chunk,
2670 u64 chunk_offset,
2671 struct btrfs_balance_args *bargs)
2672 {
2673 if (chunk_offset < bargs->vend &&
2674 chunk_offset + btrfs_chunk_length(leaf, chunk) > bargs->vstart)
2675 /* at least part of the chunk is inside this vrange */
2676 return 0;
2677
2678 return 1;
2679 }
2680
2681 static int chunk_soft_convert_filter(u64 chunk_type,
2682 struct btrfs_balance_args *bargs)
2683 {
2684 if (!(bargs->flags & BTRFS_BALANCE_ARGS_CONVERT))
2685 return 0;
2686
2687 chunk_type = chunk_to_extended(chunk_type) &
2688 BTRFS_EXTENDED_PROFILE_MASK;
2689
2690 if (bargs->target == chunk_type)
2691 return 1;
2692
2693 return 0;
2694 }
2695
2696 static int should_balance_chunk(struct btrfs_root *root,
2697 struct extent_buffer *leaf,
2698 struct btrfs_chunk *chunk, u64 chunk_offset)
2699 {
2700 struct btrfs_balance_control *bctl = root->fs_info->balance_ctl;
2701 struct btrfs_balance_args *bargs = NULL;
2702 u64 chunk_type = btrfs_chunk_type(leaf, chunk);
2703
2704 /* type filter */
2705 if (!((chunk_type & BTRFS_BLOCK_GROUP_TYPE_MASK) &
2706 (bctl->flags & BTRFS_BALANCE_TYPE_MASK))) {
2707 return 0;
2708 }
2709
2710 if (chunk_type & BTRFS_BLOCK_GROUP_DATA)
2711 bargs = &bctl->data;
2712 else if (chunk_type & BTRFS_BLOCK_GROUP_SYSTEM)
2713 bargs = &bctl->sys;
2714 else if (chunk_type & BTRFS_BLOCK_GROUP_METADATA)
2715 bargs = &bctl->meta;
2716
2717 /* profiles filter */
2718 if ((bargs->flags & BTRFS_BALANCE_ARGS_PROFILES) &&
2719 chunk_profiles_filter(chunk_type, bargs)) {
2720 return 0;
2721 }
2722
2723 /* usage filter */
2724 if ((bargs->flags & BTRFS_BALANCE_ARGS_USAGE) &&
2725 chunk_usage_filter(bctl->fs_info, chunk_offset, bargs)) {
2726 return 0;
2727 }
2728
2729 /* devid filter */
2730 if ((bargs->flags & BTRFS_BALANCE_ARGS_DEVID) &&
2731 chunk_devid_filter(leaf, chunk, bargs)) {
2732 return 0;
2733 }
2734
2735 /* drange filter, makes sense only with devid filter */
2736 if ((bargs->flags & BTRFS_BALANCE_ARGS_DRANGE) &&
2737 chunk_drange_filter(leaf, chunk, chunk_offset, bargs)) {
2738 return 0;
2739 }
2740
2741 /* vrange filter */
2742 if ((bargs->flags & BTRFS_BALANCE_ARGS_VRANGE) &&
2743 chunk_vrange_filter(leaf, chunk, chunk_offset, bargs)) {
2744 return 0;
2745 }
2746
2747 /* soft profile changing mode */
2748 if ((bargs->flags & BTRFS_BALANCE_ARGS_SOFT) &&
2749 chunk_soft_convert_filter(chunk_type, bargs)) {
2750 return 0;
2751 }
2752
2753 return 1;
2754 }
2755
2756 static int __btrfs_balance(struct btrfs_fs_info *fs_info)
2757 {
2758 struct btrfs_balance_control *bctl = fs_info->balance_ctl;
2759 struct btrfs_root *chunk_root = fs_info->chunk_root;
2760 struct btrfs_root *dev_root = fs_info->dev_root;
2761 struct list_head *devices;
2762 struct btrfs_device *device;
2763 u64 old_size;
2764 u64 size_to_free;
2765 struct btrfs_chunk *chunk;
2766 struct btrfs_path *path;
2767 struct btrfs_key key;
2768 struct btrfs_key found_key;
2769 struct btrfs_trans_handle *trans;
2770 struct extent_buffer *leaf;
2771 int slot;
2772 int ret;
2773 int enospc_errors = 0;
2774 bool counting = true;
2775
2776 /* step one make some room on all the devices */
2777 devices = &fs_info->fs_devices->devices;
2778 list_for_each_entry(device, devices, dev_list) {
2779 old_size = device->total_bytes;
2780 size_to_free = div_factor(old_size, 1);
2781 size_to_free = min(size_to_free, (u64)1 * 1024 * 1024);
2782 if (!device->writeable ||
2783 device->total_bytes - device->bytes_used > size_to_free ||
2784 device->is_tgtdev_for_dev_replace)
2785 continue;
2786
2787 ret = btrfs_shrink_device(device, old_size - size_to_free);
2788 if (ret == -ENOSPC)
2789 break;
2790 BUG_ON(ret);
2791
2792 trans = btrfs_start_transaction(dev_root, 0);
2793 BUG_ON(IS_ERR(trans));
2794
2795 ret = btrfs_grow_device(trans, device, old_size);
2796 BUG_ON(ret);
2797
2798 btrfs_end_transaction(trans, dev_root);
2799 }
2800
2801 /* step two, relocate all the chunks */
2802 path = btrfs_alloc_path();
2803 if (!path) {
2804 ret = -ENOMEM;
2805 goto error;
2806 }
2807
2808 /* zero out stat counters */
2809 spin_lock(&fs_info->balance_lock);
2810 memset(&bctl->stat, 0, sizeof(bctl->stat));
2811 spin_unlock(&fs_info->balance_lock);
2812 again:
2813 key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
2814 key.offset = (u64)-1;
2815 key.type = BTRFS_CHUNK_ITEM_KEY;
2816
2817 while (1) {
2818 if ((!counting && atomic_read(&fs_info->balance_pause_req)) ||
2819 atomic_read(&fs_info->balance_cancel_req)) {
2820 ret = -ECANCELED;
2821 goto error;
2822 }
2823
2824 ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0);
2825 if (ret < 0)
2826 goto error;
2827
2828 /*
2829 * this shouldn't happen, it means the last relocate
2830 * failed
2831 */
2832 if (ret == 0)
2833 BUG(); /* FIXME break ? */
2834
2835 ret = btrfs_previous_item(chunk_root, path, 0,
2836 BTRFS_CHUNK_ITEM_KEY);
2837 if (ret) {
2838 ret = 0;
2839 break;
2840 }
2841
2842 leaf = path->nodes[0];
2843 slot = path->slots[0];
2844 btrfs_item_key_to_cpu(leaf, &found_key, slot);
2845
2846 if (found_key.objectid != key.objectid)
2847 break;
2848
2849 /* chunk zero is special */
2850 if (found_key.offset == 0)
2851 break;
2852
2853 chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);
2854
2855 if (!counting) {
2856 spin_lock(&fs_info->balance_lock);
2857 bctl->stat.considered++;
2858 spin_unlock(&fs_info->balance_lock);
2859 }
2860
2861 ret = should_balance_chunk(chunk_root, leaf, chunk,
2862 found_key.offset);
2863 btrfs_release_path(path);
2864 if (!ret)
2865 goto loop;
2866
2867 if (counting) {
2868 spin_lock(&fs_info->balance_lock);
2869 bctl->stat.expected++;
2870 spin_unlock(&fs_info->balance_lock);
2871 goto loop;
2872 }
2873
2874 ret = btrfs_relocate_chunk(chunk_root,
2875 chunk_root->root_key.objectid,
2876 found_key.objectid,
2877 found_key.offset);
2878 if (ret && ret != -ENOSPC)
2879 goto error;
2880 if (ret == -ENOSPC) {
2881 enospc_errors++;
2882 } else {
2883 spin_lock(&fs_info->balance_lock);
2884 bctl->stat.completed++;
2885 spin_unlock(&fs_info->balance_lock);
2886 }
2887 loop:
2888 key.offset = found_key.offset - 1;
2889 }
2890
2891 if (counting) {
2892 btrfs_release_path(path);
2893 counting = false;
2894 goto again;
2895 }
2896 error:
2897 btrfs_free_path(path);
2898 if (enospc_errors) {
2899 printk(KERN_INFO "btrfs: %d enospc errors during balance\n",
2900 enospc_errors);
2901 if (!ret)
2902 ret = -ENOSPC;
2903 }
2904
2905 return ret;
2906 }
2907
2908 /**
2909 * alloc_profile_is_valid - see if a given profile is valid and reduced
2910 * @flags: profile to validate
2911 * @extended: if true @flags is treated as an extended profile
2912 */
2913 static int alloc_profile_is_valid(u64 flags, int extended)
2914 {
2915 u64 mask = (extended ? BTRFS_EXTENDED_PROFILE_MASK :
2916 BTRFS_BLOCK_GROUP_PROFILE_MASK);
2917
2918 flags &= ~BTRFS_BLOCK_GROUP_TYPE_MASK;
2919
2920 /* 1) check that all other bits are zeroed */
2921 if (flags & ~mask)
2922 return 0;
2923
2924 /* 2) see if profile is reduced */
2925 if (flags == 0)
2926 return !extended; /* "0" is valid for usual profiles */
2927
2928 /* true if exactly one bit set */
2929 return (flags & (flags - 1)) == 0;
2930 }
2931
2932 static inline int balance_need_close(struct btrfs_fs_info *fs_info)
2933 {
2934 /* cancel requested || normal exit path */
2935 return atomic_read(&fs_info->balance_cancel_req) ||
2936 (atomic_read(&fs_info->balance_pause_req) == 0 &&
2937 atomic_read(&fs_info->balance_cancel_req) == 0);
2938 }
2939
2940 static void __cancel_balance(struct btrfs_fs_info *fs_info)
2941 {
2942 int ret;
2943
2944 unset_balance_control(fs_info);
2945 ret = del_balance_item(fs_info->tree_root);
2946 BUG_ON(ret);
2947 }
2948
2949 void update_ioctl_balance_args(struct btrfs_fs_info *fs_info, int lock,
2950 struct btrfs_ioctl_balance_args *bargs);
2951
2952 /*
2953 * Should be called with both balance and volume mutexes held
2954 */
2955 int btrfs_balance(struct btrfs_balance_control *bctl,
2956 struct btrfs_ioctl_balance_args *bargs)
2957 {
2958 struct btrfs_fs_info *fs_info = bctl->fs_info;
2959 u64 allowed;
2960 int mixed = 0;
2961 int ret;
2962 u64 num_devices;
2963
2964 if (btrfs_fs_closing(fs_info) ||
2965 atomic_read(&fs_info->balance_pause_req) ||
2966 atomic_read(&fs_info->balance_cancel_req)) {
2967 ret = -EINVAL;
2968 goto out;
2969 }
2970
2971 allowed = btrfs_super_incompat_flags(fs_info->super_copy);
2972 if (allowed & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS)
2973 mixed = 1;
2974
2975 /*
2976 * In case of mixed groups both data and meta should be picked,
2977 * and identical options should be given for both of them.
2978 */
2979 allowed = BTRFS_BALANCE_DATA | BTRFS_BALANCE_METADATA;
2980 if (mixed && (bctl->flags & allowed)) {
2981 if (!(bctl->flags & BTRFS_BALANCE_DATA) ||
2982 !(bctl->flags & BTRFS_BALANCE_METADATA) ||
2983 memcmp(&bctl->data, &bctl->meta, sizeof(bctl->data))) {
2984 printk(KERN_ERR "btrfs: with mixed groups data and "
2985 "metadata balance options must be the same\n");
2986 ret = -EINVAL;
2987 goto out;
2988 }
2989 }
2990
2991 num_devices = fs_info->fs_devices->num_devices;
2992 btrfs_dev_replace_lock(&fs_info->dev_replace);
2993 if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace)) {
2994 BUG_ON(num_devices < 1);
2995 num_devices--;
2996 }
2997 btrfs_dev_replace_unlock(&fs_info->dev_replace);
2998 allowed = BTRFS_AVAIL_ALLOC_BIT_SINGLE;
2999 if (num_devices == 1)
3000 allowed |= BTRFS_BLOCK_GROUP_DUP;
3001 else if (num_devices < 4)
3002 allowed |= (BTRFS_BLOCK_GROUP_RAID0 | BTRFS_BLOCK_GROUP_RAID1);
3003 else
3004 allowed |= (BTRFS_BLOCK_GROUP_RAID0 | BTRFS_BLOCK_GROUP_RAID1 |
3005 BTRFS_BLOCK_GROUP_RAID10);
3006
3007 if ((bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
3008 (!alloc_profile_is_valid(bctl->data.target, 1) ||
3009 (bctl->data.target & ~allowed))) {
3010 printk(KERN_ERR "btrfs: unable to start balance with target "
3011 "data profile %llu\n",
3012 (unsigned long long)bctl->data.target);
3013 ret = -EINVAL;
3014 goto out;
3015 }
3016 if ((bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
3017 (!alloc_profile_is_valid(bctl->meta.target, 1) ||
3018 (bctl->meta.target & ~allowed))) {
3019 printk(KERN_ERR "btrfs: unable to start balance with target "
3020 "metadata profile %llu\n",
3021 (unsigned long long)bctl->meta.target);
3022 ret = -EINVAL;
3023 goto out;
3024 }
3025 if ((bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
3026 (!alloc_profile_is_valid(bctl->sys.target, 1) ||
3027 (bctl->sys.target & ~allowed))) {
3028 printk(KERN_ERR "btrfs: unable to start balance with target "
3029 "system profile %llu\n",
3030 (unsigned long long)bctl->sys.target);
3031 ret = -EINVAL;
3032 goto out;
3033 }
3034
3035 /* allow dup'ed data chunks only in mixed mode */
3036 if (!mixed && (bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
3037 (bctl->data.target & BTRFS_BLOCK_GROUP_DUP)) {
3038 printk(KERN_ERR "btrfs: dup for data is not allowed\n");
3039 ret = -EINVAL;
3040 goto out;
3041 }
3042
3043 /* allow to reduce meta or sys integrity only if force set */
3044 allowed = BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID1 |
3045 BTRFS_BLOCK_GROUP_RAID10;
3046 if (((bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
3047 (fs_info->avail_system_alloc_bits & allowed) &&
3048 !(bctl->sys.target & allowed)) ||
3049 ((bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
3050 (fs_info->avail_metadata_alloc_bits & allowed) &&
3051 !(bctl->meta.target & allowed))) {
3052 if (bctl->flags & BTRFS_BALANCE_FORCE) {
3053 printk(KERN_INFO "btrfs: force reducing metadata "
3054 "integrity\n");
3055 } else {
3056 printk(KERN_ERR "btrfs: balance will reduce metadata "
3057 "integrity, use force if you want this\n");
3058 ret = -EINVAL;
3059 goto out;
3060 }
3061 }
3062
3063 if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) {
3064 int num_tolerated_disk_barrier_failures;
3065 u64 target = bctl->sys.target;
3066
3067 num_tolerated_disk_barrier_failures =
3068 btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
3069 if (num_tolerated_disk_barrier_failures > 0 &&
3070 (target &
3071 (BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID0 |
3072 BTRFS_AVAIL_ALLOC_BIT_SINGLE)))
3073 num_tolerated_disk_barrier_failures = 0;
3074 else if (num_tolerated_disk_barrier_failures > 1 &&
3075 (target &
3076 (BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID10)))
3077 num_tolerated_disk_barrier_failures = 1;
3078
3079 fs_info->num_tolerated_disk_barrier_failures =
3080 num_tolerated_disk_barrier_failures;
3081 }
3082
3083 ret = insert_balance_item(fs_info->tree_root, bctl);
3084 if (ret && ret != -EEXIST)
3085 goto out;
3086
3087 if (!(bctl->flags & BTRFS_BALANCE_RESUME)) {
3088 BUG_ON(ret == -EEXIST);
3089 set_balance_control(bctl);
3090 } else {
3091 BUG_ON(ret != -EEXIST);
3092 spin_lock(&fs_info->balance_lock);
3093 update_balance_args(bctl);
3094 spin_unlock(&fs_info->balance_lock);
3095 }
3096
3097 atomic_inc(&fs_info->balance_running);
3098 mutex_unlock(&fs_info->balance_mutex);
3099
3100 ret = __btrfs_balance(fs_info);
3101
3102 mutex_lock(&fs_info->balance_mutex);
3103 atomic_dec(&fs_info->balance_running);
3104
3105 if (bargs) {
3106 memset(bargs, 0, sizeof(*bargs));
3107 update_ioctl_balance_args(fs_info, 0, bargs);
3108 }
3109
3110 if ((ret && ret != -ECANCELED && ret != -ENOSPC) ||
3111 balance_need_close(fs_info)) {
3112 __cancel_balance(fs_info);
3113 }
3114
3115 if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) {
3116 fs_info->num_tolerated_disk_barrier_failures =
3117 btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
3118 }
3119
3120 wake_up(&fs_info->balance_wait_q);
3121
3122 return ret;
3123 out:
3124 if (bctl->flags & BTRFS_BALANCE_RESUME)
3125 __cancel_balance(fs_info);
3126 else
3127 kfree(bctl);
3128 return ret;
3129 }
3130
3131 static int balance_kthread(void *data)
3132 {
3133 struct btrfs_fs_info *fs_info = data;
3134 int ret = 0;
3135
3136 mutex_lock(&fs_info->volume_mutex);
3137 mutex_lock(&fs_info->balance_mutex);
3138
3139 if (fs_info->balance_ctl) {
3140 printk(KERN_INFO "btrfs: continuing balance\n");
3141 ret = btrfs_balance(fs_info->balance_ctl, NULL);
3142 }
3143
3144 atomic_set(&fs_info->mutually_exclusive_operation_running, 0);
3145 mutex_unlock(&fs_info->balance_mutex);
3146 mutex_unlock(&fs_info->volume_mutex);
3147
3148 return ret;
3149 }
3150
3151 int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info)
3152 {
3153 struct task_struct *tsk;
3154
3155 spin_lock(&fs_info->balance_lock);
3156 if (!fs_info->balance_ctl) {
3157 spin_unlock(&fs_info->balance_lock);
3158 return 0;
3159 }
3160 spin_unlock(&fs_info->balance_lock);
3161
3162 if (btrfs_test_opt(fs_info->tree_root, SKIP_BALANCE)) {
3163 printk(KERN_INFO "btrfs: force skipping balance\n");
3164 return 0;
3165 }
3166
3167 WARN_ON(atomic_xchg(&fs_info->mutually_exclusive_operation_running, 1));
3168 tsk = kthread_run(balance_kthread, fs_info, "btrfs-balance");
3169 if (IS_ERR(tsk))
3170 return PTR_ERR(tsk);
3171
3172 return 0;
3173 }
3174
3175 int btrfs_recover_balance(struct btrfs_fs_info *fs_info)
3176 {
3177 struct btrfs_balance_control *bctl;
3178 struct btrfs_balance_item *item;
3179 struct btrfs_disk_balance_args disk_bargs;
3180 struct btrfs_path *path;
3181 struct extent_buffer *leaf;
3182 struct btrfs_key key;
3183 int ret;
3184
3185 path = btrfs_alloc_path();
3186 if (!path)
3187 return -ENOMEM;
3188
3189 key.objectid = BTRFS_BALANCE_OBJECTID;
3190 key.type = BTRFS_BALANCE_ITEM_KEY;
3191 key.offset = 0;
3192
3193 ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);
3194 if (ret < 0)
3195 goto out;
3196 if (ret > 0) { /* ret = -ENOENT; */
3197 ret = 0;
3198 goto out;
3199 }
3200
3201 bctl = kzalloc(sizeof(*bctl), GFP_NOFS);
3202 if (!bctl) {
3203 ret = -ENOMEM;
3204 goto out;
3205 }
3206
3207 leaf = path->nodes[0];
3208 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item);
3209
3210 bctl->fs_info = fs_info;
3211 bctl->flags = btrfs_balance_flags(leaf, item);
3212 bctl->flags |= BTRFS_BALANCE_RESUME;
3213
3214 btrfs_balance_data(leaf, item, &disk_bargs);
3215 btrfs_disk_balance_args_to_cpu(&bctl->data, &disk_bargs);
3216 btrfs_balance_meta(leaf, item, &disk_bargs);
3217 btrfs_disk_balance_args_to_cpu(&bctl->meta, &disk_bargs);
3218 btrfs_balance_sys(leaf, item, &disk_bargs);
3219 btrfs_disk_balance_args_to_cpu(&bctl->sys, &disk_bargs);
3220
3221 mutex_lock(&fs_info->volume_mutex);
3222 mutex_lock(&fs_info->balance_mutex);
3223
3224 set_balance_control(bctl);
3225
3226 mutex_unlock(&fs_info->balance_mutex);
3227 mutex_unlock(&fs_info->volume_mutex);
3228 out:
3229 btrfs_free_path(path);
3230 return ret;
3231 }
3232
3233 int btrfs_pause_balance(struct btrfs_fs_info *fs_info)
3234 {
3235 int ret = 0;
3236
3237 mutex_lock(&fs_info->balance_mutex);
3238 if (!fs_info->balance_ctl) {
3239 mutex_unlock(&fs_info->balance_mutex);
3240 return -ENOTCONN;
3241 }
3242
3243 if (atomic_read(&fs_info->balance_running)) {
3244 atomic_inc(&fs_info->balance_pause_req);
3245 mutex_unlock(&fs_info->balance_mutex);
3246
3247 wait_event(fs_info->balance_wait_q,
3248 atomic_read(&fs_info->balance_running) == 0);
3249
3250 mutex_lock(&fs_info->balance_mutex);
3251 /* we are good with balance_ctl ripped off from under us */
3252 BUG_ON(atomic_read(&fs_info->balance_running));
3253 atomic_dec(&fs_info->balance_pause_req);
3254 } else {
3255 ret = -ENOTCONN;
3256 }
3257
3258 mutex_unlock(&fs_info->balance_mutex);
3259 return ret;
3260 }
3261
3262 int btrfs_cancel_balance(struct btrfs_fs_info *fs_info)
3263 {
3264 mutex_lock(&fs_info->balance_mutex);
3265 if (!fs_info->balance_ctl) {
3266 mutex_unlock(&fs_info->balance_mutex);
3267 return -ENOTCONN;
3268 }
3269
3270 atomic_inc(&fs_info->balance_cancel_req);
3271 /*
3272 * if we are running just wait and return, balance item is
3273 * deleted in btrfs_balance in this case
3274 */
3275 if (atomic_read(&fs_info->balance_running)) {
3276 mutex_unlock(&fs_info->balance_mutex);
3277 wait_event(fs_info->balance_wait_q,
3278 atomic_read(&fs_info->balance_running) == 0);
3279 mutex_lock(&fs_info->balance_mutex);
3280 } else {
3281 /* __cancel_balance needs volume_mutex */
3282 mutex_unlock(&fs_info->balance_mutex);
3283 mutex_lock(&fs_info->volume_mutex);
3284 mutex_lock(&fs_info->balance_mutex);
3285
3286 if (fs_info->balance_ctl)
3287 __cancel_balance(fs_info);
3288
3289 mutex_unlock(&fs_info->volume_mutex);
3290 }
3291
3292 BUG_ON(fs_info->balance_ctl || atomic_read(&fs_info->balance_running));
3293 atomic_dec(&fs_info->balance_cancel_req);
3294 mutex_unlock(&fs_info->balance_mutex);
3295 return 0;
3296 }
3297
3298 /*
3299 * shrinking a device means finding all of the device extents past
3300 * the new size, and then following the back refs to the chunks.
3301 * The chunk relocation code actually frees the device extent
3302 */
3303 int btrfs_shrink_device(struct btrfs_device *device, u64 new_size)
3304 {
3305 struct btrfs_trans_handle *trans;
3306 struct btrfs_root *root = device->dev_root;
3307 struct btrfs_dev_extent *dev_extent = NULL;
3308 struct btrfs_path *path;
3309 u64 length;
3310 u64 chunk_tree;
3311 u64 chunk_objectid;
3312 u64 chunk_offset;
3313 int ret;
3314 int slot;
3315 int failed = 0;
3316 bool retried = false;
3317 struct extent_buffer *l;
3318 struct btrfs_key key;
3319 struct btrfs_super_block *super_copy = root->fs_info->super_copy;
3320 u64 old_total = btrfs_super_total_bytes(super_copy);
3321 u64 old_size = device->total_bytes;
3322 u64 diff = device->total_bytes - new_size;
3323
3324 if (device->is_tgtdev_for_dev_replace)
3325 return -EINVAL;
3326
3327 path = btrfs_alloc_path();
3328 if (!path)
3329 return -ENOMEM;
3330
3331 path->reada = 2;
3332
3333 lock_chunks(root);
3334
3335 device->total_bytes = new_size;
3336 if (device->writeable) {
3337 device->fs_devices->total_rw_bytes -= diff;
3338 spin_lock(&root->fs_info->free_chunk_lock);
3339 root->fs_info->free_chunk_space -= diff;
3340 spin_unlock(&root->fs_info->free_chunk_lock);
3341 }
3342 unlock_chunks(root);
3343
3344 again:
3345 key.objectid = device->devid;
3346 key.offset = (u64)-1;
3347 key.type = BTRFS_DEV_EXTENT_KEY;
3348
3349 do {
3350 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
3351 if (ret < 0)
3352 goto done;
3353
3354 ret = btrfs_previous_item(root, path, 0, key.type);
3355 if (ret < 0)
3356 goto done;
3357 if (ret) {
3358 ret = 0;
3359 btrfs_release_path(path);
3360 break;
3361 }
3362
3363 l = path->nodes[0];
3364 slot = path->slots[0];
3365 btrfs_item_key_to_cpu(l, &key, path->slots[0]);
3366
3367 if (key.objectid != device->devid) {
3368 btrfs_release_path(path);
3369 break;
3370 }
3371
3372 dev_extent = btrfs_item_ptr(l, slot, struct btrfs_dev_extent);
3373 length = btrfs_dev_extent_length(l, dev_extent);
3374
3375 if (key.offset + length <= new_size) {
3376 btrfs_release_path(path);
3377 break;
3378 }
3379
3380 chunk_tree = btrfs_dev_extent_chunk_tree(l, dev_extent);
3381 chunk_objectid = btrfs_dev_extent_chunk_objectid(l, dev_extent);
3382 chunk_offset = btrfs_dev_extent_chunk_offset(l, dev_extent);
3383 btrfs_release_path(path);
3384
3385 ret = btrfs_relocate_chunk(root, chunk_tree, chunk_objectid,
3386 chunk_offset);
3387 if (ret && ret != -ENOSPC)
3388 goto done;
3389 if (ret == -ENOSPC)
3390 failed++;
3391 } while (key.offset-- > 0);
3392
3393 if (failed && !retried) {
3394 failed = 0;
3395 retried = true;
3396 goto again;
3397 } else if (failed && retried) {
3398 ret = -ENOSPC;
3399 lock_chunks(root);
3400
3401 device->total_bytes = old_size;
3402 if (device->writeable)
3403 device->fs_devices->total_rw_bytes += diff;
3404 spin_lock(&root->fs_info->free_chunk_lock);
3405 root->fs_info->free_chunk_space += diff;
3406 spin_unlock(&root->fs_info->free_chunk_lock);
3407 unlock_chunks(root);
3408 goto done;
3409 }
3410
3411 /* Shrinking succeeded, else we would be at "done". */
3412 trans = btrfs_start_transaction(root, 0);
3413 if (IS_ERR(trans)) {
3414 ret = PTR_ERR(trans);
3415 goto done;
3416 }
3417
3418 lock_chunks(root);
3419
3420 device->disk_total_bytes = new_size;
3421 /* Now btrfs_update_device() will change the on-disk size. */
3422 ret = btrfs_update_device(trans, device);
3423 if (ret) {
3424 unlock_chunks(root);
3425 btrfs_end_transaction(trans, root);
3426 goto done;
3427 }
3428 WARN_ON(diff > old_total);
3429 btrfs_set_super_total_bytes(super_copy, old_total - diff);
3430 unlock_chunks(root);
3431 btrfs_end_transaction(trans, root);
3432 done:
3433 btrfs_free_path(path);
3434 return ret;
3435 }
3436
3437 static int btrfs_add_system_chunk(struct btrfs_root *root,
3438 struct btrfs_key *key,
3439 struct btrfs_chunk *chunk, int item_size)
3440 {
3441 struct btrfs_super_block *super_copy = root->fs_info->super_copy;
3442 struct btrfs_disk_key disk_key;
3443 u32 array_size;
3444 u8 *ptr;
3445
3446 array_size = btrfs_super_sys_array_size(super_copy);
3447 if (array_size + item_size > BTRFS_SYSTEM_CHUNK_ARRAY_SIZE)
3448 return -EFBIG;
3449
3450 ptr = super_copy->sys_chunk_array + array_size;
3451 btrfs_cpu_key_to_disk(&disk_key, key);
3452 memcpy(ptr, &disk_key, sizeof(disk_key));
3453 ptr += sizeof(disk_key);
3454 memcpy(ptr, chunk, item_size);
3455 item_size += sizeof(disk_key);
3456 btrfs_set_super_sys_array_size(super_copy, array_size + item_size);
3457 return 0;
3458 }
3459
3460 /*
3461 * sort the devices in descending order by max_avail, total_avail
3462 */
3463 static int btrfs_cmp_device_info(const void *a, const void *b)
3464 {
3465 const struct btrfs_device_info *di_a = a;
3466 const struct btrfs_device_info *di_b = b;
3467
3468 if (di_a->max_avail > di_b->max_avail)
3469 return -1;
3470 if (di_a->max_avail < di_b->max_avail)
3471 return 1;
3472 if (di_a->total_avail > di_b->total_avail)
3473 return -1;
3474 if (di_a->total_avail < di_b->total_avail)
3475 return 1;
3476 return 0;
3477 }
3478
3479 static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
3480 struct btrfs_root *extent_root,
3481 struct map_lookup **map_ret,
3482 u64 *num_bytes_out, u64 *stripe_size_out,
3483 u64 start, u64 type)
3484 {
3485 struct btrfs_fs_info *info = extent_root->fs_info;
3486 struct btrfs_fs_devices *fs_devices = info->fs_devices;
3487 struct list_head *cur;
3488 struct map_lookup *map = NULL;
3489 struct extent_map_tree *em_tree;
3490 struct extent_map *em;
3491 struct btrfs_device_info *devices_info = NULL;
3492 u64 total_avail;
3493 int num_stripes; /* total number of stripes to allocate */
3494 int sub_stripes; /* sub_stripes info for map */
3495 int dev_stripes; /* stripes per dev */
3496 int devs_max; /* max devs to use */
3497 int devs_min; /* min devs needed */
3498 int devs_increment; /* ndevs has to be a multiple of this */
3499 int ncopies; /* how many copies to data has */
3500 int ret;
3501 u64 max_stripe_size;
3502 u64 max_chunk_size;
3503 u64 stripe_size;
3504 u64 num_bytes;
3505 int ndevs;
3506 int i;
3507 int j;
3508
3509 BUG_ON(!alloc_profile_is_valid(type, 0));
3510
3511 if (list_empty(&fs_devices->alloc_list))
3512 return -ENOSPC;
3513
3514 sub_stripes = 1;
3515 dev_stripes = 1;
3516 devs_increment = 1;
3517 ncopies = 1;
3518 devs_max = 0; /* 0 == as many as possible */
3519 devs_min = 1;
3520
3521 /*
3522 * define the properties of each RAID type.
3523 * FIXME: move this to a global table and use it in all RAID
3524 * calculation code
3525 */
3526 if (type & (BTRFS_BLOCK_GROUP_DUP)) {
3527 dev_stripes = 2;
3528 ncopies = 2;
3529 devs_max = 1;
3530 } else if (type & (BTRFS_BLOCK_GROUP_RAID0)) {
3531 devs_min = 2;
3532 } else if (type & (BTRFS_BLOCK_GROUP_RAID1)) {
3533 devs_increment = 2;
3534 ncopies = 2;
3535 devs_max = 2;
3536 devs_min = 2;
3537 } else if (type & (BTRFS_BLOCK_GROUP_RAID10)) {
3538 sub_stripes = 2;
3539 devs_increment = 2;
3540 ncopies = 2;
3541 devs_min = 4;
3542 } else {
3543 devs_max = 1;
3544 }
3545
3546 if (type & BTRFS_BLOCK_GROUP_DATA) {
3547 max_stripe_size = 1024 * 1024 * 1024;
3548 max_chunk_size = 10 * max_stripe_size;
3549 } else if (type & BTRFS_BLOCK_GROUP_METADATA) {
3550 /* for larger filesystems, use larger metadata chunks */
3551 if (fs_devices->total_rw_bytes > 50ULL * 1024 * 1024 * 1024)
3552 max_stripe_size = 1024 * 1024 * 1024;
3553 else
3554 max_stripe_size = 256 * 1024 * 1024;
3555 max_chunk_size = max_stripe_size;
3556 } else if (type & BTRFS_BLOCK_GROUP_SYSTEM) {
3557 max_stripe_size = 32 * 1024 * 1024;
3558 max_chunk_size = 2 * max_stripe_size;
3559 } else {
3560 printk(KERN_ERR "btrfs: invalid chunk type 0x%llx requested\n",
3561 type);
3562 BUG_ON(1);
3563 }
3564
3565 /* we don't want a chunk larger than 10% of writeable space */
3566 max_chunk_size = min(div_factor(fs_devices->total_rw_bytes, 1),
3567 max_chunk_size);
3568
3569 devices_info = kzalloc(sizeof(*devices_info) * fs_devices->rw_devices,
3570 GFP_NOFS);
3571 if (!devices_info)
3572 return -ENOMEM;
3573
3574 cur = fs_devices->alloc_list.next;
3575
3576 /*
3577 * in the first pass through the devices list, we gather information
3578 * about the available holes on each device.
3579 */
3580 ndevs = 0;
3581 while (cur != &fs_devices->alloc_list) {
3582 struct btrfs_device *device;
3583 u64 max_avail;
3584 u64 dev_offset;
3585
3586 device = list_entry(cur, struct btrfs_device, dev_alloc_list);
3587
3588 cur = cur->next;
3589
3590 if (!device->writeable) {
3591 WARN(1, KERN_ERR
3592 "btrfs: read-only device in alloc_list\n");
3593 continue;
3594 }
3595
3596 if (!device->in_fs_metadata ||
3597 device->is_tgtdev_for_dev_replace)
3598 continue;
3599
3600 if (device->total_bytes > device->bytes_used)
3601 total_avail = device->total_bytes - device->bytes_used;
3602 else
3603 total_avail = 0;
3604
3605 /* If there is no space on this device, skip it. */
3606 if (total_avail == 0)
3607 continue;
3608
3609 ret = find_free_dev_extent(device,
3610 max_stripe_size * dev_stripes,
3611 &dev_offset, &max_avail);
3612 if (ret && ret != -ENOSPC)
3613 goto error;
3614
3615 if (ret == 0)
3616 max_avail = max_stripe_size * dev_stripes;
3617
3618 if (max_avail < BTRFS_STRIPE_LEN * dev_stripes)
3619 continue;
3620
3621 devices_info[ndevs].dev_offset = dev_offset;
3622 devices_info[ndevs].max_avail = max_avail;
3623 devices_info[ndevs].total_avail = total_avail;
3624 devices_info[ndevs].dev = device;
3625 ++ndevs;
3626 WARN_ON(ndevs > fs_devices->rw_devices);
3627 }
3628
3629 /*
3630 * now sort the devices by hole size / available space
3631 */
3632 sort(devices_info, ndevs, sizeof(struct btrfs_device_info),
3633 btrfs_cmp_device_info, NULL);
3634
3635 /* round down to number of usable stripes */
3636 ndevs -= ndevs % devs_increment;
3637
3638 if (ndevs < devs_increment * sub_stripes || ndevs < devs_min) {
3639 ret = -ENOSPC;
3640 goto error;
3641 }
3642
3643 if (devs_max && ndevs > devs_max)
3644 ndevs = devs_max;
3645 /*
3646 * the primary goal is to maximize the number of stripes, so use as many
3647 * devices as possible, even if the stripes are not maximum sized.
3648 */
3649 stripe_size = devices_info[ndevs-1].max_avail;
3650 num_stripes = ndevs * dev_stripes;
3651
3652 if (stripe_size * ndevs > max_chunk_size * ncopies) {
3653 stripe_size = max_chunk_size * ncopies;
3654 do_div(stripe_size, ndevs);
3655 }
3656
3657 do_div(stripe_size, dev_stripes);
3658
3659 /* align to BTRFS_STRIPE_LEN */
3660 do_div(stripe_size, BTRFS_STRIPE_LEN);
3661 stripe_size *= BTRFS_STRIPE_LEN;
3662
3663 map = kmalloc(map_lookup_size(num_stripes), GFP_NOFS);
3664 if (!map) {
3665 ret = -ENOMEM;
3666 goto error;
3667 }
3668 map->num_stripes = num_stripes;
3669
3670 for (i = 0; i < ndevs; ++i) {
3671 for (j = 0; j < dev_stripes; ++j) {
3672 int s = i * dev_stripes + j;
3673 map->stripes[s].dev = devices_info[i].dev;
3674 map->stripes[s].physical = devices_info[i].dev_offset +
3675 j * stripe_size;
3676 }
3677 }
3678 map->sector_size = extent_root->sectorsize;
3679 map->stripe_len = BTRFS_STRIPE_LEN;
3680 map->io_align = BTRFS_STRIPE_LEN;
3681 map->io_width = BTRFS_STRIPE_LEN;
3682 map->type = type;
3683 map->sub_stripes = sub_stripes;
3684
3685 *map_ret = map;
3686 num_bytes = stripe_size * (num_stripes / ncopies);
3687
3688 *stripe_size_out = stripe_size;
3689 *num_bytes_out = num_bytes;
3690
3691 trace_btrfs_chunk_alloc(info->chunk_root, map, start, num_bytes);
3692
3693 em = alloc_extent_map();
3694 if (!em) {
3695 ret = -ENOMEM;
3696 goto error;
3697 }
3698 em->bdev = (struct block_device *)map;
3699 em->start = start;
3700 em->len = num_bytes;
3701 em->block_start = 0;
3702 em->block_len = em->len;
3703
3704 em_tree = &extent_root->fs_info->mapping_tree.map_tree;
3705 write_lock(&em_tree->lock);
3706 ret = add_extent_mapping(em_tree, em);
3707 write_unlock(&em_tree->lock);
3708 free_extent_map(em);
3709 if (ret)
3710 goto error;
3711
3712 ret = btrfs_make_block_group(trans, extent_root, 0, type,
3713 BTRFS_FIRST_CHUNK_TREE_OBJECTID,
3714 start, num_bytes);
3715 if (ret)
3716 goto error;
3717
3718 for (i = 0; i < map->num_stripes; ++i) {
3719 struct btrfs_device *device;
3720 u64 dev_offset;
3721
3722 device = map->stripes[i].dev;
3723 dev_offset = map->stripes[i].physical;
3724
3725 ret = btrfs_alloc_dev_extent(trans, device,
3726 info->chunk_root->root_key.objectid,
3727 BTRFS_FIRST_CHUNK_TREE_OBJECTID,
3728 start, dev_offset, stripe_size);
3729 if (ret) {
3730 btrfs_abort_transaction(trans, extent_root, ret);
3731 goto error;
3732 }
3733 }
3734
3735 kfree(devices_info);
3736 return 0;
3737
3738 error:
3739 kfree(map);
3740 kfree(devices_info);
3741 return ret;
3742 }
3743
3744 static int __finish_chunk_alloc(struct btrfs_trans_handle *trans,
3745 struct btrfs_root *extent_root,
3746 struct map_lookup *map, u64 chunk_offset,
3747 u64 chunk_size, u64 stripe_size)
3748 {
3749 u64 dev_offset;
3750 struct btrfs_key key;
3751 struct btrfs_root *chunk_root = extent_root->fs_info->chunk_root;
3752 struct btrfs_device *device;
3753 struct btrfs_chunk *chunk;
3754 struct btrfs_stripe *stripe;
3755 size_t item_size = btrfs_chunk_item_size(map->num_stripes);
3756 int index = 0;
3757 int ret;
3758
3759 chunk = kzalloc(item_size, GFP_NOFS);
3760 if (!chunk)
3761 return -ENOMEM;
3762
3763 index = 0;
3764 while (index < map->num_stripes) {
3765 device = map->stripes[index].dev;
3766 device->bytes_used += stripe_size;
3767 ret = btrfs_update_device(trans, device);
3768 if (ret)
3769 goto out_free;
3770 index++;
3771 }
3772
3773 spin_lock(&extent_root->fs_info->free_chunk_lock);
3774 extent_root->fs_info->free_chunk_space -= (stripe_size *
3775 map->num_stripes);
3776 spin_unlock(&extent_root->fs_info->free_chunk_lock);
3777
3778 index = 0;
3779 stripe = &chunk->stripe;
3780 while (index < map->num_stripes) {
3781 device = map->stripes[index].dev;
3782 dev_offset = map->stripes[index].physical;
3783
3784 btrfs_set_stack_stripe_devid(stripe, device->devid);
3785 btrfs_set_stack_stripe_offset(stripe, dev_offset);
3786 memcpy(stripe->dev_uuid, device->uuid, BTRFS_UUID_SIZE);
3787 stripe++;
3788 index++;
3789 }
3790
3791 btrfs_set_stack_chunk_length(chunk, chunk_size);
3792 btrfs_set_stack_chunk_owner(chunk, extent_root->root_key.objectid);
3793 btrfs_set_stack_chunk_stripe_len(chunk, map->stripe_len);
3794 btrfs_set_stack_chunk_type(chunk, map->type);
3795 btrfs_set_stack_chunk_num_stripes(chunk, map->num_stripes);
3796 btrfs_set_stack_chunk_io_align(chunk, map->stripe_len);
3797 btrfs_set_stack_chunk_io_width(chunk, map->stripe_len);
3798 btrfs_set_stack_chunk_sector_size(chunk, extent_root->sectorsize);
3799 btrfs_set_stack_chunk_sub_stripes(chunk, map->sub_stripes);
3800
3801 key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
3802 key.type = BTRFS_CHUNK_ITEM_KEY;
3803 key.offset = chunk_offset;
3804
3805 ret = btrfs_insert_item(trans, chunk_root, &key, chunk, item_size);
3806
3807 if (ret == 0 && map->type & BTRFS_BLOCK_GROUP_SYSTEM) {
3808 /*
3809 * TODO: Cleanup of inserted chunk root in case of
3810 * failure.
3811 */
3812 ret = btrfs_add_system_chunk(chunk_root, &key, chunk,
3813 item_size);
3814 }
3815
3816 out_free:
3817 kfree(chunk);
3818 return ret;
3819 }
3820
3821 /*
3822 * Chunk allocation falls into two parts. The first part does works
3823 * that make the new allocated chunk useable, but not do any operation
3824 * that modifies the chunk tree. The second part does the works that
3825 * require modifying the chunk tree. This division is important for the
3826 * bootstrap process of adding storage to a seed btrfs.
3827 */
3828 int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
3829 struct btrfs_root *extent_root, u64 type)
3830 {
3831 u64 chunk_offset;
3832 u64 chunk_size;
3833 u64 stripe_size;
3834 struct map_lookup *map;
3835 struct btrfs_root *chunk_root = extent_root->fs_info->chunk_root;
3836 int ret;
3837
3838 ret = find_next_chunk(chunk_root, BTRFS_FIRST_CHUNK_TREE_OBJECTID,
3839 &chunk_offset);
3840 if (ret)
3841 return ret;
3842
3843 ret = __btrfs_alloc_chunk(trans, extent_root, &map, &chunk_size,
3844 &stripe_size, chunk_offset, type);
3845 if (ret)
3846 return ret;
3847
3848 ret = __finish_chunk_alloc(trans, extent_root, map, chunk_offset,
3849 chunk_size, stripe_size);
3850 if (ret)
3851 return ret;
3852 return 0;
3853 }
3854
3855 static noinline int init_first_rw_device(struct btrfs_trans_handle *trans,
3856 struct btrfs_root *root,
3857 struct btrfs_device *device)
3858 {
3859 u64 chunk_offset;
3860 u64 sys_chunk_offset;
3861 u64 chunk_size;
3862 u64 sys_chunk_size;
3863 u64 stripe_size;
3864 u64 sys_stripe_size;
3865 u64 alloc_profile;
3866 struct map_lookup *map;
3867 struct map_lookup *sys_map;
3868 struct btrfs_fs_info *fs_info = root->fs_info;
3869 struct btrfs_root *extent_root = fs_info->extent_root;
3870 int ret;
3871
3872 ret = find_next_chunk(fs_info->chunk_root,
3873 BTRFS_FIRST_CHUNK_TREE_OBJECTID, &chunk_offset);
3874 if (ret)
3875 return ret;
3876
3877 alloc_profile = BTRFS_BLOCK_GROUP_METADATA |
3878 fs_info->avail_metadata_alloc_bits;
3879 alloc_profile = btrfs_reduce_alloc_profile(root, alloc_profile);
3880
3881 ret = __btrfs_alloc_chunk(trans, extent_root, &map, &chunk_size,
3882 &stripe_size, chunk_offset, alloc_profile);
3883 if (ret)
3884 return ret;
3885
3886 sys_chunk_offset = chunk_offset + chunk_size;
3887
3888 alloc_profile = BTRFS_BLOCK_GROUP_SYSTEM |
3889 fs_info->avail_system_alloc_bits;
3890 alloc_profile = btrfs_reduce_alloc_profile(root, alloc_profile);
3891
3892 ret = __btrfs_alloc_chunk(trans, extent_root, &sys_map,
3893 &sys_chunk_size, &sys_stripe_size,
3894 sys_chunk_offset, alloc_profile);
3895 if (ret) {
3896 btrfs_abort_transaction(trans, root, ret);
3897 goto out;
3898 }
3899
3900 ret = btrfs_add_device(trans, fs_info->chunk_root, device);
3901 if (ret) {
3902 btrfs_abort_transaction(trans, root, ret);
3903 goto out;
3904 }
3905
3906 /*
3907 * Modifying chunk tree needs allocating new blocks from both
3908 * system block group and metadata block group. So we only can
3909 * do operations require modifying the chunk tree after both
3910 * block groups were created.
3911 */
3912 ret = __finish_chunk_alloc(trans, extent_root, map, chunk_offset,
3913 chunk_size, stripe_size);
3914 if (ret) {
3915 btrfs_abort_transaction(trans, root, ret);
3916 goto out;
3917 }
3918
3919 ret = __finish_chunk_alloc(trans, extent_root, sys_map,
3920 sys_chunk_offset, sys_chunk_size,
3921 sys_stripe_size);
3922 if (ret)
3923 btrfs_abort_transaction(trans, root, ret);
3924
3925 out:
3926
3927 return ret;
3928 }
3929
3930 int btrfs_chunk_readonly(struct btrfs_root *root, u64 chunk_offset)
3931 {
3932 struct extent_map *em;
3933 struct map_lookup *map;
3934 struct btrfs_mapping_tree *map_tree = &root->fs_info->mapping_tree;
3935 int readonly = 0;
3936 int i;
3937
3938 read_lock(&map_tree->map_tree.lock);
3939 em = lookup_extent_mapping(&map_tree->map_tree, chunk_offset, 1);
3940 read_unlock(&map_tree->map_tree.lock);
3941 if (!em)
3942 return 1;
3943
3944 if (btrfs_test_opt(root, DEGRADED)) {
3945 free_extent_map(em);
3946 return 0;
3947 }
3948
3949 map = (struct map_lookup *)em->bdev;
3950 for (i = 0; i < map->num_stripes; i++) {
3951 if (!map->stripes[i].dev->writeable) {
3952 readonly = 1;
3953 break;
3954 }
3955 }
3956 free_extent_map(em);
3957 return readonly;
3958 }
3959
3960 void btrfs_mapping_init(struct btrfs_mapping_tree *tree)
3961 {
3962 extent_map_tree_init(&tree->map_tree);
3963 }
3964
3965 void btrfs_mapping_tree_free(struct btrfs_mapping_tree *tree)
3966 {
3967 struct extent_map *em;
3968
3969 while (1) {
3970 write_lock(&tree->map_tree.lock);
3971 em = lookup_extent_mapping(&tree->map_tree, 0, (u64)-1);
3972 if (em)
3973 remove_extent_mapping(&tree->map_tree, em);
3974 write_unlock(&tree->map_tree.lock);
3975 if (!em)
3976 break;
3977 kfree(em->bdev);
3978 /* once for us */
3979 free_extent_map(em);
3980 /* once for the tree */
3981 free_extent_map(em);
3982 }
3983 }
3984
3985 int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len)
3986 {
3987 struct btrfs_mapping_tree *map_tree = &fs_info->mapping_tree;
3988 struct extent_map *em;
3989 struct map_lookup *map;
3990 struct extent_map_tree *em_tree = &map_tree->map_tree;
3991 int ret;
3992
3993 read_lock(&em_tree->lock);
3994 em = lookup_extent_mapping(em_tree, logical, len);
3995 read_unlock(&em_tree->lock);
3996 BUG_ON(!em);
3997
3998 BUG_ON(em->start > logical || em->start + em->len < logical);
3999 map = (struct map_lookup *)em->bdev;
4000 if (map->type & (BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID1))
4001 ret = map->num_stripes;
4002 else if (map->type & BTRFS_BLOCK_GROUP_RAID10)
4003 ret = map->sub_stripes;
4004 else
4005 ret = 1;
4006 free_extent_map(em);
4007
4008 btrfs_dev_replace_lock(&fs_info->dev_replace);
4009 if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace))
4010 ret++;
4011 btrfs_dev_replace_unlock(&fs_info->dev_replace);
4012
4013 return ret;
4014 }
4015
4016 static int find_live_mirror(struct btrfs_fs_info *fs_info,
4017 struct map_lookup *map, int first, int num,
4018 int optimal, int dev_replace_is_ongoing)
4019 {
4020 int i;
4021 int tolerance;
4022 struct btrfs_device *srcdev;
4023
4024 if (dev_replace_is_ongoing &&
4025 fs_info->dev_replace.cont_reading_from_srcdev_mode ==
4026 BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_AVOID)
4027 srcdev = fs_info->dev_replace.srcdev;
4028 else
4029 srcdev = NULL;
4030
4031 /*
4032 * try to avoid the drive that is the source drive for a
4033 * dev-replace procedure, only choose it if no other non-missing
4034 * mirror is available
4035 */
4036 for (tolerance = 0; tolerance < 2; tolerance++) {
4037 if (map->stripes[optimal].dev->bdev &&
4038 (tolerance || map->stripes[optimal].dev != srcdev))
4039 return optimal;
4040 for (i = first; i < first + num; i++) {
4041 if (map->stripes[i].dev->bdev &&
4042 (tolerance || map->stripes[i].dev != srcdev))
4043 return i;
4044 }
4045 }
4046
4047 /* we couldn't find one that doesn't fail. Just return something
4048 * and the io error handling code will clean up eventually
4049 */
4050 return optimal;
4051 }
4052
4053 static int __btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
4054 u64 logical, u64 *length,
4055 struct btrfs_bio **bbio_ret,
4056 int mirror_num)
4057 {
4058 struct extent_map *em;
4059 struct map_lookup *map;
4060 struct btrfs_mapping_tree *map_tree = &fs_info->mapping_tree;
4061 struct extent_map_tree *em_tree = &map_tree->map_tree;
4062 u64 offset;
4063 u64 stripe_offset;
4064 u64 stripe_end_offset;
4065 u64 stripe_nr;
4066 u64 stripe_nr_orig;
4067 u64 stripe_nr_end;
4068 int stripe_index;
4069 int i;
4070 int ret = 0;
4071 int num_stripes;
4072 int max_errors = 0;
4073 struct btrfs_bio *bbio = NULL;
4074 struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
4075 int dev_replace_is_ongoing = 0;
4076 int num_alloc_stripes;
4077 int patch_the_first_stripe_for_dev_replace = 0;
4078 u64 physical_to_patch_in_first_stripe = 0;
4079
4080 read_lock(&em_tree->lock);
4081 em = lookup_extent_mapping(em_tree, logical, *length);
4082 read_unlock(&em_tree->lock);
4083
4084 if (!em) {
4085 printk(KERN_CRIT "btrfs: unable to find logical %llu len %llu\n",
4086 (unsigned long long)logical,
4087 (unsigned long long)*length);
4088 BUG();
4089 }
4090
4091 BUG_ON(em->start > logical || em->start + em->len < logical);
4092 map = (struct map_lookup *)em->bdev;
4093 offset = logical - em->start;
4094
4095 stripe_nr = offset;
4096 /*
4097 * stripe_nr counts the total number of stripes we have to stride
4098 * to get to this block
4099 */
4100 do_div(stripe_nr, map->stripe_len);
4101
4102 stripe_offset = stripe_nr * map->stripe_len;
4103 BUG_ON(offset < stripe_offset);
4104
4105 /* stripe_offset is the offset of this block in its stripe*/
4106 stripe_offset = offset - stripe_offset;
4107
4108 if (rw & REQ_DISCARD)
4109 *length = min_t(u64, em->len - offset, *length);
4110 else if (map->type & BTRFS_BLOCK_GROUP_PROFILE_MASK) {
4111 /* we limit the length of each bio to what fits in a stripe */
4112 *length = min_t(u64, em->len - offset,
4113 map->stripe_len - stripe_offset);
4114 } else {
4115 *length = em->len - offset;
4116 }
4117
4118 if (!bbio_ret)
4119 goto out;
4120
4121 btrfs_dev_replace_lock(dev_replace);
4122 dev_replace_is_ongoing = btrfs_dev_replace_is_ongoing(dev_replace);
4123 if (!dev_replace_is_ongoing)
4124 btrfs_dev_replace_unlock(dev_replace);
4125
4126 if (dev_replace_is_ongoing && mirror_num == map->num_stripes + 1 &&
4127 !(rw & (REQ_WRITE | REQ_DISCARD | REQ_GET_READ_MIRRORS)) &&
4128 dev_replace->tgtdev != NULL) {
4129 /*
4130 * in dev-replace case, for repair case (that's the only
4131 * case where the mirror is selected explicitly when
4132 * calling btrfs_map_block), blocks left of the left cursor
4133 * can also be read from the target drive.
4134 * For REQ_GET_READ_MIRRORS, the target drive is added as
4135 * the last one to the array of stripes. For READ, it also
4136 * needs to be supported using the same mirror number.
4137 * If the requested block is not left of the left cursor,
4138 * EIO is returned. This can happen because btrfs_num_copies()
4139 * returns one more in the dev-replace case.
4140 */
4141 u64 tmp_length = *length;
4142 struct btrfs_bio *tmp_bbio = NULL;
4143 int tmp_num_stripes;
4144 u64 srcdev_devid = dev_replace->srcdev->devid;
4145 int index_srcdev = 0;
4146 int found = 0;
4147 u64 physical_of_found = 0;
4148
4149 ret = __btrfs_map_block(fs_info, REQ_GET_READ_MIRRORS,
4150 logical, &tmp_length, &tmp_bbio, 0);
4151 if (ret) {
4152 WARN_ON(tmp_bbio != NULL);
4153 goto out;
4154 }
4155
4156 tmp_num_stripes = tmp_bbio->num_stripes;
4157 if (mirror_num > tmp_num_stripes) {
4158 /*
4159 * REQ_GET_READ_MIRRORS does not contain this
4160 * mirror, that means that the requested area
4161 * is not left of the left cursor
4162 */
4163 ret = -EIO;
4164 kfree(tmp_bbio);
4165 goto out;
4166 }
4167
4168 /*
4169 * process the rest of the function using the mirror_num
4170 * of the source drive. Therefore look it up first.
4171 * At the end, patch the device pointer to the one of the
4172 * target drive.
4173 */
4174 for (i = 0; i < tmp_num_stripes; i++) {
4175 if (tmp_bbio->stripes[i].dev->devid == srcdev_devid) {
4176 /*
4177 * In case of DUP, in order to keep it
4178 * simple, only add the mirror with the
4179 * lowest physical address
4180 */
4181 if (found &&
4182 physical_of_found <=
4183 tmp_bbio->stripes[i].physical)
4184 continue;
4185 index_srcdev = i;
4186 found = 1;
4187 physical_of_found =
4188 tmp_bbio->stripes[i].physical;
4189 }
4190 }
4191
4192 if (found) {
4193 mirror_num = index_srcdev + 1;
4194 patch_the_first_stripe_for_dev_replace = 1;
4195 physical_to_patch_in_first_stripe = physical_of_found;
4196 } else {
4197 WARN_ON(1);
4198 ret = -EIO;
4199 kfree(tmp_bbio);
4200 goto out;
4201 }
4202
4203 kfree(tmp_bbio);
4204 } else if (mirror_num > map->num_stripes) {
4205 mirror_num = 0;
4206 }
4207
4208 num_stripes = 1;
4209 stripe_index = 0;
4210 stripe_nr_orig = stripe_nr;
4211 stripe_nr_end = (offset + *length + map->stripe_len - 1) &
4212 (~(map->stripe_len - 1));
4213 do_div(stripe_nr_end, map->stripe_len);
4214 stripe_end_offset = stripe_nr_end * map->stripe_len -
4215 (offset + *length);
4216 if (map->type & BTRFS_BLOCK_GROUP_RAID0) {
4217 if (rw & REQ_DISCARD)
4218 num_stripes = min_t(u64, map->num_stripes,
4219 stripe_nr_end - stripe_nr_orig);
4220 stripe_index = do_div(stripe_nr, map->num_stripes);
4221 } else if (map->type & BTRFS_BLOCK_GROUP_RAID1) {
4222 if (rw & (REQ_WRITE | REQ_DISCARD | REQ_GET_READ_MIRRORS))
4223 num_stripes = map->num_stripes;
4224 else if (mirror_num)
4225 stripe_index = mirror_num - 1;
4226 else {
4227 stripe_index = find_live_mirror(fs_info, map, 0,
4228 map->num_stripes,
4229 current->pid % map->num_stripes,
4230 dev_replace_is_ongoing);
4231 mirror_num = stripe_index + 1;
4232 }
4233
4234 } else if (map->type & BTRFS_BLOCK_GROUP_DUP) {
4235 if (rw & (REQ_WRITE | REQ_DISCARD | REQ_GET_READ_MIRRORS)) {
4236 num_stripes = map->num_stripes;
4237 } else if (mirror_num) {
4238 stripe_index = mirror_num - 1;
4239 } else {
4240 mirror_num = 1;
4241 }
4242
4243 } else if (map->type & BTRFS_BLOCK_GROUP_RAID10) {
4244 int factor = map->num_stripes / map->sub_stripes;
4245
4246 stripe_index = do_div(stripe_nr, factor);
4247 stripe_index *= map->sub_stripes;
4248
4249 if (rw & (REQ_WRITE | REQ_GET_READ_MIRRORS))
4250 num_stripes = map->sub_stripes;
4251 else if (rw & REQ_DISCARD)
4252 num_stripes = min_t(u64, map->sub_stripes *
4253 (stripe_nr_end - stripe_nr_orig),
4254 map->num_stripes);
4255 else if (mirror_num)
4256 stripe_index += mirror_num - 1;
4257 else {
4258 int old_stripe_index = stripe_index;
4259 stripe_index = find_live_mirror(fs_info, map,
4260 stripe_index,
4261 map->sub_stripes, stripe_index +
4262 current->pid % map->sub_stripes,
4263 dev_replace_is_ongoing);
4264 mirror_num = stripe_index - old_stripe_index + 1;
4265 }
4266 } else {
4267 /*
4268 * after this do_div call, stripe_nr is the number of stripes
4269 * on this device we have to walk to find the data, and
4270 * stripe_index is the number of our device in the stripe array
4271 */
4272 stripe_index = do_div(stripe_nr, map->num_stripes);
4273 mirror_num = stripe_index + 1;
4274 }
4275 BUG_ON(stripe_index >= map->num_stripes);
4276
4277 num_alloc_stripes = num_stripes;
4278 if (dev_replace_is_ongoing) {
4279 if (rw & (REQ_WRITE | REQ_DISCARD))
4280 num_alloc_stripes <<= 1;
4281 if (rw & REQ_GET_READ_MIRRORS)
4282 num_alloc_stripes++;
4283 }
4284 bbio = kzalloc(btrfs_bio_size(num_alloc_stripes), GFP_NOFS);
4285 if (!bbio) {
4286 ret = -ENOMEM;
4287 goto out;
4288 }
4289 atomic_set(&bbio->error, 0);
4290
4291 if (rw & REQ_DISCARD) {
4292 int factor = 0;
4293 int sub_stripes = 0;
4294 u64 stripes_per_dev = 0;
4295 u32 remaining_stripes = 0;
4296 u32 last_stripe = 0;
4297
4298 if (map->type &
4299 (BTRFS_BLOCK_GROUP_RAID0 | BTRFS_BLOCK_GROUP_RAID10)) {
4300 if (map->type & BTRFS_BLOCK_GROUP_RAID0)
4301 sub_stripes = 1;
4302 else
4303 sub_stripes = map->sub_stripes;
4304
4305 factor = map->num_stripes / sub_stripes;
4306 stripes_per_dev = div_u64_rem(stripe_nr_end -
4307 stripe_nr_orig,
4308 factor,
4309 &remaining_stripes);
4310 div_u64_rem(stripe_nr_end - 1, factor, &last_stripe);
4311 last_stripe *= sub_stripes;
4312 }
4313
4314 for (i = 0; i < num_stripes; i++) {
4315 bbio->stripes[i].physical =
4316 map->stripes[stripe_index].physical +
4317 stripe_offset + stripe_nr * map->stripe_len;
4318 bbio->stripes[i].dev = map->stripes[stripe_index].dev;
4319
4320 if (map->type & (BTRFS_BLOCK_GROUP_RAID0 |
4321 BTRFS_BLOCK_GROUP_RAID10)) {
4322 bbio->stripes[i].length = stripes_per_dev *
4323 map->stripe_len;
4324
4325 if (i / sub_stripes < remaining_stripes)
4326 bbio->stripes[i].length +=
4327 map->stripe_len;
4328
4329 /*
4330 * Special for the first stripe and
4331 * the last stripe:
4332 *
4333 * |-------|...|-------|
4334 * |----------|
4335 * off end_off
4336 */
4337 if (i < sub_stripes)
4338 bbio->stripes[i].length -=
4339 stripe_offset;
4340
4341 if (stripe_index >= last_stripe &&
4342 stripe_index <= (last_stripe +
4343 sub_stripes - 1))
4344 bbio->stripes[i].length -=
4345 stripe_end_offset;
4346
4347 if (i == sub_stripes - 1)
4348 stripe_offset = 0;
4349 } else
4350 bbio->stripes[i].length = *length;
4351
4352 stripe_index++;
4353 if (stripe_index == map->num_stripes) {
4354 /* This could only happen for RAID0/10 */
4355 stripe_index = 0;
4356 stripe_nr++;
4357 }
4358 }
4359 } else {
4360 for (i = 0; i < num_stripes; i++) {
4361 bbio->stripes[i].physical =
4362 map->stripes[stripe_index].physical +
4363 stripe_offset +
4364 stripe_nr * map->stripe_len;
4365 bbio->stripes[i].dev =
4366 map->stripes[stripe_index].dev;
4367 stripe_index++;
4368 }
4369 }
4370
4371 if (rw & (REQ_WRITE | REQ_GET_READ_MIRRORS)) {
4372 if (map->type & (BTRFS_BLOCK_GROUP_RAID1 |
4373 BTRFS_BLOCK_GROUP_RAID10 |
4374 BTRFS_BLOCK_GROUP_DUP)) {
4375 max_errors = 1;
4376 }
4377 }
4378
4379 if (dev_replace_is_ongoing && (rw & (REQ_WRITE | REQ_DISCARD)) &&
4380 dev_replace->tgtdev != NULL) {
4381 int index_where_to_add;
4382 u64 srcdev_devid = dev_replace->srcdev->devid;
4383
4384 /*
4385 * duplicate the write operations while the dev replace
4386 * procedure is running. Since the copying of the old disk
4387 * to the new disk takes place at run time while the
4388 * filesystem is mounted writable, the regular write
4389 * operations to the old disk have to be duplicated to go
4390 * to the new disk as well.
4391 * Note that device->missing is handled by the caller, and
4392 * that the write to the old disk is already set up in the
4393 * stripes array.
4394 */
4395 index_where_to_add = num_stripes;
4396 for (i = 0; i < num_stripes; i++) {
4397 if (bbio->stripes[i].dev->devid == srcdev_devid) {
4398 /* write to new disk, too */
4399 struct btrfs_bio_stripe *new =
4400 bbio->stripes + index_where_to_add;
4401 struct btrfs_bio_stripe *old =
4402 bbio->stripes + i;
4403
4404 new->physical = old->physical;
4405 new->length = old->length;
4406 new->dev = dev_replace->tgtdev;
4407 index_where_to_add++;
4408 max_errors++;
4409 }
4410 }
4411 num_stripes = index_where_to_add;
4412 } else if (dev_replace_is_ongoing && (rw & REQ_GET_READ_MIRRORS) &&
4413 dev_replace->tgtdev != NULL) {
4414 u64 srcdev_devid = dev_replace->srcdev->devid;
4415 int index_srcdev = 0;
4416 int found = 0;
4417 u64 physical_of_found = 0;
4418
4419 /*
4420 * During the dev-replace procedure, the target drive can
4421 * also be used to read data in case it is needed to repair
4422 * a corrupt block elsewhere. This is possible if the
4423 * requested area is left of the left cursor. In this area,
4424 * the target drive is a full copy of the source drive.
4425 */
4426 for (i = 0; i < num_stripes; i++) {
4427 if (bbio->stripes[i].dev->devid == srcdev_devid) {
4428 /*
4429 * In case of DUP, in order to keep it
4430 * simple, only add the mirror with the
4431 * lowest physical address
4432 */
4433 if (found &&
4434 physical_of_found <=
4435 bbio->stripes[i].physical)
4436 continue;
4437 index_srcdev = i;
4438 found = 1;
4439 physical_of_found = bbio->stripes[i].physical;
4440 }
4441 }
4442 if (found) {
4443 u64 length = map->stripe_len;
4444
4445 if (physical_of_found + length <=
4446 dev_replace->cursor_left) {
4447 struct btrfs_bio_stripe *tgtdev_stripe =
4448 bbio->stripes + num_stripes;
4449
4450 tgtdev_stripe->physical = physical_of_found;
4451 tgtdev_stripe->length =
4452 bbio->stripes[index_srcdev].length;
4453 tgtdev_stripe->dev = dev_replace->tgtdev;
4454
4455 num_stripes++;
4456 }
4457 }
4458 }
4459
4460 *bbio_ret = bbio;
4461 bbio->num_stripes = num_stripes;
4462 bbio->max_errors = max_errors;
4463 bbio->mirror_num = mirror_num;
4464
4465 /*
4466 * this is the case that REQ_READ && dev_replace_is_ongoing &&
4467 * mirror_num == num_stripes + 1 && dev_replace target drive is
4468 * available as a mirror
4469 */
4470 if (patch_the_first_stripe_for_dev_replace && num_stripes > 0) {
4471 WARN_ON(num_stripes > 1);
4472 bbio->stripes[0].dev = dev_replace->tgtdev;
4473 bbio->stripes[0].physical = physical_to_patch_in_first_stripe;
4474 bbio->mirror_num = map->num_stripes + 1;
4475 }
4476 out:
4477 if (dev_replace_is_ongoing)
4478 btrfs_dev_replace_unlock(dev_replace);
4479 free_extent_map(em);
4480 return ret;
4481 }
4482
4483 int btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
4484 u64 logical, u64 *length,
4485 struct btrfs_bio **bbio_ret, int mirror_num)
4486 {
4487 return __btrfs_map_block(fs_info, rw, logical, length, bbio_ret,
4488 mirror_num);
4489 }
4490
4491 int btrfs_rmap_block(struct btrfs_mapping_tree *map_tree,
4492 u64 chunk_start, u64 physical, u64 devid,
4493 u64 **logical, int *naddrs, int *stripe_len)
4494 {
4495 struct extent_map_tree *em_tree = &map_tree->map_tree;
4496 struct extent_map *em;
4497 struct map_lookup *map;
4498 u64 *buf;
4499 u64 bytenr;
4500 u64 length;
4501 u64 stripe_nr;
4502 int i, j, nr = 0;
4503
4504 read_lock(&em_tree->lock);
4505 em = lookup_extent_mapping(em_tree, chunk_start, 1);
4506 read_unlock(&em_tree->lock);
4507
4508 BUG_ON(!em || em->start != chunk_start);
4509 map = (struct map_lookup *)em->bdev;
4510
4511 length = em->len;
4512 if (map->type & BTRFS_BLOCK_GROUP_RAID10)
4513 do_div(length, map->num_stripes / map->sub_stripes);
4514 else if (map->type & BTRFS_BLOCK_GROUP_RAID0)
4515 do_div(length, map->num_stripes);
4516
4517 buf = kzalloc(sizeof(u64) * map->num_stripes, GFP_NOFS);
4518 BUG_ON(!buf); /* -ENOMEM */
4519
4520 for (i = 0; i < map->num_stripes; i++) {
4521 if (devid && map->stripes[i].dev->devid != devid)
4522 continue;
4523 if (map->stripes[i].physical > physical ||
4524 map->stripes[i].physical + length <= physical)
4525 continue;
4526
4527 stripe_nr = physical - map->stripes[i].physical;
4528 do_div(stripe_nr, map->stripe_len);
4529
4530 if (map->type & BTRFS_BLOCK_GROUP_RAID10) {
4531 stripe_nr = stripe_nr * map->num_stripes + i;
4532 do_div(stripe_nr, map->sub_stripes);
4533 } else if (map->type & BTRFS_BLOCK_GROUP_RAID0) {
4534 stripe_nr = stripe_nr * map->num_stripes + i;
4535 }
4536 bytenr = chunk_start + stripe_nr * map->stripe_len;
4537 WARN_ON(nr >= map->num_stripes);
4538 for (j = 0; j < nr; j++) {
4539 if (buf[j] == bytenr)
4540 break;
4541 }
4542 if (j == nr) {
4543 WARN_ON(nr >= map->num_stripes);
4544 buf[nr++] = bytenr;
4545 }
4546 }
4547
4548 *logical = buf;
4549 *naddrs = nr;
4550 *stripe_len = map->stripe_len;
4551
4552 free_extent_map(em);
4553 return 0;
4554 }
4555
4556 static void *merge_stripe_index_into_bio_private(void *bi_private,
4557 unsigned int stripe_index)
4558 {
4559 /*
4560 * with single, dup, RAID0, RAID1 and RAID10, stripe_index is
4561 * at most 1.
4562 * The alternative solution (instead of stealing bits from the
4563 * pointer) would be to allocate an intermediate structure
4564 * that contains the old private pointer plus the stripe_index.
4565 */
4566 BUG_ON((((uintptr_t)bi_private) & 3) != 0);
4567 BUG_ON(stripe_index > 3);
4568 return (void *)(((uintptr_t)bi_private) | stripe_index);
4569 }
4570
4571 static struct btrfs_bio *extract_bbio_from_bio_private(void *bi_private)
4572 {
4573 return (struct btrfs_bio *)(((uintptr_t)bi_private) & ~((uintptr_t)3));
4574 }
4575
4576 static unsigned int extract_stripe_index_from_bio_private(void *bi_private)
4577 {
4578 return (unsigned int)((uintptr_t)bi_private) & 3;
4579 }
4580
4581 static void btrfs_end_bio(struct bio *bio, int err)
4582 {
4583 struct btrfs_bio *bbio = extract_bbio_from_bio_private(bio->bi_private);
4584 int is_orig_bio = 0;
4585
4586 if (err) {
4587 atomic_inc(&bbio->error);
4588 if (err == -EIO || err == -EREMOTEIO) {
4589 unsigned int stripe_index =
4590 extract_stripe_index_from_bio_private(
4591 bio->bi_private);
4592 struct btrfs_device *dev;
4593
4594 BUG_ON(stripe_index >= bbio->num_stripes);
4595 dev = bbio->stripes[stripe_index].dev;
4596 if (dev->bdev) {
4597 if (bio->bi_rw & WRITE)
4598 btrfs_dev_stat_inc(dev,
4599 BTRFS_DEV_STAT_WRITE_ERRS);
4600 else
4601 btrfs_dev_stat_inc(dev,
4602 BTRFS_DEV_STAT_READ_ERRS);
4603 if ((bio->bi_rw & WRITE_FLUSH) == WRITE_FLUSH)
4604 btrfs_dev_stat_inc(dev,
4605 BTRFS_DEV_STAT_FLUSH_ERRS);
4606 btrfs_dev_stat_print_on_error(dev);
4607 }
4608 }
4609 }
4610
4611 if (bio == bbio->orig_bio)
4612 is_orig_bio = 1;
4613
4614 if (atomic_dec_and_test(&bbio->stripes_pending)) {
4615 if (!is_orig_bio) {
4616 bio_put(bio);
4617 bio = bbio->orig_bio;
4618 }
4619 bio->bi_private = bbio->private;
4620 bio->bi_end_io = bbio->end_io;
4621 bio->bi_bdev = (struct block_device *)
4622 (unsigned long)bbio->mirror_num;
4623 /* only send an error to the higher layers if it is
4624 * beyond the tolerance of the multi-bio
4625 */
4626 if (atomic_read(&bbio->error) > bbio->max_errors) {
4627 err = -EIO;
4628 } else {
4629 /*
4630 * this bio is actually up to date, we didn't
4631 * go over the max number of errors
4632 */
4633 set_bit(BIO_UPTODATE, &bio->bi_flags);
4634 err = 0;
4635 }
4636 kfree(bbio);
4637
4638 bio_endio(bio, err);
4639 } else if (!is_orig_bio) {
4640 bio_put(bio);
4641 }
4642 }
4643
4644 struct async_sched {
4645 struct bio *bio;
4646 int rw;
4647 struct btrfs_fs_info *info;
4648 struct btrfs_work work;
4649 };
4650
4651 /*
4652 * see run_scheduled_bios for a description of why bios are collected for
4653 * async submit.
4654 *
4655 * This will add one bio to the pending list for a device and make sure
4656 * the work struct is scheduled.
4657 */
4658 static noinline void schedule_bio(struct btrfs_root *root,
4659 struct btrfs_device *device,
4660 int rw, struct bio *bio)
4661 {
4662 int should_queue = 1;
4663 struct btrfs_pending_bios *pending_bios;
4664
4665 /* don't bother with additional async steps for reads, right now */
4666 if (!(rw & REQ_WRITE)) {
4667 bio_get(bio);
4668 btrfsic_submit_bio(rw, bio);
4669 bio_put(bio);
4670 return;
4671 }
4672
4673 /*
4674 * nr_async_bios allows us to reliably return congestion to the
4675 * higher layers. Otherwise, the async bio makes it appear we have
4676 * made progress against dirty pages when we've really just put it
4677 * on a queue for later
4678 */
4679 atomic_inc(&root->fs_info->nr_async_bios);
4680 WARN_ON(bio->bi_next);
4681 bio->bi_next = NULL;
4682 bio->bi_rw |= rw;
4683
4684 spin_lock(&device->io_lock);
4685 if (bio->bi_rw & REQ_SYNC)
4686 pending_bios = &device->pending_sync_bios;
4687 else
4688 pending_bios = &device->pending_bios;
4689
4690 if (pending_bios->tail)
4691 pending_bios->tail->bi_next = bio;
4692
4693 pending_bios->tail = bio;
4694 if (!pending_bios->head)
4695 pending_bios->head = bio;
4696 if (device->running_pending)
4697 should_queue = 0;
4698
4699 spin_unlock(&device->io_lock);
4700
4701 if (should_queue)
4702 btrfs_queue_worker(&root->fs_info->submit_workers,
4703 &device->work);
4704 }
4705
4706 static int bio_size_ok(struct block_device *bdev, struct bio *bio,
4707 sector_t sector)
4708 {
4709 struct bio_vec *prev;
4710 struct request_queue *q = bdev_get_queue(bdev);
4711 unsigned short max_sectors = queue_max_sectors(q);
4712 struct bvec_merge_data bvm = {
4713 .bi_bdev = bdev,
4714 .bi_sector = sector,
4715 .bi_rw = bio->bi_rw,
4716 };
4717
4718 if (bio->bi_vcnt == 0) {
4719 WARN_ON(1);
4720 return 1;
4721 }
4722
4723 prev = &bio->bi_io_vec[bio->bi_vcnt - 1];
4724 if ((bio->bi_size >> 9) > max_sectors)
4725 return 0;
4726
4727 if (!q->merge_bvec_fn)
4728 return 1;
4729
4730 bvm.bi_size = bio->bi_size - prev->bv_len;
4731 if (q->merge_bvec_fn(q, &bvm, prev) < prev->bv_len)
4732 return 0;
4733 return 1;
4734 }
4735
4736 static void submit_stripe_bio(struct btrfs_root *root, struct btrfs_bio *bbio,
4737 struct bio *bio, u64 physical, int dev_nr,
4738 int rw, int async)
4739 {
4740 struct btrfs_device *dev = bbio->stripes[dev_nr].dev;
4741
4742 bio->bi_private = bbio;
4743 bio->bi_private = merge_stripe_index_into_bio_private(
4744 bio->bi_private, (unsigned int)dev_nr);
4745 bio->bi_end_io = btrfs_end_bio;
4746 bio->bi_sector = physical >> 9;
4747 #ifdef DEBUG
4748 {
4749 struct rcu_string *name;
4750
4751 rcu_read_lock();
4752 name = rcu_dereference(dev->name);
4753 pr_debug("btrfs_map_bio: rw %d, sector=%llu, dev=%lu "
4754 "(%s id %llu), size=%u\n", rw,
4755 (u64)bio->bi_sector, (u_long)dev->bdev->bd_dev,
4756 name->str, dev->devid, bio->bi_size);
4757 rcu_read_unlock();
4758 }
4759 #endif
4760 bio->bi_bdev = dev->bdev;
4761 if (async)
4762 schedule_bio(root, dev, rw, bio);
4763 else
4764 btrfsic_submit_bio(rw, bio);
4765 }
4766
4767 static int breakup_stripe_bio(struct btrfs_root *root, struct btrfs_bio *bbio,
4768 struct bio *first_bio, struct btrfs_device *dev,
4769 int dev_nr, int rw, int async)
4770 {
4771 struct bio_vec *bvec = first_bio->bi_io_vec;
4772 struct bio *bio;
4773 int nr_vecs = bio_get_nr_vecs(dev->bdev);
4774 u64 physical = bbio->stripes[dev_nr].physical;
4775
4776 again:
4777 bio = btrfs_bio_alloc(dev->bdev, physical >> 9, nr_vecs, GFP_NOFS);
4778 if (!bio)
4779 return -ENOMEM;
4780
4781 while (bvec <= (first_bio->bi_io_vec + first_bio->bi_vcnt - 1)) {
4782 if (bio_add_page(bio, bvec->bv_page, bvec->bv_len,
4783 bvec->bv_offset) < bvec->bv_len) {
4784 u64 len = bio->bi_size;
4785
4786 atomic_inc(&bbio->stripes_pending);
4787 submit_stripe_bio(root, bbio, bio, physical, dev_nr,
4788 rw, async);
4789 physical += len;
4790 goto again;
4791 }
4792 bvec++;
4793 }
4794
4795 submit_stripe_bio(root, bbio, bio, physical, dev_nr, rw, async);
4796 return 0;
4797 }
4798
4799 static void bbio_error(struct btrfs_bio *bbio, struct bio *bio, u64 logical)
4800 {
4801 atomic_inc(&bbio->error);
4802 if (atomic_dec_and_test(&bbio->stripes_pending)) {
4803 bio->bi_private = bbio->private;
4804 bio->bi_end_io = bbio->end_io;
4805 bio->bi_bdev = (struct block_device *)
4806 (unsigned long)bbio->mirror_num;
4807 bio->bi_sector = logical >> 9;
4808 kfree(bbio);
4809 bio_endio(bio, -EIO);
4810 }
4811 }
4812
4813 int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
4814 int mirror_num, int async_submit)
4815 {
4816 struct btrfs_device *dev;
4817 struct bio *first_bio = bio;
4818 u64 logical = (u64)bio->bi_sector << 9;
4819 u64 length = 0;
4820 u64 map_length;
4821 int ret;
4822 int dev_nr = 0;
4823 int total_devs = 1;
4824 struct btrfs_bio *bbio = NULL;
4825
4826 length = bio->bi_size;
4827 map_length = length;
4828
4829 ret = btrfs_map_block(root->fs_info, rw, logical, &map_length, &bbio,
4830 mirror_num);
4831 if (ret)
4832 return ret;
4833
4834 total_devs = bbio->num_stripes;
4835 if (map_length < length) {
4836 printk(KERN_CRIT "btrfs: mapping failed logical %llu bio len %llu "
4837 "len %llu\n", (unsigned long long)logical,
4838 (unsigned long long)length,
4839 (unsigned long long)map_length);
4840 BUG();
4841 }
4842
4843 bbio->orig_bio = first_bio;
4844 bbio->private = first_bio->bi_private;
4845 bbio->end_io = first_bio->bi_end_io;
4846 atomic_set(&bbio->stripes_pending, bbio->num_stripes);
4847
4848 while (dev_nr < total_devs) {
4849 dev = bbio->stripes[dev_nr].dev;
4850 if (!dev || !dev->bdev || (rw & WRITE && !dev->writeable)) {
4851 bbio_error(bbio, first_bio, logical);
4852 dev_nr++;
4853 continue;
4854 }
4855
4856 /*
4857 * Check and see if we're ok with this bio based on it's size
4858 * and offset with the given device.
4859 */
4860 if (!bio_size_ok(dev->bdev, first_bio,
4861 bbio->stripes[dev_nr].physical >> 9)) {
4862 ret = breakup_stripe_bio(root, bbio, first_bio, dev,
4863 dev_nr, rw, async_submit);
4864 BUG_ON(ret);
4865 dev_nr++;
4866 continue;
4867 }
4868
4869 if (dev_nr < total_devs - 1) {
4870 bio = bio_clone(first_bio, GFP_NOFS);
4871 BUG_ON(!bio); /* -ENOMEM */
4872 } else {
4873 bio = first_bio;
4874 }
4875
4876 submit_stripe_bio(root, bbio, bio,
4877 bbio->stripes[dev_nr].physical, dev_nr, rw,
4878 async_submit);
4879 dev_nr++;
4880 }
4881 return 0;
4882 }
4883
4884 struct btrfs_device *btrfs_find_device(struct btrfs_fs_info *fs_info, u64 devid,
4885 u8 *uuid, u8 *fsid)
4886 {
4887 struct btrfs_device *device;
4888 struct btrfs_fs_devices *cur_devices;
4889
4890 cur_devices = fs_info->fs_devices;
4891 while (cur_devices) {
4892 if (!fsid ||
4893 !memcmp(cur_devices->fsid, fsid, BTRFS_UUID_SIZE)) {
4894 device = __find_device(&cur_devices->devices,
4895 devid, uuid);
4896 if (device)
4897 return device;
4898 }
4899 cur_devices = cur_devices->seed;
4900 }
4901 return NULL;
4902 }
4903
4904 static struct btrfs_device *add_missing_dev(struct btrfs_root *root,
4905 u64 devid, u8 *dev_uuid)
4906 {
4907 struct btrfs_device *device;
4908 struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
4909
4910 device = kzalloc(sizeof(*device), GFP_NOFS);
4911 if (!device)
4912 return NULL;
4913 list_add(&device->dev_list,
4914 &fs_devices->devices);
4915 device->dev_root = root->fs_info->dev_root;
4916 device->devid = devid;
4917 device->work.func = pending_bios_fn;
4918 device->fs_devices = fs_devices;
4919 device->missing = 1;
4920 fs_devices->num_devices++;
4921 fs_devices->missing_devices++;
4922 spin_lock_init(&device->io_lock);
4923 INIT_LIST_HEAD(&device->dev_alloc_list);
4924 memcpy(device->uuid, dev_uuid, BTRFS_UUID_SIZE);
4925 return device;
4926 }
4927
4928 static int read_one_chunk(struct btrfs_root *root, struct btrfs_key *key,
4929 struct extent_buffer *leaf,
4930 struct btrfs_chunk *chunk)
4931 {
4932 struct btrfs_mapping_tree *map_tree = &root->fs_info->mapping_tree;
4933 struct map_lookup *map;
4934 struct extent_map *em;
4935 u64 logical;
4936 u64 length;
4937 u64 devid;
4938 u8 uuid[BTRFS_UUID_SIZE];
4939 int num_stripes;
4940 int ret;
4941 int i;
4942
4943 logical = key->offset;
4944 length = btrfs_chunk_length(leaf, chunk);
4945
4946 read_lock(&map_tree->map_tree.lock);
4947 em = lookup_extent_mapping(&map_tree->map_tree, logical, 1);
4948 read_unlock(&map_tree->map_tree.lock);
4949
4950 /* already mapped? */
4951 if (em && em->start <= logical && em->start + em->len > logical) {
4952 free_extent_map(em);
4953 return 0;
4954 } else if (em) {
4955 free_extent_map(em);
4956 }
4957
4958 em = alloc_extent_map();
4959 if (!em)
4960 return -ENOMEM;
4961 num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
4962 map = kmalloc(map_lookup_size(num_stripes), GFP_NOFS);
4963 if (!map) {
4964 free_extent_map(em);
4965 return -ENOMEM;
4966 }
4967
4968 em->bdev = (struct block_device *)map;
4969 em->start = logical;
4970 em->len = length;
4971 em->block_start = 0;
4972 em->block_len = em->len;
4973
4974 map->num_stripes = num_stripes;
4975 map->io_width = btrfs_chunk_io_width(leaf, chunk);
4976 map->io_align = btrfs_chunk_io_align(leaf, chunk);
4977 map->sector_size = btrfs_chunk_sector_size(leaf, chunk);
4978 map->stripe_len = btrfs_chunk_stripe_len(leaf, chunk);
4979 map->type = btrfs_chunk_type(leaf, chunk);
4980 map->sub_stripes = btrfs_chunk_sub_stripes(leaf, chunk);
4981 for (i = 0; i < num_stripes; i++) {
4982 map->stripes[i].physical =
4983 btrfs_stripe_offset_nr(leaf, chunk, i);
4984 devid = btrfs_stripe_devid_nr(leaf, chunk, i);
4985 read_extent_buffer(leaf, uuid, (unsigned long)
4986 btrfs_stripe_dev_uuid_nr(chunk, i),
4987 BTRFS_UUID_SIZE);
4988 map->stripes[i].dev = btrfs_find_device(root->fs_info, devid,
4989 uuid, NULL);
4990 if (!map->stripes[i].dev && !btrfs_test_opt(root, DEGRADED)) {
4991 kfree(map);
4992 free_extent_map(em);
4993 return -EIO;
4994 }
4995 if (!map->stripes[i].dev) {
4996 map->stripes[i].dev =
4997 add_missing_dev(root, devid, uuid);
4998 if (!map->stripes[i].dev) {
4999 kfree(map);
5000 free_extent_map(em);
5001 return -EIO;
5002 }
5003 }
5004 map->stripes[i].dev->in_fs_metadata = 1;
5005 }
5006
5007 write_lock(&map_tree->map_tree.lock);
5008 ret = add_extent_mapping(&map_tree->map_tree, em);
5009 write_unlock(&map_tree->map_tree.lock);
5010 BUG_ON(ret); /* Tree corruption */
5011 free_extent_map(em);
5012
5013 return 0;
5014 }
5015
5016 static void fill_device_from_item(struct extent_buffer *leaf,
5017 struct btrfs_dev_item *dev_item,
5018 struct btrfs_device *device)
5019 {
5020 unsigned long ptr;
5021
5022 device->devid = btrfs_device_id(leaf, dev_item);
5023 device->disk_total_bytes = btrfs_device_total_bytes(leaf, dev_item);
5024 device->total_bytes = device->disk_total_bytes;
5025 device->bytes_used = btrfs_device_bytes_used(leaf, dev_item);
5026 device->type = btrfs_device_type(leaf, dev_item);
5027 device->io_align = btrfs_device_io_align(leaf, dev_item);
5028 device->io_width = btrfs_device_io_width(leaf, dev_item);
5029 device->sector_size = btrfs_device_sector_size(leaf, dev_item);
5030 WARN_ON(device->devid == BTRFS_DEV_REPLACE_DEVID);
5031 device->is_tgtdev_for_dev_replace = 0;
5032
5033 ptr = (unsigned long)btrfs_device_uuid(dev_item);
5034 read_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE);
5035 }
5036
5037 static int open_seed_devices(struct btrfs_root *root, u8 *fsid)
5038 {
5039 struct btrfs_fs_devices *fs_devices;
5040 int ret;
5041
5042 BUG_ON(!mutex_is_locked(&uuid_mutex));
5043
5044 fs_devices = root->fs_info->fs_devices->seed;
5045 while (fs_devices) {
5046 if (!memcmp(fs_devices->fsid, fsid, BTRFS_UUID_SIZE)) {
5047 ret = 0;
5048 goto out;
5049 }
5050 fs_devices = fs_devices->seed;
5051 }
5052
5053 fs_devices = find_fsid(fsid);
5054 if (!fs_devices) {
5055 ret = -ENOENT;
5056 goto out;
5057 }
5058
5059 fs_devices = clone_fs_devices(fs_devices);
5060 if (IS_ERR(fs_devices)) {
5061 ret = PTR_ERR(fs_devices);
5062 goto out;
5063 }
5064
5065 ret = __btrfs_open_devices(fs_devices, FMODE_READ,
5066 root->fs_info->bdev_holder);
5067 if (ret) {
5068 free_fs_devices(fs_devices);
5069 goto out;
5070 }
5071
5072 if (!fs_devices->seeding) {
5073 __btrfs_close_devices(fs_devices);
5074 free_fs_devices(fs_devices);
5075 ret = -EINVAL;
5076 goto out;
5077 }
5078
5079 fs_devices->seed = root->fs_info->fs_devices->seed;
5080 root->fs_info->fs_devices->seed = fs_devices;
5081 out:
5082 return ret;
5083 }
5084
5085 static int read_one_dev(struct btrfs_root *root,
5086 struct extent_buffer *leaf,
5087 struct btrfs_dev_item *dev_item)
5088 {
5089 struct btrfs_device *device;
5090 u64 devid;
5091 int ret;
5092 u8 fs_uuid[BTRFS_UUID_SIZE];
5093 u8 dev_uuid[BTRFS_UUID_SIZE];
5094
5095 devid = btrfs_device_id(leaf, dev_item);
5096 read_extent_buffer(leaf, dev_uuid,
5097 (unsigned long)btrfs_device_uuid(dev_item),
5098 BTRFS_UUID_SIZE);
5099 read_extent_buffer(leaf, fs_uuid,
5100 (unsigned long)btrfs_device_fsid(dev_item),
5101 BTRFS_UUID_SIZE);
5102
5103 if (memcmp(fs_uuid, root->fs_info->fsid, BTRFS_UUID_SIZE)) {
5104 ret = open_seed_devices(root, fs_uuid);
5105 if (ret && !btrfs_test_opt(root, DEGRADED))
5106 return ret;
5107 }
5108
5109 device = btrfs_find_device(root->fs_info, devid, dev_uuid, fs_uuid);
5110 if (!device || !device->bdev) {
5111 if (!btrfs_test_opt(root, DEGRADED))
5112 return -EIO;
5113
5114 if (!device) {
5115 printk(KERN_WARNING "warning devid %llu missing\n",
5116 (unsigned long long)devid);
5117 device = add_missing_dev(root, devid, dev_uuid);
5118 if (!device)
5119 return -ENOMEM;
5120 } else if (!device->missing) {
5121 /*
5122 * this happens when a device that was properly setup
5123 * in the device info lists suddenly goes bad.
5124 * device->bdev is NULL, and so we have to set
5125 * device->missing to one here
5126 */
5127 root->fs_info->fs_devices->missing_devices++;
5128 device->missing = 1;
5129 }
5130 }
5131
5132 if (device->fs_devices != root->fs_info->fs_devices) {
5133 BUG_ON(device->writeable);
5134 if (device->generation !=
5135 btrfs_device_generation(leaf, dev_item))
5136 return -EINVAL;
5137 }
5138
5139 fill_device_from_item(leaf, dev_item, device);
5140 device->dev_root = root->fs_info->dev_root;
5141 device->in_fs_metadata = 1;
5142 if (device->writeable && !device->is_tgtdev_for_dev_replace) {
5143 device->fs_devices->total_rw_bytes += device->total_bytes;
5144 spin_lock(&root->fs_info->free_chunk_lock);
5145 root->fs_info->free_chunk_space += device->total_bytes -
5146 device->bytes_used;
5147 spin_unlock(&root->fs_info->free_chunk_lock);
5148 }
5149 ret = 0;
5150 return ret;
5151 }
5152
5153 int btrfs_read_sys_array(struct btrfs_root *root)
5154 {
5155 struct btrfs_super_block *super_copy = root->fs_info->super_copy;
5156 struct extent_buffer *sb;
5157 struct btrfs_disk_key *disk_key;
5158 struct btrfs_chunk *chunk;
5159 u8 *ptr;
5160 unsigned long sb_ptr;
5161 int ret = 0;
5162 u32 num_stripes;
5163 u32 array_size;
5164 u32 len = 0;
5165 u32 cur;
5166 struct btrfs_key key;
5167
5168 sb = btrfs_find_create_tree_block(root, BTRFS_SUPER_INFO_OFFSET,
5169 BTRFS_SUPER_INFO_SIZE);
5170 if (!sb)
5171 return -ENOMEM;
5172 btrfs_set_buffer_uptodate(sb);
5173 btrfs_set_buffer_lockdep_class(root->root_key.objectid, sb, 0);
5174 /*
5175 * The sb extent buffer is artifical and just used to read the system array.
5176 * btrfs_set_buffer_uptodate() call does not properly mark all it's
5177 * pages up-to-date when the page is larger: extent does not cover the
5178 * whole page and consequently check_page_uptodate does not find all
5179 * the page's extents up-to-date (the hole beyond sb),
5180 * write_extent_buffer then triggers a WARN_ON.
5181 *
5182 * Regular short extents go through mark_extent_buffer_dirty/writeback cycle,
5183 * but sb spans only this function. Add an explicit SetPageUptodate call
5184 * to silence the warning eg. on PowerPC 64.
5185 */
5186 if (PAGE_CACHE_SIZE > BTRFS_SUPER_INFO_SIZE)
5187 SetPageUptodate(sb->pages[0]);
5188
5189 write_extent_buffer(sb, super_copy, 0, BTRFS_SUPER_INFO_SIZE);
5190 array_size = btrfs_super_sys_array_size(super_copy);
5191
5192 ptr = super_copy->sys_chunk_array;
5193 sb_ptr = offsetof(struct btrfs_super_block, sys_chunk_array);
5194 cur = 0;
5195
5196 while (cur < array_size) {
5197 disk_key = (struct btrfs_disk_key *)ptr;
5198 btrfs_disk_key_to_cpu(&key, disk_key);
5199
5200 len = sizeof(*disk_key); ptr += len;
5201 sb_ptr += len;
5202 cur += len;
5203
5204 if (key.type == BTRFS_CHUNK_ITEM_KEY) {
5205 chunk = (struct btrfs_chunk *)sb_ptr;
5206 ret = read_one_chunk(root, &key, sb, chunk);
5207 if (ret)
5208 break;
5209 num_stripes = btrfs_chunk_num_stripes(sb, chunk);
5210 len = btrfs_chunk_item_size(num_stripes);
5211 } else {
5212 ret = -EIO;
5213 break;
5214 }
5215 ptr += len;
5216 sb_ptr += len;
5217 cur += len;
5218 }
5219 free_extent_buffer(sb);
5220 return ret;
5221 }
5222
5223 int btrfs_read_chunk_tree(struct btrfs_root *root)
5224 {
5225 struct btrfs_path *path;
5226 struct extent_buffer *leaf;
5227 struct btrfs_key key;
5228 struct btrfs_key found_key;
5229 int ret;
5230 int slot;
5231
5232 root = root->fs_info->chunk_root;
5233
5234 path = btrfs_alloc_path();
5235 if (!path)
5236 return -ENOMEM;
5237
5238 mutex_lock(&uuid_mutex);
5239 lock_chunks(root);
5240
5241 /* first we search for all of the device items, and then we
5242 * read in all of the chunk items. This way we can create chunk
5243 * mappings that reference all of the devices that are afound
5244 */
5245 key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
5246 key.offset = 0;
5247 key.type = 0;
5248 again:
5249 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5250 if (ret < 0)
5251 goto error;
5252 while (1) {
5253 leaf = path->nodes[0];
5254 slot = path->slots[0];
5255 if (slot >= btrfs_header_nritems(leaf)) {
5256 ret = btrfs_next_leaf(root, path);
5257 if (ret == 0)
5258 continue;
5259 if (ret < 0)
5260 goto error;
5261 break;
5262 }
5263 btrfs_item_key_to_cpu(leaf, &found_key, slot);
5264 if (key.objectid == BTRFS_DEV_ITEMS_OBJECTID) {
5265 if (found_key.objectid != BTRFS_DEV_ITEMS_OBJECTID)
5266 break;
5267 if (found_key.type == BTRFS_DEV_ITEM_KEY) {
5268 struct btrfs_dev_item *dev_item;
5269 dev_item = btrfs_item_ptr(leaf, slot,
5270 struct btrfs_dev_item);
5271 ret = read_one_dev(root, leaf, dev_item);
5272 if (ret)
5273 goto error;
5274 }
5275 } else if (found_key.type == BTRFS_CHUNK_ITEM_KEY) {
5276 struct btrfs_chunk *chunk;
5277 chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);
5278 ret = read_one_chunk(root, &found_key, leaf, chunk);
5279 if (ret)
5280 goto error;
5281 }
5282 path->slots[0]++;
5283 }
5284 if (key.objectid == BTRFS_DEV_ITEMS_OBJECTID) {
5285 key.objectid = 0;
5286 btrfs_release_path(path);
5287 goto again;
5288 }
5289 ret = 0;
5290 error:
5291 unlock_chunks(root);
5292 mutex_unlock(&uuid_mutex);
5293
5294 btrfs_free_path(path);
5295 return ret;
5296 }
5297
5298 static void __btrfs_reset_dev_stats(struct btrfs_device *dev)
5299 {
5300 int i;
5301
5302 for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++)
5303 btrfs_dev_stat_reset(dev, i);
5304 }
5305
5306 int btrfs_init_dev_stats(struct btrfs_fs_info *fs_info)
5307 {
5308 struct btrfs_key key;
5309 struct btrfs_key found_key;
5310 struct btrfs_root *dev_root = fs_info->dev_root;
5311 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
5312 struct extent_buffer *eb;
5313 int slot;
5314 int ret = 0;
5315 struct btrfs_device *device;
5316 struct btrfs_path *path = NULL;
5317 int i;
5318
5319 path = btrfs_alloc_path();
5320 if (!path) {
5321 ret = -ENOMEM;
5322 goto out;
5323 }
5324
5325 mutex_lock(&fs_devices->device_list_mutex);
5326 list_for_each_entry(device, &fs_devices->devices, dev_list) {
5327 int item_size;
5328 struct btrfs_dev_stats_item *ptr;
5329
5330 key.objectid = 0;
5331 key.type = BTRFS_DEV_STATS_KEY;
5332 key.offset = device->devid;
5333 ret = btrfs_search_slot(NULL, dev_root, &key, path, 0, 0);
5334 if (ret) {
5335 __btrfs_reset_dev_stats(device);
5336 device->dev_stats_valid = 1;
5337 btrfs_release_path(path);
5338 continue;
5339 }
5340 slot = path->slots[0];
5341 eb = path->nodes[0];
5342 btrfs_item_key_to_cpu(eb, &found_key, slot);
5343 item_size = btrfs_item_size_nr(eb, slot);
5344
5345 ptr = btrfs_item_ptr(eb, slot,
5346 struct btrfs_dev_stats_item);
5347
5348 for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++) {
5349 if (item_size >= (1 + i) * sizeof(__le64))
5350 btrfs_dev_stat_set(device, i,
5351 btrfs_dev_stats_value(eb, ptr, i));
5352 else
5353 btrfs_dev_stat_reset(device, i);
5354 }
5355
5356 device->dev_stats_valid = 1;
5357 btrfs_dev_stat_print_on_load(device);
5358 btrfs_release_path(path);
5359 }
5360 mutex_unlock(&fs_devices->device_list_mutex);
5361
5362 out:
5363 btrfs_free_path(path);
5364 return ret < 0 ? ret : 0;
5365 }
5366
5367 static int update_dev_stat_item(struct btrfs_trans_handle *trans,
5368 struct btrfs_root *dev_root,
5369 struct btrfs_device *device)
5370 {
5371 struct btrfs_path *path;
5372 struct btrfs_key key;
5373 struct extent_buffer *eb;
5374 struct btrfs_dev_stats_item *ptr;
5375 int ret;
5376 int i;
5377
5378 key.objectid = 0;
5379 key.type = BTRFS_DEV_STATS_KEY;
5380 key.offset = device->devid;
5381
5382 path = btrfs_alloc_path();
5383 BUG_ON(!path);
5384 ret = btrfs_search_slot(trans, dev_root, &key, path, -1, 1);
5385 if (ret < 0) {
5386 printk_in_rcu(KERN_WARNING "btrfs: error %d while searching for dev_stats item for device %s!\n",
5387 ret, rcu_str_deref(device->name));
5388 goto out;
5389 }
5390
5391 if (ret == 0 &&
5392 btrfs_item_size_nr(path->nodes[0], path->slots[0]) < sizeof(*ptr)) {
5393 /* need to delete old one and insert a new one */
5394 ret = btrfs_del_item(trans, dev_root, path);
5395 if (ret != 0) {
5396 printk_in_rcu(KERN_WARNING "btrfs: delete too small dev_stats item for device %s failed %d!\n",
5397 rcu_str_deref(device->name), ret);
5398 goto out;
5399 }
5400 ret = 1;
5401 }
5402
5403 if (ret == 1) {
5404 /* need to insert a new item */
5405 btrfs_release_path(path);
5406 ret = btrfs_insert_empty_item(trans, dev_root, path,
5407 &key, sizeof(*ptr));
5408 if (ret < 0) {
5409 printk_in_rcu(KERN_WARNING "btrfs: insert dev_stats item for device %s failed %d!\n",
5410 rcu_str_deref(device->name), ret);
5411 goto out;
5412 }
5413 }
5414
5415 eb = path->nodes[0];
5416 ptr = btrfs_item_ptr(eb, path->slots[0], struct btrfs_dev_stats_item);
5417 for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++)
5418 btrfs_set_dev_stats_value(eb, ptr, i,
5419 btrfs_dev_stat_read(device, i));
5420 btrfs_mark_buffer_dirty(eb);
5421
5422 out:
5423 btrfs_free_path(path);
5424 return ret;
5425 }
5426
5427 /*
5428 * called from commit_transaction. Writes all changed device stats to disk.
5429 */
5430 int btrfs_run_dev_stats(struct btrfs_trans_handle *trans,
5431 struct btrfs_fs_info *fs_info)
5432 {
5433 struct btrfs_root *dev_root = fs_info->dev_root;
5434 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
5435 struct btrfs_device *device;
5436 int ret = 0;
5437
5438 mutex_lock(&fs_devices->device_list_mutex);
5439 list_for_each_entry(device, &fs_devices->devices, dev_list) {
5440 if (!device->dev_stats_valid || !device->dev_stats_dirty)
5441 continue;
5442
5443 ret = update_dev_stat_item(trans, dev_root, device);
5444 if (!ret)
5445 device->dev_stats_dirty = 0;
5446 }
5447 mutex_unlock(&fs_devices->device_list_mutex);
5448
5449 return ret;
5450 }
5451
5452 void btrfs_dev_stat_inc_and_print(struct btrfs_device *dev, int index)
5453 {
5454 btrfs_dev_stat_inc(dev, index);
5455 btrfs_dev_stat_print_on_error(dev);
5456 }
5457
5458 void btrfs_dev_stat_print_on_error(struct btrfs_device *dev)
5459 {
5460 if (!dev->dev_stats_valid)
5461 return;
5462 printk_ratelimited_in_rcu(KERN_ERR
5463 "btrfs: bdev %s errs: wr %u, rd %u, flush %u, corrupt %u, gen %u\n",
5464 rcu_str_deref(dev->name),
5465 btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_WRITE_ERRS),
5466 btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_READ_ERRS),
5467 btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_FLUSH_ERRS),
5468 btrfs_dev_stat_read(dev,
5469 BTRFS_DEV_STAT_CORRUPTION_ERRS),
5470 btrfs_dev_stat_read(dev,
5471 BTRFS_DEV_STAT_GENERATION_ERRS));
5472 }
5473
5474 static void btrfs_dev_stat_print_on_load(struct btrfs_device *dev)
5475 {
5476 int i;
5477
5478 for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++)
5479 if (btrfs_dev_stat_read(dev, i) != 0)
5480 break;
5481 if (i == BTRFS_DEV_STAT_VALUES_MAX)
5482 return; /* all values == 0, suppress message */
5483
5484 printk_in_rcu(KERN_INFO "btrfs: bdev %s errs: wr %u, rd %u, flush %u, corrupt %u, gen %u\n",
5485 rcu_str_deref(dev->name),
5486 btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_WRITE_ERRS),
5487 btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_READ_ERRS),
5488 btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_FLUSH_ERRS),
5489 btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_CORRUPTION_ERRS),
5490 btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_GENERATION_ERRS));
5491 }
5492
5493 int btrfs_get_dev_stats(struct btrfs_root *root,
5494 struct btrfs_ioctl_get_dev_stats *stats)
5495 {
5496 struct btrfs_device *dev;
5497 struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
5498 int i;
5499
5500 mutex_lock(&fs_devices->device_list_mutex);
5501 dev = btrfs_find_device(root->fs_info, stats->devid, NULL, NULL);
5502 mutex_unlock(&fs_devices->device_list_mutex);
5503
5504 if (!dev) {
5505 printk(KERN_WARNING
5506 "btrfs: get dev_stats failed, device not found\n");
5507 return -ENODEV;
5508 } else if (!dev->dev_stats_valid) {
5509 printk(KERN_WARNING
5510 "btrfs: get dev_stats failed, not yet valid\n");
5511 return -ENODEV;
5512 } else if (stats->flags & BTRFS_DEV_STATS_RESET) {
5513 for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++) {
5514 if (stats->nr_items > i)
5515 stats->values[i] =
5516 btrfs_dev_stat_read_and_reset(dev, i);
5517 else
5518 btrfs_dev_stat_reset(dev, i);
5519 }
5520 } else {
5521 for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++)
5522 if (stats->nr_items > i)
5523 stats->values[i] = btrfs_dev_stat_read(dev, i);
5524 }
5525 if (stats->nr_items > BTRFS_DEV_STAT_VALUES_MAX)
5526 stats->nr_items = BTRFS_DEV_STAT_VALUES_MAX;
5527 return 0;
5528 }
5529
5530 int btrfs_scratch_superblock(struct btrfs_device *device)
5531 {
5532 struct buffer_head *bh;
5533 struct btrfs_super_block *disk_super;
5534
5535 bh = btrfs_read_dev_super(device->bdev);
5536 if (!bh)
5537 return -EINVAL;
5538 disk_super = (struct btrfs_super_block *)bh->b_data;
5539
5540 memset(&disk_super->magic, 0, sizeof(disk_super->magic));
5541 set_buffer_dirty(bh);
5542 sync_dirty_buffer(bh);
5543 brelse(bh);
5544
5545 return 0;
5546 }
Linux kernel - Deliverables
This page took 0.22599 seconds and 5 git commands to generate.