+/*
+ * 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 <stdio.h>
#include <stdlib.h>
#include <signal.h>
+#include <sys/types.h>
+#include <sys/stat.h>
#include <unistd.h>
#include "kerncompat.h"
#include "radix-tree.h"
#include "disk-io.h"
#include "print-tree.h"
#include "hash.h"
+#include "transaction.h"
int keep_running = 1;
struct btrfs_super_block super;
-static u64 dir_oid = 44556;
+static u64 dir_oid = 0;
static u64 file_oid = 33778;
static int find_num(struct radix_tree_root *root, unsigned long *num_ret,
return 0;
}
-static int ins_one(struct btrfs_root *root, struct radix_tree_root *radix)
+static void initial_inode_init(struct btrfs_root *root,
+ struct btrfs_inode_item *inode_item)
+{
+ memset(inode_item, 0, sizeof(*inode_item));
+ btrfs_set_inode_generation(inode_item, root->fs_info->generation);
+ btrfs_set_inode_mode(inode_item, S_IFREG | 0700);
+}
+
+static int ins_one(struct btrfs_trans_handle *trans, struct btrfs_root *root,
+ struct radix_tree_root *radix)
{
int ret;
char buf[128];
unsigned long oid;
+ u64 objectid;
struct btrfs_path path;
+ struct btrfs_key inode_map;
+ struct btrfs_inode_item inode_item;
find_num(radix, &oid, 0);
sprintf(buf, "str-%lu", oid);
- ret = btrfs_insert_dir_item(root, buf, strlen(buf), dir_oid, file_oid,
- 1);
+ ret = btrfs_find_free_objectid(trans, root, dir_oid + 1, &objectid);
+ if (ret)
+ goto error;
+
+ inode_map.objectid = objectid;
+ inode_map.flags = 0;
+ inode_map.type = BTRFS_INODE_ITEM_KEY;
+ inode_map.offset = 0;
+
+ initial_inode_init(root, &inode_item);
+ ret = btrfs_insert_inode(trans, root, objectid, &inode_item);
+ if (ret)
+ goto error;
+ ret = btrfs_insert_dir_item(trans, root, buf, strlen(buf), dir_oid,
+ &inode_map, BTRFS_FT_UNKNOWN);
if (ret)
goto error;
* check
*/
btrfs_init_path(&path);
- ret = btrfs_lookup_dir_item(root, &path, dir_oid, buf, strlen(buf), 0);
+ ret = btrfs_lookup_dir_item(trans, root, &path, dir_oid, buf,
+ strlen(buf), 0);
if (ret)
goto fatal_release;
if (!btrfs_match_dir_item_name(root, &path, buf, strlen(buf))) {
di = btrfs_item_ptr(&path.nodes[0]->leaf, path.slots[0],
struct btrfs_dir_item);
found = (char *)(di + 1);
- found_len = btrfs_dir_name_len(path.nodes[0]->leaf.items +
- path.slots[0]);
- btrfs_name_hash(buf, strlen(buf), &myhash);
- btrfs_name_hash(found, found_len, &foundhash);
+ found_len = btrfs_dir_name_len(di);
+ myhash = btrfs_name_hash(buf, strlen(buf));
+ foundhash = btrfs_name_hash(found, found_len);
if (myhash != foundhash)
goto fatal_release;
- btrfs_release_path(root, &path);
+ btrfs_release_path(&path);
return 0;
}
fatal_release:
- btrfs_release_path(root, &path);
+ btrfs_release_path(&path);
fatal:
printf("failed to insert %lu ret %d\n", oid, ret);
- return -1;
+ return ret;
}
-static int insert_dup(struct btrfs_root *root, struct radix_tree_root *radix)
+static int insert_dup(struct btrfs_trans_handle *trans, struct btrfs_root
+ *root, struct radix_tree_root *radix)
{
int ret;
char buf[128];
unsigned long oid;
+ struct btrfs_key key;
ret = find_num(radix, &oid, 1);
if (ret < 0)
return 0;
sprintf(buf, "str-%lu", oid);
- ret = btrfs_insert_dir_item(root, buf, strlen(buf), dir_oid, file_oid,
- 1);
+ key.objectid = file_oid;
+ key.flags = 0;
+ key.type = BTRFS_INODE_ITEM_KEY;
+ key.offset = 0;
+ ret = btrfs_insert_dir_item(trans, root, buf, strlen(buf), dir_oid,
+ &key, BTRFS_FT_UNKNOWN);
if (ret != -EEXIST) {
printf("insert on %s gave us %d\n", buf, ret);
return 1;
return 0;
}
-static int del_one(struct btrfs_root *root, struct radix_tree_root *radix)
+static int del_dir_item(struct btrfs_trans_handle *trans,
+ struct btrfs_root *root,
+ struct radix_tree_root *radix,
+ unsigned long radix_index,
+ struct btrfs_path *path)
+{
+ int ret;
+ unsigned long *ptr;
+ u64 file_objectid;
+ struct btrfs_dir_item *di;
+
+ /* find the inode number of the file */
+ di = btrfs_item_ptr(&path->nodes[0]->leaf, path->slots[0],
+ struct btrfs_dir_item);
+ file_objectid = btrfs_disk_key_objectid(&di->location);
+
+ /* delete the directory item */
+ ret = btrfs_del_item(trans, root, path);
+ if (ret)
+ goto out_release;
+ btrfs_release_path(path);
+
+ /* delete the inode */
+ btrfs_init_path(path);
+ ret = btrfs_lookup_inode(trans, root, path, file_objectid, -1);
+ if (ret)
+ goto out_release;
+ ret = btrfs_del_item(trans, root, path);
+ if (ret)
+ goto out_release;
+ btrfs_release_path(path);
+
+ if (root->fs_info->last_inode_alloc > file_objectid)
+ root->fs_info->last_inode_alloc = file_objectid;
+ ptr = radix_tree_delete(radix, radix_index);
+ if (!ptr) {
+ ret = -5555;
+ goto out;
+ }
+ return 0;
+out_release:
+ btrfs_release_path(path);
+out:
+ printf("failed to delete %lu %d\n", radix_index, ret);
+ return ret;
+}
+
+static int del_one(struct btrfs_trans_handle *trans, struct btrfs_root *root,
+ struct radix_tree_root *radix)
{
int ret;
char buf[128];
unsigned long oid;
struct btrfs_path path;
- unsigned long *ptr;
ret = find_num(radix, &oid, 1);
if (ret < 0)
return 0;
sprintf(buf, "str-%lu", oid);
btrfs_init_path(&path);
- ret = btrfs_lookup_dir_item(root, &path, dir_oid, buf, strlen(buf), -1);
+ ret = btrfs_lookup_dir_item(trans, root, &path, dir_oid, buf,
+ strlen(buf), -1);
if (ret)
goto out_release;
- ret = btrfs_del_item(root, &path);
+
+ ret = del_dir_item(trans, root, radix, oid, &path);
if (ret)
goto out_release;
- btrfs_release_path(root, &path);
- ptr = radix_tree_delete(radix, oid);
- if (!ptr) {
- ret = -5555;
- goto out;
- }
- return 0;
+ return ret;
out_release:
- btrfs_release_path(root, &path);
-out:
+ btrfs_release_path(&path);
printf("failed to delete %lu %d\n", oid, ret);
- return -1;
+ return ret;
}
-static int lookup_item(struct btrfs_root *root, struct radix_tree_root *radix)
+static int lookup_item(struct btrfs_trans_handle *trans, struct btrfs_root
+ *root, struct radix_tree_root *radix)
{
struct btrfs_path path;
char buf[128];
int ret;
unsigned long oid;
+ u64 objectid;
+ struct btrfs_dir_item *di;
ret = find_num(radix, &oid, 1);
if (ret < 0)
return 0;
sprintf(buf, "str-%lu", oid);
btrfs_init_path(&path);
- ret = btrfs_lookup_dir_item(root, &path, dir_oid, buf, strlen(buf), 0);
- btrfs_release_path(root, &path);
+ ret = btrfs_lookup_dir_item(trans, root, &path, dir_oid, buf,
+ strlen(buf), 0);
+ if (!ret) {
+ di = btrfs_item_ptr(&path.nodes[0]->leaf, path.slots[0],
+ struct btrfs_dir_item);
+ objectid = btrfs_disk_key_objectid(&di->location);
+ }
+ btrfs_release_path(&path);
if (ret) {
printf("unable to find key %lu\n", oid);
- return -1;
+ return ret;
}
return 0;
}
-static int lookup_enoent(struct btrfs_root *root, struct radix_tree_root *radix)
+static int lookup_enoent(struct btrfs_trans_handle *trans, struct btrfs_root
+ *root, struct radix_tree_root *radix)
{
struct btrfs_path path;
char buf[128];
return 0;
sprintf(buf, "str-%lu", oid);
btrfs_init_path(&path);
- ret = btrfs_lookup_dir_item(root, &path, dir_oid, buf, strlen(buf), 0);
- btrfs_release_path(root, &path);
+ ret = btrfs_lookup_dir_item(trans, root, &path, dir_oid, buf,
+ strlen(buf), 0);
+ btrfs_release_path(&path);
if (!ret) {
printf("able to find key that should not exist %lu\n", oid);
- return -1;
+ return ret;
}
return 0;
}
-static int empty_tree(struct btrfs_root *root, struct radix_tree_root *radix,
- int nr)
+static int empty_tree(struct btrfs_trans_handle *trans, struct btrfs_root
+ *root, struct radix_tree_root *radix, int nr)
{
struct btrfs_path path;
struct btrfs_key key;
u32 found_len;
int ret;
int slot;
- int *ptr;
int count = 0;
char buf[128];
struct btrfs_dir_item *di;
key.offset = (u64)-1;
key.flags = 0;
- btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
+ key.type = BTRFS_DIR_ITEM_KEY;
key.objectid = dir_oid;
while(nr-- >= 0) {
btrfs_init_path(&path);
- ret = btrfs_search_slot(root, &key, &path, -1, 1);
+ ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
if (ret < 0) {
- btrfs_release_path(root, &path);
+ btrfs_release_path(&path);
return ret;
}
if (ret != 0) {
if (path.slots[0] == 0) {
- btrfs_release_path(root, &path);
+ btrfs_release_path(&path);
break;
}
path.slots[0] -= 1;
slot = path.slots[0];
di = btrfs_item_ptr(&path.nodes[0]->leaf, slot,
struct btrfs_dir_item);
- found_len = btrfs_dir_name_len(path.nodes[0]->leaf.items +
- slot);
+ found_len = btrfs_dir_name_len(di);
memcpy(buf, (char *)(di + 1), found_len);
BUG_ON(found_len > 128);
buf[found_len] = '\0';
found = atoi(buf + 4);
- ret = btrfs_del_item(root, &path);
+ ret = del_dir_item(trans, root, radix, found, &path);
count++;
if (ret) {
fprintf(stderr,
"failed to remove %lu from tree\n",
found);
- return -1;
+ return ret;
}
- btrfs_release_path(root, &path);
- ptr = radix_tree_delete(radix, found);
- if (!ptr)
- goto error;
if (!keep_running)
break;
}
return 0;
-error:
fprintf(stderr, "failed to delete from the radix %lu\n", found);
- return -1;
+ return ret;
}
-static int fill_tree(struct btrfs_root *root, struct radix_tree_root *radix,
- int count)
+static int fill_tree(struct btrfs_trans_handle *trans, struct btrfs_root *root,
+ struct radix_tree_root *radix, int count)
{
int i;
int ret = 0;
for (i = 0; i < count; i++) {
- ret = ins_one(root, radix);
+ ret = ins_one(trans, root, radix);
if (ret) {
fprintf(stderr, "fill failed\n");
goto out;
}
if (i % 1000 == 0) {
- ret = btrfs_commit_transaction(root, &super);
+ ret = btrfs_commit_transaction(trans, root, &super);
if (ret) {
fprintf(stderr, "fill commit failed\n");
return ret;
return ret;
}
-static int bulk_op(struct btrfs_root *root, struct radix_tree_root *radix)
+static int bulk_op(struct btrfs_trans_handle *trans, struct btrfs_root *root,
+ struct radix_tree_root *radix)
{
int ret;
int nr = rand() % 5000;
/* do the bulk op much less frequently */
if (run_nr++ % 100)
return 0;
- ret = empty_tree(root, radix, nr);
+ ret = empty_tree(trans, root, radix, nr);
if (ret)
return ret;
- ret = fill_tree(root, radix, nr);
+ ret = fill_tree(trans, root, radix, nr);
if (ret)
return ret;
return 0;
}
-int (*ops[])(struct btrfs_root *root, struct radix_tree_root *radix) =
+int (*ops[])(struct btrfs_trans_handle *trans, struct btrfs_root *root, struct
+ radix_tree_root *radix) =
{ ins_one, insert_dup, del_one, lookup_item,
lookup_enoent, bulk_op };
int init_fill_count = 800000;
int err = 0;
int initial_only = 0;
+ struct btrfs_trans_handle *trans;
radix_tree_init();
- printf("removing old tree\n");
- unlink("dbfile");
- root = open_ctree("dbfile", &super);
+ root = open_ctree(av[ac-1], &super, 0);
+
+ if (!root) {
+ fprintf(stderr, "Open ctree failed\n");
+ return 1;
+ }
+
+ trans = btrfs_start_transaction(root, 1);
+ BUG_ON(IS_ERR(trans));
+
+ dir_oid = btrfs_super_root_dir(&super);
signal(SIGTERM, sigstopper);
signal(SIGINT, sigstopper);
- for (i = 1 ; i < ac ; i++) {
+ for (i = 1 ; i < ac - 1; i++) {
if (strcmp(av[i], "-i") == 0) {
initial_only = 1;
} else if (strcmp(av[i], "-c") == 0) {
}
}
printf("initial fill\n");
- ret = fill_tree(root, &radix, init_fill_count);
+ ret = fill_tree(trans, root, &radix, init_fill_count);
printf("starting run\n");
if (ret) {
err = ret;
btrfs_header_level(&root->node->node.header),
btrfs_header_nritems(&root->node->node.header));
close_ctree(root, &super);
- root = open_ctree("dbfile", &super);
+ root = open_ctree("dbfile", &super, 0);
+
+ if (!root) {
+ fprintf(stderr, "Open ctree failed\n");
+ return 1;
+ }
}
while(count--) {
- ret = ops[op](root, &radix);
+ ret = ops[op](trans, root, &radix);
if (ret) {
fprintf(stderr, "op %d failed %d:%d\n",
op, i, iterations);
- btrfs_print_tree(root, root->node);
+ btrfs_print_tree(root, root->node, 1);
fprintf(stderr, "op %d failed %d:%d\n",
op, i, iterations);
err = ret;
}
out:
close_ctree(root, &super);
- return err;
+ return !!err;
}
projects / platform / upstream / btrfs-progs.git / blobdiff