lookup without holding the lock during registration

global_lock is a source of contention when multiple threads/cores
are adding stats concurrently, e.g. when a volume is being created
so every core has to create a set of volume stats.

This contention is mostly redundant as every directory in the root
and the entire sub-tree under it is only modified by the core
that owns it.

While a better solution would be to have a separate lock for each
of these sub-trees, we can reduce the contention by holding the lock
for a shorter period of time.
One of the suspected long locked periods is lookup for duplicate
entry done in register_item(): this walks the list, which is O(N)
and can be expensive for the "namespaces" directory with 10K entries.

Based on the above, we lookup for duplicates without holding a lock,
unless looking up in the root directory.

List modification as well as item initialization is still done under lock
to make sure the fuse interface always finds the directory and the
item in a consistent state.

Issue: LBM1-19873

Signed-off-by: Anton Eidelman <anton@lightbitslabs.com>

Author: anton-lb

src/procstat.c

@@ -779,17 +779,32 @@ static int register_item(struct procstat_context *context,
 			 struct procstat_item *item,
 			 struct procstat_directory *parent)
 {
-	pthread_mutex_lock(&context->global_lock);
-	if (parent) {
+	if (likely(parent)) {
 		struct procstat_item *duplicate;
+		bool locked = false;
+
+		if (unlikely(root_directory(context, parent))) {
+			/* Only root directory can be modified concurrently by different threads */
+			pthread_mutex_lock(&context->global_lock);
+			locked = true;
+		}
 
 		duplicate = lookup_item_locked(parent, procstat_item_name(item), item->name_hash);
-		if (duplicate) {
-			pthread_mutex_unlock(&context->global_lock);
+		if (unlikely(duplicate)) {
+			if (locked)
+				pthread_mutex_unlock(&context->global_lock);
 			return EEXIST;
 		}
+
+		if (likely(!locked))
+			pthread_mutex_lock(&context->global_lock);
+
 		list_add_tail(&item->entry, &parent->children);
+	} else {
+		pthread_mutex_lock(&context->global_lock);
 	}
+
+
 	item->flags |= STATS_ENTRY_FLAG_REGISTERED;
 	item->refcnt = 1;
 	item->parent = parent;