int btrfs_make_root_dir(struct btrfs_trans_handle *trans,
struct btrfs_root *root, u64 objectid)
{
int ret;
struct btrfs_inode_item inode_item;
memset(&inode_item, 0, sizeof(inode_item));
btrfs_set_stack_inode_generation(&inode_item, trans->transid);
btrfs_set_stack_inode_size(&inode_item, 0);
btrfs_set_stack_inode_nlink(&inode_item, 1);
btrfs_set_stack_inode_nbytes(&inode_item, root->leafsize);
btrfs_set_stack_inode_mode(&inode_item, S_IFDIR | 0555);
if (root->fs_info->tree_root == root)
btrfs_set_super_root_dir(&root->fs_info->super_copy, objectid);
ret = btrfs_insert_inode(trans, root, objectid, &inode_item);
if (ret)
goto error;
ret = btrfs_insert_inode_ref(trans, root, "..", 2, objectid, objectid, 0);
if (ret)
goto error;
btrfs_set_root_dirid(&root->root_item, objectid);
ret = 0;
error:
return ret;
}
static int add_inode_items(struct btrfs_trans_handle *trans,
struct btrfs_root *root,
struct stat *st, char *name,
u64 self_objectid, ino_t parent_inum,
int dir_index_cnt, struct btrfs_inode_item *inode_ret)
{
int ret;
struct btrfs_key inode_key;
struct btrfs_inode_item btrfs_inode;
u64 objectid;
u64 inode_size = 0;
int name_len;
name_len = strlen(name);
fill_inode_item(trans, root, &btrfs_inode, st);
objectid = self_objectid;
if (S_ISDIR(st->st_mode)) {
inode_size = calculate_dir_inode_size(name);
btrfs_set_stack_inode_size(&btrfs_inode, inode_size);
}
inode_key.objectid = objectid;
inode_key.offset = 0;
btrfs_set_key_type(&inode_key, BTRFS_INODE_ITEM_KEY);
ret = btrfs_insert_inode(trans, root, objectid, &btrfs_inode);
if (ret)
goto fail;
ret = btrfs_insert_inode_ref(trans, root, name, name_len,
objectid, parent_inum, dir_index_cnt);
if (ret)
goto fail;
*inode_ret = btrfs_inode;
fail:
return ret;
}
static int make_root_dir(struct btrfs_root *root, int mixed)
{
struct btrfs_trans_handle *trans;
struct btrfs_key location;
u64 bytes_used;
u64 chunk_start = 0;
u64 chunk_size = 0;
int ret;
trans = btrfs_start_transaction(root, 1);
bytes_used = btrfs_super_bytes_used(root->fs_info->super_copy);
root->fs_info->system_allocs = 1;
ret = btrfs_make_block_group(trans, root, bytes_used,
BTRFS_BLOCK_GROUP_SYSTEM,
BTRFS_FIRST_CHUNK_TREE_OBJECTID,
0, BTRFS_MKFS_SYSTEM_GROUP_SIZE);
BUG_ON(ret);
if (mixed) {
ret = btrfs_alloc_chunk(trans, root->fs_info->extent_root,
&chunk_start, &chunk_size,
BTRFS_BLOCK_GROUP_METADATA |
BTRFS_BLOCK_GROUP_DATA);
if (ret == -ENOSPC) {
fprintf(stderr,
"no space to alloc data/metadata chunk\n");
goto err;
}
BUG_ON(ret);
ret = btrfs_make_block_group(trans, root, 0,
BTRFS_BLOCK_GROUP_METADATA |
BTRFS_BLOCK_GROUP_DATA,
BTRFS_FIRST_CHUNK_TREE_OBJECTID,
chunk_start, chunk_size);
BUG_ON(ret);
printf("Created a data/metadata chunk of size %llu\n", chunk_size);
} else {
ret = btrfs_alloc_chunk(trans, root->fs_info->extent_root,
&chunk_start, &chunk_size,
BTRFS_BLOCK_GROUP_METADATA);
if (ret == -ENOSPC) {
fprintf(stderr, "no space to alloc metadata chunk\n");
goto err;
}
BUG_ON(ret);
ret = btrfs_make_block_group(trans, root, 0,
BTRFS_BLOCK_GROUP_METADATA,
BTRFS_FIRST_CHUNK_TREE_OBJECTID,
chunk_start, chunk_size);
BUG_ON(ret);
}
root->fs_info->system_allocs = 0;
btrfs_commit_transaction(trans, root);
trans = btrfs_start_transaction(root, 1);
BUG_ON(!trans);
if (!mixed) {
ret = btrfs_alloc_chunk(trans, root->fs_info->extent_root,
&chunk_start, &chunk_size,
BTRFS_BLOCK_GROUP_DATA);
if (ret == -ENOSPC) {
fprintf(stderr, "no space to alloc data chunk\n");
goto err;
}
BUG_ON(ret);
ret = btrfs_make_block_group(trans, root, 0,
BTRFS_BLOCK_GROUP_DATA,
BTRFS_FIRST_CHUNK_TREE_OBJECTID,
chunk_start, chunk_size);
BUG_ON(ret);
}
ret = btrfs_make_root_dir(trans, root->fs_info->tree_root,
BTRFS_ROOT_TREE_DIR_OBJECTID);
if (ret)
goto err;
ret = btrfs_make_root_dir(trans, root, BTRFS_FIRST_FREE_OBJECTID);
if (ret)
goto err;
memcpy(&location, &root->fs_info->fs_root->root_key, sizeof(location));
location.offset = (u64)-1;
ret = btrfs_insert_dir_item(trans, root->fs_info->tree_root,
"default", 7,
btrfs_super_root_dir(root->fs_info->super_copy),
&location, BTRFS_FT_DIR, 0);
if (ret)
goto err;
ret = btrfs_insert_inode_ref(trans, root->fs_info->tree_root,
"default", 7, location.objectid,
BTRFS_ROOT_TREE_DIR_OBJECTID, 0);
if (ret)
goto err;
btrfs_commit_transaction(trans, root);
err:
return ret;
}
/*
* Add dir_item/index for 'parent_ino' if add_backref is true, also insert a
* backref from the ino to parent dir and update the nlink(Kernel version does
* not do this thing)
*
* Currently only supports adding link from an inode to another inode.
*/
int btrfs_add_link(struct btrfs_trans_handle *trans, struct btrfs_root *root,
u64 ino, u64 parent_ino, char *name, int namelen,
u8 type, u64 *index, int add_backref)
{
struct btrfs_path *path;
struct btrfs_key key;
struct btrfs_inode_item *inode_item;
u32 nlink;
u64 inode_size;
u64 ret_index = 0;
int ret = 0;
path = btrfs_alloc_path();
if (!path)
return -ENOMEM;
if (index && *index) {
ret_index = *index;
} else {
ret = btrfs_find_free_dir_index(root, parent_ino, &ret_index);
if (ret < 0)
goto out;
}
ret = check_dir_conflict(root, name, namelen, parent_ino, ret_index);
if (ret < 0)
goto out;
/* Add inode ref */
if (add_backref) {
ret = btrfs_insert_inode_ref(trans, root, name, namelen,
ino, parent_ino, ret_index);
if (ret < 0)
goto out;
/* Update nlinks for the inode */
key.objectid = ino;
key.type = BTRFS_INODE_ITEM_KEY;
key.offset = 0;
ret = btrfs_search_slot(trans, root, &key, path, 1, 1);
if (ret) {
if (ret > 0)
ret = -ENOENT;
goto out;
}
inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
struct btrfs_inode_item);
nlink = btrfs_inode_nlink(path->nodes[0], inode_item);
nlink++;
btrfs_set_inode_nlink(path->nodes[0], inode_item, nlink);
btrfs_mark_buffer_dirty(path->nodes[0]);
btrfs_release_path(path);
}
/* Add dir_item and dir_index */
key.objectid = ino;
key.type = BTRFS_INODE_ITEM_KEY;
key.offset = 0;
ret = btrfs_insert_dir_item(trans, root, name, namelen, parent_ino,
&key, type, ret_index);
if (ret < 0)
goto out;
/* Update inode size of the parent inode */
key.objectid = parent_ino;
key.type = BTRFS_INODE_ITEM_KEY;
key.offset = 0;
ret = btrfs_search_slot(trans, root, &key, path, 1, 1);
if (ret)
goto out;
inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
struct btrfs_inode_item);
inode_size = btrfs_inode_size(path->nodes[0], inode_item);
inode_size += namelen * 2;
btrfs_set_inode_size(path->nodes[0], inode_item, inode_size);
btrfs_mark_buffer_dirty(path->nodes[0]);
btrfs_release_path(path);
out:
btrfs_free_path(path);
if (ret == 0 && index)
*index = ret_index;
return ret;
}