blob: 0a14b495532fcc901d3c3baaa29cb4753d327d7f [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 Mason4b4e25f2008-11-20 10:22:27 -050040#include <linux/version.h>
41#include "compat.h"
Chris Mason2e635a22007-03-21 11:12:56 -040042#include "ctree.h"
Chris Masone20d96d2007-03-22 12:13:20 -040043#include "disk-io.h"
Chris Masond5719762007-03-23 10:01:08 -040044#include "transaction.h"
Chris Mason2c90e5d2007-04-02 10:50:19 -040045#include "btrfs_inode.h"
Chris Masonc5739bb2007-04-10 09:27:04 -040046#include "ioctl.h"
Chris Mason3a686372007-05-24 13:35:57 -040047#include "print-tree.h"
Josef Bacik5103e942007-11-16 11:45:54 -050048#include "xattr.h"
Chris Mason8a4b83c2008-03-24 15:02:07 -040049#include "volumes.h"
Chris Masonb3c3da72008-07-23 12:12:13 -040050#include "version.h"
Balaji Raobe6e8dc2008-07-21 02:01:56 +053051#include "export.h"
Chris Masonc8b97812008-10-29 14:49:59 -040052#include "compression.h"
Chris Mason2e635a22007-03-21 11:12:56 -040053
Chris Mason5f39d392007-10-15 16:14:19 -040054#define BTRFS_SUPER_MAGIC 0x9123683E
Chris Masone20d96d2007-03-22 12:13:20 -040055
Chris Masone20d96d2007-03-22 12:13:20 -040056static struct super_operations btrfs_super_ops;
Chris Masone20d96d2007-03-22 12:13:20 -040057
Chris Masond3977122009-01-05 21:25:51 -050058static void btrfs_put_super(struct super_block *sb)
Chris Masone20d96d2007-03-22 12:13:20 -040059{
60 struct btrfs_root *root = btrfs_sb(sb);
61 int ret;
62
63 ret = close_ctree(root);
Chris Masone20d96d2007-03-22 12:13:20 -040064 sb->s_fs_info = NULL;
65}
Chris Mason2e635a22007-03-21 11:12:56 -040066
Chris Mason95e05282007-08-29 09:11:44 -040067enum {
Christoph Hellwig43e570b2008-06-10 10:40:46 -040068 Opt_degraded, Opt_subvol, Opt_device, Opt_nodatasum, Opt_nodatacow,
Chris Masondfe25022008-05-13 13:46:40 -040069 Opt_max_extent, Opt_max_inline, Opt_alloc_start, Opt_nobarrier,
Chris Masonc8b97812008-10-29 14:49:59 -040070 Opt_ssd, Opt_thread_pool, Opt_noacl, Opt_compress, Opt_err,
Chris Mason95e05282007-08-29 09:11:44 -040071};
72
73static match_table_t tokens = {
Chris Masondfe25022008-05-13 13:46:40 -040074 {Opt_degraded, "degraded"},
Chris Mason95e05282007-08-29 09:11:44 -040075 {Opt_subvol, "subvol=%s"},
Christoph Hellwig43e570b2008-06-10 10:40:46 -040076 {Opt_device, "device=%s"},
Chris Masonb6cda9b2007-12-14 15:30:32 -050077 {Opt_nodatasum, "nodatasum"},
Chris Masonbe20aa92007-12-17 20:14:01 -050078 {Opt_nodatacow, "nodatacow"},
Chris Mason21ad10c2008-01-09 09:23:21 -050079 {Opt_nobarrier, "nobarrier"},
Chris Masonc59f8952007-12-17 20:14:04 -050080 {Opt_max_extent, "max_extent=%s"},
Chris Mason6f568d32008-01-29 16:03:38 -050081 {Opt_max_inline, "max_inline=%s"},
Chris Mason8f662a72008-01-02 10:01:11 -050082 {Opt_alloc_start, "alloc_start=%s"},
Chris Mason4543df72008-06-11 21:47:56 -040083 {Opt_thread_pool, "thread_pool=%d"},
Chris Masonc8b97812008-10-29 14:49:59 -040084 {Opt_compress, "compress"},
Chris Masone18e4802008-01-18 10:54:22 -050085 {Opt_ssd, "ssd"},
Josef Bacik33268ea2008-07-24 12:16:36 -040086 {Opt_noacl, "noacl"},
87 {Opt_err, NULL},
Chris Mason95e05282007-08-29 09:11:44 -040088};
89
Chris Masonedbd8d42007-12-21 16:27:24 -050090u64 btrfs_parse_size(char *str)
Chris Masonc59f8952007-12-17 20:14:04 -050091{
Chris Masonedbd8d42007-12-21 16:27:24 -050092 u64 res;
Chris Masonc59f8952007-12-17 20:14:04 -050093 int mult = 1;
94 char *end;
95 char last;
96
97 res = simple_strtoul(str, &end, 10);
98
99 last = end[0];
100 if (isalpha(last)) {
101 last = tolower(last);
102 switch (last) {
103 case 'g':
104 mult *= 1024;
105 case 'm':
106 mult *= 1024;
107 case 'k':
108 mult *= 1024;
109 }
110 res = res * mult;
111 }
112 return res;
113}
114
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400115/*
116 * Regular mount options parser. Everything that is needed only when
117 * reading in a new superblock is parsed here.
118 */
119int btrfs_parse_options(struct btrfs_root *root, char *options)
Chris Mason95e05282007-08-29 09:11:44 -0400120{
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400121 struct btrfs_fs_info *info = root->fs_info;
Chris Mason95e05282007-08-29 09:11:44 -0400122 substring_t args[MAX_OPT_ARGS];
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400123 char *p, *num;
Chris Mason4543df72008-06-11 21:47:56 -0400124 int intarg;
Chris Masonb6cda9b2007-12-14 15:30:32 -0500125
Chris Mason95e05282007-08-29 09:11:44 -0400126 if (!options)
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400127 return 0;
Chris Mason95e05282007-08-29 09:11:44 -0400128
Chris Masonbe20aa92007-12-17 20:14:01 -0500129 /*
130 * strsep changes the string, duplicate it because parse_options
131 * gets called twice
132 */
133 options = kstrdup(options, GFP_NOFS);
134 if (!options)
135 return -ENOMEM;
136
Chris Masonbe20aa92007-12-17 20:14:01 -0500137
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400138 while ((p = strsep(&options, ",")) != NULL) {
Chris Mason95e05282007-08-29 09:11:44 -0400139 int token;
140 if (!*p)
141 continue;
142
143 token = match_token(p, tokens, args);
144 switch (token) {
Chris Masondfe25022008-05-13 13:46:40 -0400145 case Opt_degraded:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400146 printk(KERN_INFO "btrfs: allowing degraded mounts\n");
147 btrfs_set_opt(info->mount_opt, DEGRADED);
Chris Masondfe25022008-05-13 13:46:40 -0400148 break;
Chris Mason95e05282007-08-29 09:11:44 -0400149 case Opt_subvol:
Christoph Hellwig43e570b2008-06-10 10:40:46 -0400150 case Opt_device:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400151 /*
Christoph Hellwig43e570b2008-06-10 10:40:46 -0400152 * These are parsed by btrfs_parse_early_options
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400153 * and can be happily ignored here.
154 */
Chris Masonb6cda9b2007-12-14 15:30:32 -0500155 break;
156 case Opt_nodatasum:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400157 printk(KERN_INFO "btrfs: setting nodatacsum\n");
158 btrfs_set_opt(info->mount_opt, NODATASUM);
Chris Masonbe20aa92007-12-17 20:14:01 -0500159 break;
160 case Opt_nodatacow:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400161 printk(KERN_INFO "btrfs: setting nodatacow\n");
162 btrfs_set_opt(info->mount_opt, NODATACOW);
163 btrfs_set_opt(info->mount_opt, NODATASUM);
Chris Mason95e05282007-08-29 09:11:44 -0400164 break;
Chris Masonc8b97812008-10-29 14:49:59 -0400165 case Opt_compress:
166 printk(KERN_INFO "btrfs: use compression\n");
167 btrfs_set_opt(info->mount_opt, COMPRESS);
168 break;
Chris Masone18e4802008-01-18 10:54:22 -0500169 case Opt_ssd:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400170 printk(KERN_INFO "btrfs: use ssd allocation scheme\n");
171 btrfs_set_opt(info->mount_opt, SSD);
Chris Masone18e4802008-01-18 10:54:22 -0500172 break;
Chris Mason21ad10c2008-01-09 09:23:21 -0500173 case Opt_nobarrier:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400174 printk(KERN_INFO "btrfs: turning off barriers\n");
175 btrfs_set_opt(info->mount_opt, NOBARRIER);
Chris Mason21ad10c2008-01-09 09:23:21 -0500176 break;
Chris Mason4543df72008-06-11 21:47:56 -0400177 case Opt_thread_pool:
178 intarg = 0;
179 match_int(&args[0], &intarg);
180 if (intarg) {
181 info->thread_pool_size = intarg;
182 printk(KERN_INFO "btrfs: thread pool %d\n",
183 info->thread_pool_size);
184 }
185 break;
Chris Masonc59f8952007-12-17 20:14:04 -0500186 case Opt_max_extent:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400187 num = match_strdup(&args[0]);
188 if (num) {
189 info->max_extent = btrfs_parse_size(num);
190 kfree(num);
Chris Masonc59f8952007-12-17 20:14:04 -0500191
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400192 info->max_extent = max_t(u64,
193 info->max_extent, root->sectorsize);
194 printk(KERN_INFO "btrfs: max_extent at %llu\n",
195 info->max_extent);
Chris Masonc59f8952007-12-17 20:14:04 -0500196 }
197 break;
Chris Mason6f568d32008-01-29 16:03:38 -0500198 case Opt_max_inline:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400199 num = match_strdup(&args[0]);
200 if (num) {
201 info->max_inline = btrfs_parse_size(num);
202 kfree(num);
Chris Mason6f568d32008-01-29 16:03:38 -0500203
Chris Mason15ada042008-06-11 16:51:38 -0400204 if (info->max_inline) {
205 info->max_inline = max_t(u64,
206 info->max_inline,
207 root->sectorsize);
208 }
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400209 printk(KERN_INFO "btrfs: max_inline at %llu\n",
210 info->max_inline);
Chris Mason6f568d32008-01-29 16:03:38 -0500211 }
212 break;
Chris Mason8f662a72008-01-02 10:01:11 -0500213 case Opt_alloc_start:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400214 num = match_strdup(&args[0]);
215 if (num) {
216 info->alloc_start = btrfs_parse_size(num);
217 kfree(num);
218 printk(KERN_INFO
219 "btrfs: allocations start at %llu\n",
220 info->alloc_start);
Chris Mason8f662a72008-01-02 10:01:11 -0500221 }
222 break;
Josef Bacik33268ea2008-07-24 12:16:36 -0400223 case Opt_noacl:
224 root->fs_info->sb->s_flags &= ~MS_POSIXACL;
225 break;
Chris Mason95e05282007-08-29 09:11:44 -0400226 default:
Chris Masonbe20aa92007-12-17 20:14:01 -0500227 break;
Chris Mason95e05282007-08-29 09:11:44 -0400228 }
229 }
Chris Masonbe20aa92007-12-17 20:14:01 -0500230 kfree(options);
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400231 return 0;
232}
233
234/*
235 * Parse mount options that are required early in the mount process.
236 *
237 * All other options will be parsed on much later in the mount process and
238 * only when we need to allocate a new super block.
239 */
Christoph Hellwig97288f22008-12-02 06:36:09 -0500240static int btrfs_parse_early_options(const char *options, fmode_t flags,
Christoph Hellwig43e570b2008-06-10 10:40:46 -0400241 void *holder, char **subvol_name,
242 struct btrfs_fs_devices **fs_devices)
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400243{
244 substring_t args[MAX_OPT_ARGS];
245 char *opts, *p;
246 int error = 0;
247
248 if (!options)
249 goto out;
250
251 /*
252 * strsep changes the string, duplicate it because parse_options
253 * gets called twice
254 */
255 opts = kstrdup(options, GFP_KERNEL);
256 if (!opts)
257 return -ENOMEM;
258
259 while ((p = strsep(&opts, ",")) != NULL) {
260 int token;
261 if (!*p)
262 continue;
263
264 token = match_token(p, tokens, args);
265 switch (token) {
266 case Opt_subvol:
267 *subvol_name = match_strdup(&args[0]);
268 break;
Christoph Hellwig43e570b2008-06-10 10:40:46 -0400269 case Opt_device:
270 error = btrfs_scan_one_device(match_strdup(&args[0]),
271 flags, holder, fs_devices);
272 if (error)
273 goto out_free_opts;
274 break;
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400275 default:
276 break;
277 }
278 }
279
Christoph Hellwig43e570b2008-06-10 10:40:46 -0400280 out_free_opts:
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400281 kfree(opts);
282 out:
283 /*
284 * If no subvolume name is specified we use the default one. Allocate
Chris Mason3de45862008-11-17 21:02:50 -0500285 * a copy of the string "." here so that code later in the
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400286 * mount path doesn't care if it's the default volume or another one.
287 */
288 if (!*subvol_name) {
Chris Mason3de45862008-11-17 21:02:50 -0500289 *subvol_name = kstrdup(".", GFP_KERNEL);
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400290 if (!*subvol_name)
291 return -ENOMEM;
292 }
293 return error;
Chris Mason95e05282007-08-29 09:11:44 -0400294}
295
Chris Masond3977122009-01-05 21:25:51 -0500296static int btrfs_fill_super(struct super_block *sb,
Chris Mason8a4b83c2008-03-24 15:02:07 -0400297 struct btrfs_fs_devices *fs_devices,
Chris Masond3977122009-01-05 21:25:51 -0500298 void *data, int silent)
Chris Mason2e635a22007-03-21 11:12:56 -0400299{
Chris Masond3977122009-01-05 21:25:51 -0500300 struct inode *inode;
301 struct dentry *root_dentry;
Chris Masone20d96d2007-03-22 12:13:20 -0400302 struct btrfs_super_block *disk_super;
Chris Mason0f7d52f2007-04-09 10:42:37 -0400303 struct btrfs_root *tree_root;
Chris Masond6e4a422007-04-06 15:37:36 -0400304 struct btrfs_inode *bi;
Chris Mason39279cc2007-06-12 06:35:45 -0400305 int err;
Chris Mason2e635a22007-03-21 11:12:56 -0400306
307 sb->s_maxbytes = MAX_LFS_FILESIZE;
Chris Mason2e635a22007-03-21 11:12:56 -0400308 sb->s_magic = BTRFS_SUPER_MAGIC;
Chris Masone20d96d2007-03-22 12:13:20 -0400309 sb->s_op = &btrfs_super_ops;
Balaji Raobe6e8dc2008-07-21 02:01:56 +0530310 sb->s_export_op = &btrfs_export_ops;
Josef Bacik5103e942007-11-16 11:45:54 -0500311 sb->s_xattr = btrfs_xattr_handlers;
Chris Mason2e635a22007-03-21 11:12:56 -0400312 sb->s_time_gran = 1;
Josef Bacik33268ea2008-07-24 12:16:36 -0400313 sb->s_flags |= MS_POSIXACL;
Chris Masone20d96d2007-03-22 12:13:20 -0400314
Chris Masondfe25022008-05-13 13:46:40 -0400315 tree_root = open_ctree(sb, fs_devices, (char *)data);
Chris Masond98237b2007-03-28 13:57:48 -0400316
Yane58ca022008-04-01 11:21:34 -0400317 if (IS_ERR(tree_root)) {
Chris Masone20d96d2007-03-22 12:13:20 -0400318 printk("btrfs: open_ctree failed\n");
Yane58ca022008-04-01 11:21:34 -0400319 return PTR_ERR(tree_root);
Chris Masone20d96d2007-03-22 12:13:20 -0400320 }
Chris Mason0f7d52f2007-04-09 10:42:37 -0400321 sb->s_fs_info = tree_root;
Chris Mason5f39d392007-10-15 16:14:19 -0400322 disk_super = &tree_root->fs_info->super_copy;
Chris Mason3de45862008-11-17 21:02:50 -0500323 inode = btrfs_iget_locked(sb, BTRFS_FIRST_FREE_OBJECTID,
324 tree_root->fs_info->fs_root);
Chris Masond6e4a422007-04-06 15:37:36 -0400325 bi = BTRFS_I(inode);
326 bi->location.objectid = inode->i_ino;
327 bi->location.offset = 0;
Chris Mason3de45862008-11-17 21:02:50 -0500328 bi->root = tree_root->fs_info->fs_root;
Chris Masonb888db22007-08-27 16:49:44 -0400329
Chris Masond6e4a422007-04-06 15:37:36 -0400330 btrfs_set_key_type(&bi->location, BTRFS_INODE_ITEM_KEY);
331
Chris Mason39279cc2007-06-12 06:35:45 -0400332 if (!inode) {
333 err = -ENOMEM;
334 goto fail_close;
335 }
Chris Masone20d96d2007-03-22 12:13:20 -0400336 if (inode->i_state & I_NEW) {
337 btrfs_read_locked_inode(inode);
338 unlock_new_inode(inode);
339 }
Chris Mason2e635a22007-03-21 11:12:56 -0400340
Chris Masone20d96d2007-03-22 12:13:20 -0400341 root_dentry = d_alloc_root(inode);
342 if (!root_dentry) {
Chris Mason2e635a22007-03-21 11:12:56 -0400343 iput(inode);
Chris Mason39279cc2007-06-12 06:35:45 -0400344 err = -ENOMEM;
345 goto fail_close;
Chris Mason2e635a22007-03-21 11:12:56 -0400346 }
Yan Zhenge4404d62008-12-12 10:03:26 -0500347#if 0
Josef Bacik58176a92007-08-29 15:47:34 -0400348 /* this does the super kobj at the same time */
349 err = btrfs_sysfs_add_super(tree_root->fs_info);
350 if (err)
351 goto fail_close;
Yan Zhenge4404d62008-12-12 10:03:26 -0500352#endif
Josef Bacik58176a92007-08-29 15:47:34 -0400353
Chris Masone20d96d2007-03-22 12:13:20 -0400354 sb->s_root = root_dentry;
Chris Mason6885f302008-02-20 16:11:05 -0500355
Chris Mason6885f302008-02-20 16:11:05 -0500356 save_mount_options(sb, data);
Chris Mason2e635a22007-03-21 11:12:56 -0400357 return 0;
Chris Mason2e635a22007-03-21 11:12:56 -0400358
Chris Mason39279cc2007-06-12 06:35:45 -0400359fail_close:
360 close_ctree(tree_root);
Chris Masond5719762007-03-23 10:01:08 -0400361 return err;
362}
363
Sage Weil6bf13c02008-06-10 10:07:39 -0400364int btrfs_sync_fs(struct super_block *sb, int wait)
Chris Masond5719762007-03-23 10:01:08 -0400365{
366 struct btrfs_trans_handle *trans;
367 struct btrfs_root *root;
368 int ret;
Chris Masond98237b2007-03-28 13:57:48 -0400369 root = btrfs_sb(sb);
Chris Masondf2ce342007-03-23 11:00:45 -0400370
Yan Zhengc146afa2008-11-12 14:34:12 -0500371 if (sb->s_flags & MS_RDONLY)
372 return 0;
373
Chris Masond5719762007-03-23 10:01:08 -0400374 sb->s_dirt = 0;
Chris Masond561c022007-03-23 19:47:49 -0400375 if (!wait) {
Chris Mason7cfcc172007-04-02 14:53:59 -0400376 filemap_flush(root->fs_info->btree_inode->i_mapping);
Chris Masond561c022007-03-23 19:47:49 -0400377 return 0;
378 }
Chris Mason771ed682008-11-06 22:02:51 -0500379
380 btrfs_start_delalloc_inodes(root);
381 btrfs_wait_ordered_extents(root, 0);
382
Chris Masone9d0b132007-08-10 14:06:19 -0400383 btrfs_clean_old_snapshots(root);
Chris Masond5719762007-03-23 10:01:08 -0400384 trans = btrfs_start_transaction(root, 1);
385 ret = btrfs_commit_transaction(trans, root);
386 sb->s_dirt = 0;
Chris Mason54aa1f42007-06-22 14:16:25 -0400387 return ret;
Chris Masond5719762007-03-23 10:01:08 -0400388}
389
Chris Masond561c022007-03-23 19:47:49 -0400390static void btrfs_write_super(struct super_block *sb)
391{
Chris Mason08607c12007-06-08 15:33:54 -0400392 sb->s_dirt = 0;
Chris Masond561c022007-03-23 19:47:49 -0400393}
394
Chris Masona061fc82008-05-07 11:43:44 -0400395static int btrfs_test_super(struct super_block *s, void *data)
Chris Mason2e635a22007-03-21 11:12:56 -0400396{
Chris Masona061fc82008-05-07 11:43:44 -0400397 struct btrfs_fs_devices *test_fs_devices = data;
398 struct btrfs_root *root = btrfs_sb(s);
Yan4b82d6e2007-08-29 09:11:44 -0400399
Chris Masona061fc82008-05-07 11:43:44 -0400400 return root->fs_info->fs_devices == test_fs_devices;
Yan4b82d6e2007-08-29 09:11:44 -0400401}
402
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400403/*
404 * Find a superblock for the given device / mount point.
405 *
406 * Note: This is based on get_sb_bdev from fs/super.c with a few additions
407 * for multiple device setup. Make sure to keep it in sync.
408 */
409static int btrfs_get_sb(struct file_system_type *fs_type, int flags,
410 const char *dev_name, void *data, struct vfsmount *mnt)
Yan4b82d6e2007-08-29 09:11:44 -0400411{
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400412 char *subvol_name = NULL;
Yan4b82d6e2007-08-29 09:11:44 -0400413 struct block_device *bdev = NULL;
414 struct super_block *s;
415 struct dentry *root;
Chris Mason8a4b83c2008-03-24 15:02:07 -0400416 struct btrfs_fs_devices *fs_devices = NULL;
Christoph Hellwig97288f22008-12-02 06:36:09 -0500417 fmode_t mode = FMODE_READ;
Yan4b82d6e2007-08-29 09:11:44 -0400418 int error = 0;
419
Christoph Hellwig97288f22008-12-02 06:36:09 -0500420 if (!(flags & MS_RDONLY))
421 mode |= FMODE_WRITE;
422
423 error = btrfs_parse_early_options(data, mode, fs_type,
Christoph Hellwig43e570b2008-06-10 10:40:46 -0400424 &subvol_name, &fs_devices);
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400425 if (error)
Shen Feng1f483662009-01-05 15:43:42 -0500426 return error;
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400427
Christoph Hellwig97288f22008-12-02 06:36:09 -0500428 error = btrfs_scan_one_device(dev_name, mode, fs_type, &fs_devices);
Chris Mason8a4b83c2008-03-24 15:02:07 -0400429 if (error)
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400430 goto error_free_subvol_name;
Yan4b82d6e2007-08-29 09:11:44 -0400431
Christoph Hellwig97288f22008-12-02 06:36:09 -0500432 error = btrfs_open_devices(fs_devices, mode, fs_type);
Chris Mason8a4b83c2008-03-24 15:02:07 -0400433 if (error)
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400434 goto error_free_subvol_name;
Chris Mason8a4b83c2008-03-24 15:02:07 -0400435
Yan Zheng2b820322008-11-17 21:11:30 -0500436 if (!(flags & MS_RDONLY) && fs_devices->rw_devices == 0) {
437 error = -EACCES;
438 goto error_close_devices;
439 }
440
Chris Masondfe25022008-05-13 13:46:40 -0400441 bdev = fs_devices->latest_bdev;
Chris Masona061fc82008-05-07 11:43:44 -0400442 s = sget(fs_type, btrfs_test_super, set_anon_super, fs_devices);
Yan4b82d6e2007-08-29 09:11:44 -0400443 if (IS_ERR(s))
444 goto error_s;
445
446 if (s->s_root) {
447 if ((flags ^ s->s_flags) & MS_RDONLY) {
448 up_write(&s->s_umount);
449 deactivate_super(s);
450 error = -EBUSY;
Yan Zhengc146afa2008-11-12 14:34:12 -0500451 goto error_close_devices;
Yan4b82d6e2007-08-29 09:11:44 -0400452 }
453
Yan Zheng2b820322008-11-17 21:11:30 -0500454 btrfs_close_devices(fs_devices);
Yan4b82d6e2007-08-29 09:11:44 -0400455 } else {
456 char b[BDEVNAME_SIZE];
457
458 s->s_flags = flags;
459 strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
Chris Mason8a4b83c2008-03-24 15:02:07 -0400460 error = btrfs_fill_super(s, fs_devices, data,
461 flags & MS_SILENT ? 1 : 0);
Yan4b82d6e2007-08-29 09:11:44 -0400462 if (error) {
463 up_write(&s->s_umount);
464 deactivate_super(s);
Shen Feng1f483662009-01-05 15:43:42 -0500465 goto error_free_subvol_name;
Yan4b82d6e2007-08-29 09:11:44 -0400466 }
467
Chris Mason788f20e2008-04-28 15:29:42 -0400468 btrfs_sb(s)->fs_info->bdev_holder = fs_type;
Yan4b82d6e2007-08-29 09:11:44 -0400469 s->s_flags |= MS_ACTIVE;
470 }
471
David Woodhouse76fcef12008-08-19 16:49:35 +0100472 if (!strcmp(subvol_name, "."))
473 root = dget(s->s_root);
474 else {
475 mutex_lock(&s->s_root->d_inode->i_mutex);
Chris Masond3977122009-01-05 21:25:51 -0500476 root = lookup_one_len(subvol_name, s->s_root,
477 strlen(subvol_name));
David Woodhouse76fcef12008-08-19 16:49:35 +0100478 mutex_unlock(&s->s_root->d_inode->i_mutex);
Chris Masond3977122009-01-05 21:25:51 -0500479
David Woodhouse76fcef12008-08-19 16:49:35 +0100480 if (IS_ERR(root)) {
481 up_write(&s->s_umount);
482 deactivate_super(s);
483 error = PTR_ERR(root);
Shen Feng1f483662009-01-05 15:43:42 -0500484 goto error_free_subvol_name;
David Woodhouse76fcef12008-08-19 16:49:35 +0100485 }
486 if (!root->d_inode) {
487 dput(root);
488 up_write(&s->s_umount);
489 deactivate_super(s);
490 error = -ENXIO;
Shen Feng1f483662009-01-05 15:43:42 -0500491 goto error_free_subvol_name;
David Woodhouse76fcef12008-08-19 16:49:35 +0100492 }
Yan4b82d6e2007-08-29 09:11:44 -0400493 }
494
495 mnt->mnt_sb = s;
496 mnt->mnt_root = root;
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400497
498 kfree(subvol_name);
Yan4b82d6e2007-08-29 09:11:44 -0400499 return 0;
500
501error_s:
502 error = PTR_ERR(s);
Yan Zhengc146afa2008-11-12 14:34:12 -0500503error_close_devices:
Chris Mason8a4b83c2008-03-24 15:02:07 -0400504 btrfs_close_devices(fs_devices);
Christoph Hellwigedf24ab2008-06-10 10:40:29 -0400505error_free_subvol_name:
506 kfree(subvol_name);
Yan4b82d6e2007-08-29 09:11:44 -0400507 return error;
508}
Chris Mason2e635a22007-03-21 11:12:56 -0400509
Yan Zhengc146afa2008-11-12 14:34:12 -0500510static int btrfs_remount(struct super_block *sb, int *flags, char *data)
511{
512 struct btrfs_root *root = btrfs_sb(sb);
513 int ret;
514
515 if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
516 return 0;
517
518 if (*flags & MS_RDONLY) {
519 sb->s_flags |= MS_RDONLY;
520
521 ret = btrfs_commit_super(root);
522 WARN_ON(ret);
523 } else {
Yan Zheng2b820322008-11-17 21:11:30 -0500524 if (root->fs_info->fs_devices->rw_devices == 0)
525 return -EACCES;
526
Yan Zhengc146afa2008-11-12 14:34:12 -0500527 if (btrfs_super_log_root(&root->fs_info->super_copy) != 0)
528 return -EINVAL;
529
530 ret = btrfs_cleanup_reloc_trees(root);
531 WARN_ON(ret);
532
533 ret = btrfs_cleanup_fs_roots(root->fs_info);
534 WARN_ON(ret);
535
536 sb->s_flags &= ~MS_RDONLY;
537 }
538
539 return 0;
540}
541
Chris Mason8fd17792007-04-19 21:01:03 -0400542static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
543{
544 struct btrfs_root *root = btrfs_sb(dentry->d_sb);
Chris Mason4b52dff2007-06-26 10:06:50 -0400545 struct btrfs_super_block *disk_super = &root->fs_info->super_copy;
Chris Masondb945352007-10-15 16:15:53 -0400546 int bits = dentry->d_sb->s_blocksize_bits;
David Woodhouse9d036322008-08-18 12:01:52 +0100547 __be32 *fsid = (__be32 *)root->fs_info->fsid;
Chris Mason8fd17792007-04-19 21:01:03 -0400548
549 buf->f_namelen = BTRFS_NAME_LEN;
Chris Masondb945352007-10-15 16:15:53 -0400550 buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
551 buf->f_bfree = buf->f_blocks -
552 (btrfs_super_bytes_used(disk_super) >> bits);
Chris Mason8fd17792007-04-19 21:01:03 -0400553 buf->f_bavail = buf->f_bfree;
554 buf->f_bsize = dentry->d_sb->s_blocksize;
555 buf->f_type = BTRFS_SUPER_MAGIC;
Chris Masond3977122009-01-05 21:25:51 -0500556
David Woodhouse9d036322008-08-18 12:01:52 +0100557 /* We treat it as constant endianness (it doesn't matter _which_)
Chris Masond3977122009-01-05 21:25:51 -0500558 because we want the fsid to come out the same whether mounted
David Woodhouse9d036322008-08-18 12:01:52 +0100559 on a big-endian or little-endian host */
560 buf->f_fsid.val[0] = be32_to_cpu(fsid[0]) ^ be32_to_cpu(fsid[2]);
561 buf->f_fsid.val[1] = be32_to_cpu(fsid[1]) ^ be32_to_cpu(fsid[3]);
David Woodhouse32d48fa2008-08-18 13:10:20 +0100562 /* Mask in the root object ID too, to disambiguate subvols */
563 buf->f_fsid.val[0] ^= BTRFS_I(dentry->d_inode)->root->objectid >> 32;
564 buf->f_fsid.val[1] ^= BTRFS_I(dentry->d_inode)->root->objectid;
565
Chris Mason8fd17792007-04-19 21:01:03 -0400566 return 0;
567}
Chris Masonb5133862007-04-24 11:52:22 -0400568
Chris Mason2e635a22007-03-21 11:12:56 -0400569static struct file_system_type btrfs_fs_type = {
570 .owner = THIS_MODULE,
571 .name = "btrfs",
572 .get_sb = btrfs_get_sb,
Chris Masona061fc82008-05-07 11:43:44 -0400573 .kill_sb = kill_anon_super,
Chris Mason2e635a22007-03-21 11:12:56 -0400574 .fs_flags = FS_REQUIRES_DEV,
575};
Chris Masona9218f62008-03-24 15:02:04 -0400576
Chris Masond352ac62008-09-29 15:18:18 -0400577/*
578 * used by btrfsctl to scan devices when no FS is mounted
579 */
Chris Mason8a4b83c2008-03-24 15:02:07 -0400580static long btrfs_control_ioctl(struct file *file, unsigned int cmd,
581 unsigned long arg)
582{
583 struct btrfs_ioctl_vol_args *vol;
584 struct btrfs_fs_devices *fs_devices;
Linda Knippersf819d832008-06-09 22:17:11 -0400585 int ret = 0;
Chris Mason8a4b83c2008-03-24 15:02:07 -0400586 int len;
587
Chris Masone441d542009-01-05 16:57:23 -0500588 if (!capable(CAP_SYS_ADMIN))
589 return -EPERM;
590
Chris Mason8a4b83c2008-03-24 15:02:07 -0400591 vol = kmalloc(sizeof(*vol), GFP_KERNEL);
592 if (copy_from_user(vol, (void __user *)arg, sizeof(*vol))) {
593 ret = -EFAULT;
594 goto out;
595 }
596 len = strnlen(vol->name, BTRFS_PATH_NAME_MAX);
597 switch (cmd) {
598 case BTRFS_IOC_SCAN_DEV:
Christoph Hellwig97288f22008-12-02 06:36:09 -0500599 ret = btrfs_scan_one_device(vol->name, FMODE_READ,
Chris Mason8a4b83c2008-03-24 15:02:07 -0400600 &btrfs_fs_type, &fs_devices);
601 break;
602 }
603out:
604 kfree(vol);
Linda Knippersf819d832008-06-09 22:17:11 -0400605 return ret;
Chris Mason8a4b83c2008-03-24 15:02:07 -0400606}
607
Linus Torvalds01762602009-01-10 06:09:52 -0800608static int btrfs_freeze(struct super_block *sb)
Yaned0dab62008-01-22 12:46:56 -0500609{
610 struct btrfs_root *root = btrfs_sb(sb);
Chris Masona74a4b92008-06-25 16:01:31 -0400611 mutex_lock(&root->fs_info->transaction_kthread_mutex);
612 mutex_lock(&root->fs_info->cleaner_mutex);
Linus Torvalds01762602009-01-10 06:09:52 -0800613 return 0;
Yaned0dab62008-01-22 12:46:56 -0500614}
615
Linus Torvalds01762602009-01-10 06:09:52 -0800616static int btrfs_unfreeze(struct super_block *sb)
Yaned0dab62008-01-22 12:46:56 -0500617{
618 struct btrfs_root *root = btrfs_sb(sb);
Chris Masona74a4b92008-06-25 16:01:31 -0400619 mutex_unlock(&root->fs_info->cleaner_mutex);
620 mutex_unlock(&root->fs_info->transaction_kthread_mutex);
Linus Torvalds01762602009-01-10 06:09:52 -0800621 return 0;
Yaned0dab62008-01-22 12:46:56 -0500622}
Chris Mason2e635a22007-03-21 11:12:56 -0400623
Chris Masone20d96d2007-03-22 12:13:20 -0400624static struct super_operations btrfs_super_ops = {
Chris Mason134e9732007-03-25 13:44:56 -0400625 .delete_inode = btrfs_delete_inode,
Chris Masone20d96d2007-03-22 12:13:20 -0400626 .put_super = btrfs_put_super,
Chris Masond5719762007-03-23 10:01:08 -0400627 .write_super = btrfs_write_super,
628 .sync_fs = btrfs_sync_fs,
Chris Mason6885f302008-02-20 16:11:05 -0500629 .show_options = generic_show_options,
Chris Mason4730a4b2007-03-26 12:00:39 -0400630 .write_inode = btrfs_write_inode,
Chris Masonb5133862007-04-24 11:52:22 -0400631 .dirty_inode = btrfs_dirty_inode,
Chris Mason2c90e5d2007-04-02 10:50:19 -0400632 .alloc_inode = btrfs_alloc_inode,
633 .destroy_inode = btrfs_destroy_inode,
Chris Mason8fd17792007-04-19 21:01:03 -0400634 .statfs = btrfs_statfs,
Yan Zhengc146afa2008-11-12 14:34:12 -0500635 .remount_fs = btrfs_remount,
Linus Torvalds01762602009-01-10 06:09:52 -0800636 .freeze_fs = btrfs_freeze,
637 .unfreeze_fs = btrfs_unfreeze,
Chris Masone20d96d2007-03-22 12:13:20 -0400638};
Chris Masona9218f62008-03-24 15:02:04 -0400639
640static const struct file_operations btrfs_ctl_fops = {
641 .unlocked_ioctl = btrfs_control_ioctl,
642 .compat_ioctl = btrfs_control_ioctl,
643 .owner = THIS_MODULE,
644};
645
646static struct miscdevice btrfs_misc = {
647 .minor = MISC_DYNAMIC_MINOR,
648 .name = "btrfs-control",
649 .fops = &btrfs_ctl_fops
650};
651
652static int btrfs_interface_init(void)
653{
654 return misc_register(&btrfs_misc);
655}
656
Christoph Hellwigb2950862008-12-02 09:54:17 -0500657static void btrfs_interface_exit(void)
Chris Masona9218f62008-03-24 15:02:04 -0400658{
659 if (misc_deregister(&btrfs_misc) < 0)
Chris Masond3977122009-01-05 21:25:51 -0500660 printk(KERN_INFO "misc_deregister failed for control device");
Chris Masona9218f62008-03-24 15:02:04 -0400661}
662
Chris Mason2e635a22007-03-21 11:12:56 -0400663static int __init init_btrfs_fs(void)
664{
Chris Mason2c90e5d2007-04-02 10:50:19 -0400665 int err;
Josef Bacik58176a92007-08-29 15:47:34 -0400666
667 err = btrfs_init_sysfs();
668 if (err)
669 return err;
670
Chris Mason39279cc2007-06-12 06:35:45 -0400671 err = btrfs_init_cachep();
Chris Mason2c90e5d2007-04-02 10:50:19 -0400672 if (err)
Chris Masona74a4b92008-06-25 16:01:31 -0400673 goto free_sysfs;
Chris Masond1310b22008-01-24 16:13:08 -0500674
675 err = extent_io_init();
Wyatt Banks2f4cbe62007-11-19 10:22:33 -0500676 if (err)
677 goto free_cachep;
678
Chris Masond1310b22008-01-24 16:13:08 -0500679 err = extent_map_init();
680 if (err)
681 goto free_extent_io;
682
Chris Masona9218f62008-03-24 15:02:04 -0400683 err = btrfs_interface_init();
Wyatt Banks2f4cbe62007-11-19 10:22:33 -0500684 if (err)
685 goto free_extent_map;
Chris Masonc8b97812008-10-29 14:49:59 -0400686
Chris Masona9218f62008-03-24 15:02:04 -0400687 err = register_filesystem(&btrfs_fs_type);
688 if (err)
689 goto unregister_ioctl;
Chris Masonb3c3da72008-07-23 12:12:13 -0400690
691 printk(KERN_INFO "%s loaded\n", BTRFS_BUILD_VERSION);
Wyatt Banks2f4cbe62007-11-19 10:22:33 -0500692 return 0;
693
Chris Masona9218f62008-03-24 15:02:04 -0400694unregister_ioctl:
695 btrfs_interface_exit();
Wyatt Banks2f4cbe62007-11-19 10:22:33 -0500696free_extent_map:
697 extent_map_exit();
Chris Masond1310b22008-01-24 16:13:08 -0500698free_extent_io:
699 extent_io_exit();
Wyatt Banks2f4cbe62007-11-19 10:22:33 -0500700free_cachep:
701 btrfs_destroy_cachep();
Chris Masona74a4b92008-06-25 16:01:31 -0400702free_sysfs:
Wyatt Banks2f4cbe62007-11-19 10:22:33 -0500703 btrfs_exit_sysfs();
704 return err;
Chris Mason2e635a22007-03-21 11:12:56 -0400705}
706
707static void __exit exit_btrfs_fs(void)
708{
Chris Mason39279cc2007-06-12 06:35:45 -0400709 btrfs_destroy_cachep();
Chris Masona52d9a82007-08-27 16:49:44 -0400710 extent_map_exit();
Chris Masond1310b22008-01-24 16:13:08 -0500711 extent_io_exit();
Chris Masona9218f62008-03-24 15:02:04 -0400712 btrfs_interface_exit();
Chris Mason2e635a22007-03-21 11:12:56 -0400713 unregister_filesystem(&btrfs_fs_type);
Josef Bacik58176a92007-08-29 15:47:34 -0400714 btrfs_exit_sysfs();
Chris Mason8a4b83c2008-03-24 15:02:07 -0400715 btrfs_cleanup_fs_uuids();
Chris Masonc8b97812008-10-29 14:49:59 -0400716 btrfs_zlib_exit();
Chris Mason2e635a22007-03-21 11:12:56 -0400717}
718
719module_init(init_btrfs_fs)
720module_exit(exit_btrfs_fs)
721
722MODULE_LICENSE("GPL");