blob: 04a3bf816509d697ee8d616c6cf211689a3da43c [file] [log] [blame]
Chris Mason6cbd5572007-06-12 09:07:21 -04001/*
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
Yan4b82d6e2007-08-29 09:11:44 -040019#include <linux/blkdev.h>
Chris Mason2e635a22007-03-21 11:12:56 -040020#include <linux/module.h>
Chris Masone20d96d2007-03-22 12:13:20 -040021#include <linux/buffer_head.h>
Chris Mason2e635a22007-03-21 11:12:56 -040022#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/string.h>
28#include <linux/smp_lock.h>
29#include <linux/backing-dev.h>
Yan4b82d6e2007-08-29 09:11:44 -040030#include <linux/mount.h>
Chris Masondee26a92007-03-26 16:00:06 -040031#include <linux/mpage.h>
Chris Mason75dfe392007-03-29 11:56:46 -040032#include <linux/swap.h>
33#include <linux/writeback.h>
Chris Mason8fd17792007-04-19 21:01:03 -040034#include <linux/statfs.h>
Chris Mason08607c12007-06-08 15:33:54 -040035#include <linux/compat.h>
Chris Mason95e05282007-08-29 09:11:44 -040036#include <linux/parser.h>
Chris Masonc59f8952007-12-17 20:14:04 -050037#include <linux/ctype.h>
Chris Mason6da6aba2007-12-18 16:15:09 -050038#include <linux/namei.h>
Chris Masona9218f62008-03-24 15:02:04 -040039#include <linux/miscdevice.h>
Chris Mason2e635a22007-03-21 11:12:56 -040040#include "ctree.h"
Chris Masone20d96d2007-03-22 12:13:20 -040041#include "disk-io.h"
Chris Masond5719762007-03-23 10:01:08 -040042#include "transaction.h"
Chris Mason2c90e5d2007-04-02 10:50:19 -040043#include "btrfs_inode.h"
Chris Masonc5739bb2007-04-10 09:27:04 -040044#include "ioctl.h"
Chris Mason3a686372007-05-24 13:35:57 -040045#include "print-tree.h"
Josef Bacik5103e942007-11-16 11:45:54 -050046#include "xattr.h"
Chris Mason8a4b83c2008-03-24 15:02:07 -040047#include "volumes.h"
Chris Masonb3c3da72008-07-23 12:12:13 -040048#include "version.h"
Balaji Raobe6e8dc2008-07-21 02:01:56 +053049#include "export.h"
Chris Masonc8b97812008-10-29 14:49:59 -040050#include "compression.h"
Chris Mason2e635a22007-03-21 11:12:56 -040051
Chris Mason5f39d392007-10-15 16:14:19 -040052#define BTRFS_SUPER_MAGIC 0x9123683E
Chris Masone20d96d2007-03-22 12:13:20 -040053
Chris Masone20d96d2007-03-22 12:13:20 -040054static struct super_operations btrfs_super_ops;
Chris Masone20d96d2007-03-22 12:13:20 -040055
56static void btrfs_put_super (struct super_block * sb)
57{
58 struct btrfs_root *root = btrfs_sb(sb);
Josef Bacik58176a92007-08-29 15:47:34 -040059 struct btrfs_fs_info *fs = root->fs_info;
Chris Masone20d96d2007-03-22 12:13:20 -040060 int ret;
61
62 ret = close_ctree(root);
63 if (ret) {
64 printk("close ctree returns %d\n", ret);
65 }
Josef Bacik58176a92007-08-29 15:47:34 -040066 btrfs_sysfs_del_super(fs);
Chris Masone20d96d2007-03-22 12:13:20 -040067 sb->s_fs_info = NULL;
68}
Chris Mason2e635a22007-03-21 11:12:56 -040069
Chris Mason95e05282007-08-29 09:11:44 -040070enum {
Christoph Hellwig43e570b2008-06-10 10:40:46 -040071 Opt_degraded, Opt_subvol, Opt_device, Opt_nodatasum, Opt_nodatacow,
Chris Masondfe25022008-05-13 13:46:40 -040072 Opt_max_extent, Opt_max_inline, Opt_alloc_start, Opt_nobarrier,
Chris Masonc8b97812008-10-29 14:49:59 -040073 Opt_ssd, Opt_thread_pool, Opt_noacl, Opt_compress, Opt_err,
Chris Mason95e05282007-08-29 09:11:44 -040074};
75
76static match_table_t tokens = {
Chris Masondfe25022008-05-13 13:46:40 -040077 {Opt_degraded, "degraded"},
Chris Mason95e05282007-08-29 09:11:44 -040078 {Opt_subvol, "subvol=%s"},
Christoph Hellwig43e570b2008-06-10 10:40:46 -040079 {Opt_device, "device=%s"},
Chris Masonb6cda9b2007-12-14 15:30:32 -050080 {Opt_nodatasum, "nodatasum"},
Chris Masonbe20aa92007-12-17 20:14:01 -050081 {Opt_nodatacow, "nodatacow"},
Chris Mason21ad10c2008-01-09 09:23:21 -050082 {Opt_nobarrier, "nobarrier"},
Chris Masonc59f8952007-12-17 20:14:04 -050083 {Opt_max_extent, "max_extent=%s"},
Chris Mason6f568d32008-01-29 16:03:38 -050084 {Opt_max_inline, "max_inline=%s"},
Chris Mason8f662a72008-01-02 10:01:11 -050085 {Opt_alloc_start, "alloc_start=%s"},
Chris Mason4543df72008-06-11 21:47:56 -040086 {Opt_thread_pool, "thread_pool=%d"},
Chris Masonc8b97812008-10-29 14:49:59 -040087 {Opt_compress, "compress"},
Chris Masone18e4802008-01-18 10:54:22 -050088 {Opt_ssd, "ssd"},
Josef Bacik33268ea2008-07-24 12:16:36 -040089 {Opt_noacl, "noacl"},
90 {Opt_err, NULL},
Chris Mason95e05282007-08-29 09:11:44 -040091};
92
Chris Masonedbd8d42007-12-21 16:27:24 -050093u64 btrfs_parse_size(char *str)
Chris Masonc59f8952007-12-17 20:14:04 -050094{
Chris Masonedbd8d42007-12-21 16:27:24 -050095 u64 res;
Chris Masonc59f8952007-12-17 20:14:04 -050096 int mult = 1;
97 char *end;
98 char last;
99
100 res = simple_strtoul(str, &end, 10);
101
102 last = end[0];
103 if (isalpha(last)) {
104 last = tolower(last);
105 switch (last) {
106 case 'g':
107 mult *= 1024;
108 case 'm':
109 mult *= 1024;
110 case 'k':
111 mult *= 1024;
112 }
113 res = res * mult;
114 }
115 return res;
116}
117
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400118/*
119 * Regular mount options parser. Everything that is needed only when
120 * reading in a new superblock is parsed here.
121 */
122int btrfs_parse_options(struct btrfs_root *root, char *options)
Chris Mason95e05282007-08-29 09:11:44 -0400123{
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400124 struct btrfs_fs_info *info = root->fs_info;
Chris Mason95e05282007-08-29 09:11:44 -0400125 substring_t args[MAX_OPT_ARGS];
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400126 char *p, *num;
Chris Mason4543df72008-06-11 21:47:56 -0400127 int intarg;
Chris Masonb6cda9b2007-12-14 15:30:32 -0500128
Chris Mason95e05282007-08-29 09:11:44 -0400129 if (!options)
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400130 return 0;
Chris Mason95e05282007-08-29 09:11:44 -0400131
Chris Masonbe20aa92007-12-17 20:14:01 -0500132 /*
133 * strsep changes the string, duplicate it because parse_options
134 * gets called twice
135 */
136 options = kstrdup(options, GFP_NOFS);
137 if (!options)
138 return -ENOMEM;
139
Chris Masonbe20aa92007-12-17 20:14:01 -0500140
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400141 while ((p = strsep(&options, ",")) != NULL) {
Chris Mason95e05282007-08-29 09:11:44 -0400142 int token;
143 if (!*p)
144 continue;
145
146 token = match_token(p, tokens, args);
147 switch (token) {
Chris Masondfe25022008-05-13 13:46:40 -0400148 case Opt_degraded:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400149 printk(KERN_INFO "btrfs: allowing degraded mounts\n");
150 btrfs_set_opt(info->mount_opt, DEGRADED);
Chris Masondfe25022008-05-13 13:46:40 -0400151 break;
Chris Mason95e05282007-08-29 09:11:44 -0400152 case Opt_subvol:
Christoph Hellwig43e570b2008-06-10 10:40:46 -0400153 case Opt_device:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400154 /*
Christoph Hellwig43e570b2008-06-10 10:40:46 -0400155 * These are parsed by btrfs_parse_early_options
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400156 * and can be happily ignored here.
157 */
Chris Masonb6cda9b2007-12-14 15:30:32 -0500158 break;
159 case Opt_nodatasum:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400160 printk(KERN_INFO "btrfs: setting nodatacsum\n");
161 btrfs_set_opt(info->mount_opt, NODATASUM);
Chris Masonbe20aa92007-12-17 20:14:01 -0500162 break;
163 case Opt_nodatacow:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400164 printk(KERN_INFO "btrfs: setting nodatacow\n");
165 btrfs_set_opt(info->mount_opt, NODATACOW);
166 btrfs_set_opt(info->mount_opt, NODATASUM);
Chris Mason95e05282007-08-29 09:11:44 -0400167 break;
Chris Masonc8b97812008-10-29 14:49:59 -0400168 case Opt_compress:
169 printk(KERN_INFO "btrfs: use compression\n");
170 btrfs_set_opt(info->mount_opt, COMPRESS);
171 break;
Chris Masone18e4802008-01-18 10:54:22 -0500172 case Opt_ssd:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400173 printk(KERN_INFO "btrfs: use ssd allocation scheme\n");
174 btrfs_set_opt(info->mount_opt, SSD);
Chris Masone18e4802008-01-18 10:54:22 -0500175 break;
Chris Mason21ad10c2008-01-09 09:23:21 -0500176 case Opt_nobarrier:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400177 printk(KERN_INFO "btrfs: turning off barriers\n");
178 btrfs_set_opt(info->mount_opt, NOBARRIER);
Chris Mason21ad10c2008-01-09 09:23:21 -0500179 break;
Chris Mason4543df72008-06-11 21:47:56 -0400180 case Opt_thread_pool:
181 intarg = 0;
182 match_int(&args[0], &intarg);
183 if (intarg) {
184 info->thread_pool_size = intarg;
185 printk(KERN_INFO "btrfs: thread pool %d\n",
186 info->thread_pool_size);
187 }
188 break;
Chris Masonc59f8952007-12-17 20:14:04 -0500189 case Opt_max_extent:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400190 num = match_strdup(&args[0]);
191 if (num) {
192 info->max_extent = btrfs_parse_size(num);
193 kfree(num);
Chris Masonc59f8952007-12-17 20:14:04 -0500194
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400195 info->max_extent = max_t(u64,
196 info->max_extent, root->sectorsize);
197 printk(KERN_INFO "btrfs: max_extent at %llu\n",
198 info->max_extent);
Chris Masonc59f8952007-12-17 20:14:04 -0500199 }
200 break;
Chris Mason6f568d32008-01-29 16:03:38 -0500201 case Opt_max_inline:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400202 num = match_strdup(&args[0]);
203 if (num) {
204 info->max_inline = btrfs_parse_size(num);
205 kfree(num);
Chris Mason6f568d32008-01-29 16:03:38 -0500206
Chris Mason15ada042008-06-11 16:51:38 -0400207 if (info->max_inline) {
208 info->max_inline = max_t(u64,
209 info->max_inline,
210 root->sectorsize);
211 }
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400212 printk(KERN_INFO "btrfs: max_inline at %llu\n",
213 info->max_inline);
Chris Mason6f568d32008-01-29 16:03:38 -0500214 }
215 break;
Chris Mason8f662a72008-01-02 10:01:11 -0500216 case Opt_alloc_start:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400217 num = match_strdup(&args[0]);
218 if (num) {
219 info->alloc_start = btrfs_parse_size(num);
220 kfree(num);
221 printk(KERN_INFO
222 "btrfs: allocations start at %llu\n",
223 info->alloc_start);
Chris Mason8f662a72008-01-02 10:01:11 -0500224 }
225 break;
Josef Bacik33268ea2008-07-24 12:16:36 -0400226 case Opt_noacl:
227 root->fs_info->sb->s_flags &= ~MS_POSIXACL;
228 break;
Chris Mason95e05282007-08-29 09:11:44 -0400229 default:
Chris Masonbe20aa92007-12-17 20:14:01 -0500230 break;
Chris Mason95e05282007-08-29 09:11:44 -0400231 }
232 }
Chris Masonbe20aa92007-12-17 20:14:01 -0500233 kfree(options);
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400234 return 0;
235}
236
237/*
238 * Parse mount options that are required early in the mount process.
239 *
240 * All other options will be parsed on much later in the mount process and
241 * only when we need to allocate a new super block.
242 */
Christoph Hellwig43e570b2008-06-10 10:40:46 -0400243static int btrfs_parse_early_options(const char *options, int flags,
244 void *holder, char **subvol_name,
245 struct btrfs_fs_devices **fs_devices)
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400246{
247 substring_t args[MAX_OPT_ARGS];
248 char *opts, *p;
249 int error = 0;
250
251 if (!options)
252 goto out;
253
254 /*
255 * strsep changes the string, duplicate it because parse_options
256 * gets called twice
257 */
258 opts = kstrdup(options, GFP_KERNEL);
259 if (!opts)
260 return -ENOMEM;
261
262 while ((p = strsep(&opts, ",")) != NULL) {
263 int token;
264 if (!*p)
265 continue;
266
267 token = match_token(p, tokens, args);
268 switch (token) {
269 case Opt_subvol:
270 *subvol_name = match_strdup(&args[0]);
271 break;
Christoph Hellwig43e570b2008-06-10 10:40:46 -0400272 case Opt_device:
273 error = btrfs_scan_one_device(match_strdup(&args[0]),
274 flags, holder, fs_devices);
275 if (error)
276 goto out_free_opts;
277 break;
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400278 default:
279 break;
280 }
281 }
282
Christoph Hellwig43e570b2008-06-10 10:40:46 -0400283 out_free_opts:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400284 kfree(opts);
285 out:
286 /*
287 * If no subvolume name is specified we use the default one. Allocate
288 * a copy of the string "default" here so that code later in the
289 * mount path doesn't care if it's the default volume or another one.
290 */
291 if (!*subvol_name) {
292 *subvol_name = kstrdup("default", GFP_KERNEL);
293 if (!*subvol_name)
294 return -ENOMEM;
295 }
296 return error;
Chris Mason95e05282007-08-29 09:11:44 -0400297}
298
Chris Mason8a4b83c2008-03-24 15:02:07 -0400299static int btrfs_fill_super(struct super_block * sb,
300 struct btrfs_fs_devices *fs_devices,
301 void * data, int silent)
Chris Mason2e635a22007-03-21 11:12:56 -0400302{
303 struct inode * inode;
Chris Masone20d96d2007-03-22 12:13:20 -0400304 struct dentry * root_dentry;
305 struct btrfs_super_block *disk_super;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400306 struct btrfs_root *tree_root;
Chris Masond6e4a422007-04-06 15:37:36 -0400307 struct btrfs_inode *bi;
Chris Mason39279cc2007-06-12 06:35:45 -0400308 int err;
Chris Mason2e635a22007-03-21 11:12:56 -0400309
310 sb->s_maxbytes = MAX_LFS_FILESIZE;
Chris Mason2e635a22007-03-21 11:12:56 -0400311 sb->s_magic = BTRFS_SUPER_MAGIC;
Chris Masone20d96d2007-03-22 12:13:20 -0400312 sb->s_op = &btrfs_super_ops;
Balaji Raobe6e8dc2008-07-21 02:01:56 +0530313 sb->s_export_op = &btrfs_export_ops;
Josef Bacik5103e942007-11-16 11:45:54 -0500314 sb->s_xattr = btrfs_xattr_handlers;
Chris Mason2e635a22007-03-21 11:12:56 -0400315 sb->s_time_gran = 1;
Josef Bacik33268ea2008-07-24 12:16:36 -0400316 sb->s_flags |= MS_POSIXACL;
Chris Masone20d96d2007-03-22 12:13:20 -0400317
Chris Masondfe25022008-05-13 13:46:40 -0400318 tree_root = open_ctree(sb, fs_devices, (char *)data);
Chris Masond98237b2007-03-28 13:57:48 -0400319
Yane58ca022008-04-01 11:21:34 -0400320 if (IS_ERR(tree_root)) {
Chris Masone20d96d2007-03-22 12:13:20 -0400321 printk("btrfs: open_ctree failed\n");
Yane58ca022008-04-01 11:21:34 -0400322 return PTR_ERR(tree_root);
Chris Masone20d96d2007-03-22 12:13:20 -0400323 }
Chris Mason0f7d52f2007-04-09 10:42:37 -0400324 sb->s_fs_info = tree_root;
Chris Mason5f39d392007-10-15 16:14:19 -0400325 disk_super = &tree_root->fs_info->super_copy;
Chris Masonc5739bb2007-04-10 09:27:04 -0400326 inode = btrfs_iget_locked(sb, btrfs_super_root_dir(disk_super),
327 tree_root);
Chris Masond6e4a422007-04-06 15:37:36 -0400328 bi = BTRFS_I(inode);
329 bi->location.objectid = inode->i_ino;
330 bi->location.offset = 0;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400331 bi->root = tree_root;
Chris Masonb888db22007-08-27 16:49:44 -0400332
Chris Masond6e4a422007-04-06 15:37:36 -0400333 btrfs_set_key_type(&bi->location, BTRFS_INODE_ITEM_KEY);
334
Chris Mason39279cc2007-06-12 06:35:45 -0400335 if (!inode) {
336 err = -ENOMEM;
337 goto fail_close;
338 }
Chris Masone20d96d2007-03-22 12:13:20 -0400339 if (inode->i_state & I_NEW) {
340 btrfs_read_locked_inode(inode);
341 unlock_new_inode(inode);
342 }
Chris Mason2e635a22007-03-21 11:12:56 -0400343
Chris Masone20d96d2007-03-22 12:13:20 -0400344 root_dentry = d_alloc_root(inode);
345 if (!root_dentry) {
Chris Mason2e635a22007-03-21 11:12:56 -0400346 iput(inode);
Chris Mason39279cc2007-06-12 06:35:45 -0400347 err = -ENOMEM;
348 goto fail_close;
Chris Mason2e635a22007-03-21 11:12:56 -0400349 }
Josef Bacik58176a92007-08-29 15:47:34 -0400350
351 /* this does the super kobj at the same time */
352 err = btrfs_sysfs_add_super(tree_root->fs_info);
353 if (err)
354 goto fail_close;
355
Chris Masone20d96d2007-03-22 12:13:20 -0400356 sb->s_root = root_dentry;
Chris Mason6885f302008-02-20 16:11:05 -0500357
Chris Mason6885f302008-02-20 16:11:05 -0500358 save_mount_options(sb, data);
Chris Mason2e635a22007-03-21 11:12:56 -0400359 return 0;
Chris Mason2e635a22007-03-21 11:12:56 -0400360
Chris Mason39279cc2007-06-12 06:35:45 -0400361fail_close:
362 close_ctree(tree_root);
Chris Masond5719762007-03-23 10:01:08 -0400363 return err;
364}
365
Sage Weil6bf13c02008-06-10 10:07:39 -0400366int btrfs_sync_fs(struct super_block *sb, int wait)
Chris Masond5719762007-03-23 10:01:08 -0400367{
368 struct btrfs_trans_handle *trans;
369 struct btrfs_root *root;
370 int ret;
Chris Masond98237b2007-03-28 13:57:48 -0400371 root = btrfs_sb(sb);
Chris Masondf2ce342007-03-23 11:00:45 -0400372
Yan Zhengc146afa2008-11-12 14:34:12 -0500373 if (sb->s_flags & MS_RDONLY)
374 return 0;
375
Chris Masond5719762007-03-23 10:01:08 -0400376 sb->s_dirt = 0;
Chris Masond561c022007-03-23 19:47:49 -0400377 if (!wait) {
Chris Mason7cfcc172007-04-02 14:53:59 -0400378 filemap_flush(root->fs_info->btree_inode->i_mapping);
Chris Masond561c022007-03-23 19:47:49 -0400379 return 0;
380 }
Chris Mason771ed682008-11-06 22:02:51 -0500381
382 btrfs_start_delalloc_inodes(root);
383 btrfs_wait_ordered_extents(root, 0);
384
Chris Masone9d0b132007-08-10 14:06:19 -0400385 btrfs_clean_old_snapshots(root);
Chris Masond5719762007-03-23 10:01:08 -0400386 trans = btrfs_start_transaction(root, 1);
387 ret = btrfs_commit_transaction(trans, root);
388 sb->s_dirt = 0;
Chris Mason54aa1f42007-06-22 14:16:25 -0400389 return ret;
Chris Masond5719762007-03-23 10:01:08 -0400390}
391
Chris Masond561c022007-03-23 19:47:49 -0400392static void btrfs_write_super(struct super_block *sb)
393{
Chris Mason08607c12007-06-08 15:33:54 -0400394 sb->s_dirt = 0;
Chris Masond561c022007-03-23 19:47:49 -0400395}
396
Chris Masona061fc82008-05-07 11:43:44 -0400397static int btrfs_test_super(struct super_block *s, void *data)
Chris Mason2e635a22007-03-21 11:12:56 -0400398{
Chris Masona061fc82008-05-07 11:43:44 -0400399 struct btrfs_fs_devices *test_fs_devices = data;
400 struct btrfs_root *root = btrfs_sb(s);
Yan4b82d6e2007-08-29 09:11:44 -0400401
Chris Masona061fc82008-05-07 11:43:44 -0400402 return root->fs_info->fs_devices == test_fs_devices;
Yan4b82d6e2007-08-29 09:11:44 -0400403}
404
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400405/*
406 * Find a superblock for the given device / mount point.
407 *
408 * Note: This is based on get_sb_bdev from fs/super.c with a few additions
409 * for multiple device setup. Make sure to keep it in sync.
410 */
411static int btrfs_get_sb(struct file_system_type *fs_type, int flags,
412 const char *dev_name, void *data, struct vfsmount *mnt)
Yan4b82d6e2007-08-29 09:11:44 -0400413{
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400414 char *subvol_name = NULL;
Yan4b82d6e2007-08-29 09:11:44 -0400415 struct block_device *bdev = NULL;
416 struct super_block *s;
417 struct dentry *root;
Chris Mason8a4b83c2008-03-24 15:02:07 -0400418 struct btrfs_fs_devices *fs_devices = NULL;
Yan4b82d6e2007-08-29 09:11:44 -0400419 int error = 0;
420
Christoph Hellwig43e570b2008-06-10 10:40:46 -0400421 error = btrfs_parse_early_options(data, flags, fs_type,
422 &subvol_name, &fs_devices);
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400423 if (error)
424 goto error;
425
Chris Mason8a4b83c2008-03-24 15:02:07 -0400426 error = btrfs_scan_one_device(dev_name, flags, fs_type, &fs_devices);
427 if (error)
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400428 goto error_free_subvol_name;
Yan4b82d6e2007-08-29 09:11:44 -0400429
Chris Mason8a4b83c2008-03-24 15:02:07 -0400430 error = btrfs_open_devices(fs_devices, flags, fs_type);
431 if (error)
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400432 goto error_free_subvol_name;
Chris Mason8a4b83c2008-03-24 15:02:07 -0400433
Chris Masondfe25022008-05-13 13:46:40 -0400434 bdev = fs_devices->latest_bdev;
Chris Masona061fc82008-05-07 11:43:44 -0400435 s = sget(fs_type, btrfs_test_super, set_anon_super, fs_devices);
Yan4b82d6e2007-08-29 09:11:44 -0400436 if (IS_ERR(s))
437 goto error_s;
438
439 if (s->s_root) {
440 if ((flags ^ s->s_flags) & MS_RDONLY) {
441 up_write(&s->s_umount);
442 deactivate_super(s);
443 error = -EBUSY;
Yan Zhengc146afa2008-11-12 14:34:12 -0500444 goto error_close_devices;
Yan4b82d6e2007-08-29 09:11:44 -0400445 }
446
Yan4b82d6e2007-08-29 09:11:44 -0400447 } else {
448 char b[BDEVNAME_SIZE];
449
450 s->s_flags = flags;
451 strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
Chris Mason8a4b83c2008-03-24 15:02:07 -0400452 error = btrfs_fill_super(s, fs_devices, data,
453 flags & MS_SILENT ? 1 : 0);
Yan4b82d6e2007-08-29 09:11:44 -0400454 if (error) {
455 up_write(&s->s_umount);
456 deactivate_super(s);
457 goto error;
458 }
459
Chris Mason788f20e2008-04-28 15:29:42 -0400460 btrfs_sb(s)->fs_info->bdev_holder = fs_type;
Yan4b82d6e2007-08-29 09:11:44 -0400461 s->s_flags |= MS_ACTIVE;
462 }
463
David Woodhouse76fcef12008-08-19 16:49:35 +0100464 if (!strcmp(subvol_name, "."))
465 root = dget(s->s_root);
466 else {
467 mutex_lock(&s->s_root->d_inode->i_mutex);
468 root = lookup_one_len(subvol_name, s->s_root, strlen(subvol_name));
469 mutex_unlock(&s->s_root->d_inode->i_mutex);
470 if (IS_ERR(root)) {
471 up_write(&s->s_umount);
472 deactivate_super(s);
473 error = PTR_ERR(root);
474 goto error;
475 }
476 if (!root->d_inode) {
477 dput(root);
478 up_write(&s->s_umount);
479 deactivate_super(s);
480 error = -ENXIO;
481 goto error;
482 }
Yan4b82d6e2007-08-29 09:11:44 -0400483 }
484
485 mnt->mnt_sb = s;
486 mnt->mnt_root = root;
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400487
488 kfree(subvol_name);
Yan4b82d6e2007-08-29 09:11:44 -0400489 return 0;
490
491error_s:
492 error = PTR_ERR(s);
Yan Zhengc146afa2008-11-12 14:34:12 -0500493error_close_devices:
Chris Mason8a4b83c2008-03-24 15:02:07 -0400494 btrfs_close_devices(fs_devices);
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400495error_free_subvol_name:
496 kfree(subvol_name);
Yan4b82d6e2007-08-29 09:11:44 -0400497error:
498 return error;
499}
Chris Mason2e635a22007-03-21 11:12:56 -0400500
Yan Zhengc146afa2008-11-12 14:34:12 -0500501static int btrfs_remount(struct super_block *sb, int *flags, char *data)
502{
503 struct btrfs_root *root = btrfs_sb(sb);
504 int ret;
505
506 if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
507 return 0;
508
509 if (*flags & MS_RDONLY) {
510 sb->s_flags |= MS_RDONLY;
511
512 ret = btrfs_commit_super(root);
513 WARN_ON(ret);
514 } else {
515 if (btrfs_super_log_root(&root->fs_info->super_copy) != 0)
516 return -EINVAL;
517
518 ret = btrfs_cleanup_reloc_trees(root);
519 WARN_ON(ret);
520
521 ret = btrfs_cleanup_fs_roots(root->fs_info);
522 WARN_ON(ret);
523
524 sb->s_flags &= ~MS_RDONLY;
525 }
526
527 return 0;
528}
529
Chris Mason8fd17792007-04-19 21:01:03 -0400530static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
531{
532 struct btrfs_root *root = btrfs_sb(dentry->d_sb);
Chris Mason4b52dff2007-06-26 10:06:50 -0400533 struct btrfs_super_block *disk_super = &root->fs_info->super_copy;
Chris Masondb945352007-10-15 16:15:53 -0400534 int bits = dentry->d_sb->s_blocksize_bits;
David Woodhouse9d036322008-08-18 12:01:52 +0100535 __be32 *fsid = (__be32 *)root->fs_info->fsid;
Chris Mason8fd17792007-04-19 21:01:03 -0400536
537 buf->f_namelen = BTRFS_NAME_LEN;
Chris Masondb945352007-10-15 16:15:53 -0400538 buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
539 buf->f_bfree = buf->f_blocks -
540 (btrfs_super_bytes_used(disk_super) >> bits);
Chris Mason8fd17792007-04-19 21:01:03 -0400541 buf->f_bavail = buf->f_bfree;
542 buf->f_bsize = dentry->d_sb->s_blocksize;
543 buf->f_type = BTRFS_SUPER_MAGIC;
David Woodhouse9d036322008-08-18 12:01:52 +0100544 /* We treat it as constant endianness (it doesn't matter _which_)
545 because we want the fsid to come out the same whether mounted
546 on a big-endian or little-endian host */
547 buf->f_fsid.val[0] = be32_to_cpu(fsid[0]) ^ be32_to_cpu(fsid[2]);
548 buf->f_fsid.val[1] = be32_to_cpu(fsid[1]) ^ be32_to_cpu(fsid[3]);
David Woodhouse32d48fa2008-08-18 13:10:20 +0100549 /* Mask in the root object ID too, to disambiguate subvols */
550 buf->f_fsid.val[0] ^= BTRFS_I(dentry->d_inode)->root->objectid >> 32;
551 buf->f_fsid.val[1] ^= BTRFS_I(dentry->d_inode)->root->objectid;
552
Chris Mason8fd17792007-04-19 21:01:03 -0400553 return 0;
554}
Chris Masonb5133862007-04-24 11:52:22 -0400555
Chris Mason2e635a22007-03-21 11:12:56 -0400556static struct file_system_type btrfs_fs_type = {
557 .owner = THIS_MODULE,
558 .name = "btrfs",
559 .get_sb = btrfs_get_sb,
Chris Masona061fc82008-05-07 11:43:44 -0400560 .kill_sb = kill_anon_super,
Chris Mason2e635a22007-03-21 11:12:56 -0400561 .fs_flags = FS_REQUIRES_DEV,
562};
Chris Masona9218f62008-03-24 15:02:04 -0400563
Chris Masond352ac62008-09-29 15:18:18 -0400564/*
565 * used by btrfsctl to scan devices when no FS is mounted
566 */
Chris Mason8a4b83c2008-03-24 15:02:07 -0400567static long btrfs_control_ioctl(struct file *file, unsigned int cmd,
568 unsigned long arg)
569{
570 struct btrfs_ioctl_vol_args *vol;
571 struct btrfs_fs_devices *fs_devices;
Linda Knippersf819d832008-06-09 22:17:11 -0400572 int ret = 0;
Chris Mason8a4b83c2008-03-24 15:02:07 -0400573 int len;
574
575 vol = kmalloc(sizeof(*vol), GFP_KERNEL);
576 if (copy_from_user(vol, (void __user *)arg, sizeof(*vol))) {
577 ret = -EFAULT;
578 goto out;
579 }
580 len = strnlen(vol->name, BTRFS_PATH_NAME_MAX);
581 switch (cmd) {
582 case BTRFS_IOC_SCAN_DEV:
583 ret = btrfs_scan_one_device(vol->name, MS_RDONLY,
584 &btrfs_fs_type, &fs_devices);
585 break;
586 }
587out:
588 kfree(vol);
Linda Knippersf819d832008-06-09 22:17:11 -0400589 return ret;
Chris Mason8a4b83c2008-03-24 15:02:07 -0400590}
591
Yaned0dab62008-01-22 12:46:56 -0500592static void btrfs_write_super_lockfs(struct super_block *sb)
593{
594 struct btrfs_root *root = btrfs_sb(sb);
Chris Masona74a4b92008-06-25 16:01:31 -0400595 mutex_lock(&root->fs_info->transaction_kthread_mutex);
596 mutex_lock(&root->fs_info->cleaner_mutex);
Yaned0dab62008-01-22 12:46:56 -0500597}
598
599static void btrfs_unlockfs(struct super_block *sb)
600{
601 struct btrfs_root *root = btrfs_sb(sb);
Chris Masona74a4b92008-06-25 16:01:31 -0400602 mutex_unlock(&root->fs_info->cleaner_mutex);
603 mutex_unlock(&root->fs_info->transaction_kthread_mutex);
Yaned0dab62008-01-22 12:46:56 -0500604}
Chris Mason2e635a22007-03-21 11:12:56 -0400605
Chris Masone20d96d2007-03-22 12:13:20 -0400606static struct super_operations btrfs_super_ops = {
Chris Mason134e9732007-03-25 13:44:56 -0400607 .delete_inode = btrfs_delete_inode,
Chris Masone20d96d2007-03-22 12:13:20 -0400608 .put_super = btrfs_put_super,
Chris Masond5719762007-03-23 10:01:08 -0400609 .write_super = btrfs_write_super,
610 .sync_fs = btrfs_sync_fs,
Chris Mason6885f302008-02-20 16:11:05 -0500611 .show_options = generic_show_options,
Chris Mason4730a4b2007-03-26 12:00:39 -0400612 .write_inode = btrfs_write_inode,
Chris Masonb5133862007-04-24 11:52:22 -0400613 .dirty_inode = btrfs_dirty_inode,
Chris Mason2c90e5d2007-04-02 10:50:19 -0400614 .alloc_inode = btrfs_alloc_inode,
615 .destroy_inode = btrfs_destroy_inode,
Chris Mason8fd17792007-04-19 21:01:03 -0400616 .statfs = btrfs_statfs,
Yan Zhengc146afa2008-11-12 14:34:12 -0500617 .remount_fs = btrfs_remount,
Yaned0dab62008-01-22 12:46:56 -0500618 .write_super_lockfs = btrfs_write_super_lockfs,
619 .unlockfs = btrfs_unlockfs,
Chris Masone20d96d2007-03-22 12:13:20 -0400620};
Chris Masona9218f62008-03-24 15:02:04 -0400621
622static const struct file_operations btrfs_ctl_fops = {
623 .unlocked_ioctl = btrfs_control_ioctl,
624 .compat_ioctl = btrfs_control_ioctl,
625 .owner = THIS_MODULE,
626};
627
628static struct miscdevice btrfs_misc = {
629 .minor = MISC_DYNAMIC_MINOR,
630 .name = "btrfs-control",
631 .fops = &btrfs_ctl_fops
632};
633
634static int btrfs_interface_init(void)
635{
636 return misc_register(&btrfs_misc);
637}
638
639void btrfs_interface_exit(void)
640{
641 if (misc_deregister(&btrfs_misc) < 0)
642 printk("misc_deregister failed for control device");
643}
644
Chris Mason2e635a22007-03-21 11:12:56 -0400645static int __init init_btrfs_fs(void)
646{
Chris Mason2c90e5d2007-04-02 10:50:19 -0400647 int err;
Josef Bacik58176a92007-08-29 15:47:34 -0400648
649 err = btrfs_init_sysfs();
650 if (err)
651 return err;
652
Chris Mason39279cc2007-06-12 06:35:45 -0400653 err = btrfs_init_cachep();
Chris Mason2c90e5d2007-04-02 10:50:19 -0400654 if (err)
Chris Masona74a4b92008-06-25 16:01:31 -0400655 goto free_sysfs;
Chris Masond1310b22008-01-24 16:13:08 -0500656
657 err = extent_io_init();
Wyatt Banks2f4cbe62007-11-19 10:22:33 -0500658 if (err)
659 goto free_cachep;
660
Chris Masond1310b22008-01-24 16:13:08 -0500661 err = extent_map_init();
662 if (err)
663 goto free_extent_io;
664
Chris Masona9218f62008-03-24 15:02:04 -0400665 err = btrfs_interface_init();
Wyatt Banks2f4cbe62007-11-19 10:22:33 -0500666 if (err)
667 goto free_extent_map;
Chris Masonc8b97812008-10-29 14:49:59 -0400668
Chris Masona9218f62008-03-24 15:02:04 -0400669 err = register_filesystem(&btrfs_fs_type);
670 if (err)
671 goto unregister_ioctl;
Chris Masonb3c3da72008-07-23 12:12:13 -0400672
673 printk(KERN_INFO "%s loaded\n", BTRFS_BUILD_VERSION);
Wyatt Banks2f4cbe62007-11-19 10:22:33 -0500674 return 0;
675
Chris Masona9218f62008-03-24 15:02:04 -0400676unregister_ioctl:
677 btrfs_interface_exit();
Wyatt Banks2f4cbe62007-11-19 10:22:33 -0500678free_extent_map:
679 extent_map_exit();
Chris Masond1310b22008-01-24 16:13:08 -0500680free_extent_io:
681 extent_io_exit();
Wyatt Banks2f4cbe62007-11-19 10:22:33 -0500682free_cachep:
683 btrfs_destroy_cachep();
Chris Masona74a4b92008-06-25 16:01:31 -0400684free_sysfs:
Wyatt Banks2f4cbe62007-11-19 10:22:33 -0500685 btrfs_exit_sysfs();
686 return err;
Chris Mason2e635a22007-03-21 11:12:56 -0400687}
688
689static void __exit exit_btrfs_fs(void)
690{
Chris Mason39279cc2007-06-12 06:35:45 -0400691 btrfs_destroy_cachep();
Chris Masona52d9a82007-08-27 16:49:44 -0400692 extent_map_exit();
Chris Masond1310b22008-01-24 16:13:08 -0500693 extent_io_exit();
Chris Masona9218f62008-03-24 15:02:04 -0400694 btrfs_interface_exit();
Chris Mason2e635a22007-03-21 11:12:56 -0400695 unregister_filesystem(&btrfs_fs_type);
Josef Bacik58176a92007-08-29 15:47:34 -0400696 btrfs_exit_sysfs();
Chris Mason8a4b83c2008-03-24 15:02:07 -0400697 btrfs_cleanup_fs_uuids();
Chris Masonc8b97812008-10-29 14:49:59 -0400698 btrfs_zlib_exit();
Chris Mason2e635a22007-03-21 11:12:56 -0400699}
700
701module_init(init_btrfs_fs)
702module_exit(exit_btrfs_fs)
703
704MODULE_LICENSE("GPL");