Changes in / [797ab95:88cbc66] in mainline

Location:

uspace/lib

Files:

• c/generic/libc.c (modified) (2 diffs)
• c/generic/private/fibril.h (modified) (2 diffs)
• c/generic/rtld/symbol.c (modified) (1 diff)
• c/generic/thread/fibril.c (modified) (4 diffs)
• c/include/fibril.h (modified) (1 diff)
• c/meson.build (modified) (1 diff)
• c/test/fibril/exit_hook.c (added)
• c/test/main.c (modified) (1 diff)
• posix/meson.build (modified) (1 diff)
• posix/src/pthread/keys.c (modified) (1 diff)
• posix/test/main.c (modified) (1 diff)
• posix/test/pthread/keys.c (added)

uspace/lib/c/generic/libc.c

@@ -81 +81 @@
                 main_fibril.tcb = tls_make_initial(__progsymbols.elfstart);
         }
+        main_fibril.is_freeable = false;
 
         assert(main_fibril.tcb);
@@ -172 +173 @@
 void __libc_exit(int status)
 {
+        fibril_run_exit_hooks(&main_fibril);
+
         /*
          * GCC extension __attribute__((destructor)),

uspace/lib/c/generic/private/fibril.h

@@ -70 +70 @@
         fibril_owner_info_t *waits_for;
         fibril_event_t *sleep_event;
+
+        list_t exit_hooks;
 };
+
+typedef struct {
+        link_t link;
+        void (*func)(void);
+} fibril_hook_t;
 
 extern fibril_t *fibril_alloc(void);
@@ -86 +93 @@
 extern errno_t fibril_ipc_wait(ipc_call_t *, const struct timespec *);
 extern void fibril_ipc_poke(void);
+
+extern void fibril_run_exit_hooks(fibril_t *);
 
 /**

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

@@ -65 +65 @@
 static elf_symbol_t *def_find_in_module(const char *name, module_t *m)
 {
+        if (m->dyn.hash == NULL) {
+                /* No hash table */
+                return NULL;
+        }
+
         elf_symbol_t *sym_table;
         elf_symbol_t *s, *sym;

uspace/lib/c/generic/thread/fibril.c

@@ -185 +185 @@
 void fibril_setup(fibril_t *f)
 {
+        list_initialize(&f->exit_hooks);
         futex_lock(&fibril_futex);
         list_append(&f->all_link, &fibril_list);
@@ -845 +846 @@
 }
 
+void fibril_run_exit_hooks(fibril_t *f)
+{
+        list_foreach_safe(f->exit_hooks, cur, _next) {
+                fibril_hook_t *hook = list_get_instance(cur, fibril_hook_t, link);
+                list_remove(cur);
+                hook->func();
+                free(hook);
+        }
+}
+
 /**
  * Exit a fibril. Never returns.
@@ -854 +865 @@
         // TODO: implement fibril_join() and remember retval
         (void) retval;
+
+        fibril_run_exit_hooks(fibril_self());
 
         fibril_t *f = _ready_list_pop_nonblocking(false);
@@ -918 +931 @@
 }
 
+errno_t fibril_add_exit_hook(void (*hook)(void))
+{
+        fibril_hook_t *h = malloc(sizeof(fibril_hook_t));
+        if (!h)
+                return ENOMEM;
+
+        DPRINTF("adding exit hook: function %p (fibril_hook_t structure at %p)\n", hook, h);
+
+        h->func = hook;
+        list_append(&h->link, &fibril_self()->exit_hooks);
+        return EOK;
+}
+
 errno_t fibril_ipc_wait(ipc_call_t *call, const struct timespec *expires)
 {

uspace/lib/c/include/fibril.h

@@ -74 +74 @@
 extern __noreturn void fibril_exit(long);
 
+/** Add a function to be called after fibril exits, just before it is destroyed */
+extern errno_t fibril_add_exit_hook(void (*)(void));
+
 __HELENOS_DECLS_END;
 

uspace/lib/c/meson.build

@@ -177 +177 @@
         'test/double_to_str.c',
         'test/fibril/timer.c',
+        'test/fibril/exit_hook.c',
         'test/getopt.c',
         'test/gsort.c',

uspace/lib/c/test/main.c

