Changeset 8b36bf2 in mainline for uspace


Ignore:
Timestamp:
2012-06-20T23:03:29Z (13 years ago)
Author:
Sean Bartell <wingedtachikoma@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
d5070ef
Parents:
8375d0eb (diff), 6eef3c4 (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 mainline changes

Location:
uspace
Files:
42 edited

Legend:

Unmodified
Added
Removed

  • uspace/Makefile.common

    r8375d0eb r8b36bf2  
    206206        GCC_CFLAGS += -g
    207207        ICC_CFLAGS += -g
    208         SUNCC_CFLAGS += -g
    209208        CLANG_CFLAGS += -g
    210209endif

  • uspace/app/devctl/devctl.c

    r8375d0eb r8b36bf2  
    4444#define MAX_NAME_LENGTH 1024
    4545
     46char name[MAX_NAME_LENGTH];
     47char drv_name[MAX_NAME_LENGTH];
     48
    4649static int fun_subtree_print(devman_handle_t funh, int lvl)
    4750{
    48         char name[MAX_NAME_LENGTH];
    4951        devman_handle_t devh;
    5052        devman_handle_t *cfuns;
    … …  
    5759
    5860        rc = devman_fun_get_name(funh, name, MAX_NAME_LENGTH);
    59         if (rc != EOK) {
    60                 str_cpy(name, MAX_NAME_LENGTH, "unknown");
    61                 return ENOMEM;
    62         }
     61        if (rc != EOK)
     62                return ELIMIT;
    6363
    6464        if (name[0] == '\0')
    6565                str_cpy(name, MAX_NAME_LENGTH, "/");
    6666
    67         printf("%s (%" PRIun ")\n", name, funh);
     67        rc = devman_fun_get_driver_name(funh, drv_name, MAX_NAME_LENGTH);
     68        if (rc != EOK && rc != EINVAL)
     69                return ELIMIT;
     70
     71        if (rc == EINVAL)
     72                printf("%s\n", name);
     73        else
     74                printf("%s : %s\n", name, drv_name);
    6875
    6976        rc = devman_fun_get_child(funh, &devh);

  • uspace/app/loc/loc.c

    r8375d0eb r8b36bf2  
    4848        size_t svc_cnt;
    4949        char *svc_name;
     50        char *server_name;
    5051        int rc;
    5152        size_t j;
    5253
    53         printf("%s (%" PRIun "):\n", cat_name, cat_id);
     54        printf("%s:\n", cat_name);
    5455
    5556        rc = loc_category_get_svcs(cat_id, &svc_ids, &svc_cnt);
    … …  
    6768                        continue;
    6869                }
    69                 printf("\t%s (%" PRIun ")\n", svc_name, svc_ids[j]);
     70
     71                rc = loc_service_get_server_name(svc_ids[j], &server_name);
     72                if (rc != EOK && rc != EINVAL) {
     73                        free(svc_name);
     74                        printf(NAME ": Unknown service name (SID %"
     75                            PRIun ").\n", svc_ids[j]);
     76                        continue;
     77                }
     78
     79                if (rc == EOK)
     80                        printf("\t%s : %s\n", svc_name, server_name);
     81                else
     82                        printf("\t%s\n", svc_name);
     83       
    7084                free(svc_name);
     85                free(server_name);
    7186        }
    7287

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

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

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

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

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

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

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

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

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

    r8375d0eb r8b36bf2  
    4949#define PFM_MASK  (~0x3fffffffff)
    5050
    51 #define PSTHREAD_INITIAL_STACK_PAGES_NO  2
    52 
    5351/* Stack is divided into two equal parts (for memory stack and register stack). */
    54 #define PSTHREAD_INITIAL_STACK_DIVISION  2
     52#define FIBRIL_INITIAL_STACK_DIVISION  2
    5553
    5654#define context_set(c, _pc, stack, size, tls) \
    … …  
    5856                (c)->pc = (uint64_t) _pc; \
    5957                (c)->bsp = ((uint64_t) stack) + \
    60                     size / PSTHREAD_INITIAL_STACK_DIVISION; \
     58                    size / FIBRIL_INITIAL_STACK_DIVISION; \
    6159                (c)->ar_pfs &= PFM_MASK; \
    6260                (c)->sp = ((uint64_t) stack) + \
    63                     ALIGN_UP((size / PSTHREAD_INITIAL_STACK_DIVISION), STACK_ALIGNMENT) - \
     61                    ALIGN_UP((size / FIBRIL_INITIAL_STACK_DIVISION), STACK_ALIGNMENT) - \
    6462                    SP_DELTA; \
    6563                (c)->tp = (uint64_t) tls; \

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

    r8375d0eb r8b36bf2  
    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 
    4038#endif
    4139

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

    r8375d0eb r8b36bf2  
    4646 *
    4747 * @param base  Starting virtual address of the area.
    48  *              If set to (void *) -1, the kernel finds
    49  *              a mappable area.
     48 *              If set to AS_AREA_ANY ((void *) -1),
     49 *              the kernel finds 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 (void *) -1 otherwise.
     54 * @return AS_MAP_FAILED ((void *) -1) otherwise.
    5555 *
    5656 */

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

    r8375d0eb r8b36bf2  
    13881388
    13891389        futex_down(&async_futex);
    1390         if (msg->done)
     1390        if (msg->done) {
    13911391                amsg_destroy(msg);
    1392         else
     1392        } else {
     1393                msg->dataptr = NULL;
    13931394                msg->forget = true;
     1395        }
    13941396        futex_up(&async_futex);
    13951397}

  • uspace/lib/c/generic/devman.c

    r8375d0eb r8b36bf2  
    430430        async_wait_for(req, &retval);
    431431       
    432         if (retval != EOK)
    433                 return retval;
     432        if (retval != EOK) {
     433                return retval;
     434        }
    434435       
    435436        act_size = IPC_GET_ARG2(dreply);
    … …  
    449450{
    450451        return devman_get_str_internal(DEVMAN_FUN_GET_NAME, handle, buf,
     452            buf_size);
     453}
     454
     455int devman_fun_get_driver_name(devman_handle_t handle, char *buf, size_t buf_size)
     456{
     457        return devman_get_str_internal(DEVMAN_FUN_GET_DRIVER_NAME, handle, buf,
    451458            buf_size);
    452459}

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

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

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

    r8375d0eb r8b36bf2  
    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 */
     296void fibril_destroy(fid_t fid)
     297{
     298        fibril_t *fibril = (fibril_t *) fid;
     299       
     300        free(fibril->stack);
     301        fibril_teardown(fibril);
     302}
     303
    288304/** Add a fibril to the ready list.
    289305 *

  • uspace/lib/c/generic/loc.c

    r8375d0eb r8b36bf2  
    450450}
    451451
     452/** Get service server name.
     453 *
     454 * Provided ID of a service, return the name of its server.
     455 *
     456 * @param svc_id        Service ID
     457 * @param name          Place to store pointer to new string. Caller should
     458 *                      free it using free().
     459 * @return              EOK on success or negative error code
     460 */
     461int loc_service_get_server_name(service_id_t svc_id, char **name)
     462{
     463        return loc_get_name_internal(LOC_SERVICE_GET_SERVER_NAME, svc_id, name);
     464}
     465
    452466int loc_namespace_get_id(const char *name, service_id_t *handle,
    453467    unsigned int flags)

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

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

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

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

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

    r8375d0eb r8b36bf2  
    4141#include <str.h>
    4242#include <async.h>
     43#include <errno.h>
     44#include <as.h>
    4345#include "private/thread.h"
    4446
    45 #ifndef THREAD_INITIAL_STACK_PAGES_NO
    46 #define THREAD_INITIAL_STACK_PAGES_NO   2
     47#ifndef THREAD_INITIAL_STACK_PAGES
     48        #define THREAD_INITIAL_STACK_PAGES  2
    4749#endif
    4850
    … …  
    6567       
    6668        uarg->uspace_thread_function(uarg->uspace_thread_arg);
    67         /* XXX: we cannot free the userspace stack while running on it
    68                 free(uarg->uspace_stack);
    69                 free(uarg);
    70         */
     69        /*
     70         * XXX: we cannot free the userspace stack while running on it
     71         *
     72         * free(uarg->uspace_stack);
     73         * free(uarg);
     74         */
    7175       
    7276        /* If there is a manager, destroy it */
    … …  
    9296    thread_id_t *tid)
    9397{
    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;
     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;
    106109        }
    107110       
    108111        uarg->uspace_entry = (void *) FADDR(__thread_entry);
    109         uarg->uspace_stack = (void *) stack;
     112        uarg->uspace_stack = stack;
     113        uarg->uspace_stack_size = stack_size;
    110114        uarg->uspace_thread_function = function;
    111115        uarg->uspace_thread_arg = arg;
    112116        uarg->uspace_uarg = uarg;
    113117       
    114         rc = __SYSCALL4(SYS_THREAD_CREATE, (sysarg_t) uarg, (sysarg_t) name,
    115             (sysarg_t) str_size(name), (sysarg_t) tid);
     118        int rc = __SYSCALL4(SYS_THREAD_CREATE, (sysarg_t) uarg,
     119            (sysarg_t) name, (sysarg_t) str_size(name), (sysarg_t) tid);
    116120       
    117         if (rc) {
     121        if (rc != EOK) {
    118122                /*
    119123                 * Failed to create a new thread.
    120                  * Free up the allocated structures.
     124                 * Free up the allocated data.
    121125                 */
     126                as_area_destroy(stack);
    122127                free(uarg);
    123                 free(stack);
    124128        }
    125 
     129       
    126130        return rc;
    127131}

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

    r8375d0eb r8b36bf2  
    4141#include <libarch/config.h>
    4242
     43#define AS_AREA_ANY    ((void *) -1)
     44#define AS_MAP_FAILED  ((void *) -1)
     45
    4346static inline size_t SIZE2PAGES(size_t size)
    4447{

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

    r8375d0eb r8b36bf2  
    6464    size_t *);
    6565extern int devman_fun_get_name(devman_handle_t, char *, size_t);
     66extern int devman_fun_get_driver_name(devman_handle_t, char *, size_t);
    6667extern int devman_fun_get_path(devman_handle_t, char *, size_t);
    6768extern int devman_fun_online(devman_handle_t);

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

    r8375d0eb r8b36bf2  
    8787
    8888extern fid_t fibril_create(int (*func)(void *), void *arg);
     89extern void fibril_destroy(fid_t fid);
    8990extern fibril_t *fibril_setup(void);
    9091extern void fibril_teardown(fibril_t *f);

  • uspace/lib/c/include/ipc/devman.h

    r8375d0eb r8b36bf2  
    157157        DEVMAN_FUN_GET_CHILD,
    158158        DEVMAN_FUN_GET_NAME,
     159        DEVMAN_FUN_GET_DRIVER_NAME,
    159160        DEVMAN_FUN_ONLINE,
    160161        DEVMAN_FUN_OFFLINE,

  • uspace/lib/c/include/ipc/loc.h

    r8375d0eb r8b36bf2  
    5656        LOC_SERVICE_GET_ID,
    5757        LOC_SERVICE_GET_NAME,
     58        LOC_SERVICE_GET_SERVER_NAME,
    5859        LOC_NAMESPACE_GET_ID,
    5960        LOC_CALLBACK_CREATE,

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

    r8375d0eb r8b36bf2  
    5656    unsigned int);
    5757extern int loc_service_get_name(service_id_t, char **);
     58extern int loc_service_get_server_name(service_id_t, char **);
    5859extern int loc_namespace_get_id(const char *, service_id_t *,
    5960    unsigned int);

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

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

  • uspace/lib/fb/imgmap.c

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

  • uspace/lib/fb/screenbuffer.c

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

  • uspace/lib/fs/libfs.c

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

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

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

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

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

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

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

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

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

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

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

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

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

  • uspace/srv/devman/main.c

    r8375d0eb r8b36bf2  
    855855}
    856856
     857/** Get function driver name. */
     858static void devman_fun_get_driver_name(ipc_callid_t iid, ipc_call_t *icall)
     859{
     860        devman_handle_t handle = IPC_GET_ARG1(*icall);
     861
     862        fun_node_t *fun = find_fun_node(&device_tree, handle);
     863        if (fun == NULL) {
     864                async_answer_0(iid, ENOMEM);
     865                return;
     866        }
     867
     868        ipc_callid_t data_callid;
     869        size_t data_len;
     870        if (!async_data_read_receive(&data_callid, &data_len)) {
     871                async_answer_0(iid, EINVAL);
     872                fun_del_ref(fun);
     873                return;
     874        }
     875
     876        void *buffer = malloc(data_len);
     877        if (buffer == NULL) {
     878                async_answer_0(data_callid, ENOMEM);
     879                async_answer_0(iid, ENOMEM);
     880                fun_del_ref(fun);
     881                return;
     882        }
     883
     884        fibril_rwlock_read_lock(&device_tree.rwlock);
     885
     886        /* Check function state */
     887        if (fun->state == FUN_REMOVED) {
     888                fibril_rwlock_read_unlock(&device_tree.rwlock);
     889                free(buffer);
     890
     891                async_answer_0(data_callid, ENOENT);
     892                async_answer_0(iid, ENOENT);
     893                fun_del_ref(fun);
     894                return;
     895        }
     896
     897        /* Check whether function has a driver */
     898        if (fun->child == NULL || fun->child->drv == NULL) {
     899                fibril_rwlock_read_unlock(&device_tree.rwlock);
     900                free(buffer);
     901
     902                async_answer_0(data_callid, EINVAL);
     903                async_answer_0(iid, EINVAL);
     904                fun_del_ref(fun);
     905                return;
     906        }
     907
     908        size_t sent_length = str_size(fun->child->drv->name);
     909        if (sent_length > data_len) {
     910                sent_length = data_len;
     911        }
     912
     913        async_data_read_finalize(data_callid, fun->child->drv->name,
     914            sent_length);
     915        async_answer_0(iid, EOK);
     916
     917        fibril_rwlock_read_unlock(&device_tree.rwlock);
     918        fun_del_ref(fun);
     919        free(buffer);
     920}
    857921
    858922/** Get device path. */
    … …  
    10821146                case DEVMAN_FUN_GET_NAME:
    10831147                        devman_fun_get_name(callid, &call);
     1148                        break;
     1149                case DEVMAN_FUN_GET_DRIVER_NAME:
     1150                        devman_fun_get_driver_name(callid, &call);
    10841151                        break;
    10851152                case DEVMAN_FUN_GET_PATH:

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

    r8375d0eb r8b36bf2  
    305305       
    306306        int rc = async_share_out_finalize(callid, &frontbuf->data);
    307         if ((rc != EOK) || (frontbuf->data == (void *) -1)) {
     307        if ((rc != EOK) || (frontbuf->data == AS_MAP_FAILED)) {
    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 == (void *) -1)) {
     350        if ((rc != EOK) || (imagemap->data == AS_MAP_FAILED)) {
    351351                free(imagemap);
    352352                async_answer_0(iid, ENOMEM);

  • uspace/srv/locsrv/locsrv.c

    r8375d0eb r8b36bf2  
    656656}
    657657
     658static void loc_service_get_server_name(ipc_callid_t iid, ipc_call_t *icall)
     659{
     660        ipc_callid_t callid;
     661        size_t size;
     662        size_t act_size;
     663        loc_service_t *svc;
     664       
     665        if (!async_data_read_receive(&callid, &size)) {
     666                async_answer_0(callid, EREFUSED);
     667                async_answer_0(iid, EREFUSED);
     668                return;
     669        }
     670       
     671        fibril_mutex_lock(&services_list_mutex);
     672       
     673        svc = loc_service_find_id(IPC_GET_ARG1(*icall));
     674        if (svc == NULL) {
     675                fibril_mutex_unlock(&services_list_mutex);
     676                async_answer_0(callid, ENOENT);
     677                async_answer_0(iid, ENOENT);
     678                return;
     679        }
     680       
     681        if (svc->server == NULL) {
     682                fibril_mutex_unlock(&services_list_mutex);
     683                async_answer_0(callid, EINVAL);
     684                async_answer_0(iid, EINVAL);
     685                return;
     686        }
     687       
     688        act_size = str_size(svc->server->name);
     689        if (act_size > size) {
     690                fibril_mutex_unlock(&services_list_mutex);
     691                async_answer_0(callid, EOVERFLOW);
     692                async_answer_0(iid, EOVERFLOW);
     693                return;
     694        }
     695       
     696        sysarg_t retval = async_data_read_finalize(callid, svc->server->name,
     697            min(size, act_size));
     698       
     699        fibril_mutex_unlock(&services_list_mutex);
     700       
     701        async_answer_0(iid, retval);
     702}
     703
    658704/** Connect client to the service.
    659705 *
    … …  
    14041450                case LOC_SERVICE_GET_NAME:
    14051451                        loc_service_get_name(callid, &call);
     1452                        break;
     1453                case LOC_SERVICE_GET_SERVER_NAME:
     1454                        loc_service_get_server_name(callid, &call);
    14061455                        break;
    14071456                case LOC_NAMESPACE_GET_ID:

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

    r8375d0eb r8b36bf2  
    151151            sock, sock_id);
    152152
    153         if (rc != EOK)
     153        if (rc != EOK) {
     154                fibril_destroy(sock->recv_fibril);
     155                sock->recv_fibril = 0;
    154156                return rc;
     157        }
    155158
    156159        sock_core = socket_cores_find(&sock->client->sockets, *sock_id);

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

    r8375d0eb r8b36bf2  
    5151#include "ucall.h"
    5252
    53 #define FRAGMENT_SIZE 1024
    54 
    5553/** Free ports pool start. */
    5654#define UDP_FREE_PORTS_START            1025
    … …  
    6361
    6462static void udp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg);
     63static int udp_sock_recv_fibril(void *arg);
    6564
    6665int udp_sock_init(void)
    … …  
    8281
    8382        socket = (udp_sockdata_t *)sock_core->specific_data;
    84         assert(socket->assoc != NULL);
    85         udp_uc_destroy(socket->assoc);
     83        (void)socket;
     84
     85        /* XXX We need to force the receive fibril to quit */
    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             FRAGMENT_SIZE, 0, 0, 1);
     93            UDP_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
    115120        rc = udp_uc_create(&sock->assoc);
    116121        if (rc != EOK) {
     122                free(sock);
     123                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);
     132                return;
     133        }
     134
     135        sock_id = SOCKET_GET_SOCKET_ID(call);
     136        rc = socket_create(&client->sockets, client->sess, sock, &sock_id);
     137        if (rc != EOK) {
     138                fibril_destroy(sock->recv_fibril);
    117139                udp_uc_destroy(sock->assoc);
    118140                free(sock);
    … …  
    121143        }
    122144
    123         sock_id = SOCKET_GET_SOCKET_ID(call);
    124         rc = socket_create(&client->sockets, client->sess, sock, &sock_id);
    125         if (rc != EOK) {
    126                 async_answer_0(callid, rc);
    127                 return;
    128         }
     145        fibril_add_ready(sock->recv_fibril);
    129146
    130147        sock_core = socket_cores_find(&client->sockets, sock_id);
    … …  
    134151        SOCKET_SET_SOCKET_ID(answer, sock_id);
    135152
    136         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
     153        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, UDP_FRAGMENT_SIZE);
    137154        SOCKET_SET_HEADER_SIZE(answer, sizeof(udp_header_t));
    138155        async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
    … …  
    205222        }
    206223
    207         udp_sock_notify_data(sock_core);
    208 
    209224        log_msg(LVL_DEBUG, " - success");
    210225        async_answer_0(callid, rc);
    … …  
    245260        ipc_callid_t wcallid;
    246261        size_t length;
    247         uint8_t buffer[FRAGMENT_SIZE];
     262        uint8_t buffer[UDP_FRAGMENT_SIZE];
    248263        udp_error_t urc;
    249264        int rc;
    … …  
    292307                        goto out;
    293308                }
    294 
    295                 udp_sock_notify_data(sock_core);
    296309        }
    297310
    … …  
    330343                }
    331344
    332                 if (length > FRAGMENT_SIZE)
    333                         length = FRAGMENT_SIZE;
     345                if (length > UDP_FRAGMENT_SIZE)
     346                        length = UDP_FRAGMENT_SIZE;
    334347
    335348                rc = async_data_write_finalize(wcallid, buffer, length);
    … …  
    367380       
    368381        IPC_SET_ARG1(answer, 0);
    369         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
     382        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, UDP_FRAGMENT_SIZE);
    370383        async_answer_2(callid, EOK, IPC_GET_ARG1(answer),
    371384            IPC_GET_ARG2(answer));
    … …  
    386399        ipc_call_t answer;
    387400        ipc_callid_t rcallid;
    388         uint8_t buffer[FRAGMENT_SIZE];
    389401        size_t data_len;
    390         xflags_t xflags;
    391402        udp_error_t urc;
     403        udp_sock_t rsock;
    392404        struct sockaddr_in addr;
    393         udp_sock_t rsock;
    394405        int rc;
    395406
    … …  
    416427        (void)flags;
    417428
    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);
     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);
    421444
    422445        switch (urc) {
    … …  
    437460        log_msg(LVL_DEBUG, "**** udp_uc_receive -> %d", rc);
    438461        if (rc != EOK) {
     462                fibril_mutex_unlock(&socket->recv_buffer_lock);
    439463                fibril_mutex_unlock(&socket->lock);
    440464                async_answer_0(callid, rc);
    … …  
    450474                log_msg(LVL_DEBUG, "addr read receive");
    451475                if (!async_data_read_receive(&rcallid, &addr_length)) {
     476                        fibril_mutex_unlock(&socket->recv_buffer_lock);
    452477                        fibril_mutex_unlock(&socket->lock);
    453478                        async_answer_0(callid, EINVAL);
    … …  
    461486                rc = async_data_read_finalize(rcallid, &addr, addr_length);
    462487                if (rc != EOK) {
     488                        fibril_mutex_unlock(&socket->recv_buffer_lock);
    463489                        fibril_mutex_unlock(&socket->lock);
    464490                        async_answer_0(callid, EINVAL);
    … …  
    469495        log_msg(LVL_DEBUG, "data read receive");
    470496        if (!async_data_read_receive(&rcallid, &length)) {
     497                fibril_mutex_unlock(&socket->recv_buffer_lock);
    471498                fibril_mutex_unlock(&socket->lock);
    472499                async_answer_0(callid, EINVAL);
    … …  
    478505
    479506        log_msg(LVL_DEBUG, "data read finalize");
    480         rc = async_data_read_finalize(rcallid, buffer, length);
     507        rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
    481508
    482509        if (length < data_len && rc == EOK)
    … …  
    489516        async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
    490517            IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
    491        
    492         /* Push one fragment notification to client's queue */
    493         udp_sock_notify_data(sock_core);
     518
     519        socket->recv_buffer_used = 0;
     520
     521        fibril_condvar_broadcast(&socket->recv_buffer_cv);
     522        fibril_mutex_unlock(&socket->recv_buffer_lock);
    494523        fibril_mutex_unlock(&socket->lock);
    495524}
    … …  
    538567}
    539568
     569static 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
    540611static void udp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    541612{

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

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

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

    r8375d0eb r8b36bf2  
    3636#define UDP_TYPE_H
    3737
     38#include <fibril.h>
    3839#include <fibril_synch.h>
    3940#include <socket_core.h>
    4041#include <sys/types.h>
     42
     43#define UDP_FRAGMENT_SIZE 4096
     44
    4145
    4246typedef enum {
    … …  
    141145        /** Connection */
    142146        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;
    143155} udp_sockdata_t;
    144156

  • uspace/srv/vfs/vfs.c

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