Changeset d30e067 in mainline for uspace/lib/c

Timestamp:

2025-03-02T20:02:33Z (5 months ago)

Author:

Miroslav Cimerman <mc@…>

Children:

8cdf360

Parents:

7debda3 (diff), 4285f384 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge 'upstream/master' into helenraid-para

Location:

uspace/lib/c

Files:

• arch/arm32/src/atomic.c (modified) (2 diffs)
• generic/device/hw_res.c (modified) (2 diffs)
• generic/elf/elf_load.c (modified) (1 diff)
• generic/libc.c (modified) (1 diff)
• generic/rtld/module.c (modified) (3 diffs)
• generic/rtld/rtld.c (modified) (5 diffs)
• generic/thread/fibril_synch.c (modified) (5 diffs)
• generic/thread/tls.c (modified) (5 diffs)
• include/device/hw_res.h (modified) (4 diffs)
• include/rtld/module.h (modified) (1 diff)
• include/rtld/rtld.h (modified) (1 diff)

uspace/lib/c/arch/arm32/src/atomic.c

@@ -86 +86 @@
 }
 
+unsigned char __atomic_exchange_1(volatile void *mem0, unsigned char val,
+    int model)
+{
+        volatile unsigned char *mem = mem0;
+
+        (void) model;
+
+        unsigned ret;
+
+        /*
+         * The following instructions between labels 1 and 2 constitute a
+         * Restartable Atomic Seqeunce. Should the sequence be non-atomic,
+         * the kernel will restart it.
+         */
+        asm volatile (
+            "1:\n"
+            "   adr %[ret], 1b\n"
+            "   str %[ret], %[rp0]\n"
+            "   adr %[ret], 2f\n"
+            "   str %[ret], %[rp1]\n"
+            "   ldrb %[ret], %[addr]\n"
+            "   strb %[imm], %[addr]\n"
+            "2:\n"
+            : [ret] "=&r" (ret),
+              [rp0] "=m" (ras_page[0]),
+              [rp1] "=m" (ras_page[1]),
+              [addr] "+m" (*mem)
+            : [imm] "r" (val)
+        );
+
+        ras_page[0] = 0;
+        ras_page[1] = 0xffffffff;
+
+        return ret;
+}
+
+unsigned short __atomic_exchange_2(volatile void *mem0, unsigned short val,
+    int model)
+{
+        volatile unsigned short *mem = mem0;
+
+        (void) model;
+
+        unsigned ret;
+
+        /*
+         * The following instructions between labels 1 and 2 constitute a
+         * Restartable Atomic Seqeunce. Should the sequence be non-atomic,
+         * the kernel will restart it.
+         */
+        asm volatile (
+            "1:\n"
+            "   adr %[ret], 1b\n"
+            "   str %[ret], %[rp0]\n"
+            "   adr %[ret], 2f\n"
+            "   str %[ret], %[rp1]\n"
+            "   ldrh %[ret], %[addr]\n"
+            "   strh %[imm], %[addr]\n"
+            "2:\n"
+            : [ret] "=&r" (ret),
+              [rp0] "=m" (ras_page[0]),
+              [rp1] "=m" (ras_page[1]),
+              [addr] "+m" (*mem)
+            : [imm] "r" (val)
+        );
+
+        ras_page[0] = 0;
+        ras_page[1] = 0xffffffff;
+
+        return ret;
+}
+
+unsigned __atomic_exchange_4(volatile void *mem0, unsigned val, int model)
+{
+        volatile unsigned *mem = mem0;
+
+        (void) model;
+
+        unsigned ret;
+
+        /*
+         * The following instructions between labels 1 and 2 constitute a
+         * Restartable Atomic Seqeunce. Should the sequence be non-atomic,
+         * the kernel will restart it.
+         */
+        asm volatile (
+            "1:\n"
+            "   adr %[ret], 1b\n"
+            "   str %[ret], %[rp0]\n"
+            "   adr %[ret], 2f\n"
+            "   str %[ret], %[rp1]\n"
+            "   ldr %[ret], %[addr]\n"
+            "   str %[imm], %[addr]\n"
+            "2:\n"
+            : [ret] "=&r" (ret),
+              [rp0] "=m" (ras_page[0]),
+              [rp1] "=m" (ras_page[1]),
+              [addr] "+m" (*mem)
+            : [imm] "r" (val)
+        );
+
+        ras_page[0] = 0;
+        ras_page[1] = 0xffffffff;
+
+        return ret;
+}
+
 unsigned short __atomic_fetch_add_2(volatile void *mem0, unsigned short val,
     int model)
@@ -164 +271 @@
 }
 
