Allocations may need to read in block groups from the extent allocation tree,
which will require a tree search and take locks on the extent allocation
tree. But, those locks might already be held in other places, leading
to deadlocks.
Since the alloc_mutex serializes everything right now, it is safe to
skip the btree locking while caching block groups. A better fix will be
to either create a recursive lock or find a way to back off existing
locks while caching block groups.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
{
int i;
int keep = p->keep_locks;
{
int i;
int keep = p->keep_locks;
+ int skip = p->skip_locking;
for (i = 0; i < BTRFS_MAX_LEVEL; i++) {
if (!p->nodes[i])
for (i = 0; i < BTRFS_MAX_LEVEL; i++) {
if (!p->nodes[i])
}
memset(p, 0, sizeof(*p));
p->keep_locks = keep;
}
memset(p, 0, sizeof(*p));
p->keep_locks = keep;
+ p->skip_locking = skip;
}
struct extent_buffer *btrfs_root_node(struct btrfs_root *root)
}
struct extent_buffer *btrfs_root_node(struct btrfs_root *root)
if (ins_len < 0)
lowest_unlock = 2;
again:
if (ins_len < 0)
lowest_unlock = 2;
again:
- b = btrfs_lock_root_node(root);
+ if (p->skip_locking)
+ b = btrfs_root_node(root);
+ else
+ b = btrfs_lock_root_node(root);
while (b) {
level = btrfs_header_level(b);
while (b) {
level = btrfs_header_level(b);
WARN_ON(1);
level = btrfs_header_level(b);
p->nodes[level] = b;
WARN_ON(1);
level = btrfs_header_level(b);
p->nodes[level] = b;
+ if (!p->skip_locking)
+ p->locks[level] = 1;
ret = check_block(root, p, level);
if (ret)
return -1;
ret = check_block(root, p, level);
if (ret)
return -1;
b = read_node_slot(root, b, slot);
}
}
b = read_node_slot(root, b, slot);
}
}
+ if (!p->skip_locking)
+ btrfs_tree_lock(b);
unlock_up(p, level, lowest_unlock);
} else {
p->slots[level] = slot;
unlock_up(p, level, lowest_unlock);
} else {
p->slots[level] = slot;
break;
t = path->nodes[i];
btrfs_set_node_key(t, key, tslot);
break;
t = path->nodes[i];
btrfs_set_node_key(t, key, tslot);
- if (!btrfs_tree_locked(path->nodes[i])) {
- int ii;
-printk("fixup without lock on level %d\n", btrfs_header_level(path->nodes[i]));
- for (ii = 0; ii < BTRFS_MAX_LEVEL; ii++) {
-printk("level %d slot %d\n", ii, path->slots[ii]);
- }
- }
btrfs_mark_buffer_dirty(path->nodes[i]);
if (tslot != 0)
break;
btrfs_mark_buffer_dirty(path->nodes[i]);
if (tslot != 0)
break;
reada_for_search(root, path, level, slot, 0);
next = read_node_slot(root, c, slot);
reada_for_search(root, path, level, slot, 0);
next = read_node_slot(root, c, slot);
- WARN_ON(!btrfs_tree_locked(c));
- btrfs_tree_lock(next);
+ if (!path->skip_locking) {
+ WARN_ON(!btrfs_tree_locked(c));
+ btrfs_tree_lock(next);
+ }
break;
}
path->slots[level] = slot;
break;
}
path->slots[level] = slot;
if (level == 1 && path->locks[1] && path->reada)
reada_for_search(root, path, level, slot, 0);
next = read_node_slot(root, next, 0);
if (level == 1 && path->locks[1] && path->reada)
reada_for_search(root, path, level, slot, 0);
next = read_node_slot(root, next, 0);
- WARN_ON(!btrfs_tree_locked(path->nodes[level]));
- btrfs_tree_lock(next);
+ if (!path->skip_locking) {
+ WARN_ON(!btrfs_tree_locked(path->nodes[level]));
+ btrfs_tree_lock(next);
+ }
}
done:
unlock_up(path, 0, 1);
}
done:
unlock_up(path, 0, 1);
int reada;
/* keep some upper locks as we walk down */
int keep_locks;
int reada;
/* keep some upper locks as we walk down */
int keep_locks;
return -ENOMEM;
path->reada = 2;
return -ENOMEM;
path->reada = 2;
+ /*
+ * we get into deadlocks with paths held by callers of this function.
+ * since the alloc_mutex is protecting things right now, just
+ * skip the locking here
+ */
+ path->skip_locking = 1;
first_free = block_group->key.objectid;
key.objectid = block_group->key.objectid;
key.offset = 0;
first_free = block_group->key.objectid;
key.objectid = block_group->key.objectid;
key.offset = 0;