Changeset dd0c8a0 in mainline for uspace/lib/c


Ignore:
Timestamp:
2013-09-29T06:56:33Z (13 years ago)
Author:
Beniamino Galvani <b.galvani@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a9bd960d
Parents:
3deb0155 (diff), 13be2583 (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
Files:
24 added
77 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/Makefile

    r3deb0155 rdd0c8a0  
    6161        generic/bd.c \
    6262        generic/bd_srv.c \
     63        generic/bitops.c \
    6364        generic/cap.c \
    6465        generic/cfg.c \
    6566        generic/clipboard.c \
     67        generic/corecfg.c \
    6668        generic/devman.c \
    6769        generic/device/hw_res.c \
    6870        generic/device/hw_res_parsed.c \
     71        generic/device/pio_window.c \
    6972        generic/device/char_dev.c \
    7073        generic/device/clock_dev.c \
    … …  
    7477        generic/device/pci.c \
    7578        generic/device/ahci.c \
     79        generic/dhcp.c \
     80        generic/dnsr.c \
    7681        generic/dlfcn.c \
    7782        generic/elf/elf_load.c \
    … …  
    9196        generic/task.c \
    9297        generic/futex.c \
     98        generic/inet/addr.c \
    9399        generic/inet.c \
    94100        generic/inetcfg.c \
    95101        generic/inetping.c \
     102        generic/inetping6.c \
    96103        generic/io/asprintf.c \
    97104        generic/io/input.c \
    … …  
    161168
    162169$(LIBC_PREFIX)/arch/$(UARCH)/_link.ld: $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld.in
    163         $(GCC) $(DEFS) $(CFLAGS) -DLIBC_PATH=$(CURDIR) -E -x c $< | grep -v "^\#" > $@
     170        $(CC) $(DEFS) $(CFLAGS) -DLIBC_PATH=$(CURDIR) -E -x c $< | grep -v "^\#" > $@
    164171
    165172$(LIBC_PREFIX)/arch/$(UARCH)/_link-loader.ld: $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld.in
    166         $(GCC) $(DEFS) $(CFLAGS) -DLIBC_PATH=$(CURDIR) -DLOADER -E -x c $< | grep -v "^\#" > $@
     173        $(CC) $(DEFS) $(CFLAGS) -DLIBC_PATH=$(CURDIR) -DLOADER -E -x c $< | grep -v "^\#" > $@
    167174
    168175$(LIBC_PREFIX)/arch/$(UARCH)/_link-shlib.ld: $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld.in
    169         $(GCC) $(DEFS) $(CFLAGS) -DLIBC_PATH=$(CURDIR) -DSHLIB -E -x c $< | grep -v "^\#" > $@
     176        $(CC) $(DEFS) $(CFLAGS) -DLIBC_PATH=$(CURDIR) -DSHLIB -E -x c $< | grep -v "^\#" > $@
    170177
    171178$(LIBC_PREFIX)/arch/$(UARCH)/_link-dlexe.ld: $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld.in
    172         $(GCC) $(DEFS) $(CFLAGS) -DLIBC_PATH=$(CURDIR) -DDLEXE -E -x c $< | grep -v "^\#" > $@
     179        $(CC) $(DEFS) $(CFLAGS) -DLIBC_PATH=$(CURDIR) -DDLEXE -E -x c $< | grep -v "^\#" > $@
    173180
    174181$(COMMON_HEADER_ARCH): $(COMMON_HEADER)

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

    r3deb0155 rdd0c8a0  
    2727#
    2828
    29 ifeq ($(COMPILER),clang)
    30         CLANG_ARCH = i386
    31 endif
    32 
    3329ENDIANESS = LE

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

    r3deb0155 rdd0c8a0  
    2727#
    2828
    29 CLANG_ARCH = x86_64
    3029GCC_CFLAGS += -fno-omit-frame-pointer
     30CLANG_CFLAGS += -fno-omit-frame-pointer
    3131
    3232ENDIANESS = LE

  • uspace/lib/c/arch/amd64/src/entry.s

    r3deb0155 rdd0c8a0  
    4242        #
    4343        pushq $0
     44        pushq $0
    4445        movq %rsp, %rbp
    4546       

  • uspace/lib/c/arch/amd64/src/entryjmp.s

    r3deb0155 rdd0c8a0  
    3636# Jump to program entry point
    3737entry_point_jmp:
     38        # use standard amd32 prologue not to confuse anybody
     39        push %rbp
     40        movq %rsp, %rbp
     41       
    3842        # pcb must be passed in %rdi, use %rdx as a scratch register
    3943        mov %rdi, %rdx
    4044        mov %rsi, %rdi
    41 
     45       
    4246        # jump to entry point
    4347        jmp %rdx

  • uspace/lib/c/arch/amd64/src/fibril.S

    r3deb0155 rdd0c8a0  
    4242        movq (%rsp), %rdx     # the caller's return %eip
    4343       
    44         # In %edi is passed 1st argument
     44        # in %edi is passed 1st argument
    4545        CONTEXT_SAVE_ARCH_CORE %rdi %rdx
    4646       
    47         # Save TLS
     47        # save TLS
    4848        movq %fs:0, %rax
    4949        movq %rax, OFFSET_TLS(%rdi)
    50                
    51         xorl %eax, %eax         # context_save returns 1
     50       
     51        xorl %eax, %eax       # context_save returns 1
    5252        incl %eax
    5353        ret
    54 
    5554
    5655## Restore current CPU context
    … …  
    6463       
    6564        movq %rdx,(%rsp)
    66 
     65       
    6766        # Set thread local storage
    68         movq OFFSET_TLS(%rdi), %rdi   # Set arg1 to TLS addr
    69         movl $1, %eax           # SYS_TLS_SET
     67        movq OFFSET_TLS(%rdi), %rdi  # Set arg1 to TLS addr
     68        movl $1, %eax                # SYS_TLS_SET
    7069        syscall
    71 
    72         xorl %eax, %eax         # context_restore returns 0
     70       
     71        xorl %eax, %eax              # context_restore returns 0
    7372        ret

  • uspace/lib/c/arch/amd64/src/thread_entry.s

    r3deb0155 rdd0c8a0  
    3939        #
    4040        pushq $0
     41        pushq $0
    4142        movq %rsp, %rbp
    42 
     43       
    4344        #
    4445        # RAX contains address of uarg

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

    r3deb0155 rdd0c8a0  
    2727#
    2828
    29 CLANG_ARCH = i386
    30 
    3129ifeq ($(PROCESSOR),i486)
    3230        GCC_CFLAGS += -march=i486 -fno-omit-frame-pointer
    … …  
    3432        GCC_CFLAGS += -march=pentium -fno-omit-frame-pointer
    3533endif
     34CLANG_CFLAGS += -fno-omit-frame-pointer
    3635
    3736ENDIANESS = LE

  • uspace/lib/c/arch/ia32/include/libarch/fibril.h

    r3deb0155 rdd0c8a0  
    4343 * panic sooner or later
    4444 */
    45 #define SP_DELTA  12
     45#define SP_DELTA  8
    4646
    4747#define context_set(c, _pc, stack, size, ptls) \

  • uspace/lib/c/arch/ia32/src/entry.S

    r3deb0155 rdd0c8a0  
    4747        # Do not set %gs, it contains descriptor that can see TLS
    4848       
    49 #ifndef PROCESSOR_i486 
     49#ifndef PROCESSOR_i486
    5050        # Detect the mechanism used for making syscalls
    5151        movl $(INTEL_CPUID_STANDARD), %eax
    … …  
    6262        #
    6363        pushl $0
     64        pushl $0
    6465        movl %esp, %ebp
    6566       

  • uspace/lib/c/arch/ia32/src/entryjmp.s

    r3deb0155 rdd0c8a0  
    3636        push %ebp
    3737        movl %esp, %ebp
    38 
     38       
    3939        # %eax := entry_point
    4040        movl 0x8(%ebp), %eax
    41 
     41       
    4242        # %edi := pcb
    4343        # pcb is passed to the entry point in %edi
    4444        mov 0xc(%ebp), %edi
    45 
     45       
    4646        # Save a tiny bit of stack space
    4747        pop %ebp
    48 
     48       
    4949        jmp *%eax

  • uspace/lib/c/arch/ia32/src/fibril.S

    r3deb0155 rdd0c8a0  
    3434.global context_restore
    3535
    36 
    3736## Save current CPU context
    3837#
    … …  
    4140#
    4241context_save:
    43         movl 0(%esp),%eax       # the caller's return %eip
    44         movl 4(%esp),%edx       # address of the context variable to save context to
    45 
    46                 # save registers to the context structure
     42        movl 0(%esp), %eax  # the caller's return %eip
     43        movl 4(%esp), %edx  # address of the context variable to save context to
     44       
     45        # save registers to the context structure
    4746        CONTEXT_SAVE_ARCH_CORE %edx %eax
    48 
    49         # Save TLS
     47       
     48        # save TLS
    5049        movl %gs:0, %eax
    5150        movl %eax, OFFSET_TLS(%edx)     # tls -> ctx->tls
    5251       
    53         xorl %eax,%eax          # context_save returns 1
     52        xorl %eax, %eax     # context_save returns 1
    5453        incl %eax
    5554        ret
    56 
    5755
    5856## Restore saved CPU context
    … …  
    6260#
    6361context_restore:
    64         movl 4(%esp),%eax       # address of the context variable to restore context from
    65 
    66                 # restore registers from the context structure
     62        movl 4(%esp), %eax  # address of the context variable to restore context from
     63       
     64        # restore registers from the context structure
    6765        CONTEXT_RESTORE_ARCH_CORE %eax %edx
    68 
    69         movl %edx,0(%esp)       # ctx->pc -> saver's return %eip
    70 
    71         # Set thread local storage
     66       
     67        movl %edx, 0(%esp)  # ctx->pc -> saver's return %eip
     68       
     69        # set thread local storage
    7270        pushl %edx
    73         movl OFFSET_TLS(%eax), %edx   # Set arg1 to TLS addr
    74         movl $1, %eax         # Syscall SYS_TLS_SET
     71        movl OFFSET_TLS(%eax), %edx  # Set arg1 to TLS addr
     72        movl $1, %eax                # Syscall SYS_TLS_SET
    7573        int $0x30
    7674        popl %edx
    7775       
    78         xorl %eax,%eax          # context_restore returns 0
     76        xorl %eax, %eax     # context_restore returns 0
    7977        ret

  • uspace/lib/c/arch/ia32/src/setjmp.S

    r3deb0155 rdd0c8a0  
    3535.type setjmp,@function
    3636setjmp:
    37         movl 0(%esp),%eax  # save pc value into eax
    38         movl 4(%esp),%edx  # address of the jmp_buf structure to save context to
     37        movl 0(%esp), %eax  # save pc value into eax
     38        movl 4(%esp), %edx  # address of the jmp_buf structure to save context to
    3939       
    4040        # save registers to the jmp_buf structure
    4141        CONTEXT_SAVE_ARCH_CORE %edx %eax
    4242       
    43         xorl %eax,%eax  # set_jmp returns 0
     43        xorl %eax, %eax     # set_jmp returns 0
    4444        ret
    4545
    … …  
    5252        CONTEXT_RESTORE_ARCH_CORE %ecx %edx
    5353       
    54         movl %edx,0(%esp)  # put saved pc on stack
     54        movl %edx, 0(%esp)  # put saved pc on stack
    5555        ret

  • uspace/lib/c/arch/ia32/src/thread_entry.s

    r3deb0155 rdd0c8a0  
    4040        mov %dx, %fs
    4141        # Do not set %gs, it contains descriptor that can see TLS
    42 
     42       
    4343        #
    4444        # Create the first stack frame.
    4545        #
    4646        pushl $0
     47        pushl $0
    4748        mov %esp, %ebp
    48 
     49       
    4950        #
    5051        # EAX contains address of uarg.

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

    r3deb0155 rdd0c8a0  
    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

    r3deb0155 rdd0c8a0  
    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

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

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

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

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

    r3deb0155 rdd0c8a0  
    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

    r3deb0155 rdd0c8a0  
    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

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

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

    r3deb0155 rdd0c8a0  
    3838#include <errno.h>
    3939
    40 static void hw_res_parse_add_irq(hw_res_list_parsed_t *out, hw_resource_t *res,
    41     int flags)
     40static void hw_res_parse_add_dma_channel(hw_res_list_parsed_t *out,
     41    const hw_resource_t *res, int flags)
     42{
     43        assert(res);
     44        assert((res->type == DMA_CHANNEL_8) || (res->type == DMA_CHANNEL_16));
     45       
     46        const unsigned channel = (res->type == DMA_CHANNEL_8) ?
     47            res->res.dma_channel.dma8 : res->res.dma_channel.dma16;
     48        const size_t count = out->dma_channels.count;
     49        const int keep_duplicit = flags & HW_RES_KEEP_DUPLICIT;
     50       
     51        if (!keep_duplicit) {
     52                for (size_t i = 0; i < count; ++i) {
     53                        if (out->dma_channels.channels[i] == channel)
     54                                return;
     55                }
     56        }
     57       
     58        out->dma_channels.channels[count] = channel;
     59        ++out->dma_channels.count;
     60}
     61
     62static void hw_res_parse_add_irq(hw_res_list_parsed_t *out,
     63    const hw_resource_t *res, int flags)
    4264{
    4365        assert(res && (res->type == INTERRUPT));
    … …  
    5880}
    5981
     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
    6098static void hw_res_parse_add_io_range(hw_res_list_parsed_t *out,
    61     hw_resource_t *res, int flags)
    62 {
     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
    63106        assert(res && (res->type == IO_RANGE));
    64107       
    65         uint64_t address = res->res.io_range.address;
    66         endianness_t endianness = res->res.io_range.endianness;
    67         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;
    68114       
    69115        if ((size == 0) && (!(flags & HW_RES_KEEP_ZERO_AREA)))
    … …  
    75121        if (!keep_duplicit) {
    76122                for (size_t i = 0; i < count; i++) {
    77                         uint64_t s_address = out->io_ranges.ranges[i].address;
    78                         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]);
    79128                       
    80                         if ((address == s_address) && (size == s_size))
    81                                 return;
    82                 }
    83         }
    84        
    85         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;
    86137        out->io_ranges.ranges[count].endianness = endianness;
    87         out->io_ranges.ranges[count].size = size;
    88138        out->io_ranges.count++;
    89139}
    90140
    91141static void hw_res_parse_add_mem_range(hw_res_list_parsed_t *out,
    92     hw_resource_t *res, int flags)
    93 {
     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       
    94149        assert(res && (res->type == MEM_RANGE));
    95150       
    96         uint64_t address = res->res.mem_range.address;
    97         endianness_t endianness = res->res.mem_range.endianness;
    98         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;
    99157       
    100158        if ((size == 0) && (!(flags & HW_RES_KEEP_ZERO_AREA)))
    … …  
    106164        if (!keep_duplicit) {
    107165                for (size_t i = 0; i < count; ++i) {
    108                         uint64_t s_address = out->mem_ranges.ranges[i].address;
    109                         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]);
    110171                       
    111                         if ((address == s_address) && (size == s_size))
    112                                 return;
    113                 }
    114         }
    115        
    116         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;
    117180        out->mem_ranges.ranges[count].endianness = endianness;
    118         out->mem_ranges.ranges[count].size = size;
    119181        out->mem_ranges.count++;
    120182}
    … …  
    122184/** Parse list of hardware resources
    123185 *
    124  * @param      hw_resources Original structure resource
    125  * @param[out] out          Output parsed resources
    126  * @param      flags        Flags of the parsing.
    127  *                          HW_RES_KEEP_ZERO_AREA for keeping
    128  *                          zero-size areas, HW_RES_KEEP_DUPLICITIES
    129  *                          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.
    130192 *
    131193 * @return EOK if succeed, error code otherwise.
    132194 *
    133195 */
    134 int hw_res_list_parse(hw_resource_list_t *hw_resources,
    135     hw_res_list_parsed_t *out, int flags)
    136 {
    137         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)
    138200                return EINVAL;
    139201       
    140         size_t res_count = hw_resources->count;
     202        size_t res_count = res->count;
    141203        hw_res_list_parsed_clean(out);
    142204       
    143         out->irqs.irqs = malloc(res_count * sizeof(int));
    144         out->io_ranges.ranges = malloc(res_count * sizeof(io_range_t));
    145         out->mem_ranges.ranges = malloc(res_count * sizeof(mem_range_t));
     205        out->irqs.irqs = calloc(res_count, sizeof(int));
     206        out->dma_channels.channels = calloc(res_count, sizeof(int));
     207        out->io_ranges.ranges = calloc(res_count, sizeof(io_range_t));
     208        out->mem_ranges.ranges = calloc(res_count, sizeof(mem_range_t));
     209        if (!out->irqs.irqs || !out->dma_channels.channels ||
     210            !out->io_ranges.ranges || !out->mem_ranges.ranges) {
     211                hw_res_list_parsed_clean(out);
     212                return ENOMEM;
     213        }
    146214       
    147215        for (size_t i = 0; i < res_count; ++i) {
    148                 hw_resource_t *resource = &(hw_resources->resources[i]);
     216                const hw_resource_t *resource = &res->resources[i];
    149217               
    150218                switch (resource->type) {
    … …  
    153221                        break;
    154222                case IO_RANGE:
    155                         hw_res_parse_add_io_range(out, resource, flags);
     223                        hw_res_parse_add_io_range(out, win, resource, flags);
    156224                        break;
    157225                case MEM_RANGE:
    158                         hw_res_parse_add_mem_range(out, resource, flags);
     226                        hw_res_parse_add_mem_range(out, win, resource, flags);
     227                        break;
     228                case DMA_CHANNEL_8:
     229                case DMA_CHANNEL_16:
     230                        hw_res_parse_add_dma_channel(out, resource, flags);
    159231                        break;
    160232                default:
     233                        hw_res_list_parsed_clean(out);
    161234                        return EINVAL;
    162235                }
    … …  
    183256    hw_res_list_parsed_t *hw_res_parsed, int flags)
    184257{
     258        pio_window_t pio_window;
     259        int rc;
     260
    185261        if (!hw_res_parsed)
    186262                return EBADMEM;
    … …  
    188264        hw_resource_list_t hw_resources;
    189265        hw_res_list_parsed_clean(hw_res_parsed);
    190         bzero(&hw_resources, sizeof(hw_resource_list_t));
    191        
    192         int rc = hw_res_get_resource_list(sess, &hw_resources);
     266        memset(&hw_resources, 0, sizeof(hw_resource_list_t));
     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);
    193273        if (rc != EOK)
    194274                return rc;
    195        
    196         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);
    197278        hw_res_clean_resource_list(&hw_resources);
    198279       

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

    r3deb0155 rdd0c8a0  
    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;
    … …  
    413409        sysarg_t dretval;
    414410       
    415         exch = devman_exchange_begin_blocking(LOC_PORT_CONSUMER);
     411        exch = devman_exchange_begin_blocking(DEVMAN_CLIENT);
    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

    r3deb0155 rdd0c8a0  
    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

    r3deb0155 rdd0c8a0  
    3030#include <assert.h>
    3131#include <errno.h>
     32#include <net/socket_codes.h>
    3233#include <inet/inet.h>
    3334#include <ipc/inet.h>
    … …  
    108109{
    109110        async_exch_t *exch = async_exchange_begin(inet_sess);
    110 
     111       
    111112        ipc_call_t answer;
    112         aid_t req = async_send_5(exch, INET_SEND, dgram->src.ipv4,
    113             dgram->dest.ipv4, dgram->tos, ttl, df, &answer);
    114         int rc = async_data_write_start(exch, dgram->data, dgram->size);
    115         async_exchange_end(exch);
    116 
    117         if (rc != EOK) {
    118                 async_forget(req);
    119                 return rc;
    120         }
    121 
     113        aid_t req = async_send_4(exch, INET_SEND, dgram->iplink, dgram->tos,
     114            ttl, df, &answer);
     115       
     116        int rc = async_data_write_start(exch, &dgram->src, sizeof(inet_addr_t));
     117        if (rc != EOK) {
     118                async_exchange_end(exch);
     119                async_forget(req);
     120                return rc;
     121        }
     122       
     123        rc = async_data_write_start(exch, &dgram->dest, sizeof(inet_addr_t));
     124        if (rc != EOK) {
     125                async_exchange_end(exch);
     126                async_forget(req);
     127                return rc;
     128        }
     129       
     130        rc = async_data_write_start(exch, dgram->data, dgram->size);
     131       
     132        async_exchange_end(exch);
     133       
     134        if (rc != EOK) {
     135                async_forget(req);
     136                return rc;
     137        }
     138       
    122139        sysarg_t retval;
    123140        async_wait_for(req, &retval);
    124         if (retval != EOK)
    125                 return retval;
    126 
    127         return EOK;
     141       
     142        return (int) retval;
    128143}
    129144
    130145int inet_get_srcaddr(inet_addr_t *remote, uint8_t tos, inet_addr_t *local)
    131146{
    132         sysarg_t local_addr;
    133         async_exch_t *exch = async_exchange_begin(inet_sess);
    134 
    135         int rc = async_req_2_1(exch, INET_GET_SRCADDR, remote->ipv4,
    136             tos, &local_addr);
    137         async_exchange_end(exch);
    138 
    139         if (rc != EOK)
    140                 return rc;
    141 
    142         local->ipv4 = local_addr;
    143         return EOK;
    144 }
    145 
    146 static void inet_ev_recv(ipc_callid_t callid, ipc_call_t *call)
    147 {
    148         int rc;
     147        async_exch_t *exch = async_exchange_begin(inet_sess);
     148       
     149        ipc_call_t answer;
     150        aid_t req = async_send_1(exch, INET_GET_SRCADDR, tos, &answer);
     151       
     152        int rc = async_data_write_start(exch, remote, sizeof(inet_addr_t));
     153        if (rc != EOK) {
     154                async_exchange_end(exch);
     155                async_forget(req);
     156                return rc;
     157        }
     158       
     159        rc = async_data_read_start(exch, local, sizeof(inet_addr_t));
     160       
     161        async_exchange_end(exch);
     162       
     163        if (rc != EOK) {
     164                async_forget(req);
     165                return rc;
     166        }
     167       
     168        sysarg_t retval;
     169        async_wait_for(req, &retval);
     170       
     171        return (int) retval;
     172}
     173
     174static void inet_ev_recv(ipc_callid_t iid, ipc_call_t *icall)
     175{
    149176        inet_dgram_t dgram;
    150 
    151         dgram.src.ipv4 = IPC_GET_ARG1(*call);
    152         dgram.dest.ipv4 = IPC_GET_ARG2(*call);
    153         dgram.tos = IPC_GET_ARG3(*call);
    154 
     177       
     178        dgram.tos = IPC_GET_ARG1(*icall);
     179       
     180        ipc_callid_t callid;
     181        size_t size;
     182        if (!async_data_write_receive(&callid, &size)) {
     183                async_answer_0(callid, EINVAL);
     184                async_answer_0(iid, EINVAL);
     185                return;
     186        }
     187       
     188        if (size != sizeof(inet_addr_t)) {
     189                async_answer_0(callid, EINVAL);
     190                async_answer_0(iid, EINVAL);
     191                return;
     192        }
     193       
     194        int rc = async_data_write_finalize(callid, &dgram.src, size);
     195        if (rc != EOK) {
     196                async_answer_0(callid, rc);
     197                async_answer_0(iid, rc);
     198                return;
     199        }
     200       
     201        if (!async_data_write_receive(&callid, &size)) {
     202                async_answer_0(callid, EINVAL);
     203                async_answer_0(iid, EINVAL);
     204                return;
     205        }
     206       
     207        if (size != sizeof(inet_addr_t)) {
     208                async_answer_0(callid, EINVAL);
     209                async_answer_0(iid, EINVAL);
     210                return;
     211        }
     212       
     213        rc = async_data_write_finalize(callid, &dgram.dest, size);
     214        if (rc != EOK) {
     215                async_answer_0(callid, rc);
     216                async_answer_0(iid, rc);
     217                return;
     218        }
     219       
    155220        rc = async_data_write_accept(&dgram.data, false, 0, 0, 0, &dgram.size);
    156221        if (rc != EOK) {
    157                 async_answer_0(callid, rc);
    158                 return;
    159         }
    160 
     222                async_answer_0(iid, rc);
     223                return;
     224        }
     225       
    161226        rc = inet_ev_ops->recv(&dgram);
    162         async_answer_0(callid, rc);
     227        async_answer_0(iid, rc);
    163228}
    164229
    … …  
    168233                ipc_call_t call;
    169234                ipc_callid_t callid = async_get_call(&call);
    170 
     235               
    171236                if (!IPC_GET_IMETHOD(call)) {
    172237                        /* TODO: Handle hangup */
    173238                        return;
    174239                }
    175 
     240               
    176241                switch (IPC_GET_IMETHOD(call)) {
    177242                case INET_EV_RECV:

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

    r3deb0155 rdd0c8a0  
    137137{
    138138        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    139 
    140         ipc_call_t answer;
    141         aid_t req = async_send_3(exch, INETCFG_ADDR_CREATE_STATIC, naddr->ipv4,
    142             naddr->bits, link_id, &answer);
     139       
     140        ipc_call_t answer;
     141        aid_t req = async_send_1(exch, INETCFG_ADDR_CREATE_STATIC, link_id,
     142            &answer);
     143       
     144        int rc = async_data_write_start(exch, naddr, sizeof(inet_naddr_t));
     145        if (rc != EOK) {
     146                async_exchange_end(exch);
     147                async_forget(req);
     148                return rc;
     149        }
     150       
     151        rc = async_data_write_start(exch, name, str_size(name));
     152       
     153        async_exchange_end(exch);
     154       
     155        if (rc != EOK) {
     156                async_forget(req);
     157                return rc;
     158        }
     159       
     160        sysarg_t retval;
     161        async_wait_for(req, &retval);
     162       
     163        *addr_id = IPC_GET_ARG1(answer);
     164       
     165        return (int) retval;
     166}
     167
     168int inetcfg_addr_delete(sysarg_t addr_id)
     169{
     170        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     171
     172        int rc = async_req_1_0(exch, INETCFG_ADDR_DELETE, addr_id);
     173        async_exchange_end(exch);
     174
     175        return rc;
     176}
     177
     178int inetcfg_addr_get(sysarg_t addr_id, inet_addr_info_t *ainfo)
     179{
     180        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     181       
     182        ipc_call_t answer;
     183        aid_t req = async_send_1(exch, INETCFG_ADDR_GET, addr_id, &answer);
     184       
     185        ipc_call_t answer_naddr;
     186        aid_t req_naddr = async_data_read(exch, &ainfo->naddr,
     187            sizeof(inet_naddr_t), &answer_naddr);
     188       
     189        sysarg_t retval_naddr;
     190        async_wait_for(req_naddr, &retval_naddr);
     191       
     192        if (retval_naddr != EOK) {
     193                async_exchange_end(exch);
     194                async_forget(req);
     195                return (int) retval_naddr;
     196        }
     197       
     198        ipc_call_t answer_name;
     199        char name_buf[LOC_NAME_MAXLEN + 1];
     200        aid_t req_name = async_data_read(exch, name_buf, LOC_NAME_MAXLEN,
     201            &answer_name);
     202       
     203        async_exchange_end(exch);
     204       
     205        sysarg_t retval_name;
     206        async_wait_for(req_name, &retval_name);
     207       
     208        if (retval_name != EOK) {
     209                async_forget(req);
     210                return (int) retval_name;
     211        }
     212       
     213        sysarg_t retval;
     214        async_wait_for(req, &retval);
     215       
     216        if (retval != EOK)
     217                return (int) retval;
     218       
     219        size_t act_size = IPC_GET_ARG2(answer_name);
     220        assert(act_size <= LOC_NAME_MAXLEN);
     221       
     222        name_buf[act_size] = '\0';
     223       
     224        ainfo->ilink = IPC_GET_ARG1(answer);
     225        ainfo->name = str_dup(name_buf);
     226       
     227        return EOK;
     228}
     229
     230int inetcfg_addr_get_id(const char *name, sysarg_t link_id, sysarg_t *addr_id)
     231{
     232        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     233
     234        ipc_call_t answer;
     235        aid_t req = async_send_1(exch, INETCFG_ADDR_GET_ID, link_id, &answer);
    143236        sysarg_t retval = async_data_write_start(exch, name, str_size(name));
    144237
    … …  
    156249}
    157250
    158 int inetcfg_addr_delete(sysarg_t addr_id)
    159 {
    160         async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    161 
    162         int rc = async_req_1_0(exch, INETCFG_ADDR_DELETE, addr_id);
     251int inetcfg_get_addr_list(sysarg_t **addrs, size_t *count)
     252{
     253        return inetcfg_get_ids_internal(INETCFG_GET_ADDR_LIST,
     254            0, addrs, count);
     255}
     256
     257int inetcfg_get_link_list(sysarg_t **links, size_t *count)
     258{
     259        return inetcfg_get_ids_internal(INETCFG_GET_LINK_LIST,
     260            0, links, count);
     261}
     262
     263int inetcfg_get_sroute_list(sysarg_t **sroutes, size_t *count)
     264{
     265        return inetcfg_get_ids_internal(INETCFG_GET_SROUTE_LIST,
     266            0, sroutes, count);
     267}
     268
     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);
    163274        async_exchange_end(exch);
    164275
    … …  
    166277}
    167278
    168 int inetcfg_addr_get(sysarg_t addr_id, inet_addr_info_t *ainfo)
     279int inetcfg_link_get(sysarg_t link_id, inet_link_info_t *linfo)
    169280{
    170281        ipc_call_t dreply;
    … …  
    176287
    177288        ipc_call_t answer;
    178         aid_t req = async_send_1(exch, INETCFG_ADDR_GET, addr_id, &answer);
     289        aid_t req = async_send_1(exch, INETCFG_LINK_GET, link_id, &answer);
    179290        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));
    180292        async_wait_for(dreq, &dretval);
    181293
    182294        async_exchange_end(exch);
    183295
    184         if (dretval != EOK) {
     296        if (dretval != EOK || rc != EOK) {
    185297                async_forget(req);
    186298                return dretval;
    … …  
    197309        name_buf[act_size] = '\0';
    198310
    199         ainfo->naddr.ipv4 = IPC_GET_ARG1(answer);
    200         ainfo->naddr.bits = IPC_GET_ARG2(answer);
    201         ainfo->ilink = IPC_GET_ARG3(answer);
    202         ainfo->name = str_dup(name_buf);
    203 
    204         return EOK;
    205 }
    206 
    207 int inetcfg_addr_get_id(const char *name, sysarg_t link_id, sysarg_t *addr_id)
    208 {
    209         async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    210 
    211         ipc_call_t answer;
    212         aid_t req = async_send_1(exch, INETCFG_ADDR_GET_ID, link_id, &answer);
    213         sysarg_t retval = async_data_write_start(exch, name, str_size(name));
    214 
    215         async_exchange_end(exch);
    216 
    217         if (retval != EOK) {
    218                 async_forget(req);
    219                 return retval;
    220         }
    221 
    222         async_wait_for(req, &retval);
    223         *addr_id = IPC_GET_ARG1(answer);
    224 
    225         return retval;
    226 }
    227 
    228 int inetcfg_get_addr_list(sysarg_t **addrs, size_t *count)
    229 {
    230         return inetcfg_get_ids_internal(INETCFG_GET_ADDR_LIST,
    231             0, addrs, count);
    232 }
    233 
    234 int inetcfg_get_link_list(sysarg_t **links, size_t *count)
    235 {
    236         return inetcfg_get_ids_internal(INETCFG_GET_LINK_LIST,
    237             0, links, count);
    238 }
    239 
    240 int inetcfg_get_sroute_list(sysarg_t **sroutes, size_t *count)
    241 {
    242         return inetcfg_get_ids_internal(INETCFG_GET_SROUTE_LIST,
    243             0, sroutes, count);
    244 }
    245 
    246 int inetcfg_link_get(sysarg_t link_id, inet_link_info_t *linfo)
    247 {
    248         ipc_call_t dreply;
    249         sysarg_t dretval;
    250         size_t act_size;
    251         char name_buf[LOC_NAME_MAXLEN + 1];
    252 
    253         async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    254 
    255         ipc_call_t answer;
    256         aid_t req = async_send_1(exch, INETCFG_LINK_GET, link_id, &answer);
    257         aid_t dreq = async_data_read(exch, name_buf, LOC_NAME_MAXLEN, &dreply);
    258         async_wait_for(dreq, &dretval);
    259 
    260         async_exchange_end(exch);
    261 
    262         if (dretval != EOK) {
    263                 async_forget(req);
    264                 return dretval;
    265         }
    266 
    267         sysarg_t retval;
    268         async_wait_for(req, &retval);
    269 
    270         if (retval != EOK)
    271                 return retval;
    272 
    273         act_size = IPC_GET_ARG2(dreply);
    274         assert(act_size <= LOC_NAME_MAXLEN);
    275         name_buf[act_size] = '\0';
    276 
    277311        linfo->name = str_dup(name_buf);
    278312        linfo->def_mtu = IPC_GET_ARG1(answer);
    … …  
    281315}
    282316
     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;
     325}
     326
    283327int inetcfg_sroute_create(const char *name, inet_naddr_t *dest,
    284328    inet_addr_t *router, sysarg_t *sroute_id)
    285329{
    286330        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    287 
    288         ipc_call_t answer;
    289         aid_t req = async_send_3(exch, INETCFG_SROUTE_CREATE,
    290             dest->ipv4, dest->bits, router->ipv4, &answer);
    291         sysarg_t retval = async_data_write_start(exch, name, str_size(name));
    292 
    293         async_exchange_end(exch);
    294 
    295         if (retval != EOK) {
    296                 async_forget(req);
    297                 return retval;
    298         }
    299 
    300         async_wait_for(req, &retval);
     331       
     332        ipc_call_t answer;
     333        aid_t req = async_send_0(exch, INETCFG_SROUTE_CREATE, &answer);
     334       
     335        int rc = async_data_write_start(exch, dest, sizeof(inet_naddr_t));
     336        if (rc != EOK) {
     337                async_exchange_end(exch);
     338                async_forget(req);
     339                return rc;
     340        }
     341       
     342        rc = async_data_write_start(exch, router, sizeof(inet_addr_t));
     343        if (rc != EOK) {
     344                async_exchange_end(exch);
     345                async_forget(req);
     346                return rc;
     347        }
     348       
     349        rc = async_data_write_start(exch, name, str_size(name));
     350       
     351        async_exchange_end(exch);
     352       
     353        if (rc != EOK) {
     354                async_forget(req);
     355                return rc;
     356        }
     357       
     358        sysarg_t retval;
     359        async_wait_for(req, &retval);
     360       
    301361        *sroute_id = IPC_GET_ARG1(answer);
    302 
    303         return retval;
     362       
     363        return (int) retval;
    304364}
    305365
    … …  
    316376int inetcfg_sroute_get(sysarg_t sroute_id, inet_sroute_info_t *srinfo)
    317377{
    318         ipc_call_t dreply;
    319         sysarg_t dretval;
    320         size_t act_size;
     378        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     379       
     380        ipc_call_t answer;
     381        aid_t req = async_send_1(exch, INETCFG_SROUTE_GET, sroute_id, &answer);
     382       
     383        ipc_call_t answer_dest;
     384        aid_t req_dest = async_data_read(exch, &srinfo->dest,
     385            sizeof(inet_naddr_t), &answer_dest);
     386       
     387        sysarg_t retval_dest;
     388        async_wait_for(req_dest, &retval_dest);
     389       
     390        if (retval_dest != EOK) {
     391                async_exchange_end(exch);
     392                async_forget(req);
     393                return (int) retval_dest;
     394        }
     395       
     396        ipc_call_t answer_router;
     397        aid_t req_router = async_data_read(exch, &srinfo->router,
     398            sizeof(inet_addr_t), &answer_router);
     399       
     400        sysarg_t retval_router;
     401        async_wait_for(req_router, &retval_router);
     402       
     403        if (retval_router != EOK) {
     404                async_exchange_end(exch);
     405                async_forget(req);
     406                return (int) retval_router;
     407        }
     408       
     409        ipc_call_t answer_name;
    321410        char name_buf[LOC_NAME_MAXLEN + 1];
    322 
    323         async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    324 
    325         ipc_call_t answer;
    326         aid_t req = async_send_1(exch, INETCFG_SROUTE_GET, sroute_id, &answer);
    327         aid_t dreq = async_data_read(exch, name_buf, LOC_NAME_MAXLEN, &dreply);
    328         async_wait_for(dreq, &dretval);
    329 
    330         async_exchange_end(exch);
    331 
    332         if (dretval != EOK) {
    333                 async_forget(req);
    334                 return dretval;
    335         }
    336 
    337         sysarg_t retval;
    338         async_wait_for(req, &retval);
    339 
     411        aid_t req_name = async_data_read(exch, name_buf, LOC_NAME_MAXLEN,
     412            &answer_name);
     413       
     414        async_exchange_end(exch);
     415       
     416        sysarg_t retval_name;
     417        async_wait_for(req_name, &retval_name);
     418       
     419        if (retval_name != EOK) {
     420                async_forget(req);
     421                return (int) retval_name;
     422        }
     423       
     424        sysarg_t retval;
     425        async_wait_for(req, &retval);
     426       
    340427        if (retval != EOK)
    341                 return retval;
    342 
    343         act_size = IPC_GET_ARG2(dreply);
     428                return (int) retval;
     429       
     430        size_t act_size = IPC_GET_ARG2(answer_name);
    344431        assert(act_size <= LOC_NAME_MAXLEN);
     432       
    345433        name_buf[act_size] = '\0';
    346 
    347         srinfo->dest.ipv4 = IPC_GET_ARG1(answer);
    348         srinfo->dest.bits = IPC_GET_ARG2(answer);
    349         srinfo->router.ipv4 = IPC_GET_ARG3(answer);
     434       
    350435        srinfo->name = str_dup(name_buf);
    351 
     436       
    352437        return EOK;
    353438}

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

    r3deb0155 rdd0c8a0  
    7979{
    8080        async_exch_t *exch = async_exchange_begin(inetping_sess);
    81 
     81       
    8282        ipc_call_t answer;
    83         aid_t req = async_send_3(exch, INETPING_SEND, sdu->src.ipv4,
    84             sdu->dest.ipv4, sdu->seq_no, &answer);
     83        aid_t req = async_send_3(exch, INETPING_SEND, (sysarg_t) sdu->src,
     84            (sysarg_t) sdu->dest, sdu->seq_no, &answer);
    8585        sysarg_t retval = async_data_write_start(exch, sdu->data, sdu->size);
    86 
     86       
    8787        async_exchange_end(exch);
    88 
     88       
    8989        if (retval != EOK) {
    9090                async_forget(req);
    9191                return retval;
    9292        }
    93 
     93       
    9494        async_wait_for(req, &retval);
    9595        return retval;
    9696}
    9797
    98 int inetping_get_srcaddr(inet_addr_t *remote, inet_addr_t *local)
     98int inetping_get_srcaddr(uint32_t remote, uint32_t *local)
    9999{
     100        async_exch_t *exch = async_exchange_begin(inetping_sess);
     101       
    100102        sysarg_t local_addr;
    101         async_exch_t *exch = async_exchange_begin(inetping_sess);
    102 
    103         int rc = async_req_1_1(exch, INETPING_GET_SRCADDR, remote->ipv4,
     103        int rc = async_req_1_1(exch, INETPING_GET_SRCADDR, (sysarg_t) remote,
    104104            &local_addr);
     105       
    105106        async_exchange_end(exch);
    106 
     107       
    107108        if (rc != EOK)
    108109                return rc;
    109 
    110         local->ipv4 = local_addr;
     110       
     111        *local = (uint32_t) local_addr;
    111112        return EOK;
    112113}
    … …  
    114115static void inetping_ev_recv(ipc_callid_t callid, ipc_call_t *call)
    115116{
    116         int rc;
    117117        inetping_sdu_t sdu;
    118 
    119         sdu.src.ipv4 = IPC_GET_ARG1(*call);
    120         sdu.dest.ipv4 = IPC_GET_ARG2(*call);
     118       
     119        sdu.src = IPC_GET_ARG1(*call);
     120        sdu.dest = IPC_GET_ARG2(*call);
    121121        sdu.seq_no = IPC_GET_ARG3(*call);
    122 
    123         rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
     122       
     123        int rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
    124124        if (rc != EOK) {
    125125                async_answer_0(callid, rc);
    126126                return;
    127127        }
    128 
     128       
    129129        rc = inetping_ev_ops->recv(&sdu);
    130130        free(sdu.data);

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

    r3deb0155 rdd0c8a0  
    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/io/con_srv.c

    r3deb0155 rdd0c8a0  
    3535 */
    3636#include <errno.h>
     37#include <io/cons_event.h>
    3738#include <ipc/console.h>
    3839#include <stdlib.h>
    … …  
    4041
    4142#include <io/con_srv.h>
     43
     44static int console_ev_encode(cons_event_t *event, ipc_call_t *call)
     45{
     46        IPC_SET_ARG1(*call, event->type);
     47
     48        switch (event->type) {
     49        case CEV_KEY:
     50                IPC_SET_ARG2(*call, event->ev.key.type);
     51                IPC_SET_ARG3(*call, event->ev.key.key);
     52                IPC_SET_ARG4(*call, event->ev.key.mods);
     53                IPC_SET_ARG5(*call, event->ev.key.c);
     54                break;
     55        case CEV_POS:
     56                IPC_SET_ARG2(*call, (event->ev.pos.pos_id << 16) | (event->ev.pos.type & 0xffff));
     57                IPC_SET_ARG3(*call, event->ev.pos.btn_num);
     58                IPC_SET_ARG4(*call, event->ev.pos.hpos);
     59                IPC_SET_ARG5(*call, event->ev.pos.vpos);
     60                break;
     61        default:
     62                return EIO;
     63        }
     64
     65        return EOK;
     66}
    4267
    4368static void con_read_srv(con_srv_t *srv, ipc_callid_t callid,
    … …  
    273298{
    274299        int rc;
    275         kbd_event_t event;
     300        cons_event_t event;
     301        ipc_call_t result;
    276302
    277303        if (srv->srvs->ops->get_event == NULL) {
    … …  
    281307
    282308        rc = srv->srvs->ops->get_event(srv, &event);
    283         async_answer_4(callid, rc, event.type, event.key, event.mods, event.c);
     309        if (rc != EOK) {
     310                async_answer_0(callid, rc);
     311                return;
     312        }
     313
     314        rc = console_ev_encode(&event, &result);
     315        if (rc != EOK) {
     316                async_answer_0(callid, rc);
     317                return;
     318        }
     319
     320        async_answer_5(callid, rc, IPC_GET_ARG1(result), IPC_GET_ARG2(result),
     321            IPC_GET_ARG3(result), IPC_GET_ARG4(result), IPC_GET_ARG5(result));
    284322}
    285323

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

    r3deb0155 rdd0c8a0  
    154154}
    155155
    156 bool console_get_kbd_event(console_ctrl_t *ctrl, kbd_event_t *event)
     156static int console_ev_decode(ipc_call_t *call, cons_event_t *event)
     157{
     158        event->type = IPC_GET_ARG1(*call);
     159
     160        switch (event->type) {
     161        case CEV_KEY:
     162                event->ev.key.type = IPC_GET_ARG2(*call);
     163                event->ev.key.key = IPC_GET_ARG3(*call);
     164                event->ev.key.mods = IPC_GET_ARG4(*call);
     165                event->ev.key.c = IPC_GET_ARG5(*call);
     166                break;
     167        case CEV_POS:
     168                event->ev.pos.pos_id = IPC_GET_ARG2(*call) >> 16;
     169                event->ev.pos.type = IPC_GET_ARG2(*call) & 0xffff;
     170                event->ev.pos.btn_num = IPC_GET_ARG3(*call);
     171                event->ev.pos.hpos = IPC_GET_ARG4(*call);
     172                event->ev.pos.vpos = IPC_GET_ARG5(*call);
     173                break;
     174        default:
     175                return EIO;
     176        }
     177
     178        return EOK;
     179}
     180
     181bool console_get_event(console_ctrl_t *ctrl, cons_event_t *event)
    157182{
    158183        if (ctrl->input_aid == 0) {
    159                 sysarg_t type;
    160                 sysarg_t key;
    161                 sysarg_t mods;
    162                 sysarg_t c;
     184                ipc_call_t result;
    163185               
    164186                async_exch_t *exch = async_exchange_begin(ctrl->input_sess);
    165                 int rc = async_req_0_4(exch, CONSOLE_GET_EVENT, &type, &key, &mods, &c);
     187                aid_t aid = async_send_0(exch, CONSOLE_GET_EVENT, &result);
    166188                async_exchange_end(exch);
     189               
     190                sysarg_t rc;
     191                async_wait_for(aid, &rc);
    167192               
    168193                if (rc != EOK) {
    … …  
    171196                }
    172197               
    173                 event->type = type;
    174                 event->key = key;
    175                 event->mods = mods;
    176                 event->c = c;
     198                rc = console_ev_decode(&result, event);
     199                if (rc != EOK) {
     200                        errno = rc;
     201                        return false;
     202                }
    177203        } else {
    178204                sysarg_t retval;
    … …  
    186212                }
    187213               
    188                 event->type = IPC_GET_ARG1(ctrl->input_call);
    189                 event->key = IPC_GET_ARG2(ctrl->input_call);
    190                 event->mods = IPC_GET_ARG3(ctrl->input_call);
    191                 event->c = IPC_GET_ARG4(ctrl->input_call);
     214                int rc = console_ev_decode(&ctrl->input_call, event);
     215                if (rc != EOK) {
     216                        errno = rc;
     217                        return false;
     218                }
    192219        }
    193220       
    … …  
    195222}
    196223
    197 bool console_get_kbd_event_timeout(console_ctrl_t *ctrl, kbd_event_t *event,
     224bool console_get_event_timeout(console_ctrl_t *ctrl, cons_event_t *event,
    198225    suseconds_t *timeout)
    199226{
    … …  
    223250        }
    224251       
    225         event->type = IPC_GET_ARG1(ctrl->input_call);
    226         event->key = IPC_GET_ARG2(ctrl->input_call);
    227         event->mods = IPC_GET_ARG3(ctrl->input_call);
    228         event->c = IPC_GET_ARG4(ctrl->input_call);
     252        rc = console_ev_decode(&ctrl->input_call, event);
     253        if (rc != EOK) {
     254                errno = rc;
     255                return false;
     256        }
    229257       
    230258        /* Update timeout */

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

    r3deb0155 rdd0c8a0  
    192192}
    193193
     194/** Set stream buffer.
     195 *
     196 * When @p buf is NULL, the stream is set as unbuffered, otherwise
     197 * full buffering is enabled.
     198 */
     199void setbuf(FILE *stream, void *buf)
     200{
     201        if (buf == NULL) {
     202                setvbuf(stream, NULL, _IONBF, BUFSIZ);
     203        } else {
     204                setvbuf(stream, buf, _IOFBF, BUFSIZ);
     205        }
     206}
     207
    194208static void _setvbuf(FILE *stream)
    195209{

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

    r3deb0155 rdd0c8a0  
    3939#include <errno.h>
    4040#include <inet/iplink.h>
     41#include <inet/addr.h>
    4142#include <ipc/iplink.h>
    4243#include <ipc/services.h>
    … …  
    8384{
    8485        async_exch_t *exch = async_exchange_begin(iplink->sess);
    85 
    86         ipc_call_t answer;
    87         aid_t req = async_send_2(exch, IPLINK_SEND, sdu->lsrc.ipv4,
    88             sdu->ldest.ipv4, &answer);
     86       
     87        ipc_call_t answer;
     88        aid_t req = async_send_2(exch, IPLINK_SEND, (sysarg_t) sdu->src,
     89            (sysarg_t) sdu->dest, &answer);
     90       
    8991        int rc = async_data_write_start(exch, sdu->data, sdu->size);
    90         async_exchange_end(exch);
    91 
    92         if (rc != EOK) {
    93                 async_forget(req);
    94                 return rc;
    95         }
    96 
    97         sysarg_t retval;
    98         async_wait_for(req, &retval);
    99         if (retval != EOK)
    100                 return retval;
    101 
    102         return EOK;
     92       
     93        async_exchange_end(exch);
     94       
     95        if (rc != EOK) {
     96                async_forget(req);
     97                return rc;
     98        }
     99       
     100        sysarg_t retval;
     101        async_wait_for(req, &retval);
     102       
     103        return (int) retval;
     104}
     105
     106int iplink_send6(iplink_t *iplink, iplink_sdu6_t *sdu)
     107{
     108        async_exch_t *exch = async_exchange_begin(iplink->sess);
     109       
     110        ipc_call_t answer;
     111        aid_t req = async_send_0(exch, IPLINK_SEND6, &answer);
     112       
     113        int rc = async_data_write_start(exch, &sdu->dest, sizeof(addr48_t));
     114        if (rc != EOK) {
     115                async_exchange_end(exch);
     116                async_forget(req);
     117                return rc;
     118        }
     119       
     120        rc = async_data_write_start(exch, sdu->data, sdu->size);
     121       
     122        async_exchange_end(exch);
     123       
     124        if (rc != EOK) {
     125                async_forget(req);
     126                return rc;
     127        }
     128       
     129        sysarg_t retval;
     130        async_wait_for(req, &retval);
     131       
     132        return (int) retval;
    103133}
    104134
    105135int iplink_get_mtu(iplink_t *iplink, size_t *rmtu)
    106136{
     137        async_exch_t *exch = async_exchange_begin(iplink->sess);
     138       
    107139        sysarg_t mtu;
    108         async_exch_t *exch = async_exchange_begin(iplink->sess);
    109 
    110140        int rc = async_req_0_1(exch, IPLINK_GET_MTU, &mtu);
    111         async_exchange_end(exch);
    112 
     141       
     142        async_exchange_end(exch);
     143       
    113144        if (rc != EOK)
    114145                return rc;
    115 
     146       
    116147        *rmtu = mtu;
    117148        return EOK;
    118149}
    119150
    120 int iplink_addr_add(iplink_t *iplink, iplink_addr_t *addr)
    121 {
    122         async_exch_t *exch = async_exchange_begin(iplink->sess);
    123 
    124         int rc = async_req_1_0(exch, IPLINK_ADDR_ADD, (sysarg_t)addr->ipv4);
    125         async_exchange_end(exch);
    126 
    127         return rc;
    128 }
    129 
    130 int iplink_addr_remove(iplink_t *iplink, iplink_addr_t *addr)
    131 {
    132         async_exch_t *exch = async_exchange_begin(iplink->sess);
    133 
    134         int rc = async_req_1_0(exch, IPLINK_ADDR_REMOVE, (sysarg_t)addr->ipv4);
    135         async_exchange_end(exch);
    136 
    137         return rc;
    138 }
    139 
    140 static void iplink_ev_recv(iplink_t *iplink, ipc_callid_t callid,
    141     ipc_call_t *call)
    142 {
    143         int rc;
    144         iplink_sdu_t sdu;
    145 
    146         sdu.lsrc.ipv4 = IPC_GET_ARG1(*call);
    147         sdu.ldest.ipv4 = IPC_GET_ARG2(*call);
    148 
    149         rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
    150         if (rc != EOK) {
    151                 async_answer_0(callid, rc);
     151int iplink_get_mac48(iplink_t *iplink, addr48_t *mac)
     152{
     153        async_exch_t *exch = async_exchange_begin(iplink->sess);
     154       
     155        ipc_call_t answer;
     156        aid_t req = async_send_0(exch, IPLINK_GET_MAC48, &answer);
     157       
     158        int rc = async_data_read_start(exch, mac, sizeof(addr48_t));
     159       
     160        loc_exchange_end(exch);
     161       
     162        if (rc != EOK) {
     163                async_forget(req);
     164                return rc;
     165        }
     166       
     167        sysarg_t retval;
     168        async_wait_for(req, &retval);
     169       
     170        return (int) retval;
     171}
     172
     173int iplink_addr_add(iplink_t *iplink, inet_addr_t *addr)
     174{
     175        async_exch_t *exch = async_exchange_begin(iplink->sess);
     176       
     177        ipc_call_t answer;
     178        aid_t req = async_send_0(exch, IPLINK_ADDR_ADD, &answer);
     179       
     180        int rc = async_data_write_start(exch, addr, sizeof(inet_addr_t));
     181        async_exchange_end(exch);
     182       
     183        if (rc != EOK) {
     184                async_forget(req);
     185                return rc;
     186        }
     187       
     188        sysarg_t retval;
     189        async_wait_for(req, &retval);
     190       
     191        return (int) retval;
     192}
     193
     194int iplink_addr_remove(iplink_t *iplink, inet_addr_t *addr)
     195{
     196        async_exch_t *exch = async_exchange_begin(iplink->sess);
     197       
     198        ipc_call_t answer;
     199        aid_t req = async_send_0(exch, IPLINK_ADDR_REMOVE, &answer);
     200       
     201        int rc = async_data_write_start(exch, addr, sizeof(inet_addr_t));
     202        async_exchange_end(exch);
     203       
     204        if (rc != EOK) {
     205                async_forget(req);
     206                return rc;
     207        }
     208       
     209        sysarg_t retval;
     210        async_wait_for(req, &retval);
     211       
     212        return (int) retval;
     213}
     214
     215static void iplink_ev_recv(iplink_t *iplink, ipc_callid_t iid,
     216    ipc_call_t *icall)
     217{
     218        iplink_recv_sdu_t sdu;
     219       
     220        uint16_t af = IPC_GET_ARG1(*icall);
     221       
     222        int rc = async_data_write_accept(&sdu.data, false, 0, 0, 0,
     223            &sdu.size);
     224        if (rc != EOK) {
     225                async_answer_0(iid, rc);
    152226                return;
    153227        }
    154 
    155         rc = iplink->ev_ops->recv(iplink, &sdu);
     228       
     229        rc = iplink->ev_ops->recv(iplink, &sdu, af);
    156230        free(sdu.data);
    157         async_answer_0(callid, rc);
     231        async_answer_0(iid, rc);
    158232}
    159233
    160234static void iplink_cb_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    161235{
    162         iplink_t *iplink = (iplink_t *)arg;
    163 
     236        iplink_t *iplink = (iplink_t *) arg;
     237       
    164238        while (true) {
    165239                ipc_call_t call;
    166240                ipc_callid_t callid = async_get_call(&call);
    167 
     241               
    168242                if (!IPC_GET_IMETHOD(call)) {
    169243                        /* TODO: Handle hangup */
    170244                        return;
    171245                }
    172 
     246               
    173247                switch (IPC_GET_IMETHOD(call)) {
    174248                case IPLINK_EV_RECV:

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

    r3deb0155 rdd0c8a0  
    3434 * @brief IP link server stub
    3535 */
     36
    3637#include <errno.h>
    3738#include <ipc/iplink.h>
    3839#include <stdlib.h>
    3940#include <sys/types.h>
    40 
     41#include <inet/addr.h>
    4142#include <inet/iplink_srv.h>
    4243
    … …  
    4445    ipc_call_t *call)
    4546{
    46         int rc;
    4747        size_t mtu;
    48 
    49         rc = srv->ops->get_mtu(srv, &mtu);
     48        int rc = srv->ops->get_mtu(srv, &mtu);
    5049        async_answer_1(callid, rc, mtu);
    5150}
    5251
    53 static void iplink_addr_add_srv(iplink_srv_t *srv, ipc_callid_t callid,
    54     ipc_call_t *call)
    55 {
    56         int rc;
    57         iplink_srv_addr_t addr;
    58 
    59         addr.ipv4 = IPC_GET_ARG1(*call);
    60 
     52static void iplink_get_mac48_srv(iplink_srv_t *srv, ipc_callid_t iid,
     53    ipc_call_t *icall)
     54{
     55        addr48_t mac;
     56        int rc = srv->ops->get_mac48(srv, &mac);
     57        if (rc != EOK) {
     58                async_answer_0(iid, rc);
     59                return;
     60        }
     61       
     62        ipc_callid_t callid;
     63        size_t size;
     64        if (!async_data_read_receive(&callid, &size)) {
     65                async_answer_0(callid, EREFUSED);
     66                async_answer_0(iid, EREFUSED);
     67                return;
     68        }
     69       
     70        if (size != sizeof(addr48_t)) {
     71                async_answer_0(callid, EINVAL);
     72                async_answer_0(iid, EINVAL);
     73                return;
     74        }
     75       
     76        rc = async_data_read_finalize(callid, &mac, size);
     77        if (rc != EOK)
     78                async_answer_0(callid, rc);
     79       
     80        async_answer_0(iid, (sysarg_t) rc);
     81}
     82
     83static void iplink_addr_add_srv(iplink_srv_t *srv, ipc_callid_t iid,
     84    ipc_call_t *icall)
     85{
     86        ipc_callid_t callid;
     87        size_t size;
     88        if (!async_data_write_receive(&callid, &size)) {
     89                async_answer_0(callid, EREFUSED);
     90                async_answer_0(iid, EREFUSED);
     91                return;
     92        }
     93       
     94        if (size != sizeof(inet_addr_t)) {
     95                async_answer_0(callid, EINVAL);
     96                async_answer_0(iid, EINVAL);
     97                return;
     98        }
     99       
     100        inet_addr_t addr;
     101        int rc = async_data_write_finalize(callid, &addr, size);
     102        if (rc != EOK) {
     103                async_answer_0(callid, (sysarg_t) rc);
     104                async_answer_0(iid, (sysarg_t) rc);
     105        }
     106       
    61107        rc = srv->ops->addr_add(srv, &addr);
    62         async_answer_0(callid, rc);
    63 }
    64 
    65 static void iplink_addr_remove_srv(iplink_srv_t *srv, ipc_callid_t callid,
    66     ipc_call_t *call)
    67 {
    68         int rc;
    69         iplink_srv_addr_t addr;
    70 
    71         addr.ipv4 = IPC_GET_ARG1(*call);
    72 
     108        async_answer_0(iid, (sysarg_t) rc);
     109}
     110
     111static void iplink_addr_remove_srv(iplink_srv_t *srv, ipc_callid_t iid,
     112    ipc_call_t *icall)
     113{
     114        ipc_callid_t callid;
     115        size_t size;
     116        if (!async_data_write_receive(&callid, &size)) {
     117                async_answer_0(callid, EREFUSED);
     118                async_answer_0(iid, EREFUSED);
     119                return;
     120        }
     121       
     122        if (size != sizeof(inet_addr_t)) {
     123                async_answer_0(callid, EINVAL);
     124                async_answer_0(iid, EINVAL);
     125                return;
     126        }
     127       
     128        inet_addr_t addr;
     129        int rc = async_data_write_finalize(callid, &addr, size);
     130        if (rc != EOK) {
     131                async_answer_0(callid, (sysarg_t) rc);
     132                async_answer_0(iid, (sysarg_t) rc);
     133        }
     134       
    73135        rc = srv->ops->addr_remove(srv, &addr);
    74         async_answer_0(callid, rc);
    75 }
    76 
    77 static void iplink_send_srv(iplink_srv_t *srv, ipc_callid_t callid,
    78     ipc_call_t *call)
    79 {
    80         iplink_srv_sdu_t sdu;
    81         int rc;
    82 
    83         sdu.lsrc.ipv4 = IPC_GET_ARG1(*call);
    84         sdu.ldest.ipv4 = IPC_GET_ARG2(*call);
    85 
    86         rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
    87         if (rc != EOK) {
    88                 async_answer_0(callid, rc);
    89                 return;
    90         }
    91 
     136        async_answer_0(iid, (sysarg_t) rc);
     137}
     138
     139static void iplink_send_srv(iplink_srv_t *srv, ipc_callid_t iid,
     140    ipc_call_t *icall)
     141{
     142        iplink_sdu_t sdu;
     143       
     144        sdu.src = IPC_GET_ARG1(*icall);
     145        sdu.dest = IPC_GET_ARG2(*icall);
     146       
     147        int rc = async_data_write_accept(&sdu.data, false, 0, 0, 0,
     148            &sdu.size);
     149        if (rc != EOK) {
     150                async_answer_0(iid, rc);
     151                return;
     152        }
     153       
    92154        rc = srv->ops->send(srv, &sdu);
    93155        free(sdu.data);
    94         async_answer_0(callid, rc);
     156        async_answer_0(iid, rc);
     157}
     158
     159static void iplink_send6_srv(iplink_srv_t *srv, ipc_callid_t iid,
     160    ipc_call_t *icall)
     161{
     162        iplink_sdu6_t sdu;
     163       
     164        ipc_callid_t callid;
     165        size_t size;
     166        if (!async_data_write_receive(&callid, &size)) {
     167                async_answer_0(callid, EREFUSED);
     168                async_answer_0(iid, EREFUSED);
     169                return;
     170        }
     171       
     172        if (size != sizeof(addr48_t)) {
     173                async_answer_0(callid, EINVAL);
     174                async_answer_0(iid, EINVAL);
     175                return;
     176        }
     177       
     178        int rc = async_data_write_finalize(callid, &sdu.dest, size);
     179        if (rc != EOK) {
     180                async_answer_0(callid, (sysarg_t) rc);
     181                async_answer_0(iid, (sysarg_t) rc);
     182        }
     183       
     184        rc = async_data_write_accept(&sdu.data, false, 0, 0, 0,
     185            &sdu.size);
     186        if (rc != EOK) {
     187                async_answer_0(iid, rc);
     188                return;
     189        }
     190       
     191        rc = srv->ops->send6(srv, &sdu);
     192        free(sdu.data);
     193        async_answer_0(iid, rc);
    95194}
    96195
    … …  
    106205int iplink_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    107206{
    108         iplink_srv_t *srv = (iplink_srv_t *)arg;
     207        iplink_srv_t *srv = (iplink_srv_t *) arg;
    109208        int rc;
    110 
     209       
    111210        fibril_mutex_lock(&srv->lock);
    112211        if (srv->connected) {
    … …  
    115214                return EBUSY;
    116215        }
    117 
     216       
    118217        srv->connected = true;
    119218        fibril_mutex_unlock(&srv->lock);
    120 
     219       
    121220        /* Accept the connection */
    122221        async_answer_0(iid, EOK);
    123 
     222       
    124223        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
    125224        if (sess == NULL)
    126225                return ENOMEM;
    127 
     226       
    128227        srv->client_sess = sess;
    129 
     228       
    130229        rc = srv->ops->open(srv);
    131230        if (rc != EOK)
    132231                return rc;
    133 
     232       
    134233        while (true) {
    135234                ipc_call_t call;
    136235                ipc_callid_t callid = async_get_call(&call);
    137236                sysarg_t method = IPC_GET_IMETHOD(call);
    138 
     237               
    139238                if (!method) {
    140239                        /* The other side has hung up */
    141                         fibril_mutex_lock(&srv->lock);
     240                        fibril_mutex_lock(&srv->lock);
    142241                        srv->connected = false;
    143                         fibril_mutex_unlock(&srv->lock);
     242                        fibril_mutex_unlock(&srv->lock);
    144243                        async_answer_0(callid, EOK);
    145244                        break;
    146245                }
    147 
     246               
    148247                switch (method) {
    149248                case IPLINK_GET_MTU:
    150249                        iplink_get_mtu_srv(srv, callid, &call);
    151250                        break;
     251                case IPLINK_GET_MAC48:
     252                        iplink_get_mac48_srv(srv, callid, &call);
     253                        break;
    152254                case IPLINK_SEND:
    153255                        iplink_send_srv(srv, callid, &call);
     256                        break;
     257                case IPLINK_SEND6:
     258                        iplink_send6_srv(srv, callid, &call);
    154259                        break;
    155260                case IPLINK_ADDR_ADD:
    … …  
    163268                }
    164269        }
    165 
     270       
    166271        return srv->ops->close(srv);
    167272}
    168273
    169 int iplink_ev_recv(iplink_srv_t *srv, iplink_srv_sdu_t *sdu)
     274int iplink_ev_recv(iplink_srv_t *srv, iplink_recv_sdu_t *sdu, uint16_t af)
    170275{
    171276        if (srv->client_sess == NULL)
    172277                return EIO;
    173 
     278       
    174279        async_exch_t *exch = async_exchange_begin(srv->client_sess);
    175 
     280       
    176281        ipc_call_t answer;
    177         aid_t req = async_send_2(exch, IPLINK_EV_RECV, sdu->lsrc.ipv4,
    178             sdu->ldest.ipv4, &answer);
     282        aid_t req = async_send_1(exch, IPLINK_EV_RECV, (sysarg_t) af,
     283            &answer);
     284       
    179285        int rc = async_data_write_start(exch, sdu->data, sdu->size);
    180286        async_exchange_end(exch);
    181 
     287       
    182288        if (rc != EOK) {
    183289                async_forget(req);
    184290                return rc;
    185291        }
    186 
     292       
    187293        sysarg_t retval;
    188294        async_wait_for(req, &retval);
    189295        if (retval != EOK)
    190296                return retval;
    191 
     297       
    192298        return EOK;
    193299}

  • uspace/lib/c/generic/mem.c

    r3deb0155 rdd0c8a0  
    224224 * @param s1  Pointer to the first area to compare.
    225225 * @param s2  Pointer to the second area to compare.
    226  * @param len Size of the first area in bytes. Both areas must have
    227  *            the same length.
    228  *
    229  * @return If len is 0, return zero. If the areas match, return
    230  *         zero. Otherwise return non-zero.
    231  *
    232  */
    233 int bcmp(const void *s1, const void *s2, size_t len)
     226 * @param len Size of the areas in bytes.
     227 *
     228 * @return Zero if areas have the same contents. If they differ,
     229 *         the sign of the result is the same as the sign of the
     230 *         difference of the first pair of different bytes.
     231 *
     232 */
     233int memcmp(const void *s1, const void *s2, size_t len)
    234234{
    235235        uint8_t *u1 = (uint8_t *) s1;
    236236        uint8_t *u2 = (uint8_t *) s2;
    237        
    238         for (; (len != 0) && (*u1++ == *u2++); len--);
    239        
    240         return len;
     237        size_t i;
     238
     239        for (i = 0; i < len; i++) {
     240                if (*u1 != *u2)
     241                        return (int)(*u1) - (int)(*u2);
     242                ++u1;
     243                ++u2;
     244        }
     245
     246        return 0;
    241247}
    242248

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

    r3deb0155 rdd0c8a0  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2013 Martin Decky
    33 * All rights reserved.
    44 *
    … …  
    3939#include <net/in6.h>
    4040#include <net/inet.h>
    41 
     41#include <inet/addr.h>
    4242#include <errno.h>
    4343#include <mem.h>
    … …  
    4545#include <str.h>
    4646
     47const in6_addr_t in6addr_any = {
     48        { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
     49};
     50
     51static int inet_ntop4(const uint8_t *data, char *address, size_t length)
     52{
     53        /* Check output buffer size */
     54        if (length < INET_ADDRSTRLEN)
     55                return ENOMEM;
     56       
     57        /* Fill buffer with IPv4 address */
     58        snprintf(address, length,
     59            "%" PRIu8 ".%" PRIu8 ".%" PRIu8 ".%" PRIu8,
     60            data[0], data[1], data[2], data[3]);
     61       
     62        return EOK;
     63}
     64
     65static int inet_ntop6(const uint8_t *data, char *address, size_t length)
     66{
     67        /* Check output buffer size */
     68        if (length < INET6_ADDRSTRLEN)
     69                return ENOMEM;
     70       
     71        /* Find the longest zero subsequence */
     72       
     73        uint16_t zeroes[8];
     74        uint16_t bioctets[8];
     75       
     76        for (size_t i = 8; i > 0; i--) {
     77                size_t j = i - 1;
     78               
     79                bioctets[j] = (data[j << 1] << 8) | data[(j << 1) + 1];
     80               
     81                if (bioctets[j] == 0) {
     82                        zeroes[j] = 1;
     83                        if (j < 7)
     84                                zeroes[j] += zeroes[j + 1];
     85                } else
     86                        zeroes[j] = 0;
     87        }
     88       
     89        size_t wildcard_pos = (size_t) -1;
     90        size_t wildcard_size = 0;
     91       
     92        for (size_t i = 0; i < 8; i++) {
     93                if (zeroes[i] > wildcard_size) {
     94                        wildcard_pos = i;
     95                        wildcard_size = zeroes[i];
     96                }
     97        }
     98       
     99        char *cur = address;
     100        size_t rest = length;
     101        bool tail_zero = false;
     102        int ret;
     103       
     104        for (size_t i = 0; i < 8; i++) {
     105                if ((i == wildcard_pos) && (wildcard_size > 1)) {
     106                        ret = snprintf(cur, rest, ":");
     107                        i += wildcard_size - 1;
     108                        tail_zero = true;
     109                } else if (i == 0) {
     110                        ret = snprintf(cur, rest, "%" PRIx16, bioctets[i]);
     111                        tail_zero = false;
     112                } else {
     113                        ret = snprintf(cur, rest, ":%" PRIx16, bioctets[i]);
     114                        tail_zero = false;
     115                }
     116               
     117                if (ret < 0)
     118                        return EINVAL;
     119               
     120                cur += ret;
     121                rest -= ret;
     122        }
     123       
     124        if (tail_zero) {
     125                ret = snprintf(cur, rest, ":");
     126                if (ret < 0)
     127                        return EINVAL;
     128        }
     129       
     130        return EOK;
     131}
     132
    47133/** Prints the address into the character buffer.
    48134 *
    49  *  @param[in] family   The address family.
    50  *  @param[in] data     The address data.
    51  *  @param[out] address The character buffer to be filled.
    52  *  @param[in] length   The buffer length.
    53  *  @return             EOK on success.
    54  *  @return             EINVAL if the data or address parameter is NULL.
    55  *  @return             ENOMEM if the character buffer is not long enough.
    56  *  @return             ENOTSUP if the address family is not supported.
    57  */
    58 int
    59 inet_ntop(uint16_t family, const uint8_t *data, char *address, size_t length)
    60 {
    61         if ((!data) || (!address))
    62                 return EINVAL;
    63 
     135 * @param[in]  family  Address family.
     136 * @param[in]  data    Address data.
     137 * @param[out] address Character buffer to be filled.
     138 * @param[in]  length  Buffer length.
     139 *
     140 * @return EOK on success.
     141 * @return EINVAL if the data or address parameter is NULL.
     142 * @return ENOMEM if the character buffer is not long enough.
     143 * @return ENOTSUP if the address family is not supported.
     144 *
     145 */
     146int inet_ntop(uint16_t family, const uint8_t *data, char *address, size_t length)
     147{
    64148        switch (family) {
    65149        case AF_INET:
    66                 /* Check output buffer size */
    67                 if (length < INET_ADDRSTRLEN)
    68                         return ENOMEM;
    69                        
    70                 /* Fill buffer with IPv4 address */
    71                 snprintf(address, length, "%hhu.%hhu.%hhu.%hhu",
    72                     data[0], data[1], data[2], data[3]);
    73 
    74                 return EOK;
    75 
     150                return inet_ntop4(data, address, length);
    76151        case AF_INET6:
    77                 /* Check output buffer size */
    78                 if (length < INET6_ADDRSTRLEN)
    79                         return ENOMEM;
    80                
    81                 /* Fill buffer with IPv6 address */
    82                 snprintf(address, length,
    83                     "%hhx%hhx:%hhx%hhx:%hhx%hhx:%hhx%hhx:%hhx%hhx:%hhx%hhx:"
    84                     "%hhx%hhx:%hhx%hhx",
    85                     data[0], data[1], data[2], data[3], data[4], data[5],
    86                     data[6], data[7], data[8], data[9], data[10], data[11],
    87                     data[12], data[13], data[14], data[15]);
    88                
    89                 return EOK;
    90 
     152                return inet_ntop6(data, address, length);
    91153        default:
    92154                return ENOTSUP;
    … …  
    94156}
    95157
     158static int inet_pton4(const char *address, uint8_t *data)
     159{
     160        memset(data, 0, 4);
     161       
     162        const char *cur = address;
     163        size_t i = 0;
     164       
     165        while (i < 4) {
     166                int rc = str_uint8_t(cur, &cur, 10, false, &data[i]);
     167                if (rc != EOK)
     168                        return rc;
     169               
     170                i++;
     171               
     172                if (*cur == 0)
     173                        break;
     174               
     175                if (*cur != '.')
     176                        return EINVAL;
     177               
     178                if (i < 4)
     179                        cur++;
     180        }
     181       
     182        if ((i == 4) && (*cur != 0))
     183                return EINVAL;
     184       
     185        return EOK;
     186}
     187
     188static int inet_pton6(const char *address, uint8_t *data)
     189{
     190        memset(data, 0, 16);
     191       
     192        const char *cur = address;
     193        size_t i = 0;
     194        size_t wildcard_pos = (size_t) -1;
     195        size_t wildcard_size = 0;
     196       
     197        /* Handle initial wildcard */
     198        if ((address[0] == ':') && (address[1] == ':')) {
     199                cur = address + 2;
     200                wildcard_pos = 0;
     201                wildcard_size = 16;
     202               
     203                /* Handle empty address */
     204                if (*cur == 0)
     205                        return EOK;
     206        }
     207       
     208        while (i < 16) {
     209                uint16_t bioctet;
     210                int rc = str_uint16_t(cur, &cur, 16, false, &bioctet);
     211                if (rc != EOK)
     212                        return rc;
     213               
     214                data[i] = (bioctet >> 8) & 0xff;
     215                data[i + 1] = bioctet & 0xff;
     216               
     217                if (wildcard_pos != (size_t) -1) {
     218                        if (wildcard_size < 2)
     219                                return EINVAL;
     220                       
     221                        wildcard_size -= 2;
     222                }
     223               
     224                i += 2;
     225               
     226                if (*cur == 0)
     227                        break;
     228               
     229                if (*cur != ':')
     230                        return EINVAL;
     231               
     232                if (i < 16) {
     233                        cur++;
     234                       
     235                        /* Handle wildcard */
     236                        if (*cur == ':') {
     237                                if (wildcard_pos != (size_t) -1)
     238                                        return EINVAL;
     239                               
     240                                wildcard_pos = i;
     241                                wildcard_size = 16 - i;
     242                                cur++;
     243                               
     244                                if (*cur == 0)
     245                                        break;
     246                        }
     247                }
     248        }
     249       
     250        if ((i == 16) && (*cur != 0))
     251                return EINVAL;
     252       
     253        /* Create wildcard positions */
     254        if ((wildcard_pos != (size_t) -1) && (wildcard_size > 0)) {
     255                size_t wildcard_shift = 16 - wildcard_size;
     256               
     257                for (i = wildcard_pos + wildcard_shift; i > wildcard_pos; i--) {
     258                        size_t j = i - 1;
     259                        data[j + wildcard_size] = data[j];
     260                        data[j] = 0;
     261                }
     262        }
     263       
     264        return EOK;
     265}
     266
    96267/** Parses the character string into the address.
    97268 *
    98  *  If the string is shorter than the full address, zero bytes are added.
    99  *
    100  *  @param[in] family   The address family.
    101  *  @param[in] address  The character buffer to be parsed.
    102  *  @param[out] data    The address data to be filled.
    103  *  @return             EOK on success.
    104  *  @return             EINVAL if the data parameter is NULL.
    105  *  @return             ENOENT if the address parameter is NULL.
    106  *  @return             ENOTSUP if the address family is not supported.
     269 * @param[in]  family  The address family.
     270 * @param[in]  address The character buffer to be parsed.
     271 * @param[out] data    The address data to be filled.
     272 *
     273 * @return EOK on success.
     274 * @return EINVAL if the data parameter is NULL.
     275 * @return ENOENT if the address parameter is NULL.
     276 * @return ENOTSUP if the address family is not supported.
     277 *
    107278 */
    108279int inet_pton(uint16_t family, const char *address, uint8_t *data)
    109280{
    110         /** The base number of the values. */
    111         int base;
    112         /** The number of bytes per a section. */
    113         size_t bytes;
    114         /** The number of bytes of the address data. */
    115         int count;
    116 
    117         const char *next;
    118         char *last;
    119         int index;
    120         size_t shift;
    121         unsigned long value;
    122 
    123         if (!data)
    124                 return EINVAL;
    125 
    126         /* Set processing parameters */
    127281        switch (family) {
    128282        case AF_INET:
    129                 count = 4;
    130                 base = 10;
    131                 bytes = 1;
    132                 break;
    133 
     283                return inet_pton4(address, data);
    134284        case AF_INET6:
    135                 count = 16;
    136                 base = 16;
    137                 bytes = 4;
    138                 break;
    139 
     285                return inet_pton6(address, data);
    140286        default:
     287                /** Unknown address family */
    141288                return ENOTSUP;
    142289        }
    143 
    144         /* Erase if no address */
    145         if (!address) {
    146                 bzero(data, count);
    147                 return ENOENT;
    148         }
    149 
    150         /* Process string from the beginning */
    151         next = address;
    152         index = 0;
    153         do {
    154                 /* If the actual character is set */
    155                 if (next && *next) {
    156 
    157                         /* If not on the first character */
    158                         if (index) {
    159                                 /* Move to the next character */
    160                                 ++next;
    161                         }
    162 
    163                         /* Parse the actual integral value */
    164                         value = strtoul(next, &last, base);
    165                         /*
    166                          * Remember the last problematic character
    167                          * should be either '.' or ':' but is ignored to be
    168                          * more generic
    169                          */
    170                         next = last;
    171 
    172                         /* Fill the address data byte by byte */
    173                         shift = bytes - 1;
    174                         do {
    175                                 /* like little endian */
    176                                 data[index + shift] = value;
    177                                 value >>= 8;
    178                         } while(shift --);
    179 
    180                         index += bytes;
    181                 } else {
    182                         /* Erase the rest of the address */
    183                         bzero(data + index, count - index);
    184                         return EOK;
    185                 }
    186         } while (index < count);
    187 
    188         return EOK;
    189290}
    190291

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

    r3deb0155 rdd0c8a0  
    8787        /** Parent module service. */
    8888        services_t service;
     89        /** Socket family */
     90        int family;
    8991
    9092        /**
    … …  
    395397        switch (domain) {
    396398        case PF_INET:
     399        case PF_INET6:
    397400                switch (type) {
    398401                case SOCK_STREAM:
    … …  
    433436                break;
    434437
    435         case PF_INET6:
    436438        default:
    437439                return EPFNOSUPPORT;
    … …  
    446448                return ENOMEM;
    447449
    448         bzero(socket, sizeof(*socket));
     450        memset(socket, 0, sizeof(*socket));
     451        socket->family = domain;
    449452        fibril_rwlock_write_lock(&socket_globals.lock);
    450453
    … …  
    657660                return ENOMEM;
    658661        }
    659         bzero(new_socket, sizeof(*new_socket));
     662        memset(new_socket, 0, sizeof(*new_socket));
    660663        socket_id = socket_generate_new_id();
    661664        if (socket_id <= 0) {
    … …  
    920923 *                      message.
    921924 */
    922 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)
    923926{
    924927        /* Without the address */

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

    r3deb0155 rdd0c8a0  
    5353int socket_parse_address_family(const char *name, int *af)
    5454{
    55         if (str_lcmp(name, "AF_INET", 7) == 0) {
    56                 *af = AF_INET;
     55        if (str_lcmp(name, "AF_INET6", 8) == 0) {
     56                *af = AF_INET6;
    5757                return EOK;
    5858        }
    5959       
    60         if (str_lcmp(name, "AF_INET6", 8) == 0) {
    61                 *af = AF_INET6;
     60        if (str_lcmp(name, "AF_INET", 7) == 0) {
     61                *af = AF_INET;
    6262                return EOK;
    6363        }
    … …  
    7979int socket_parse_protocol_family(const char *name, int *pf)
    8080{
     81        if (str_lcmp(name, "PF_INET6", 8) == 0) {
     82                *pf = PF_INET6;
     83                return EOK;
     84        }
     85
    8186        if (str_lcmp(name, "PF_INET", 7) == 0) {
    8287                *pf = PF_INET;
    83                 return EOK;
    84         }
    85        
    86         if (str_lcmp(name, "PF_INET6", 8) == 0) {
    87                 *pf = PF_INET6;
    8888                return EOK;
    8989        }

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

    r3deb0155 rdd0c8a0  
    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/str.c

    r3deb0155 rdd0c8a0  
    15241524 *
    15251525 */
    1526 int str_uint8_t(const char *nptr, char **endptr, unsigned int base,
     1526int str_uint8_t(const char *nptr, const char **endptr, unsigned int base,
    15271527    bool strict, uint8_t *result)
    15281528{
    … …  
    15711571 *
    15721572 */
    1573 int str_uint16_t(const char *nptr, char **endptr, unsigned int base,
     1573int str_uint16_t(const char *nptr, const char **endptr, unsigned int base,
    15741574    bool strict, uint16_t *result)
    15751575{
    … …  
    16181618 *
    16191619 */
    1620 int str_uint32_t(const char *nptr, char **endptr, unsigned int base,
     1620int str_uint32_t(const char *nptr, const char **endptr, unsigned int base,
    16211621    bool strict, uint32_t *result)
    16221622{
    … …  
    16651665 *
    16661666 */
    1667 int str_uint64_t(const char *nptr, char **endptr, unsigned int base,
     1667int str_uint64_t(const char *nptr, const char **endptr, unsigned int base,
    16681668    bool strict, uint64_t *result)
    16691669{
    … …  
    17041704 *
    17051705 */
    1706 int str_size_t(const char *nptr, char **endptr, unsigned int base,
     1706int str_size_t(const char *nptr, const char **endptr, unsigned int base,
    17071707    bool strict, size_t *result)
    17081708{

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

    r3deb0155 rdd0c8a0  
    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

    r3deb0155 rdd0c8a0  
    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 *st)
     896{
     897        sysarg_t rc, rc_orig;
     898        aid_t req;
     899        size_t pa_size;
     900
     901        char *pa = absolutize(path, &pa_size);
     902        if (!pa)
     903                return ENOMEM;
     904
     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                goto exit;
     911
     912        rc = async_data_read_start(exch, (void *) st, sizeof(*st));
     913
     914exit:
     915        vfs_exchange_end(exch);
     916        free(pa);
     917        async_wait_for(req, &rc_orig);
     918        return (int) (rc_orig != EOK ? rc_orig : rc);
     919}
     920
    894921/** @}
    895922 */

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

    r3deb0155 rdd0c8a0  
    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/async.h

    r3deb0155 rdd0c8a0  
    399399extern int async_data_read_start(async_exch_t *, void *, size_t);
    400400extern bool async_data_read_receive(ipc_callid_t *, size_t *);
     401extern bool async_data_read_receive_call(ipc_callid_t *, ipc_call_t *, size_t *);
    401402extern int async_data_read_finalize(ipc_callid_t, const void *, size_t);
    402403
    … …  
    437438extern int async_data_write_start(async_exch_t *, const void *, size_t);
    438439extern bool async_data_write_receive(ipc_callid_t *, size_t *);
     440extern bool async_data_write_receive_call(ipc_callid_t *, ipc_call_t *, size_t *);
    439441extern int async_data_write_finalize(ipc_callid_t, void *, size_t);
    440442

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

    r3deb0155 rdd0c8a0  
    5757} bd_srv_t;
    5858
    59 typedef struct bd_ops {
     59struct bd_ops {
    6060        int (*open)(bd_srvs_t *, bd_srv_t *);
    6161        int (*close)(bd_srv_t *);
    … …  
    6565        int (*get_block_size)(bd_srv_t *, size_t *);
    6666        int (*get_num_blocks)(bd_srv_t *, aoff64_t *);
    67 } bd_ops_t;
     67};
    6868
    6969extern void bd_srvs_init(bd_srvs_t *);

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

    r3deb0155 rdd0c8a0  
    107107}
    108108
     109extern int __popcountsi2(int);
     110
    109111#endif
    110112

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

    r3deb0155 rdd0c8a0  
    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

    r3deb0155 rdd0c8a0  
    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

    r3deb0155 rdd0c8a0  
    5353        HW_RES_ENABLE_INTERRUPT,
    5454        HW_RES_DMA_CHANNEL_SETUP,
     55        HW_RES_DMA_CHANNEL_REMAIN,
    5556} hw_res_method_t;
    5657
    … …  
    7576                struct {
    7677                        uint64_t address;
     78                        size_t size;
     79                        bool relative;
    7780                        endianness_t endianness;
    78                         size_t size;
    7981                } mem_range;
    8082               
    8183                struct {
    8284                        uint64_t address;
     85                        size_t size;
     86                        bool relative;
    8387                        endianness_t endianness;
    84                         size_t size;
    8588                } io_range;
    8689               
    … …  
    115118
    116119extern int hw_res_dma_channel_setup(async_sess_t *, unsigned int, uint32_t,
    117     uint16_t, uint8_t);
     120    uint32_t, uint8_t);
     121extern int hw_res_dma_channel_remain(async_sess_t *, unsigned);
    118122
    119123#endif

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

    r3deb0155 rdd0c8a0  
    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
    … …  
    127142        free(list->dma_channels.channels);
    128143       
    129         bzero(list, sizeof(hw_res_list_parsed_t));
     144        memset(list, 0, sizeof(hw_res_list_parsed_t));
    130145}
    131146
    … …  
    136151static inline void hw_res_list_parsed_init(hw_res_list_parsed_t *list)
    137152{
    138         bzero(list, sizeof(hw_res_list_parsed_t));
     153        memset(list, 0, sizeof(hw_res_list_parsed_t));
    139154}
    140155
    141 extern int hw_res_list_parse(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);
    142158extern int hw_res_get_list_parsed(async_sess_t *, hw_res_list_parsed_t *, int);
    143159

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

    r3deb0155 rdd0c8a0  
    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/inet.h

    r3deb0155 rdd0c8a0  
    3636#define LIBC_INET_INET_H_
    3737
     38#include <inet/addr.h>
     39#include <ipc/loc.h>
    3840#include <sys/types.h>
    39 
    40 #define INET_TTL_MAX 255
    41 
    42 typedef struct {
    43         uint32_t ipv4;
    44 } inet_addr_t;
    45 
    46 typedef struct {
    47         inet_addr_t src;
    48         inet_addr_t dest;
    49         uint8_t tos;
    50         void *data;
    51         size_t size;
    52 } inet_dgram_t;
    53 
    54 typedef struct {
    55         int (*recv)(inet_dgram_t *);
    56 } inet_ev_ops_t;
    57 
    58 typedef enum {
    59         INET_DF = 1
    60 } inet_df_t;
     41#include <types/inet.h>
    6142
    6243extern int inet_init(uint8_t, inet_ev_ops_t *);

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

    r3deb0155 rdd0c8a0  
    3838#include <inet/inet.h>
    3939#include <sys/types.h>
    40 
    41 /** Network address */
    42 typedef struct {
    43         /** Address */
    44         uint32_t ipv4;
    45         /** Number of valid bits in @c ipv4 */
    46         int bits;
    47 } inet_naddr_t;
    48 
    49 /** Address object info */
    50 typedef struct {
    51         /** Network address */
    52         inet_naddr_t naddr;
    53         /** Link service ID */
    54         sysarg_t ilink;
    55         /** Address object name */
    56         char *name;
    57 } inet_addr_info_t;
    58 
    59 /** IP link info */
    60 typedef struct {
    61         /** Link service name */
    62         char *name;
    63         /** Default MTU */
    64         size_t def_mtu;
    65 } inet_link_info_t;
    66 
    67 /** Static route info */
    68 typedef struct {
    69         /** Destination network address */
    70         inet_naddr_t dest;
    71         /** Router address */
    72         inet_addr_t router;
    73         /** Static route name */
    74         char *name;
    75 } inet_sroute_info_t;
     40#include <types/inetcfg.h>
    7641
    7742extern int inetcfg_init(void);
    … …  
    8348extern int inetcfg_get_link_list(sysarg_t **, size_t *);
    8449extern int inetcfg_get_sroute_list(sysarg_t **, size_t *);
     50extern int inetcfg_link_add(sysarg_t);
    8551extern int inetcfg_link_get(sysarg_t, inet_link_info_t *);
     52extern int inetcfg_link_remove(sysarg_t);
    8653extern int inetcfg_sroute_get(sysarg_t, inet_sroute_info_t *);
    8754extern int inetcfg_sroute_get_id(const char *, sysarg_t *);

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

    r3deb0155 rdd0c8a0  
    3838#include <inet/inet.h>
    3939#include <sys/types.h>
    40 
    41 typedef struct {
    42         inet_addr_t src;
    43         inet_addr_t dest;
    44         uint16_t seq_no;
    45         void *data;
    46         size_t size;
    47 } inetping_sdu_t;
     40#include <types/inetping.h>
    4841
    4942typedef struct inetping_ev_ops {
    … …  
    5346extern int inetping_init(inetping_ev_ops_t *);
    5447extern int inetping_send(inetping_sdu_t *);
    55 extern int inetping_get_srcaddr(inet_addr_t *, inet_addr_t *);
    56 
     48extern int inetping_get_srcaddr(uint32_t, uint32_t *);
    5749
    5850#endif

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

    r3deb0155 rdd0c8a0  
    3838#include <async.h>
    3939#include <sys/types.h>
     40#include <inet/addr.h>
    4041
    4142struct iplink_ev_ops;
    … …  
    4647} iplink_t;
    4748
    48 typedef struct {
    49         uint32_t ipv4;
    50 } iplink_addr_t;
    51 
    52 /** IP link Service Data Unit */
     49/** IPv4 link Service Data Unit */
    5350typedef struct {
    5451        /** Local source address */
    55         iplink_addr_t lsrc;
     52        addr32_t src;
    5653        /** Local destination address */
    57         iplink_addr_t ldest;
     54        addr32_t dest;
    5855        /** Serialized IP packet */
    5956        void *data;
    … …  
    6259} iplink_sdu_t;
    6360
     61/** IPv6 link Service Data Unit */
     62typedef struct {
     63        /** Local MAC destination address */
     64        addr48_t dest;
     65        /** Serialized IP packet */
     66        void *data;
     67        /** Size of @c data in bytes */
     68        size_t size;
     69} iplink_sdu6_t;
     70
     71/** Internet link receive Service Data Unit */
     72typedef struct {
     73        /** Serialized datagram */
     74        void *data;
     75        /** Size of @c data in bytes */
     76        size_t size;
     77} iplink_recv_sdu_t;
     78
    6479typedef struct iplink_ev_ops {
    65         int (*recv)(iplink_t *, iplink_sdu_t *);
     80        int (*recv)(iplink_t *, iplink_recv_sdu_t *, uint16_t);
    6681} iplink_ev_ops_t;
    6782
    … …  
    6984extern void iplink_close(iplink_t *);
    7085extern int iplink_send(iplink_t *, iplink_sdu_t *);
    71 extern int iplink_addr_add(iplink_t *, iplink_addr_t *);
    72 extern int iplink_addr_remove(iplink_t *, iplink_addr_t *);
     86extern int iplink_send6(iplink_t *, iplink_sdu6_t *);
     87extern int iplink_addr_add(iplink_t *, inet_addr_t *);
     88extern int iplink_addr_remove(iplink_t *, inet_addr_t *);
    7389extern int iplink_get_mtu(iplink_t *, size_t *);
     90extern int iplink_get_mac48(iplink_t *, addr48_t *);
    7491
    7592#endif

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

    r3deb0155 rdd0c8a0  
    4040#include <stdbool.h>
    4141#include <sys/types.h>
     42#include <inet/addr.h>
     43#include <inet/iplink.h>
    4244
    4345struct iplink_ops;
    … …  
    5153} iplink_srv_t;
    5254
    53 typedef struct {
    54         uint32_t ipv4;
    55 } iplink_srv_addr_t;
    56 
    57 /** IP link Service Data Unit */
    58 typedef struct {
    59         /** Local source address */
    60         iplink_srv_addr_t lsrc;
    61         /** Local destination address */
    62         iplink_srv_addr_t ldest;
    63         /** Serialized IP packet */
    64         void *data;
    65         /** Size of @c data in bytes */
    66         size_t size;
    67 } iplink_srv_sdu_t;
    68 
    6955typedef struct iplink_ops {
    7056        int (*open)(iplink_srv_t *);
    7157        int (*close)(iplink_srv_t *);
    72         int (*send)(iplink_srv_t *, iplink_srv_sdu_t *);
     58        int (*send)(iplink_srv_t *, iplink_sdu_t *);
     59        int (*send6)(iplink_srv_t *, iplink_sdu6_t *);
    7360        int (*get_mtu)(iplink_srv_t *, size_t *);
    74         int (*addr_add)(iplink_srv_t *, iplink_srv_addr_t *);
    75         int (*addr_remove)(iplink_srv_t *, iplink_srv_addr_t *);
     61        int (*get_mac48)(iplink_srv_t *, addr48_t *);
     62        int (*addr_add)(iplink_srv_t *, inet_addr_t *);
     63        int (*addr_remove)(iplink_srv_t *, inet_addr_t *);
    7664} iplink_ops_t;
    7765
    … …  
    7967
    8068extern int iplink_conn(ipc_callid_t, ipc_call_t *, void *);
    81 extern int iplink_ev_recv(iplink_srv_t *, iplink_srv_sdu_t *);
     69extern int iplink_ev_recv(iplink_srv_t *, iplink_recv_sdu_t *, uint16_t);
    8270
    8371#endif

  • uspace/lib/c/include/io/con_srv.h

    r3deb0155 rdd0c8a0  
    4141#include <io/color.h>
    4242#include <io/concaps.h>
    43 #include <io/kbd_event.h>
     43#include <io/cons_event.h>
    4444#include <io/pixel.h>
    4545#include <io/style.h>
    … …  
    6666} con_srv_t;
    6767
    68 typedef struct con_ops {
     68struct con_ops {
    6969        int (*open)(con_srvs_t *, con_srv_t *);
    7070        int (*close)(con_srv_t *);
    … …  
    8282        void (*set_rgb_color)(con_srv_t *, pixel_t, pixel_t);
    8383        void (*set_cursor_visibility)(con_srv_t *, bool);
    84         int (*get_event)(con_srv_t *, kbd_event_t *);
    85 } con_ops_t;
     84        int (*get_event)(con_srv_t *, cons_event_t *);
     85};
    8686
    8787extern void con_srvs_init(con_srvs_t *);

  • uspace/lib/c/include/io/console.h

    r3deb0155 rdd0c8a0  
    3939#include <io/concaps.h>
    4040#include <io/kbd_event.h>
     41#include <io/cons_event.h>
    4142#include <io/keycode.h>
    4243#include <async.h>
    … …  
    8283extern void console_cursor_visibility(console_ctrl_t *, bool);
    8384extern int console_get_color_cap(console_ctrl_t *, sysarg_t *);
    84 extern bool console_get_kbd_event(console_ctrl_t *, kbd_event_t *);
    85 extern bool console_get_kbd_event_timeout(console_ctrl_t *, kbd_event_t *,
     85extern bool console_get_event(console_ctrl_t *, cons_event_t *);
     86extern bool console_get_event_timeout(console_ctrl_t *, cons_event_t *,
    8687    suseconds_t *);
    8788

  • uspace/lib/c/include/io/verify.h

    r3deb0155 rdd0c8a0  
    3838#ifndef NVERIFY_PRINTF
    3939
     40#ifdef __clang__
     41#define PRINTF_ATTRIBUTE(start, end) \
     42        __attribute__((format(__printf__, start, end)))
     43#else
    4044#define PRINTF_ATTRIBUTE(start, end) \
    4145        __attribute__((format(gnu_printf, start, end)))
     46#endif
    4247
    4348#else /* NVERIFY_PRINTF */

  • uspace/lib/c/include/io/window.h

    r3deb0155 rdd0c8a0  
    4040#include <async.h>
    4141#include <loc.h>
    42 #include <io/console.h>
    43 
    44 typedef enum {
    45         POS_UPDATE,
    46         POS_PRESS,
    47         POS_RELEASE
    48 } pos_event_type_t;
    49 
    50 typedef struct {
    51         sysarg_t pos_id;
    52         pos_event_type_t type;
    53         sysarg_t btn_num;
    54         sysarg_t hpos;
    55         sysarg_t vpos;
    56 } pos_event_t;
     42#include <io/kbd_event.h>
     43#include <io/pos_event.h>
    5744
    5845typedef struct {

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

    r3deb0155 rdd0c8a0  
    3636typedef enum {
    3737        HW_RES_DEV_IFACE = 0,
     38        PIO_WINDOW_DEV_IFACE,
     39
    3840        /** Character device interface */
    3941        CHAR_DEV_IFACE,
    … …  
    4143        /** Graphic device interface */
    4244        GRAPH_DEV_IFACE,
     45
     46        /** Audio device mixer interface */
     47        AUDIO_MIXER_IFACE,
     48        /** Audio device pcm buffer interface */
     49        AUDIO_PCM_BUFFER_IFACE,
    4350       
    4451        /** Network interface controller interface */
    … …  
    5461        /** Interface provided by USB HID devices. */
    5562        USBHID_DEV_IFACE,
     63
    5664        /** Interface provided by Real Time Clock devices */
    5765        CLOCK_DEV_IFACE,
     66
    5867        /** Interface provided by battery powered devices */
    5968        BATTERY_DEV_IFACE,
     69
    6070        /** Interface provided by AHCI devices. */
    6171        AHCI_DEV_IFACE,

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

    r3deb0155 rdd0c8a0  
    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/inet.h

    r3deb0155 rdd0c8a0  
    4545        INET_PORT_CFG,
    4646        /** Ping service port */
    47         INET_PORT_PING
     47        INET_PORT_PING,
     48        /** Ping6 service port */
     49        INET_PORT_PING6
    4850} inet_port_t;
    4951
    … …  
    7072        INETCFG_GET_LINK_LIST,
    7173        INETCFG_GET_SROUTE_LIST,
     74        INETCFG_LINK_ADD,
    7275        INETCFG_LINK_GET,
     76        INETCFG_LINK_REMOVE,
    7377        INETCFG_SROUTE_CREATE,
    7478        INETCFG_SROUTE_DELETE,
    … …  
    8892} inetping_request_t;
    8993
     94/** Events on Inet ping6 port */
     95typedef enum {
     96        INETPING6_EV_RECV = IPC_FIRST_USER_METHOD
     97} inetping6_event_t;
     98
     99/** Requests on Inet ping6 port */
     100typedef enum {
     101        INETPING6_SEND = IPC_FIRST_USER_METHOD,
     102        INETPING6_GET_SRCADDR
     103} inetping6_request_t;
     104
    90105#endif
    91106

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

    r3deb0155 rdd0c8a0  
    4040typedef enum {
    4141        IPLINK_GET_MTU = IPC_FIRST_USER_METHOD,
     42        IPLINK_GET_MAC48,
    4243        IPLINK_SEND,
     44        IPLINK_SEND6,
    4345        IPLINK_ADDR_ADD,
    4446        IPLINK_ADDR_REMOVE

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

    r3deb0155 rdd0c8a0  
    5353} services_t;
    5454
    55 #define SERVICE_NAME_INET     "net/inet"
    56 #define SERVICE_NAME_INETCFG  "net/inetcfg"
    57 #define SERVICE_NAME_INETPING "net/inetping"
     55#define SERVICE_NAME_CORECFG    "corecfg"
     56#define SERVICE_NAME_DHCP       "net/dhcp"
     57#define SERVICE_NAME_DNSR       "net/dnsr"
     58#define SERVICE_NAME_INET       "net/inet"
     59#define SERVICE_NAME_INETCFG    "net/inetcfg"
     60#define SERVICE_NAME_INETPING   "net/inetping"
     61#define SERVICE_NAME_INETPING6  "net/inetping6"
     62#define SERVICE_NAME_NETCONF    "net/netconf"
    5863
    5964#endif

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

    r3deb0155 rdd0c8a0  
    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

    r3deb0155 rdd0c8a0  
    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/macros.h

    r3deb0155 rdd0c8a0  
    4040#define abs(a)     ((a) >= 0 ? (a) : -(a))
    4141
     42#define ARRAY_SIZE(array)   (sizeof(array) / sizeof(array[0]))
    4243
    4344#define KiB2SIZE(kb)  ((kb) << 10)

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

    r3deb0155 rdd0c8a0  
    3737
    3838#include <sys/types.h>
    39 
    40 #define bzero(ptr, len)  memset((ptr), 0, (len))
     39#include <cc.h>
    4140
    4241extern void *memset(void *, int, size_t)
    43     __attribute__ ((optimize("-fno-tree-loop-distribute-patterns")));
     42    ATTRIBUTE_OPTIMIZE("-fno-tree-loop-distribute-patterns");
    4443extern void *memcpy(void *, const void *, size_t)
    45     __attribute__ ((optimize("-fno-tree-loop-distribute-patterns")));
     44    ATTRIBUTE_OPTIMIZE("-fno-tree-loop-distribute-patterns");
    4645extern void *memmove(void *, const void *, size_t);
    47 
    48 extern int bcmp(const void *, const void *, size_t);
     46extern int memcmp(const void *, const void *, size_t);
    4947
    5048#endif

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

    r3deb0155 rdd0c8a0  
    4545#define INET_ADDRSTRLEN  (4 * 3 + 3 + 1)
    4646
    47 #define INADDR_ANY 0
    48 
    49 /** Type definition of the INET address.
    50  * @see in_addr
    51  */
    52 typedef struct in_addr in_addr_t;
    53 
    54 /** Type definition of the INET socket address.
    55  * @see sockaddr_in
    56  */
    57 typedef struct sockaddr_in      sockaddr_in_t;
     47#define INADDR_ANY  0
    5848
    5949/** INET address. */
    60 struct in_addr {
     50typedef struct in_addr {
    6151        /** 4 byte IP address. */
    6252        uint32_t s_addr;
    63 };
     53} in_addr_t;
    6454
    6555/** INET socket address.
    6656 * @see sockaddr
    6757 */
    68 struct sockaddr_in {
     58typedef struct sockaddr_in {
    6959        /** Address family. Should be AF_INET. */
    7060        uint16_t sin_family;
    … …  
    7262        uint16_t sin_port;
    7363        /** Internet address. */
    74         struct in_addr sin_addr;
     64        in_addr_t sin_addr;
    7565        /** Padding to meet the sockaddr size. */
    7666        uint8_t sin_zero[8];
    77 };
     67} sockaddr_in_t;
    7868
    7969#endif

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

    r3deb0155 rdd0c8a0  
    4343
    4444/** INET6 string address maximum length. */
    45 #define INET6_ADDRSTRLEN        (8 * 4 + 7 + 1)
    46 
    47 /** Type definition of the INET6 address.
    48  * @see in6_addr
    49  */
    50 typedef struct in6_addr in6_addr_t;
    51 
    52 /** Type definition of the INET6 socket address.
    53  * @see sockaddr_in6
    54  */
    55 typedef struct sockaddr_in6     sockaddr_in6_t;
     45#define INET6_ADDRSTRLEN  (8 * 4 + 7 + 1)
    5646
    5747/** INET6 address. */
    58 struct in6_addr {
     48typedef struct in6_addr {
    5949        /** 16 byte IPv6 address. */
    60         unsigned char s6_addr[16];
    61 };
     50        uint8_t s6_addr[16];
     51} in6_addr_t;
    6252
    6353/** INET6 socket address.
    6454 * @see sockaddr
    6555 */
    66 struct sockaddr_in6 {
     56typedef struct sockaddr_in6 {
    6757        /** Address family. Should be AF_INET6. */
    6858        uint16_t sin6_family;
    … …  
    7565        /** Scope identifier. */
    7666        uint32_t sin6_scope_id;
    77 };
     67} sockaddr_in6_t;
     68
     69extern const in6_addr_t in6addr_any;
    7870
    7971#endif

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

    r3deb0155 rdd0c8a0  
    4141#include <byteorder.h>
    4242
    43 /** Type definition of the socket address.
    44  * @see sockaddr
    45  */
    46 typedef struct sockaddr         sockaddr_t;
    47 
    4843/** Type definition of the address information.
    4944 * @see addrinfo
    5045 */
    51 typedef struct addrinfo         addrinfo_t;
     46typedef struct addrinfo addrinfo_t;
    5247
    5348/** Socket address. */
    54 struct sockaddr {
     49typedef struct sockaddr {
    5550        /** Address family. @see socket.h */
    5651        uint16_t sa_family;
    5752        /** 14 byte protocol address. */
    5853        uint8_t sa_data[14];
    59 };
     54} sockaddr_t;
    6055
    6156extern int inet_ntop(uint16_t, const uint8_t *, char *, size_t);

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

    r3deb0155 rdd0c8a0  
    4444/*@{*/
    4545
    46 #define IPPROTO_ICMP    1
    47 #define IPPROTO_TCP     6
    48 #define IPPROTO_UDP     17
     46#define IPPROTO_ICMP    1
     47#define IPPROTO_TCP     6
     48#define IPPROTO_UDP     17
     49#define IPPROTO_ICMPV6  58
    4950
    5051/*@}*/

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

    r3deb0155 rdd0c8a0  
    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

    r3deb0155 rdd0c8a0  
    4545
    4646enum {
    47         AF_UNKNOWN = 0,
    48         AF_INET,        /* IPv4 address */
    49         AF_INET6        /* IPv6 address */
     47        AF_NONE = 0,
     48        AF_INET,  /* IPv4 address */
     49        AF_INET6  /* IPv6 address */
    5050};
    5151
    … …  
    5353
    5454/** @name Protocol families definitions
    55  *  Same as address families.
     55 * Same as address families.
    5656 */
    5757/*@{*/
    5858
    59 #define PF_INET         AF_INET
    60 #define PF_INET6        AF_INET6
     59#define PF_INET   AF_INET
     60#define PF_INET6  AF_INET6
    6161
    6262/*@}*/
    … …  
    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

    r3deb0155 rdd0c8a0  
    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 *);
    … …  
    143147
    144148extern void setvbuf(FILE *, void *, int, size_t);
     149extern void setbuf(FILE *, void *);
    145150
    146151/* Misc file functions */

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

    r3deb0155 rdd0c8a0  
    109109extern char *str_ndup(const char *, size_t max_size);
    110110
    111 extern int str_uint8_t(const char *, char **, unsigned int, bool, uint8_t *);
    112 extern int str_uint16_t(const char *, char **, unsigned int, bool, uint16_t *);
    113 extern int str_uint32_t(const char *, char **, unsigned int, bool, uint32_t *);
    114 extern int str_uint64_t(const char *, char **, unsigned int, bool, uint64_t *);
    115 extern int str_size_t(const char *, char **, unsigned int, bool, size_t *);
     111extern int str_uint8_t(const char *, const char **, unsigned int, bool,
     112    uint8_t *);
     113extern int str_uint16_t(const char *, const char **, unsigned int, bool,
     114    uint16_t *);
     115extern int str_uint32_t(const char *, const char **, unsigned int, bool,
     116    uint32_t *);
     117extern int str_uint64_t(const char *, const char **, unsigned int, bool,
     118    uint64_t *);
     119extern int str_size_t(const char *, const char **, unsigned int, bool,
     120    size_t *);
    116121
    117122extern void order_suffix(const uint64_t, uint64_t *, char *);

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

    r3deb0155 rdd0c8a0  
    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.