1 files changed, 15 insertions, 78 deletions
diff --git a/fs/btrfs/inode-map.c b/fs/btrfs/inode-map.c
index 9abbced1123d..c56eb5909172 100644
--- a/fs/btrfs/inode-map.c
+++ b/fs/btrfs/inode-map.c
@@ -43,9 +43,10 @@ int btrfs_find_highest_inode(struct btrfs_root *root, u64 *objectid)
                slot = path->slots[0] - 1;
                l = path->nodes[0];
                btrfs_item_key_to_cpu(l, &found_key, slot);
-                *objectid = found_key.objectid;
+                *objectid = max_t(u64, found_key.objectid,
+                                  BTRFS_FIRST_FREE_OBJECTID - 1);
        } else {
-                *objectid = BTRFS_FIRST_FREE_OBJECTID;
+                *objectid = BTRFS_FIRST_FREE_OBJECTID - 1;
        }
        ret = 0;
 error:
@@ -53,91 +54,27 @@ error:
        return ret;
 }
-/*
- * walks the btree of allocated inodes and find a hole.
- */
 int btrfs_find_free_objectid(struct btrfs_trans_handle *trans,
                             struct btrfs_root *root,
                             u64 dirid, u64 *objectid)
 {
-        struct btrfs_path *path;
-        struct btrfs_key key;
        int ret;
-        int slot = 0;
-        u64 last_ino = 0;
-        int start_found;
-        struct extent_buffer *l;
-        struct btrfs_key search_key;
-        u64 search_start = dirid;
        mutex_lock(&root->objectid_mutex);
-        if (root->last_inode_alloc >= BTRFS_FIRST_FREE_OBJECTID &&
-            root->last_inode_alloc < BTRFS_LAST_FREE_OBJECTID) {
-                *objectid = ++root->last_inode_alloc;
-                mutex_unlock(&root->objectid_mutex);
-                return 0;
-        }
-        path = btrfs_alloc_path();
-        BUG_ON(!path);
-        search_start = max(search_start, (u64)BTRFS_FIRST_FREE_OBJECTID);
-        search_key.objectid = search_start;
-        search_key.type = 0;
-        search_key.offset = 0;
-        start_found = 0;
-        ret = btrfs_search_slot(trans, root, &search_key, path, 0, 0);
-        if (ret < 0)
-                goto error;
-        while (1) {
+        if (unlikely(root->highest_objectid < BTRFS_FIRST_FREE_OBJECTID)) {
-                l = path->nodes[0];
+                ret = btrfs_find_highest_inode(root, &root->highest_objectid);
-                slot = path->slots[0];
+                if (ret)
-                if (slot >= btrfs_header_nritems(l)) {
+                        goto out;
-                        ret = btrfs_next_leaf(root, path);
+        }
-                        if (ret == 0)
-                                continue;
-                        if (ret < 0)
-                                goto error;
-                        if (!start_found) {
-                                *objectid = search_start;
-                                start_found = 1;
-                                goto found;
-                        }
-                        *objectid = last_ino > search_start ?
-                                last_ino : search_start;
-                        goto found;
-                }
-                btrfs_item_key_to_cpu(l, &key, slot);
-                if (key.objectid >= search_start) {
-                        if (start_found) {
-                                if (last_ino < search_start)
-                                        last_ino = search_start;
-                                if (key.objectid > last_ino) {
-                                        *objectid = last_ino;
-                                        goto found;
-                                }
-                        } else if (key.objectid > search_start) {
-                                *objectid = search_start;
-                                goto found;
-                        }
-                }
-                if (key.objectid >= BTRFS_LAST_FREE_OBJECTID)
-                        break;
-                start_found = 1;
+        if (unlikely(root->highest_objectid >= BTRFS_LAST_FREE_OBJECTID)) {
-                last_ino = key.objectid + 1;
+                ret = -ENOSPC;
-                path->slots[0]++;
+                goto out;
        }
-        BUG_ON(1);
-found:
+        *objectid = ++root->highest_objectid;
-        btrfs_release_path(root, path);
+        ret = 0;
-        btrfs_free_path(path);
+out:
-        BUG_ON(*objectid < search_start);
-        mutex_unlock(&root->objectid_mutex);
-        return 0;
-error:
-        btrfs_release_path(root, path);
-        btrfs_free_path(path);
        mutex_unlock(&root->objectid_mutex);
        return ret;
 }

diff --git a/fs/btrfs/inode-map.c b/fs/btrfs/inode-map.c index 9abbced1123d..c56eb5909172 100644 --- a/fs/btrfs/inode-map.c +++ b/fs/btrfs/inode-map.c
@@ -43,9 +43,10 @@ int btrfs_find_highest_inode(struct btrfs_root root, u64 objectid)
43	slot = path->slots[0] - 1;	43	slot = path->slots[0] - 1;
44	l = path->nodes[0];	44	l = path->nodes[0];
45	btrfs_item_key_to_cpu(l, &found_key, slot);	45	btrfs_item_key_to_cpu(l, &found_key, slot);
46	*objectid = found_key.objectid;	46	*objectid = max_t(u64, found_key.objectid,
		47	BTRFS_FIRST_FREE_OBJECTID - 1);
47	} else {	48	} else {
48	*objectid = BTRFS_FIRST_FREE_OBJECTID;	49	*objectid = BTRFS_FIRST_FREE_OBJECTID - 1;
49	}	50	}
50	ret = 0;	51	ret = 0;
51	error:	52	error:
@@ -53,91 +54,27 @@ error:
53	return ret;	54	return ret;
54	}	55	}
55		56
56	/*
57	* walks the btree of allocated inodes and find a hole.
58	*/
59	int btrfs_find_free_objectid(struct btrfs_trans_handle *trans,	57	int btrfs_find_free_objectid(struct btrfs_trans_handle *trans,
60	struct btrfs_root *root,	58	struct btrfs_root *root,
61	u64 dirid, u64 *objectid)	59	u64 dirid, u64 *objectid)
62	{	60	{
63	struct btrfs_path *path;
64	struct btrfs_key key;
65	int ret;	61	int ret;
66	int slot = 0;
67	u64 last_ino = 0;
68	int start_found;
69	struct extent_buffer *l;
70	struct btrfs_key search_key;
71	u64 search_start = dirid;
72
73	mutex_lock(&root->objectid_mutex);	62	mutex_lock(&root->objectid_mutex);
74	if (root->last_inode_alloc >= BTRFS_FIRST_FREE_OBJECTID &&
75	root->last_inode_alloc < BTRFS_LAST_FREE_OBJECTID) {
76	*objectid = ++root->last_inode_alloc;
77	mutex_unlock(&root->objectid_mutex);
78	return 0;
79	}
80	path = btrfs_alloc_path();
81	BUG_ON(!path);
82	search_start = max(search_start, (u64)BTRFS_FIRST_FREE_OBJECTID);
83	search_key.objectid = search_start;
84	search_key.type = 0;
85	search_key.offset = 0;
86
87	start_found = 0;
88	ret = btrfs_search_slot(trans, root, &search_key, path, 0, 0);
89	if (ret < 0)
90	goto error;
91		63
92	while (1) {	64	if (unlikely(root->highest_objectid < BTRFS_FIRST_FREE_OBJECTID)) {
93	l = path->nodes[0];	65	ret = btrfs_find_highest_inode(root, &root->highest_objectid);
94	slot = path->slots[0];	66	if (ret)
95	if (slot >= btrfs_header_nritems(l)) {	67	goto out;
96	ret = btrfs_next_leaf(root, path);	68	}
97	if (ret == 0)
98	continue;
99	if (ret < 0)
100	goto error;
101	if (!start_found) {
102	*objectid = search_start;
103	start_found = 1;
104	goto found;
105	}
106	*objectid = last_ino > search_start ?
107	last_ino : search_start;
108	goto found;
109	}
110	btrfs_item_key_to_cpu(l, &key, slot);
111	if (key.objectid >= search_start) {
112	if (start_found) {
113	if (last_ino < search_start)
114	last_ino = search_start;
115	if (key.objectid > last_ino) {
116	*objectid = last_ino;
117	goto found;
118	}
119	} else if (key.objectid > search_start) {
120	*objectid = search_start;
121	goto found;
122	}
123	}
124	if (key.objectid >= BTRFS_LAST_FREE_OBJECTID)
125	break;
126		69
127	start_found = 1;	70	if (unlikely(root->highest_objectid >= BTRFS_LAST_FREE_OBJECTID)) {
128	last_ino = key.objectid + 1;	71	ret = -ENOSPC;
129	path->slots[0]++;	72	goto out;
130	}	73	}
131	BUG_ON(1);	74
132	found:	75	*objectid = ++root->highest_objectid;
133	btrfs_release_path(root, path);	76	ret = 0;
134	btrfs_free_path(path);	77	out:
135	BUG_ON(*objectid < search_start);
136	mutex_unlock(&root->objectid_mutex);
137	return 0;
138	error:
139	btrfs_release_path(root, path);
140	btrfs_free_path(path);
141	mutex_unlock(&root->objectid_mutex);	78	mutex_unlock(&root->objectid_mutex);
142	return ret;	79	return ret;
143	}	80	}