Changeset 3a0a4d8 in mainline for uspace/lib/c/generic


Ignore:
Timestamp:
2013-09-12T07:54:05Z (13 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
95027b5
Parents:
47f5a77 (diff), 64f3d3b (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:
2 added
14 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/adt/hash_table.c

    r47f5a77 r3a0a4d8  
    227227       
    228228        /* Check for duplicates. */
    229         list_foreach(h->bucket[idx], cur) {
     229        list_foreach(h->bucket[idx], link, ht_link_t, cur_link) {
    230230                /*
    231231                 * We could filter out items using their hashes first, but
    232232                 * calling equal() might very well be just as fast.
    233233                 */
    234                 ht_link_t *cur_link = member_to_inst(cur, ht_link_t, link);
    235234                if (h->op->equal(cur_link, item))
    236235                        return false;
    … …  
    258257        size_t idx = h->op->key_hash(key) % h->bucket_cnt;
    259258
    260         list_foreach(h->bucket[idx], cur) {
    261                 ht_link_t *cur_link = member_to_inst(cur, ht_link_t, link);
     259        list_foreach(h->bucket[idx], link, ht_link_t, cur_link) {
    262260                /*
    263261                 * Is this is the item we are looking for? We could have first

  • uspace/lib/c/generic/adt/list.c

    r47f5a77 r3a0a4d8  
    102102        unsigned int count = 0;
    103103       
    104         list_foreach(*list, link) {
     104        link_t *link = list_first(list);
     105        while (link != NULL) {
    105106                count++;
     107                link = list_next(link, list);
    106108        }
    107109       

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

    r47f5a77 r3a0a4d8  
    22812281bool async_data_read_receive(ipc_callid_t *callid, size_t *size)
    22822282{
     2283        ipc_call_t data;
     2284        return async_data_read_receive_call(callid, &data, size);
     2285}
     2286
     2287/** Wrapper for receiving the IPC_M_DATA_READ calls using the async framework.
     2288 *
     2289 * This wrapper only makes it more comfortable to receive IPC_M_DATA_READ
     2290 * calls so that the user doesn't have to remember the meaning of each IPC
     2291 * argument.
     2292 *
     2293 * So far, this wrapper is to be used from within a connection fibril.
     2294 *
     2295 * @param callid Storage for the hash of the IPC_M_DATA_READ.
     2296 * @param size   Storage for the maximum size. Can be NULL.
     2297 *
     2298 * @return True on success, false on failure.
     2299 *
     2300 */
     2301bool async_data_read_receive_call(ipc_callid_t *callid, ipc_call_t *data,
     2302    size_t *size)
     2303{
    22832304        assert(callid);
    2284        
    2285         ipc_call_t data;
    2286         *callid = async_get_call(&data);
    2287        
    2288         if (IPC_GET_IMETHOD(data) != IPC_M_DATA_READ)
     2305        assert(data);
     2306       
     2307        *callid = async_get_call(data);
     2308       
     2309        if (IPC_GET_IMETHOD(*data) != IPC_M_DATA_READ)
    22892310                return false;
    22902311       
    22912312        if (size)
    2292                 *size = (size_t) IPC_GET_ARG2(data);
     2313                *size = (size_t) IPC_GET_ARG2(*data);
    22932314       
    22942315        return true;
    … …  
    23852406bool async_data_write_receive(ipc_callid_t *callid, size_t *size)
    23862407{
     2408        ipc_call_t data;
     2409        return async_data_write_receive_call(callid, &data, size);
     2410}
     2411
     2412/** Wrapper for receiving the IPC_M_DATA_WRITE calls using the async framework.
     2413 *
     2414 * This wrapper only makes it more comfortable to receive IPC_M_DATA_WRITE
     2415 * calls so that the user doesn't have to remember the meaning of each IPC
     2416 * argument.
     2417 *
     2418 * So far, this wrapper is to be used from within a connection fibril.
     2419 *
     2420 * @param callid Storage for the hash of the IPC_M_DATA_WRITE.
     2421 * @param data   Storage for the ipc call data.
     2422 * @param size   Storage for the suggested size. May be NULL.
     2423 *
     2424 * @return True on success, false on failure.
     2425 *
     2426 */
     2427bool async_data_write_receive_call(ipc_callid_t *callid, ipc_call_t *data,
     2428    size_t *size)
     2429{
    23872430        assert(callid);
    2388        
    2389         ipc_call_t data;
    2390         *callid = async_get_call(&data);
    2391        
    2392         if (IPC_GET_IMETHOD(data) != IPC_M_DATA_WRITE)
     2431        assert(data);
     2432       
     2433        *callid = async_get_call(data);
     2434       
     2435        if (IPC_GET_IMETHOD(*data) != IPC_M_DATA_WRITE)
    23932436                return false;
    23942437       
    23952438        if (size)
    2396                 *size = (size_t) IPC_GET_ARG2(data);
     2439                *size = (size_t) IPC_GET_ARG2(*data);
    23972440       
    23982441        return true;

  • uspace/lib/c/generic/cfg.c

    r47f5a77 r3a0a4d8  
    8383                return true;
    8484       
    85         list_foreach(data->sections, link) {
    86                 const cfg_section_t *section = cfg_section_instance(link);
    87                
     85        cfg_file_foreach(data, section) {
    8886                if (!list_empty(&section->entries))
    8987                        return false;
    … …  
    413411const cfg_section_t *cfg_find_section(const cfg_file_t *data, const char *title)
    414412{
    415         list_foreach(data->sections, link) {
    416                 const cfg_section_t *section = cfg_section_instance(link);
    417                
     413        cfg_file_foreach(data, section) {
    418414                if (str_cmp(section->title, title) == 0)
    419415                        return section;
    … …  
    434430const char *cfg_find_value(const cfg_section_t *section, const char *key)
    435431{
    436         list_foreach(section->entries, link) {
    437                 const cfg_entry_t *entry = cfg_entry_instance(link);
    438                
     432        cfg_section_foreach(section, entry) {
    439433                if (str_cmp(entry->key, key) == 0)
    440434                        return entry->value;

  • uspace/lib/c/generic/ddi.c

    r47f5a77 r3a0a4d8  
    7676 *
    7777 */
    78 int physmem_map(void *phys, size_t pages, unsigned int flags, void **virt)
     78int physmem_map(uintptr_t phys, size_t pages, unsigned int flags, void **virt)
    7979{
    8080        return __SYSCALL5(SYS_PHYSMEM_MAP, (sysarg_t) phys,
    … …  
    8383
    8484int dmamem_map(void *virt, size_t size, unsigned int map_flags,
    85     unsigned int flags, void **phys)
     85    unsigned int flags, uintptr_t *phys)
    8686{
    8787        return (int) __SYSCALL6(SYS_DMAMEM_MAP, (sysarg_t) size,
    … …  
    9090}
    9191
    92 int dmamem_map_anonymous(size_t size, unsigned int map_flags,
    93     unsigned int flags, void **phys, void **virt)
    94 {
     92int dmamem_map_anonymous(size_t size, uintptr_t constraint,
     93    unsigned int map_flags, unsigned int flags, uintptr_t *phys, void **virt)
     94{
     95        *phys = constraint;
     96       
    9597        return (int) __SYSCALL6(SYS_DMAMEM_MAP, (sysarg_t) size,
    9698            (sysarg_t) map_flags, (sysarg_t) flags | DMAMEM_FLAGS_ANONYMOUS,
    … …  
    158160        if (!virt)
    159161                return EINVAL;
    160 
    161         void *phys_frame =
    162             (void *) ALIGN_DOWN((uintptr_t) pio_addr, PAGE_SIZE);
    163         size_t offset = pio_addr - phys_frame;
     162       
     163        uintptr_t phys_frame =
     164            ALIGN_DOWN((uintptr_t) pio_addr, PAGE_SIZE);
     165        size_t offset = (uintptr_t) pio_addr - phys_frame;
    164166        size_t pages = SIZE2PAGES(offset + size);
    165167       

  • uspace/lib/c/generic/device/hw_res.c

    r47f5a77 r3a0a4d8  
    4444       
    4545        async_exch_t *exch = async_exchange_begin(sess);
     46       
    4647        int rc = async_req_1_1(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
    4748            HW_RES_GET_RESOURCE_LIST, &count);
    … …  
    7778{
    7879        async_exch_t *exch = async_exchange_begin(sess);
     80       
    7981        int rc = async_req_1_0(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
    8082            HW_RES_ENABLE_INTERRUPT);
    … …  
    8486}
    8587
     88/** Setup DMA channel to specified place and mode.
     89 *
     90 * @param channel DMA channel.
     91 * @param pa      Physical address of the buffer.
     92 * @param size    DMA buffer size.
     93 * @param mode    Mode of the DMA channel:
     94 *                 - Read or Write
     95 *                 - Allow automatic reset
     96 *                 - Use address decrement instead of increment
     97 *                 - Use SINGLE/BLOCK/ON DEMAND transfer mode
     98 *
     99 * @return Error code.
     100 *
     101 */
     102int hw_res_dma_channel_setup(async_sess_t *sess,
     103    unsigned channel, uint32_t pa, uint32_t size, uint8_t mode)
     104{
     105        async_exch_t *exch = async_exchange_begin(sess);
     106       
     107        const uint32_t packed = (channel & 0xffff) | (mode << 16);
     108        const int ret = async_req_4_0(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
     109            HW_RES_DMA_CHANNEL_SETUP, packed, pa, size);
     110       
     111        async_exchange_end(exch);
     112       
     113        return ret;
     114}
     115
     116/** Query remaining bytes in the buffer.
     117 *
     118 * @param channel DMA channel.
     119 *
     120 * @return Number of bytes remaining in the buffer if positive.
     121 * @return Error code if negative.
     122 *
     123 */
     124int hw_res_dma_channel_remain(async_sess_t *sess, unsigned channel)
     125{
     126        async_exch_t *exch = async_exchange_begin(sess);
     127       
     128        sysarg_t remain;
     129        const int ret = async_req_2_1(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
     130            HW_RES_DMA_CHANNEL_REMAIN, channel, &remain);
     131       
     132        async_exchange_end(exch);
     133       
     134        if (ret == EOK)
     135                return remain;
     136       
     137        return ret;
     138}
     139
    86140/** @}
    87141 */

  • uspace/lib/c/generic/device/hw_res_parsed.c

    r47f5a77 r3a0a4d8  
    3838#include <errno.h>
    3939
    40 static void hw_res_parse_add_irq(hw_res_list_parsed_t *out, hw_resource_t *res,
    41     int flags)
     40static void hw_res_parse_add_dma_channel(hw_res_list_parsed_t *out,
     41    const hw_resource_t *res, int flags)
     42{
     43        assert(res);
     44        assert((res->type == DMA_CHANNEL_8) || (res->type == DMA_CHANNEL_16));
     45       
     46        const unsigned channel = (res->type == DMA_CHANNEL_8) ?
     47            res->res.dma_channel.dma8 : res->res.dma_channel.dma16;
     48        const size_t count = out->dma_channels.count;
     49        const int keep_duplicit = flags & HW_RES_KEEP_DUPLICIT;
     50       
     51        if (!keep_duplicit) {
     52                for (size_t i = 0; i < count; ++i) {
     53                        if (out->dma_channels.channels[i] == channel)
     54                                return;
     55                }
     56        }
     57       
     58        out->dma_channels.channels[count] = channel;
     59        ++out->dma_channels.count;
     60}
     61
     62static void hw_res_parse_add_irq(hw_res_list_parsed_t *out,
     63    const hw_resource_t *res, int flags)
    4264{
    4365        assert(res && (res->type == INTERRUPT));
    … …  
    5981
    6082static void hw_res_parse_add_io_range(hw_res_list_parsed_t *out,
    61     hw_resource_t *res, int flags)
     83    const hw_resource_t *res, int flags)
    6284{
    6385        assert(res && (res->type == IO_RANGE));
    … …  
    90112
    91113static void hw_res_parse_add_mem_range(hw_res_list_parsed_t *out,
    92     hw_resource_t *res, int flags)
     114    const hw_resource_t *res, int flags)
    93115{
    94116        assert(res && (res->type == MEM_RANGE));
    … …  
    132154 *
    133155 */
    134 int hw_res_list_parse(hw_resource_list_t *hw_resources,
     156int hw_res_list_parse(const hw_resource_list_t *hw_resources,
    135157    hw_res_list_parsed_t *out, int flags)
    136158{
    … …  
    141163        hw_res_list_parsed_clean(out);
    142164       
    143         out->irqs.irqs = malloc(res_count * sizeof(int));
    144         out->io_ranges.ranges = malloc(res_count * sizeof(io_range_t));
    145         out->mem_ranges.ranges = malloc(res_count * sizeof(mem_range_t));
     165        out->irqs.irqs = calloc(res_count, sizeof(int));
     166        out->dma_channels.channels = calloc(res_count, sizeof(int));
     167        out->io_ranges.ranges = calloc(res_count, sizeof(io_range_t));
     168        out->mem_ranges.ranges = calloc(res_count, sizeof(mem_range_t));
     169        if (!out->irqs.irqs || !out->dma_channels.channels ||
     170            !out->io_ranges.ranges || !out->mem_ranges.ranges) {
     171                hw_res_list_parsed_clean(out);
     172                return ENOMEM;
     173        }
    146174       
    147175        for (size_t i = 0; i < res_count; ++i) {
    148                 hw_resource_t *resource = &(hw_resources->resources[i]);
     176                const hw_resource_t *resource = &(hw_resources->resources[i]);
    149177               
    150178                switch (resource->type) {
    … …  
    158186                        hw_res_parse_add_mem_range(out, resource, flags);
    159187                        break;
     188                case DMA_CHANNEL_8:
     189                case DMA_CHANNEL_16:
     190                        hw_res_parse_add_dma_channel(out, resource, flags);
     191                        break;
    160192                default:
     193                        hw_res_list_parsed_clean(out);
    161194                        return EINVAL;
    162195                }

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

    r47f5a77 r3a0a4d8  
    11/*
    22 * Copyright (c) 2007 Josef Cejka
    3  * Copyright (c) 2011 Jiri Svoboda
     3 * Copyright (c) 2013 Jiri Svoboda
    44 * Copyright (c) 2010 Lenka Trochtova
    55 * All rights reserved.
    … …  
    230230        }
    231231       
    232         match_id_t *match_id = NULL;
    233        
    234         list_foreach(match_ids->ids, link) {
    235                 match_id = list_get_instance(link, match_id_t, link);
    236                
     232        list_foreach(match_ids->ids, link, match_id_t, match_id) {
    237233                ipc_call_t answer2;
    238234                aid_t req2 = async_send_1(exch, DEVMAN_ADD_MATCH_ID,
    … …  
    405401}
    406402
    407 static int devman_get_str_internal(sysarg_t method, sysarg_t arg1, char *buf,
    408     size_t buf_size)
     403static int devman_get_str_internal(sysarg_t method, sysarg_t arg1,
     404    sysarg_t arg2, sysarg_t *r1, char *buf, size_t buf_size)
    409405{
    410406        async_exch_t *exch;
    … …  
    416412       
    417413        ipc_call_t answer;
    418         aid_t req = async_send_1(exch, method, arg1, &answer);
     414        aid_t req = async_send_2(exch, method, arg1, arg2, &answer);
    419415        aid_t dreq = async_data_read(exch, buf, buf_size - 1, &dreply);
    420416        async_wait_for(dreq, &dretval);
    … …  
    434430        }
    435431       
     432        if (r1 != NULL)
     433                *r1 = IPC_GET_ARG1(answer);
    436434        act_size = IPC_GET_ARG2(dreply);
    437435        assert(act_size <= buf_size - 1);
    … …  
    443441int devman_fun_get_path(devman_handle_t handle, char *buf, size_t buf_size)
    444442{
    445         return devman_get_str_internal(DEVMAN_FUN_GET_PATH, handle, buf,
    446             buf_size);
     443        return devman_get_str_internal(DEVMAN_FUN_GET_PATH, handle, 0, NULL,
     444            buf, buf_size);
     445}
     446
     447int devman_fun_get_match_id(devman_handle_t handle, size_t index, char *buf,
     448    size_t buf_size, unsigned int *rscore)
     449{
     450        int rc;
     451        sysarg_t score = 0;
     452
     453        rc = devman_get_str_internal(DEVMAN_FUN_GET_MATCH_ID, handle, index,
     454            &score, buf, buf_size);
     455        if (rc != EOK)
     456                return rc;
     457
     458        *rscore = score;
     459        return rc;
    447460}
    448461
    449462int devman_fun_get_name(devman_handle_t handle, char *buf, size_t buf_size)
    450463{
    451         return devman_get_str_internal(DEVMAN_FUN_GET_NAME, handle, buf,
    452             buf_size);
     464        return devman_get_str_internal(DEVMAN_FUN_GET_NAME, handle, 0, NULL,
     465            buf, buf_size);
    453466}
    454467
    455468int devman_fun_get_driver_name(devman_handle_t handle, char *buf, size_t buf_size)
    456469{
    457         return devman_get_str_internal(DEVMAN_FUN_GET_DRIVER_NAME, handle, buf,
    458             buf_size);
     470        return devman_get_str_internal(DEVMAN_FUN_GET_DRIVER_NAME, handle, 0,
     471            NULL, buf, buf_size);
    459472}
    460473
    … …  
    583596}
    584597
     598int devman_dev_get_parent(devman_handle_t devh, devman_handle_t *funh)
     599{
     600        async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
     601        if (exch == NULL)
     602                return ENOMEM;
     603       
     604        sysarg_t retval = async_req_1_1(exch, DEVMAN_DEV_GET_PARENT,
     605            devh, funh);
     606       
     607        devman_exchange_end(exch);
     608        return (int) retval;
     609}
     610
    585611int devman_fun_sid_to_handle(service_id_t sid, devman_handle_t *handle)
    586612{
    … …  
    596622}
    597623
     624int devman_get_drivers(devman_handle_t **drvs,
     625    size_t *count)
     626{
     627        return devman_get_handles_internal(DEVMAN_GET_DRIVERS, 0, drvs, count);
     628}
     629
     630int devman_driver_get_devices(devman_handle_t drvh, devman_handle_t **devs,
     631    size_t *count)
     632{
     633        return devman_get_handles_internal(DEVMAN_DRIVER_GET_DEVICES,
     634            drvh, devs, count);
     635}
     636
     637int devman_driver_get_handle(const char *drvname, devman_handle_t *handle)
     638{
     639        async_exch_t *exch;
     640
     641        exch = devman_exchange_begin(DEVMAN_CLIENT);
     642        if (exch == NULL)
     643                return ENOMEM;
     644       
     645        ipc_call_t answer;
     646        aid_t req = async_send_0(exch, DEVMAN_DRIVER_GET_HANDLE, &answer);
     647        sysarg_t retval = async_data_write_start(exch, drvname,
     648            str_size(drvname));
     649       
     650        devman_exchange_end(exch);
     651       
     652        if (retval != EOK) {
     653                async_forget(req);
     654                return retval;
     655        }
     656       
     657        async_wait_for(req, &retval);
     658       
     659        if (retval != EOK) {
     660                if (handle != NULL)
     661                        *handle = (devman_handle_t) -1;
     662               
     663                return retval;
     664        }
     665       
     666        if (handle != NULL)
     667                *handle = (devman_handle_t) IPC_GET_ARG1(answer);
     668       
     669        return retval;
     670}
     671
     672int devman_driver_get_match_id(devman_handle_t handle, size_t index, char *buf,
     673    size_t buf_size, unsigned int *rscore)
     674{
     675        int rc;
     676        sysarg_t score = 0;
     677
     678        rc = devman_get_str_internal(DEVMAN_DRIVER_GET_MATCH_ID, handle, index,
     679            &score, buf, buf_size);
     680        if (rc != EOK)
     681                return rc;
     682
     683        *rscore = score;
     684        return rc;
     685}
     686
     687int devman_driver_get_name(devman_handle_t handle, char *buf, size_t buf_size)
     688{
     689        return devman_get_str_internal(DEVMAN_DRIVER_GET_NAME, handle, 0, NULL,
     690            buf, buf_size);
     691}
     692
     693int devman_driver_get_state(devman_handle_t drvh, driver_state_t *rstate)
     694{
     695        sysarg_t state;
     696        async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
     697        if (exch == NULL)
     698                return ENOMEM;
     699       
     700        int rc = async_req_1_1(exch, DEVMAN_DRIVER_GET_STATE, drvh,
     701            &state);
     702       
     703        devman_exchange_end(exch);
     704        if (rc != EOK)
     705                return rc;
     706
     707        *rstate = state;
     708        return rc;
     709}
     710
     711int devman_driver_load(devman_handle_t drvh)
     712{
     713        async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
     714        if (exch == NULL)
     715                return ENOMEM;
     716       
     717        int rc = async_req_1_0(exch, DEVMAN_DRIVER_LOAD, drvh);
     718       
     719        devman_exchange_end(exch);
     720        return rc;
     721}
     722
    598723/** @}
    599724 */

  • uspace/lib/c/generic/dnsr.c

    r47f5a77 r3a0a4d8  
    6767}
    6868
    69 int dnsr_name2host(const char *name, dnsr_hostinfo_t **rinfo)
     69int dnsr_name2host(const char *name, dnsr_hostinfo_t **rinfo, uint16_t af)
    7070{
    7171        dnsr_hostinfo_t *info = calloc(1, sizeof(dnsr_hostinfo_t));
    … …  
    7676       
    7777        ipc_call_t answer;
    78         aid_t req = async_send_0(exch, DNSR_NAME2HOST, &answer);
     78        aid_t req = async_send_1(exch, DNSR_NAME2HOST, (sysarg_t) af,
     79            &answer);
    7980       
    8081        int rc = async_data_write_start(exch, name, str_size(name));

  • uspace/lib/c/generic/futex.c

    r47f5a77 r3a0a4d8  
    3535#include <futex.h>
    3636#include <atomic.h>
     37#include <libarch/barrier.h>
    3738#include <libc.h>
    3839#include <sys/types.h>
    … …  
    5960int futex_trydown(futex_t *futex)
    6061{
    61         return cas(futex, 1, 0);
     62        int rc;
     63
     64        rc = cas(futex, 1, 0);
     65        CS_ENTER_BARRIER();
     66
     67        return rc;
    6268}
    6369
    … …  
    7379int futex_down(futex_t *futex)
    7480{
    75         if ((atomic_signed_t) atomic_predec(futex) < 0)
     81        atomic_signed_t nv;
     82
     83        nv = (atomic_signed_t) atomic_predec(futex);
     84        CS_ENTER_BARRIER();
     85        if (nv < 0)
    7686                return __SYSCALL1(SYS_FUTEX_SLEEP, (sysarg_t) &futex->count);
    7787       
    … …  
    8999int futex_up(futex_t *futex)
    90100{
     101        CS_LEAVE_BARRIER();
     102
    91103        if ((atomic_signed_t) atomic_postinc(futex) < 0)
    92104                return __SYSCALL1(SYS_FUTEX_WAKEUP, (sysarg_t) &futex->count);

  • uspace/lib/c/generic/inet/addr.c

    r47f5a77 r3a0a4d8  
    5252};
    5353
     54static const addr48_t inet_addr48_solicited_node = {
     55        0x33, 0x33, 0xff, 0, 0, 0
     56};
     57
    5458static const inet_addr_t inet_addr_any_addr = {
    5559        .family = AF_INET,
    … …  
    7276}
    7377
     78int addr48_compare(const addr48_t a, const addr48_t b)
     79{
     80        return memcmp(a, b, 6);
     81}
     82
    7483int addr128_compare(const addr128_t a, const addr128_t b)
    7584{
    7685        return memcmp(a, b, 16);
     86}
     87
     88/** Compute solicited node MAC multicast address from target IPv6 address
     89 *
     90 * @param ip  Target IPv6 address
     91 * @param mac Solicited MAC address to be assigned
     92 *
     93 */
     94void addr48_solicited_node(const addr128_t ip, addr48_t mac)
     95{
     96        memcpy(mac, inet_addr48_solicited_node, 3);
     97        memcpy(mac + 3, ip + 13, 3);
    7798}
    7899

  • uspace/lib/c/generic/pio_trace.c

    r47f5a77 r3a0a4d8  
    9595        pio_regions_t *regions = get_regions();
    9696        fibril_rwlock_read_lock(&regions->guard);
    97         list_foreach(regions->list, it) {
    98                 assert(it);
    99                 region_t *reg = region_instance(it);
    100                 assert(reg);
     97        list_foreach(regions->list, link, region_t, reg) {
    10198                if ((r >= reg->base) && (r < reg->base + reg->size)) {
    10299                        if (reg->log)
    … …  
    131128        fibril_rwlock_write_lock(&regions->guard);
    132129        list_foreach_safe(regions->list, it, next) {
    133                 assert(it);
    134130                region_t *reg = region_instance(it);
    135                 assert(reg);
    136131                if (r >= reg->base && (r < reg->base + reg->size)) {
    137                                 list_remove(&reg->link);
    138                                 region_destroy(reg);
     132                        list_remove(&reg->link);
     133                        region_destroy(reg);
    139134                }
    140135        }

  • uspace/lib/c/generic/time.c

    r47f5a77 r3a0a4d8  
    556556               
    557557                void *addr;
    558                 rc = physmem_map((void *) faddr, 1,
    559                     AS_AREA_READ | AS_AREA_CACHEABLE, &addr);
     558                rc = physmem_map(faddr, 1, AS_AREA_READ | AS_AREA_CACHEABLE,
     559                    &addr);
    560560                if (rc != EOK) {
    561561                        as_area_destroy(addr);

  • uspace/lib/c/generic/vfs/vfs.c

    r47f5a77 r3a0a4d8  
    4343#include <stdio.h>
    4444#include <sys/stat.h>
     45#include <sys/statfs.h>
    4546#include <sys/types.h>
    4647#include <ipc/services.h>
    … …  
    892893}
    893894
     895int statfs(const char *path, struct statfs *statfs)
     896{
     897        sysarg_t rc;
     898        sysarg_t rc_orig;
     899        aid_t req;
     900        size_t pa_size;
     901       
     902        char *pa = absolutize(path, &pa_size);
     903        if (!pa)
     904                return ENOMEM;
     905        async_exch_t *exch = vfs_exchange_begin();
     906       
     907        req = async_send_0(exch, VFS_IN_STATFS, NULL);
     908        rc = async_data_write_start(exch, pa, pa_size);
     909        if (rc != EOK) {
     910                vfs_exchange_end(exch);
     911                free(pa);
     912                async_wait_for(req, &rc_orig);
     913                if (rc_orig == EOK)
     914                        return (int) rc;
     915                else
     916                        return (int) rc_orig;
     917        }
     918        rc = async_data_read_start(exch, (void *) statfs, sizeof(struct statfs));
     919        if (rc != EOK) {
     920                vfs_exchange_end(exch);
     921                free(pa);
     922                async_wait_for(req, &rc_orig);
     923                if (rc_orig == EOK)
     924                        return (int) rc;
     925                else
     926                        return (int) rc_orig;
     927        }
     928        vfs_exchange_end(exch);
     929        free(pa);
     930        async_wait_for(req, &rc);
     931        return rc;
     932}
     933
    894934/** @}
    895935 */
Note: See TracChangeset for help on using the changeset viewer.