Changes in / [1d4024cf:33f9670] in mainline


Ignore:
Files:
43 edited

Legend:

Unmodified
Added
Removed

  • abi/include/proc/uarg.h

    r1d4024cf r33f9670  
    4040        void *uspace_entry;
    4141        void *uspace_stack;
    42         size_t uspace_stack_size;
    4342       
    4443        void (* uspace_thread_function)();

  • kernel/arch/amd64/src/userspace.c

    r1d4024cf r33f9670  
    5555        asm volatile (
    5656                "pushq %[udata_des]\n"
    57                 "pushq %[stack_top]\n"
     57                "pushq %[stack_size]\n"
    5858                "pushq %[ipl]\n"
    5959                "pushq %[utext_des]\n"
    … …  
    6565                "iretq\n"
    6666                :: [udata_des] "i" (GDT_SELECTOR(UDATA_DES) | PL_USER),
    67                    [stack_top] "r" ((uint8_t *) kernel_uarg->uspace_stack +
    68                        kernel_uarg->uspace_stack_size),
     67                   [stack_size] "r" (kernel_uarg->uspace_stack + STACK_SIZE),
    6968                   [ipl] "r" (ipl),
    7069                   [utext_des] "i" (GDT_SELECTOR(UTEXT_DES) | PL_USER),
    … …  
    7574       
    7675        /* Unreachable */
    77         while (1);
     76        while (1)
     77                ;
    7878}
    7979

  • kernel/arch/arm32/src/userspace.c

    r1d4024cf r33f9670  
    9292
    9393        /* set user stack */
    94         ustate.sp = ((uint32_t) kernel_uarg->uspace_stack) +
    95             kernel_uarg->uspace_stack_size;
     94        ustate.sp = ((uint32_t)kernel_uarg->uspace_stack) + STACK_SIZE;
    9695
    9796        /* set where uspace execution starts */

  • kernel/arch/ia32/src/userspace.c

    r1d4024cf r33f9670  
    6363               
    6464                "pushl %[udata_des]\n"
    65                 "pushl %[stack_top]\n"
     65                "pushl %[stack_size]\n"
    6666                "pushl %[ipl]\n"
    6767                "pushl %[utext_des]\n"
    … …  
    7575                :
    7676                : [udata_des] "i" (GDT_SELECTOR(UDATA_DES) | PL_USER),
    77                   [stack_top] "r" ((uint8_t *) kernel_uarg->uspace_stack +
    78                       kernel_uarg->uspace_stack_size),
     77                  [stack_size] "r" ((uint8_t *) kernel_uarg->uspace_stack + STACK_SIZE),
    7978                  [ipl] "r" (ipl),
    8079                  [utext_des] "i" (GDT_SELECTOR(UTEXT_DES) | PL_USER),

  • kernel/arch/ia64/src/ia64.c

    r1d4024cf r33f9670  
    232232         *
    233233         * When calculating stack addresses, mind the stack split between the
    234          * memory stack and the RSE stack. Each occuppies
    235          * uspace_stack_size / 2 bytes.
     234         * memory stack and the RSE stack. Each occuppies STACK_SIZE / 2 bytes.
    236235         */
    237236        switch_to_userspace((uintptr_t) kernel_uarg->uspace_entry,
    238             ((uintptr_t) kernel_uarg->uspace_stack) +
    239             kernel_uarg->uspace_stack_size / 2 -
     237            ((uintptr_t) kernel_uarg->uspace_stack) + STACK_SIZE / 2 -
    240238            ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT),
    241             ((uintptr_t) kernel_uarg->uspace_stack) +
    242             kernel_uarg->uspace_stack_size / 2,
     239            ((uintptr_t) kernel_uarg->uspace_stack) + STACK_SIZE / 2,
    243240            (uintptr_t) kernel_uarg->uspace_uarg, psr.value, rsc.value);
    244        
    245         while (1);
     241
     242        while (1)
     243                ;
    246244}
    247245

  • kernel/arch/mips32/src/mips32.c

    r1d4024cf r33f9670  
    211211            cp0_status_um_bit | cp0_status_ie_enabled_bit));
    212212        cp0_epc_write((uintptr_t) kernel_uarg->uspace_entry);
    213         userspace_asm(((uintptr_t) kernel_uarg->uspace_stack +
    214             kernel_uarg->uspace_stack_size),
     213        userspace_asm(((uintptr_t) kernel_uarg->uspace_stack + STACK_SIZE),
    215214            (uintptr_t) kernel_uarg->uspace_uarg,
    216215            (uintptr_t) kernel_uarg->uspace_entry);

  • kernel/arch/mips64/src/mips64.c

    r1d4024cf r33f9670  
    188188            cp0_status_um_bit | cp0_status_ie_enabled_bit));
    189189        cp0_epc_write((uintptr_t) kernel_uarg->uspace_entry);
    190         userspace_asm(((uintptr_t) kernel_uarg->uspace_stack +
    191             kernel_uarg->uspace_stack_size),
     190        userspace_asm(((uintptr_t) kernel_uarg->uspace_stack + STACK_SIZE),
    192191            (uintptr_t) kernel_uarg->uspace_uarg,
    193192            (uintptr_t) kernel_uarg->uspace_entry);

  • kernel/arch/ppc32/src/ppc32.c

    r1d4024cf r33f9670  
    269269{
    270270        userspace_asm((uintptr_t) kernel_uarg->uspace_uarg,
    271             (uintptr_t) kernel_uarg->uspace_stack +
    272             kernel_uarg->uspace_stack_size - SP_DELTA,
     271            (uintptr_t) kernel_uarg->uspace_stack + STACK_SIZE - SP_DELTA,
    273272            (uintptr_t) kernel_uarg->uspace_entry);
    274273       

  • kernel/arch/sparc64/src/sun4u/sparc64.c

    r1d4024cf r33f9670  
    156156        (void) interrupts_disable();
    157157        switch_to_userspace((uintptr_t) kernel_uarg->uspace_entry,
    158             ((uintptr_t) kernel_uarg->uspace_stack) +
    159             kernel_uarg->uspace_stack_size -
    160             (ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT) + STACK_BIAS),
     158            ((uintptr_t) kernel_uarg->uspace_stack) + STACK_SIZE
     159            - (ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT) + STACK_BIAS),
    161160            (uintptr_t) kernel_uarg->uspace_uarg);
    162        
    163         /* Not reached */
    164         while (1);
     161
     162        for (;;)
     163                ;
     164        /* not reached */
    165165}
    166166

  • kernel/arch/sparc64/src/sun4v/sparc64.c

    r1d4024cf r33f9670  
    154154        (void) interrupts_disable();
    155155        switch_to_userspace((uintptr_t) kernel_uarg->uspace_entry,
    156             ((uintptr_t) kernel_uarg->uspace_stack) +
    157             kernel_uarg->uspace_stack_size -
    158             (ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT) + STACK_BIAS),
     156            ((uintptr_t) kernel_uarg->uspace_stack) + STACK_SIZE
     157            - (ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT) + STACK_BIAS),
    159158            (uintptr_t) kernel_uarg->uspace_uarg);
    160        
    161         /* Not reached */
    162         while (1);
     159
     160        for (;;)
     161                ;
     162        /* not reached */
    163163}
    164164

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

    r1d4024cf r33f9670  
    5656void uinit(void *arg)
    5757{
     58        uspace_arg_t uarg;
     59       
    5860        /*
    5961         * So far, we don't have a use for joining userspace threads so we
    … …  
    7072#endif
    7173       
    72         uspace_arg_t *uarg = (uspace_arg_t *) arg;
    73         uspace_arg_t local_uarg;
     74        uarg.uspace_entry = ((uspace_arg_t *) arg)->uspace_entry;
     75        uarg.uspace_stack = ((uspace_arg_t *) arg)->uspace_stack;
     76        uarg.uspace_uarg = ((uspace_arg_t *) arg)->uspace_uarg;
     77        uarg.uspace_thread_function = NULL;
     78        uarg.uspace_thread_arg = NULL;
    7479       
    75         local_uarg.uspace_entry = uarg->uspace_entry;
    76         local_uarg.uspace_stack = uarg->uspace_stack;
    77         local_uarg.uspace_stack_size = uarg->uspace_stack_size;
    78         local_uarg.uspace_uarg = uarg->uspace_uarg;
    79         local_uarg.uspace_thread_function = NULL;
    80         local_uarg.uspace_thread_arg = NULL;
     80        free((uspace_arg_t *) arg);
    8181       
    82         free(uarg);
    83        
    84         userspace(&local_uarg);
     82        userspace(&uarg);
    8583}
    8684

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

    r1d4024cf r33f9670  
    7171int program_create(as_t *as, uintptr_t entry_addr, char *name, program_t *prg)
    7272{
     73        uspace_arg_t *kernel_uarg;
     74       
     75        kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
     76        kernel_uarg->uspace_entry = (void *) entry_addr;
     77        kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;
     78        kernel_uarg->uspace_thread_function = NULL;
     79        kernel_uarg->uspace_thread_arg = NULL;
     80        kernel_uarg->uspace_uarg = NULL;
     81       
    7382        prg->loader_status = EE_OK;
    7483        prg->task = task_create(as, name);
    … …  
    8392            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE,
    8493            STACK_SIZE, AS_AREA_ATTR_NONE, &anon_backend, NULL, &virt, 0);
    85         if (!area) {
    86                 task_destroy(prg->task);
     94        if (!area)
    8795                return ENOMEM;
    88         }
    89        
    90         uspace_arg_t *kernel_uarg = (uspace_arg_t *)
    91             malloc(sizeof(uspace_arg_t), 0);
    92        
    93         kernel_uarg->uspace_entry = (void *) entry_addr;
    94         kernel_uarg->uspace_stack = (void *) virt;
    95         kernel_uarg->uspace_stack_size = STACK_SIZE;
    96         kernel_uarg->uspace_thread_function = NULL;
    97         kernel_uarg->uspace_thread_arg = NULL;
    98         kernel_uarg->uspace_uarg = NULL;
    9996       
    10097        /*
    … …  
    103100        prg->main_thread = thread_create(uinit, kernel_uarg, prg->task,
    104101            THREAD_FLAG_USPACE, "uinit", false);
    105         if (!prg->main_thread) {
    106                 free(kernel_uarg);
    107                 as_area_destroy(as, virt);
    108                 task_destroy(prg->task);
     102        if (!prg->main_thread)
    109103                return ELIMIT;
    110         }
    111104       
    112105        return EOK;

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

    r1d4024cf r33f9670  
    854854         * In case of failure, kernel_uarg will be deallocated in this function.
    855855         * In case of success, kernel_uarg will be freed in uinit().
     856         *
    856857         */
    857858        uspace_arg_t *kernel_uarg =

  • uspace/app/tester/mm/common.c

    r1d4024cf r33f9670  
    342342        link_initialize(&area->link);
    343343       
    344         area->addr = as_area_create(AS_AREA_ANY, size,
     344        area->addr = as_area_create((void *) -1, size,
    345345            AS_AREA_WRITE | AS_AREA_READ);
    346         if (area->addr == AS_MAP_FAILED) {
     346        if (area->addr == (void *) -1) {
    347347                free(area);
    348348                check_consistency("map_area (a)");

  • uspace/app/tester/mm/mapping1.c

    r1d4024cf r33f9670  
    4242        TPRINTF("Creating AS area...\n");
    4343       
    44         void *result = as_area_create(AS_AREA_ANY, size,
     44        void *result = as_area_create((void *) -1, size,
    4545            AS_AREA_READ | AS_AREA_WRITE);
    46         if (result == AS_MAP_FAILED)
     46        if (result == (void *) -1)
    4747                return NULL;
    4848       

  • uspace/drv/bus/usb/uhci/utils/malloc32.h

    r1d4024cf r33f9670  
    9999static inline void * get_page(void)
    100100{
    101         void *address = as_area_create(AS_AREA_ANY, UHCI_REQUIRED_PAGE_SIZE,
     101        void *address = as_area_create((void *) -1, UHCI_REQUIRED_PAGE_SIZE,
    102102            AS_AREA_READ | AS_AREA_WRITE);
    103         if (address == AS_MAP_FAILED)
     103        if (address == (void *) -1)
    104104                return NULL;
    105105       

  • uspace/drv/bus/usb/usbmast/main.c

    r1d4024cf r33f9670  
    302302       
    303303        (void) async_share_out_finalize(callid, &comm_buf);
    304         if (comm_buf == AS_MAP_FAILED) {
     304        if (comm_buf == (void *) -1) {
    305305                async_answer_0(callid, EHANGUP);
    306306                return;

  • uspace/lib/c/arch/ia64/include/fibril.h

    r1d4024cf r33f9670  
    4949#define PFM_MASK  (~0x3fffffffff)
    5050
     51#define PSTHREAD_INITIAL_STACK_PAGES_NO  2
     52
    5153/* Stack is divided into two equal parts (for memory stack and register stack). */
    52 #define FIBRIL_INITIAL_STACK_DIVISION  2
     54#define PSTHREAD_INITIAL_STACK_DIVISION  2
    5355
    5456#define context_set(c, _pc, stack, size, tls) \
    … …  
    5658                (c)->pc = (uint64_t) _pc; \
    5759                (c)->bsp = ((uint64_t) stack) + \
    58                     size / FIBRIL_INITIAL_STACK_DIVISION; \
     60                    size / PSTHREAD_INITIAL_STACK_DIVISION; \
    5961                (c)->ar_pfs &= PFM_MASK; \
    6062                (c)->sp = ((uint64_t) stack) + \
    61                     ALIGN_UP((size / FIBRIL_INITIAL_STACK_DIVISION), STACK_ALIGNMENT) - \
     63                    ALIGN_UP((size / PSTHREAD_INITIAL_STACK_DIVISION), STACK_ALIGNMENT) - \
    6264                    SP_DELTA; \
    6365                (c)->tp = (uint64_t) tls; \

  • uspace/lib/c/arch/ia64/include/thread.h

    r1d4024cf r33f9670  
    2727 */
    2828
    29 /** @addtogroup libcia64
     29/** @addtogroup libcia64       
    3030 * @{
    3131 */
    … …  
    3636#define LIBC_ia64_THREAD_H_
    3737
     38#define THREAD_INITIAL_STACK_PAGES_NO 2
     39
    3840#endif
    3941

  • uspace/lib/c/generic/as.c

    r1d4024cf r33f9670  
    4646 *
    4747 * @param base  Starting virtual address of the area.
    48  *              If set to AS_AREA_ANY ((void *) -1),
    49  *              the kernel finds a mappable area.
     48 *              If set to (void *) -1, the kernel finds
     49 *              a mappable area.
    5050 * @param size  Size of the area.
    5151 * @param flags Flags describing type of the area.
    5252 *
    5353 * @return Starting virtual address of the created area on success.
    54  * @return AS_MAP_FAILED ((void *) -1) otherwise.
     54 * @return (void *) -1 otherwise.
    5555 *
    5656 */

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

    r1d4024cf r33f9670  
    366366        a = as_area_create((uint8_t *) base + bias, mem_sz,
    367367            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
    368         if (a == AS_MAP_FAILED) {
     368        if (a == (void *) -1) {
    369369                DPRINTF("memory mapping failed (0x%x, %d)\n",
    370370                    base + bias, mem_sz);

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

    r1d4024cf r33f9670  
    286286}
    287287
    288 /** Delete a fibril that has never run.
    289  *
    290  * Free resources of a fibril that has been created with fibril_create()
    291  * but never readied using fibril_add_ready().
    292  *
    293  * @param fid Pointer to the fibril structure of the fibril to be
    294  *            added.
    295  */
    296 void fibril_destroy(fid_t fid)
    297 {
    298         fibril_t *fibril = (fibril_t *) fid;
    299        
    300         free(fibril->stack);
    301         fibril_teardown(fibril);
    302 }
    303 
    304288/** Add a fibril to the ready list.
    305289 *

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

    r1d4024cf r33f9670  
    285285        /* Align the heap area size on page boundary */
    286286        size_t asize = ALIGN_UP(size, PAGE_SIZE);
    287         void *astart = as_area_create(AS_AREA_ANY, asize,
     287        void *astart = as_area_create((void *) -1, asize,
    288288            AS_AREA_WRITE | AS_AREA_READ);
    289         if (astart == AS_MAP_FAILED)
     289        if (astart == (void *) -1)
    290290                return false;
    291291       

  • uspace/lib/c/generic/mman.c

    r1d4024cf r33f9670  
    4242{
    4343        if (!start)
    44                 start = AS_AREA_ANY;
     44                start = (void *) -1;
    4545       
    4646//      if (!((flags & MAP_SHARED) ^ (flags & MAP_PRIVATE)))

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

    r1d4024cf r33f9670  
    4141#include <str.h>
    4242#include <async.h>
    43 #include <errno.h>
    44 #include <as.h>
    4543#include "private/thread.h"
    4644
    47 #ifndef THREAD_INITIAL_STACK_PAGES
    48         #define THREAD_INITIAL_STACK_PAGES  2
     45#ifndef THREAD_INITIAL_STACK_PAGES_NO
     46#define THREAD_INITIAL_STACK_PAGES_NO   2
    4947#endif
    5048
    … …  
    6765       
    6866        uarg->uspace_thread_function(uarg->uspace_thread_arg);
    69         /*
    70          * XXX: we cannot free the userspace stack while running on it
    71          *
    72          * free(uarg->uspace_stack);
    73          * free(uarg);
    74          */
     67        /* XXX: we cannot free the userspace stack while running on it
     68                free(uarg->uspace_stack);
     69                free(uarg);
     70        */
    7571       
    7672        /* If there is a manager, destroy it */
    … …  
    9692    thread_id_t *tid)
    9793{
    98         uspace_arg_t *uarg =
    99             (uspace_arg_t *) malloc(sizeof(uspace_arg_t));
    100         if (!uarg)
    101                 return ENOMEM;
    102        
    103         size_t stack_size = getpagesize() * THREAD_INITIAL_STACK_PAGES;
    104         void *stack = as_area_create(AS_AREA_ANY, stack_size,
    105             AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
    106         if (stack == AS_MAP_FAILED) {
    107                 free(uarg);
    108                 return ENOMEM;
     94        char *stack;
     95        uspace_arg_t *uarg;
     96        int rc;
     97
     98        stack = (char *) malloc(getpagesize() * THREAD_INITIAL_STACK_PAGES_NO);
     99        if (!stack)
     100                return -1;
     101               
     102        uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t));
     103        if (!uarg) {
     104                free(stack);
     105                return -1;
    109106        }
    110107       
    111108        uarg->uspace_entry = (void *) FADDR(__thread_entry);
    112         uarg->uspace_stack = stack;
    113         uarg->uspace_stack_size = stack_size;
     109        uarg->uspace_stack = (void *) stack;
    114110        uarg->uspace_thread_function = function;
    115111        uarg->uspace_thread_arg = arg;
    116112        uarg->uspace_uarg = uarg;
    117113       
    118         int rc = __SYSCALL4(SYS_THREAD_CREATE, (sysarg_t) uarg,
    119             (sysarg_t) name, (sysarg_t) str_size(name), (sysarg_t) tid);
     114        rc = __SYSCALL4(SYS_THREAD_CREATE, (sysarg_t) uarg, (sysarg_t) name,
     115            (sysarg_t) str_size(name), (sysarg_t) tid);
    120116       
    121         if (rc != EOK) {
     117        if (rc) {
    122118                /*
    123119                 * Failed to create a new thread.
    124                  * Free up the allocated data.
     120                 * Free up the allocated structures.
    125121                 */
    126                 as_area_destroy(stack);
    127122                free(uarg);
     123                free(stack);
    128124        }
    129        
     125
    130126        return rc;
    131127}

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

    r1d4024cf r33f9670  
    4141#include <libarch/config.h>
    4242
    43 #define AS_AREA_ANY    ((void *) -1)
    44 #define AS_MAP_FAILED  ((void *) -1)
    45 
    4643static inline size_t SIZE2PAGES(size_t size)
    4744{

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

    r1d4024cf r33f9670  
    8787
    8888extern fid_t fibril_create(int (*func)(void *), void *arg);
    89 extern void fibril_destroy(fid_t fid);
    9089extern fibril_t *fibril_setup(void);
    9190extern void fibril_teardown(fibril_t *f);

  • uspace/lib/c/include/sys/mman.h

    r1d4024cf r33f9670  
    3939#include <sys/types.h>
    4040
    41 #define MAP_FAILED  AS_MAP_FAILED
     41#define MAP_FAILED  ((void *) -1)
    4242
    4343#define MAP_SHARED     (1 << 0)

  • uspace/lib/fb/imgmap.c

    r1d4024cf r33f9670  
    420420       
    421421        if ((flags & IMGMAP_FLAG_SHARED) == IMGMAP_FLAG_SHARED) {
    422                 imgmap = (imgmap_t *) as_area_create(AS_AREA_ANY, size,
     422                imgmap = (imgmap_t *) as_area_create((void *) -1, size,
    423423                    AS_AREA_READ | AS_AREA_WRITE);
    424                 if (imgmap == AS_MAP_FAILED)
     424                if (imgmap == (void *) -1)
    425425                        return NULL;
    426426        } else {

  • uspace/lib/fb/screenbuffer.c

    r1d4024cf r33f9670  
    7979       
    8080        if ((flags & SCREENBUFFER_FLAG_SHARED) == SCREENBUFFER_FLAG_SHARED) {
    81                 scrbuf = (screenbuffer_t *) as_area_create(AS_AREA_ANY, size,
     81                scrbuf = (screenbuffer_t *) as_area_create((void *) -1, size,
    8282                    AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
    83                 if (scrbuf == AS_MAP_FAILED)
     83                if (scrbuf == (void *) -1)
    8484                        return NULL;
    8585        } else {

  • uspace/lib/fs/libfs.c

    r1d4024cf r33f9670  
    339339         */
    340340        rc = async_share_in_start_0_0(exch, PLB_SIZE, (void *) &reg.plb_ro);
    341         if (reg.plb_ro == AS_MAP_FAILED) {
     341        if (reg.plb_ro == (void *) -1) {
    342342                async_exchange_end(exch);
    343343                async_forget(req);

  • uspace/srv/bd/ata_bd/ata_bd.c

    r1d4024cf r33f9670  
    308308
    309309        (void) async_share_out_finalize(callid, &fs_va);
    310         if (fs_va == AS_MAP_FAILED) {
     310        if (fs_va == (void *) -1) {
    311311                async_answer_0(callid, EHANGUP);
    312312                return;

  • uspace/srv/bd/file_bd/file_bd.c

    r1d4024cf r33f9670  
    189189
    190190        (void) async_share_out_finalize(callid, &fs_va);
    191         if (fs_va == AS_MAP_FAILED) {
     191        if (fs_va == (void *) -1) {
    192192                async_answer_0(callid, EHANGUP);
    193193                return;

  • uspace/srv/bd/gxe_bd/gxe_bd.c

    r1d4024cf r33f9670  
    196196
    197197        (void) async_share_out_finalize(callid, &fs_va);
    198         if (fs_va == AS_MAP_FAILED) {
     198        if (fs_va == (void *) -1) {
    199199                async_answer_0(callid, EHANGUP);
    200200                return;

  • uspace/srv/bd/part/guid_part/guid_part.c

    r1d4024cf r33f9670  
    350350
    351351        (void) async_share_out_finalize(callid, &fs_va);
    352         if (fs_va == AS_MAP_FAILED) {
     352        if (fs_va == (void *) -1) {
    353353                async_answer_0(callid, EHANGUP);
    354354                return;

  • uspace/srv/bd/part/mbr_part/mbr_part.c

    r1d4024cf r33f9670  
    427427
    428428        (void) async_share_out_finalize(callid, &fs_va);
    429         if (fs_va == AS_MAP_FAILED) {
     429        if (fs_va == (void *) -1) {
    430430                async_answer_0(callid, EHANGUP);
    431431                return;

  • uspace/srv/bd/rd/rd.c

    r1d4024cf r33f9670  
    106106        if (async_share_out_receive(&callid, &comm_size, &flags)) {
    107107                (void) async_share_out_finalize(callid, &fs_va);
    108                 if (fs_va == AS_MAP_FAILED) {
     108                if (fs_va == (void *) -1) {
    109109                        async_answer_0(callid, EHANGUP);
    110110                        return;

  • uspace/srv/hid/fb/fb.c

    r1d4024cf r33f9670  
    305305       
    306306        int rc = async_share_out_finalize(callid, &frontbuf->data);
    307         if ((rc != EOK) || (frontbuf->data == AS_MAP_FAILED)) {
     307        if ((rc != EOK) || (frontbuf->data == (void *) -1)) {
    308308                free(frontbuf);
    309309                async_answer_0(iid, ENOMEM);
    … …  
    348348       
    349349        int rc = async_share_out_finalize(callid, &imagemap->data);
    350         if ((rc != EOK) || (imagemap->data == AS_MAP_FAILED)) {
     350        if ((rc != EOK) || (imagemap->data == (void *) -1)) {
    351351                free(imagemap);
    352352                async_answer_0(iid, ENOMEM);

  • uspace/srv/net/tcp/sock.c

    r1d4024cf r33f9670  
    151151            sock, sock_id);
    152152
    153         if (rc != EOK) {
    154                 fibril_destroy(sock->recv_fibril);
    155                 sock->recv_fibril = 0;
     153        if (rc != EOK)
    156154                return rc;
    157         }
    158155
    159156        sock_core = socket_cores_find(&sock->client->sockets, *sock_id);

  • uspace/srv/net/udp/sock.c

    r1d4024cf r33f9670  
    5151#include "ucall.h"
    5252
     53#define FRAGMENT_SIZE 1024
     54
    5355/** Free ports pool start. */
    5456#define UDP_FREE_PORTS_START            1025
    … …  
    6163
    6264static void udp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    63 static int udp_sock_recv_fibril(void *arg);
    6465
    6566int udp_sock_init(void)
    … …  
    8182
    8283        socket = (udp_sockdata_t *)sock_core->specific_data;
    83         (void)socket;
    84 
    85         /* XXX We need to force the receive fibril to quit */
     84        assert(socket->assoc != NULL);
     85        udp_uc_destroy(socket->assoc);
    8686}
    8787
    … …  
    9191        async_exch_t *exch = async_exchange_begin(sock_core->sess);
    9292        async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t)sock_core->socket_id,
    93             UDP_FRAGMENT_SIZE, 0, 0, 1);
     93            FRAGMENT_SIZE, 0, 0, 1);
    9494        async_exchange_end(exch);
    9595}
    … …  
    113113        sock->client = client;
    114114
    115         sock->recv_buffer_used = 0;
    116         sock->recv_error = UDP_EOK;
    117         fibril_mutex_initialize(&sock->recv_buffer_lock);
    118         fibril_condvar_initialize(&sock->recv_buffer_cv);
    119 
    120115        rc = udp_uc_create(&sock->assoc);
    121116        if (rc != EOK) {
     117                udp_uc_destroy(sock->assoc);
    122118                free(sock);
    123119                async_answer_0(callid, rc);
    124                 return;
    125         }
    126 
    127         sock->recv_fibril = fibril_create(udp_sock_recv_fibril, sock);
    128         if (sock->recv_fibril == 0) {
    129                 udp_uc_destroy(sock->assoc);
    130                 free(sock);
    131                 async_answer_0(callid, ENOMEM);
    132120                return;
    133121        }
    … …  
    136124        rc = socket_create(&client->sockets, client->sess, sock, &sock_id);
    137125        if (rc != EOK) {
    138                 fibril_destroy(sock->recv_fibril);
    139                 udp_uc_destroy(sock->assoc);
    140                 free(sock);
    141126                async_answer_0(callid, rc);
    142127                return;
    143128        }
    144 
    145         fibril_add_ready(sock->recv_fibril);
    146129
    147130        sock_core = socket_cores_find(&client->sockets, sock_id);
    … …  
    151134        SOCKET_SET_SOCKET_ID(answer, sock_id);
    152135
    153         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, UDP_FRAGMENT_SIZE);
     136        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
    154137        SOCKET_SET_HEADER_SIZE(answer, sizeof(udp_header_t));
    155138        async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
    … …  
    222205        }
    223206
     207        udp_sock_notify_data(sock_core);
     208
    224209        log_msg(LVL_DEBUG, " - success");
    225210        async_answer_0(callid, rc);
    … …  
    260245        ipc_callid_t wcallid;
    261246        size_t length;
    262         uint8_t buffer[UDP_FRAGMENT_SIZE];
     247        uint8_t buffer[FRAGMENT_SIZE];
    263248        udp_error_t urc;
    264249        int rc;
    … …  
    307292                        goto out;
    308293                }
     294
     295                udp_sock_notify_data(sock_core);
    309296        }
    310297
    … …  
    343330                }
    344331
    345                 if (length > UDP_FRAGMENT_SIZE)
    346                         length = UDP_FRAGMENT_SIZE;
     332                if (length > FRAGMENT_SIZE)
     333                        length = FRAGMENT_SIZE;
    347334
    348335                rc = async_data_write_finalize(wcallid, buffer, length);
    … …  
    380367       
    381368        IPC_SET_ARG1(answer, 0);
    382         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, UDP_FRAGMENT_SIZE);
     369        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
    383370        async_answer_2(callid, EOK, IPC_GET_ARG1(answer),
    384371            IPC_GET_ARG2(answer));
    … …  
    399386        ipc_call_t answer;
    400387        ipc_callid_t rcallid;
     388        uint8_t buffer[FRAGMENT_SIZE];
    401389        size_t data_len;
     390        xflags_t xflags;
    402391        udp_error_t urc;
     392        struct sockaddr_in addr;
    403393        udp_sock_t rsock;
    404         struct sockaddr_in addr;
    405394        int rc;
    406395
    … …  
    427416        (void)flags;
    428417
    429         log_msg(LVL_DEBUG, "udp_sock_recvfrom(): lock recv_buffer lock");
    430         fibril_mutex_lock(&socket->recv_buffer_lock);
    431         while (socket->recv_buffer_used == 0 && socket->recv_error == UDP_EOK) {
    432                 log_msg(LVL_DEBUG, "udp_sock_recvfrom(): wait for cv");
    433                 fibril_condvar_wait(&socket->recv_buffer_cv,
    434                     &socket->recv_buffer_lock);
    435         }
    436 
    437         log_msg(LVL_DEBUG, "Got data in sock recv_buffer");
    438 
    439         rsock = socket->recv_fsock;
    440         data_len = socket->recv_buffer_used;
    441         urc = socket->recv_error;
    442 
    443         log_msg(LVL_DEBUG, "**** recv data_len=%zu", data_len);
     418        urc = udp_uc_receive(socket->assoc, buffer, FRAGMENT_SIZE, &data_len,
     419            &xflags, &rsock);
     420        log_msg(LVL_DEBUG, "**** udp_uc_receive done, data_len=%zu", data_len);
    444421
    445422        switch (urc) {
    … …  
    460437        log_msg(LVL_DEBUG, "**** udp_uc_receive -> %d", rc);
    461438        if (rc != EOK) {
    462                 fibril_mutex_unlock(&socket->recv_buffer_lock);
    463439                fibril_mutex_unlock(&socket->lock);
    464440                async_answer_0(callid, rc);
    … …  
    474450                log_msg(LVL_DEBUG, "addr read receive");
    475451                if (!async_data_read_receive(&rcallid, &addr_length)) {
    476                         fibril_mutex_unlock(&socket->recv_buffer_lock);
    477452                        fibril_mutex_unlock(&socket->lock);
    478453                        async_answer_0(callid, EINVAL);
    … …  
    486461                rc = async_data_read_finalize(rcallid, &addr, addr_length);
    487462                if (rc != EOK) {
    488                         fibril_mutex_unlock(&socket->recv_buffer_lock);
    489463                        fibril_mutex_unlock(&socket->lock);
    490464                        async_answer_0(callid, EINVAL);
    … …  
    495469        log_msg(LVL_DEBUG, "data read receive");
    496470        if (!async_data_read_receive(&rcallid, &length)) {
    497                 fibril_mutex_unlock(&socket->recv_buffer_lock);
    498471                fibril_mutex_unlock(&socket->lock);
    499472                async_answer_0(callid, EINVAL);
    … …  
    505478
    506479        log_msg(LVL_DEBUG, "data read finalize");
    507         rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
     480        rc = async_data_read_finalize(rcallid, buffer, length);
    508481
    509482        if (length < data_len && rc == EOK)
    … …  
    516489        async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
    517490            IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
    518 
    519         socket->recv_buffer_used = 0;
    520 
    521         fibril_condvar_broadcast(&socket->recv_buffer_cv);
    522         fibril_mutex_unlock(&socket->recv_buffer_lock);
     491       
     492        /* Push one fragment notification to client's queue */
     493        udp_sock_notify_data(sock_core);
    523494        fibril_mutex_unlock(&socket->lock);
    524495}
    … …  
    567538}
    568539
    569 static int udp_sock_recv_fibril(void *arg)
    570 {
    571         udp_sockdata_t *sock = (udp_sockdata_t *)arg;
    572         udp_error_t urc;
    573         xflags_t xflags;
    574         size_t rcvd;
    575 
    576         log_msg(LVL_DEBUG, "udp_sock_recv_fibril()");
    577 
    578         while (true) {
    579                 log_msg(LVL_DEBUG, "[] wait for rcv buffer empty()");
    580                 fibril_mutex_lock(&sock->recv_buffer_lock);
    581                 while (sock->recv_buffer_used != 0) {
    582                         fibril_condvar_wait(&sock->recv_buffer_cv,
    583                             &sock->recv_buffer_lock);
    584                 }
    585 
    586                 log_msg(LVL_DEBUG, "[] call udp_uc_receive()");
    587                 urc = udp_uc_receive(sock->assoc, sock->recv_buffer,
    588                     UDP_FRAGMENT_SIZE, &rcvd, &xflags, &sock->recv_fsock);
    589                 sock->recv_error = urc;
    590 
    591                 udp_sock_notify_data(sock->sock_core);
    592 
    593                 if (urc != UDP_EOK) {
    594                         fibril_condvar_broadcast(&sock->recv_buffer_cv);
    595                         fibril_mutex_unlock(&sock->recv_buffer_lock);
    596                         break;
    597                 }
    598 
    599                 log_msg(LVL_DEBUG, "[] got data - broadcast recv_buffer_cv");
    600 
    601                 sock->recv_buffer_used = rcvd;
    602                 fibril_mutex_unlock(&sock->recv_buffer_lock);
    603                 fibril_condvar_broadcast(&sock->recv_buffer_cv);
    604         }
    605 
    606         udp_uc_destroy(sock->assoc);
    607 
    608         return 0;
    609 }
    610 
    611540static void udp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    612541{

  • uspace/srv/net/udp/udp.c

    r1d4024cf r33f9670  
    7373        printf(NAME ": UDP (User Datagram Protocol) service\n");
    7474
    75         rc = log_init(NAME, LVL_DEBUG);
     75        rc = log_init(NAME, LVL_WARN);
    7676        if (rc != EOK) {
    7777                printf(NAME ": Failed to initialize log.\n");

  • uspace/srv/net/udp/udp_type.h

    r1d4024cf r33f9670  
    3636#define UDP_TYPE_H
    3737
    38 #include <fibril.h>
    3938#include <fibril_synch.h>
    4039#include <socket_core.h>
    4140#include <sys/types.h>
    42 
    43 #define UDP_FRAGMENT_SIZE 4096
    44 
    4541
    4642typedef enum {
    … …  
    145141        /** Connection */
    146142        udp_assoc_t *assoc;
    147         /** Receiving fibril */
    148         fid_t recv_fibril;
    149         uint8_t recv_buffer[UDP_FRAGMENT_SIZE];
    150         size_t recv_buffer_used;
    151         udp_sock_t recv_fsock;
    152         fibril_mutex_t recv_buffer_lock;
    153         fibril_condvar_t recv_buffer_cv;
    154         udp_error_t recv_error;
    155143} udp_sockdata_t;
    156144

  • uspace/srv/vfs/vfs.c

    r1d4024cf r33f9670  
    173173         * Allocate and initialize the Path Lookup Buffer.
    174174         */
    175         plb = as_area_create(AS_AREA_ANY, PLB_SIZE,
     175        plb = as_area_create((void *) -1, PLB_SIZE,
    176176            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
    177         if (plb == AS_MAP_FAILED) {
     177        if (plb == (void *) -1) {
    178178                printf("%s: Cannot create address space area\n", NAME);
    179179                return ENOMEM;
Note: See TracChangeset for help on using the changeset viewer.