mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-22 17:01:14 +00:00
![Yan, Zheng](/assets/img/avatar_default.png)
btrfs allows subvolumes and snapshots anywhere in the directory tree. If we snapshot a subvolume that contains a link to other subvolume called subvolA, subvolA can be accessed through both the original subvolume and the snapshot. This is similar to creating hard link to directory, and has the very similar problems. The aim of this patch is enforcing there is only one access point to each subvolume. Only the first directory entry (the one added when the subvolume/snapshot was created) is treated as valid access point. The first directory entry is distinguished by checking root forward reference. If the corresponding root forward reference is missing, we know the entry is not the first one. This patch also adds snapshot/subvolume rename support, the code allows rename subvolume link across subvolumes. Signed-off-by: Yan Zheng <zheng.yan@oracle.com> Signed-off-by: Chris Mason <chris.mason@oracle.com>
436 lines
12 KiB
C
436 lines
12 KiB
C
/*
|
|
* 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.
|
|
*/
|
|
|
|
#include "ctree.h"
|
|
#include "disk-io.h"
|
|
#include "hash.h"
|
|
#include "transaction.h"
|
|
|
|
/*
|
|
* insert a name into a directory, doing overflow properly if there is a hash
|
|
* collision. data_size indicates how big the item inserted should be. On
|
|
* success a struct btrfs_dir_item pointer is returned, otherwise it is
|
|
* an ERR_PTR.
|
|
*
|
|
* The name is not copied into the dir item, you have to do that yourself.
|
|
*/
|
|
static struct btrfs_dir_item *insert_with_overflow(struct btrfs_trans_handle
|
|
*trans,
|
|
struct btrfs_root *root,
|
|
struct btrfs_path *path,
|
|
struct btrfs_key *cpu_key,
|
|
u32 data_size,
|
|
const char *name,
|
|
int name_len)
|
|
{
|
|
int ret;
|
|
char *ptr;
|
|
struct btrfs_item *item;
|
|
struct extent_buffer *leaf;
|
|
|
|
ret = btrfs_insert_empty_item(trans, root, path, cpu_key, data_size);
|
|
if (ret == -EEXIST) {
|
|
struct btrfs_dir_item *di;
|
|
di = btrfs_match_dir_item_name(root, path, name, name_len);
|
|
if (di)
|
|
return ERR_PTR(-EEXIST);
|
|
ret = btrfs_extend_item(trans, root, path, data_size);
|
|
WARN_ON(ret > 0);
|
|
}
|
|
if (ret < 0)
|
|
return ERR_PTR(ret);
|
|
WARN_ON(ret > 0);
|
|
leaf = path->nodes[0];
|
|
item = btrfs_item_nr(leaf, path->slots[0]);
|
|
ptr = btrfs_item_ptr(leaf, path->slots[0], char);
|
|
BUG_ON(data_size > btrfs_item_size(leaf, item));
|
|
ptr += btrfs_item_size(leaf, item) - data_size;
|
|
return (struct btrfs_dir_item *)ptr;
|
|
}
|
|
|
|
/*
|
|
* xattrs work a lot like directories, this inserts an xattr item
|
|
* into the tree
|
|
*/
|
|
int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,
|
|
struct btrfs_root *root, const char *name,
|
|
u16 name_len, const void *data, u16 data_len,
|
|
u64 dir)
|
|
{
|
|
int ret = 0;
|
|
struct btrfs_path *path;
|
|
struct btrfs_dir_item *dir_item;
|
|
unsigned long name_ptr, data_ptr;
|
|
struct btrfs_key key, location;
|
|
struct btrfs_disk_key disk_key;
|
|
struct extent_buffer *leaf;
|
|
u32 data_size;
|
|
|
|
key.objectid = dir;
|
|
btrfs_set_key_type(&key, BTRFS_XATTR_ITEM_KEY);
|
|
key.offset = btrfs_name_hash(name, name_len);
|
|
path = btrfs_alloc_path();
|
|
if (!path)
|
|
return -ENOMEM;
|
|
if (name_len + data_len + sizeof(struct btrfs_dir_item) >
|
|
BTRFS_LEAF_DATA_SIZE(root) - sizeof(struct btrfs_item))
|
|
return -ENOSPC;
|
|
|
|
data_size = sizeof(*dir_item) + name_len + data_len;
|
|
dir_item = insert_with_overflow(trans, root, path, &key, data_size,
|
|
name, name_len);
|
|
/*
|
|
* FIXME: at some point we should handle xattr's that are larger than
|
|
* what we can fit in our leaf. We set location to NULL b/c we arent
|
|
* pointing at anything else, that will change if we store the xattr
|
|
* data in a separate inode.
|
|
*/
|
|
BUG_ON(IS_ERR(dir_item));
|
|
memset(&location, 0, sizeof(location));
|
|
|
|
leaf = path->nodes[0];
|
|
btrfs_cpu_key_to_disk(&disk_key, &location);
|
|
btrfs_set_dir_item_key(leaf, dir_item, &disk_key);
|
|
btrfs_set_dir_type(leaf, dir_item, BTRFS_FT_XATTR);
|
|
btrfs_set_dir_name_len(leaf, dir_item, name_len);
|
|
btrfs_set_dir_transid(leaf, dir_item, trans->transid);
|
|
btrfs_set_dir_data_len(leaf, dir_item, data_len);
|
|
name_ptr = (unsigned long)(dir_item + 1);
|
|
data_ptr = (unsigned long)((char *)name_ptr + name_len);
|
|
|
|
write_extent_buffer(leaf, name, name_ptr, name_len);
|
|
write_extent_buffer(leaf, data, data_ptr, data_len);
|
|
btrfs_mark_buffer_dirty(path->nodes[0]);
|
|
|
|
btrfs_free_path(path);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* insert a directory item in the tree, doing all the magic for
|
|
* both indexes. 'dir' indicates which objectid to insert it into,
|
|
* 'location' is the key to stuff into the directory item, 'type' is the
|
|
* type of the inode we're pointing to, and 'index' is the sequence number
|
|
* to use for the second index (if one is created).
|
|
*/
|
|
int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
|
|
*root, const char *name, int name_len, u64 dir,
|
|
struct btrfs_key *location, u8 type, u64 index)
|
|
{
|
|
int ret = 0;
|
|
int ret2 = 0;
|
|
struct btrfs_path *path;
|
|
struct btrfs_dir_item *dir_item;
|
|
struct extent_buffer *leaf;
|
|
unsigned long name_ptr;
|
|
struct btrfs_key key;
|
|
struct btrfs_disk_key disk_key;
|
|
u32 data_size;
|
|
|
|
key.objectid = dir;
|
|
btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
|
|
key.offset = btrfs_name_hash(name, name_len);
|
|
|
|
path = btrfs_alloc_path();
|
|
path->leave_spinning = 1;
|
|
|
|
data_size = sizeof(*dir_item) + name_len;
|
|
dir_item = insert_with_overflow(trans, root, path, &key, data_size,
|
|
name, name_len);
|
|
if (IS_ERR(dir_item)) {
|
|
ret = PTR_ERR(dir_item);
|
|
if (ret == -EEXIST)
|
|
goto second_insert;
|
|
goto out;
|
|
}
|
|
|
|
leaf = path->nodes[0];
|
|
btrfs_cpu_key_to_disk(&disk_key, location);
|
|
btrfs_set_dir_item_key(leaf, dir_item, &disk_key);
|
|
btrfs_set_dir_type(leaf, dir_item, type);
|
|
btrfs_set_dir_data_len(leaf, dir_item, 0);
|
|
btrfs_set_dir_name_len(leaf, dir_item, name_len);
|
|
btrfs_set_dir_transid(leaf, dir_item, trans->transid);
|
|
name_ptr = (unsigned long)(dir_item + 1);
|
|
|
|
write_extent_buffer(leaf, name, name_ptr, name_len);
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
|
|
second_insert:
|
|
/* FIXME, use some real flag for selecting the extra index */
|
|
if (root == root->fs_info->tree_root) {
|
|
ret = 0;
|
|
goto out;
|
|
}
|
|
btrfs_release_path(root, path);
|
|
|
|
btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY);
|
|
key.offset = index;
|
|
dir_item = insert_with_overflow(trans, root, path, &key, data_size,
|
|
name, name_len);
|
|
if (IS_ERR(dir_item)) {
|
|
ret2 = PTR_ERR(dir_item);
|
|
goto out;
|
|
}
|
|
leaf = path->nodes[0];
|
|
btrfs_cpu_key_to_disk(&disk_key, location);
|
|
btrfs_set_dir_item_key(leaf, dir_item, &disk_key);
|
|
btrfs_set_dir_type(leaf, dir_item, type);
|
|
btrfs_set_dir_data_len(leaf, dir_item, 0);
|
|
btrfs_set_dir_name_len(leaf, dir_item, name_len);
|
|
btrfs_set_dir_transid(leaf, dir_item, trans->transid);
|
|
name_ptr = (unsigned long)(dir_item + 1);
|
|
write_extent_buffer(leaf, name, name_ptr, name_len);
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
out:
|
|
btrfs_free_path(path);
|
|
if (ret)
|
|
return ret;
|
|
if (ret2)
|
|
return ret2;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* lookup a directory item based on name. 'dir' is the objectid
|
|
* we're searching in, and 'mod' tells us if you plan on deleting the
|
|
* item (use mod < 0) or changing the options (use mod > 0)
|
|
*/
|
|
struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
|
|
struct btrfs_root *root,
|
|
struct btrfs_path *path, u64 dir,
|
|
const char *name, int name_len,
|
|
int mod)
|
|
{
|
|
int ret;
|
|
struct btrfs_key key;
|
|
int ins_len = mod < 0 ? -1 : 0;
|
|
int cow = mod != 0;
|
|
struct btrfs_key found_key;
|
|
struct extent_buffer *leaf;
|
|
|
|
key.objectid = dir;
|
|
btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
|
|
|
|
key.offset = btrfs_name_hash(name, name_len);
|
|
|
|
ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
|
|
if (ret < 0)
|
|
return ERR_PTR(ret);
|
|
if (ret > 0) {
|
|
if (path->slots[0] == 0)
|
|
return NULL;
|
|
path->slots[0]--;
|
|
}
|
|
|
|
leaf = path->nodes[0];
|
|
btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
|
|
|
|
if (found_key.objectid != dir ||
|
|
btrfs_key_type(&found_key) != BTRFS_DIR_ITEM_KEY ||
|
|
found_key.offset != key.offset)
|
|
return NULL;
|
|
|
|
return btrfs_match_dir_item_name(root, path, name, name_len);
|
|
}
|
|
|
|
/*
|
|
* lookup a directory item based on index. 'dir' is the objectid
|
|
* we're searching in, and 'mod' tells us if you plan on deleting the
|
|
* item (use mod < 0) or changing the options (use mod > 0)
|
|
*
|
|
* The name is used to make sure the index really points to the name you were
|
|
* looking for.
|
|
*/
|
|
struct btrfs_dir_item *
|
|
btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,
|
|
struct btrfs_root *root,
|
|
struct btrfs_path *path, u64 dir,
|
|
u64 objectid, const char *name, int name_len,
|
|
int mod)
|
|
{
|
|
int ret;
|
|
struct btrfs_key key;
|
|
int ins_len = mod < 0 ? -1 : 0;
|
|
int cow = mod != 0;
|
|
|
|
key.objectid = dir;
|
|
btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY);
|
|
key.offset = objectid;
|
|
|
|
ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
|
|
if (ret < 0)
|
|
return ERR_PTR(ret);
|
|
if (ret > 0)
|
|
return ERR_PTR(-ENOENT);
|
|
return btrfs_match_dir_item_name(root, path, name, name_len);
|
|
}
|
|
|
|
struct btrfs_dir_item *
|
|
btrfs_search_dir_index_item(struct btrfs_root *root,
|
|
struct btrfs_path *path, u64 dirid,
|
|
const char *name, int name_len)
|
|
{
|
|
struct extent_buffer *leaf;
|
|
struct btrfs_dir_item *di;
|
|
struct btrfs_key key;
|
|
u32 nritems;
|
|
int ret;
|
|
|
|
key.objectid = dirid;
|
|
key.type = BTRFS_DIR_INDEX_KEY;
|
|
key.offset = 0;
|
|
|
|
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
|
|
if (ret < 0)
|
|
return ERR_PTR(ret);
|
|
|
|
leaf = path->nodes[0];
|
|
nritems = btrfs_header_nritems(leaf);
|
|
|
|
while (1) {
|
|
if (path->slots[0] >= nritems) {
|
|
ret = btrfs_next_leaf(root, path);
|
|
if (ret < 0)
|
|
return ERR_PTR(ret);
|
|
if (ret > 0)
|
|
break;
|
|
leaf = path->nodes[0];
|
|
nritems = btrfs_header_nritems(leaf);
|
|
continue;
|
|
}
|
|
|
|
btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
|
|
if (key.objectid != dirid || key.type != BTRFS_DIR_INDEX_KEY)
|
|
break;
|
|
|
|
di = btrfs_match_dir_item_name(root, path, name, name_len);
|
|
if (di)
|
|
return di;
|
|
|
|
path->slots[0]++;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans,
|
|
struct btrfs_root *root,
|
|
struct btrfs_path *path, u64 dir,
|
|
const char *name, u16 name_len,
|
|
int mod)
|
|
{
|
|
int ret;
|
|
struct btrfs_key key;
|
|
int ins_len = mod < 0 ? -1 : 0;
|
|
int cow = mod != 0;
|
|
struct btrfs_key found_key;
|
|
struct extent_buffer *leaf;
|
|
|
|
key.objectid = dir;
|
|
btrfs_set_key_type(&key, BTRFS_XATTR_ITEM_KEY);
|
|
key.offset = btrfs_name_hash(name, name_len);
|
|
ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
|
|
if (ret < 0)
|
|
return ERR_PTR(ret);
|
|
if (ret > 0) {
|
|
if (path->slots[0] == 0)
|
|
return NULL;
|
|
path->slots[0]--;
|
|
}
|
|
|
|
leaf = path->nodes[0];
|
|
btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
|
|
|
|
if (found_key.objectid != dir ||
|
|
btrfs_key_type(&found_key) != BTRFS_XATTR_ITEM_KEY ||
|
|
found_key.offset != key.offset)
|
|
return NULL;
|
|
|
|
return btrfs_match_dir_item_name(root, path, name, name_len);
|
|
}
|
|
|
|
/*
|
|
* helper function to look at the directory item pointed to by 'path'
|
|
* this walks through all the entries in a dir item and finds one
|
|
* for a specific name.
|
|
*/
|
|
struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root,
|
|
struct btrfs_path *path,
|
|
const char *name, int name_len)
|
|
{
|
|
struct btrfs_dir_item *dir_item;
|
|
unsigned long name_ptr;
|
|
u32 total_len;
|
|
u32 cur = 0;
|
|
u32 this_len;
|
|
struct extent_buffer *leaf;
|
|
|
|
leaf = path->nodes[0];
|
|
dir_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dir_item);
|
|
total_len = btrfs_item_size_nr(leaf, path->slots[0]);
|
|
while (cur < total_len) {
|
|
this_len = sizeof(*dir_item) +
|
|
btrfs_dir_name_len(leaf, dir_item) +
|
|
btrfs_dir_data_len(leaf, dir_item);
|
|
name_ptr = (unsigned long)(dir_item + 1);
|
|
|
|
if (btrfs_dir_name_len(leaf, dir_item) == name_len &&
|
|
memcmp_extent_buffer(leaf, name, name_ptr, name_len) == 0)
|
|
return dir_item;
|
|
|
|
cur += this_len;
|
|
dir_item = (struct btrfs_dir_item *)((char *)dir_item +
|
|
this_len);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* given a pointer into a directory item, delete it. This
|
|
* handles items that have more than one entry in them.
|
|
*/
|
|
int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
|
|
struct btrfs_root *root,
|
|
struct btrfs_path *path,
|
|
struct btrfs_dir_item *di)
|
|
{
|
|
|
|
struct extent_buffer *leaf;
|
|
u32 sub_item_len;
|
|
u32 item_len;
|
|
int ret = 0;
|
|
|
|
leaf = path->nodes[0];
|
|
sub_item_len = sizeof(*di) + btrfs_dir_name_len(leaf, di) +
|
|
btrfs_dir_data_len(leaf, di);
|
|
item_len = btrfs_item_size_nr(leaf, path->slots[0]);
|
|
if (sub_item_len == item_len) {
|
|
ret = btrfs_del_item(trans, root, path);
|
|
} else {
|
|
/* MARKER */
|
|
unsigned long ptr = (unsigned long)di;
|
|
unsigned long start;
|
|
|
|
start = btrfs_item_ptr_offset(leaf, path->slots[0]);
|
|
memmove_extent_buffer(leaf, ptr, ptr + sub_item_len,
|
|
item_len - (ptr + sub_item_len - start));
|
|
ret = btrfs_truncate_item(trans, root, path,
|
|
item_len - sub_item_len, 1);
|
|
}
|
|
return 0;
|
|
}
|