Changeset aaa3c457 in mainline for uspace/lib/c


Ignore:
Timestamp:
2018-11-12T10:36:10Z (7 years ago)
Author:
GitHub <noreply@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a43dfcb
Parents:
3ce781f4 (diff), 6874bd2 (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.
git-author:
Jakub Jermář <jakub@…> (2018-11-12 10:36:10)
git-committer:
GitHub <noreply@…> (2018-11-12 10:36:10)
Message:

Merge pull request #56 from jermar/futexremoval

Remove kernel support for futexes in favor of waitq kobjects.

Location:
uspace/lib/c
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/async/client.c

    r3ce781f4 raaa3c457  
    122122#include "../private/fibril.h"
    123123
    124 static FIBRIL_RMUTEX_INITIALIZE(message_mutex);
     124static fibril_rmutex_t message_mutex;
    125125
    126126/** Naming service session */
    … …  
    173173void __async_client_init(void)
    174174{
     175        if (fibril_rmutex_initialize(&message_mutex) != EOK)
     176                abort();
     177
    175178        session_ns.iface = 0;
    176179        session_ns.mgmt = EXCHANGE_ATOMIC;
    … …  
    186189        fibril_mutex_initialize(&session_ns.mutex);
    187190        session_ns.exchanges = 0;
     191}
     192
     193void __async_client_fini(void)
     194{
     195        fibril_rmutex_destroy(&message_mutex);
    188196}
    189197

  • uspace/lib/c/generic/async/ports.c

    r3ce781f4 raaa3c457  
    100100
    101101/** Futex guarding the interface hash table. */
    102 static FIBRIL_RMUTEX_INITIALIZE(interface_mutex);
     102static fibril_rmutex_t interface_mutex;
    103103static hash_table_t interface_hash_table;
    104104
    … …  
    292292void __async_ports_init(void)
    293293{
     294        if (fibril_rmutex_initialize(&interface_mutex) != EOK)
     295                abort();
     296
    294297        if (!hash_table_create(&interface_hash_table, 0, 0,
    295298            &interface_hash_table_ops))
    296299                abort();
    297300}
     301
     302void __async_ports_fini(void)
     303{
     304        fibril_rmutex_destroy(&interface_mutex);
     305}

  • uspace/lib/c/generic/async/server.c

    r3ce781f4 raaa3c457  
    216216}
    217217
    218 static FIBRIL_RMUTEX_INITIALIZE(client_mutex);
     218static fibril_rmutex_t client_mutex;
    219219static hash_table_t client_hash_table;
    220220
    221221// TODO: lockfree notification_queue?
    222 static FIBRIL_RMUTEX_INITIALIZE(notification_mutex);
     222static fibril_rmutex_t notification_mutex;
    223223static hash_table_t notification_hash_table;
    224224static LIST_INITIALIZE(notification_queue);
    … …  
    10131013void __async_server_init(void)
    10141014{
     1015        if (fibril_rmutex_initialize(&client_mutex) != EOK)
     1016                abort();
     1017        if (fibril_rmutex_initialize(&notification_mutex) != EOK)
     1018                abort();
     1019
    10151020        if (!hash_table_create(&client_hash_table, 0, 0, &client_hash_table_ops))
    10161021                abort();
    … …  
    10211026
    10221027        async_create_manager();
     1028}
     1029
     1030void __async_server_fini(void)
     1031{
     1032        fibril_rmutex_destroy(&client_mutex);
     1033        fibril_rmutex_destroy(&notification_mutex);
    10231034}
    10241035

  • uspace/lib/c/generic/io/kio.c

    r3ce781f4 raaa3c457  
    3838#include <str.h>
    3939#include <stdint.h>
     40#include <stdlib.h>
    4041#include <errno.h>
    4142#include <abi/kio.h>
    … …  
    5354        char data[KIO_BUFFER_SIZE];
    5455        size_t used;
    55 } kio_buffer = { .futex = FUTEX_INITIALIZER, };
     56} kio_buffer;
     57
     58void __kio_init(void)
     59{
     60        if (futex_initialize(&kio_buffer.futex, 1) != EOK)
     61                abort();
     62}
     63
     64void __kio_fini(void)
     65{
     66        futex_destroy(&kio_buffer.futex);
     67}
    5668
    5769errno_t kio_write(const void *buf, size_t size, size_t *nwritten)

  • uspace/lib/c/generic/libc.c

    r3ce781f4 raaa3c457  
    4040#include <tls.h>
    4141#include <fibril.h>
     42#include <fibril_synch.h>
    4243#include <task.h>
    4344#include <loader/pcb.h>
    4445#include <vfs/vfs.h>
    4546#include <vfs/inbox.h>
     47#include <io/kio.h>
    4648#include "private/libc.h"
    4749#include "private/async.h"
    … …  
    6163void __libc_main(void *pcb_ptr)
    6264{
     65        __kio_init();
     66
    6367        assert(!__tcb_is_set());
    6468
    … …  
    8185
    8286        __fibrils_init();
     87        __fibril_synch_init();
    8388
    8489        /* Initialize the fibril. */
    … …  
    148153}
    149154
     155void __libc_fini(void)
     156{
     157        __async_client_fini();
     158        __async_server_fini();
     159        __async_ports_fini();
     160
     161        __fibril_synch_fini();
     162        __fibrils_fini();
     163
     164        __malloc_fini();
     165
     166        __kio_fini();
     167}
     168
    150169void __libc_exit(int status)
    151170{

  • uspace/lib/c/generic/malloc.c

    r3ce781f4 raaa3c457  
    195195
    196196/** Futex for thread-safe heap manipulation */
    197 static FIBRIL_RMUTEX_INITIALIZE(malloc_mutex);
     197static fibril_rmutex_t malloc_mutex;
    198198
    199199#define malloc_assert(expr) safe_assert(expr)
    … …  
    484484void __malloc_init(void)
    485485{
     486        if (fibril_rmutex_initialize(&malloc_mutex) != EOK)
     487                abort();
     488
    486489        if (!area_create(PAGE_SIZE))
    487490                abort();
     491}
     492
     493void __malloc_fini(void)
     494{
     495        fibril_rmutex_destroy(&malloc_mutex);
    488496}
    489497

  • uspace/lib/c/generic/private/async.h

    r3ce781f4 raaa3c457  
    9595
    9696extern void __async_server_init(void);
     97extern void __async_server_fini(void);
    9798extern void __async_client_init(void);
     99extern void __async_client_fini(void);
    98100extern void __async_ports_init(void);
     101extern void __async_ports_fini(void);
    99102
    100103extern errno_t async_create_port_internal(iface_t, async_port_handler_t,

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

    r3ce781f4 raaa3c457  
    7979
    8080extern void __fibrils_init(void);
     81extern void __fibrils_fini(void);
    8182
    8283extern void fibril_wait_for(fibril_event_t *);
    … …  
    120121} fibril_rmutex_t;
    121122
    122 #define FIBRIL_RMUTEX_INITIALIZER(name) \
    123         { .futex = FUTEX_INITIALIZE(1) }
    124 
    125 #define FIBRIL_RMUTEX_INITIALIZE(name) \
    126         fibril_rmutex_t name = FIBRIL_RMUTEX_INITIALIZER(name)
    127 
    128 extern void fibril_rmutex_initialize(fibril_rmutex_t *);
     123extern errno_t fibril_rmutex_initialize(fibril_rmutex_t *);
     124extern void fibril_rmutex_destroy(fibril_rmutex_t *);
    129125extern void fibril_rmutex_lock(fibril_rmutex_t *);
    130126extern bool fibril_rmutex_trylock(fibril_rmutex_t *);

  • uspace/lib/c/generic/private/futex.h

    r3ce781f4 raaa3c457  
    4242#include <time.h>
    4343#include <fibril.h>
     44#include <abi/cap.h>
     45#include <abi/synch.h>
    4446
    4547typedef struct futex {
    4648        volatile atomic_int val;
     49        volatile cap_waitq_handle_t whandle;
     50
    4751#ifdef CONFIG_DEBUG_FUTEX
    4852        _Atomic(fibril_t *) owner;
    … …  
    5054} futex_t;
    5155
    52 extern void futex_initialize(futex_t *futex, int value);
     56extern errno_t futex_initialize(futex_t *futex, int value);
     57
     58static inline errno_t futex_destroy(futex_t *futex)
     59{
     60        if (futex->whandle) {
     61                errno_t rc;
     62                rc = __SYSCALL1(SYS_WAITQ_DESTROY, (sysarg_t) futex->whandle);
     63                futex->whandle = CAP_NIL;
     64                return rc;
     65        }
     66        return EOK;
     67}
    5368
    5469#ifdef CONFIG_DEBUG_FUTEX
    55 
    56 #define FUTEX_INITIALIZE(val) { (val) , NULL }
    57 #define FUTEX_INITIALIZER     FUTEX_INITIALIZE(1)
    5870
    5971void __futex_assert_is_locked(futex_t *, const char *);
    … …  
    7486#else
    7587
    76 #define FUTEX_INITIALIZE(val) { (val) }
    77 #define FUTEX_INITIALIZER     FUTEX_INITIALIZE(1)
    78 
    7988#define futex_lock(fut)     (void) futex_down((fut))
    8089#define futex_trylock(fut)  futex_trydown((fut))
    … …  
    8695
    8796#endif
     97
     98static inline errno_t futex_allocate_waitq(futex_t *futex)
     99{
     100        return __SYSCALL1(SYS_WAITQ_CREATE, (sysarg_t) &futex->whandle);
     101}
    88102
    89103/** Down the futex with timeout, composably.
    … …  
    107121{
    108122        // TODO: Add tests for this.
     123
     124        assert(futex->whandle != CAP_NIL);
    109125
    110126        if (atomic_fetch_sub_explicit(&futex->val, 1, memory_order_acquire) > 0)
    … …  
    132148        }
    133149
    134         return __SYSCALL2(SYS_FUTEX_SLEEP, (sysarg_t) futex, (sysarg_t) timeout);
     150        return __SYSCALL3(SYS_WAITQ_SLEEP, (sysarg_t) futex->whandle,
     151            (sysarg_t) timeout, (sysarg_t) SYNCH_FLAGS_FUTEX);
    135152}
    136153
    … …  
    147164{
    148165        if (atomic_fetch_add_explicit(&futex->val, 1, memory_order_release) < 0)
    149                 return __SYSCALL1(SYS_FUTEX_WAKEUP, (sysarg_t) futex);
     166                return __SYSCALL1(SYS_WAITQ_WAKEUP, (sysarg_t) futex->whandle);
    150167
    151168        return EOK;

  • uspace/lib/c/generic/private/malloc.h

    r3ce781f4 raaa3c457  
    3737
    3838extern void __malloc_init(void);
     39extern void __malloc_fini(void);
    3940
    4041#endif

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

    r3ce781f4 raaa3c457  
    8787
    8888/* This futex serializes access to global data. */
    89 static futex_t fibril_futex = FUTEX_INITIALIZER;
     89static futex_t fibril_futex;
    9090static futex_t ready_semaphore;
    9191static long ready_st_count;
    … …  
    9595static LIST_INITIALIZE(timeout_list);
    9696
    97 static futex_t ipc_lists_futex = FUTEX_INITIALIZER;
     97static futex_t ipc_lists_futex;
    9898static LIST_INITIALIZE(ipc_waiter_list);
    9999static LIST_INITIALIZE(ipc_buffer_list);
    … …  
    796796        if (!multithreaded) {
    797797                _ready_debug_check();
    798                 futex_initialize(&ready_semaphore, ready_st_count);
     798                if (futex_initialize(&ready_semaphore, ready_st_count) != EOK)
     799                        abort();
    799800                multithreaded = true;
    800801        }
    … …  
    861862void __fibrils_init(void)
    862863{
     864        if (futex_initialize(&fibril_futex, 1) != EOK)
     865                abort();
     866        if (futex_initialize(&ipc_lists_futex, 1) != EOK)
     867                abort();
     868
    863869        /*
    864870         * We allow a fixed, small amount of parallelism for IPC reads, but
    … …  
    876882}
    877883
     884void __fibrils_fini(void)
     885{
     886        futex_destroy(&fibril_futex);
     887        futex_destroy(&ipc_lists_futex);
     888}
     889
    878890void fibril_usleep(usec_t timeout)
    879891{

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

    r3ce781f4 raaa3c457  
    5151#include "../private/futex.h"
    5252
    53 void fibril_rmutex_initialize(fibril_rmutex_t *m)
    54 {
    55         futex_initialize(&m->futex, 1);
     53errno_t fibril_rmutex_initialize(fibril_rmutex_t *m)
     54{
     55        return futex_initialize(&m->futex, 1);
     56}
     57
     58void fibril_rmutex_destroy(fibril_rmutex_t *m)
     59{
     60        futex_destroy(&m->futex);
    5661}
    5762
    … …  
    8590static fibril_local bool deadlocked = false;
    8691
    87 static futex_t fibril_synch_futex = FUTEX_INITIALIZER;
     92static futex_t fibril_synch_futex;
     93
     94void __fibril_synch_init(void)
     95{
     96        if (futex_initialize(&fibril_synch_futex, 1) != EOK)
     97                abort();
     98}
     99
     100void __fibril_synch_fini(void)
     101{
     102        futex_destroy(&fibril_synch_futex);
     103}
    88104
    89105typedef struct {

  • uspace/lib/c/generic/thread/futex.c

    r3ce781f4 raaa3c457  
    4949 * @param val   Initialization value.
    5050 *
     51 * @return      Error code.
    5152 */
    52 void futex_initialize(futex_t *futex, int val)
     53errno_t futex_initialize(futex_t *futex, int val)
    5354{
    5455        atomic_store_explicit(&futex->val, val, memory_order_relaxed);
     56        futex->whandle = CAP_NIL;
     57        return futex_allocate_waitq(futex);
    5558}
    5659

  • uspace/lib/c/generic/thread/mpsc.c

    r3ce781f4 raaa3c457  
    8080        }
    8181
     82        if (fibril_rmutex_initialize(&q->t_lock) != EOK) {
     83                free(q);
     84                free(n);
     85                free(c);
     86                return NULL;
     87        }
     88
    8289        q->elem_size = elem_size;
    83         fibril_rmutex_initialize(&q->t_lock);
    8490        q->head = q->tail = n;
    8591        q->close_node = c;
    … …  
    97103        }
    98104
    99         // TODO: fibril_rmutex_destroy()
     105        fibril_rmutex_destroy(&q->t_lock);
    100106
    101107        free(q);

  • uspace/lib/c/include/fibril_synch.h

    r3ce781f4 raaa3c457  
    164164        fibril_semaphore_t name = FIBRIL_SEMAPHORE_INITIALIZER(name, cnt)
    165165
     166extern void __fibril_synch_init(void);
     167extern void __fibril_synch_fini(void);
     168
    166169extern void fibril_mutex_initialize(fibril_mutex_t *);
    167170extern void fibril_mutex_lock(fibril_mutex_t *);

  • uspace/lib/c/include/io/kio.h

    r3ce781f4 raaa3c457  
    4242#include <_bits/size_t.h>
    4343
     44extern void __kio_init(void);
     45extern void __kio_fini(void);
    4446extern errno_t kio_write(const void *, size_t, size_t *);
    4547extern void kio_update(void);

  • uspace/lib/c/include/libc.h

    r3ce781f4 raaa3c457  
    6262        __syscall6(p1, p2, p3, p4, p5, p6, id)
    6363
     64extern void __libc_fini(void);
     65
    6466#endif
    6567
Note: See TracChangeset for help on using the changeset viewer.