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


Ignore:
Timestamp:
2013-12-25T13:05:25Z (12 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
bc54126c
Parents:
f4a47e52 (diff), 6946f23 (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:
4 added
1 deleted
21 edited

Legend:

Unmodified
Added
Removed

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

    rf4a47e52 r0773396  
    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

    rf4a47e52 r0773396  
    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/cfg.c

    rf4a47e52 r0773396  
    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

    rf4a47e52 r0773396  
    4242#include <ddi.h>
    4343#include <libarch/ddi.h>
     44#include <device/hw_res.h>
     45#include <device/hw_res_parsed.h>
     46#include <device/pio_window.h>
    4447#include <libc.h>
    4548#include <task.h>
    … …  
    7679 *
    7780 */
    78 int physmem_map(void *phys, size_t pages, unsigned int flags, void **virt)
     81int physmem_map(uintptr_t phys, size_t pages, unsigned int flags, void **virt)
    7982{
    8083        return __SYSCALL5(SYS_PHYSMEM_MAP, (sysarg_t) phys,
    … …  
    8386
    8487int dmamem_map(void *virt, size_t size, unsigned int map_flags,
    85     unsigned int flags, void **phys)
     88    unsigned int flags, uintptr_t *phys)
    8689{
    8790        return (int) __SYSCALL6(SYS_DMAMEM_MAP, (sysarg_t) size,
    … …  
    9093}
    9194
    92 int dmamem_map_anonymous(size_t size, unsigned int map_flags,
    93     unsigned int flags, void **phys, void **virt)
    94 {
     95int dmamem_map_anonymous(size_t size, uintptr_t constraint,
     96    unsigned int map_flags, unsigned int flags, uintptr_t *phys, void **virt)
     97{
     98        *phys = constraint;
     99       
    95100        return (int) __SYSCALL6(SYS_DMAMEM_MAP, (sysarg_t) size,
    96101            (sysarg_t) map_flags, (sysarg_t) flags | DMAMEM_FLAGS_ANONYMOUS,
    … …  
    132137       
    133138        return __SYSCALL1(SYS_IOSPACE_ENABLE, (sysarg_t) &arg);
     139}
     140
     141/** Enable PIO for specified address range.
     142 *
     143 * @param range I/O range to be enable.
     144 * @param virt  Virtual address for application's PIO operations.
     145 */
     146int pio_enable_range(addr_range_t *range, void **virt)
     147{
     148        return pio_enable(RNGABSPTR(*range), RNGSZ(*range), virt);
     149}
     150
     151/** Enable PIO for specified HW resource wrt. to the PIO window.
     152 *
     153 * @param win      PIO window. May be NULL if the resources are known to be
     154 *                 absolute.
     155 * @param res      Resources specifying the I/O range wrt. to the PIO window.
     156 * @param virt     Virtual address for application's PIO operations.
     157 *
     158 * @return EOK on success.
     159 * @return Negative error code on failure.
     160 *
     161 */
     162int pio_enable_resource(pio_window_t *win, hw_resource_t *res, void **virt)
     163{
     164        uintptr_t addr;
     165        size_t size;
     166
     167        switch (res->type) {
     168        case IO_RANGE:
     169                addr = res->res.io_range.address;
     170                if (res->res.io_range.relative) {
     171                        if (!win)
     172                                return EINVAL;
     173                        addr += win->io.base;
     174                }
     175                size = res->res.io_range.size;
     176                break;
     177        case MEM_RANGE:
     178                addr = res->res.mem_range.address;
     179                if (res->res.mem_range.relative) {
     180                        if (!win)
     181                                return EINVAL;
     182                        addr += win->mem.base;
     183                }
     184                size = res->res.mem_range.size;
     185                break;
     186        default:
     187                return EINVAL;
     188        }
     189
     190        return pio_enable((void *) addr, size, virt);   
    134191}
    135192
    … …  
    158215        if (!virt)
    159216                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;
     217       
     218        uintptr_t phys_frame =
     219            ALIGN_DOWN((uintptr_t) pio_addr, PAGE_SIZE);
     220        size_t offset = (uintptr_t) pio_addr - phys_frame;
    164221        size_t pages = SIZE2PAGES(offset + size);
    165222       

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

    rf4a47e52 r0773396  
    4444       
    4545        async_exch_t *exch = async_exchange_begin(sess);
    46         if (exch == NULL)
    47                 return ENOMEM;
     46       
    4847        int rc = async_req_1_1(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
    4948            HW_RES_GET_RESOURCE_LIST, &count);
    … …  
    7978{
    8079        async_exch_t *exch = async_exchange_begin(sess);
    81         if (exch == NULL)
    82                 return false;
     80       
    8381        int rc = async_req_1_0(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
    8482            HW_RES_ENABLE_INTERRUPT);
    … …  
    8886}
    8987
    90 /**
    91  * Setup DMA channel to specified place and mode.
    92  * @param channel DMA Channel 1,2,3 for 8 bit transfers, 5,6,7 for 16 bit.
    93  * @param pa Physical address of the buffer. Must be < 16MB for 16 bit and < 1MB
    94  *           for 8 bit transfers.
    95  * @param size DMA buffer size, limited to 64K.
    96  * @param mode Mode of the DMA channel:
    97  *              - Read or Write
    98  *              - Allow automatic reset
    99  *              - Use address decrement instead of increment
    100  *              - Use SINGLE/BLOCK/ON DEMAND transfer mode
     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 *
    10199 * @return Error code.
     100 *
    102101 */
    103102int hw_res_dma_channel_setup(async_sess_t *sess,
    … …  
    105104{
    106105        async_exch_t *exch = async_exchange_begin(sess);
    107         if (exch == NULL)
    108                 return ENOMEM;
     106       
    109107        const uint32_t packed = (channel & 0xffff) | (mode << 16);
    110108        const int ret = async_req_4_0(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
    111109            HW_RES_DMA_CHANNEL_SETUP, packed, pa, size);
     110       
    112111        async_exchange_end(exch);
    113 
     112       
    114113        return ret;
    115114}
    116115
    117 /**
    118  * Query remaining bytes in the buffer.
    119  * @param channel DMA Channel 1,2,3 for 8 bit transfers, 5,6,7 for 16 bit.
    120  * @return Number of bytes remaining in the buffer(>=0) or error code(<0).
     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 *
    121123 */
    122124int hw_res_dma_channel_remain(async_sess_t *sess, unsigned channel)
    123125{
    124126        async_exch_t *exch = async_exchange_begin(sess);
    125         if (exch == NULL)
    126                 return ENOMEM;
     127       
    127128        sysarg_t remain;
    128129        const int ret = async_req_2_1(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
    129130            HW_RES_DMA_CHANNEL_REMAIN, channel, &remain);
     131       
    130132        async_exchange_end(exch);
     133       
    131134        if (ret == EOK)
    132135                return remain;
     136       
    133137        return ret;
    134138}

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

    rf4a47e52 r0773396  
    8080}
    8181
     82static uint64_t absolutize(uint64_t addr, bool relative, uint64_t base)
     83{
     84        if (!relative)
     85                return addr;
     86        else
     87                return addr + base;
     88}
     89
     90static uint64_t relativize(uint64_t addr, bool relative, uint64_t base)
     91{
     92        if (relative)
     93                return addr;
     94        else
     95                return addr - base;
     96}
     97
    8298static void hw_res_parse_add_io_range(hw_res_list_parsed_t *out,
    83     const hw_resource_t *res, int flags)
    84 {
     99    const pio_window_t *win, const hw_resource_t *res, int flags)
     100{
     101        endianness_t endianness;
     102        uint64_t absolute;
     103        uint64_t relative;
     104        size_t size;
     105
    85106        assert(res && (res->type == IO_RANGE));
    86107       
    87         uint64_t address = res->res.io_range.address;
    88         endianness_t endianness = res->res.io_range.endianness;
    89         size_t size = res->res.io_range.size;
     108        absolute = absolutize(res->res.io_range.address,
     109            res->res.io_range.relative, win->io.base);
     110        relative = relativize(res->res.io_range.address,
     111            res->res.io_range.relative, win->io.base);
     112        size = res->res.io_range.size;
     113        endianness = res->res.io_range.endianness;
    90114       
    91115        if ((size == 0) && (!(flags & HW_RES_KEEP_ZERO_AREA)))
    … …  
    97121        if (!keep_duplicit) {
    98122                for (size_t i = 0; i < count; i++) {
    99                         uint64_t s_address = out->io_ranges.ranges[i].address;
    100                         size_t s_size = out->io_ranges.ranges[i].size;
     123                        uint64_t s_address;
     124                        size_t s_size;
     125
     126                        s_address = RNGABS(out->io_ranges.ranges[i]);
     127                        s_size = RNGSZ(out->io_ranges.ranges[i]);
    101128                       
    102                         if ((address == s_address) && (size == s_size))
    103                                 return;
    104                 }
    105         }
    106        
    107         out->io_ranges.ranges[count].address = address;
     129                        if ((absolute == s_address) && (size == s_size))
     130                                return;
     131                }
     132        }
     133       
     134        RNGABS(out->io_ranges.ranges[count]) = absolute;
     135        RNGREL(out->io_ranges.ranges[count]) = relative;
     136        RNGSZ(out->io_ranges.ranges[count]) = size;
    108137        out->io_ranges.ranges[count].endianness = endianness;
    109         out->io_ranges.ranges[count].size = size;
    110138        out->io_ranges.count++;
    111139}
    112140
    113141static void hw_res_parse_add_mem_range(hw_res_list_parsed_t *out,
    114     const hw_resource_t *res, int flags)
    115 {
     142    const pio_window_t *win, const hw_resource_t *res, int flags)
     143{
     144        endianness_t endianness;
     145        uint64_t absolute;
     146        uint64_t relative;
     147        size_t size;
     148       
    116149        assert(res && (res->type == MEM_RANGE));
    117150       
    118         uint64_t address = res->res.mem_range.address;
    119         endianness_t endianness = res->res.mem_range.endianness;
    120         size_t size = res->res.mem_range.size;
     151        absolute = absolutize(res->res.mem_range.address,
     152            res->res.mem_range.relative, win->mem.base);
     153        relative = relativize(res->res.mem_range.address,
     154            res->res.mem_range.relative, win->mem.base);
     155        size = res->res.mem_range.size;
     156        endianness = res->res.mem_range.endianness;
    121157       
    122158        if ((size == 0) && (!(flags & HW_RES_KEEP_ZERO_AREA)))
    … …  
    128164        if (!keep_duplicit) {
    129165                for (size_t i = 0; i < count; ++i) {
    130                         uint64_t s_address = out->mem_ranges.ranges[i].address;
    131                         size_t s_size = out->mem_ranges.ranges[i].size;
     166                        uint64_t s_address;
     167                        size_t s_size;
     168
     169                        s_address = RNGABS(out->mem_ranges.ranges[i]);;
     170                        s_size = RNGSZ(out->mem_ranges.ranges[i]);
    132171                       
    133                         if ((address == s_address) && (size == s_size))
    134                                 return;
    135                 }
    136         }
    137        
    138         out->mem_ranges.ranges[count].address = address;
     172                        if ((absolute == s_address) && (size == s_size))
     173                                return;
     174                }
     175        }
     176       
     177        RNGABS(out->mem_ranges.ranges[count]) = absolute;
     178        RNGREL(out->mem_ranges.ranges[count]) = relative;
     179        RNGSZ(out->mem_ranges.ranges[count]) = size;
    139180        out->mem_ranges.ranges[count].endianness = endianness;
    140         out->mem_ranges.ranges[count].size = size;
    141181        out->mem_ranges.count++;
    142182}
    … …  
    144184/** Parse list of hardware resources
    145185 *
    146  * @param      hw_resources Original structure resource
    147  * @param[out] out          Output parsed resources
    148  * @param      flags        Flags of the parsing.
    149  *                          HW_RES_KEEP_ZERO_AREA for keeping
    150  *                          zero-size areas, HW_RES_KEEP_DUPLICITIES
    151  *                          for keep duplicit areas
     186 * @param      win          PIO window.
     187 * @param      res          Original structure resource.
     188 * @param[out] out          Output parsed resources.
     189 * @param      flags        Flags of the parsing:
     190 *                          HW_RES_KEEP_ZERO_AREA for keeping zero-size areas,
     191 *                          HW_RES_KEEP_DUPLICITIES to keep duplicit areas.
    152192 *
    153193 * @return EOK if succeed, error code otherwise.
    154194 *
    155195 */
    156 int hw_res_list_parse(const hw_resource_list_t *hw_resources,
    157     hw_res_list_parsed_t *out, int flags)
    158 {
    159         if ((!hw_resources) || (!out))
     196int hw_res_list_parse(const pio_window_t *win,
     197    const hw_resource_list_t *res, hw_res_list_parsed_t *out, int flags)
     198{
     199        if (!res || !out)
    160200                return EINVAL;
    161201       
    162         size_t res_count = hw_resources->count;
     202        size_t res_count = res->count;
    163203        hw_res_list_parsed_clean(out);
    164204       
    … …  
    174214       
    175215        for (size_t i = 0; i < res_count; ++i) {
    176                 const hw_resource_t *resource = &(hw_resources->resources[i]);
     216                const hw_resource_t *resource = &res->resources[i];
    177217               
    178218                switch (resource->type) {
    … …  
    181221                        break;
    182222                case IO_RANGE:
    183                         hw_res_parse_add_io_range(out, resource, flags);
     223                        hw_res_parse_add_io_range(out, win, resource, flags);
    184224                        break;
    185225                case MEM_RANGE:
    186                         hw_res_parse_add_mem_range(out, resource, flags);
     226                        hw_res_parse_add_mem_range(out, win, resource, flags);
    187227                        break;
    188228                case DMA_CHANNEL_8:
    … …  
    216256    hw_res_list_parsed_t *hw_res_parsed, int flags)
    217257{
     258        pio_window_t pio_window;
     259        int rc;
     260
    218261        if (!hw_res_parsed)
    219262                return EBADMEM;
    … …  
    222265        hw_res_list_parsed_clean(hw_res_parsed);
    223266        memset(&hw_resources, 0, sizeof(hw_resource_list_t));
    224        
    225         int rc = hw_res_get_resource_list(sess, &hw_resources);
     267
     268        rc = pio_window_get(sess, &pio_window);
     269        if (rc != EOK)
     270                return rc;
     271       
     272        rc = hw_res_get_resource_list(sess, &hw_resources);
    226273        if (rc != EOK)
    227274                return rc;
    228        
    229         rc = hw_res_list_parse(&hw_resources, hw_res_parsed, flags);
     275
     276        rc = hw_res_list_parse(&pio_window, &hw_resources, hw_res_parsed,
     277            flags);
    230278        hw_res_clean_resource_list(&hw_resources);
    231279       

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

    rf4a47e52 r0773396  
    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

    rf4a47e52 r0773396  
    6767}
    6868
    69 int dnsr_name2host(const char *name, dnsr_hostinfo_t **rinfo, uint16_t af)
     69int dnsr_name2host(const char *name, dnsr_hostinfo_t **rinfo, ip_ver_t ver)
    7070{
    7171        dnsr_hostinfo_t *info = calloc(1, sizeof(dnsr_hostinfo_t));
    … …  
    7676       
    7777        ipc_call_t answer;
    78         aid_t req = async_send_1(exch, DNSR_NAME2HOST, (sysarg_t) af,
     78        aid_t req = async_send_1(exch, DNSR_NAME2HOST, (sysarg_t) ver,
    7979            &answer);
    8080       

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

    rf4a47e52 r0773396  
    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.c

    rf4a47e52 r0773396  
    3030#include <assert.h>
    3131#include <errno.h>
    32 #include <net/socket_codes.h>
    3332#include <inet/inet.h>
    3433#include <ipc/inet.h>
    … …  
    111110       
    112111        ipc_call_t answer;
    113         aid_t req = async_send_3(exch, INET_SEND, dgram->tos, ttl, df,
    114             &answer);
     112        aid_t req = async_send_4(exch, INET_SEND, dgram->iplink, dgram->tos,
     113            ttl, df, &answer);
    115114       
    116115        int rc = async_data_write_start(exch, &dgram->src, sizeof(inet_addr_t));

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

    rf4a47e52 r0773396  
    3333 */
    3434
     35#include <assert.h>
    3536#include <errno.h>
    3637#include <unistd.h>
    … …  
    4849#endif
    4950
     51const addr32_t addr32_broadcast_all_hosts = 0xffffffff;
     52
    5053const addr48_t addr48_broadcast = {
    5154        0xff, 0xff, 0xff, 0xff, 0xff, 0xff
    … …  
    5760
    5861static const inet_addr_t inet_addr_any_addr = {
    59         .family = AF_INET,
     62        .version = ip_v4,
    6063        .addr = 0
    6164};
    6265
    6366static const inet_addr_t inet_addr_any_addr6 = {
    64         .family = AF_INET6,
     67        .version = ip_v6,
    6568        .addr6 = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    6669};
    … …  
    7679}
    7780
     81/** Compare addr48.
     82  *
     83  * @return Non-zero if equal, zero if not equal.
     84  */
    7885int addr48_compare(const addr48_t a, const addr48_t b)
    7986{
    80         return memcmp(a, b, 6);
    81 }
    82 
     87        return memcmp(a, b, 6) == 0;
     88}
     89
     90/** Compare addr128.
     91  *
     92  * @return Non-zero if equal, zero if not equal.
     93  */
    8394int addr128_compare(const addr128_t a, const addr128_t b)
    8495{
    85         return memcmp(a, b, 16);
     96        return memcmp(a, b, 16) == 0;
    8697}
    8798
    … …  
    100111void host2addr128_t_be(const addr128_t host, addr128_t be)
    101112{
    102 #ifdef __BE__
    103113        memcpy(be, host, 16);
    104 #else
    105         be[0] = host[15];
    106         be[1] = host[14];
    107         be[2] = host[13];
    108         be[3] = host[12];
    109         be[4] = host[11];
    110         be[5] = host[10];
    111         be[6] = host[9];
    112         be[7] = host[8];
    113         be[8] = host[7];
    114         be[9] = host[6];
    115         be[10] = host[5];
    116         be[11] = host[4];
    117         be[12] = host[3];
    118         be[13] = host[2];
    119         be[14] = host[1];
    120         be[15] = host[0];
    121 #endif
    122114}
    123115
    124116void addr128_t_be2host(const addr128_t be, addr128_t host)
    125117{
    126 #ifdef __BE__
    127118        memcpy(host, be, 16);
    128 #else
    129         host[0] = be[15];
    130         host[1] = be[14];
    131         host[2] = be[13];
    132         host[3] = be[12];
    133         host[4] = be[11];
    134         host[5] = be[10];
    135         host[6] = be[9];
    136         host[7] = be[8];
    137         host[8] = be[7];
    138         host[9] = be[6];
    139         host[10] = be[5];
    140         host[11] = be[4];
    141         host[12] = be[3];
    142         host[13] = be[2];
    143         host[14] = be[1];
    144         host[15] = be[0];
    145 #endif
    146119}
    147120
    148121void inet_addr(inet_addr_t *addr, uint8_t a, uint8_t b, uint8_t c, uint8_t d)
    149122{
    150         addr->family = AF_INET;
     123        addr->version = ip_v4;
    151124        addr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) |
    152125            ((addr32_t) c << 8) | ((addr32_t) d);
    … …  
    156129    uint8_t prefix)
    157130{
    158         naddr->family = AF_INET;
     131        naddr->version = ip_v4;
    159132        naddr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) |
    160133            ((addr32_t) c << 8) | ((addr32_t) d);
    … …  
    165138    uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h)
    166139{
    167         addr->family = AF_INET6;
     140        addr->version = ip_v6;
    168141        addr->addr6[0] = (a >> 8) & 0xff;
    169142        addr->addr6[1] = a & 0xff;
    … …  
    187160    uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h, uint8_t prefix)
    188161{
    189         naddr->family = AF_INET6;
     162        naddr->version = ip_v6;
    190163        naddr->addr6[0] = (a >> 8) & 0xff;
    191164        naddr->addr6[1] = a & 0xff;
    … …  
    207180}
    208181
    209 /** Parse network address family.
    210  *
    211  * @param text Network address in common notation.
    212  * @param af   Place to store network address family.
     182/** Determine address version.
     183 *
     184 * @param text Address in common notation.
     185 * @param af   Place to store address version.
    213186 *
    214187 * @return EOK on success, EINVAL if input is not in valid format.
    215188 *
    216189 */
    217 int inet_addr_family(const char *text, uint16_t *af)
     190static int inet_addr_version(const char *text, ip_ver_t *ver)
    218191{
    219192        char *dot = str_chr(text, '.');
    220193        if (dot != NULL) {
    221                 *af = AF_INET;
     194                *ver = ip_v4;
    222195                return EOK;
    223196        }
    224        
     197
    225198        char *collon = str_chr(text, ':');
    226199        if (collon != NULL) {
    227                 *af = AF_INET6;
     200                *ver = ip_v6;
    228201                return EOK;
    229202        }
    230        
     203
    231204        return EINVAL;
    232205}
    233206
     207static int ipver_af(ip_ver_t ver)
     208{
     209        switch (ver) {
     210        case ip_any:
     211                return AF_NONE;
     212        case ip_v4:
     213                return AF_INET;
     214        case ip_v6:
     215                return AF_INET6;
     216        default:
     217                assert(false);
     218                return EINVAL;
     219        }
     220}
     221
     222ip_ver_t ipver_from_af(int af)
     223{
     224        switch (af) {
     225        case AF_NONE:
     226                return ip_any;
     227        case AF_INET:
     228                return ip_v4;
     229        case AF_INET6:
     230                return ip_v6;
     231        default:
     232                assert(false);
     233                return EINVAL;
     234        }
     235}
     236
    234237void inet_naddr_addr(const inet_naddr_t *naddr, inet_addr_t *addr)
    235238{
    236         addr->family = naddr->family;
     239        addr->version = naddr->version;
    237240        memcpy(addr->addr6, naddr->addr6, 16);
    238241}
    … …  
    241244    inet_naddr_t *naddr)
    242245{
    243         naddr->family = addr->family;
     246        naddr->version = addr->version;
    244247        memcpy(naddr->addr6, addr->addr6, 16);
    245248        naddr->prefix = prefix;
    … …  
    248251void inet_addr_any(inet_addr_t *addr)
    249252{
    250         addr->family = AF_NONE;
     253        addr->version = ip_any;
    251254        memset(addr->addr6, 0, 16);
    252255}
    … …  
    254257void inet_naddr_any(inet_naddr_t *naddr)
    255258{
    256         naddr->family = AF_NONE;
     259        naddr->version = ip_any;
    257260        memset(naddr->addr6, 0, 16);
    258261        naddr->prefix = 0;
    … …  
    261264int inet_addr_compare(const inet_addr_t *a, const inet_addr_t *b)
    262265{
    263         if (a->family != b->family)
     266        if (a->version != b->version)
    264267                return 0;
    265        
    266         switch (a->family) {
    267         case AF_INET:
     268
     269        switch (a->version) {
     270        case ip_v4:
    268271                return (a->addr == b->addr);
    269         case AF_INET6:
     272        case ip_v6:
    270273                return addr128_compare(a->addr6, b->addr6);
    271274        default:
    … …  
    276279int inet_addr_is_any(const inet_addr_t *addr)
    277280{
    278         return ((addr->family == 0) ||
     281        return ((addr->version == ip_any) ||
    279282            (inet_addr_compare(addr, &inet_addr_any_addr)) ||
    280283            (inet_addr_compare(addr, &inet_addr_any_addr6)));
    … …  
    283286int inet_naddr_compare(const inet_naddr_t *naddr, const inet_addr_t *addr)
    284287{
    285         if (naddr->family != addr->family)
     288        if (naddr->version != addr->version)
    286289                return 0;
    287290       
    288         switch (naddr->family) {
    289         case AF_INET:
     291        switch (naddr->version) {
     292        case ip_v4:
    290293                return (naddr->addr == addr->addr);
    291         case AF_INET6:
     294        case ip_v6:
    292295                return addr128_compare(naddr->addr6, addr->addr6);
    293296        default:
    … …  
    298301int inet_naddr_compare_mask(const inet_naddr_t *naddr, const inet_addr_t *addr)
    299302{
    300         if (naddr->family != addr->family)
     303        if (naddr->version != addr->version)
    301304                return 0;
    302        
    303         switch (naddr->family) {
    304         case AF_INET:
     305
     306        switch (naddr->version) {
     307        case ip_v4:
    305308                if (naddr->prefix > 32)
    306309                        return 0;
    307                
     310
    308311                addr32_t mask =
    309312                    BIT_RANGE(addr32_t, 31, 31 - (naddr->prefix - 1));
    310313                return ((naddr->addr & mask) == (addr->addr & mask));
    311         case AF_INET6:
     314        case ip_v6:
    312315                if (naddr->prefix > 128)
    313316                        return 0;
    … …  
    350353int inet_addr_parse(const char *text, inet_addr_t *addr)
    351354{
    352         int rc = inet_addr_family(text, &addr->family);
     355        int rc = inet_addr_version(text, &addr->version);
    353356        if (rc != EOK)
    354357                return rc;
    355358       
    356359        uint8_t buf[16];
    357         rc = inet_pton(addr->family, text, buf);
     360        rc = inet_pton(ipver_af(addr->version), text, buf);
    358361        if (rc != EOK)
    359362                return rc;
    360363       
    361         switch (addr->family) {
    362         case AF_INET:
     364        switch (addr->version) {
     365        case ip_v4:
    363366                addr->addr = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) |
    364367                    buf[3];
    365368                break;
    366         case AF_INET6:
     369        case ip_v6:
    367370                memcpy(addr->addr6, buf, 16);
    368371                break;
    … …  
    390393        *slash = 0;
    391394       
    392         int rc = inet_addr_family(text, &naddr->family);
     395        int rc = inet_addr_version(text, &naddr->version);
    393396        if (rc != EOK)
    394397                return rc;
    395398       
    396399        uint8_t buf[16];
    397         rc = inet_pton(naddr->family, text, buf);
     400        rc = inet_pton(ipver_af(naddr->version), text, buf);
    398401        *slash = '/';
    399402       
    … …  
    404407        uint8_t prefix;
    405408       
    406         switch (naddr->family) {
    407         case AF_INET:
     409        switch (naddr->version) {
     410        case ip_v4:
    408411                prefix = strtoul(slash, &slash, 10);
    409412                if (prefix > 32)
    … …  
    415418               
    416419                break;
    417         case AF_INET6:
     420        case ip_v6:
    418421                prefix = strtoul(slash, &slash, 10);
    419422                if (prefix > 128)
    … …  
    445448        int rc = 0;
    446449       
    447         switch (addr->family) {
    448         case AF_NONE:
     450        switch (addr->version) {
     451        case ip_any:
    449452                rc = asprintf(bufp, "none");
    450453                break;
    451         case AF_INET:
     454        case ip_v4:
    452455                rc = asprintf(bufp, "%u.%u.%u.%u", (addr->addr >> 24) & 0xff,
    453456                    (addr->addr >> 16) & 0xff, (addr->addr >> 8) & 0xff,
    454457                    addr->addr & 0xff);
    455458                break;
    456         case AF_INET6:
     459        case ip_v6:
    457460                *bufp = (char *) malloc(INET6_ADDRSTRLEN);
    458461                if (*bufp == NULL)
    … …  
    485488        char prefix[INET_PREFIXSTRSIZE];
    486489       
    487         switch (naddr->family) {
    488         case AF_NONE:
     490        switch (naddr->version) {
     491        case ip_any:
    489492                rc = asprintf(bufp, "none");
    490493                break;
    491         case AF_INET:
     494        case ip_v4:
    492495                rc = asprintf(bufp, "%" PRIu8 ".%" PRIu8 ".%" PRIu8 ".%" PRIu8
    493496                    "/%" PRIu8, (naddr->addr >> 24) & 0xff,
    … …  
    495498                    naddr->addr & 0xff, naddr->prefix);
    496499                break;
    497         case AF_INET6:
     500        case ip_v6:
    498501                *bufp = (char *) malloc(INET6_ADDRSTRLEN + INET_PREFIXSTRSIZE);
    499502                if (*bufp == NULL)
    … …  
    527530}
    528531
    529 uint16_t inet_addr_get(const inet_addr_t *addr, addr32_t *v4, addr128_t *v6)
    530 {
    531         switch (addr->family) {
    532         case AF_INET:
     532ip_ver_t inet_addr_get(const inet_addr_t *addr, addr32_t *v4, addr128_t *v6)
     533{
     534        switch (addr->version) {
     535        case ip_v4:
    533536                if (v4 != NULL)
    534537                        *v4 = addr->addr;
    535                
    536                 break;
    537         case AF_INET6:
     538                break;
     539        case ip_v6:
    538540                if (v6 != NULL)
    539541                        memcpy(*v6, addr->addr6, 16);
    540                
    541                 break;
    542         }
    543        
    544         return addr->family;
    545 }
    546 
    547 uint16_t inet_naddr_get(const inet_naddr_t *naddr, addr32_t *v4, addr128_t *v6,
     542                break;
     543        default:
     544                assert(false);
     545                break;
     546        }
     547
     548        return addr->version;
     549}
     550
     551ip_ver_t inet_naddr_get(const inet_naddr_t *naddr, addr32_t *v4, addr128_t *v6,
    548552    uint8_t *prefix)
    549553{
    550         switch (naddr->family) {
    551         case AF_INET:
     554        switch (naddr->version) {
     555        case ip_v4:
    552556                if (v4 != NULL)
    553557                        *v4 = naddr->addr;
    554                
    555558                if (prefix != NULL)
    556559                        *prefix = naddr->prefix;
    557                
    558                 break;
    559         case AF_INET6:
     560                break;
     561        case ip_v6:
    560562                if (v6 != NULL)
    561563                        memcpy(*v6, naddr->addr6, 16);
    562                
    563564                if (prefix != NULL)
    564565                        *prefix = naddr->prefix;
    565                
    566                 break;
    567         }
    568        
    569         return naddr->family;
     566                break;
     567        default:
     568                assert(false);
     569                break;
     570        }
     571
     572        return naddr->version;
    570573}
    571574
    572575void inet_addr_set(addr32_t v4, inet_addr_t *addr)
    573576{
    574         addr->family = AF_INET;
     577        addr->version = ip_v4;
    575578        addr->addr = v4;
    576579}
    … …  
    578581void inet_naddr_set(addr32_t v4, uint8_t prefix, inet_naddr_t *naddr)
    579582{
    580         naddr->family = AF_INET;
     583        naddr->version = ip_v4;
    581584        naddr->addr = v4;
    582585        naddr->prefix = prefix;
    … …  
    585588void inet_sockaddr_in_addr(const sockaddr_in_t *sockaddr_in, inet_addr_t *addr)
    586589{
    587         addr->family = AF_INET;
     590        addr->version = ip_v4;
    588591        addr->addr = uint32_t_be2host(sockaddr_in->sin_addr.s_addr);
    589592}
    … …  
    591594void inet_addr_set6(addr128_t v6, inet_addr_t *addr)
    592595{
    593         addr->family = AF_INET6;
     596        addr->version = ip_v6;
    594597        memcpy(addr->addr6, v6, 16);
    595598}
    … …  
    597600void inet_naddr_set6(addr128_t v6, uint8_t prefix, inet_naddr_t *naddr)
    598601{
    599         naddr->family = AF_INET6;
     602        naddr->version = ip_v6;
    600603        memcpy(naddr->addr6, v6, 16);
    601604        naddr->prefix = prefix;
    … …  
    605608    inet_addr_t *addr)
    606609{
    607         addr->family = AF_INET6;
     610        addr->version = ip_v6;
    608611        addr128_t_be2host(sockaddr_in6->sin6_addr.s6_addr, addr->addr6);
    609612}
    … …  
    612615    sockaddr_in_t *sockaddr_in, sockaddr_in6_t *sockaddr_in6)
    613616{
    614         switch (addr->family) {
    615         case AF_INET:
     617        switch (addr->version) {
     618        case ip_v4:
    616619                if (sockaddr_in != NULL) {
    617620                        sockaddr_in->sin_family = AF_INET;
    618621                        sockaddr_in->sin_addr.s_addr = host2uint32_t_be(addr->addr);
    619622                }
    620                
    621                 break;
    622         case AF_INET6:
     623                break;
     624        case ip_v6:
    623625                if (sockaddr_in6 != NULL) {
    624626                        sockaddr_in6->sin6_family = AF_INET6;
    625627                        host2addr128_t_be(addr->addr6, sockaddr_in6->sin6_addr.s6_addr);
    626628                }
    627                
    628                 break;
    629         }
    630        
    631         return addr->family;
     629                break;
     630        default:
     631                assert(false);
     632                break;
     633        }
     634
     635        return ipver_af(addr->version);
     636}
     637
     638int inet_addr_sockaddr(const inet_addr_t *addr, uint16_t port,
     639    sockaddr_t **nsockaddr, socklen_t *naddrlen)
     640{
     641        sockaddr_in_t *sa4;
     642        sockaddr_in6_t *sa6;
     643
     644        switch (addr->version) {
     645        case ip_v4:
     646                sa4 = calloc(1, sizeof(sockaddr_in_t));
     647                if (sa4 == NULL)
     648                        return ENOMEM;
     649
     650                sa4->sin_family = AF_INET;
     651                sa4->sin_port = host2uint16_t_be(port);
     652                sa4->sin_addr.s_addr = host2uint32_t_be(addr->addr);
     653                if (nsockaddr != NULL)
     654                        *nsockaddr = (sockaddr_t *)sa4;
     655                if (naddrlen != NULL)
     656                        *naddrlen = sizeof(*sa4);
     657                break;
     658        case ip_v6:
     659                sa6 = calloc(1, sizeof(sockaddr_in6_t));
     660                if (sa6 == NULL)
     661                        return ENOMEM;
     662
     663                sa6->sin6_family = AF_INET6;
     664                sa6->sin6_port = host2uint16_t_be(port);
     665                host2addr128_t_be(addr->addr6, sa6->sin6_addr.s6_addr);
     666                if (nsockaddr != NULL)
     667                        *nsockaddr = (sockaddr_t *)sa6;
     668                if (naddrlen != NULL)
     669                        *naddrlen = sizeof(*sa6);
     670                break;
     671        default:
     672                assert(false);
     673                break;
     674        }
     675
     676        return EOK;
    632677}
    633678

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

    rf4a47e52 r0773396  
    267267}
    268268
     269int inetcfg_link_add(sysarg_t link_id)
     270{
     271        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     272
     273        int rc = async_req_1_0(exch, INETCFG_LINK_ADD, link_id);
     274        async_exchange_end(exch);
     275
     276        return rc;
     277}
     278
    269279int inetcfg_link_get(sysarg_t link_id, inet_link_info_t *linfo)
    270280{
    … …  
    279289        aid_t req = async_send_1(exch, INETCFG_LINK_GET, link_id, &answer);
    280290        aid_t dreq = async_data_read(exch, name_buf, LOC_NAME_MAXLEN, &dreply);
     291        int rc = async_data_read_start(exch, &linfo->mac_addr, sizeof(addr48_t));
    281292        async_wait_for(dreq, &dretval);
    282293
    283294        async_exchange_end(exch);
    284295
    285         if (dretval != EOK) {
     296        if (dretval != EOK || rc != EOK) {
    286297                async_forget(req);
    287298                return dretval;
    … …  
    302313
    303314        return EOK;
     315}
     316
     317int inetcfg_link_remove(sysarg_t link_id)
     318{
     319        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     320
     321        int rc = async_req_1_0(exch, INETCFG_LINK_REMOVE, link_id);
     322        async_exchange_end(exch);
     323
     324        return rc;
    304325}
    305326

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

    rf4a47e52 r0773396  
    11/*
    2  * Copyright (c) 2012 Jiri Svoboda
     2 * Copyright (c) 2013 Jiri Svoboda
     3 * Copyright (c) 2013 Martin Decky
    34 * All rights reserved.
    45 *
    … …  
    4950
    5051        assert(inetping_sess == NULL);
    51        
     52
    5253        inetping_ev_ops = ev_ops;
    53        
     54
    5455        rc = loc_service_get_id(SERVICE_NAME_INETPING, &inetping_svc,
    5556            IPC_FLAG_BLOCKING);
    5657        if (rc != EOK)
    5758                return ENOENT;
    58        
     59
    5960        inetping_sess = loc_service_connect(EXCHANGE_SERIALIZE, inetping_svc,
    6061            IPC_FLAG_BLOCKING);
    6162        if (inetping_sess == NULL)
    6263                return ENOENT;
    63        
     64
    6465        async_exch_t *exch = async_exchange_begin(inetping_sess);
    6566
    6667        rc = async_connect_to_me(exch, 0, 0, 0, inetping_cb_conn, NULL);
    6768        async_exchange_end(exch);
    68        
     69
    6970        if (rc != EOK) {
    7071                async_hangup(inetping_sess);
    … …  
    7273                return rc;
    7374        }
    74        
     75
    7576        return EOK;
    7677}
    … …  
    7980{
    8081        async_exch_t *exch = async_exchange_begin(inetping_sess);
    81        
     82
    8283        ipc_call_t answer;
    83         aid_t req = async_send_3(exch, INETPING_SEND, (sysarg_t) sdu->src,
    84             (sysarg_t) sdu->dest, sdu->seq_no, &answer);
    85         sysarg_t retval = async_data_write_start(exch, sdu->data, sdu->size);
    86        
     84        aid_t req = async_send_1(exch, INETPING_SEND, sdu->seq_no, &answer);
     85
     86        int rc = async_data_write_start(exch, &sdu->src, sizeof(sdu->src));
     87        if (rc != EOK) {
     88                async_exchange_end(exch);
     89                async_forget(req);
     90                return rc;
     91        }
     92
     93        rc = async_data_write_start(exch, &sdu->dest, sizeof(sdu->dest));
     94        if (rc != EOK) {
     95                async_exchange_end(exch);
     96                async_forget(req);
     97                return rc;
     98        }
     99
     100        rc = async_data_write_start(exch, sdu->data, sdu->size);
     101
    87102        async_exchange_end(exch);
    88        
    89         if (retval != EOK) {
    90                 async_forget(req);
    91                 return retval;
    92         }
    93        
     103
     104        if (rc != EOK) {
     105                async_forget(req);
     106                return rc;
     107        }
     108
     109        sysarg_t retval;
    94110        async_wait_for(req, &retval);
    95         return retval;
    96 }
    97 
    98 int inetping_get_srcaddr(uint32_t remote, uint32_t *local)
     111
     112        return (int) retval;
     113}
     114
     115int inetping_get_srcaddr(const inet_addr_t *remote, inet_addr_t *local)
    99116{
    100117        async_exch_t *exch = async_exchange_begin(inetping_sess);
    101        
    102         sysarg_t local_addr;
    103         int rc = async_req_1_1(exch, INETPING_GET_SRCADDR, (sysarg_t) remote,
    104             &local_addr);
    105        
     118
     119        ipc_call_t answer;
     120        aid_t req = async_send_0(exch, INETPING_GET_SRCADDR, &answer);
     121
     122        int rc = async_data_write_start(exch, remote, sizeof(*remote));
     123        if (rc != EOK) {
     124                async_exchange_end(exch);
     125                async_forget(req);
     126                return rc;
     127        }
     128
     129        ipc_call_t answer_local;
     130        aid_t req_local = async_data_read(exch, local, sizeof(*local),
     131            &answer_local);
     132
    106133        async_exchange_end(exch);
    107        
    108         if (rc != EOK)
    109                 return rc;
    110        
    111         *local = (uint32_t) local_addr;
    112         return EOK;
    113 }
    114 
    115 static void inetping_ev_recv(ipc_callid_t callid, ipc_call_t *call)
     134
     135        sysarg_t retval_local;
     136        async_wait_for(req_local, &retval_local);
     137
     138        if (retval_local != EOK) {
     139                async_forget(req);
     140                return (int) retval_local;
     141        }
     142
     143        sysarg_t retval;
     144        async_wait_for(req, &retval);
     145
     146        return (int) retval;
     147}
     148
     149static void inetping_ev_recv(ipc_callid_t iid, ipc_call_t *icall)
    116150{
    117151        inetping_sdu_t sdu;
    118        
    119         sdu.src = IPC_GET_ARG1(*call);
    120         sdu.dest = IPC_GET_ARG2(*call);
    121         sdu.seq_no = IPC_GET_ARG3(*call);
    122        
    123         int rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
     152
     153        sdu.seq_no = IPC_GET_ARG1(*icall);
     154
     155        ipc_callid_t callid;
     156        size_t size;
     157        if (!async_data_write_receive(&callid, &size)) {
     158                async_answer_0(callid, EREFUSED);
     159                async_answer_0(iid, EREFUSED);
     160                return;
     161        }
     162
     163        if (size != sizeof(sdu.src)) {
     164                async_answer_0(callid, EINVAL);
     165                async_answer_0(iid, EINVAL);
     166                return;
     167        }
     168
     169        int rc = async_data_write_finalize(callid, &sdu.src, size);
    124170        if (rc != EOK) {
    125171                async_answer_0(callid, rc);
    126                 return;
    127         }
    128        
     172                async_answer_0(iid, rc);
     173                return;
     174        }
     175
     176        if (!async_data_write_receive(&callid, &size)) {
     177                async_answer_0(callid, EREFUSED);
     178                async_answer_0(iid, EREFUSED);
     179                return;
     180        }
     181
     182        if (size != sizeof(sdu.dest)) {
     183                async_answer_0(callid, EINVAL);
     184                async_answer_0(iid, EINVAL);
     185                return;
     186        }
     187
     188        rc = async_data_write_finalize(callid, &sdu.dest, size);
     189        if (rc != EOK) {
     190                async_answer_0(callid, rc);
     191                async_answer_0(iid, rc);
     192                return;
     193        }
     194
     195        rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
     196        if (rc != EOK) {
     197                async_answer_0(iid, rc);
     198                return;
     199        }
     200
    129201        rc = inetping_ev_ops->recv(&sdu);
    130202        free(sdu.data);
    131         async_answer_0(callid, rc);
     203        async_answer_0(iid, rc);
    132204}
    133205

  • uspace/lib/c/generic/io/asprintf.c

    rf4a47e52 r0773396  
    5050}
    5151
     52int vprintf_size(const char *fmt, va_list args)
     53{
     54        printf_spec_t ps = {
     55                asprintf_str_write,
     56                asprintf_wstr_write,
     57                NULL
     58        };
     59       
     60        return printf_core(fmt, &ps, args);
     61}
     62
     63int printf_size(const char *fmt, ...)
     64{
     65        va_list args;
     66        va_start(args, fmt);
     67        int ret = vprintf_size(fmt, args);
     68        va_end(args);
     69       
     70        return ret;
     71}
     72
    5273/** Allocate and print to string.
    5374 *
    … …  
    6182int asprintf(char **strp, const char *fmt, ...)
    6283{
    63         printf_spec_t ps = {
    64                 asprintf_str_write,
    65                 asprintf_wstr_write,
    66                 NULL
    67         };
    68        
    6984        va_list args;
    7085        va_start(args, fmt);
    71        
    72         int ret = printf_core(fmt, &ps, args);
     86        int ret = vprintf_size(fmt, args);
    7387        va_end(args);
    7488       

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

    rf4a47e52 r0773396  
    218218        iplink_recv_sdu_t sdu;
    219219       
    220         uint16_t af = IPC_GET_ARG1(*icall);
     220        ip_ver_t ver = IPC_GET_ARG1(*icall);
    221221       
    222222        int rc = async_data_write_accept(&sdu.data, false, 0, 0, 0,
    … …  
    227227        }
    228228       
    229         rc = iplink->ev_ops->recv(iplink, &sdu, af);
     229        rc = iplink->ev_ops->recv(iplink, &sdu, ver);
    230230        free(sdu.data);
    231231        async_answer_0(iid, rc);

  • uspace/lib/c/generic/iplink_srv.c

    rf4a47e52 r0773396  
    272272}
    273273
    274 int iplink_ev_recv(iplink_srv_t *srv, iplink_recv_sdu_t *sdu, uint16_t af)
     274/* XXX Version should be part of @a sdu */
     275int iplink_ev_recv(iplink_srv_t *srv, iplink_recv_sdu_t *sdu, ip_ver_t ver)
    275276{
    276277        if (srv->client_sess == NULL)
    … …  
    280281       
    281282        ipc_call_t answer;
    282         aid_t req = async_send_1(exch, IPLINK_EV_RECV, (sysarg_t) af,
     283        aid_t req = async_send_1(exch, IPLINK_EV_RECV, (sysarg_t)ver,
    283284            &answer);
    284285       

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

    rf4a47e52 r0773396  
    923923 *                      message.
    924924 */
    925 int send(int socket_id, void *data, size_t datalength, int flags)
     925int send(int socket_id, const void *data, size_t datalength, int flags)
    926926{
    927927        /* Without the address */

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

    rf4a47e52 r0773396  
    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/rtld/module.c

    rf4a47e52 r0773396  
    9393module_t *module_find(const char *name)
    9494{
    95         module_t *m;
    9695        const char *p, *soname;
    9796
    … …  
    107106
    108107        /* Traverse list of all modules. Not extremely fast, but simple */
    109         list_foreach(runtime_env->modules, cur) {
    110                 DPRINTF("cur = %p\n", cur);
    111                 m = list_get_instance(cur, module_t, modules_link);
     108        list_foreach(runtime_env->modules, modules_link, module_t, m) {
     109                DPRINTF("m = %p\n", m);
    112110                if (str_cmp(m->dyn.soname, soname) == 0) {
    113111                        return m; /* Found */
    … …  
    245243void modules_process_relocs(module_t *start)
    246244{
    247         module_t *m;
    248 
    249         list_foreach(runtime_env->modules, cur) {
    250                 m = list_get_instance(cur, module_t, modules_link);
    251 
     245        list_foreach(runtime_env->modules, modules_link, module_t, m) {
    252246                /* Skip rtld, since it has already been processed */
    253247                if (m != &runtime_env->rtld) {
    … …  
    261255void modules_untag(void)
    262256{
    263         module_t *m;
    264 
    265         list_foreach(runtime_env->modules, cur) {
    266                 m = list_get_instance(cur, module_t, modules_link);
     257        list_foreach(runtime_env->modules, modules_link, module_t, m) {
    267258                m->bfs_tag = false;
    268259        }

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

    rf4a47e52 r0773396  
    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

    rf4a47e52 r0773396  
    4343#include <stdio.h>
    4444#include <sys/stat.h>
     45#include <sys/statfs.h>
    4546#include <sys/types.h>
    4647#include <ipc/services.h>
    … …  
    341342}
    342343
    343 ssize_t read(int fildes, void *buf, size_t nbyte) 
     344ssize_t read(int fildes, void *buf, size_t nbyte)
    344345{
    345346        sysarg_t rc;
    … …  
    347348        aid_t req;
    348349       
     350        if (nbyte > DATA_XFER_LIMIT)
     351                nbyte = DATA_XFER_LIMIT;
     352       
    349353        async_exch_t *exch = vfs_exchange_begin();
    350354       
    351355        req = async_send_1(exch, VFS_IN_READ, fildes, &answer);
    352         rc = async_data_read_start(exch, (void *)buf, nbyte);
     356        rc = async_data_read_start(exch, (void *) buf, nbyte);
    353357        if (rc != EOK) {
    354358                vfs_exchange_end(exch);
    … …  
    376380        aid_t req;
    377381       
     382        if (nbyte > DATA_XFER_LIMIT)
     383                nbyte = DATA_XFER_LIMIT;
     384       
    378385        async_exch_t *exch = vfs_exchange_begin();
    379386       
    380387        req = async_send_1(exch, VFS_IN_WRITE, fildes, &answer);
    381         rc = async_data_write_start(exch, (void *)buf, nbyte);
     388        rc = async_data_write_start(exch, (void *) buf, nbyte);
    382389        if (rc != EOK) {
    383390                vfs_exchange_end(exch);
    … …  
    735742}
    736743
     744int remove(const char *path)
     745{
     746        return unlink(path);
     747}
     748
    737749int chdir(const char *path)
    738750{
    … …  
    892904}
    893905
     906int statfs(const char *path, struct statfs *st)
     907{
     908        sysarg_t rc, rc_orig;
     909        aid_t req;
     910        size_t pa_size;
     911
     912        char *pa = absolutize(path, &pa_size);
     913        if (!pa)
     914                return ENOMEM;
     915
     916        async_exch_t *exch = vfs_exchange_begin();
     917
     918        req = async_send_0(exch, VFS_IN_STATFS, NULL);
     919        rc = async_data_write_start(exch, pa, pa_size);
     920        if (rc != EOK)
     921                goto exit;
     922
     923        rc = async_data_read_start(exch, (void *) st, sizeof(*st));
     924
     925exit:
     926        vfs_exchange_end(exch);
     927        free(pa);
     928        async_wait_for(req, &rc_orig);
     929        return (int) (rc_orig != EOK ? rc_orig : rc);
     930}
     931
    894932/** @}
    895933 */
Note: See TracChangeset for help on using the changeset viewer.