+bool __atomic_test_and_set(volatile void *ptr, int memorder)
+{
+        volatile unsigned char *b = ptr;
+
+        unsigned char orig = __atomic_exchange_n(b, (unsigned char) true, memorder);
+        return orig != 0;
+}
+
 void __sync_synchronize(void)
 {

uspace/lib/c/generic/device/hw_res.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2024 Jiri Svoboda
+ * Copyright (c) 2025 Jiri Svoboda
  * Copyright (c) 2010 Lenka Trochtova
  * All rights reserved.
@@ -162 +162 @@
 }
 
-/** Get bus flags.
+/** Query legacy IO claims.
  *
  * @param sess HW res session
- * @param rflags Place to store the flags
- *
- * @return Error code.
- *
- */
-errno_t hw_res_get_flags(async_sess_t *sess, hw_res_flags_t *rflags)
-{
-        async_exch_t *exch = async_exchange_begin(sess);
-
-        sysarg_t flags;
+ * @param rclaims Place to store the claims
+ *
+ * @return Error code.
+ *
+ */
+errno_t hw_res_query_legacy_io(async_sess_t *sess, hw_res_claims_t *rclaims)
+{
+        async_exch_t *exch = async_exchange_begin(sess);
+
+        sysarg_t claims;
         const errno_t ret = async_req_1_1(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
-            HW_RES_GET_FLAGS, &flags);
+            HW_RES_QUERY_LEGACY_IO, &claims);
 
         async_exchange_end(exch);
 
         if (ret == EOK)
-                *rflags = flags;
+                *rclaims = claims;
+
+        return ret;
+}
+
+/** Claim legacy IO devices.
+ *
+ * @param sess HW res session
+ * @param claims Claims
+ *
+ * @return Error code.
+ *
+ */
+errno_t hw_res_claim_legacy_io(async_sess_t *sess, hw_res_claims_t claims)
+{
+        async_exch_t *exch = async_exchange_begin(sess);
+
+        const errno_t ret = async_req_2_0(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
+            HW_RES_CLAIM_LEGACY_IO, claims);
+
+        async_exchange_end(exch);
 
         return ret;

uspace/lib/c/generic/elf/elf_load.c

@@ -60 +60 @@
         rtld_t *env;
 #endif
-        errno_t rc;
+        errno_t rc = EOK;
+        elf_finfo_t *finfo = &info->finfo;
 
-        rc = elf_load_file(file, 0, &info->finfo);
+        rc = elf_load_file(file, 0, finfo);
         if (rc != EOK) {
-                DPRINTF("Failed to load executable '%s'.\n", file_name);
+                DPRINTF("Failed to load executable.\n");
                 return rc;
         }
 
+#ifdef CONFIG_RTLD
+        DPRINTF("- prog dynamic: %p\n", finfo->dynamic);
+        rc = rtld_prog_process(finfo, &env);
+        if (rc != EOK) {
+                DPRINTF("Failed to process executable.\n");
+                return rc;
+        }
+        info->env = env;
+        return EOK;
+#else
         if (info->finfo.dynamic == NULL) {
-                /* Statically linked program */
-                DPRINTF("Binary is statically linked.\n");
                 info->env = NULL;
                 return EOK;
         }
 
-        DPRINTF("Binary is dynamically linked.\n");
-#ifdef CONFIG_RTLD
-        DPRINTF("- prog dynamic: %p\n", info->finfo.dynamic);
-
-        rc = rtld_prog_process(&info->finfo, &env);
-        info->env = env;
-#else
-        rc = ENOTSUP;
+        DPRINTF("Error: trying to run a dynamically-linked executable with CONFIG_RTLD disabled.\n");
+        return ENOTSUP;
 #endif
-        return rc;
 }
 

uspace/lib/c/generic/libc.c

@@ -96 +96 @@
 
 #ifdef CONFIG_RTLD
