Re: Reviving planned ldso changes

[Rich Felker <dalias@libc.org>]

[-- Attachment #1: Type: text/plain, Size: 834 bytes --]

On Tue, Jan 03, 2017 at 12:43:51AM -0500, Rich Felker wrote:
> - Dependency-order ctor execution. I think the walk order looks
>   something like, starting at a given node (initially the main app or
>   new library being loaded dynamically), traversing to its first
>   deps[] entry that hasn't been constructed, or, if none remain,
>   executing its ctors then traversing back to its needed_by. This
>   process avoids the need for any call recursion and should be
>   near-optimal (if not optimal) provided the position in a dso's
>   deps[] list is saved in the dso struct.

Attached is a proposed, completely untested patch to implement
dependency order loading, posted for review/comments. In order to
work, I think it also needs p->deps to be setup unconditionally (right
now it's only setup for dynamically loaded libs).

Rich

[-- Attachment #2: ctor_dep_order.diff --]
[-- Type: text/plain, Size: 1540 bytes --]

diff --git a/ldso/dynlink.c b/ldso/dynlink.c
index c689084..cb82b2c 100644
--- a/ldso/dynlink.c
+++ b/ldso/dynlink.c
@@ -67,6 +67,7 @@ struct dso {
 	char constructed;
 	char kernel_mapped;
 	struct dso **deps, *needed_by;
+	size_t next_dep;
 	char *rpath_orig, *rpath;
 	struct tls_module tls;
 	size_t tls_id;
@@ -1211,13 +1212,14 @@ void __libc_exit_fini()
 static void do_init_fini(struct dso *p)
 {
 	size_t dyn[DYN_CNT];
-	int need_locking = libc.threads_minus_1;
-	/* Allow recursive calls that arise when a library calls
-	 * dlopen from one of its constructors, but block any
-	 * other threads until all ctors have finished. */
-	if (need_locking) pthread_mutex_lock(&init_fini_lock);
-	for (; p; p=p->prev) {
-		if (p->constructed) continue;
+	pthread_mutex_lock(&init_fini_lock);
+	while (!p->constructed) {
+		while (p->deps[p->next_dep] && p->deps[p->next_dep]->constructed)
+			p->next_dep++;
+		if (p->deps[p->next_dep]) {
+			p = p->deps[p->next_dep++];
+			continue;
+		}
 		p->constructed = 1;
 		decode_vec(p->dynv, dyn, DYN_CNT);
 		if (dyn[0] & ((1<<DT_FINI) | (1<<DT_FINI_ARRAY))) {
@@ -1233,12 +1235,9 @@ static void do_init_fini(struct dso *p)
 			size_t *fn = laddr(p, dyn[DT_INIT_ARRAY]);
 			while (n--) ((void (*)(void))*fn++)();
 		}
-		if (!need_locking && libc.threads_minus_1) {
-			need_locking = 1;
-			pthread_mutex_lock(&init_fini_lock);
-		}
+		p = p->needed_by;
 	}
-	if (need_locking) pthread_mutex_unlock(&init_fini_lock);
+	pthread_mutex_unlock(&init_fini_lock);
 }
 
 void __libc_start_init(void)