@@ -38 +38 @@
 PCUT_IMPORT(double_to_str);
 PCUT_IMPORT(fibril_timer);
+PCUT_IMPORT(fibril_exit_hook);
 PCUT_IMPORT(getopt);
 PCUT_IMPORT(gsort);

uspace/lib/posix/meson.build

@@ -61 +61 @@
         'test/stdlib.c',
         'test/unistd.c',
+        'test/pthread/keys.c',
 )
 

uspace/lib/posix/src/pthread/keys.c

@@ -36 +36 @@
 #include <pthread.h>
 #include <errno.h>
+#include <fibril.h>
+#include <stdatomic.h>
 #include "../internal/common.h"
+
+#define DPRINTF(format, ...) ((void) 0)
+
+static fibril_local bool fibril_initialized = false;
+static atomic_ushort next_key = 1; // skip the key 'zero'
+
+/*
+ * For now, we just support maximum of 100 keys. This can be improved
+ * in the future by implementing a dynamically growing array with
+ * reallocations, but that will require more synchronization.
+ */
+#define PTHREAD_KEYS_MAX 100
+static void (*destructors[PTHREAD_KEYS_MAX])(void *);
+
+static fibril_local void *key_data[PTHREAD_KEYS_MAX];
 
 void *pthread_getspecific(pthread_key_t key)
 {
-        not_implemented();
-        return NULL;
+        // initialization is done in setspecific -> if not initialized, nothing was set yet
+        if (!fibril_initialized)
+                return NULL;
+
+        assert(key < PTHREAD_KEYS_MAX);
+        assert(key < next_key);
+        assert(key > 0);
+
+        return key_data[key];
+}
+
+static void pthread_key_on_fibril_exit(void)
+{
+        if (!fibril_initialized)
+                return;
+
+        for (unsigned i = 0; i < PTHREAD_KEYS_MAX; i++) {
+                /*
+                 * Note that this doesn't cause a race with pthread_key_create:
+                 * if key `i` has not been assigned yet (it could be just being
+                 * created), key_data[i] has never been assigned, therefore it
+                 * is NULL, and the destructor is not checked at all.
+                 */
+                if (key_data[i] != NULL && destructors[i] != NULL)
+                        destructors[i](key_data[i]);
+        }
 }
 
 int pthread_setspecific(pthread_key_t key, const void *data)
 {
-        not_implemented();
-        return ENOTSUP;
+        if (!fibril_initialized) {
+                DPRINTF("initializing pthread keys\n");
+                errno_t res = fibril_add_exit_hook(pthread_key_on_fibril_exit);
+                if (res != EOK)
+                        return res;
+
+                for (unsigned i = 0; i < PTHREAD_KEYS_MAX; i++) {
+                        key_data[i] = NULL;
+                }
+                fibril_initialized = true;
+        }
+        assert(key < PTHREAD_KEYS_MAX);
+        assert(key < next_key);
+        assert(key > 0);
+
+        key_data[key] = (void *) data;
+        return EOK;
 }
 
 int pthread_key_delete(pthread_key_t key)
 {
-        not_implemented();
-        return ENOTSUP;
+        /*
+         * FIXME: this can cause a data race if another fibrill concurrently
+         * runs on_fibril_exit. The obvious solution is to add a rwlock on
+         * the destructors array, which will be needed anyway if we want to
+         * support unlimited number of keys.
+         */
+        destructors[key] = NULL;
+        key_data[key] = NULL;
+
+        // TODO: the key could also be reused
+        return EOK;
 }
 
 int pthread_key_create(pthread_key_t *key, void (*destructor)(void *))
 {
-        not_implemented();
-        return ENOTSUP;
+        unsigned short k = atomic_fetch_add(&next_key, 1);
+        if (k >= PTHREAD_KEYS_MAX) {
+                atomic_store(&next_key, PTHREAD_KEYS_MAX + 1);
+                return ELIMIT;
+        }
+
+        destructors[k] = destructor;
+        *key = k;
+        return EOK;
 }
 

uspace/lib/posix/test/main.c

@@ -34 +34 @@
 PCUT_IMPORT(stdlib);
 PCUT_IMPORT(unistd);
+PCUT_IMPORT(pthread_keys);
 
 PCUT_MAIN();