Changeset 936351c1 in mainline


Ignore:
Timestamp:
2006-03-14T23:48:33Z (19 years ago)
Author:
Ondrej Palkovsky <ondrap@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
d73942c
Parents:
4f34b6a
Message:

Completed asynchronous IPC.
Fixed sbrk.
Cleared some unnecessary defines in malloc.
Changed u8 * to char * in list.

Files:
1 added
10 edited

Legend:

Unmodified
Added
Removed

  • init/Makefile

    r4f34b6a r936351c1  
    5959
    6060$(OUTPUT): $(OBJECTS)
    61         $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld  $(OBJECTS) $(LIBC_PREFIX)/libc.a $(LIBIPC_PREFIX)/libipc.a $(LFLAGS) -o $@ -Map $(OUTPUT).map
     61        $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld  $(OBJECTS) $(LIBIPC_PREFIX)/libipc.a $(LIBC_PREFIX)/libc.a $(LFLAGS) -o $@ -Map $(OUTPUT).map
    6262
    6363disasm:

  • init/init.c

    r4f34b6a r936351c1  
    3333#include <unistd.h>
    3434#include <stdlib.h>
     35
    3536/*
    3637static void test_printf(void)
    … …  
    4546}
    4647*/
     48
    4749/*
    4850static void test_mremap(void)
    … …  
    9092*/
    9193
     94/*
     95static void got_answer(void *private, int retval, ipc_data_t *data)
     96{
     97        printf("Retval: %d...%s...%X, %X\n", retval, private,
     98               IPC_GET_ARG1(*data), IPC_GET_ARG2(*data));
     99}
     100static void test_async_ipc(void)
     101{
     102        ipc_data_t data;
     103        int i;
     104
     105        printf("Sending ping\n");
     106        ipc_call_async_2(PHONE_NS, NS_PING, 1, 0xbeefbee2,
     107                         "Pong1", got_answer);
     108        ipc_call_async_2(PHONE_NS, NS_PING, 2, 0xbeefbee4,
     109                         "Pong2", got_answer);
     110        ipc_call_async_2(PHONE_NS, NS_PING, 3, 0xbeefbee4,
     111                         "Pong3", got_answer);
     112        ipc_call_async_2(PHONE_NS, NS_PING, 4, 0xbeefbee4,
     113                         "Pong4", got_answer);
     114        ipc_call_async_2(PHONE_NS, NS_PING, 5, 0xbeefbee4,
     115                         "Pong5", got_answer);
     116        ipc_call_async_2(PHONE_NS, NS_PING, 6, 0xbeefbee4,
     117                         "Pong6", got_answer);
     118        printf("Waiting forever...\n");
     119        for (i=0; i<100;i++)
     120                printf(".");
     121        printf("\n");
     122        ipc_wait_for_call(&data, NULL);
     123        printf("Received call???\n");
     124}
     125*/
     126
    92127int main(int argc, char *argv[])
    93128{
     129        ipcarg_t arg1, arg2;
     130
    94131        version_print();
    95132
    96         ipc_call_sync_2(PHONE_NS, NS_PING, 2, 0, 0, 0);
     133        ipc_call_sync_2(PHONE_NS, NS_PING, 0xaaaa, 0xbbbb, &arg1, &arg2);
     134        printf("Pong: %P %P\n", arg1, arg2);
    97135       
    98136        return 0;

  • libadt/include/list.h

    r4f34b6a r936351c1  
    178178}
    179179
    180 #define list_get_instance(link,type,member) (type *)(((__u8*)(link))-((__u8*)&(((type *)NULL)->member)))
     180#define list_get_instance(link,type,member) (type *)(((char *)(link))-((char *)&(((type *)NULL)->member)))
    181181
    182182extern int list_member(const link_t *link, const link_t *head);

  • libc/Makefile

    r4f34b6a r936351c1  
    4343        generic/libc.c \
    4444        generic/mmap.c \
     45        generic/string.c \
    4546        generic/io/io.c \
    4647        generic/io/print.c \

  • libc/generic/mmap.c

    r4f34b6a r936351c1  
    6363        if (!res)
    6464                return NULL;
    65         res = (void *)&_heap + incr;
     65       
     66        /* Compute start of new area */
     67        res = (void *)&_heap + heapsize;
     68
    6669        heapsize += incr;
     70
    6771        return res;
    6872}

  • libc/include/string.h

    r4f34b6a r936351c1  
    3131#define __LIBC__STRING_H__
    3232
    33 static inline void * memset(void *s, int c, size_t n)
    34 {
    35         char *os = s;
    36         while (n--)
    37                 *(os++) = c;
    38         return s;
    39 }
    40 
    41 static inline void * memcpy(void *dest, void *src, size_t n)
    42 {
    43         char *os = src;
    44         char *odst = dest;
    45         while (n--)
    46                 *(odst++) = *(os++);
    47         return dest;
    48 }
     33void * memset(void *s, int c, size_t n);
     34void * memcpy(void *dest, void *src, size_t n);
    4935
    5036#endif

  • libc/malloc/malloc.c

    r4f34b6a r936351c1  
    439439*/
    440440
    441 #ifndef WIN32
    442 #ifdef _WIN32
    443 #define WIN32 1
    444 #endif  /* _WIN32 */
    445 #endif  /* WIN32 */
    446 #ifdef WIN32
    447 #define WIN32_LEAN_AND_MEAN
    448 #include <windows.h>
    449 #define HAVE_MMAP 1
    450 #define HAVE_MORECORE 0
    451 #define LACKS_UNISTD_H
     441#include <sys/types.h>  /* For size_t */
     442
     443/** Non-default helenos customizations */
     444#define LACKS_FCNTL_H
     445#define LACKS_SYS_MMAN_H
    452446#define LACKS_SYS_PARAM_H
    453 #define LACKS_SYS_MMAN_H
    454 #define LACKS_STRING_H
    455 #define LACKS_STRINGS_H
    456 #define LACKS_SYS_TYPES_H
     447#undef HAVE_MMAP
     448#define HAVE_MMAP 0
    457449#define LACKS_ERRNO_H
     450/* Set errno? */
     451#undef MALLOC_FAILURE_ACTION
    458452#define MALLOC_FAILURE_ACTION
    459 #define MMAP_CLEARS 0 /* WINCE and some others apparently don't clear */
    460 #endif  /* WIN32 */
    461 
    462 #if defined(DARWIN) || defined(_DARWIN)
    463 /* Mac OSX docs advise not to use sbrk; it seems better to use mmap */
    464 #ifndef HAVE_MORECORE
    465 #define HAVE_MORECORE 0
    466 #define HAVE_MMAP 1
    467 #endif  /* HAVE_MORECORE */
    468 #endif  /* DARWIN */
    469 
    470 #ifndef LACKS_SYS_TYPES_H
    471 #include <sys/types.h>  /* For size_t */
    472 #endif  /* LACKS_SYS_TYPES_H */
    473453
    474454/* The maximum possible size_t value has all bits set */
    475455#define MAX_SIZE_T           (~(size_t)0)
    476456
    477 #ifndef ONLY_MSPACES
    478457#define ONLY_MSPACES 0
    479 #endif  /* ONLY_MSPACES */
    480 #ifndef MSPACES
    481 #if ONLY_MSPACES
    482 #define MSPACES 1
    483 #else   /* ONLY_MSPACES */
    484458#define MSPACES 0
    485 #endif  /* ONLY_MSPACES */
    486 #endif  /* MSPACES */
    487 #ifndef MALLOC_ALIGNMENT
    488459#define MALLOC_ALIGNMENT ((size_t)8U)
    489 #endif  /* MALLOC_ALIGNMENT */
    490 #ifndef FOOTERS
    491460#define FOOTERS 0
    492 #endif  /* FOOTERS */
    493 #ifndef ABORT
    494461#define ABORT  abort()
    495 #endif  /* ABORT */
    496 #ifndef ABORT_ON_ASSERT_FAILURE
    497462#define ABORT_ON_ASSERT_FAILURE 1
    498 #endif  /* ABORT_ON_ASSERT_FAILURE */
    499 #ifndef PROCEED_ON_ERROR
    500463#define PROCEED_ON_ERROR 0
    501 #endif  /* PROCEED_ON_ERROR */
    502 #ifndef USE_LOCKS
    503464#define USE_LOCKS 0
    504 #endif  /* USE_LOCKS */
    505 #ifndef INSECURE
    506465#define INSECURE 0
    507 #endif  /* INSECURE */
    508 #ifndef HAVE_MMAP
    509 #define HAVE_MMAP 1
    510 #endif  /* HAVE_MMAP */
    511 #ifndef MMAP_CLEARS
     466#define HAVE_MMAP 0
     467
    512468#define MMAP_CLEARS 1
    513 #endif  /* MMAP_CLEARS */
    514 #ifndef HAVE_MREMAP
    515 #ifdef linux
    516 #define HAVE_MREMAP 1
    517 #else   /* linux */
    518 #define HAVE_MREMAP 0
    519 #endif  /* linux */
    520 #endif  /* HAVE_MREMAP */
    521 #ifndef MALLOC_FAILURE_ACTION
    522 #define MALLOC_FAILURE_ACTION  errno = ENOMEM;
    523 #endif  /* MALLOC_FAILURE_ACTION */
    524 #ifndef HAVE_MORECORE
    525 #if ONLY_MSPACES
    526 #define HAVE_MORECORE 0
    527 #else   /* ONLY_MSPACES */
     469
    528470#define HAVE_MORECORE 1
    529 #endif  /* ONLY_MSPACES */
    530 #endif  /* HAVE_MORECORE */
    531 #if !HAVE_MORECORE
    532 #define MORECORE_CONTIGUOUS 0
    533 #else   /* !HAVE_MORECORE */
    534 #ifndef MORECORE
     471#define MORECORE_CONTIGUOUS 1
    535472#define MORECORE sbrk
    536 #endif  /* MORECORE */
    537 #ifndef MORECORE_CONTIGUOUS
    538 #define MORECORE_CONTIGUOUS 1
    539 #endif  /* MORECORE_CONTIGUOUS */
    540 #endif  /* HAVE_MORECORE */
    541 #ifndef DEFAULT_GRANULARITY
    542 #if MORECORE_CONTIGUOUS
    543473#define DEFAULT_GRANULARITY (0)  /* 0 means to compute in init_mparams */
    544 #else   /* MORECORE_CONTIGUOUS */
    545 #define DEFAULT_GRANULARITY ((size_t)64U * (size_t)1024U)
    546 #endif  /* MORECORE_CONTIGUOUS */
    547 #endif  /* DEFAULT_GRANULARITY */
     474
    548475#ifndef DEFAULT_TRIM_THRESHOLD
    549476#ifndef MORECORE_CANNOT_TRIM
    … …  
    584511#define M_MMAP_THRESHOLD     (-3)
    585512
    586 /** Non-default helenos customizations */
    587 #define LACKS_FCNTL_H
    588 #define LACKS_SYS_MMAN_H
    589 #define LACKS_SYS_PARAM_H
    590 #undef HAVE_MMAP
    591 #define HAVE_MMAP 0
    592 #define LACKS_ERRNO_H
    593 /* Set errno? */
    594 #undef MALLOC_FAILURE_ACTION
    595 #define MALLOC_FAILURE_ACTION
    596 
    597 
    598513/*
    599514  ========================================================================
    … …  
    608523/*------------------------------ internal #includes ---------------------- */
    609524
    610 #ifdef WIN32
    611 #pragma warning( disable : 4146 ) /* no "unsigned" warnings */
    612 #endif /* WIN32 */
    613 
    614525#include <stdio.h>       /* for printing in malloc_stats */
     526#include <string.h>
    615527
    616528#ifndef LACKS_ERRNO_H
    … …  
    632544#define assert(x)
    633545#endif /* DEBUG */
    634 #ifndef LACKS_STRING_H
    635 #include <string.h>      /* for memset etc */
    636 #endif  /* LACKS_STRING_H */
    637546#if USE_BUILTIN_FFS
    638547#ifndef LACKS_STRINGS_H

  • libipc/Makefile

    r4f34b6a r936351c1  
    3737include $(LIBC_PREFIX)/Makefile.toolchain
    3838
    39 CFLAGS += -Iinclude
     39CFLAGS += -Iinclude -I../libadt/include -I../libc/include
    4040
    4141## Sources

  • libipc/generic/ipc.c

    r4f34b6a r936351c1  
    2929#include <ipc.h>
    3030#include <libc.h>
    31 
    32 int ipc_call_sync(int phoneid, sysarg_t method, sysarg_t arg1,
    33                   sysarg_t *result)
     31#include <malloc.h>
     32#include <errno.h>
     33#include <list.h>
     34#include <stdio.h>
     35#include <unistd.h>
     36
     37/** Structure used for keeping track of sent async msgs
     38 * and queing unsent msgs
     39 *
     40 */
     41typedef struct {
     42        link_t list;
     43
     44        ipc_async_callback_t callback;
     45        void *private;
     46        union {
     47                ipc_callid_t callid;
     48                struct {
     49                        int phoneid;
     50                        ipc_data_t data;
     51                } msg;
     52        }u;
     53} async_call_t;
     54
     55LIST_INITIALIZE(dispatched_calls);
     56LIST_INITIALIZE(queued_calls);
     57
     58int ipc_call_sync(int phoneid, ipcarg_t method, ipcarg_t arg1,
     59                  ipcarg_t *result)
    3460{
    3561        ipc_data_t resdata;
    3662        int callres;
    3763       
    38         callres = __SYSCALL4(SYS_IPC_CALL_SYNC, phoneid, method, arg1,
     64        callres = __SYSCALL4(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1,
    3965                             (sysarg_t)&resdata);
    4066        if (callres)
    … …  
    4571}
    4672
    47 int ipc_call_sync_3(int phoneid, sysarg_t method, sysarg_t arg1,
    48                     sysarg_t arg2, sysarg_t arg3,
    49                     sysarg_t *result1, sysarg_t *result2, sysarg_t *result3)
     73int ipc_call_sync_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
     74                    ipcarg_t arg2, ipcarg_t arg3,
     75                    ipcarg_t *result1, ipcarg_t *result2, ipcarg_t *result3)
    5076{
    5177        ipc_data_t data;
    … …  
    5783        IPC_SET_ARG3(data, arg3);
    5884
    59         callres = __SYSCALL2(SYS_IPC_CALL_SYNC_MEDIUM, phoneid, (sysarg_t)&data);
     85        callres = __SYSCALL2(SYS_IPC_CALL_SYNC, phoneid, (sysarg_t)&data);
    6086        if (callres)
    6187                return callres;
    … …  
    7096}
    7197
     98/** Syscall to send asynchronous message */
     99static  ipc_callid_t _ipc_call_async(int phoneid, ipc_data_t *data)
     100{
     101        return __SYSCALL2(SYS_IPC_CALL_ASYNC, phoneid, (sysarg_t)data);
     102}
     103
    72104/** Send asynchronous message
    73105 *
    … …  
    75107 * - if message cannot be temporarily sent, add to queue
    76108 */
    77 void ipc_call_async_2(int phoneid, sysarg_t method, sysarg_t arg1,
    78                       sysarg_t arg2,
     109void ipc_call_async_2(int phoneid, ipcarg_t method, ipcarg_t arg1,
     110                      ipcarg_t arg2, void *private,
    79111                      ipc_async_callback_t callback)
    80112{
     113        async_call_t *call;
    81114        ipc_callid_t callid;
    82         ipc_data_t data; /* Data storage for saving calls */
    83 
    84         callid = __SYSCALL4(SYS_IPC_CALL_ASYNC, phoneid, method, arg1, arg2);
     115
     116        call = malloc(sizeof(*call));
     117        if (!call) {
     118                callback(private, ENOMEM, NULL);
     119        }
     120               
     121        callid = __SYSCALL4(SYS_IPC_CALL_ASYNC_FAST, phoneid, method, arg1, arg2);
    85122        if (callid == IPC_CALLRET_FATAL) {
    86123                /* Call asynchronous handler with error code */
    87                 IPC_SET_RETVAL(data, IPC_CALLRET_FATAL);
    88                 callback(&data);
     124                IPC_SET_RETVAL(call->u.msg.data, ENOENT);
     125                callback(private, ENOENT, NULL);
     126                free(call);
    89127                return;
    90128        }
     129
     130        call->callback = callback;
     131        call->private = private;
     132
    91133        if (callid == IPC_CALLRET_TEMPORARY) {
    92134                /* Add asynchronous call to queue of non-dispatched async calls */
    93                 IPC_SET_METHOD(data, method);
    94                 IPC_SET_ARG1(data, arg1);
    95                 IPC_SET_ARG2(data, arg2);
    96                
     135                call->u.msg.phoneid = phoneid;
     136                IPC_SET_METHOD(call->u.msg.data, method);
     137                IPC_SET_ARG1(call->u.msg.data, arg1);
     138                IPC_SET_ARG2(call->u.msg.data, arg2);
     139
     140                list_append(&call->list, &queued_calls);
    97141                return;
    98142        }
    99         /* Add callid to list of dispatched calls */
    100        
     143        call->u.callid = callid;
     144        /* Add call to list of dispatched calls */
     145        list_append(&call->list, &dispatched_calls);
    101146}
    102147
    103148
    104149/** Send answer to a received call */
    105 void ipc_answer(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
    106                 sysarg_t arg2)
     150void ipc_answer(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,
     151                ipcarg_t arg2)
    107152{
    108153        __SYSCALL4(SYS_IPC_ANSWER, callid, retval, arg1, arg2);
    … …  
    116161}
    117162
     163/** Try to dispatch queed calls from async queue */
     164static void try_dispatch_queued_calls(void)
     165{
     166        async_call_t *call;
     167        ipc_callid_t callid;
     168
     169        while (!list_empty(&queued_calls)) {
     170                call = list_get_instance(queued_calls.next, async_call_t,
     171                                         list);
     172
     173                callid = _ipc_call_async(call->u.msg.phoneid,
     174                                         &call->u.msg.data);
     175                if (callid == IPC_CALLRET_TEMPORARY)
     176                        break;
     177                list_remove(&call->list);
     178                if (callid == IPC_CALLRET_FATAL) {
     179                        call->callback(call->private, ENOENT, NULL);
     180                        free(call);
     181                } else {
     182                        call->u.callid = callid;
     183                        list_append(&call->list, &dispatched_calls);
     184                }
     185        }
     186}
     187
     188/** Handle received answer
     189 *
     190 * TODO: Make it use hash table
     191 *
     192 * @param callid Callid (with first bit set) of the answered call
     193 */
     194static void handle_answer(ipc_callid_t callid, ipc_data_t *data)
     195{
     196        link_t *item;
     197        async_call_t *call;
     198
     199        callid &= ~IPC_CALLID_ANSWERED;
     200       
     201        for (item = dispatched_calls.next; item != &dispatched_calls;
     202             item = item->next) {
     203                call = list_get_instance(item, async_call_t, list);
     204                if (call->u.callid == callid) {
     205                        list_remove(&call->list);
     206                        call->callback(call->private,
     207                                       IPC_GET_RETVAL(*data),
     208                                       data);
     209                        return;
     210                }
     211        }
     212        printf("Received unidentified answer: %P!!!\n", callid);
     213}
     214
     215
    118216/** Wait for IPC call and return
    119217 *
    120218 * - dispatch ASYNC reoutines in the background
     219 * @param data Space where the message is stored
     220 * @return Callid or 0 if nothing available and started with
     221 *         IPC_WAIT_NONBLOCKING
    121222 */
    122223int ipc_wait_for_call(ipc_data_t *data, int flags)
    … …  
    125226
    126227        do {
    127                 /* Try to dispatch non-dispatched async calls */
     228                try_dispatch_queued_calls();
     229
    128230                callid = _ipc_wait_for_call(data, flags);
    129                 if (callid & IPC_CALLID_ANSWERED) {
    130                         /* TODO: Call async answer handler */
    131                 }
     231                /* Handle received answers */
     232                if (callid & IPC_CALLID_ANSWERED)
     233                        handle_answer(callid, data);
    132234        } while (callid & IPC_CALLID_ANSWERED);
     235
    133236        return callid;
    134237}

  • libipc/include/ipc.h

    r4f34b6a r936351c1  
    3333#include <libc.h>
    3434
    35 typedef sysarg_t ipc_data_t[IPC_CALL_LEN];
     35typedef sysarg_t ipcarg_t;
     36typedef ipcarg_t ipc_data_t[IPC_CALL_LEN];
    3637typedef sysarg_t ipc_callid_t;
    3738
    38 typedef void (* ipc_async_callback_t)(ipc_data_t *data);
     39typedef void (* ipc_async_callback_t)(void *private,
     40                                      int retval,
     41                                      ipc_data_t *data);
    3942
    4043#define ipc_call_sync_2(phoneid, method, arg1, arg2, res1, res2) ipc_call_sync_3((phoneid), (method), (arg1), (arg2), 0, (res1), (res2), 0)
    41 extern int ipc_call_sync_3(int phoneid, sysarg_t method, sysarg_t arg1,
    42                            sysarg_t arg2, sysarg_t arg3,
    43                            sysarg_t *result1, sysarg_t *result2,
    44                            sysarg_t *result3);
     44extern int ipc_call_sync_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
     45                           ipcarg_t arg2, ipcarg_t arg3,
     46                           ipcarg_t *result1, ipcarg_t *result2,
     47                           ipcarg_t *result3);
    4548
    4649
    47 extern int ipc_call_sync(int phoneid, sysarg_t method, sysarg_t arg1,
    48                          sysarg_t *result);
     50extern int ipc_call_sync(int phoneid, ipcarg_t method, ipcarg_t arg1,
     51                         ipcarg_t *result);
    4952extern int ipc_wait_for_call(ipc_data_t *data, int flags);
    50 extern void ipc_answer(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
    51                        sysarg_t arg2);
     53extern void ipc_answer(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,
     54                       ipcarg_t arg2);
    5255
    53 #define ipc_call_async(phoneid,method,arg1,callback) (ipc_call_async_2(phoneid, method, arg1, 0, callback))
    54 void ipc_call_async_2(int phoneid, sysarg_t method, sysarg_t arg1,
    55                       sysarg_t arg2,
     56#define ipc_call_async(phoneid,method,arg1,private, callback) (ipc_call_async_2(phoneid, method, arg1, 0, private, callback))
     57void ipc_call_async_2(int phoneid, ipcarg_t method, ipcarg_t arg1,
     58                      ipcarg_t arg2, void *private,
    5659                      ipc_async_callback_t callback);
    5760
Note: See TracChangeset for help on using the changeset viewer.