Changeset e6a78b9 in mainline for uspace/lib/c/generic


Ignore:
Timestamp:
2012-06-29T15:31:44Z (14 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
9432f08
Parents:
34ab31c0 (diff), 0bbd13e (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/lib/c/generic
Files:
18 edited

Legend:

Unmodified
Added
Removed

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

    r34ab31c0 re6a78b9  
    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

    r34ab31c0 re6a78b9  
    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

    r34ab31c0 re6a78b9  
    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

    r34ab31c0 re6a78b9  
    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

    r34ab31c0 re6a78b9  
    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/inet.c

    r34ab31c0 re6a78b9  
    4444{
    4545        async_exch_t *exch = async_exchange_begin(inet_sess);
    46 
     46       
    4747        ipc_call_t answer;
    4848        aid_t req = async_send_0(exch, INET_CALLBACK_CREATE, &answer);
    4949        int rc = async_connect_to_me(exch, 0, 0, 0, inet_cb_conn, NULL);
    5050        async_exchange_end(exch);
    51 
     51       
    5252        if (rc != EOK)
    5353                return rc;
    54 
     54       
    5555        sysarg_t retval;
    5656        async_wait_for(req, &retval);
    57         if (retval != EOK)
    58                 return retval;
    59 
    60         return EOK;
     57       
     58        return retval;
    6159}
    6260
    6361static int inet_set_proto(uint8_t protocol)
    6462{
    65         int rc;
    66 
    6763        async_exch_t *exch = async_exchange_begin(inet_sess);
    68         rc = async_req_1_0(exch, INET_SET_PROTO, protocol);
     64        int rc = async_req_1_0(exch, INET_SET_PROTO, protocol);
    6965        async_exchange_end(exch);
    70 
     66       
    7167        return rc;
    7268}
    … …  
    8076        assert(inet_ev_ops == NULL);
    8177        assert(inet_protocol == 0);
    82 
     78       
    8379        rc = loc_service_get_id(SERVICE_NAME_INET, &inet_svc,
    8480            IPC_FLAG_BLOCKING);
    8581        if (rc != EOK)
    8682                return ENOENT;
    87 
     83       
    8884        inet_sess = loc_service_connect(EXCHANGE_SERIALIZE, inet_svc,
    8985            IPC_FLAG_BLOCKING);
    9086        if (inet_sess == NULL)
    9187                return ENOENT;
    92 
     88       
    9389        if (inet_set_proto(protocol) != EOK) {
    9490                async_hangup(inet_sess);
    … …  
    9692                return EIO;
    9793        }
    98 
     94       
    9995        if (inet_callback_create() != EOK) {
    10096                async_hangup(inet_sess);
    … …  
    10298                return EIO;
    10399        }
    104 
     100       
    105101        inet_protocol = protocol;
    106102        inet_ev_ops = ev_ops;

  • uspace/lib/c/generic/inetcfg.c

    r34ab31c0 re6a78b9  
    119119
    120120        assert(inetcfg_sess == NULL);
    121 
     121       
    122122        rc = loc_service_get_id(SERVICE_NAME_INETCFG, &inet_svc,
    123123            IPC_FLAG_BLOCKING);
    124124        if (rc != EOK)
    125125                return ENOENT;
    126 
     126       
    127127        inetcfg_sess = loc_service_connect(EXCHANGE_SERIALIZE, inet_svc,
    128128            IPC_FLAG_BLOCKING);
    129129        if (inetcfg_sess == NULL)
    130130                return ENOENT;
    131 
     131       
    132132        return EOK;
    133133}

  • uspace/lib/c/generic/inetping.c

    r34ab31c0 re6a78b9  
    4949
    5050        assert(inetping_sess == NULL);
    51 
     51       
    5252        inetping_ev_ops = ev_ops;
    53 
     53       
    5454        rc = loc_service_get_id(SERVICE_NAME_INETPING, &inetping_svc,
    5555            IPC_FLAG_BLOCKING);
    5656        if (rc != EOK)
    5757                return ENOENT;
    58 
     58       
    5959        inetping_sess = loc_service_connect(EXCHANGE_SERIALIZE, inetping_svc,
    6060            IPC_FLAG_BLOCKING);
    6161        if (inetping_sess == NULL)
    6262                return ENOENT;
    63 
     63       
    6464        async_exch_t *exch = async_exchange_begin(inetping_sess);
    6565
    6666        rc = async_connect_to_me(exch, 0, 0, 0, inetping_cb_conn, NULL);
    6767        async_exchange_end(exch);
    68 
     68       
    6969        if (rc != EOK) {
    7070                async_hangup(inetping_sess);
    … …  
    7272                return rc;
    7373        }
    74 
     74       
    7575        return EOK;
    7676}

  • uspace/lib/c/generic/iplink.c

    r34ab31c0 re6a78b9  
    4949    iplink_t **riplink)
    5050{
    51         iplink_t *iplink = NULL;
    52         int rc;
    53 
    54         iplink = calloc(1, sizeof(iplink_t));
     51        iplink_t *iplink = calloc(1, sizeof(iplink_t));
    5552        if (iplink == NULL)
    5653                return ENOMEM;
    57 
     54       
    5855        iplink->sess = sess;
    5956        iplink->ev_ops = ev_ops;
    60 
     57       
    6158        async_exch_t *exch = async_exchange_begin(sess);
    62 
    63         rc = async_connect_to_me(exch, 0, 0, 0, iplink_cb_conn, iplink);
     59       
     60        int rc = async_connect_to_me(exch, 0, 0, 0, iplink_cb_conn, iplink);
    6461        async_exchange_end(exch);
    65 
     62       
    6663        if (rc != EOK)
    6764                goto error;
    68 
     65       
    6966        *riplink = iplink;
    7067        return EOK;
    71 
     68       
    7269error:
    7370        if (iplink != NULL)
    7471                free(iplink);
    75 
     72       
    7673        return rc;
    7774}

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

    r34ab31c0 re6a78b9  
    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

    r34ab31c0 re6a78b9  
    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

    r34ab31c0 re6a78b9  
    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/net/socket_client.c

    r34ab31c0 re6a78b9  
    283283static async_sess_t *socket_get_tcp_sess(void)
    284284{
    285         if (socket_globals.tcp_sess == NULL) {
     285        if (socket_globals.tcp_sess == NULL)
    286286                socket_globals.tcp_sess = service_bind(SERVICE_TCP,
    287287                    0, 0, SERVICE_TCP, socket_connection);
    288         }
    289 
     288       
    290289        return socket_globals.tcp_sess;
    291290}
    … …  
    300299static async_sess_t *socket_get_udp_sess(void)
    301300{
    302         if (socket_globals.udp_sess == NULL) {
     301        if (socket_globals.udp_sess == NULL)
    303302                socket_globals.udp_sess = service_bind(SERVICE_UDP,
    304303                    0, 0, SERVICE_UDP, socket_connection);
    305         }
    306 
     304       
    307305        return socket_globals.udp_sess;
    308306}

  • uspace/lib/c/generic/stacktrace.c

    r34ab31c0 re6a78b9  
    3838#include <sys/types.h>
    3939#include <errno.h>
     40#include <unistd.h>
    4041
    4142static int stacktrace_read_uintptr(void *arg, uintptr_t addr, uintptr_t *data);

  • uspace/lib/c/generic/stats.c

    r34ab31c0 re6a78b9  
    4040#include <inttypes.h>
    4141#include <malloc.h>
     42#include <unistd.h>
    4243
    4344#define SYSINFO_STATS_MAX_PATH  64

  • uspace/lib/c/generic/sysinfo.c

    r34ab31c0 re6a78b9  
    3939#include <malloc.h>
    4040#include <bool.h>
     41#include <unistd.h>
    4142
    4243/** Get sysinfo keys size

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

    r34ab31c0 re6a78b9  
    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/generic/time.c

    r34ab31c0 re6a78b9  
    4343#include <ddi.h>
    4444#include <libc.h>
     45#include <unistd.h>
    4546
    4647/** Pointer to kernel shared variables with time */
Note: See TracChangeset for help on using the changeset viewer.