-        if (__pcb != NULL && __pcb->rtld_runtime != NULL) {
+        if (__pcb == NULL) {
+                /*
+                 * A binary loaded by kernel, not the loader.
+                 * Noop - code loaded by kernel doesn't need RTLD.
+                 */
+        } else {
+                assert(__pcb->rtld_runtime != NULL);
                 runtime_env = (rtld_t *) __pcb->rtld_runtime;
-        } else {
-                if (rtld_init_static() != EOK)
-                        abort();
         }
 #endif

uspace/lib/c/generic/rtld/module.c

@@ -55 +55 @@
 #include "../private/libc.h"
 
-/** Create module for static executable.
- *
+/** Create the "entrypoint" module, of the program executable
+ *
+ * @param p_info Program ELF file info
  * @param rtld Run-time dynamic linker
  * @param rmodule Place to store pointer to new module or @c NULL
  * @return EOK on success, ENOMEM if out of memory
  */
-errno_t module_create_static_exec(rtld_t *rtld, module_t **rmodule)
+errno_t module_create_entrypoint(elf_finfo_t *p_info, rtld_t *rtld, module_t **rmodule)
 {
         module_t *module;
+        bool is_dynamic = p_info->dynamic != NULL;
+        DPRINTF("module_create_entrypoint\n");
 
         module = calloc(1, sizeof(module_t));
-        if (module == NULL) {
-                DPRINTF("malloc failed\n");
+        if (module == NULL)
                 return ENOMEM;
-        }
-
+
+        uintptr_t bias = elf_get_bias(p_info->base);
+
+        /*
+         * First we need to process dynamic sections of the executable
+         * program and insert it into the module graph.
+         */
+        if (is_dynamic) {
+                DPRINTF("Parse program .dynamic section at %p\n", p_info->dynamic);
+                dynamic_parse(p_info->dynamic, bias, &module->dyn);
+        } else {
+                DPRINTF("Executable is not dynamically linked\n");
+        }
+
+        module->bias = bias;
         module->id = rtld_get_next_id(rtld);
         module->dyn.soname = "[program]";
@@ -76 +91 @@
         module->rtld = rtld;
         module->exec = true;
-        module->local = true;
-
-        const elf_segment_header_t *tls =
-            elf_get_phdr(__progsymbols.elfstart, PT_TLS);
-
-        if (tls) {
-                uintptr_t bias = elf_get_bias(__progsymbols.elfstart);
-                module->tdata = (void *) (tls->p_vaddr + bias);
-                module->tdata_size = tls->p_filesz;
-                module->tbss_size = tls->p_memsz - tls->p_filesz;
-                module->tls_align = tls->p_align;
-        } else {
-                module->tdata = NULL;
-                module->tdata_size = 0;
-                module->tbss_size = 0;
-                module->tls_align = 1;
-        }
+        module->local = !is_dynamic;
+
+        module->tdata = p_info->tls.tdata;
+        module->tdata_size = p_info->tls.tdata_size;
+        module->tbss_size = p_info->tls.tbss_size;
+        module->tls_align = p_info->tls.tls_align;
+
+        DPRINTF("prog tdata at %p size %zu, tbss size %zu\n",
+        module->tdata, module->tdata_size, module->tbss_size);
 
         list_append(&module->modules_link, &rtld->modules);
@@ -398 +405 @@
          * be correct, "zero" offset (i.e. the total size) must be aligned
          * to the strictest alignment present.
-         * Note that the padding is actually in front of the TLS data,
-         * not after it.
          */
         rtld->tls_size = ALIGN_UP(rtld->tls_size, rtld->tls_align);
 
-        /* Space for the TCB. */
+        /*
+         * Space for the TCB.
+         * Later, the TLS zero offset is equal to the pointer to tcb_t, so
+         * adding the sizeof(tcb_t) block AFTER we calculated the alignment
+         * of the remainder above is correct.
+         */
         rtld->tls_size += sizeof(tcb_t);
 #endif

uspace/lib/c/generic/rtld/rtld.c

@@ -43 +43 @@
 
 rtld_t *runtime_env;
-static rtld_t rt_env_static;
-
-/** Initialize the runtime linker for use in a statically-linked executable. */
-errno_t rtld_init_static(void)
-{
-        errno_t rc;
-
-        runtime_env = &rt_env_static;
-        list_initialize(&runtime_env->modules);
-        list_initialize(&runtime_env->imodules);
-        runtime_env->program = NULL;
-        runtime_env->next_id = 1;
-
-        rc = module_create_static_exec(runtime_env, NULL);
-        if (rc != EOK)
-                return rc;
-
-        modules_process_tls(runtime_env);
-
-        return EOK;
-}
-
-/** Initialize and process a dynamically linked executable.
+
+/** Initialize and process an executable.
  *
  * @param p_info Program info
@@ -73 +52 @@
 {
         rtld_t *env;
-        module_t *prog;
-
-        DPRINTF("Load dynamically linked program.\n");
+        bool is_dynamic = p_info->dynamic != NULL;
+        DPRINTF("rtld_prog_process\n");
 
         /* Allocate new RTLD environment to pass to the loaded program */
@@ -82 +60 @@
                 return ENOMEM;
 
-        env->next_id = 1;
-
-        prog = calloc(1, sizeof(module_t));
-        if (prog == NULL) {
-                free(env);
-                return ENOMEM;
-        }
-
-        /*
-         * First we need to process dynamic sections of the executable
-         * program and insert it into the module graph.
-         */
-
-        DPRINTF("Parse program .dynamic section at %p\n", p_info->dynamic);
-        dynamic_parse(p_info->dynamic, 0, &prog->dyn);
-        prog->bias = 0;
-        prog->dyn.soname = "[program]";
-        prog->rtld = env;
-        prog->id = rtld_get_next_id(env);
-        prog->exec = true;
-        prog->local = false;
-
-        prog->tdata = p_info->tls.tdata;
-        prog->tdata_size = p_info->tls.tdata_size;
-        prog->tbss_size = p_info->tls.tbss_size;
-        prog->tls_align = p_info->tls.tls_align;
-
-        DPRINTF("prog tdata at %p size %zu, tbss size %zu\n",
-            prog->tdata, prog->tdata_size, prog->tbss_size);
-
-        /* Initialize list of loaded modules */
         list_initialize(&env->modules);
         list_initialize(&env->imodules);
-        list_append(&prog->modules_link, &env->modules);
+        env->next_id = 1;
+
+        module_t *module;
+        errno_t rc = module_create_entrypoint(p_info, env, &module);
+        if (rc != EOK) {
+                free(env);
+                return rc;
+        }
 
         /* Pointer to program module. Used as root of the module graph. */
-        env->program = prog;
+        env->program = module;
 
         /*
@@ -124 +78 @@
          */
 
-        DPRINTF("Load all program dependencies\n");
-        errno_t rc = module_load_deps(prog, 0);
-        if (rc != EOK) {
-                return rc;
+        if (is_dynamic) {
+                DPRINTF("Load all program dependencies\n");
+                rc = module_load_deps(module, 0);
+                if (rc != EOK) {
+                        free(module);
+                        free(env);
+                        return rc;
+                }
         }
 
@@ -137 +95 @@
          */
 
-        /* Process relocations in all modules */
-        DPRINTF("Relocate all modules\n");
-        modules_process_relocs(env, prog);
-
-        *rre = env;
+        if (is_dynamic) {
+                /* Process relocations in all modules */
+                DPRINTF("Relocate all modules\n");
+                modules_process_relocs(env, module);
+        }
+
+        if (rre != NULL)
+                *rre = env;
         return EOK;
 }

uspace/lib/c/generic/thread/fibril_synch.c

@@ -1 +1 @@
 /*
+ * Copyright (c) 2025 Jiri Svoboda
  * Copyright (c) 2009 Jakub Jermar
  * All rights reserved.
@@ -112 +113 @@
 #define AWAITER_INIT { .fid = fibril_get_id() }
 
-static void print_deadlock(fibril_owner_info_t *oi)
+/** Print deadlock message nad blocking chain.
+ *
+ * @param oi Owner info for the resource being acquired
+ * @param f Fibril that is trying to acquire the resource
+ */
+static void print_deadlock(fibril_owner_info_t *oi, fibril_t *f)
 {
         // FIXME: Print to stderr.
-
-        fibril_t *f = (fibril_t *) fibril_get_id();
 
         if (deadlocked) {
@@ -143 +147 @@
 }
 
-static void check_fibril_for_deadlock(fibril_owner_info_t *oi, fibril_t *fib)
-{
+/** Check whether fibril trying to acquire a resource will cause deadlock.
+ *
+ * @param wanted_oi Owner info for the primitive that the fibril wants
+ * @param fib Fibril that wants to aquire the primitive
+ */
+static void check_fibril_for_deadlock(fibril_owner_info_t *wanted_oi,
+    fibril_t *fib)
+{
+        fibril_owner_info_t *oi;
+
         futex_assert_is_locked(&fibril_synch_futex);
 
+        oi = wanted_oi;
         while (oi && oi->owned_by) {
                 if (oi->owned_by == fib) {
                         futex_unlock(&fibril_synch_futex);
-                        print_deadlock(oi);
+                        print_deadlock(wanted_oi, fib);
                         abort();
                 }
@@ -157 +170 @@
 }
 
+/** Check whether trying to acquire a resource will cause deadlock.
+ *
+ * @param oi Owner info for the primitive that the current fibril wants
+ */
 static void check_for_deadlock(fibril_owner_info_t *oi)
 {
@@ -246 +263 @@
         futex_lock(&fibril_synch_futex);
 
-        if (!frw->writers) {
+        if (!frw->writers && list_empty(&frw->waiters)) {
                 /* Consider the first reader the owner. */
                 if (frw->readers++ == 0)

uspace/lib/c/generic/thread/tls.c

@@ -59 +59 @@
 #endif
 
-static ptrdiff_t _tcb_data_offset(void)
+static ptrdiff_t _tcb_data_offset(const void *elf)
 {
         const elf_segment_header_t *tls =
-            elf_get_phdr(__progsymbols.elfstart, PT_TLS);
+            elf_get_phdr(elf, PT_TLS);
 
         size_t tls_align = tls ? tls->p_align : 1;
@@ -74 +74 @@
 }
 
-/** Get address of static TLS block */
+/** Get address of static TLS block - only when RTLD is not initialized  */
 void *tls_get(void)
 {
@@ -80 +80 @@
         assert(runtime_env == NULL);
 #endif
-        return (uint8_t *)__tcb_get() + _tcb_data_offset();
+        return (uint8_t *)__tcb_get() + _tcb_data_offset(__progsymbols.elfstart);
 }
 
 static tcb_t *tls_make_generic(const void *elf, void *(*alloc)(size_t, size_t))
 {
+        /*
+         * See also rtld/module.c -> modules_process_tls(), where we have less
+         * messy code for the dynamic-linking version of this.
+         */
         assert(!elf_get_phdr(elf, PT_DYNAMIC));
 #ifdef CONFIG_RTLD
@@ -100 +104 @@
         assert(tls_align <= PAGE_SIZE);
 
+        /*
+         * FIXME: the calculation of alloc_size shouldn't include the alignment
+         * of tcb_t (at least in Variant II)
+         * See https://github.com/HelenOS/helenos/pull/240/files/4ef27ebf98a0656e09889b7d00efdec03343f1aa#r1929592924
+         * (you will also need to fix _tcb_data_offset)
+         */
+
 #ifdef CONFIG_TLS_VARIANT_1
         size_t alloc_size =
@@ -114 +125 @@
 #ifdef CONFIG_TLS_VARIANT_1
         tcb_t *tcb = area;
-        uint8_t *data = (uint8_t *)tcb + _tcb_data_offset();
+        uint8_t *data = (uint8_t *)tcb + _tcb_data_offset(elf);
         memset(tcb, 0, sizeof(*tcb));
 #else
         uint8_t *data = area;
-        tcb_t *tcb = (tcb_t *) (data - _tcb_data_offset());
+        tcb_t *tcb = (tcb_t *) (data - _tcb_data_offset(elf));
         memset(tcb, 0, sizeof(tcb_t));
         tcb->self = tcb;

uspace/lib/c/include/device/hw_res.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2024 Jiri Svoboda
+ * Copyright (c) 2025 Jiri Svoboda
  * Copyright (c) 2010 Lenka Trochtova
  * All rights reserved.
@@ -57 +57 @@
         HW_RES_DMA_CHANNEL_SETUP,
         HW_RES_DMA_CHANNEL_REMAIN,
-        HW_RES_GET_FLAGS
+        HW_RES_QUERY_LEGACY_IO,
+        HW_RES_CLAIM_LEGACY_IO
 } hw_res_method_t;
 
@@ -118 +119 @@
 }
 
+/** Claims to legacy devices */
 typedef enum {
-        /** This is an PCI/ISA bridge, not 'classic' ISA bus */
-        hwf_isa_bridge = 0x1
-} hw_res_flags_t;
+        /** 'Legacy' ISA IDE I/O ranges */
+        hwc_isa_ide = 0x1
+} hw_res_claims_t;
 
 extern errno_t hw_res_get_resource_list(async_sess_t *, hw_resource_list_t *);
@@ -131 +133 @@
     uint32_t, uint8_t);
 extern errno_t hw_res_dma_channel_remain(async_sess_t *, unsigned, size_t *);
-extern errno_t hw_res_get_flags(async_sess_t *, hw_res_flags_t *);
+extern errno_t hw_res_query_legacy_io(async_sess_t *, hw_res_claims_t *);
+extern errno_t hw_res_claim_legacy_io(async_sess_t *, hw_res_claims_t);
 
 #endif

uspace/lib/c/include/rtld/module.h

@@ -41 +41 @@
 #include <types/rtld/rtld.h>
 
-extern errno_t module_create_static_exec(rtld_t *, module_t **);
+extern errno_t module_create_entrypoint(elf_finfo_t *, rtld_t *, module_t **);
 extern void module_process_relocs(module_t *);
 extern module_t *module_find(rtld_t *, const char *);

uspace/lib/c/include/rtld/rtld.h

@@ -45 +45 @@
 extern rtld_t *runtime_env;
 
-extern errno_t rtld_init_static(void);
 extern errno_t rtld_prog_process(elf_finfo_t *, rtld_t **);
 extern tcb_t *rtld_tls_make(rtld_t *);