2007-06-12 21:07:21 +08:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2007 Oracle. All rights reserved.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public
|
|
|
|
* License v2 as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public
|
|
|
|
* License along with this program; if not, write to the
|
|
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
* Boston, MA 021110-1307, USA.
|
|
|
|
*/
|
|
|
|
|
2007-08-29 21:11:44 +08:00
|
|
|
#include <linux/blkdev.h>
|
2007-03-21 23:12:56 +08:00
|
|
|
#include <linux/module.h>
|
2007-03-23 00:13:20 +08:00
|
|
|
#include <linux/buffer_head.h>
|
2007-03-21 23:12:56 +08:00
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/pagemap.h>
|
|
|
|
#include <linux/highmem.h>
|
|
|
|
#include <linux/time.h>
|
|
|
|
#include <linux/init.h>
|
2009-04-03 04:46:06 +08:00
|
|
|
#include <linux/seq_file.h>
|
2007-03-21 23:12:56 +08:00
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/backing-dev.h>
|
2007-08-29 21:11:44 +08:00
|
|
|
#include <linux/mount.h>
|
2007-03-27 04:00:06 +08:00
|
|
|
#include <linux/mpage.h>
|
2007-03-29 23:56:46 +08:00
|
|
|
#include <linux/swap.h>
|
|
|
|
#include <linux/writeback.h>
|
2007-04-20 09:01:03 +08:00
|
|
|
#include <linux/statfs.h>
|
2007-06-09 03:33:54 +08:00
|
|
|
#include <linux/compat.h>
|
2007-08-29 21:11:44 +08:00
|
|
|
#include <linux/parser.h>
|
2007-12-18 09:14:04 +08:00
|
|
|
#include <linux/ctype.h>
|
2007-12-19 05:15:09 +08:00
|
|
|
#include <linux/namei.h>
|
2008-03-25 03:02:04 +08:00
|
|
|
#include <linux/miscdevice.h>
|
2009-01-16 05:51:03 +08:00
|
|
|
#include <linux/magic.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2008-11-20 23:22:27 +08:00
|
|
|
#include "compat.h"
|
2007-03-21 23:12:56 +08:00
|
|
|
#include "ctree.h"
|
2007-03-23 00:13:20 +08:00
|
|
|
#include "disk-io.h"
|
2007-03-23 22:01:08 +08:00
|
|
|
#include "transaction.h"
|
2007-04-02 22:50:19 +08:00
|
|
|
#include "btrfs_inode.h"
|
2007-04-10 21:27:04 +08:00
|
|
|
#include "ioctl.h"
|
2007-05-25 01:35:57 +08:00
|
|
|
#include "print-tree.h"
|
2007-11-17 00:45:54 +08:00
|
|
|
#include "xattr.h"
|
2008-03-25 03:02:07 +08:00
|
|
|
#include "volumes.h"
|
2008-07-24 00:12:13 +08:00
|
|
|
#include "version.h"
|
2008-07-21 04:31:56 +08:00
|
|
|
#include "export.h"
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-30 02:49:59 +08:00
|
|
|
#include "compression.h"
|
2007-03-21 23:12:56 +08:00
|
|
|
|
2009-09-22 08:01:09 +08:00
|
|
|
static const struct super_operations btrfs_super_ops;
|
2007-03-29 23:56:46 +08:00
|
|
|
|
2009-01-06 10:25:51 +08:00
|
|
|
static void btrfs_put_super(struct super_block *sb)
|
2007-04-18 01:26:50 +08:00
|
|
|
{
|
2007-06-12 18:35:45 +08:00
|
|
|
struct btrfs_root *root = btrfs_sb(sb);
|
2007-04-18 01:26:50 +08:00
|
|
|
int ret;
|
|
|
|
|
2007-06-12 18:35:45 +08:00
|
|
|
ret = close_ctree(root);
|
|
|
|
sb->s_fs_info = NULL;
|
2010-10-30 03:14:37 +08:00
|
|
|
|
|
|
|
(void)ret; /* FIXME: need to fix VFS to return error? */
|
2007-03-29 23:56:46 +08:00
|
|
|
}
|
|
|
|
|
2007-08-29 21:11:44 +08:00
|
|
|
enum {
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
Opt_degraded, Opt_subvol, Opt_subvolid, Opt_device, Opt_nodatasum,
|
2010-03-20 02:07:23 +08:00
|
|
|
Opt_nodatacow, Opt_max_inline, Opt_alloc_start, Opt_nobarrier, Opt_ssd,
|
|
|
|
Opt_nossd, Opt_ssd_spread, Opt_thread_pool, Opt_noacl, Opt_compress,
|
|
|
|
Opt_compress_force, Opt_notreelog, Opt_ratio, Opt_flushoncommit,
|
2010-09-22 02:21:34 +08:00
|
|
|
Opt_discard, Opt_space_cache, Opt_clear_cache, Opt_err,
|
2010-10-30 03:46:43 +08:00
|
|
|
Opt_user_subvol_rm_allowed,
|
2007-08-29 21:11:44 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static match_table_t tokens = {
|
2008-05-14 01:46:40 +08:00
|
|
|
{Opt_degraded, "degraded"},
|
2007-08-29 21:11:44 +08:00
|
|
|
{Opt_subvol, "subvol=%s"},
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
{Opt_subvolid, "subvolid=%d"},
|
2008-06-10 22:40:46 +08:00
|
|
|
{Opt_device, "device=%s"},
|
2007-12-15 04:30:32 +08:00
|
|
|
{Opt_nodatasum, "nodatasum"},
|
2007-12-18 09:14:01 +08:00
|
|
|
{Opt_nodatacow, "nodatacow"},
|
2008-01-09 22:23:21 +08:00
|
|
|
{Opt_nobarrier, "nobarrier"},
|
2008-01-30 05:03:38 +08:00
|
|
|
{Opt_max_inline, "max_inline=%s"},
|
2008-01-02 23:01:11 +08:00
|
|
|
{Opt_alloc_start, "alloc_start=%s"},
|
2008-06-12 09:47:56 +08:00
|
|
|
{Opt_thread_pool, "thread_pool=%d"},
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-30 02:49:59 +08:00
|
|
|
{Opt_compress, "compress"},
|
2010-01-29 05:18:15 +08:00
|
|
|
{Opt_compress_force, "compress-force"},
|
2008-01-18 23:54:22 +08:00
|
|
|
{Opt_ssd, "ssd"},
|
2009-06-10 08:28:34 +08:00
|
|
|
{Opt_ssd_spread, "ssd_spread"},
|
2009-06-10 04:42:22 +08:00
|
|
|
{Opt_nossd, "nossd"},
|
2008-07-25 00:16:36 +08:00
|
|
|
{Opt_noacl, "noacl"},
|
2009-04-03 04:49:40 +08:00
|
|
|
{Opt_notreelog, "notreelog"},
|
2009-04-03 04:59:01 +08:00
|
|
|
{Opt_flushoncommit, "flushoncommit"},
|
2009-04-22 05:40:57 +08:00
|
|
|
{Opt_ratio, "metadata_ratio=%d"},
|
2009-10-14 21:24:59 +08:00
|
|
|
{Opt_discard, "discard"},
|
2010-06-22 02:48:16 +08:00
|
|
|
{Opt_space_cache, "space_cache"},
|
2010-09-22 02:21:34 +08:00
|
|
|
{Opt_clear_cache, "clear_cache"},
|
2010-10-30 03:46:43 +08:00
|
|
|
{Opt_user_subvol_rm_allowed, "user_subvol_rm_allowed"},
|
2008-07-25 00:16:36 +08:00
|
|
|
{Opt_err, NULL},
|
2007-08-29 21:11:44 +08:00
|
|
|
};
|
|
|
|
|
2008-06-10 22:40:29 +08:00
|
|
|
/*
|
|
|
|
* Regular mount options parser. Everything that is needed only when
|
|
|
|
* reading in a new superblock is parsed here.
|
|
|
|
*/
|
|
|
|
int btrfs_parse_options(struct btrfs_root *root, char *options)
|
2007-08-29 21:11:44 +08:00
|
|
|
{
|
2008-06-10 22:40:29 +08:00
|
|
|
struct btrfs_fs_info *info = root->fs_info;
|
2007-08-29 21:11:44 +08:00
|
|
|
substring_t args[MAX_OPT_ARGS];
|
2010-02-26 04:38:35 +08:00
|
|
|
char *p, *num, *orig;
|
2008-06-12 09:47:56 +08:00
|
|
|
int intarg;
|
2009-11-07 14:19:16 +08:00
|
|
|
int ret = 0;
|
2007-12-15 04:30:32 +08:00
|
|
|
|
2007-08-29 21:11:44 +08:00
|
|
|
if (!options)
|
2008-06-10 22:40:29 +08:00
|
|
|
return 0;
|
2007-08-29 21:11:44 +08:00
|
|
|
|
2007-12-18 09:14:01 +08:00
|
|
|
/*
|
|
|
|
* strsep changes the string, duplicate it because parse_options
|
|
|
|
* gets called twice
|
|
|
|
*/
|
|
|
|
options = kstrdup(options, GFP_NOFS);
|
|
|
|
if (!options)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2010-02-26 04:38:35 +08:00
|
|
|
orig = options;
|
2007-12-18 09:14:01 +08:00
|
|
|
|
2008-06-10 22:40:29 +08:00
|
|
|
while ((p = strsep(&options, ",")) != NULL) {
|
2007-08-29 21:11:44 +08:00
|
|
|
int token;
|
|
|
|
if (!*p)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
token = match_token(p, tokens, args);
|
|
|
|
switch (token) {
|
2008-05-14 01:46:40 +08:00
|
|
|
case Opt_degraded:
|
2008-06-10 22:40:29 +08:00
|
|
|
printk(KERN_INFO "btrfs: allowing degraded mounts\n");
|
|
|
|
btrfs_set_opt(info->mount_opt, DEGRADED);
|
2008-05-14 01:46:40 +08:00
|
|
|
break;
|
2007-08-29 21:11:44 +08:00
|
|
|
case Opt_subvol:
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
case Opt_subvolid:
|
2008-06-10 22:40:46 +08:00
|
|
|
case Opt_device:
|
2008-06-10 22:40:29 +08:00
|
|
|
/*
|
2008-06-10 22:40:46 +08:00
|
|
|
* These are parsed by btrfs_parse_early_options
|
2008-06-10 22:40:29 +08:00
|
|
|
* and can be happily ignored here.
|
|
|
|
*/
|
2007-12-15 04:30:32 +08:00
|
|
|
break;
|
|
|
|
case Opt_nodatasum:
|
2009-06-11 21:30:13 +08:00
|
|
|
printk(KERN_INFO "btrfs: setting nodatasum\n");
|
2008-06-10 22:40:29 +08:00
|
|
|
btrfs_set_opt(info->mount_opt, NODATASUM);
|
2007-12-18 09:14:01 +08:00
|
|
|
break;
|
|
|
|
case Opt_nodatacow:
|
2008-06-10 22:40:29 +08:00
|
|
|
printk(KERN_INFO "btrfs: setting nodatacow\n");
|
|
|
|
btrfs_set_opt(info->mount_opt, NODATACOW);
|
|
|
|
btrfs_set_opt(info->mount_opt, NODATASUM);
|
2007-08-29 21:11:44 +08:00
|
|
|
break;
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-30 02:49:59 +08:00
|
|
|
case Opt_compress:
|
|
|
|
printk(KERN_INFO "btrfs: use compression\n");
|
|
|
|
btrfs_set_opt(info->mount_opt, COMPRESS);
|
|
|
|
break;
|
2010-01-29 05:18:15 +08:00
|
|
|
case Opt_compress_force:
|
|
|
|
printk(KERN_INFO "btrfs: forcing compression\n");
|
|
|
|
btrfs_set_opt(info->mount_opt, FORCE_COMPRESS);
|
|
|
|
btrfs_set_opt(info->mount_opt, COMPRESS);
|
|
|
|
break;
|
2008-01-18 23:54:22 +08:00
|
|
|
case Opt_ssd:
|
2008-06-10 22:40:29 +08:00
|
|
|
printk(KERN_INFO "btrfs: use ssd allocation scheme\n");
|
|
|
|
btrfs_set_opt(info->mount_opt, SSD);
|
2008-01-18 23:54:22 +08:00
|
|
|
break;
|
2009-06-10 08:28:34 +08:00
|
|
|
case Opt_ssd_spread:
|
|
|
|
printk(KERN_INFO "btrfs: use spread ssd "
|
|
|
|
"allocation scheme\n");
|
|
|
|
btrfs_set_opt(info->mount_opt, SSD);
|
|
|
|
btrfs_set_opt(info->mount_opt, SSD_SPREAD);
|
|
|
|
break;
|
2009-06-10 04:42:22 +08:00
|
|
|
case Opt_nossd:
|
2009-06-10 08:28:34 +08:00
|
|
|
printk(KERN_INFO "btrfs: not using ssd allocation "
|
|
|
|
"scheme\n");
|
2009-06-10 21:51:32 +08:00
|
|
|
btrfs_set_opt(info->mount_opt, NOSSD);
|
2009-06-10 04:42:22 +08:00
|
|
|
btrfs_clear_opt(info->mount_opt, SSD);
|
2009-06-10 08:28:34 +08:00
|
|
|
btrfs_clear_opt(info->mount_opt, SSD_SPREAD);
|
2009-06-10 04:42:22 +08:00
|
|
|
break;
|
2008-01-09 22:23:21 +08:00
|
|
|
case Opt_nobarrier:
|
2008-06-10 22:40:29 +08:00
|
|
|
printk(KERN_INFO "btrfs: turning off barriers\n");
|
|
|
|
btrfs_set_opt(info->mount_opt, NOBARRIER);
|
2008-01-09 22:23:21 +08:00
|
|
|
break;
|
2008-06-12 09:47:56 +08:00
|
|
|
case Opt_thread_pool:
|
|
|
|
intarg = 0;
|
|
|
|
match_int(&args[0], &intarg);
|
|
|
|
if (intarg) {
|
|
|
|
info->thread_pool_size = intarg;
|
|
|
|
printk(KERN_INFO "btrfs: thread pool %d\n",
|
|
|
|
info->thread_pool_size);
|
|
|
|
}
|
|
|
|
break;
|
2008-01-30 05:03:38 +08:00
|
|
|
case Opt_max_inline:
|
2008-06-10 22:40:29 +08:00
|
|
|
num = match_strdup(&args[0]);
|
|
|
|
if (num) {
|
2010-02-28 18:59:11 +08:00
|
|
|
info->max_inline = memparse(num, NULL);
|
2008-06-10 22:40:29 +08:00
|
|
|
kfree(num);
|
|
|
|
|
2008-06-12 04:51:38 +08:00
|
|
|
if (info->max_inline) {
|
|
|
|
info->max_inline = max_t(u64,
|
|
|
|
info->max_inline,
|
|
|
|
root->sectorsize);
|
|
|
|
}
|
2008-06-10 22:40:29 +08:00
|
|
|
printk(KERN_INFO "btrfs: max_inline at %llu\n",
|
2009-04-22 03:38:29 +08:00
|
|
|
(unsigned long long)info->max_inline);
|
2008-01-30 05:03:38 +08:00
|
|
|
}
|
|
|
|
break;
|
2008-01-02 23:01:11 +08:00
|
|
|
case Opt_alloc_start:
|
2008-06-10 22:40:29 +08:00
|
|
|
num = match_strdup(&args[0]);
|
|
|
|
if (num) {
|
2010-02-28 18:59:11 +08:00
|
|
|
info->alloc_start = memparse(num, NULL);
|
2008-06-10 22:40:29 +08:00
|
|
|
kfree(num);
|
|
|
|
printk(KERN_INFO
|
|
|
|
"btrfs: allocations start at %llu\n",
|
2009-04-22 03:38:29 +08:00
|
|
|
(unsigned long long)info->alloc_start);
|
2008-01-02 23:01:11 +08:00
|
|
|
}
|
|
|
|
break;
|
2008-07-25 00:16:36 +08:00
|
|
|
case Opt_noacl:
|
|
|
|
root->fs_info->sb->s_flags &= ~MS_POSIXACL;
|
|
|
|
break;
|
2009-04-03 04:49:40 +08:00
|
|
|
case Opt_notreelog:
|
|
|
|
printk(KERN_INFO "btrfs: disabling tree log\n");
|
|
|
|
btrfs_set_opt(info->mount_opt, NOTREELOG);
|
|
|
|
break;
|
2009-04-03 04:59:01 +08:00
|
|
|
case Opt_flushoncommit:
|
|
|
|
printk(KERN_INFO "btrfs: turning on flush-on-commit\n");
|
|
|
|
btrfs_set_opt(info->mount_opt, FLUSHONCOMMIT);
|
|
|
|
break;
|
2009-04-22 05:40:57 +08:00
|
|
|
case Opt_ratio:
|
|
|
|
intarg = 0;
|
|
|
|
match_int(&args[0], &intarg);
|
|
|
|
if (intarg) {
|
|
|
|
info->metadata_ratio = intarg;
|
|
|
|
printk(KERN_INFO "btrfs: metadata ratio %d\n",
|
|
|
|
info->metadata_ratio);
|
|
|
|
}
|
|
|
|
break;
|
2009-10-14 21:24:59 +08:00
|
|
|
case Opt_discard:
|
|
|
|
btrfs_set_opt(info->mount_opt, DISCARD);
|
|
|
|
break;
|
2010-06-22 02:48:16 +08:00
|
|
|
case Opt_space_cache:
|
|
|
|
printk(KERN_INFO "btrfs: enabling disk space caching\n");
|
|
|
|
btrfs_set_opt(info->mount_opt, SPACE_CACHE);
|
2010-11-19 21:40:41 +08:00
|
|
|
break;
|
2010-09-22 02:21:34 +08:00
|
|
|
case Opt_clear_cache:
|
|
|
|
printk(KERN_INFO "btrfs: force clearing of disk cache\n");
|
|
|
|
btrfs_set_opt(info->mount_opt, CLEAR_CACHE);
|
2010-06-22 02:48:16 +08:00
|
|
|
break;
|
2010-10-30 03:46:43 +08:00
|
|
|
case Opt_user_subvol_rm_allowed:
|
|
|
|
btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED);
|
|
|
|
break;
|
2009-11-07 14:19:16 +08:00
|
|
|
case Opt_err:
|
|
|
|
printk(KERN_INFO "btrfs: unrecognized mount option "
|
|
|
|
"'%s'\n", p);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
2007-08-29 21:11:44 +08:00
|
|
|
default:
|
2007-12-18 09:14:01 +08:00
|
|
|
break;
|
2007-08-29 21:11:44 +08:00
|
|
|
}
|
|
|
|
}
|
2009-11-07 14:19:16 +08:00
|
|
|
out:
|
2010-02-26 04:38:35 +08:00
|
|
|
kfree(orig);
|
2009-11-07 14:19:16 +08:00
|
|
|
return ret;
|
2008-06-10 22:40:29 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Parse mount options that are required early in the mount process.
|
|
|
|
*
|
|
|
|
* All other options will be parsed on much later in the mount process and
|
|
|
|
* only when we need to allocate a new super block.
|
|
|
|
*/
|
2008-12-02 19:36:09 +08:00
|
|
|
static int btrfs_parse_early_options(const char *options, fmode_t flags,
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
void *holder, char **subvol_name, u64 *subvol_objectid,
|
2008-06-10 22:40:46 +08:00
|
|
|
struct btrfs_fs_devices **fs_devices)
|
2008-06-10 22:40:29 +08:00
|
|
|
{
|
|
|
|
substring_t args[MAX_OPT_ARGS];
|
|
|
|
char *opts, *p;
|
|
|
|
int error = 0;
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
int intarg;
|
2008-06-10 22:40:29 +08:00
|
|
|
|
|
|
|
if (!options)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* strsep changes the string, duplicate it because parse_options
|
|
|
|
* gets called twice
|
|
|
|
*/
|
|
|
|
opts = kstrdup(options, GFP_KERNEL);
|
|
|
|
if (!opts)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
while ((p = strsep(&opts, ",")) != NULL) {
|
|
|
|
int token;
|
|
|
|
if (!*p)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
token = match_token(p, tokens, args);
|
|
|
|
switch (token) {
|
|
|
|
case Opt_subvol:
|
|
|
|
*subvol_name = match_strdup(&args[0]);
|
|
|
|
break;
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
case Opt_subvolid:
|
|
|
|
intarg = 0;
|
2009-12-15 03:18:38 +08:00
|
|
|
error = match_int(&args[0], &intarg);
|
|
|
|
if (!error) {
|
|
|
|
/* we want the original fs_tree */
|
|
|
|
if (!intarg)
|
|
|
|
*subvol_objectid =
|
|
|
|
BTRFS_FS_TREE_OBJECTID;
|
|
|
|
else
|
|
|
|
*subvol_objectid = intarg;
|
|
|
|
}
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
break;
|
2008-06-10 22:40:46 +08:00
|
|
|
case Opt_device:
|
|
|
|
error = btrfs_scan_one_device(match_strdup(&args[0]),
|
|
|
|
flags, holder, fs_devices);
|
|
|
|
if (error)
|
|
|
|
goto out_free_opts;
|
|
|
|
break;
|
2008-06-10 22:40:29 +08:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-06-10 22:40:46 +08:00
|
|
|
out_free_opts:
|
2008-06-10 22:40:29 +08:00
|
|
|
kfree(opts);
|
|
|
|
out:
|
|
|
|
/*
|
|
|
|
* If no subvolume name is specified we use the default one. Allocate
|
2008-11-18 10:02:50 +08:00
|
|
|
* a copy of the string "." here so that code later in the
|
2008-06-10 22:40:29 +08:00
|
|
|
* mount path doesn't care if it's the default volume or another one.
|
|
|
|
*/
|
|
|
|
if (!*subvol_name) {
|
2008-11-18 10:02:50 +08:00
|
|
|
*subvol_name = kstrdup(".", GFP_KERNEL);
|
2008-06-10 22:40:29 +08:00
|
|
|
if (!*subvol_name)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
return error;
|
2007-08-29 21:11:44 +08:00
|
|
|
}
|
|
|
|
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
static struct dentry *get_default_root(struct super_block *sb,
|
|
|
|
u64 subvol_objectid)
|
|
|
|
{
|
|
|
|
struct btrfs_root *root = sb->s_fs_info;
|
|
|
|
struct btrfs_root *new_root;
|
|
|
|
struct btrfs_dir_item *di;
|
|
|
|
struct btrfs_path *path;
|
|
|
|
struct btrfs_key location;
|
|
|
|
struct inode *inode;
|
|
|
|
struct dentry *dentry;
|
|
|
|
u64 dir_id;
|
|
|
|
int new = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We have a specific subvol we want to mount, just setup location and
|
|
|
|
* go look up the root.
|
|
|
|
*/
|
|
|
|
if (subvol_objectid) {
|
|
|
|
location.objectid = subvol_objectid;
|
|
|
|
location.type = BTRFS_ROOT_ITEM_KEY;
|
|
|
|
location.offset = (u64)-1;
|
|
|
|
goto find_root;
|
|
|
|
}
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
path->leave_spinning = 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the "default" dir item which points to the root item that we
|
|
|
|
* will mount by default if we haven't been given a specific subvolume
|
|
|
|
* to mount.
|
|
|
|
*/
|
|
|
|
dir_id = btrfs_super_root_dir(&root->fs_info->super_copy);
|
|
|
|
di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);
|
2010-05-29 17:40:57 +08:00
|
|
|
if (IS_ERR(di))
|
|
|
|
return ERR_CAST(di);
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
if (!di) {
|
|
|
|
/*
|
|
|
|
* Ok the default dir item isn't there. This is weird since
|
|
|
|
* it's always been there, but don't freak out, just try and
|
|
|
|
* mount to root most subvolume.
|
|
|
|
*/
|
|
|
|
btrfs_free_path(path);
|
|
|
|
dir_id = BTRFS_FIRST_FREE_OBJECTID;
|
|
|
|
new_root = root->fs_info->fs_root;
|
|
|
|
goto setup_root;
|
|
|
|
}
|
|
|
|
|
|
|
|
btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
|
|
|
|
btrfs_free_path(path);
|
|
|
|
|
|
|
|
find_root:
|
|
|
|
new_root = btrfs_read_fs_root_no_name(root->fs_info, &location);
|
|
|
|
if (IS_ERR(new_root))
|
2010-10-30 03:14:23 +08:00
|
|
|
return ERR_CAST(new_root);
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
|
|
|
|
if (btrfs_root_refs(&new_root->root_item) == 0)
|
|
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
|
|
|
|
dir_id = btrfs_root_dirid(&new_root->root_item);
|
|
|
|
setup_root:
|
|
|
|
location.objectid = dir_id;
|
|
|
|
location.type = BTRFS_INODE_ITEM_KEY;
|
|
|
|
location.offset = 0;
|
|
|
|
|
|
|
|
inode = btrfs_iget(sb, &location, new_root, &new);
|
2010-05-29 17:42:19 +08:00
|
|
|
if (IS_ERR(inode))
|
|
|
|
return ERR_CAST(inode);
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we're just mounting the root most subvol put the inode and return
|
|
|
|
* a reference to the dentry. We will have already gotten a reference
|
|
|
|
* to the inode in btrfs_fill_super so we're good to go.
|
|
|
|
*/
|
|
|
|
if (!new && sb->s_root->d_inode == inode) {
|
|
|
|
iput(inode);
|
|
|
|
return dget(sb->s_root);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (new) {
|
|
|
|
const struct qstr name = { .name = "/", .len = 1 };
|
|
|
|
|
|
|
|
/*
|
|
|
|
* New inode, we need to make the dentry a sibling of s_root so
|
|
|
|
* everything gets cleaned up properly on unmount.
|
|
|
|
*/
|
|
|
|
dentry = d_alloc(sb->s_root, &name);
|
|
|
|
if (!dentry) {
|
|
|
|
iput(inode);
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
}
|
|
|
|
d_splice_alias(inode, dentry);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* We found the inode in cache, just find a dentry for it and
|
|
|
|
* put the reference to the inode we just got.
|
|
|
|
*/
|
|
|
|
dentry = d_find_alias(inode);
|
|
|
|
iput(inode);
|
|
|
|
}
|
|
|
|
|
|
|
|
return dentry;
|
|
|
|
}
|
|
|
|
|
2009-01-06 10:25:51 +08:00
|
|
|
static int btrfs_fill_super(struct super_block *sb,
|
2008-03-25 03:02:07 +08:00
|
|
|
struct btrfs_fs_devices *fs_devices,
|
2009-01-06 10:25:51 +08:00
|
|
|
void *data, int silent)
|
2007-03-29 23:56:46 +08:00
|
|
|
{
|
2009-01-06 10:25:51 +08:00
|
|
|
struct inode *inode;
|
|
|
|
struct dentry *root_dentry;
|
2007-06-12 18:35:45 +08:00
|
|
|
struct btrfs_root *tree_root;
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 22:45:14 +08:00
|
|
|
struct btrfs_key key;
|
2007-06-12 18:35:45 +08:00
|
|
|
int err;
|
2007-04-19 04:15:28 +08:00
|
|
|
|
2007-06-12 18:35:45 +08:00
|
|
|
sb->s_maxbytes = MAX_LFS_FILESIZE;
|
|
|
|
sb->s_magic = BTRFS_SUPER_MAGIC;
|
|
|
|
sb->s_op = &btrfs_super_ops;
|
2008-07-21 04:31:56 +08:00
|
|
|
sb->s_export_op = &btrfs_export_ops;
|
2007-11-17 00:45:54 +08:00
|
|
|
sb->s_xattr = btrfs_xattr_handlers;
|
2007-06-12 18:35:45 +08:00
|
|
|
sb->s_time_gran = 1;
|
2009-10-14 01:50:18 +08:00
|
|
|
#ifdef CONFIG_BTRFS_FS_POSIX_ACL
|
2008-07-25 00:16:36 +08:00
|
|
|
sb->s_flags |= MS_POSIXACL;
|
2009-09-30 01:51:04 +08:00
|
|
|
#endif
|
2007-04-19 04:15:28 +08:00
|
|
|
|
2008-05-14 01:46:40 +08:00
|
|
|
tree_root = open_ctree(sb, fs_devices, (char *)data);
|
2007-04-16 21:22:45 +08:00
|
|
|
|
2008-04-01 23:21:34 +08:00
|
|
|
if (IS_ERR(tree_root)) {
|
2007-06-12 18:35:45 +08:00
|
|
|
printk("btrfs: open_ctree failed\n");
|
2008-04-01 23:21:34 +08:00
|
|
|
return PTR_ERR(tree_root);
|
2007-04-19 04:15:28 +08:00
|
|
|
}
|
2007-06-12 18:35:45 +08:00
|
|
|
sb->s_fs_info = tree_root;
|
2007-04-19 04:15:28 +08:00
|
|
|
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 22:45:14 +08:00
|
|
|
key.objectid = BTRFS_FIRST_FREE_OBJECTID;
|
|
|
|
key.type = BTRFS_INODE_ITEM_KEY;
|
|
|
|
key.offset = 0;
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
inode = btrfs_iget(sb, &key, tree_root->fs_info->fs_root, NULL);
|
Btrfs: Mixed back reference (FORWARD ROLLING FORMAT CHANGE)
This commit introduces a new kind of back reference for btrfs metadata.
Once a filesystem has been mounted with this commit, IT WILL NO LONGER
BE MOUNTABLE BY OLDER KERNELS.
When a tree block in subvolume tree is cow'd, the reference counts of all
extents it points to are increased by one. At transaction commit time,
the old root of the subvolume is recorded in a "dead root" data structure,
and the btree it points to is later walked, dropping reference counts
and freeing any blocks where the reference count goes to 0.
The increments done during cow and decrements done after commit cancel out,
and the walk is a very expensive way to go about freeing the blocks that
are no longer referenced by the new btree root. This commit reduces the
transaction overhead by avoiding the need for dead root records.
When a non-shared tree block is cow'd, we free the old block at once, and the
new block inherits old block's references. When a tree block with reference
count > 1 is cow'd, we increase the reference counts of all extents
the new block points to by one, and decrease the old block's reference count by
one.
This dead tree avoidance code removes the need to modify the reference
counts of lower level extents when a non-shared tree block is cow'd.
But we still need to update back ref for all pointers in the block.
This is because the location of the block is recorded in the back ref
item.
We can solve this by introducing a new type of back ref. The new
back ref provides information about pointer's key, level and in which
tree the pointer lives. This information allow us to find the pointer
by searching the tree. The shortcoming of the new back ref is that it
only works for pointers in tree blocks referenced by their owner trees.
This is mostly a problem for snapshots, where resolving one of these
fuzzy back references would be O(number_of_snapshots) and quite slow.
The solution used here is to use the fuzzy back references in the common
case where a given tree block is only referenced by one root,
and use the full back references when multiple roots have a reference
on a given block.
This commit adds per subvolume red-black tree to keep trace of cached
inodes. The red-black tree helps the balancing code to find cached
inodes whose inode numbers within a given range.
This commit improves the balancing code by introducing several data
structures to keep the state of balancing. The most important one
is the back ref cache. It caches how the upper level tree blocks are
referenced. This greatly reduce the overhead of checking back ref.
The improved balancing code scales significantly better with a large
number of snapshots.
This is a very large commit and was written in a number of
pieces. But, they depend heavily on the disk format change and were
squashed together to make sure git bisect didn't end up in a
bad state wrt space balancing or the format change.
Signed-off-by: Yan Zheng <zheng.yan@oracle.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-06-10 22:45:14 +08:00
|
|
|
if (IS_ERR(inode)) {
|
|
|
|
err = PTR_ERR(inode);
|
2007-06-12 18:35:45 +08:00
|
|
|
goto fail_close;
|
2007-03-30 03:15:27 +08:00
|
|
|
}
|
|
|
|
|
2007-06-12 18:35:45 +08:00
|
|
|
root_dentry = d_alloc_root(inode);
|
|
|
|
if (!root_dentry) {
|
|
|
|
iput(inode);
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto fail_close;
|
2007-03-30 03:15:27 +08:00
|
|
|
}
|
2007-08-30 03:47:34 +08:00
|
|
|
|
2007-06-12 18:35:45 +08:00
|
|
|
sb->s_root = root_dentry;
|
2008-02-21 05:11:05 +08:00
|
|
|
|
|
|
|
save_mount_options(sb, data);
|
2007-04-11 04:58:11 +08:00
|
|
|
return 0;
|
2007-06-12 18:35:45 +08:00
|
|
|
|
|
|
|
fail_close:
|
|
|
|
close_ctree(tree_root);
|
|
|
|
return err;
|
2007-04-11 04:58:11 +08:00
|
|
|
}
|
|
|
|
|
2008-06-10 22:07:39 +08:00
|
|
|
int btrfs_sync_fs(struct super_block *sb, int wait)
|
2007-04-10 21:27:04 +08:00
|
|
|
{
|
|
|
|
struct btrfs_trans_handle *trans;
|
2009-04-03 04:59:01 +08:00
|
|
|
struct btrfs_root *root = btrfs_sb(sb);
|
2007-04-10 21:27:04 +08:00
|
|
|
int ret;
|
2007-04-11 04:58:11 +08:00
|
|
|
|
2007-06-12 18:35:45 +08:00
|
|
|
if (!wait) {
|
|
|
|
filemap_flush(root->fs_info->btree_inode->i_mapping);
|
|
|
|
return 0;
|
|
|
|
}
|
2008-11-07 11:02:51 +08:00
|
|
|
|
2009-11-12 17:36:34 +08:00
|
|
|
btrfs_start_delalloc_inodes(root, 0);
|
|
|
|
btrfs_wait_ordered_extents(root, 0, 0);
|
2008-11-07 11:02:51 +08:00
|
|
|
|
2010-05-16 22:48:46 +08:00
|
|
|
trans = btrfs_start_transaction(root, 0);
|
2007-04-10 21:27:04 +08:00
|
|
|
ret = btrfs_commit_transaction(trans, root);
|
2007-06-23 02:16:25 +08:00
|
|
|
return ret;
|
2007-04-02 22:50:19 +08:00
|
|
|
}
|
|
|
|
|
2009-04-03 04:46:06 +08:00
|
|
|
static int btrfs_show_options(struct seq_file *seq, struct vfsmount *vfs)
|
|
|
|
{
|
|
|
|
struct btrfs_root *root = btrfs_sb(vfs->mnt_sb);
|
|
|
|
struct btrfs_fs_info *info = root->fs_info;
|
|
|
|
|
|
|
|
if (btrfs_test_opt(root, DEGRADED))
|
|
|
|
seq_puts(seq, ",degraded");
|
|
|
|
if (btrfs_test_opt(root, NODATASUM))
|
|
|
|
seq_puts(seq, ",nodatasum");
|
|
|
|
if (btrfs_test_opt(root, NODATACOW))
|
|
|
|
seq_puts(seq, ",nodatacow");
|
|
|
|
if (btrfs_test_opt(root, NOBARRIER))
|
|
|
|
seq_puts(seq, ",nobarrier");
|
|
|
|
if (info->max_inline != 8192 * 1024)
|
2009-04-22 03:38:29 +08:00
|
|
|
seq_printf(seq, ",max_inline=%llu",
|
|
|
|
(unsigned long long)info->max_inline);
|
2009-04-03 04:46:06 +08:00
|
|
|
if (info->alloc_start != 0)
|
2009-04-22 03:38:29 +08:00
|
|
|
seq_printf(seq, ",alloc_start=%llu",
|
|
|
|
(unsigned long long)info->alloc_start);
|
2009-04-03 04:46:06 +08:00
|
|
|
if (info->thread_pool_size != min_t(unsigned long,
|
|
|
|
num_online_cpus() + 2, 8))
|
|
|
|
seq_printf(seq, ",thread_pool=%d", info->thread_pool_size);
|
|
|
|
if (btrfs_test_opt(root, COMPRESS))
|
|
|
|
seq_puts(seq, ",compress");
|
2009-06-10 21:51:32 +08:00
|
|
|
if (btrfs_test_opt(root, NOSSD))
|
|
|
|
seq_puts(seq, ",nossd");
|
2009-06-10 08:28:34 +08:00
|
|
|
if (btrfs_test_opt(root, SSD_SPREAD))
|
|
|
|
seq_puts(seq, ",ssd_spread");
|
|
|
|
else if (btrfs_test_opt(root, SSD))
|
2009-04-03 04:46:06 +08:00
|
|
|
seq_puts(seq, ",ssd");
|
2009-04-03 04:49:40 +08:00
|
|
|
if (btrfs_test_opt(root, NOTREELOG))
|
2009-05-15 01:52:21 +08:00
|
|
|
seq_puts(seq, ",notreelog");
|
2009-04-03 04:59:01 +08:00
|
|
|
if (btrfs_test_opt(root, FLUSHONCOMMIT))
|
2009-05-15 01:52:21 +08:00
|
|
|
seq_puts(seq, ",flushoncommit");
|
2009-12-15 06:01:12 +08:00
|
|
|
if (btrfs_test_opt(root, DISCARD))
|
|
|
|
seq_puts(seq, ",discard");
|
2009-04-03 04:46:06 +08:00
|
|
|
if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
|
|
|
|
seq_puts(seq, ",noacl");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-05-07 23:43:44 +08:00
|
|
|
static int btrfs_test_super(struct super_block *s, void *data)
|
2007-08-29 21:11:44 +08:00
|
|
|
{
|
2010-11-20 03:59:15 +08:00
|
|
|
struct btrfs_root *test_root = data;
|
2008-05-07 23:43:44 +08:00
|
|
|
struct btrfs_root *root = btrfs_sb(s);
|
2007-08-29 21:11:44 +08:00
|
|
|
|
2010-11-22 10:21:38 +08:00
|
|
|
/*
|
|
|
|
* If this super block is going away, return false as it
|
|
|
|
* can't match as an existing super block.
|
|
|
|
*/
|
|
|
|
if (!atomic_read(&s->s_active))
|
|
|
|
return 0;
|
2010-11-20 03:59:15 +08:00
|
|
|
return root->fs_info->fs_devices == test_root->fs_info->fs_devices;
|
2007-08-29 21:11:44 +08:00
|
|
|
}
|
|
|
|
|
2010-11-20 03:59:15 +08:00
|
|
|
static int btrfs_set_super(struct super_block *s, void *data)
|
|
|
|
{
|
|
|
|
s->s_fs_info = data;
|
|
|
|
|
|
|
|
return set_anon_super(s, data);
|
2007-08-29 21:11:44 +08:00
|
|
|
}
|
|
|
|
|
2010-11-20 03:59:15 +08:00
|
|
|
|
2008-06-10 22:40:29 +08:00
|
|
|
/*
|
|
|
|
* Find a superblock for the given device / mount point.
|
|
|
|
*
|
|
|
|
* Note: This is based on get_sb_bdev from fs/super.c with a few additions
|
|
|
|
* for multiple device setup. Make sure to keep it in sync.
|
|
|
|
*/
|
2010-07-26 20:21:33 +08:00
|
|
|
static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
|
|
|
|
const char *dev_name, void *data)
|
2007-08-29 21:11:44 +08:00
|
|
|
{
|
|
|
|
struct block_device *bdev = NULL;
|
|
|
|
struct super_block *s;
|
|
|
|
struct dentry *root;
|
2008-03-25 03:02:07 +08:00
|
|
|
struct btrfs_fs_devices *fs_devices = NULL;
|
2010-11-20 03:59:15 +08:00
|
|
|
struct btrfs_root *tree_root = NULL;
|
|
|
|
struct btrfs_fs_info *fs_info = NULL;
|
2008-12-02 19:36:09 +08:00
|
|
|
fmode_t mode = FMODE_READ;
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
char *subvol_name = NULL;
|
|
|
|
u64 subvol_objectid = 0;
|
2007-08-29 21:11:44 +08:00
|
|
|
int error = 0;
|
|
|
|
|
2008-12-02 19:36:09 +08:00
|
|
|
if (!(flags & MS_RDONLY))
|
|
|
|
mode |= FMODE_WRITE;
|
|
|
|
|
|
|
|
error = btrfs_parse_early_options(data, mode, fs_type,
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
&subvol_name, &subvol_objectid,
|
|
|
|
&fs_devices);
|
2008-06-10 22:40:29 +08:00
|
|
|
if (error)
|
2010-07-26 20:21:33 +08:00
|
|
|
return ERR_PTR(error);
|
2008-06-10 22:40:29 +08:00
|
|
|
|
2008-12-02 19:36:09 +08:00
|
|
|
error = btrfs_scan_one_device(dev_name, mode, fs_type, &fs_devices);
|
2008-03-25 03:02:07 +08:00
|
|
|
if (error)
|
2008-06-10 22:40:29 +08:00
|
|
|
goto error_free_subvol_name;
|
2007-08-29 21:11:44 +08:00
|
|
|
|
2008-12-02 19:36:09 +08:00
|
|
|
error = btrfs_open_devices(fs_devices, mode, fs_type);
|
2008-03-25 03:02:07 +08:00
|
|
|
if (error)
|
2008-06-10 22:40:29 +08:00
|
|
|
goto error_free_subvol_name;
|
2008-03-25 03:02:07 +08:00
|
|
|
|
2008-11-18 10:11:30 +08:00
|
|
|
if (!(flags & MS_RDONLY) && fs_devices->rw_devices == 0) {
|
|
|
|
error = -EACCES;
|
|
|
|
goto error_close_devices;
|
|
|
|
}
|
|
|
|
|
2010-11-20 03:59:15 +08:00
|
|
|
/*
|
|
|
|
* Setup a dummy root and fs_info for test/set super. This is because
|
|
|
|
* we don't actually fill this stuff out until open_ctree, but we need
|
|
|
|
* it for searching for existing supers, so this lets us do that and
|
|
|
|
* then open_ctree will properly initialize everything later.
|
|
|
|
*/
|
|
|
|
fs_info = kzalloc(sizeof(struct btrfs_fs_info), GFP_NOFS);
|
|
|
|
tree_root = kzalloc(sizeof(struct btrfs_root), GFP_NOFS);
|
|
|
|
if (!fs_info || !tree_root) {
|
|
|
|
error = -ENOMEM;
|
|
|
|
goto error_close_devices;
|
|
|
|
}
|
|
|
|
fs_info->tree_root = tree_root;
|
|
|
|
fs_info->fs_devices = fs_devices;
|
|
|
|
tree_root->fs_info = fs_info;
|
|
|
|
|
2008-05-14 01:46:40 +08:00
|
|
|
bdev = fs_devices->latest_bdev;
|
2010-11-20 03:59:15 +08:00
|
|
|
s = sget(fs_type, btrfs_test_super, btrfs_set_super, tree_root);
|
2007-08-29 21:11:44 +08:00
|
|
|
if (IS_ERR(s))
|
|
|
|
goto error_s;
|
|
|
|
|
|
|
|
if (s->s_root) {
|
|
|
|
if ((flags ^ s->s_flags) & MS_RDONLY) {
|
2009-05-06 13:34:22 +08:00
|
|
|
deactivate_locked_super(s);
|
2007-08-29 21:11:44 +08:00
|
|
|
error = -EBUSY;
|
2008-11-13 03:34:12 +08:00
|
|
|
goto error_close_devices;
|
2007-08-29 21:11:44 +08:00
|
|
|
}
|
|
|
|
|
2008-11-18 10:11:30 +08:00
|
|
|
btrfs_close_devices(fs_devices);
|
2007-08-29 21:11:44 +08:00
|
|
|
} else {
|
|
|
|
char b[BDEVNAME_SIZE];
|
|
|
|
|
|
|
|
s->s_flags = flags;
|
|
|
|
strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
|
2008-03-25 03:02:07 +08:00
|
|
|
error = btrfs_fill_super(s, fs_devices, data,
|
|
|
|
flags & MS_SILENT ? 1 : 0);
|
2007-08-29 21:11:44 +08:00
|
|
|
if (error) {
|
2009-05-06 13:34:22 +08:00
|
|
|
deactivate_locked_super(s);
|
2009-01-06 04:43:42 +08:00
|
|
|
goto error_free_subvol_name;
|
2007-08-29 21:11:44 +08:00
|
|
|
}
|
|
|
|
|
2008-04-29 03:29:42 +08:00
|
|
|
btrfs_sb(s)->fs_info->bdev_holder = fs_type;
|
2007-08-29 21:11:44 +08:00
|
|
|
s->s_flags |= MS_ACTIVE;
|
|
|
|
}
|
|
|
|
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
root = get_default_root(s, subvol_objectid);
|
|
|
|
if (IS_ERR(root)) {
|
|
|
|
error = PTR_ERR(root);
|
|
|
|
deactivate_locked_super(s);
|
2010-10-23 03:26:53 +08:00
|
|
|
goto error_free_subvol_name;
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
}
|
|
|
|
/* if they gave us a subvolume name bind mount into that */
|
|
|
|
if (strcmp(subvol_name, ".")) {
|
|
|
|
struct dentry *new_root;
|
|
|
|
mutex_lock(&root->d_inode->i_mutex);
|
|
|
|
new_root = lookup_one_len(subvol_name, root,
|
2009-01-06 10:25:51 +08:00
|
|
|
strlen(subvol_name));
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
mutex_unlock(&root->d_inode->i_mutex);
|
2009-01-06 10:25:51 +08:00
|
|
|
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
if (IS_ERR(new_root)) {
|
2010-12-07 09:51:26 +08:00
|
|
|
dput(root);
|
2009-05-06 13:34:22 +08:00
|
|
|
deactivate_locked_super(s);
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
error = PTR_ERR(new_root);
|
2010-10-23 03:26:53 +08:00
|
|
|
goto error_free_subvol_name;
|
2008-08-19 23:49:35 +08:00
|
|
|
}
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
if (!new_root->d_inode) {
|
2008-08-19 23:49:35 +08:00
|
|
|
dput(root);
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
dput(new_root);
|
2009-05-06 13:34:22 +08:00
|
|
|
deactivate_locked_super(s);
|
2008-08-19 23:49:35 +08:00
|
|
|
error = -ENXIO;
|
2010-10-23 03:26:53 +08:00
|
|
|
goto error_free_subvol_name;
|
2008-08-19 23:49:35 +08:00
|
|
|
}
|
Btrfs: change how we mount subvolumes
This work is in preperation for being able to set a different root as the
default mounting root.
There is currently a problem with how we mount subvolumes. We cannot currently
mount a subvolume of a subvolume, you can only mount subvolumes/snapshots of the
default subvolume. So say you take a snapshot of the default subvolume and call
it snap1, and then take a snapshot of snap1 and call it snap2, so now you have
/
/snap1
/snap1/snap2
as your available volumes. Currently you can only mount / and /snap1,
you cannot mount /snap1/snap2. To fix this problem instead of passing
subvolid=<name> you must pass in subvolid=<treeid>, where <treeid> is
the tree id that gets spit out via the subvolume listing you get from
the subvolume listing patches (btrfs filesystem list). This allows us
to mount /, /snap1 and /snap1/snap2 as the root volume.
In addition to the above, we also now read the default dir item in the
tree root to get the root key that it points to. For now this just
points at what has always been the default subvolme, but later on I plan
to change it to point at whatever root you want to be the new default
root, so you can just set the default mount and not have to mount with
-o subvolid=<treeid>. I tested this out with the above scenario and it
worked perfectly. Thanks,
mount -o subvol operates inside the selected subvolid. For example:
mount -o subvol=snap1,subvolid=256 /dev/xxx /mnt
/mnt will have the snap1 directory for the subvolume with id
256.
mount -o subvol=snap /dev/xxx /mnt
/mnt will be the snap directory of whatever the default subvolume
is.
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-12-05 01:38:27 +08:00
|
|
|
dput(root);
|
|
|
|
root = new_root;
|
2007-08-29 21:11:44 +08:00
|
|
|
}
|
|
|
|
|
2008-06-10 22:40:29 +08:00
|
|
|
kfree(subvol_name);
|
2010-07-26 20:21:33 +08:00
|
|
|
return root;
|
2007-08-29 21:11:44 +08:00
|
|
|
|
|
|
|
error_s:
|
|
|
|
error = PTR_ERR(s);
|
2008-11-13 03:34:12 +08:00
|
|
|
error_close_devices:
|
2008-03-25 03:02:07 +08:00
|
|
|
btrfs_close_devices(fs_devices);
|
2010-11-20 03:59:15 +08:00
|
|
|
kfree(fs_info);
|
|
|
|
kfree(tree_root);
|
2008-06-10 22:40:29 +08:00
|
|
|
error_free_subvol_name:
|
|
|
|
kfree(subvol_name);
|
2010-07-26 20:21:33 +08:00
|
|
|
return ERR_PTR(error);
|
2007-08-29 21:11:44 +08:00
|
|
|
}
|
2007-03-21 23:12:56 +08:00
|
|
|
|
2008-11-13 03:34:12 +08:00
|
|
|
static int btrfs_remount(struct super_block *sb, int *flags, char *data)
|
|
|
|
{
|
|
|
|
struct btrfs_root *root = btrfs_sb(sb);
|
|
|
|
int ret;
|
|
|
|
|
2009-02-12 22:37:35 +08:00
|
|
|
ret = btrfs_parse_options(root, data);
|
|
|
|
if (ret)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-11-13 03:34:12 +08:00
|
|
|
if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (*flags & MS_RDONLY) {
|
|
|
|
sb->s_flags |= MS_RDONLY;
|
|
|
|
|
|
|
|
ret = btrfs_commit_super(root);
|
|
|
|
WARN_ON(ret);
|
|
|
|
} else {
|
2008-11-18 10:11:30 +08:00
|
|
|
if (root->fs_info->fs_devices->rw_devices == 0)
|
|
|
|
return -EACCES;
|
|
|
|
|
2008-11-13 03:34:12 +08:00
|
|
|
if (btrfs_super_log_root(&root->fs_info->super_copy) != 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2010-05-16 22:49:58 +08:00
|
|
|
ret = btrfs_cleanup_fs_roots(root->fs_info);
|
2008-11-13 03:34:12 +08:00
|
|
|
WARN_ON(ret);
|
|
|
|
|
2010-05-16 22:49:58 +08:00
|
|
|
/* recover relocation */
|
|
|
|
ret = btrfs_recover_relocation(root);
|
2008-11-13 03:34:12 +08:00
|
|
|
WARN_ON(ret);
|
|
|
|
|
|
|
|
sb->s_flags &= ~MS_RDONLY;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-04-20 09:01:03 +08:00
|
|
|
static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
|
|
|
|
{
|
|
|
|
struct btrfs_root *root = btrfs_sb(dentry->d_sb);
|
2007-06-26 22:06:50 +08:00
|
|
|
struct btrfs_super_block *disk_super = &root->fs_info->super_copy;
|
Btrfs: make df be a little bit more understandable
The way we report df usage is way confusing for everybody, including some other
utilities (bacula for one). So this patch makes df a little bit more
understandable. First we make used actually count the total amount of used
space in all space info's. This will give us a real view of how much disk space
is in use. Second, for blocks available, only count data space. This makes
things like bacula work because it says 0 when you can no longer write anymore
data to the disk. I think this is a nice compromise, since you will end up with
something like the following
[root@alpha ~]# df -h
Filesystem Size Used Avail Use% Mounted on
/dev/mapper/VolGroup-lv_root
148G 30G 111G 21% /
/dev/sda1 194M 116M 68M 64% /boot
tmpfs 985M 12K 985M 1% /dev/shm
/dev/mapper/VolGroup-LogVol02
145G 140G 0 100% /mnt/btrfs-test
Compare this with btrfsctl -i output
[root@alpha btrfs-progs-unstable]# ./btrfsctl -i /mnt/btrfs-test/
Metadata, DUP: total=4.62GB, used=2.46GB
System, DUP: total=8.00MB, used=24.00KB
Data: total=134.80GB, used=134.80GB
Metadata: total=8.00MB, used=0.00
System: total=4.00MB, used=0.00
operation complete
This way we show that there is no more data space to be used, but we have
another 5GB of space left for metadata. Thanks,
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-03-06 05:59:21 +08:00
|
|
|
struct list_head *head = &root->fs_info->space_info;
|
|
|
|
struct btrfs_space_info *found;
|
|
|
|
u64 total_used = 0;
|
2010-10-15 02:52:27 +08:00
|
|
|
u64 total_used_data = 0;
|
2007-10-16 04:15:53 +08:00
|
|
|
int bits = dentry->d_sb->s_blocksize_bits;
|
2008-08-18 19:01:52 +08:00
|
|
|
__be32 *fsid = (__be32 *)root->fs_info->fsid;
|
2007-04-20 09:01:03 +08:00
|
|
|
|
Btrfs: make df be a little bit more understandable
The way we report df usage is way confusing for everybody, including some other
utilities (bacula for one). So this patch makes df a little bit more
understandable. First we make used actually count the total amount of used
space in all space info's. This will give us a real view of how much disk space
is in use. Second, for blocks available, only count data space. This makes
things like bacula work because it says 0 when you can no longer write anymore
data to the disk. I think this is a nice compromise, since you will end up with
something like the following
[root@alpha ~]# df -h
Filesystem Size Used Avail Use% Mounted on
/dev/mapper/VolGroup-lv_root
148G 30G 111G 21% /
/dev/sda1 194M 116M 68M 64% /boot
tmpfs 985M 12K 985M 1% /dev/shm
/dev/mapper/VolGroup-LogVol02
145G 140G 0 100% /mnt/btrfs-test
Compare this with btrfsctl -i output
[root@alpha btrfs-progs-unstable]# ./btrfsctl -i /mnt/btrfs-test/
Metadata, DUP: total=4.62GB, used=2.46GB
System, DUP: total=8.00MB, used=24.00KB
Data: total=134.80GB, used=134.80GB
Metadata: total=8.00MB, used=0.00
System: total=4.00MB, used=0.00
operation complete
This way we show that there is no more data space to be used, but we have
another 5GB of space left for metadata. Thanks,
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-03-06 05:59:21 +08:00
|
|
|
rcu_read_lock();
|
2010-10-15 02:52:27 +08:00
|
|
|
list_for_each_entry_rcu(found, head, list) {
|
|
|
|
if (found->flags & (BTRFS_BLOCK_GROUP_METADATA |
|
|
|
|
BTRFS_BLOCK_GROUP_SYSTEM))
|
|
|
|
total_used_data += found->disk_total;
|
|
|
|
else
|
|
|
|
total_used_data += found->disk_used;
|
2010-05-16 22:46:24 +08:00
|
|
|
total_used += found->disk_used;
|
2010-10-15 02:52:27 +08:00
|
|
|
}
|
Btrfs: make df be a little bit more understandable
The way we report df usage is way confusing for everybody, including some other
utilities (bacula for one). So this patch makes df a little bit more
understandable. First we make used actually count the total amount of used
space in all space info's. This will give us a real view of how much disk space
is in use. Second, for blocks available, only count data space. This makes
things like bacula work because it says 0 when you can no longer write anymore
data to the disk. I think this is a nice compromise, since you will end up with
something like the following
[root@alpha ~]# df -h
Filesystem Size Used Avail Use% Mounted on
/dev/mapper/VolGroup-lv_root
148G 30G 111G 21% /
/dev/sda1 194M 116M 68M 64% /boot
tmpfs 985M 12K 985M 1% /dev/shm
/dev/mapper/VolGroup-LogVol02
145G 140G 0 100% /mnt/btrfs-test
Compare this with btrfsctl -i output
[root@alpha btrfs-progs-unstable]# ./btrfsctl -i /mnt/btrfs-test/
Metadata, DUP: total=4.62GB, used=2.46GB
System, DUP: total=8.00MB, used=24.00KB
Data: total=134.80GB, used=134.80GB
Metadata: total=8.00MB, used=0.00
System: total=4.00MB, used=0.00
operation complete
This way we show that there is no more data space to be used, but we have
another 5GB of space left for metadata. Thanks,
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-03-06 05:59:21 +08:00
|
|
|
rcu_read_unlock();
|
|
|
|
|
2007-04-20 09:01:03 +08:00
|
|
|
buf->f_namelen = BTRFS_NAME_LEN;
|
2007-10-16 04:15:53 +08:00
|
|
|
buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
|
Btrfs: make df be a little bit more understandable
The way we report df usage is way confusing for everybody, including some other
utilities (bacula for one). So this patch makes df a little bit more
understandable. First we make used actually count the total amount of used
space in all space info's. This will give us a real view of how much disk space
is in use. Second, for blocks available, only count data space. This makes
things like bacula work because it says 0 when you can no longer write anymore
data to the disk. I think this is a nice compromise, since you will end up with
something like the following
[root@alpha ~]# df -h
Filesystem Size Used Avail Use% Mounted on
/dev/mapper/VolGroup-lv_root
148G 30G 111G 21% /
/dev/sda1 194M 116M 68M 64% /boot
tmpfs 985M 12K 985M 1% /dev/shm
/dev/mapper/VolGroup-LogVol02
145G 140G 0 100% /mnt/btrfs-test
Compare this with btrfsctl -i output
[root@alpha btrfs-progs-unstable]# ./btrfsctl -i /mnt/btrfs-test/
Metadata, DUP: total=4.62GB, used=2.46GB
System, DUP: total=8.00MB, used=24.00KB
Data: total=134.80GB, used=134.80GB
Metadata: total=8.00MB, used=0.00
System: total=4.00MB, used=0.00
operation complete
This way we show that there is no more data space to be used, but we have
another 5GB of space left for metadata. Thanks,
Signed-off-by: Josef Bacik <josef@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2010-03-06 05:59:21 +08:00
|
|
|
buf->f_bfree = buf->f_blocks - (total_used >> bits);
|
2010-10-15 02:52:27 +08:00
|
|
|
buf->f_bavail = buf->f_blocks - (total_used_data >> bits);
|
2007-04-20 09:01:03 +08:00
|
|
|
buf->f_bsize = dentry->d_sb->s_blocksize;
|
|
|
|
buf->f_type = BTRFS_SUPER_MAGIC;
|
2009-01-06 10:25:51 +08:00
|
|
|
|
2008-08-18 19:01:52 +08:00
|
|
|
/* We treat it as constant endianness (it doesn't matter _which_)
|
2009-01-06 10:25:51 +08:00
|
|
|
because we want the fsid to come out the same whether mounted
|
2008-08-18 19:01:52 +08:00
|
|
|
on a big-endian or little-endian host */
|
|
|
|
buf->f_fsid.val[0] = be32_to_cpu(fsid[0]) ^ be32_to_cpu(fsid[2]);
|
|
|
|
buf->f_fsid.val[1] = be32_to_cpu(fsid[1]) ^ be32_to_cpu(fsid[3]);
|
2008-08-18 20:10:20 +08:00
|
|
|
/* Mask in the root object ID too, to disambiguate subvols */
|
|
|
|
buf->f_fsid.val[0] ^= BTRFS_I(dentry->d_inode)->root->objectid >> 32;
|
|
|
|
buf->f_fsid.val[1] ^= BTRFS_I(dentry->d_inode)->root->objectid;
|
|
|
|
|
2007-04-20 09:01:03 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2007-04-24 23:52:22 +08:00
|
|
|
|
2007-03-21 23:12:56 +08:00
|
|
|
static struct file_system_type btrfs_fs_type = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.name = "btrfs",
|
2010-07-26 20:21:33 +08:00
|
|
|
.mount = btrfs_mount,
|
2008-05-07 23:43:44 +08:00
|
|
|
.kill_sb = kill_anon_super,
|
2007-03-21 23:12:56 +08:00
|
|
|
.fs_flags = FS_REQUIRES_DEV,
|
|
|
|
};
|
2008-03-25 03:02:04 +08:00
|
|
|
|
2008-09-30 03:18:18 +08:00
|
|
|
/*
|
|
|
|
* used by btrfsctl to scan devices when no FS is mounted
|
|
|
|
*/
|
2008-03-25 03:02:07 +08:00
|
|
|
static long btrfs_control_ioctl(struct file *file, unsigned int cmd,
|
|
|
|
unsigned long arg)
|
|
|
|
{
|
|
|
|
struct btrfs_ioctl_vol_args *vol;
|
|
|
|
struct btrfs_fs_devices *fs_devices;
|
2009-01-17 00:59:08 +08:00
|
|
|
int ret = -ENOTTY;
|
2008-03-25 03:02:07 +08:00
|
|
|
|
2009-01-06 05:57:23 +08:00
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EPERM;
|
|
|
|
|
2009-04-08 15:06:54 +08:00
|
|
|
vol = memdup_user((void __user *)arg, sizeof(*vol));
|
|
|
|
if (IS_ERR(vol))
|
|
|
|
return PTR_ERR(vol);
|
2009-01-17 00:59:08 +08:00
|
|
|
|
2008-03-25 03:02:07 +08:00
|
|
|
switch (cmd) {
|
|
|
|
case BTRFS_IOC_SCAN_DEV:
|
2008-12-02 19:36:09 +08:00
|
|
|
ret = btrfs_scan_one_device(vol->name, FMODE_READ,
|
2008-03-25 03:02:07 +08:00
|
|
|
&btrfs_fs_type, &fs_devices);
|
|
|
|
break;
|
|
|
|
}
|
2009-04-08 15:06:54 +08:00
|
|
|
|
2008-03-25 03:02:07 +08:00
|
|
|
kfree(vol);
|
2008-06-10 10:17:11 +08:00
|
|
|
return ret;
|
2008-03-25 03:02:07 +08:00
|
|
|
}
|
|
|
|
|
2009-01-10 22:09:52 +08:00
|
|
|
static int btrfs_freeze(struct super_block *sb)
|
2008-01-23 01:46:56 +08:00
|
|
|
{
|
|
|
|
struct btrfs_root *root = btrfs_sb(sb);
|
2008-06-26 04:01:31 +08:00
|
|
|
mutex_lock(&root->fs_info->transaction_kthread_mutex);
|
|
|
|
mutex_lock(&root->fs_info->cleaner_mutex);
|
2009-01-10 22:09:52 +08:00
|
|
|
return 0;
|
2008-01-23 01:46:56 +08:00
|
|
|
}
|
|
|
|
|
2009-01-10 22:09:52 +08:00
|
|
|
static int btrfs_unfreeze(struct super_block *sb)
|
2008-01-23 01:46:56 +08:00
|
|
|
{
|
|
|
|
struct btrfs_root *root = btrfs_sb(sb);
|
2008-06-26 04:01:31 +08:00
|
|
|
mutex_unlock(&root->fs_info->cleaner_mutex);
|
|
|
|
mutex_unlock(&root->fs_info->transaction_kthread_mutex);
|
2009-01-10 22:09:52 +08:00
|
|
|
return 0;
|
2008-01-23 01:46:56 +08:00
|
|
|
}
|
2007-03-21 23:12:56 +08:00
|
|
|
|
2009-09-22 08:01:09 +08:00
|
|
|
static const struct super_operations btrfs_super_ops = {
|
2009-09-22 04:00:26 +08:00
|
|
|
.drop_inode = btrfs_drop_inode,
|
2010-06-07 23:35:40 +08:00
|
|
|
.evict_inode = btrfs_evict_inode,
|
2007-03-23 00:13:20 +08:00
|
|
|
.put_super = btrfs_put_super,
|
2007-03-23 22:01:08 +08:00
|
|
|
.sync_fs = btrfs_sync_fs,
|
2009-04-03 04:46:06 +08:00
|
|
|
.show_options = btrfs_show_options,
|
2007-03-27 00:00:39 +08:00
|
|
|
.write_inode = btrfs_write_inode,
|
2007-04-24 23:52:22 +08:00
|
|
|
.dirty_inode = btrfs_dirty_inode,
|
2007-04-02 22:50:19 +08:00
|
|
|
.alloc_inode = btrfs_alloc_inode,
|
|
|
|
.destroy_inode = btrfs_destroy_inode,
|
2007-04-20 09:01:03 +08:00
|
|
|
.statfs = btrfs_statfs,
|
2008-11-13 03:34:12 +08:00
|
|
|
.remount_fs = btrfs_remount,
|
2009-01-10 22:09:52 +08:00
|
|
|
.freeze_fs = btrfs_freeze,
|
|
|
|
.unfreeze_fs = btrfs_unfreeze,
|
2007-03-23 00:13:20 +08:00
|
|
|
};
|
2008-03-25 03:02:04 +08:00
|
|
|
|
|
|
|
static const struct file_operations btrfs_ctl_fops = {
|
|
|
|
.unlocked_ioctl = btrfs_control_ioctl,
|
|
|
|
.compat_ioctl = btrfs_control_ioctl,
|
|
|
|
.owner = THIS_MODULE,
|
llseek: automatically add .llseek fop
All file_operations should get a .llseek operation so we can make
nonseekable_open the default for future file operations without a
.llseek pointer.
The three cases that we can automatically detect are no_llseek, seq_lseek
and default_llseek. For cases where we can we can automatically prove that
the file offset is always ignored, we use noop_llseek, which maintains
the current behavior of not returning an error from a seek.
New drivers should normally not use noop_llseek but instead use no_llseek
and call nonseekable_open at open time. Existing drivers can be converted
to do the same when the maintainer knows for certain that no user code
relies on calling seek on the device file.
The generated code is often incorrectly indented and right now contains
comments that clarify for each added line why a specific variant was
chosen. In the version that gets submitted upstream, the comments will
be gone and I will manually fix the indentation, because there does not
seem to be a way to do that using coccinelle.
Some amount of new code is currently sitting in linux-next that should get
the same modifications, which I will do at the end of the merge window.
Many thanks to Julia Lawall for helping me learn to write a semantic
patch that does all this.
===== begin semantic patch =====
// This adds an llseek= method to all file operations,
// as a preparation for making no_llseek the default.
//
// The rules are
// - use no_llseek explicitly if we do nonseekable_open
// - use seq_lseek for sequential files
// - use default_llseek if we know we access f_pos
// - use noop_llseek if we know we don't access f_pos,
// but we still want to allow users to call lseek
//
@ open1 exists @
identifier nested_open;
@@
nested_open(...)
{
<+...
nonseekable_open(...)
...+>
}
@ open exists@
identifier open_f;
identifier i, f;
identifier open1.nested_open;
@@
int open_f(struct inode *i, struct file *f)
{
<+...
(
nonseekable_open(...)
|
nested_open(...)
)
...+>
}
@ read disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ read_no_fpos disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
... when != off
}
@ write @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ write_no_fpos @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
... when != off
}
@ fops0 @
identifier fops;
@@
struct file_operations fops = {
...
};
@ has_llseek depends on fops0 @
identifier fops0.fops;
identifier llseek_f;
@@
struct file_operations fops = {
...
.llseek = llseek_f,
...
};
@ has_read depends on fops0 @
identifier fops0.fops;
identifier read_f;
@@
struct file_operations fops = {
...
.read = read_f,
...
};
@ has_write depends on fops0 @
identifier fops0.fops;
identifier write_f;
@@
struct file_operations fops = {
...
.write = write_f,
...
};
@ has_open depends on fops0 @
identifier fops0.fops;
identifier open_f;
@@
struct file_operations fops = {
...
.open = open_f,
...
};
// use no_llseek if we call nonseekable_open
////////////////////////////////////////////
@ nonseekable1 depends on !has_llseek && has_open @
identifier fops0.fops;
identifier nso ~= "nonseekable_open";
@@
struct file_operations fops = {
... .open = nso, ...
+.llseek = no_llseek, /* nonseekable */
};
@ nonseekable2 depends on !has_llseek @
identifier fops0.fops;
identifier open.open_f;
@@
struct file_operations fops = {
... .open = open_f, ...
+.llseek = no_llseek, /* open uses nonseekable */
};
// use seq_lseek for sequential files
/////////////////////////////////////
@ seq depends on !has_llseek @
identifier fops0.fops;
identifier sr ~= "seq_read";
@@
struct file_operations fops = {
... .read = sr, ...
+.llseek = seq_lseek, /* we have seq_read */
};
// use default_llseek if there is a readdir
///////////////////////////////////////////
@ fops1 depends on !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier readdir_e;
@@
// any other fop is used that changes pos
struct file_operations fops = {
... .readdir = readdir_e, ...
+.llseek = default_llseek, /* readdir is present */
};
// use default_llseek if at least one of read/write touches f_pos
/////////////////////////////////////////////////////////////////
@ fops2 depends on !fops1 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read.read_f;
@@
// read fops use offset
struct file_operations fops = {
... .read = read_f, ...
+.llseek = default_llseek, /* read accesses f_pos */
};
@ fops3 depends on !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write.write_f;
@@
// write fops use offset
struct file_operations fops = {
... .write = write_f, ...
+ .llseek = default_llseek, /* write accesses f_pos */
};
// Use noop_llseek if neither read nor write accesses f_pos
///////////////////////////////////////////////////////////
@ fops4 depends on !fops1 && !fops2 && !fops3 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
identifier write_no_fpos.write_f;
@@
// write fops use offset
struct file_operations fops = {
...
.write = write_f,
.read = read_f,
...
+.llseek = noop_llseek, /* read and write both use no f_pos */
};
@ depends on has_write && !has_read && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write_no_fpos.write_f;
@@
struct file_operations fops = {
... .write = write_f, ...
+.llseek = noop_llseek, /* write uses no f_pos */
};
@ depends on has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
@@
struct file_operations fops = {
... .read = read_f, ...
+.llseek = noop_llseek, /* read uses no f_pos */
};
@ depends on !has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
@@
struct file_operations fops = {
...
+.llseek = noop_llseek, /* no read or write fn */
};
===== End semantic patch =====
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Julia Lawall <julia@diku.dk>
Cc: Christoph Hellwig <hch@infradead.org>
2010-08-16 00:52:59 +08:00
|
|
|
.llseek = noop_llseek,
|
2008-03-25 03:02:04 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct miscdevice btrfs_misc = {
|
driver core: add devname module aliases to allow module on-demand auto-loading
This adds:
alias: devname:<name>
to some common kernel modules, which will allow the on-demand loading
of the kernel module when the device node is accessed.
Ideally all these modules would be compiled-in, but distros seems too
much in love with their modularization that we need to cover the common
cases with this new facility. It will allow us to remove a bunch of pretty
useless init scripts and modprobes from init scripts.
The static device node aliases will be carried in the module itself. The
program depmod will extract this information to a file in the module directory:
$ cat /lib/modules/2.6.34-00650-g537b60d-dirty/modules.devname
# Device nodes to trigger on-demand module loading.
microcode cpu/microcode c10:184
fuse fuse c10:229
ppp_generic ppp c108:0
tun net/tun c10:200
dm_mod mapper/control c10:235
Udev will pick up the depmod created file on startup and create all the
static device nodes which the kernel modules specify, so that these modules
get automatically loaded when the device node is accessed:
$ /sbin/udevd --debug
...
static_dev_create_from_modules: mknod '/dev/cpu/microcode' c10:184
static_dev_create_from_modules: mknod '/dev/fuse' c10:229
static_dev_create_from_modules: mknod '/dev/ppp' c108:0
static_dev_create_from_modules: mknod '/dev/net/tun' c10:200
static_dev_create_from_modules: mknod '/dev/mapper/control' c10:235
udev_rules_apply_static_dev_perms: chmod '/dev/net/tun' 0666
udev_rules_apply_static_dev_perms: chmod '/dev/fuse' 0666
A few device nodes are switched to statically allocated numbers, to allow
the static nodes to work. This might also useful for systems which still run
a plain static /dev, which is completely unsafe to use with any dynamic minor
numbers.
Note:
The devname aliases must be limited to the *common* and *single*instance*
device nodes, like the misc devices, and never be used for conceptually limited
systems like the loop devices, which should rather get fixed properly and get a
control node for losetup to talk to, instead of creating a random number of
device nodes in advance, regardless if they are ever used.
This facility is to hide the mess distros are creating with too modualized
kernels, and just to hide that these modules are not compiled-in, and not to
paper-over broken concepts. Thanks! :)
Cc: Greg Kroah-Hartman <gregkh@suse.de>
Cc: David S. Miller <davem@davemloft.net>
Cc: Miklos Szeredi <miklos@szeredi.hu>
Cc: Chris Mason <chris.mason@oracle.com>
Cc: Alasdair G Kergon <agk@redhat.com>
Cc: Tigran Aivazian <tigran@aivazian.fsnet.co.uk>
Cc: Ian Kent <raven@themaw.net>
Signed-Off-By: Kay Sievers <kay.sievers@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2010-05-21 00:07:20 +08:00
|
|
|
.minor = BTRFS_MINOR,
|
2008-03-25 03:02:04 +08:00
|
|
|
.name = "btrfs-control",
|
|
|
|
.fops = &btrfs_ctl_fops
|
|
|
|
};
|
|
|
|
|
driver core: add devname module aliases to allow module on-demand auto-loading
This adds:
alias: devname:<name>
to some common kernel modules, which will allow the on-demand loading
of the kernel module when the device node is accessed.
Ideally all these modules would be compiled-in, but distros seems too
much in love with their modularization that we need to cover the common
cases with this new facility. It will allow us to remove a bunch of pretty
useless init scripts and modprobes from init scripts.
The static device node aliases will be carried in the module itself. The
program depmod will extract this information to a file in the module directory:
$ cat /lib/modules/2.6.34-00650-g537b60d-dirty/modules.devname
# Device nodes to trigger on-demand module loading.
microcode cpu/microcode c10:184
fuse fuse c10:229
ppp_generic ppp c108:0
tun net/tun c10:200
dm_mod mapper/control c10:235
Udev will pick up the depmod created file on startup and create all the
static device nodes which the kernel modules specify, so that these modules
get automatically loaded when the device node is accessed:
$ /sbin/udevd --debug
...
static_dev_create_from_modules: mknod '/dev/cpu/microcode' c10:184
static_dev_create_from_modules: mknod '/dev/fuse' c10:229
static_dev_create_from_modules: mknod '/dev/ppp' c108:0
static_dev_create_from_modules: mknod '/dev/net/tun' c10:200
static_dev_create_from_modules: mknod '/dev/mapper/control' c10:235
udev_rules_apply_static_dev_perms: chmod '/dev/net/tun' 0666
udev_rules_apply_static_dev_perms: chmod '/dev/fuse' 0666
A few device nodes are switched to statically allocated numbers, to allow
the static nodes to work. This might also useful for systems which still run
a plain static /dev, which is completely unsafe to use with any dynamic minor
numbers.
Note:
The devname aliases must be limited to the *common* and *single*instance*
device nodes, like the misc devices, and never be used for conceptually limited
systems like the loop devices, which should rather get fixed properly and get a
control node for losetup to talk to, instead of creating a random number of
device nodes in advance, regardless if they are ever used.
This facility is to hide the mess distros are creating with too modualized
kernels, and just to hide that these modules are not compiled-in, and not to
paper-over broken concepts. Thanks! :)
Cc: Greg Kroah-Hartman <gregkh@suse.de>
Cc: David S. Miller <davem@davemloft.net>
Cc: Miklos Szeredi <miklos@szeredi.hu>
Cc: Chris Mason <chris.mason@oracle.com>
Cc: Alasdair G Kergon <agk@redhat.com>
Cc: Tigran Aivazian <tigran@aivazian.fsnet.co.uk>
Cc: Ian Kent <raven@themaw.net>
Signed-Off-By: Kay Sievers <kay.sievers@vrfy.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2010-05-21 00:07:20 +08:00
|
|
|
MODULE_ALIAS_MISCDEV(BTRFS_MINOR);
|
|
|
|
MODULE_ALIAS("devname:btrfs-control");
|
|
|
|
|
2008-03-25 03:02:04 +08:00
|
|
|
static int btrfs_interface_init(void)
|
|
|
|
{
|
|
|
|
return misc_register(&btrfs_misc);
|
|
|
|
}
|
|
|
|
|
2008-12-02 22:54:17 +08:00
|
|
|
static void btrfs_interface_exit(void)
|
2008-03-25 03:02:04 +08:00
|
|
|
{
|
|
|
|
if (misc_deregister(&btrfs_misc) < 0)
|
2009-01-06 10:25:51 +08:00
|
|
|
printk(KERN_INFO "misc_deregister failed for control device");
|
2008-03-25 03:02:04 +08:00
|
|
|
}
|
|
|
|
|
2007-03-21 23:12:56 +08:00
|
|
|
static int __init init_btrfs_fs(void)
|
|
|
|
{
|
2007-04-02 22:50:19 +08:00
|
|
|
int err;
|
2007-08-30 03:47:34 +08:00
|
|
|
|
|
|
|
err = btrfs_init_sysfs();
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2007-06-12 18:35:45 +08:00
|
|
|
err = btrfs_init_cachep();
|
2007-04-02 22:50:19 +08:00
|
|
|
if (err)
|
2008-06-26 04:01:31 +08:00
|
|
|
goto free_sysfs;
|
2008-01-25 05:13:08 +08:00
|
|
|
|
|
|
|
err = extent_io_init();
|
2007-11-19 23:22:33 +08:00
|
|
|
if (err)
|
|
|
|
goto free_cachep;
|
|
|
|
|
2008-01-25 05:13:08 +08:00
|
|
|
err = extent_map_init();
|
|
|
|
if (err)
|
|
|
|
goto free_extent_io;
|
|
|
|
|
2008-03-25 03:02:04 +08:00
|
|
|
err = btrfs_interface_init();
|
2007-11-19 23:22:33 +08:00
|
|
|
if (err)
|
|
|
|
goto free_extent_map;
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-30 02:49:59 +08:00
|
|
|
|
2008-03-25 03:02:04 +08:00
|
|
|
err = register_filesystem(&btrfs_fs_type);
|
|
|
|
if (err)
|
|
|
|
goto unregister_ioctl;
|
2008-07-24 00:12:13 +08:00
|
|
|
|
|
|
|
printk(KERN_INFO "%s loaded\n", BTRFS_BUILD_VERSION);
|
2007-11-19 23:22:33 +08:00
|
|
|
return 0;
|
|
|
|
|
2008-03-25 03:02:04 +08:00
|
|
|
unregister_ioctl:
|
|
|
|
btrfs_interface_exit();
|
2007-11-19 23:22:33 +08:00
|
|
|
free_extent_map:
|
|
|
|
extent_map_exit();
|
2008-01-25 05:13:08 +08:00
|
|
|
free_extent_io:
|
|
|
|
extent_io_exit();
|
2007-11-19 23:22:33 +08:00
|
|
|
free_cachep:
|
|
|
|
btrfs_destroy_cachep();
|
2008-06-26 04:01:31 +08:00
|
|
|
free_sysfs:
|
2007-11-19 23:22:33 +08:00
|
|
|
btrfs_exit_sysfs();
|
|
|
|
return err;
|
2007-03-21 23:12:56 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit exit_btrfs_fs(void)
|
|
|
|
{
|
2007-06-12 18:35:45 +08:00
|
|
|
btrfs_destroy_cachep();
|
2007-08-28 04:49:44 +08:00
|
|
|
extent_map_exit();
|
2008-01-25 05:13:08 +08:00
|
|
|
extent_io_exit();
|
2008-03-25 03:02:04 +08:00
|
|
|
btrfs_interface_exit();
|
2007-03-21 23:12:56 +08:00
|
|
|
unregister_filesystem(&btrfs_fs_type);
|
2007-08-30 03:47:34 +08:00
|
|
|
btrfs_exit_sysfs();
|
2008-03-25 03:02:07 +08:00
|
|
|
btrfs_cleanup_fs_uuids();
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-30 02:49:59 +08:00
|
|
|
btrfs_zlib_exit();
|
2007-03-21 23:12:56 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(init_btrfs_fs)
|
|
|
|
module_exit(exit_btrfs_fs)
|
|
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|