X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dir-test.c;h=cfb77f2ac3262bad1ee890d48b988f59901d4b5a;hb=e181c03d420ef36c8bedd86492dc5c7b229be8a9;hp=56f06c3ba5733fb421680bc85bac31b0e1852427;hpb=099f1ae6e49f844be2acb6316357d1466defb723;p=platform%2Fupstream%2Fbtrfs-progs.git

diff --git a/dir-test.c b/dir-test.c
index 56f06c3..cfb77f2 100644
--- a/dir-test.c
+++ b/dir-test.c
@@ -1,6 +1,26 @@
+/*
+ * 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"
@@ -12,7 +32,7 @@
 
 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,
@@ -39,6 +59,14 @@ again:
 	return 0;
 }
 
+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)
 {
@@ -48,6 +76,7 @@ static int ins_one(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 	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);
@@ -58,13 +87,15 @@ static int ins_one(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 
 	inode_map.objectid = objectid;
 	inode_map.flags = 0;
+	inode_map.type = BTRFS_INODE_ITEM_KEY;
 	inode_map.offset = 0;
 
-	ret = btrfs_insert_inode_map(trans, root, objectid, &inode_map);
+	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,
-				    objectid, 1);
+				    &inode_map, BTRFS_FT_UNKNOWN);
 	if (ret)
 		goto error;
 
@@ -98,18 +129,18 @@ error:
 				    struct btrfs_dir_item);
 		found = (char *)(di + 1);
 		found_len = btrfs_dir_name_len(di);
-		btrfs_name_hash(buf, strlen(buf), &myhash);
-		btrfs_name_hash(found, found_len, &foundhash);
+		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_trans_handle *trans, struct btrfs_root
@@ -118,14 +149,19 @@ static int insert_dup(struct btrfs_trans_handle *trans, struct btrfs_root
 	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);
 
+	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,
-				    file_oid, 1);
+				    &key, BTRFS_FT_UNKNOWN);
 	if (ret != -EEXIST) {
 		printf("insert on %s gave us %d\n", buf, ret);
 		return 1;
@@ -143,30 +179,30 @@ static int del_dir_item(struct btrfs_trans_handle *trans,
 	unsigned long *ptr;
 	u64 file_objectid;
 	struct btrfs_dir_item *di;
-	struct btrfs_path map_path;
 
 	/* 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_dir_objectid(di);
+	file_objectid = btrfs_disk_key_objectid(&di->location);
 
 	/* delete the directory item */
 	ret = btrfs_del_item(trans, root, path);
 	if (ret)
-		goto out;
+		goto out_release;
+	btrfs_release_path(path);
 
-	/* delete the inode mapping */
-	btrfs_init_path(&map_path);
-	ret = btrfs_lookup_inode_map(trans, root, &map_path, file_objectid, -1);
+	/* 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->fs_info->inode_root, &map_path);
+	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;
-	btrfs_release_path(root, &map_path);
 	ptr = radix_tree_delete(radix, radix_index);
 	if (!ptr) {
 		ret = -5555;
@@ -174,10 +210,10 @@ static int del_dir_item(struct btrfs_trans_handle *trans,
 	}
 	return 0;
 out_release:
-	btrfs_release_path(root, &map_path);
+	btrfs_release_path(path);
 out:
 	printf("failed to delete %lu %d\n", radix_index, ret);
-	return -1;
+	return ret;
 }
 
 static int del_one(struct btrfs_trans_handle *trans, struct btrfs_root *root,
@@ -201,12 +237,11 @@ static int del_one(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 	ret = del_dir_item(trans, root, radix, oid, &path);
 	if (ret)
 		goto out_release;
-	btrfs_release_path(root, &path);
 	return ret;
 out_release:
-	btrfs_release_path(root, &path);
+	btrfs_release_path(&path);
 	printf("failed to delete %lu %d\n", oid, ret);
-	return -1;
+	return ret;
 }
 
 static int lookup_item(struct btrfs_trans_handle *trans, struct btrfs_root
@@ -229,15 +264,12 @@ static int lookup_item(struct btrfs_trans_handle *trans, struct btrfs_root
 	if (!ret) {
 		di = btrfs_item_ptr(&path.nodes[0]->leaf, path.slots[0],
 				    struct btrfs_dir_item);
-		objectid = btrfs_dir_objectid(di);
-		btrfs_release_path(root, &path);
-		btrfs_init_path(&path);
-		ret = btrfs_lookup_inode_map(trans, root, &path, objectid, 0);
+		objectid = btrfs_disk_key_objectid(&di->location);
 	}
-	btrfs_release_path(root, &path);
+	btrfs_release_path(&path);
 	if (ret) {
 		printf("unable to find key %lu\n", oid);
-		return -1;
+		return ret;
 	}
 	return 0;
 }
@@ -257,10 +289,10 @@ static int lookup_enoent(struct btrfs_trans_handle *trans, struct btrfs_root
 	btrfs_init_path(&path);
 	ret = btrfs_lookup_dir_item(trans, root, &path, dir_oid, buf,
 				    strlen(buf), 0);
-	btrfs_release_path(root, &path);
+	btrfs_release_path(&path);
 	if (!ret) {
 		printf("able to find key that should not exist %lu\n", oid);
-		return -1;
+		return ret;
 	}
 	return 0;
 }
@@ -280,18 +312,18 @@ static int empty_tree(struct btrfs_trans_handle *trans, struct btrfs_root
 
 	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(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;
@@ -310,15 +342,14 @@ static int empty_tree(struct btrfs_trans_handle *trans, struct btrfs_root
 			fprintf(stderr,
 				"failed to remove %lu from tree\n",
 				found);
-			return -1;
+			return ret;
 		}
-		btrfs_release_path(root, &path);
 		if (!keep_running)
 			break;
 	}
 	return 0;
 	fprintf(stderr, "failed to delete from the radix %lu\n", found);
-	return -1;
+	return ret;
 }
 
 static int fill_tree(struct btrfs_trans_handle *trans, struct btrfs_root *root,
@@ -404,15 +435,22 @@ int main(int ac, char **av)
 	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) {
@@ -447,14 +485,19 @@ int main(int ac, char **av)
 				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](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;
@@ -470,6 +513,6 @@ int main(int ac, char **av)
 	}
 out:
 	close_ctree(root, &super);
-	return err;
+	return !!err;
 }