Changes in / [aaa3c457:3ce781f4] in mainline


Ignore:
Files:
2 added
2 deleted
29 edited

Legend:

Unmodified
Added
Removed

  • abi/include/abi/cap.h

    raaa3c457 r3ce781f4  
    5252} *cap_irq_handle_t;
    5353
    54 typedef struct {
    55 } *cap_waitq_handle_t;
    56 
    5754#endif
    5855

  • abi/include/abi/syscall.h

    raaa3c457 r3ce781f4  
    5151        SYS_PROGRAM_SPAWN_LOADER,
    5252
    53         SYS_WAITQ_CREATE,
    54         SYS_WAITQ_SLEEP,
    55         SYS_WAITQ_WAKEUP,
    56         SYS_WAITQ_DESTROY,
     53        SYS_FUTEX_SLEEP,
     54        SYS_FUTEX_WAKEUP,
    5755        SYS_SMC_COHERENCE,
    5856

  • kernel/Makefile

    raaa3c457 r3ce781f4  
    227227        generic/src/synch/smc.c \
    228228        generic/src/synch/waitq.c \
    229         generic/src/synch/syswaitq.c \
     229        generic/src/synch/futex.c \
    230230        generic/src/smp/ipi.c \
    231231        generic/src/smp/smp.c \

  • kernel/generic/include/cap/cap.h

    raaa3c457 r3ce781f4  
    5555        KOBJECT_TYPE_IRQ,
    5656        KOBJECT_TYPE_PHONE,
    57         KOBJECT_TYPE_WAITQ,
    5857        KOBJECT_TYPE_MAX
    5958} kobject_type_t;
    … …  
    6463struct irq;
    6564struct phone;
    66 struct waitq;
    6765
    6866typedef struct kobject_ops {
    … …  
    9088                struct irq *irq;
    9189                struct phone *phone;
    92                 struct waitq *waitq;
    9390        };
    9491} kobject_t;

  • kernel/generic/include/proc/task.h

    raaa3c457 r3ce781f4  
    4242#include <synch/spinlock.h>
    4343#include <synch/mutex.h>
     44#include <synch/futex.h>
    4445#include <adt/list.h>
    4546#include <adt/odict.h>
    … …  
    127128        task_arch_t arch;
    128129
     130        /** Serializes access to futex_list.*/
     131        SPINLOCK_DECLARE(futex_list_lock);
     132        /** List of all futexes accesses by this task. */
     133        list_t futex_list;
     134
    129135        /** Accumulated accounting. */
    130136        uint64_t ucycles;

  • kernel/generic/include/synch/waitq.h

    raaa3c457 r3ce781f4  
    4949 *
    5050 */
    51 typedef struct waitq {
     51typedef struct {
    5252        /** Lock protecting wait queue structure.
    5353         *

  • kernel/generic/src/main/main.c

    raaa3c457 r3ce781f4  
    7777#include <mm/reserve.h>
    7878#include <synch/waitq.h>
    79 #include <synch/syswaitq.h>
     79#include <synch/futex.h>
    8080#include <arch/arch.h>
    8181#include <arch.h>
    … …  
    278278        task_init();
    279279        thread_init();
    280         sys_waitq_init();
     280        futex_init();
    281281
    282282        sysinfo_set_item_data("boot_args", NULL, bargs, str_size(bargs) + 1);

  • kernel/generic/src/proc/task.c

    raaa3c457 r3ce781f4  
    4343#include <mm/slab.h>
    4444#include <atomic.h>
     45#include <synch/futex.h>
    4546#include <synch/spinlock.h>
    4647#include <synch/waitq.h>
    … …  
    250251        }
    251252
     253        futex_task_init(task);
     254
    252255        irq_spinlock_lock(&tasks_lock, true);
    253256

  • kernel/generic/src/proc/thread.c

    raaa3c457 r3ce781f4  
    4848#include <synch/spinlock.h>
    4949#include <synch/waitq.h>
    50 #include <synch/syswaitq.h>
    5150#include <cpu.h>
    5251#include <str.h>
    … …  
    520519                         */
    521520                        ipc_cleanup();
    522                         sys_waitq_task_cleanup();
     521                        futex_task_cleanup();
    523522                        LOG("Cleanup of task %" PRIu64 " completed.", TASK->taskid);
    524523                }

  • kernel/generic/src/syscall/syscall.c

    raaa3c457 r3ce781f4  
    4646#include <interrupt.h>
    4747#include <ipc/sysipc.h>
     48#include <synch/futex.h>
    4849#include <synch/smc.h>
    49 #include <synch/syswaitq.h>
    5050#include <ddi/ddi.h>
    5151#include <ipc/event.h>
    … …  
    136136
    137137        /* Synchronization related syscalls. */
    138         [SYS_WAITQ_CREATE] = (syshandler_t) sys_waitq_create,
    139         [SYS_WAITQ_SLEEP] = (syshandler_t) sys_waitq_sleep,
    140         [SYS_WAITQ_WAKEUP] = (syshandler_t) sys_waitq_wakeup,
    141         [SYS_WAITQ_DESTROY] = (syshandler_t) sys_waitq_destroy,
     138        [SYS_FUTEX_SLEEP] = (syshandler_t) sys_futex_sleep,
     139        [SYS_FUTEX_WAKEUP] = (syshandler_t) sys_futex_wakeup,
    142140        [SYS_SMC_COHERENCE] = (syshandler_t) sys_smc_coherence,
    143141

  • uspace/app/trace/syscalls.c

    raaa3c457 r3ce781f4  
    4646        [SYS_TASK_GET_ID] = { "task_get_id", 1, V_ERRNO },
    4747        [SYS_TASK_SET_NAME] = { "task_set_name", 2, V_ERRNO },
     48        [SYS_FUTEX_SLEEP] = { "futex_sleep_timeout", 3, V_ERRNO },
     49        [SYS_FUTEX_WAKEUP] = { "futex_wakeup", 1, V_ERRNO },
    4850
    4951        [SYS_AS_AREA_CREATE] = { "as_area_create", 5, V_ERRNO },

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

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

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

    raaa3c457 r3ce781f4  
    100100
    101101/** Futex guarding the interface hash table. */
    102 static fibril_rmutex_t interface_mutex;
     102static FIBRIL_RMUTEX_INITIALIZE(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 
    297294        if (!hash_table_create(&interface_hash_table, 0, 0,
    298295            &interface_hash_table_ops))
    299296                abort();
    300297}
    301 
    302 void __async_ports_fini(void)
    303 {
    304         fibril_rmutex_destroy(&interface_mutex);
    305 }

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

    raaa3c457 r3ce781f4  
    216216}
    217217
    218 static fibril_rmutex_t client_mutex;
     218static FIBRIL_RMUTEX_INITIALIZE(client_mutex);
    219219static hash_table_t client_hash_table;
    220220
    221221// TODO: lockfree notification_queue?
    222 static fibril_rmutex_t notification_mutex;
     222static FIBRIL_RMUTEX_INITIALIZE(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 
    10201015        if (!hash_table_create(&client_hash_table, 0, 0, &client_hash_table_ops))
    10211016                abort();
    … …  
    10261021
    10271022        async_create_manager();
    1028 }
    1029 
    1030 void __async_server_fini(void)
    1031 {
    1032         fibril_rmutex_destroy(&client_mutex);
    1033         fibril_rmutex_destroy(&notification_mutex);
    10341023}
    10351024

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

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

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

    raaa3c457 r3ce781f4  
    4040#include <tls.h>
    4141#include <fibril.h>
    42 #include <fibril_synch.h>
    4342#include <task.h>
    4443#include <loader/pcb.h>
    4544#include <vfs/vfs.h>
    4645#include <vfs/inbox.h>
    47 #include <io/kio.h>
    4846#include "private/libc.h"
    4947#include "private/async.h"
    … …  
    6361void __libc_main(void *pcb_ptr)
    6462{
    65         __kio_init();
    66 
    6763        assert(!__tcb_is_set());
    6864
    … …  
    8581
    8682        __fibrils_init();
    87         __fibril_synch_init();
    8883
    8984        /* Initialize the fibril. */
    … …  
    153148}
    154149
    155 void __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 
    169150void __libc_exit(int status)
    170151{

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

    raaa3c457 r3ce781f4  
    195195
    196196/** Futex for thread-safe heap manipulation */
    197 static fibril_rmutex_t malloc_mutex;
     197static FIBRIL_RMUTEX_INITIALIZE(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 
    489486        if (!area_create(PAGE_SIZE))
    490487                abort();
    491 }
    492 
    493 void __malloc_fini(void)
    494 {
    495         fibril_rmutex_destroy(&malloc_mutex);
    496488}
    497489

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

    raaa3c457 r3ce781f4  
    9595
    9696extern void __async_server_init(void);
    97 extern void __async_server_fini(void);
    9897extern void __async_client_init(void);
    99 extern void __async_client_fini(void);
    10098extern void __async_ports_init(void);
    101 extern void __async_ports_fini(void);
    10299
    103100extern errno_t async_create_port_internal(iface_t, async_port_handler_t,

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

    raaa3c457 r3ce781f4  
    7979
    8080extern void __fibrils_init(void);
    81 extern void __fibrils_fini(void);
    8281
    8382extern void fibril_wait_for(fibril_event_t *);
    … …  
    121120} fibril_rmutex_t;
    122121
    123 extern errno_t fibril_rmutex_initialize(fibril_rmutex_t *);
    124 extern void fibril_rmutex_destroy(fibril_rmutex_t *);
     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
     128extern void fibril_rmutex_initialize(fibril_rmutex_t *);
    125129extern void fibril_rmutex_lock(fibril_rmutex_t *);
    126130extern bool fibril_rmutex_trylock(fibril_rmutex_t *);

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

    raaa3c457 r3ce781f4  
    4242#include <time.h>
    4343#include <fibril.h>
    44 #include <abi/cap.h>
    45 #include <abi/synch.h>
    4644
    4745typedef struct futex {
    4846        volatile atomic_int val;
    49         volatile cap_waitq_handle_t whandle;
    50 
    5147#ifdef CONFIG_DEBUG_FUTEX
    5248        _Atomic(fibril_t *) owner;
    … …  
    5450} futex_t;
    5551
    56 extern errno_t futex_initialize(futex_t *futex, int value);
    57 
    58 static 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 }
     52extern void futex_initialize(futex_t *futex, int value);
    6853
    6954#ifdef CONFIG_DEBUG_FUTEX
     55
     56#define FUTEX_INITIALIZE(val) { (val) , NULL }
     57#define FUTEX_INITIALIZER     FUTEX_INITIALIZE(1)
    7058
    7159void __futex_assert_is_locked(futex_t *, const char *);
    … …  
    8674#else
    8775
     76#define FUTEX_INITIALIZE(val) { (val) }
     77#define FUTEX_INITIALIZER     FUTEX_INITIALIZE(1)
     78
    8879#define futex_lock(fut)     (void) futex_down((fut))
    8980#define futex_trylock(fut)  futex_trydown((fut))
    … …  
    9586
    9687#endif
    97 
    98 static inline errno_t futex_allocate_waitq(futex_t *futex)
    99 {
    100         return __SYSCALL1(SYS_WAITQ_CREATE, (sysarg_t) &futex->whandle);
    101 }
    10288
    10389/** Down the futex with timeout, composably.
    … …  
    121107{
    122108        // TODO: Add tests for this.
    123 
    124         assert(futex->whandle != CAP_NIL);
    125109
    126110        if (atomic_fetch_sub_explicit(&futex->val, 1, memory_order_acquire) > 0)
    … …  
    148132        }
    149133
    150         return __SYSCALL3(SYS_WAITQ_SLEEP, (sysarg_t) futex->whandle,
    151             (sysarg_t) timeout, (sysarg_t) SYNCH_FLAGS_FUTEX);
     134        return __SYSCALL2(SYS_FUTEX_SLEEP, (sysarg_t) futex, (sysarg_t) timeout);
    152135}
    153136
    … …  
    164147{
    165148        if (atomic_fetch_add_explicit(&futex->val, 1, memory_order_release) < 0)
    166                 return __SYSCALL1(SYS_WAITQ_WAKEUP, (sysarg_t) futex->whandle);
     149                return __SYSCALL1(SYS_FUTEX_WAKEUP, (sysarg_t) futex);
    167150
    168151        return EOK;

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

    raaa3c457 r3ce781f4  
    3737
    3838extern void __malloc_init(void);
    39 extern void __malloc_fini(void);
    4039
    4140#endif

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

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

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

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

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

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

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

    raaa3c457 r3ce781f4  
    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 
    8982        q->elem_size = elem_size;
     83        fibril_rmutex_initialize(&q->t_lock);
    9084        q->head = q->tail = n;
    9185        q->close_node = c;
    … …  
    10397        }
    10498
    105         fibril_rmutex_destroy(&q->t_lock);
     99        // TODO: fibril_rmutex_destroy()
    106100
    107101        free(q);

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

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

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

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

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

    raaa3c457 r3ce781f4  
    6262        __syscall6(p1, p2, p3, p4, p5, p6, id)
    6363
    64 extern void __libc_fini(void);
    65 
    6664#endif
    6765

  • uspace/srv/loader/main.c

    raaa3c457 r3ce781f4  
    5959#include <vfs/vfs.h>
    6060#include <vfs/inbox.h>
    61 #include <libc.h>
    6261
    6362#ifdef CONFIG_RTLD
    … …  
    358357        DPRINTF("Jump to entry point at %p\n", pcb.entry);
    359358
    360         __libc_fini();
    361359        __tcb_reset();
    362360        entry_point_jmp(prog_info.finfo.entry, &pcb);
Note: See TracChangeset for help on using the changeset viewer.