2008-07-20 14:31:56 -06:00
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include "ctree.h"
|
|
|
|
#include "disk-io.h"
|
|
|
|
#include "btrfs_inode.h"
|
|
|
|
#include "print-tree.h"
|
|
|
|
#include "export.h"
|
|
|
|
|
2009-01-05 19:25:51 -07:00
|
|
|
#define BTRFS_FID_SIZE_NON_CONNECTABLE (offsetof(struct btrfs_fid, \
|
|
|
|
parent_objectid) / 4)
|
|
|
|
#define BTRFS_FID_SIZE_CONNECTABLE (offsetof(struct btrfs_fid, \
|
|
|
|
parent_root_objectid) / 4)
|
|
|
|
#define BTRFS_FID_SIZE_CONNECTABLE_ROOT (sizeof(struct btrfs_fid) / 4)
|
2008-07-20 14:31:56 -06:00
|
|
|
|
2012-04-02 12:34:06 -06:00
|
|
|
static int btrfs_encode_fh(struct inode *inode, u32 *fh, int *max_len,
|
|
|
|
struct inode *parent)
|
2008-07-20 14:31:56 -06:00
|
|
|
{
|
|
|
|
struct btrfs_fid *fid = (struct btrfs_fid *)fh;
|
|
|
|
int len = *max_len;
|
|
|
|
int type;
|
|
|
|
|
2012-04-02 12:34:06 -06:00
|
|
|
if (parent && (len < BTRFS_FID_SIZE_CONNECTABLE)) {
|
2011-01-29 06:13:25 -07:00
|
|
|
*max_len = BTRFS_FID_SIZE_CONNECTABLE;
|
2013-02-16 23:48:11 -07:00
|
|
|
return FILEID_INVALID;
|
2011-01-29 06:13:25 -07:00
|
|
|
} else if (len < BTRFS_FID_SIZE_NON_CONNECTABLE) {
|
|
|
|
*max_len = BTRFS_FID_SIZE_NON_CONNECTABLE;
|
2013-02-16 23:48:11 -07:00
|
|
|
return FILEID_INVALID;
|
2011-01-29 06:13:25 -07:00
|
|
|
}
|
2008-07-20 14:31:56 -06:00
|
|
|
|
|
|
|
len = BTRFS_FID_SIZE_NON_CONNECTABLE;
|
|
|
|
type = FILEID_BTRFS_WITHOUT_PARENT;
|
|
|
|
|
2011-04-19 20:31:50 -06:00
|
|
|
fid->objectid = btrfs_ino(inode);
|
2008-07-20 14:31:56 -06:00
|
|
|
fid->root_objectid = BTRFS_I(inode)->root->objectid;
|
|
|
|
fid->gen = inode->i_generation;
|
|
|
|
|
2012-04-02 12:34:06 -06:00
|
|
|
if (parent) {
|
2008-07-20 14:31:56 -06:00
|
|
|
u64 parent_root_id;
|
|
|
|
|
|
|
|
fid->parent_objectid = BTRFS_I(parent)->location.objectid;
|
|
|
|
fid->parent_gen = parent->i_generation;
|
|
|
|
parent_root_id = BTRFS_I(parent)->root->objectid;
|
|
|
|
|
|
|
|
if (parent_root_id != fid->root_objectid) {
|
|
|
|
fid->parent_root_objectid = parent_root_id;
|
|
|
|
len = BTRFS_FID_SIZE_CONNECTABLE_ROOT;
|
|
|
|
type = FILEID_BTRFS_WITH_PARENT_ROOT;
|
|
|
|
} else {
|
|
|
|
len = BTRFS_FID_SIZE_CONNECTABLE;
|
|
|
|
type = FILEID_BTRFS_WITH_PARENT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*max_len = len;
|
|
|
|
return type;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct dentry *btrfs_get_dentry(struct super_block *sb, u64 objectid,
|
2009-09-21 14:00:26 -06:00
|
|
|
u64 root_objectid, u32 generation,
|
|
|
|
int check_generation)
|
2008-07-20 14:31:56 -06:00
|
|
|
{
|
2011-11-17 13:40:49 -07:00
|
|
|
struct btrfs_fs_info *fs_info = btrfs_sb(sb);
|
2008-07-20 14:31:56 -06:00
|
|
|
struct btrfs_root *root;
|
|
|
|
struct inode *inode;
|
|
|
|
struct btrfs_key key;
|
2009-09-21 14:00:26 -06:00
|
|
|
int index;
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
if (objectid < BTRFS_FIRST_FREE_OBJECTID)
|
|
|
|
return ERR_PTR(-ESTALE);
|
2008-07-20 14:31:56 -06:00
|
|
|
|
2008-08-19 15:20:17 -06:00
|
|
|
key.objectid = root_objectid;
|
2014-06-04 10:41:45 -06:00
|
|
|
key.type = BTRFS_ROOT_ITEM_KEY;
|
2008-08-19 15:20:17 -06:00
|
|
|
key.offset = (u64)-1;
|
|
|
|
|
2009-09-21 14:00:26 -06:00
|
|
|
index = srcu_read_lock(&fs_info->subvol_srcu);
|
|
|
|
|
|
|
|
root = btrfs_read_fs_root_no_name(fs_info, &key);
|
|
|
|
if (IS_ERR(root)) {
|
|
|
|
err = PTR_ERR(root);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2008-07-20 14:31:56 -06:00
|
|
|
key.objectid = objectid;
|
2014-06-04 10:41:45 -06:00
|
|
|
key.type = BTRFS_INODE_ITEM_KEY;
|
2008-07-20 14:31:56 -06:00
|
|
|
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-04 10:38:27 -07:00
|
|
|
inode = btrfs_iget(sb, &key, root, NULL);
|
2009-09-21 14:00:26 -06:00
|
|
|
if (IS_ERR(inode)) {
|
|
|
|
err = PTR_ERR(inode);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
srcu_read_unlock(&fs_info->subvol_srcu, index);
|
2008-07-20 14:31:56 -06:00
|
|
|
|
2009-09-21 14:00:26 -06:00
|
|
|
if (check_generation && generation != inode->i_generation) {
|
2008-07-20 14:31:56 -06:00
|
|
|
iput(inode);
|
|
|
|
return ERR_PTR(-ESTALE);
|
|
|
|
}
|
|
|
|
|
2010-12-20 08:56:06 -07:00
|
|
|
return d_obtain_alias(inode);
|
2009-09-21 14:00:26 -06:00
|
|
|
fail:
|
|
|
|
srcu_read_unlock(&fs_info->subvol_srcu, index);
|
|
|
|
return ERR_PTR(err);
|
2008-07-20 14:31:56 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct dentry *btrfs_fh_to_parent(struct super_block *sb, struct fid *fh,
|
|
|
|
int fh_len, int fh_type)
|
|
|
|
{
|
|
|
|
struct btrfs_fid *fid = (struct btrfs_fid *) fh;
|
|
|
|
u64 objectid, root_objectid;
|
|
|
|
u32 generation;
|
|
|
|
|
|
|
|
if (fh_type == FILEID_BTRFS_WITH_PARENT) {
|
|
|
|
if (fh_len != BTRFS_FID_SIZE_CONNECTABLE)
|
|
|
|
return NULL;
|
|
|
|
root_objectid = fid->root_objectid;
|
|
|
|
} else if (fh_type == FILEID_BTRFS_WITH_PARENT_ROOT) {
|
|
|
|
if (fh_len != BTRFS_FID_SIZE_CONNECTABLE_ROOT)
|
|
|
|
return NULL;
|
|
|
|
root_objectid = fid->parent_root_objectid;
|
|
|
|
} else
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
objectid = fid->parent_objectid;
|
|
|
|
generation = fid->parent_gen;
|
|
|
|
|
2009-09-21 14:00:26 -06:00
|
|
|
return btrfs_get_dentry(sb, objectid, root_objectid, generation, 1);
|
2008-07-20 14:31:56 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct dentry *btrfs_fh_to_dentry(struct super_block *sb, struct fid *fh,
|
|
|
|
int fh_len, int fh_type)
|
|
|
|
{
|
|
|
|
struct btrfs_fid *fid = (struct btrfs_fid *) fh;
|
|
|
|
u64 objectid, root_objectid;
|
|
|
|
u32 generation;
|
|
|
|
|
|
|
|
if ((fh_type != FILEID_BTRFS_WITH_PARENT ||
|
|
|
|
fh_len != BTRFS_FID_SIZE_CONNECTABLE) &&
|
|
|
|
(fh_type != FILEID_BTRFS_WITH_PARENT_ROOT ||
|
|
|
|
fh_len != BTRFS_FID_SIZE_CONNECTABLE_ROOT) &&
|
|
|
|
(fh_type != FILEID_BTRFS_WITHOUT_PARENT ||
|
|
|
|
fh_len != BTRFS_FID_SIZE_NON_CONNECTABLE))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
objectid = fid->objectid;
|
|
|
|
root_objectid = fid->root_objectid;
|
|
|
|
generation = fid->gen;
|
|
|
|
|
2009-09-21 14:00:26 -06:00
|
|
|
return btrfs_get_dentry(sb, objectid, root_objectid, generation, 1);
|
2008-07-20 14:31:56 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct dentry *btrfs_get_parent(struct dentry *child)
|
|
|
|
{
|
2015-03-17 16:25:59 -06:00
|
|
|
struct inode *dir = d_inode(child);
|
2008-07-20 14:31:56 -06:00
|
|
|
struct btrfs_root *root = BTRFS_I(dir)->root;
|
|
|
|
struct btrfs_path *path;
|
|
|
|
struct extent_buffer *leaf;
|
2009-09-21 14:00:26 -06:00
|
|
|
struct btrfs_root_ref *ref;
|
|
|
|
struct btrfs_key key;
|
|
|
|
struct btrfs_key found_key;
|
2008-07-20 14:31:56 -06:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
2011-01-25 23:22:08 -07:00
|
|
|
if (!path)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
2008-07-20 14:31:56 -06:00
|
|
|
|
2011-04-19 20:31:50 -06:00
|
|
|
if (btrfs_ino(dir) == BTRFS_FIRST_FREE_OBJECTID) {
|
2009-09-21 14:00:26 -06:00
|
|
|
key.objectid = root->root_key.objectid;
|
|
|
|
key.type = BTRFS_ROOT_BACKREF_KEY;
|
|
|
|
key.offset = (u64)-1;
|
|
|
|
root = root->fs_info->tree_root;
|
|
|
|
} else {
|
2011-04-19 20:31:50 -06:00
|
|
|
key.objectid = btrfs_ino(dir);
|
2009-09-21 14:00:26 -06:00
|
|
|
key.type = BTRFS_INODE_REF_KEY;
|
|
|
|
key.offset = (u64)-1;
|
|
|
|
}
|
2008-07-20 14:31:56 -06:00
|
|
|
|
2008-08-18 15:50:22 -06:00
|
|
|
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
|
2009-09-21 14:00:26 -06:00
|
|
|
if (ret < 0)
|
|
|
|
goto fail;
|
|
|
|
|
2012-03-12 09:03:00 -06:00
|
|
|
BUG_ON(ret == 0); /* Key with offset of -1 found */
|
2009-09-21 14:00:26 -06:00
|
|
|
if (path->slots[0] == 0) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto fail;
|
2008-08-19 15:33:04 -06:00
|
|
|
}
|
2009-09-21 14:00:26 -06:00
|
|
|
|
|
|
|
path->slots[0]--;
|
2008-07-20 14:31:56 -06:00
|
|
|
leaf = path->nodes[0];
|
2009-09-21 14:00:26 -06:00
|
|
|
|
|
|
|
btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
|
|
|
|
if (found_key.objectid != key.objectid || found_key.type != key.type) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto fail;
|
2008-07-20 14:31:56 -06:00
|
|
|
}
|
|
|
|
|
2009-09-21 14:00:26 -06:00
|
|
|
if (found_key.type == BTRFS_ROOT_BACKREF_KEY) {
|
|
|
|
ref = btrfs_item_ptr(leaf, path->slots[0],
|
|
|
|
struct btrfs_root_ref);
|
|
|
|
key.objectid = btrfs_root_ref_dirid(leaf, ref);
|
|
|
|
} else {
|
|
|
|
key.objectid = found_key.offset;
|
|
|
|
}
|
2008-07-20 14:31:56 -06:00
|
|
|
btrfs_free_path(path);
|
|
|
|
|
2009-09-21 14:00:26 -06:00
|
|
|
if (found_key.type == BTRFS_ROOT_BACKREF_KEY) {
|
|
|
|
return btrfs_get_dentry(root->fs_info->sb, key.objectid,
|
|
|
|
found_key.offset, 0, 0);
|
|
|
|
}
|
2008-08-19 15:20:17 -06:00
|
|
|
|
2009-09-21 14:00:26 -06:00
|
|
|
key.type = BTRFS_INODE_ITEM_KEY;
|
2008-07-20 14:31:56 -06:00
|
|
|
key.offset = 0;
|
2010-12-20 08:56:06 -07:00
|
|
|
return d_obtain_alias(btrfs_iget(root->fs_info->sb, &key, root, NULL));
|
2009-09-21 14:00:26 -06:00
|
|
|
fail:
|
|
|
|
btrfs_free_path(path);
|
|
|
|
return ERR_PTR(ret);
|
2008-07-20 14:31:56 -06:00
|
|
|
}
|
|
|
|
|
2010-11-17 11:54:54 -07:00
|
|
|
static int btrfs_get_name(struct dentry *parent, char *name,
|
|
|
|
struct dentry *child)
|
|
|
|
{
|
2015-03-17 16:25:59 -06:00
|
|
|
struct inode *inode = d_inode(child);
|
|
|
|
struct inode *dir = d_inode(parent);
|
2010-11-17 11:54:54 -07:00
|
|
|
struct btrfs_path *path;
|
|
|
|
struct btrfs_root *root = BTRFS_I(dir)->root;
|
|
|
|
struct btrfs_inode_ref *iref;
|
|
|
|
struct btrfs_root_ref *rref;
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
unsigned long name_ptr;
|
|
|
|
struct btrfs_key key;
|
|
|
|
int name_len;
|
|
|
|
int ret;
|
2011-04-19 20:31:50 -06:00
|
|
|
u64 ino;
|
2010-11-17 11:54:54 -07:00
|
|
|
|
|
|
|
if (!dir || !inode)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!S_ISDIR(dir->i_mode))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-04-19 20:31:50 -06:00
|
|
|
ino = btrfs_ino(inode);
|
|
|
|
|
2010-11-17 11:54:54 -07:00
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
|
|
|
path->leave_spinning = 1;
|
|
|
|
|
2011-04-19 20:31:50 -06:00
|
|
|
if (ino == BTRFS_FIRST_FREE_OBJECTID) {
|
2010-11-17 11:54:54 -07:00
|
|
|
key.objectid = BTRFS_I(inode)->root->root_key.objectid;
|
|
|
|
key.type = BTRFS_ROOT_BACKREF_KEY;
|
|
|
|
key.offset = (u64)-1;
|
|
|
|
root = root->fs_info->tree_root;
|
|
|
|
} else {
|
2011-04-19 20:31:50 -06:00
|
|
|
key.objectid = ino;
|
|
|
|
key.offset = btrfs_ino(dir);
|
2010-11-17 11:54:54 -07:00
|
|
|
key.type = BTRFS_INODE_REF_KEY;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
|
|
|
|
if (ret < 0) {
|
|
|
|
btrfs_free_path(path);
|
|
|
|
return ret;
|
|
|
|
} else if (ret > 0) {
|
2011-04-19 20:31:50 -06:00
|
|
|
if (ino == BTRFS_FIRST_FREE_OBJECTID) {
|
2010-11-17 11:54:54 -07:00
|
|
|
path->slots[0]--;
|
|
|
|
} else {
|
|
|
|
btrfs_free_path(path);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
|
2011-04-19 20:31:50 -06:00
|
|
|
if (ino == BTRFS_FIRST_FREE_OBJECTID) {
|
|
|
|
rref = btrfs_item_ptr(leaf, path->slots[0],
|
2010-11-17 11:54:54 -07:00
|
|
|
struct btrfs_root_ref);
|
2011-04-19 20:31:50 -06:00
|
|
|
name_ptr = (unsigned long)(rref + 1);
|
|
|
|
name_len = btrfs_root_ref_name_len(leaf, rref);
|
2010-11-17 11:54:54 -07:00
|
|
|
} else {
|
|
|
|
iref = btrfs_item_ptr(leaf, path->slots[0],
|
|
|
|
struct btrfs_inode_ref);
|
|
|
|
name_ptr = (unsigned long)(iref + 1);
|
|
|
|
name_len = btrfs_inode_ref_name_len(leaf, iref);
|
|
|
|
}
|
|
|
|
|
|
|
|
read_extent_buffer(leaf, name, name_ptr, name_len);
|
|
|
|
btrfs_free_path(path);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* have to add the null termination to make sure that reconnect_path
|
|
|
|
* gets the right len for strlen
|
|
|
|
*/
|
|
|
|
name[name_len] = '\0';
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-20 14:31:56 -06:00
|
|
|
const struct export_operations btrfs_export_ops = {
|
|
|
|
.encode_fh = btrfs_encode_fh,
|
|
|
|
.fh_to_dentry = btrfs_fh_to_dentry,
|
|
|
|
.fh_to_parent = btrfs_fh_to_parent,
|
|
|
|
.get_parent = btrfs_get_parent,
|
2010-11-17 11:54:54 -07:00
|
|
|
.get_name = btrfs_get_name,
|
2008-07-20 14:31:56 -06:00
|
|
|
};
|