Root/fs/btrfs/super.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
19#include <linux/blkdev.h>
20#include <linux/module.h>
21#include <linux/buffer_head.h>
22#include <linux/fs.h>
23#include <linux/pagemap.h>
24#include <linux/highmem.h>
25#include <linux/time.h>
26#include <linux/init.h>
27#include <linux/seq_file.h>
28#include <linux/string.h>
29#include <linux/backing-dev.h>
30#include <linux/mount.h>
31#include <linux/mpage.h>
32#include <linux/swap.h>
33#include <linux/writeback.h>
34#include <linux/statfs.h>
35#include <linux/compat.h>
36#include <linux/parser.h>
37#include <linux/ctype.h>
38#include <linux/namei.h>
39#include <linux/miscdevice.h>
40#include <linux/magic.h>
41#include <linux/slab.h>
42#include "compat.h"
43#include "ctree.h"
44#include "disk-io.h"
45#include "transaction.h"
46#include "btrfs_inode.h"
47#include "ioctl.h"
48#include "print-tree.h"
49#include "xattr.h"
50#include "volumes.h"
51#include "version.h"
52#include "export.h"
53#include "compression.h"
54
55static const struct super_operations btrfs_super_ops;
56
57static void btrfs_put_super(struct super_block *sb)
58{
59    struct btrfs_root *root = btrfs_sb(sb);
60    int ret;
61
62    ret = close_ctree(root);
63    sb->s_fs_info = NULL;
64}
65
66enum {
67    Opt_degraded, Opt_subvol, Opt_subvolid, Opt_device, Opt_nodatasum,
68    Opt_nodatacow, Opt_max_inline, Opt_alloc_start, Opt_nobarrier, Opt_ssd,
69    Opt_nossd, Opt_ssd_spread, Opt_thread_pool, Opt_noacl, Opt_compress,
70    Opt_compress_force, Opt_notreelog, Opt_ratio, Opt_flushoncommit,
71    Opt_discard, Opt_err,
72};
73
74static match_table_t tokens = {
75    {Opt_degraded, "degraded"},
76    {Opt_subvol, "subvol=%s"},
77    {Opt_subvolid, "subvolid=%d"},
78    {Opt_device, "device=%s"},
79    {Opt_nodatasum, "nodatasum"},
80    {Opt_nodatacow, "nodatacow"},
81    {Opt_nobarrier, "nobarrier"},
82    {Opt_max_inline, "max_inline=%s"},
83    {Opt_alloc_start, "alloc_start=%s"},
84    {Opt_thread_pool, "thread_pool=%d"},
85    {Opt_compress, "compress"},
86    {Opt_compress_force, "compress-force"},
87    {Opt_ssd, "ssd"},
88    {Opt_ssd_spread, "ssd_spread"},
89    {Opt_nossd, "nossd"},
90    {Opt_noacl, "noacl"},
91    {Opt_notreelog, "notreelog"},
92    {Opt_flushoncommit, "flushoncommit"},
93    {Opt_ratio, "metadata_ratio=%d"},
94    {Opt_discard, "discard"},
95    {Opt_err, NULL},
96};
97
98/*
99 * Regular mount options parser. Everything that is needed only when
100 * reading in a new superblock is parsed here.
101 */
102int btrfs_parse_options(struct btrfs_root *root, char *options)
103{
104    struct btrfs_fs_info *info = root->fs_info;
105    substring_t args[MAX_OPT_ARGS];
106    char *p, *num, *orig;
107    int intarg;
108    int ret = 0;
109
110    if (!options)
111        return 0;
112
113    /*
114     * strsep changes the string, duplicate it because parse_options
115     * gets called twice
116     */
117    options = kstrdup(options, GFP_NOFS);
118    if (!options)
119        return -ENOMEM;
120
121    orig = options;
122
123    while ((p = strsep(&options, ",")) != NULL) {
124        int token;
125        if (!*p)
126            continue;
127
128        token = match_token(p, tokens, args);
129        switch (token) {
130        case Opt_degraded:
131            printk(KERN_INFO "btrfs: allowing degraded mounts\n");
132            btrfs_set_opt(info->mount_opt, DEGRADED);
133            break;
134        case Opt_subvol:
135        case Opt_subvolid:
136        case Opt_device:
137            /*
138             * These are parsed by btrfs_parse_early_options
139             * and can be happily ignored here.
140             */
141            break;
142        case Opt_nodatasum:
143            printk(KERN_INFO "btrfs: setting nodatasum\n");
144            btrfs_set_opt(info->mount_opt, NODATASUM);
145            break;
146        case Opt_nodatacow:
147            printk(KERN_INFO "btrfs: setting nodatacow\n");
148            btrfs_set_opt(info->mount_opt, NODATACOW);
149            btrfs_set_opt(info->mount_opt, NODATASUM);
150            break;
151        case Opt_compress:
152            printk(KERN_INFO "btrfs: use compression\n");
153            btrfs_set_opt(info->mount_opt, COMPRESS);
154            break;
155        case Opt_compress_force:
156            printk(KERN_INFO "btrfs: forcing compression\n");
157            btrfs_set_opt(info->mount_opt, FORCE_COMPRESS);
158            btrfs_set_opt(info->mount_opt, COMPRESS);
159            break;
160        case Opt_ssd:
161            printk(KERN_INFO "btrfs: use ssd allocation scheme\n");
162            btrfs_set_opt(info->mount_opt, SSD);
163            break;
164        case Opt_ssd_spread:
165            printk(KERN_INFO "btrfs: use spread ssd "
166                   "allocation scheme\n");
167            btrfs_set_opt(info->mount_opt, SSD);
168            btrfs_set_opt(info->mount_opt, SSD_SPREAD);
169            break;
170        case Opt_nossd:
171            printk(KERN_INFO "btrfs: not using ssd allocation "
172                   "scheme\n");
173            btrfs_set_opt(info->mount_opt, NOSSD);
174            btrfs_clear_opt(info->mount_opt, SSD);
175            btrfs_clear_opt(info->mount_opt, SSD_SPREAD);
176            break;
177        case Opt_nobarrier:
178            printk(KERN_INFO "btrfs: turning off barriers\n");
179            btrfs_set_opt(info->mount_opt, NOBARRIER);
180            break;
181        case Opt_thread_pool:
182            intarg = 0;
183            match_int(&args[0], &intarg);
184            if (intarg) {
185                info->thread_pool_size = intarg;
186                printk(KERN_INFO "btrfs: thread pool %d\n",
187                       info->thread_pool_size);
188            }
189            break;
190        case Opt_max_inline:
191            num = match_strdup(&args[0]);
192            if (num) {
193                info->max_inline = memparse(num, NULL);
194                kfree(num);
195
196                if (info->max_inline) {
197                    info->max_inline = max_t(u64,
198                        info->max_inline,
199                        root->sectorsize);
200                }
201                printk(KERN_INFO "btrfs: max_inline at %llu\n",
202                    (unsigned long long)info->max_inline);
203            }
204            break;
205        case Opt_alloc_start:
206            num = match_strdup(&args[0]);
207            if (num) {
208                info->alloc_start = memparse(num, NULL);
209                kfree(num);
210                printk(KERN_INFO
211                    "btrfs: allocations start at %llu\n",
212                    (unsigned long long)info->alloc_start);
213            }
214            break;
215        case Opt_noacl:
216            root->fs_info->sb->s_flags &= ~MS_POSIXACL;
217            break;
218        case Opt_notreelog:
219            printk(KERN_INFO "btrfs: disabling tree log\n");
220            btrfs_set_opt(info->mount_opt, NOTREELOG);
221            break;
222        case Opt_flushoncommit:
223            printk(KERN_INFO "btrfs: turning on flush-on-commit\n");
224            btrfs_set_opt(info->mount_opt, FLUSHONCOMMIT);
225            break;
226        case Opt_ratio:
227            intarg = 0;
228            match_int(&args[0], &intarg);
229            if (intarg) {
230                info->metadata_ratio = intarg;
231                printk(KERN_INFO "btrfs: metadata ratio %d\n",
232                       info->metadata_ratio);
233            }
234            break;
235        case Opt_discard:
236            btrfs_set_opt(info->mount_opt, DISCARD);
237            break;
238        case Opt_err:
239            printk(KERN_INFO "btrfs: unrecognized mount option "
240                   "'%s'\n", p);
241            ret = -EINVAL;
242            goto out;
243        default:
244            break;
245        }
246    }
247out:
248    kfree(orig);
249    return ret;
250}
251
252/*
253 * Parse mount options that are required early in the mount process.
254 *
255 * All other options will be parsed on much later in the mount process and
256 * only when we need to allocate a new super block.
257 */
258static int btrfs_parse_early_options(const char *options, fmode_t flags,
259        void *holder, char **subvol_name, u64 *subvol_objectid,
260        struct btrfs_fs_devices **fs_devices)
261{
262    substring_t args[MAX_OPT_ARGS];
263    char *opts, *p;
264    int error = 0;
265    int intarg;
266
267    if (!options)
268        goto out;
269
270    /*
271     * strsep changes the string, duplicate it because parse_options
272     * gets called twice
273     */
274    opts = kstrdup(options, GFP_KERNEL);
275    if (!opts)
276        return -ENOMEM;
277
278    while ((p = strsep(&opts, ",")) != NULL) {
279        int token;
280        if (!*p)
281            continue;
282
283        token = match_token(p, tokens, args);
284        switch (token) {
285        case Opt_subvol:
286            *subvol_name = match_strdup(&args[0]);
287            break;
288        case Opt_subvolid:
289            intarg = 0;
290            error = match_int(&args[0], &intarg);
291            if (!error) {
292                /* we want the original fs_tree */
293                if (!intarg)
294                    *subvol_objectid =
295                        BTRFS_FS_TREE_OBJECTID;
296                else
297                    *subvol_objectid = intarg;
298            }
299            break;
300        case Opt_device:
301            error = btrfs_scan_one_device(match_strdup(&args[0]),
302                    flags, holder, fs_devices);
303            if (error)
304                goto out_free_opts;
305            break;
306        default:
307            break;
308        }
309    }
310
311 out_free_opts:
312    kfree(opts);
313 out:
314    /*
315     * If no subvolume name is specified we use the default one. Allocate
316     * a copy of the string "." here so that code later in the
317     * mount path doesn't care if it's the default volume or another one.
318     */
319    if (!*subvol_name) {
320        *subvol_name = kstrdup(".", GFP_KERNEL);
321        if (!*subvol_name)
322            return -ENOMEM;
323    }
324    return error;
325}
326
327static struct dentry *get_default_root(struct super_block *sb,
328                       u64 subvol_objectid)
329{
330    struct btrfs_root *root = sb->s_fs_info;
331    struct btrfs_root *new_root;
332    struct btrfs_dir_item *di;
333    struct btrfs_path *path;
334    struct btrfs_key location;
335    struct inode *inode;
336    struct dentry *dentry;
337    u64 dir_id;
338    int new = 0;
339
340    /*
341     * We have a specific subvol we want to mount, just setup location and
342     * go look up the root.
343     */
344    if (subvol_objectid) {
345        location.objectid = subvol_objectid;
346        location.type = BTRFS_ROOT_ITEM_KEY;
347        location.offset = (u64)-1;
348        goto find_root;
349    }
350
351    path = btrfs_alloc_path();
352    if (!path)
353        return ERR_PTR(-ENOMEM);
354    path->leave_spinning = 1;
355
356    /*
357     * Find the "default" dir item which points to the root item that we
358     * will mount by default if we haven't been given a specific subvolume
359     * to mount.
360     */
361    dir_id = btrfs_super_root_dir(&root->fs_info->super_copy);
362    di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);
363    if (!di) {
364        /*
365         * Ok the default dir item isn't there. This is weird since
366         * it's always been there, but don't freak out, just try and
367         * mount to root most subvolume.
368         */
369        btrfs_free_path(path);
370        dir_id = BTRFS_FIRST_FREE_OBJECTID;
371        new_root = root->fs_info->fs_root;
372        goto setup_root;
373    }
374
375    btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
376    btrfs_free_path(path);
377
378find_root:
379    new_root = btrfs_read_fs_root_no_name(root->fs_info, &location);
380    if (IS_ERR(new_root))
381        return ERR_PTR(PTR_ERR(new_root));
382
383    if (btrfs_root_refs(&new_root->root_item) == 0)
384        return ERR_PTR(-ENOENT);
385
386    dir_id = btrfs_root_dirid(&new_root->root_item);
387setup_root:
388    location.objectid = dir_id;
389    location.type = BTRFS_INODE_ITEM_KEY;
390    location.offset = 0;
391
392    inode = btrfs_iget(sb, &location, new_root, &new);
393    if (!inode)
394        return ERR_PTR(-ENOMEM);
395
396    /*
397     * If we're just mounting the root most subvol put the inode and return
398     * a reference to the dentry. We will have already gotten a reference
399     * to the inode in btrfs_fill_super so we're good to go.
400     */
401    if (!new && sb->s_root->d_inode == inode) {
402        iput(inode);
403        return dget(sb->s_root);
404    }
405
406    if (new) {
407        const struct qstr name = { .name = "/", .len = 1 };
408
409        /*
410         * New inode, we need to make the dentry a sibling of s_root so
411         * everything gets cleaned up properly on unmount.
412         */
413        dentry = d_alloc(sb->s_root, &name);
414        if (!dentry) {
415            iput(inode);
416            return ERR_PTR(-ENOMEM);
417        }
418        d_splice_alias(inode, dentry);
419    } else {
420        /*
421         * We found the inode in cache, just find a dentry for it and
422         * put the reference to the inode we just got.
423         */
424        dentry = d_find_alias(inode);
425        iput(inode);
426    }
427
428    return dentry;
429}
430
431static int btrfs_fill_super(struct super_block *sb,
432                struct btrfs_fs_devices *fs_devices,
433                void *data, int silent)
434{
435    struct inode *inode;
436    struct dentry *root_dentry;
437    struct btrfs_super_block *disk_super;
438    struct btrfs_root *tree_root;
439    struct btrfs_key key;
440    int err;
441
442    sb->s_maxbytes = MAX_LFS_FILESIZE;
443    sb->s_magic = BTRFS_SUPER_MAGIC;
444    sb->s_op = &btrfs_super_ops;
445    sb->s_export_op = &btrfs_export_ops;
446    sb->s_xattr = btrfs_xattr_handlers;
447    sb->s_time_gran = 1;
448#ifdef CONFIG_BTRFS_FS_POSIX_ACL
449    sb->s_flags |= MS_POSIXACL;
450#endif
451
452    tree_root = open_ctree(sb, fs_devices, (char *)data);
453
454    if (IS_ERR(tree_root)) {
455        printk("btrfs: open_ctree failed\n");
456        return PTR_ERR(tree_root);
457    }
458    sb->s_fs_info = tree_root;
459    disk_super = &tree_root->fs_info->super_copy;
460
461    key.objectid = BTRFS_FIRST_FREE_OBJECTID;
462    key.type = BTRFS_INODE_ITEM_KEY;
463    key.offset = 0;
464    inode = btrfs_iget(sb, &key, tree_root->fs_info->fs_root, NULL);
465    if (IS_ERR(inode)) {
466        err = PTR_ERR(inode);
467        goto fail_close;
468    }
469
470    root_dentry = d_alloc_root(inode);
471    if (!root_dentry) {
472        iput(inode);
473        err = -ENOMEM;
474        goto fail_close;
475    }
476
477    sb->s_root = root_dentry;
478
479    save_mount_options(sb, data);
480    return 0;
481
482fail_close:
483    close_ctree(tree_root);
484    return err;
485}
486
487int btrfs_sync_fs(struct super_block *sb, int wait)
488{
489    struct btrfs_trans_handle *trans;
490    struct btrfs_root *root = btrfs_sb(sb);
491    int ret;
492
493    if (!wait) {
494        filemap_flush(root->fs_info->btree_inode->i_mapping);
495        return 0;
496    }
497
498    btrfs_start_delalloc_inodes(root, 0);
499    btrfs_wait_ordered_extents(root, 0, 0);
500
501    trans = btrfs_start_transaction(root, 1);
502    ret = btrfs_commit_transaction(trans, root);
503    return ret;
504}
505
506static int btrfs_show_options(struct seq_file *seq, struct vfsmount *vfs)
507{
508    struct btrfs_root *root = btrfs_sb(vfs->mnt_sb);
509    struct btrfs_fs_info *info = root->fs_info;
510
511    if (btrfs_test_opt(root, DEGRADED))
512        seq_puts(seq, ",degraded");
513    if (btrfs_test_opt(root, NODATASUM))
514        seq_puts(seq, ",nodatasum");
515    if (btrfs_test_opt(root, NODATACOW))
516        seq_puts(seq, ",nodatacow");
517    if (btrfs_test_opt(root, NOBARRIER))
518        seq_puts(seq, ",nobarrier");
519    if (info->max_inline != 8192 * 1024)
520        seq_printf(seq, ",max_inline=%llu",
521               (unsigned long long)info->max_inline);
522    if (info->alloc_start != 0)
523        seq_printf(seq, ",alloc_start=%llu",
524               (unsigned long long)info->alloc_start);
525    if (info->thread_pool_size != min_t(unsigned long,
526                         num_online_cpus() + 2, 8))
527        seq_printf(seq, ",thread_pool=%d", info->thread_pool_size);
528    if (btrfs_test_opt(root, COMPRESS))
529        seq_puts(seq, ",compress");
530    if (btrfs_test_opt(root, NOSSD))
531        seq_puts(seq, ",nossd");
532    if (btrfs_test_opt(root, SSD_SPREAD))
533        seq_puts(seq, ",ssd_spread");
534    else if (btrfs_test_opt(root, SSD))
535        seq_puts(seq, ",ssd");
536    if (btrfs_test_opt(root, NOTREELOG))
537        seq_puts(seq, ",notreelog");
538    if (btrfs_test_opt(root, FLUSHONCOMMIT))
539        seq_puts(seq, ",flushoncommit");
540    if (btrfs_test_opt(root, DISCARD))
541        seq_puts(seq, ",discard");
542    if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
543        seq_puts(seq, ",noacl");
544    return 0;
545}
546
547static int btrfs_test_super(struct super_block *s, void *data)
548{
549    struct btrfs_fs_devices *test_fs_devices = data;
550    struct btrfs_root *root = btrfs_sb(s);
551
552    return root->fs_info->fs_devices == test_fs_devices;
553}
554
555/*
556 * Find a superblock for the given device / mount point.
557 *
558 * Note: This is based on get_sb_bdev from fs/super.c with a few additions
559 * for multiple device setup. Make sure to keep it in sync.
560 */
561static int btrfs_get_sb(struct file_system_type *fs_type, int flags,
562        const char *dev_name, void *data, struct vfsmount *mnt)
563{
564    struct block_device *bdev = NULL;
565    struct super_block *s;
566    struct dentry *root;
567    struct btrfs_fs_devices *fs_devices = NULL;
568    fmode_t mode = FMODE_READ;
569    char *subvol_name = NULL;
570    u64 subvol_objectid = 0;
571    int error = 0;
572    int found = 0;
573
574    if (!(flags & MS_RDONLY))
575        mode |= FMODE_WRITE;
576
577    error = btrfs_parse_early_options(data, mode, fs_type,
578                      &subvol_name, &subvol_objectid,
579                      &fs_devices);
580    if (error)
581        return error;
582
583    error = btrfs_scan_one_device(dev_name, mode, fs_type, &fs_devices);
584    if (error)
585        goto error_free_subvol_name;
586
587    error = btrfs_open_devices(fs_devices, mode, fs_type);
588    if (error)
589        goto error_free_subvol_name;
590
591    if (!(flags & MS_RDONLY) && fs_devices->rw_devices == 0) {
592        error = -EACCES;
593        goto error_close_devices;
594    }
595
596    bdev = fs_devices->latest_bdev;
597    s = sget(fs_type, btrfs_test_super, set_anon_super, fs_devices);
598    if (IS_ERR(s))
599        goto error_s;
600
601    if (s->s_root) {
602        if ((flags ^ s->s_flags) & MS_RDONLY) {
603            deactivate_locked_super(s);
604            error = -EBUSY;
605            goto error_close_devices;
606        }
607
608        found = 1;
609        btrfs_close_devices(fs_devices);
610    } else {
611        char b[BDEVNAME_SIZE];
612
613        s->s_flags = flags;
614        strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
615        error = btrfs_fill_super(s, fs_devices, data,
616                     flags & MS_SILENT ? 1 : 0);
617        if (error) {
618            deactivate_locked_super(s);
619            goto error_free_subvol_name;
620        }
621
622        btrfs_sb(s)->fs_info->bdev_holder = fs_type;
623        s->s_flags |= MS_ACTIVE;
624    }
625
626    root = get_default_root(s, subvol_objectid);
627    if (IS_ERR(root)) {
628        error = PTR_ERR(root);
629        deactivate_locked_super(s);
630        goto error;
631    }
632    /* if they gave us a subvolume name bind mount into that */
633    if (strcmp(subvol_name, ".")) {
634        struct dentry *new_root;
635        mutex_lock(&root->d_inode->i_mutex);
636        new_root = lookup_one_len(subvol_name, root,
637                      strlen(subvol_name));
638        mutex_unlock(&root->d_inode->i_mutex);
639
640        if (IS_ERR(new_root)) {
641            deactivate_locked_super(s);
642            error = PTR_ERR(new_root);
643            dput(root);
644            goto error_close_devices;
645        }
646        if (!new_root->d_inode) {
647            dput(root);
648            dput(new_root);
649            deactivate_locked_super(s);
650            error = -ENXIO;
651            goto error_close_devices;
652        }
653        dput(root);
654        root = new_root;
655    }
656
657    mnt->mnt_sb = s;
658    mnt->mnt_root = root;
659
660    kfree(subvol_name);
661    return 0;
662
663error_s:
664    error = PTR_ERR(s);
665error_close_devices:
666    btrfs_close_devices(fs_devices);
667error_free_subvol_name:
668    kfree(subvol_name);
669error:
670    return error;
671}
672
673static int btrfs_remount(struct super_block *sb, int *flags, char *data)
674{
675    struct btrfs_root *root = btrfs_sb(sb);
676    int ret;
677
678    ret = btrfs_parse_options(root, data);
679    if (ret)
680        return -EINVAL;
681
682    if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
683        return 0;
684
685    if (*flags & MS_RDONLY) {
686        sb->s_flags |= MS_RDONLY;
687
688        ret = btrfs_commit_super(root);
689        WARN_ON(ret);
690    } else {
691        if (root->fs_info->fs_devices->rw_devices == 0)
692            return -EACCES;
693
694        if (btrfs_super_log_root(&root->fs_info->super_copy) != 0)
695            return -EINVAL;
696
697        /* recover relocation */
698        ret = btrfs_recover_relocation(root);
699        WARN_ON(ret);
700
701        ret = btrfs_cleanup_fs_roots(root->fs_info);
702        WARN_ON(ret);
703
704        sb->s_flags &= ~MS_RDONLY;
705    }
706
707    return 0;
708}
709
710static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
711{
712    struct btrfs_root *root = btrfs_sb(dentry->d_sb);
713    struct btrfs_super_block *disk_super = &root->fs_info->super_copy;
714    struct list_head *head = &root->fs_info->space_info;
715    struct btrfs_space_info *found;
716    u64 total_used = 0;
717    u64 data_used = 0;
718    int bits = dentry->d_sb->s_blocksize_bits;
719    __be32 *fsid = (__be32 *)root->fs_info->fsid;
720
721    rcu_read_lock();
722    list_for_each_entry_rcu(found, head, list) {
723        if (found->flags & (BTRFS_BLOCK_GROUP_DUP|
724                    BTRFS_BLOCK_GROUP_RAID10|
725                    BTRFS_BLOCK_GROUP_RAID1)) {
726            total_used += found->bytes_used;
727            if (found->flags & BTRFS_BLOCK_GROUP_DATA)
728                data_used += found->bytes_used;
729            else
730                data_used += found->total_bytes;
731        }
732
733        total_used += found->bytes_used;
734        if (found->flags & BTRFS_BLOCK_GROUP_DATA)
735            data_used += found->bytes_used;
736        else
737            data_used += found->total_bytes;
738    }
739    rcu_read_unlock();
740
741    buf->f_namelen = BTRFS_NAME_LEN;
742    buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
743    buf->f_bfree = buf->f_blocks - (total_used >> bits);
744    buf->f_bavail = buf->f_blocks - (data_used >> bits);
745    buf->f_bsize = dentry->d_sb->s_blocksize;
746    buf->f_type = BTRFS_SUPER_MAGIC;
747
748    /* We treat it as constant endianness (it doesn't matter _which_)
749       because we want the fsid to come out the same whether mounted
750       on a big-endian or little-endian host */
751    buf->f_fsid.val[0] = be32_to_cpu(fsid[0]) ^ be32_to_cpu(fsid[2]);
752    buf->f_fsid.val[1] = be32_to_cpu(fsid[1]) ^ be32_to_cpu(fsid[3]);
753    /* Mask in the root object ID too, to disambiguate subvols */
754    buf->f_fsid.val[0] ^= BTRFS_I(dentry->d_inode)->root->objectid >> 32;
755    buf->f_fsid.val[1] ^= BTRFS_I(dentry->d_inode)->root->objectid;
756
757    return 0;
758}
759
760static struct file_system_type btrfs_fs_type = {
761    .owner = THIS_MODULE,
762    .name = "btrfs",
763    .get_sb = btrfs_get_sb,
764    .kill_sb = kill_anon_super,
765    .fs_flags = FS_REQUIRES_DEV,
766};
767
768/*
769 * used by btrfsctl to scan devices when no FS is mounted
770 */
771static long btrfs_control_ioctl(struct file *file, unsigned int cmd,
772                unsigned long arg)
773{
774    struct btrfs_ioctl_vol_args *vol;
775    struct btrfs_fs_devices *fs_devices;
776    int ret = -ENOTTY;
777
778    if (!capable(CAP_SYS_ADMIN))
779        return -EPERM;
780
781    vol = memdup_user((void __user *)arg, sizeof(*vol));
782    if (IS_ERR(vol))
783        return PTR_ERR(vol);
784
785    switch (cmd) {
786    case BTRFS_IOC_SCAN_DEV:
787        ret = btrfs_scan_one_device(vol->name, FMODE_READ,
788                        &btrfs_fs_type, &fs_devices);
789        break;
790    }
791
792    kfree(vol);
793    return ret;
794}
795
796static int btrfs_freeze(struct super_block *sb)
797{
798    struct btrfs_root *root = btrfs_sb(sb);
799    mutex_lock(&root->fs_info->transaction_kthread_mutex);
800    mutex_lock(&root->fs_info->cleaner_mutex);
801    return 0;
802}
803
804static int btrfs_unfreeze(struct super_block *sb)
805{
806    struct btrfs_root *root = btrfs_sb(sb);
807    mutex_unlock(&root->fs_info->cleaner_mutex);
808    mutex_unlock(&root->fs_info->transaction_kthread_mutex);
809    return 0;
810}
811
812static const struct super_operations btrfs_super_ops = {
813    .drop_inode = btrfs_drop_inode,
814    .delete_inode = btrfs_delete_inode,
815    .put_super = btrfs_put_super,
816    .sync_fs = btrfs_sync_fs,
817    .show_options = btrfs_show_options,
818    .write_inode = btrfs_write_inode,
819    .dirty_inode = btrfs_dirty_inode,
820    .alloc_inode = btrfs_alloc_inode,
821    .destroy_inode = btrfs_destroy_inode,
822    .statfs = btrfs_statfs,
823    .remount_fs = btrfs_remount,
824    .freeze_fs = btrfs_freeze,
825    .unfreeze_fs = btrfs_unfreeze,
826};
827
828static const struct file_operations btrfs_ctl_fops = {
829    .unlocked_ioctl = btrfs_control_ioctl,
830    .compat_ioctl = btrfs_control_ioctl,
831    .owner = THIS_MODULE,
832};
833
834static struct miscdevice btrfs_misc = {
835    .minor = MISC_DYNAMIC_MINOR,
836    .name = "btrfs-control",
837    .fops = &btrfs_ctl_fops
838};
839
840static int btrfs_interface_init(void)
841{
842    return misc_register(&btrfs_misc);
843}
844
845static void btrfs_interface_exit(void)
846{
847    if (misc_deregister(&btrfs_misc) < 0)
848        printk(KERN_INFO "misc_deregister failed for control device");
849}
850
851static int __init init_btrfs_fs(void)
852{
853    int err;
854
855    err = btrfs_init_sysfs();
856    if (err)
857        return err;
858
859    err = btrfs_init_cachep();
860    if (err)
861        goto free_sysfs;
862
863    err = extent_io_init();
864    if (err)
865        goto free_cachep;
866
867    err = extent_map_init();
868    if (err)
869        goto free_extent_io;
870
871    err = btrfs_interface_init();
872    if (err)
873        goto free_extent_map;
874
875    err = register_filesystem(&btrfs_fs_type);
876    if (err)
877        goto unregister_ioctl;
878
879    printk(KERN_INFO "%s loaded\n", BTRFS_BUILD_VERSION);
880    return 0;
881
882unregister_ioctl:
883    btrfs_interface_exit();
884free_extent_map:
885    extent_map_exit();
886free_extent_io:
887    extent_io_exit();
888free_cachep:
889    btrfs_destroy_cachep();
890free_sysfs:
891    btrfs_exit_sysfs();
892    return err;
893}
894
895static void __exit exit_btrfs_fs(void)
896{
897    btrfs_destroy_cachep();
898    extent_map_exit();
899    extent_io_exit();
900    btrfs_interface_exit();
901    unregister_filesystem(&btrfs_fs_type);
902    btrfs_exit_sysfs();
903    btrfs_cleanup_fs_uuids();
904    btrfs_zlib_exit();
905}
906
907module_init(init_btrfs_fs)
908module_exit(exit_btrfs_fs)
909
910MODULE_LICENSE("GPL");
911

Archive Download this file



interactive