Changeset 3f03199 in mainline for uspace/lib/c


Ignore:
Timestamp:
2013-09-15T06:33:53Z (12 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
9348862
Parents:
dd7078c (diff), 1c0cef0 (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.

Major conflicts in USB HC drivers.
Compiles and UHCI works (qemu).
OHCI has device remove problems.

Location:
uspace/lib/c
Files:
6 added
34 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/Makefile

    rdd7078c r3f03199  
    6565        generic/cfg.c \
    6666        generic/clipboard.c \
     67        generic/corecfg.c \
    6768        generic/devman.c \
    6869        generic/device/hw_res.c \
    6970        generic/device/hw_res_parsed.c \
     71        generic/device/pio_window.c \
    7072        generic/device/char_dev.c \
    7173        generic/device/clock_dev.c \

  • uspace/lib/c/arch/sparc64/Makefile.common

    rdd7078c r3f03199  
    2727#
    2828
    29 GCC_CFLAGS += -mcpu=ultrasparc -m64 -mcmodel=medlow
     29ifeq ($(PROCESSOR),sun4v)
     30GCC_CFLAGS += -mcpu=niagara -mno-vis
     31else
     32GCC_CFLAGS += -mcpu=ultrasparc
     33endif
     34
     35GCC_CFLAGS += -m64 -mcmodel=medlow
     36
    3037LFLAGS = -no-check-sections
    3138

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

    rdd7078c r3f03199  
    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

    rdd7078c r3f03199  
    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

    rdd7078c r3f03199  
    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

    rdd7078c r3f03199  
    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

    rdd7078c r3f03199  
    4242{
    4343        sysarg_t count = 0;
    44 
     44       
    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);
    50 
     49       
    5150        if (rc != EOK) {
    5251                async_exchange_end(exch);
    5352                return rc;
    5453        }
    55 
     54       
    5655        size_t size = count * sizeof(hw_resource_t);
    5756        hw_resource_t *resources = (hw_resource_t *) malloc(size);
    … …  
    6160                return ENOMEM;
    6261        }
    63 
     62       
    6463        rc = async_data_read_start(exch, resources, size);
    6564        async_exchange_end(exch);
    66 
     65       
    6766        if (rc != EOK) {
    6867                free(resources);
    6968                return rc;
    7069        }
    71 
     70       
    7271        hw_resources->resources = resources;
    7372        hw_resources->count = count;
    74 
     73       
    7574        return EOK;
    7675}
    … …  
    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);
    8583        async_exchange_end(exch);
    86 
     84       
    8785        return (rc == EOK);
    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

    rdd7078c r3f03199  
    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]);
    177 
     216                const hw_resource_t *resource = &res->resources[i];
     217               
    178218                switch (resource->type) {
    179219                case INTERRUPT:
    … …  
    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:
    … …  
    195235                }
    196236        }
    197 
     237       
    198238        return EOK;
    199239};
    … …  
    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

    rdd7078c r3f03199  
    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/futex.c

    rdd7078c r3f03199  
    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

    rdd7078c r3f03199  
    111111       
    112112        ipc_call_t answer;
    113         aid_t req = async_send_3(exch, INET_SEND, dgram->tos, ttl, df,
    114             &answer);
     113        aid_t req = async_send_4(exch, INET_SEND, dgram->iplink, dgram->tos,
     114            ttl, df, &answer);
    115115       
    116116        int rc = async_data_write_start(exch, &dgram->src, sizeof(inet_addr_t));

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

    rdd7078c r3f03199  
    4747        #error The architecture must be either big-endian or little-endian.
    4848#endif
     49
     50const addr32_t addr32_broadcast_all_hosts = 0xffffffff;
    4951
    5052const addr48_t addr48_broadcast = {

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

    rdd7078c r3f03199  
    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/net/socket_client.c

    rdd7078c r3f03199  
    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

    rdd7078c r3f03199  
    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

    rdd7078c r3f03199  
    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

    rdd7078c r3f03199  
    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 */

  • uspace/lib/c/include/adt/list.h

    rdd7078c r3f03199  
    11/*
    22 * Copyright (c) 2001-2004 Jakub Jermar
    3  * Copyright (c) 2011 Jiri Svoboda
     3 * Copyright (c) 2013 Jiri Svoboda
    44 * All rights reserved.
    55 *
    … …  
    6565
    6666#define list_get_instance(link, type, member) \
    67         ((type *) (((void *)(link)) - ((void *) &(((type *) NULL)->member))))
    68 
    69 #define list_foreach(list, iterator) \
    70         for (link_t *iterator = (list).head.next; \
    71             iterator != &(list).head; iterator = iterator->next)
     67        ((type *) (((void *)(link)) - list_link_to_void(&(((type *) NULL)->member))))
     68
     69#define list_foreach(list, member, itype, iterator) \
     70        for (itype *iterator = NULL; iterator == NULL; iterator = (itype *) 1) \
     71            for (link_t *_link = (list).head.next; \
     72            iterator = list_get_instance(_link, itype, member), \
     73            _link != &(list).head; _link = _link->next)
    7274
    7375/** Unlike list_foreach(), allows removing items while traversing a list.
    74  * 
     76 *
    7577 * @code
    7678 * list_t mylist;
    … …  
    238240static inline link_t *list_last(list_t *list)
    239241{
    240         return ((list->head.prev == &list->head) ? NULL : list->head.prev);
     242        return (list->head.prev == &list->head) ? NULL : list->head.prev;
     243}
     244
     245/** Get next item in list.
     246 *
     247 * @param link Current item link
     248 * @param list List containing @a link
     249 *
     250 * @return Next item or NULL if @a link is the last item.
     251 *
     252 */
     253static inline link_t *list_next(link_t *link, const list_t *list)
     254{
     255        return (link->next == &list->head) ? NULL : link->next;
     256}
     257
     258/** Get previous item in list.
     259 *
     260 * @param link Current item link
     261 * @param list List containing @a link
     262 *
     263 * @return Previous item or NULL if @a link is the first item.
     264 *
     265 */
     266static inline link_t *list_prev(link_t *link, const list_t *list)
     267{
     268        return (link->prev == &list->head) ? NULL : link->prev;
    241269}
    242270
    … …  
    308336        unsigned int cnt = 0;
    309337       
    310         list_foreach(*list, link) {
     338        link_t *link = list_first(list);
     339        while (link != NULL) {
    311340                if (cnt == n)
    312341                        return link;
    313342               
    314343                cnt++;
     344                link = list_next(link, list);
    315345        }
    316346       
    317347        return NULL;
     348}
     349
     350/** Verify that argument type is a pointer to link_t (at compile time).
     351 *
     352 * This can be used to check argument type in a macro.
     353 */
     354static inline const void *list_link_to_void(const link_t *link)
     355{
     356        return link;
    318357}
    319358

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

    rdd7078c r3f03199  
    8080
    8181#define cfg_file_foreach(file, cur) \
    82         list_foreach((file)->sections, (cur))
     82        list_foreach((file)->sections, link, const cfg_section_t, (cur))
    8383
    8484#define cfg_section_instance(cur) \
    … …  
    8686
    8787#define cfg_section_foreach(section, cur) \
    88         list_foreach((section)->entries, (cur))
     88        list_foreach((section)->entries, link, const cfg_entry_t, (cur))
    8989
    9090#define cfg_entry_instance(cur) \

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

    rdd7078c r3f03199  
    4040#include <sys/time.h>
    4141#include <abi/ddi/irq.h>
     42#include <device/hw_res.h>
     43#include <device/hw_res_parsed.h>
     44#include <device/pio_window.h>
    4245#include <task.h>
     46
     47#define DMAMEM_16MiB  ((uintptr_t) UINT64_C(0xffffffffff000000))
     48#define DMAMEM_4GiB   ((uintptr_t) UINT64_C(0xffffffff00000000))
    4349
    4450extern int device_assign_devno(void);
    4551
    46 extern int physmem_map(void *, size_t, unsigned int, void **);
     52extern int physmem_map(uintptr_t, size_t, unsigned int, void **);
    4753
    48 extern int dmamem_map(void *, size_t, unsigned int, unsigned int, void **);
    49 extern int dmamem_map_anonymous(size_t, unsigned int, unsigned int, void **,
    50     void **);
     54extern int dmamem_map(void *, size_t, unsigned int, unsigned int, uintptr_t *);
     55extern int dmamem_map_anonymous(size_t, uintptr_t, unsigned int, unsigned int,
     56    uintptr_t *, void **);
    5157extern int dmamem_unmap(void *, size_t);
    5258extern int dmamem_unmap_anonymous(void *);
    5359
     60extern int pio_enable_range(addr_range_t *, void **);
     61extern int pio_enable_resource(pio_window_t *, hw_resource_t *, void **);
    5462extern int pio_enable(void *, size_t, void **);
    5563
    … …  
    6977extern uint32_t pio_read_32(const ioport32_t *);
    7078
    71 static inline uint8_t pio_change_8(
    72     ioport8_t *reg, uint8_t val, uint8_t mask, useconds_t delay)
     79static inline uint8_t pio_change_8(ioport8_t *reg, uint8_t val, uint8_t mask,
     80    useconds_t delay)
    7381{
    7482        uint8_t v = pio_read_8(reg);
    … …  
    7886}
    7987
    80 static inline uint16_t pio_change_16(
    81     ioport16_t *reg, uint16_t val, uint16_t mask, useconds_t delay)
     88static inline uint16_t pio_change_16(ioport16_t *reg, uint16_t val,
     89    uint16_t mask, useconds_t delay)
    8290{
    8391        uint16_t v = pio_read_16(reg);
    … …  
    8795}
    8896
    89 static inline uint32_t pio_change_32(
    90     ioport32_t *reg, uint32_t val, uint32_t mask, useconds_t delay)
     97static inline uint32_t pio_change_32(ioport32_t *reg, uint32_t val,
     98    uint32_t mask, useconds_t delay)
    9199{
    92100        uint32_t v = pio_read_32(reg);

  • uspace/lib/c/include/device/hw_res.h

    rdd7078c r3f03199  
    7676                struct {
    7777                        uint64_t address;
     78                        size_t size;
     79                        bool relative;
    7880                        endianness_t endianness;
    79                         size_t size;
    8081                } mem_range;
    8182               
    8283                struct {
    8384                        uint64_t address;
     85                        size_t size;
     86                        bool relative;
    8487                        endianness_t endianness;
    85                         size_t size;
    8688                } io_range;
    8789               

  • uspace/lib/c/include/device/hw_res_parsed.h

    rdd7078c r3f03199  
    3737
    3838#include <device/hw_res.h>
     39#include <device/pio_window.h>
    3940#include <str.h>
    4041
    … …  
    4546#define HW_RES_KEEP_DUPLICIT   0x2
    4647
     48
     49#define RNGABS(rng)     (rng).address.absolute
     50#define RNGREL(rng)     (rng).address.relative
     51#define RNGSZ(rng)      (rng).size
     52
     53#define RNGABSPTR(rng)  ((void *) ((uintptr_t) RNGABS((rng))))
     54
     55typedef struct address64 {
     56        /** Aboslute address. */
     57        uint64_t absolute;
     58        /** PIO window base relative address. */
     59        uint64_t relative;
     60} address64_t;
     61
    4762/** Address range structure */
    4863typedef struct addr_range {
    4964        /** Start address */
    50         uint64_t address;
    51        
    52         /** Endianness */
    53         endianness_t endianness;
     65        address64_t address;
    5466       
    5567        /** Area size */
    5668        size_t size;
     69
     70        /** Endianness */
     71        endianness_t endianness;
    5772} addr_range_t;
    5873
    … …  
    139154}
    140155
    141 extern int hw_res_list_parse(
    142     const hw_resource_list_t *, hw_res_list_parsed_t *, int);
     156extern int hw_res_list_parse(const pio_window_t *, const hw_resource_list_t *,
     157    hw_res_list_parsed_t *, int);
    143158extern int hw_res_get_list_parsed(async_sess_t *, hw_res_list_parsed_t *, int);
    144159

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

    rdd7078c r3f03199  
    6161    unsigned int);
    6262extern int devman_fun_get_child(devman_handle_t, devman_handle_t *);
     63extern int devman_dev_get_parent(devman_handle_t, devman_handle_t *);
    6364extern int devman_dev_get_functions(devman_handle_t, devman_handle_t **,
    6465    size_t *);
     66extern int devman_fun_get_match_id(devman_handle_t, size_t, char *, size_t,
     67    unsigned int *);
    6568extern int devman_fun_get_name(devman_handle_t, char *, size_t);
    6669extern int devman_fun_get_driver_name(devman_handle_t, char *, size_t);
    … …  
    7174extern int devman_add_device_to_category(devman_handle_t, const char *);
    7275extern int devman_fun_sid_to_handle(service_id_t, devman_handle_t *);
     76extern int devman_get_drivers(devman_handle_t **, size_t *);
     77extern int devman_driver_get_devices(devman_handle_t, devman_handle_t **,
     78    size_t *);
     79extern int devman_driver_get_handle(const char *, devman_handle_t *);
     80extern int devman_driver_get_match_id(devman_handle_t, size_t, char *, size_t,
     81    unsigned int *);
     82extern int devman_driver_get_name(devman_handle_t, char *, size_t);
     83extern int devman_driver_get_state(devman_handle_t, driver_state_t *);
     84extern int devman_driver_load(devman_handle_t);
    7385
    7486#endif

  • uspace/lib/c/include/inet/addr.h

    rdd7078c r3f03199  
    6868} inet_naddr_t;
    6969
     70extern const addr32_t addr32_broadcast_all_hosts;
    7071extern const addr48_t addr48_broadcast;
    7172

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

    rdd7078c r3f03199  
    3737
    3838#include <inet/addr.h>
     39#include <ipc/loc.h>
    3940#include <sys/types.h>
    4041
    … …  
    4243
    4344typedef struct {
     45        /** Local IP link service ID (optional) */
     46        service_id_t iplink;
    4447        inet_addr_t src;
    4548        inet_addr_t dest;

  • uspace/lib/c/include/ipc/dev_iface.h

    rdd7078c r3f03199  
    3636typedef enum {
    3737        HW_RES_DEV_IFACE = 0,
    38 
    39         /** Audio device mixer interface */
    40         AUDIO_MIXER_IFACE,
    41         /** Audio device pcm buffer interface */
    42         AUDIO_PCM_BUFFER_IFACE,
     38        PIO_WINDOW_DEV_IFACE,
    4339
    4440        /** Character device interface */
    … …  
    4743        /** Graphic device interface */
    4844        GRAPH_DEV_IFACE,
     45
     46        /** Audio device mixer interface */
     47        AUDIO_MIXER_IFACE,
     48        /** Audio device pcm buffer interface */
     49        AUDIO_PCM_BUFFER_IFACE,
    4950       
    5051        /** Network interface controller interface */
    … …  
    6061        /** Interface provided by USB HID devices. */
    6162        USBHID_DEV_IFACE,
     63
    6264        /** Interface provided by Real Time Clock devices */
    6365        CLOCK_DEV_IFACE,
     66
    6467        /** Interface provided by battery powered devices */
    6568        BATTERY_DEV_IFACE,
     69
    6670        /** Interface provided by AHCI devices. */
    6771        AHCI_DEV_IFACE,

  • uspace/lib/c/include/ipc/devman.h

    rdd7078c r3f03199  
    4242
    4343typedef sysarg_t devman_handle_t;
     44
     45typedef enum {
     46        /** Driver has not been started. */
     47        DRIVER_NOT_STARTED = 0,
     48       
     49        /**
     50         * Driver has been started, but has not registered as running and ready
     51         * to receive requests.
     52         */
     53        DRIVER_STARTING,
     54       
     55        /** Driver is running and prepared to serve incomming requests. */
     56        DRIVER_RUNNING
     57} driver_state_t;
    4458
    4559typedef enum {
    … …  
    155169        DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD,
    156170        DEVMAN_DEV_GET_FUNCTIONS,
     171        DEVMAN_DEV_GET_PARENT,
    157172        DEVMAN_FUN_GET_CHILD,
     173        DEVMAN_FUN_GET_MATCH_ID,
    158174        DEVMAN_FUN_GET_NAME,
    159175        DEVMAN_FUN_GET_DRIVER_NAME,
    … …  
    161177        DEVMAN_FUN_OFFLINE,
    162178        DEVMAN_FUN_GET_PATH,
    163         DEVMAN_FUN_SID_TO_HANDLE
     179        DEVMAN_FUN_SID_TO_HANDLE,
     180        DEVMAN_GET_DRIVERS,
     181        DEVMAN_DRIVER_GET_DEVICES,
     182        DEVMAN_DRIVER_GET_HANDLE,
     183        DEVMAN_DRIVER_GET_MATCH_ID,
     184        DEVMAN_DRIVER_GET_NAME,
     185        DEVMAN_DRIVER_GET_STATE,
     186        DEVMAN_DRIVER_LOAD
    164187} client_to_devman_t;
    165188

  • uspace/lib/c/include/ipc/services.h

    rdd7078c r3f03199  
    5353} services_t;
    5454
     55#define SERVICE_NAME_CORECFG    "corecfg"
    5556#define SERVICE_NAME_DNSR       "net/dnsr"
    5657#define SERVICE_NAME_INET       "net/inet"

  • uspace/lib/c/include/ipc/socket.h

    rdd7078c r3f03199  
    198198#define SOCKET_GET_OPT_NAME(call) \
    199199        ({ \
    200                 int opt_name = (int) IPC_GET_ARG4(call); \
     200                int opt_name = (int) IPC_GET_ARG2(call); \
    201201                opt_name; \
    202202        })

  • uspace/lib/c/include/ipc/vfs.h

    rdd7078c r3f03199  
    8282        VFS_IN_WAIT_HANDLE,
    8383        VFS_IN_MTAB_GET,
     84        VFS_IN_STATFS
    8485} vfs_in_request_t;
    8586
    … …  
    9899        VFS_OUT_LOOKUP,
    99100        VFS_OUT_DESTROY,
     101        VFS_OUT_STATFS,
    100102        VFS_OUT_LAST
    101103} vfs_out_request_t;

  • uspace/lib/c/include/net/socket.h

    rdd7078c r3f03199  
    5757extern int connect(int, const struct sockaddr *, socklen_t);
    5858extern int closesocket(int);
    59 extern int send(int, void *, size_t, int);
     59extern int send(int, const void *, size_t, int);
    6060extern int sendto(int, const void *, size_t, int, const struct sockaddr *,
    6161    socklen_t);

  • uspace/lib/c/include/net/socket_codes.h

    rdd7078c r3f03199  
    7575typedef int32_t socklen_t;
    7676
     77/* Socket options */
     78
     79enum {
     80        SOL_SOCKET = 1,
     81
     82        /* IP link to transmit on */
     83        SO_IPLINK
     84};
     85
    7786#endif
    7887

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

    rdd7078c r3f03199  
    124124extern int vsnprintf(char *, size_t, const char *, va_list);
    125125
     126extern int printf_size(const char *, ...)
     127    PRINTF_ATTRIBUTE(1, 2);
     128extern int vprintf_size(const char *, va_list);
     129
    126130/* File stream functions */
    127131extern FILE *fopen(const char *, const char *);

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

    rdd7078c r3f03199  
    4444#include "vfs_mtab.h"
    4545
     46
    4647enum vfs_change_state_type {
    4748        VFS_PASS_HANDLE
    4849};
     50
    4951
    5052extern char *absolutize(const char *, size_t *);
    … …  
    6163extern async_exch_t *vfs_exchange_begin(void);
    6264extern void vfs_exchange_end(async_exch_t *);
    63 
    6465#endif
    6566
Note: See TracChangeset for help on using the changeset viewer.