struct cds_ja_inode_flag *ja_linear_node_get_nth(const struct cds_ja_type *type,
struct cds_ja_inode *node,
struct cds_ja_inode_flag ***child_node_flag_ptr,
+ struct cds_ja_inode_flag ***node_flag_ptr,
uint8_t n)
{
uint8_t nr_child;
if (CMM_LOAD_SHARED(values[i]) == n)
break;
}
- if (i >= nr_child)
+ if (i >= nr_child) {
+ if (caa_unlikely(node_flag_ptr))
+ *node_flag_ptr = NULL;
return NULL;
+ }
pointers = (struct cds_ja_inode_flag **) align_ptr_size(&values[type->max_linear_child]);
ptr = rcu_dereference(pointers[i]);
if (caa_unlikely(child_node_flag_ptr) && ptr)
*child_node_flag_ptr = &pointers[i];
+ if (caa_unlikely(node_flag_ptr))
+ *node_flag_ptr = &pointers[i];
return ptr;
}
struct cds_ja_inode_flag *ja_pool_node_get_nth(const struct cds_ja_type *type,
struct cds_ja_inode *node,
struct cds_ja_inode_flag ***child_node_flag_ptr,
+ struct cds_ja_inode_flag ***node_flag_ptr,
uint8_t n)
{
struct cds_ja_inode *linear;
*/
linear = (struct cds_ja_inode *)
&node->u.data[((unsigned long) n >> (CHAR_BIT - type->nr_pool_order)) << type->pool_size_order];
- return ja_linear_node_get_nth(type, linear, child_node_flag_ptr, n);
+ return ja_linear_node_get_nth(type, linear, child_node_flag_ptr,
+ node_flag_ptr, n);
}
static
struct cds_ja_inode_flag *ja_pigeon_node_get_nth(const struct cds_ja_type *type,
struct cds_ja_inode *node,
struct cds_ja_inode_flag ***child_node_flag_ptr,
+ struct cds_ja_inode_flag ***node_flag_ptr,
uint8_t n)
{
struct cds_ja_inode_flag **child_node_flag;
child_node_flag);
if (caa_unlikely(child_node_flag_ptr) && *child_node_flag)
*child_node_flag_ptr = child_node_flag;
+ if (caa_unlikely(node_flag_ptr))
+ *node_flag_ptr = child_node_flag;
return rcu_dereference(*child_node_flag);
}
struct cds_ja_inode *node,
uint8_t i)
{
- return ja_pigeon_node_get_nth(type, node, NULL, i);
+ return ja_pigeon_node_get_nth(type, node, NULL, NULL, i);
}
/*
static
struct cds_ja_inode_flag * ja_node_get_nth(struct cds_ja_inode_flag *node_flag,
struct cds_ja_inode_flag ***child_node_flag_ptr,
+ struct cds_ja_inode_flag ***node_flag_ptr,
uint8_t n)
{
unsigned int type_index;
switch (type->type_class) {
case RCU_JA_LINEAR:
return ja_linear_node_get_nth(type, node,
- child_node_flag_ptr, n);
+ child_node_flag_ptr, node_flag_ptr, n);
case RCU_JA_POOL:
return ja_pool_node_get_nth(type, node,
- child_node_flag_ptr, n);
+ child_node_flag_ptr, node_flag_ptr, n);
case RCU_JA_PIGEON:
return ja_pigeon_node_get_nth(type, node,
- child_node_flag_ptr, n);
+ child_node_flag_ptr, node_flag_ptr, n);
default:
assert(0);
return (void *) -1UL;
uint8_t iter_key;
iter_key = (uint8_t) (key >> (JA_BITS_PER_BYTE * (tree_depth - i - 1)));
- node_flag = ja_node_get_nth(node_flag, NULL,
+ node_flag = ja_node_get_nth(node_flag, NULL, NULL,
iter_key);
dbg_printf("cds_ja_lookup iter key lookup %u finds node_flag %p\n",
(unsigned int) iter_key, node_flag);
*/
static
int ja_attach_node(struct cds_ja *ja,
+ struct cds_ja_inode_flag **attach_node_flag_ptr,
struct cds_ja_inode_flag **node_flag_ptr,
struct cds_ja_inode_flag *node_flag,
struct cds_ja_inode_flag *parent_node_flag,
}
}
+ if (node_flag_ptr && ja_node_ptr(*node_flag_ptr) != NULL) {
+ /*
+ * Attach point is non-NULL: it has been updated between
+ * RCU lookup and lock acquisition. We need to re-try
+ * lookup and attach.
+ */
+ ret = -EAGAIN;
+ goto unlock_parent;
+ }
+
/* Create new branch, starting from bottom */
CDS_INIT_HLIST_HEAD(&head);
cds_hlist_add_head_rcu(&child_node->list, &head);
/* Publish new branch */
dbg_printf("Publish branch %p, replacing %p\n",
- iter_node_flag, *node_flag_ptr);
- rcu_assign_pointer(*node_flag_ptr, iter_node_flag);
+ iter_node_flag, *attach_node_flag_ptr);
+ rcu_assign_pointer(*attach_node_flag_ptr, iter_node_flag);
/* Success */
ret = 0;
assert(!tmpret);
}
}
+unlock_parent:
if (parent_shadow_node)
rcuja_shadow_unlock(parent_shadow_node);
unlock_shadow:
struct cds_ja_shadow_node *shadow_node;
shadow_node = rcuja_shadow_lookup_lock(ja->ht, parent_node_flag);
- if (!shadow_node)
+ if (!shadow_node) {
return -EAGAIN;
+ }
cds_hlist_add_head_rcu(&node->list, head);
rcuja_shadow_unlock(shadow_node);
return 0;
struct cds_ja_node *new_node)
{
unsigned int tree_depth, i;
- struct cds_ja_inode_flag **node_flag_ptr; /* in parent */
+ struct cds_ja_inode_flag **attach_node_flag_ptr,
+ **node_flag_ptr;
struct cds_ja_inode_flag *node_flag,
*parent_node_flag,
*parent2_node_flag;
int ret;
- if (caa_unlikely(key > ja->key_max))
+ if (caa_unlikely(key > ja->key_max)) {
return -EINVAL;
+ }
tree_depth = ja->tree_depth;
retry:
parent2_node_flag = NULL;
parent_node_flag =
(struct cds_ja_inode_flag *) &ja->root; /* Use root ptr address as key for mutex */
+ attach_node_flag_ptr = &ja->root;
node_flag_ptr = &ja->root;
node_flag = rcu_dereference(ja->root);
for (i = 1; i < tree_depth; i++) {
uint8_t iter_key;
- dbg_printf("cds_ja_add iter node_flag_ptr %p node_flag %p\n",
- *node_flag_ptr, node_flag);
+ dbg_printf("cds_ja_add iter attach_node_flag_ptr %p node_flag_ptr %p node_flag %p\n",
+ *attach_node_flag_ptr, *node_flag_ptr, node_flag);
if (!ja_node_ptr(node_flag)) {
- ret = ja_attach_node(ja, node_flag_ptr,
+ ret = ja_attach_node(ja, attach_node_flag_ptr,
+ node_flag_ptr,
parent_node_flag, parent2_node_flag,
key, i, new_node);
if (ret == -EAGAIN || ret == -EEXIST)
parent2_node_flag = parent_node_flag;
parent_node_flag = node_flag;
node_flag = ja_node_get_nth(node_flag,
+ &attach_node_flag_ptr,
&node_flag_ptr,
iter_key);
- dbg_printf("cds_ja_add iter key lookup %u finds node_flag %p node_flag_ptr %p\n",
- (unsigned int) iter_key, node_flag, *node_flag_ptr);
+ dbg_printf("cds_ja_add iter key lookup %u finds node_flag %p attach_node_flag_ptr %p node_flag_ptr %p\n",
+ (unsigned int) iter_key, node_flag,
+ *attach_node_flag_ptr,
+ *node_flag_ptr);
}
/*
* level, or chain it if key is already present.
*/
if (!ja_node_ptr(node_flag)) {
- dbg_printf("cds_ja_add last node_flag_ptr %p node_flag %p\n",
- *node_flag_ptr, node_flag);
- ret = ja_attach_node(ja, node_flag_ptr, parent_node_flag,
+ dbg_printf("cds_ja_add last attach_node_flag_ptr %p node_flag_ptr %p node_flag %p\n",
+ *attach_node_flag_ptr, *node_flag_ptr, node_flag);
+ ret = ja_attach_node(ja, attach_node_flag_ptr,
+ node_flag_ptr, parent_node_flag,
parent2_node_flag, key, i, new_node);
} else {
ret = ja_chain_node(ja,
parent_node_flag,
- (struct cds_hlist_head *) node_flag_ptr,
+ (struct cds_hlist_head *) attach_node_flag_ptr,
new_node);
}
- if (ret == -EAGAIN)
+ if (ret == -EAGAIN || ret == -EEXIST)
goto retry;
end:
return ret;
* ensure that when a match value -> pointer is found in a node, it is
* _NEVER_ changed for that node without recompaction, and recompaction
* reallocates the node.
+ * However, when a child is removed from "linear" nodes, its pointer
+ * is set to NULL. We therefore check, while holding the locks, if this
+ * pointer is NULL, and return -ENOENT to the caller if it is the case.
*/
static
int ja_detach_node(struct cds_ja *ja,
}
}
+ /*
+ * Check if node has been removed between RCU lookup and lock
+ * acquisition.
+ */
+ assert(node_flag_ptr);
+ if (ja_node_ptr(*node_flag_ptr) == NULL) {
+ ret = -ENOENT;
+ goto end;
+ }
+
/*
* At this point, we want to delete all nodes that are about to
* be removed from shadow_nodes (except the last one, which is
&iter_node_flag, /* Old new parent ptr in its parent */
shadow_nodes[nr_branch - 1], /* of parent */
n);
+ if (ret)
+ goto end;
dbg_printf("ja_detach_node: publish %p instead of %p\n",
iter_node_flag, *parent_node_flag_ptr);
snapshot[nr_snapshot++] = node_flag;
node_flag = ja_node_get_nth(node_flag,
&prev_node_flag_ptr,
+ NULL,
iter_key);
dbg_printf("cds_ja_del iter key lookup %u finds node_flag %p, prev_node_flag_ptr %p\n",
(unsigned int) iter_key, node_flag,
&hlist_head, match);
}
}
- if (ret == -EAGAIN)
+ /*
+ * Explanation of -ENOENT handling: caused by concurrent delete
+ * between RCU lookup and actual removal. Need to re-do the
+ * lookup and removal attempt.
+ */
+ if (ret == -EAGAIN || ret == -ENOENT)
goto retry;
return ret;
}
switch (key_bits) {
case 8:
- ja->key_max = UINT8_MAX;
- break;
case 16:
- ja->key_max = UINT16_MAX;
- break;
+ case 24:
case 32:
- ja->key_max = UINT32_MAX;
+ case 40:
+ case 48:
+ case 56:
+ ja->key_max = (1ULL << key_bits) - 1;
break;
case 64:
ja->key_max = UINT64_MAX;
projects / urcu.git / blobdiff