Changeset 5c1b3cd in mainline for uspace/lib/c


Ignore:
Timestamp:
2013-03-16T21:48:33Z (13 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
6b0cfa1
Parents:
71fe7e9d (diff), f597bc4 (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:

Mainline changes

Location:
uspace/lib/c
Files:
64 added
64 deleted
18 edited
109 moved

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/Makefile

    r71fe7e9d r5c1b3cd  
    3131ROOT_PATH = $(USPACE_PREFIX)/..
    3232
    33 INCLUDE_ABI = include/abi
    34 INCLUDE_LIBARCH = include/libarch
    35 
    3633COMMON_MAKEFILE = $(ROOT_PATH)/Makefile.common
    3734COMMON_HEADER = $(ROOT_PATH)/common.h
    38 COMMON_HEADER_ARCH = arch/$(UARCH)/include/common.h
     35COMMON_HEADER_ARCH = arch/$(UARCH)/include/libarch/common.h
    3936
    4037CONFIG_MAKEFILE = $(ROOT_PATH)/Makefile.config
    … …  
    4643        $(LIBC_PREFIX)/arch/$(UARCH)/_link-dlexe.ld
    4744
    48 PRE_DEPEND = $(INCLUDE_ABI) $(INCLUDE_LIBARCH) $(COMMON_HEADER_ARCH)
     45PRE_DEPEND = $(COMMON_HEADER_ARCH)
    4946EXTRA_OUTPUT = $(LINKER_SCRIPTS)
    50 EXTRA_CLEAN = $(INCLUDE_ABI) $(INCLUDE_LIBARCH) $(COMMON_HEADER_ARCH) $(LINKER_SCRIPTS)
     47EXTRA_CLEAN = $(COMMON_HEADER_ARCH) $(LINKER_SCRIPTS)
    5148LIBRARY = libc
    5249SLIBRARY = libc.so.0.0
    … …  
    162159include $(USPACE_PREFIX)/Makefile.common
    163160
    164 $(INCLUDE_LIBARCH): arch/$(UARCH)/include
    165         ln -sfn ../$< $@
    166 
    167 $(INCLUDE_ABI): ../../../abi/include/
    168         ln -sfn ../$< $@
    169161
    170162$(LIBC_PREFIX)/arch/$(UARCH)/_link.ld: $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld.in
    … …  
    181173
    182174$(COMMON_HEADER_ARCH): $(COMMON_HEADER)
    183         ln -sfn ../../../$< $@
     175        ln -sfn ../../../../$< $@

  • uspace/lib/c/arch/abs32le/src/tls.c

    r71fe7e9d r5c1b3cd  
    3434#include <unistd.h>
    3535
    36 tcb_t * __alloc_tls(void **data, size_t size)
     36tcb_t * tls_alloc_arch(void **data, size_t size)
    3737{
    3838        return tls_alloc_variant_2(data, size);
    3939}
    4040
    41 void __free_tls_arch(tcb_t *tcb, size_t size)
     41void tls_free_arch(tcb_t *tcb, size_t size)
    4242{
    4343        tls_free_variant_2(tcb, size);

  • uspace/lib/c/arch/amd64/src/tls.c

    r71fe7e9d r5c1b3cd  
    3838#include <sys/types.h>
    3939
    40 tcb_t * __alloc_tls(void **data, size_t size)
     40tcb_t *tls_alloc_arch(void **data, size_t size)
    4141{
    4242        return tls_alloc_variant_2(data, size);
    4343}
    4444
    45 void __free_tls_arch(tcb_t *tcb, size_t size)
     45void tls_free_arch(tcb_t *tcb, size_t size)
    4646{
    4747        tls_free_variant_2(tcb, size);

  • uspace/lib/c/arch/arm32/src/tls.c

    r71fe7e9d r5c1b3cd  
    3838#include <sys/types.h>
    3939
    40 tcb_t * __alloc_tls(void **data, size_t size)
     40tcb_t *tls_alloc_arch(void **data, size_t size)
    4141{
    4242        return tls_alloc_variant_1(data, size);
    4343}
    4444
    45 void __free_tls_arch(tcb_t *tcb, size_t size)
     45void tls_free_arch(tcb_t *tcb, size_t size)
    4646{
    4747        tls_free_variant_1(tcb, size);

  • uspace/lib/c/arch/ia32/src/tls.c

    r71fe7e9d r5c1b3cd  
    3939#include <align.h>
    4040
    41 tcb_t * __alloc_tls(void **data, size_t size)
     41tcb_t *tls_alloc_arch(void **data, size_t size)
    4242{
    4343        return tls_alloc_variant_2(data, size);
    4444}
    4545
    46 void __free_tls_arch(tcb_t *tcb, size_t size)
     46void tls_free_arch(tcb_t *tcb, size_t size)
    4747{
    4848        tls_free_variant_2(tcb, size);

  • uspace/lib/c/arch/ia64/src/tls.c

    r71fe7e9d r5c1b3cd  
    3838#include <malloc.h>
    3939
    40 tcb_t * __alloc_tls(void **data, size_t size)
     40tcb_t *tls_alloc_arch(void **data, size_t size)
    4141{
    4242        return tls_alloc_variant_1(data, size);
    4343}
    4444
    45 void __free_tls_arch(tcb_t *tcb, size_t size)
     45void tls_free_arch(tcb_t *tcb, size_t size)
    4646{
    4747        tls_free_variant_1(tcb, size);

  • uspace/lib/c/arch/mips32/src/tls.c

    r71fe7e9d r5c1b3cd  
    3737#include <sys/types.h>
    3838
    39 tcb_t * __alloc_tls(void **data, size_t size)
     39tcb_t * tls_alloc_arch(void **data, size_t size)
    4040{
    4141        return tls_alloc_variant_1(data, size);
    4242}
    4343
    44 void __free_tls_arch(tcb_t *tcb, size_t size)
     44void tls_free_arch(tcb_t *tcb, size_t size)
    4545{
    4646        tls_free_variant_1(tcb, size);

  • uspace/lib/c/arch/mips64/src/tls.c

    r71fe7e9d r5c1b3cd  
    3737#include <sys/types.h>
    3838
    39 tcb_t * __alloc_tls(void **data, size_t size)
     39tcb_t *tls_alloc_arch(void **data, size_t size)
    4040{
    4141        return tls_alloc_variant_1(data, size);
    4242}
    4343
    44 void __free_tls_arch(tcb_t *tcb, size_t size)
     44void tls_free_arch(tcb_t *tcb, size_t size)
    4545{
    4646        tls_free_variant_1(tcb, size);

  • uspace/lib/c/arch/ppc32/src/tls.c

    r71fe7e9d r5c1b3cd  
    3636#include <sys/types.h>
    3737
    38 tcb_t * __alloc_tls(void **data, size_t size)
     38tcb_t *tls_alloc_arch(void **data, size_t size)
    3939{
    4040        return tls_alloc_variant_1(data, size);
    4141}
    4242
    43 void __free_tls_arch(tcb_t *tcb, size_t size)
     43void tls_free_arch(tcb_t *tcb, size_t size)
    4444{
    4545        tls_free_variant_1(tcb, size);

  • uspace/lib/c/arch/sparc64/src/tls.c

    r71fe7e9d r5c1b3cd  
    3838#include <sys/types.h>
    3939
    40 tcb_t * __alloc_tls(void **data, size_t size)
     40tcb_t *tls_alloc_arch(void **data, size_t size)
    4141{
    4242        return tls_alloc_variant_2(data, size);
    4343}
    4444
    45 void __free_tls_arch(tcb_t *tcb, size_t size)
     45void tls_free_arch(tcb_t *tcb, size_t size)
    4646{
    4747        tls_free_variant_2(tcb, size);

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

    r71fe7e9d r5c1b3cd  
    350350static async_client_conn_t client_connection = default_client_connection;
    351351static async_interrupt_handler_t interrupt_received = default_interrupt_received;
     352static size_t interrupt_handler_stksz = FIBRIL_DFLT_STK_SIZE;
    352353
    353354/** Setter for client_connection function pointer.
    … …  
    370371{
    371372        interrupt_received = intr;
     373}
     374
     375/** Set the stack size for the interrupt handler notification fibrils.
     376 *
     377 * @param size Stack size in bytes.
     378 */
     379void async_set_interrupt_handler_stack_size(size_t size)
     380{
     381        interrupt_handler_stksz = size;
    372382}
    373383
    … …  
    587597        msg->call = *call;
    588598       
    589         fid_t fid = fibril_create(notification_fibril, msg);
     599        fid_t fid = fibril_create_generic(notification_fibril, msg,
     600            interrupt_handler_stksz);
    590601        if (fid == 0) {
    591602                free(msg);
    … …  
    20572068       
    20582069        async_sess_t *sess = exch->sess;
     2070        assert(sess != NULL);
    20592071       
    20602072        atomic_dec(&sess->refcnt);

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

    r71fe7e9d r5c1b3cd  
    9595fibril_t *fibril_setup(void)
    9696{
    97         tcb_t *tcb = __make_tls();
     97        tcb_t *tcb = tls_make();
    9898        if (!tcb)
    9999                return NULL;
    … …  
    101101        fibril_t *fibril = malloc(sizeof(fibril_t));
    102102        if (!fibril) {
    103                 __free_tls(tcb);
     103                tls_free(tcb);
    104104                return NULL;
    105105        }
    … …  
    122122void fibril_teardown(fibril_t *fibril)
    123123{
    124         __free_tls(fibril->tcb);
     124        tls_free(fibril->tcb);
    125125        free(fibril);
    126126}
    … …  
    256256 * @param func Implementing function of the new fibril.
    257257 * @param arg Argument to pass to func.
     258 * @param stksz Stack size in bytes.
    258259 *
    259260 * @return 0 on failure or TLS of the new fibril.
    260261 *
    261262 */
    262 fid_t fibril_create(int (*func)(void *), void *arg)
     263fid_t fibril_create_generic(int (*func)(void *), void *arg, size_t stksz)
    263264{
    264265        fibril_t *fibril;
    … …  
    268269                return 0;
    269270       
    270         size_t stack_size = stack_size_get();
     271        size_t stack_size = (stksz == FIBRIL_DFLT_STK_SIZE) ?
     272            stack_size_get() : stksz;
    271273        fibril->stack = as_area_create((void *) -1, stack_size,
    272274            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE | AS_AREA_GUARD |

  • uspace/lib/c/generic/net/socket_client.c

    r71fe7e9d r5c1b3cd  
    192192/** Default thread for new connections.
    193193 *
    194  * @param[in] iid       The initial message identifier.
    195  * @param[in] icall     The initial message call structure.
    196  * @param[in] arg       Local argument.
     194 * @param[in] iid   The initial message identifier.
     195 * @param[in] icall The initial message call structure.
     196 * @param[in] arg   Local argument.
     197 *
    197198 */
    198199static void socket_connection(ipc_callid_t iid, ipc_call_t * icall, void *arg)
    199200{
    200         ipc_callid_t callid;
    201         ipc_call_t call;
    202         socket_t *socket;
    203         int rc;
    204 
    205 loop:
    206         callid = async_get_call(&call);
    207 
    208         switch (IPC_GET_IMETHOD(call)) {
    209         case NET_SOCKET_RECEIVED:
    210         case NET_SOCKET_ACCEPTED:
    211         case NET_SOCKET_DATA_FRAGMENT_SIZE:
    212                 fibril_rwlock_read_lock(&socket_globals.lock);
    213 
    214                 /* Find the socket */
    215                 socket = sockets_find(socket_get_sockets(),
    216                     SOCKET_GET_SOCKET_ID(call));
    217                 if (!socket) {
    218                         rc = ENOTSOCK;
    219                         fibril_rwlock_read_unlock(&socket_globals.lock);
    220                         break;
     201        while (true) {
     202                ipc_call_t call;
     203                ipc_callid_t callid = async_get_call(&call);
     204               
     205                if (!IPC_GET_IMETHOD(call)) {
     206                        async_answer_0(callid, 0);
     207                        return;
    221208                }
     209               
     210                int rc;
    222211               
    223212                switch (IPC_GET_IMETHOD(call)) {
    224213                case NET_SOCKET_RECEIVED:
    225                         fibril_mutex_lock(&socket->receive_lock);
    226                         /* Push the number of received packet fragments */
    227                         rc = dyn_fifo_push(&socket->received,
    228                             SOCKET_GET_DATA_FRAGMENTS(call),
    229                             SOCKET_MAX_RECEIVED_SIZE);
    230                         if (rc == EOK) {
    231                                 /* Signal the received packet */
    232                                 fibril_condvar_signal(&socket->receive_signal);
     214                case NET_SOCKET_ACCEPTED:
     215                case NET_SOCKET_DATA_FRAGMENT_SIZE:
     216                        fibril_rwlock_read_lock(&socket_globals.lock);
     217                       
     218                        /* Find the socket */
     219                        socket_t *socket = sockets_find(socket_get_sockets(),
     220                            SOCKET_GET_SOCKET_ID(call));
     221                        if (!socket) {
     222                                rc = ENOTSOCK;
     223                                fibril_rwlock_read_unlock(&socket_globals.lock);
     224                                break;
    233225                        }
    234                         fibril_mutex_unlock(&socket->receive_lock);
     226                       
     227                        switch (IPC_GET_IMETHOD(call)) {
     228                        case NET_SOCKET_RECEIVED:
     229                                fibril_mutex_lock(&socket->receive_lock);
     230                                /* Push the number of received packet fragments */
     231                                rc = dyn_fifo_push(&socket->received,
     232                                    SOCKET_GET_DATA_FRAGMENTS(call),
     233                                    SOCKET_MAX_RECEIVED_SIZE);
     234                                if (rc == EOK) {
     235                                        /* Signal the received packet */
     236                                        fibril_condvar_signal(&socket->receive_signal);
     237                                }
     238                                fibril_mutex_unlock(&socket->receive_lock);
     239                                break;
     240                               
     241                        case NET_SOCKET_ACCEPTED:
     242                                /* Push the new socket identifier */
     243                                fibril_mutex_lock(&socket->accept_lock);
     244                                rc = dyn_fifo_push(&socket->accepted, 1,
     245                                    SOCKET_MAX_ACCEPTED_SIZE);
     246                                if (rc == EOK) {
     247                                        /* Signal the accepted socket */
     248                                        fibril_condvar_signal(&socket->accept_signal);
     249                                }
     250                                fibril_mutex_unlock(&socket->accept_lock);
     251                                break;
     252                       
     253                        default:
     254                                rc = ENOTSUP;
     255                        }
     256                       
     257                        if ((SOCKET_GET_DATA_FRAGMENT_SIZE(call) > 0) &&
     258                            (SOCKET_GET_DATA_FRAGMENT_SIZE(call) !=
     259                            socket->data_fragment_size)) {
     260                                fibril_rwlock_write_lock(&socket->sending_lock);
     261                               
     262                                /* Set the data fragment size */
     263                                socket->data_fragment_size =
     264                                    SOCKET_GET_DATA_FRAGMENT_SIZE(call);
     265                               
     266                                fibril_rwlock_write_unlock(&socket->sending_lock);
     267                        }
     268                       
     269                        fibril_rwlock_read_unlock(&socket_globals.lock);
    235270                        break;
    236 
    237                 case NET_SOCKET_ACCEPTED:
    238                         /* Push the new socket identifier */
    239                         fibril_mutex_lock(&socket->accept_lock);
    240                         rc = dyn_fifo_push(&socket->accepted, 1,
    241                             SOCKET_MAX_ACCEPTED_SIZE);
    242                         if (rc == EOK) {
    243                                 /* Signal the accepted socket */
    244                                 fibril_condvar_signal(&socket->accept_signal);
    245                         }
    246                         fibril_mutex_unlock(&socket->accept_lock);
    247                         break;
    248 
     271                       
    249272                default:
    250273                        rc = ENOTSUP;
    251274                }
    252 
    253                 if ((SOCKET_GET_DATA_FRAGMENT_SIZE(call) > 0) &&
    254                     (SOCKET_GET_DATA_FRAGMENT_SIZE(call) !=
    255                     socket->data_fragment_size)) {
    256                         fibril_rwlock_write_lock(&socket->sending_lock);
    257 
    258                         /* Set the data fragment size */
    259                         socket->data_fragment_size =
    260                             SOCKET_GET_DATA_FRAGMENT_SIZE(call);
    261 
    262                         fibril_rwlock_write_unlock(&socket->sending_lock);
    263                 }
    264 
    265                 fibril_rwlock_read_unlock(&socket_globals.lock);
    266                 break;
    267 
    268         default:
    269                 rc = ENOTSUP;
    270         }
    271 
    272         async_answer_0(callid, (sysarg_t) rc);
    273         goto loop;
     275               
     276                async_answer_0(callid, (sysarg_t) rc);
     277        }
    274278}
    275279

  • uspace/lib/c/generic/tls.c

    r71fe7e9d r5c1b3cd  
    5151 * @return Pointer to TCB.
    5252 */
    53 tcb_t *__make_tls(void)
     53tcb_t *tls_make(void)
    5454{
    5555        void *data;
    … …  
    5757        size_t tls_size = &_tbss_end - &_tdata_start;
    5858       
    59         tcb = __alloc_tls(&data, tls_size);
     59        tcb = tls_alloc_arch(&data, tls_size);
    6060        if (!tcb)
    6161                return NULL;
    … …  
    7474}
    7575
    76 void __free_tls(tcb_t *tcb)
     76void tls_free(tcb_t *tcb)
    7777{
    7878        size_t tls_size = &_tbss_end - &_tdata_start;
    79         __free_tls_arch(tcb, tls_size);
     79        tls_free_arch(tcb, tls_size);
    8080}
    8181

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

    r71fe7e9d r5c1b3cd  
    156156extern void async_set_client_connection(async_client_conn_t);
    157157extern void async_set_interrupt_received(async_interrupt_handler_t);
     158extern void async_set_interrupt_handler_stack_size(size_t);
    158159
    159160/*

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

    r71fe7e9d r5c1b3cd  
    8686extern void context_restore(context_t *ctx) __attribute__((noreturn));
    8787
    88 extern fid_t fibril_create(int (*func)(void *), void *arg);
     88#define FIBRIL_DFLT_STK_SIZE    0
     89
     90#define fibril_create(func, arg) \
     91        fibril_create_generic((func), (arg), FIBRIL_DFLT_STK_SIZE)
     92extern fid_t fibril_create_generic(int (*func)(void *), void *arg, size_t);
    8993extern void fibril_destroy(fid_t fid);
    9094extern fibril_t *fibril_setup(void);

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

    r71fe7e9d r5c1b3cd  
    3838#define min(a, b)  ((a) < (b) ? (a) : (b))
    3939#define max(a, b)  ((a) > (b) ? (a) : (b))
    40 #define abs(a)     ((a) >= 0 ? (a) : (-a))
     40#define abs(a)     ((a) >= 0 ? (a) : -(a))
    4141
    4242#define ARRAY_SIZE(array)   (sizeof(array) / sizeof(array[0]))

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

    r71fe7e9d r5c1b3cd  
    4848extern char _tbss_end;
    4949
    50 extern tcb_t *__make_tls(void);
    51 extern tcb_t *__alloc_tls(void **, size_t);
    52 extern void __free_tls(tcb_t *);
    53 extern void __free_tls_arch(tcb_t *, size_t);
     50extern tcb_t *tls_make(void);
     51extern tcb_t *tls_alloc_arch(void **, size_t);
     52extern void tls_free(tcb_t *);
     53extern void tls_free_arch(tcb_t *, size_t);
    5454
    5555#ifdef CONFIG_TLS_VARIANT_1
Note: See TracChangeset for help on using the changeset viewer.