exec, mmap, musl: dynamic linking

A program that names an interpreter in PT_INTERP gets it loaded too, at
the bottom of the mmap area, and started instead -- with AT_PHDR,
AT_PHENT, AT_PHNUM, AT_BASE and AT_ENTRY to find the program by. ET_DYN
images are placed at a base: the interpreter there, a PIE program where
a fixed one would go. Static musl programs get AT_PHDR now as well,
which is how musl finds their TLS template.

mmap(MAP_FIXED) of a file handed back zeroed pages whatever the
descriptor said, and kept no record of them, so fork() did not copy
them. A dynamic linker maps every library segment after the first that
way. Fixed mappings now read the file and are recorded wherever no
mapping already covers them.

musl is built shared as well as static, and libc.so ships as
/lib/ld-musl-x86_64.so.1 -- libc and loader in one file. Every port
still links -static on purpose.

cmd/dynhello is the test: against libc.so and a library of its own,
checking TLS, the heap, and a fork whose child still has both.
mprotect is accepted and not enforced yet.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01S1giNvrHTrPMPw7V6x1kQ4

cmd/dynhello/lib.c

@@ -0,0 +1,14 @@
+// libdynhello.so: a shared library that is not libc, so that dynhello proves
+// the dynamic linker can find, map and bind something it was not born with.
+
+#include <stdio.h>
+
+static int calls;
+
+int
+dynhello_greet(const char *who)
+{
+    calls++;
+    return printf("dynhello: hello, %s, from a shared library (call %d)\n",
+                  who, calls);
+}

cmd/dynhello/main.c

@@ -0,0 +1,55 @@
+// dynhello: the smallest honest test of dynamic linking.
+//
+// Linked against libc.so and libdynhello.so, with /lib/ld-musl-x86_64.so.1 as
+// its interpreter, so nothing here works unless the kernel loaded the
+// interpreter and the interpreter mapped both libraries. It then checks the
+// three things a dynamic program leans on that a static one hides: thread-
+// local storage (errno), the heap, and a fork whose child still has its
+// libraries.
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+int dynhello_greet(const char *who);
+
+int
+main(int argc, char **argv)
+{
+    int bad = 0;
+
+    dynhello_greet(argc > 1 ? argv[1] : "world");
+
+    errno = 0;
+    if (close(-1) == 0 || errno != EBADF) {
+        printf("dynhello: FAIL errno is %d, not EBADF\n", errno);
+        bad++;
+    }
+
+    char *p = malloc(1 << 20);
+    if (!p) {
+        printf("dynhello: FAIL malloc\n");
+        bad++;
+    } else {
+        memset(p, 0x5a, 1 << 20);
+        free(p);
+    }
+
+    pid_t pid = fork();
+    if (pid == 0) {
+        dynhello_greet("child");
+        _exit(0);
+    }
+    int st = 0;
+    if (pid < 0 || waitpid(pid, &st, 0) != pid || !WIFEXITED(st) ||
+        WEXITSTATUS(st) != 0) {
+        printf("dynhello: FAIL fork child status %d\n", st);
+        bad++;
+    }
+
+    printf("dynhello: %s\n", bad ? "FAILED" : "ok");
+    return bad != 0;
+}