Changeset e28175d in mainline for uspace/lib/c


Ignore:
Timestamp:
2020-03-15T10:44:02Z (6 years ago)
Author:
GitHub <noreply@…>
Parents:
b401b33 (diff), 44dde42 (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.
git-author:
heiducteam <tristanided@…> (2020-03-15 10:44:02)
git-committer:
GitHub <noreply@…> (2020-03-15 10:44:02)
Message:

Merge pull request #1 from HelenOS/master

sync

Location:
uspace/lib/c
Files:
6 added
26 deleted
35 edited
13 moved

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/arch/abs32le/meson.build

    rb401b33 re28175d  
    2727#
    2828
    29 USPACE_PREFIX = ../..
    30 LIBS =
    31 EXTRA_CFLAGS =
    32 BINARY = killall
     29arch_src += files(
     30        'src/entryjmp.c',
     31        'src/thread_entry.c',
     32        'src/fibril.c',
     33        'src/tls.c',
     34        'src/syscall.c',
     35        'src/stacktrace.c',
     36)
    3337
    34 SOURCES = \
    35         killall.c
    36 
    37 include $(USPACE_PREFIX)/Makefile.common
     38arch_start_src = files('src/crt0.c')

  • uspace/lib/c/arch/amd64/src/rtld/reloc.c

    rb401b33 re28175d  
    234234}
    235235
     236/** Get the adress of a function.
     237 *
     238 * @param sym Symbol
     239 * @param m Module in which the symbol is located
     240 * @return Address of function
     241 */
     242void *func_get_addr(elf_symbol_t *sym, module_t *m)
     243{
     244        return symbol_get_addr(sym, m, __tcb_get());
     245}
     246
    236247/** @}
    237248 */

  • uspace/lib/c/arch/arm32/include/libarch/fibril_context.h

    rb401b33 re28175d  
    3333
    3434/*
    35  * Only registers preserved accross function calls are included. r9 is
     35 * Only registers preserved across function calls are included. r9 is
    3636 * used to store a TLS address. -ffixed-r9 gcc forces gcc not to use this
    3737 * register. -mtp=soft forces gcc to use #__aeabi_read_tp to obtain

  • uspace/lib/c/arch/arm32/meson.build

    rb401b33 re28175d  
    2828#
    2929
    30 COMMON_CFLAGS += -ffixed-r9 -mtp=soft -fno-omit-frame-pointer -mapcs-frame \
    31         -mcpu=$(subst _,-,$(PROCESSOR)) -Wl,-z,max-page-size=0x1000
     30arch_src += files(
     31        'src/atomic.c',
     32        'src/entryjmp.S',
     33        'src/thread_entry.S',
     34        'src/syscall.c',
     35        'src/fibril.S',
     36        'src/tls.c',
     37        'src/eabi.S',
     38        'src/stacktrace.c',
     39        'src/stacktrace_asm.S',
     40        'src/rtld/dynamic.c',
     41        'src/rtld/reloc.c',
     42)
    3243
    33 LDFLAGS += -Wl,--gc-sections
    34 
    35 ifeq ($(CONFIG_FPU),y)
    36         COMMON_CFLAGS += -mfloat-abi=hard
    37 endif
    38 
    39 ENDIANESS = LE
    40 
    41 BFD_NAME = elf32-littlearm
    42 BFD_ARCH = arm
     44arch_start_src = files('src/crt0.S')

  • uspace/lib/c/arch/arm32/src/rtld/reloc.c

    rb401b33 re28175d  
    216216}
    217217
     218/** Get the adress of a function.
     219 *
     220 * @param sym Symbol
     221 * @param m Module in which the symbol is located
     222 * @return Address of function
     223 */
     224void *func_get_addr(elf_symbol_t *sym, module_t *m)
     225{
     226        return symbol_get_addr(sym, m, __tcb_get());
     227}
     228
    218229/** @}
    219230 */

  • uspace/lib/c/arch/arm64/meson.build

    rb401b33 re28175d  
    2727#
    2828
    29 COMMON_CFLAGS += -fno-omit-frame-pointer
     29arch_src += [ autocheck.process('include/libarch/fibril_context.h') ]
    3030
    31 LDFLAGS += -Wl,--gc-sections
     31arch_src += files(
     32        'src/entryjmp.S',
     33        'src/fibril.S',
     34        'src/stacktrace.c',
     35        'src/stacktrace_asm.S',
     36        'src/syscall.c',
     37        'src/tls.c',
     38        'src/thread_entry.S',
     39)
    3240
    33 ENDIANESS = LE
    34 
    35 BFD_NAME = elf64-littleaarch64
    36 BFD_ARCH = aarch64
     41arch_start_src = files('src/crt0.S')

  • uspace/lib/c/arch/ia32/src/rtld/reloc.c

    rb401b33 re28175d  
    216216}
    217217
     218/** Get the adress of a function.
     219 *
     220 * @param sym Symbol
     221 * @param m Module in which the symbol is located
     222 * @return Address of function
     223 */
     224void *func_get_addr(elf_symbol_t *sym, module_t *m)
     225{
     226        return symbol_get_addr(sym, m, __tcb_get());
     227}
     228
    218229/** @}
    219230 */

  • uspace/lib/c/arch/ia64/include/libarch/rtld/dynamic.h

    rb401b33 re28175d  
    11/*
    2  * Copyright (c) 2012 Petr Koupy
     2 * Copyright (c) 2019 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup draw
     29/** @addtogroup generic
    3030 * @{
    3131 */
    32 /**
    33  * @file
     32/** @file
    3433 */
    3534
    36 #ifndef DRAW_CURSOR_EMBEDDED_H_
    37 #define DRAW_CURSOR_EMBEDDED_H_
     35#ifndef LIBC_ia64_RTLD_DYNAMIC_H_
     36#define LIBC_ia64_RTLD_DYNAMIC_H_
    3837
    39 #include "../cursor.h"
    40 
    41 extern cursor_decoder_t cd_embedded;
     38typedef struct {
     39        /* Empty. */
     40} dyn_info_arch_t;
    4241
    4342#endif

  • uspace/lib/c/arch/ia64/include/libarch/rtld/elf_dyn.h

    rb401b33 re28175d  
    11/*
    2  * Copyright (c) 2011 Martin Decky
    3  * Copyright (c) 2011 Petr Koupy
     2 * Copyright (c) 2019 Jiri Svoboda
    43 * All rights reserved.
    54 *
    … …  
    2827 */
    2928
    30 /** @addtogroup draw
     29/** @addtogroup generic
    3130 * @{
    3231 */
    33 /**
    34  * @file
     32/** @file ia64 dynamic relocation types
    3533 */
    3634
    37 #ifndef DRAW_CODEC_TGA_H_
    38 #define DRAW_CODEC_TGA_H_
     35#ifndef LIBC_ia64_RTLD_ELF_DYN_H_
     36#define LIBC_ia64_RTLD_ELF_DYN_H_
    3937
    40 #include <stddef.h>
    41 #include "../surface.h"
    42 
    43 extern surface_t *decode_tga(void *, size_t, surface_flags_t);
    44 extern bool encode_tga(surface_t *, void **, size_t *);
     38#define R_IA_64_DIR64LSB    0x27
     39#define R_IA_64_FPTR64LSB   0x47
     40#define R_IA_64_REL64LSB    0x6f
     41#define R_IA_64_IPLTLSB     0x81
     42#define R_IA_64_DTPMOD64LSB 0xa7
     43#define R_IA_64_DTPREL64LSB 0xb7
    4544
    4645#endif

  • uspace/lib/c/arch/ia64/include/libarch/rtld/module.h

    rb401b33 re28175d  
    11/*
    2  * Copyright (c) 2014 Martin Sucha
     2 * Copyright (c) 2019 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup draw
     29/** @addtogroup libc
    3030 * @{
    3131 */
    32 /**
    33  * @file
     32/** @file
    3433 */
    3534
    36 #ifndef DRAW_FONT_PBF_H_
    37 #define DRAW_FONT_PBF_H_
     35#ifndef LIBC_ia64_RTLD_MODULE_H_
     36#define LIBC_ia64_RTLD_MODULE_H_
    3837
    39 #include "../font.h"
     38#include <elf/elf_mod.h>
    4039
    41 extern errno_t pcf_font_create(font_t **, char *path, uint16_t points);
     40/** ELF module load flags */
     41#define RTLD_MODULE_LDF 0
    4242
    4343#endif

  • uspace/lib/c/arch/ia64/include/libarch/tls.h

    rb401b33 re28175d  
    4242/* This structure must be exactly 16 bytes long */
    4343typedef struct {
    44         void *dtv; /* unused in static linking*/
     44        void **dtv;
    4545        void *fibril_data;
    4646} tcb_t;

  • uspace/lib/c/arch/ia64/src/rtld/dynamic.c

    rb401b33 re28175d  
    11/*
    2  * Copyright (c) 2014 Martin Decky
     2 * Copyright (c) 2019 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup draw
     29/** @addtogroup libcia64
     30 * @brief
    3031 * @{
    3132 */
    … …  
    3435 */
    3536
    36 #ifndef DRAW_CODEC_WEBP_H_
    37 #define DRAW_CODEC_WEBP_H_
     37#include <stdio.h>
     38#include <stdlib.h>
    3839
    39 #include <stddef.h>
    40 #include "../surface.h"
     40#include <rtld/elf_dyn.h>
     41#include <rtld/dynamic.h>
    4142
    42 extern surface_t *decode_webp(void *, size_t, surface_flags_t);
    43 extern bool encode_webp(surface_t *, void **, size_t *);
    44 
    45 #endif
     43void dyn_parse_arch(elf_dyn_t *dp, size_t bias, dyn_info_t *info)
     44{
     45        (void) dp;
     46        (void) bias;
     47        (void) info;
     48}
    4649
    4750/** @}

  • uspace/lib/c/arch/ia64/src/thread_entry.S

    rb401b33 re28175d  
    3434#
    3535#
    36 SYMBOL(__thread_entry)
     36SYMBOL_BEGIN(__thread_entry)
    3737        alloc loc0 = ar.pfs, 0, 1, 1, 0
    3838
     39#ifndef CONFIG_RTLD
     40        # XXX This does not work in a shared library
    3941        movl gp = __gp
     42#endif
    4043
    4144        #
    … …  
    4447
    4548        mov out0 = r8 ;;
     49        # XXX br.call.sptk.many b0 = FUNCTION_REF(__thread_main)
    4650        br.call.sptk.many b0 = __thread_main
    4751
    … …  
    5054        #
    5155
     56SYMBOL_END(__thread_entry)

  • uspace/lib/c/arch/ia64/src/tls.c

    rb401b33 re28175d  
    11/*
     2 * Copyright (c) 2019 Jiri Svoboda
    23 * Copyright (c) 2006 Ondrej Palkovsky
    34 * All rights reserved.
    … …  
    3738#include <tls.h>
    3839
     40#ifdef CONFIG_RTLD
     41#include <rtld/rtld.h>
     42#endif
     43
    3944tcb_t *tls_alloc_arch(size_t size, size_t align)
    4045{
    … …  
    4752}
    4853
     54/*
     55 * Rtld TLS support
     56 */
     57
     58typedef struct {
     59        unsigned long int ti_module;
     60        unsigned long int ti_offset;
     61} tls_index;
     62
     63void *__tls_get_addr(tls_index *ti);
     64
     65void *__tls_get_addr(tls_index *ti)
     66{
     67        uint8_t *tls;
     68
     69#ifdef CONFIG_RTLD
     70        if (runtime_env != NULL) {
     71                return rtld_tls_get_addr(runtime_env, __tcb_get(),
     72                    ti->ti_module, ti->ti_offset);
     73        }
     74#endif
     75        /* Get address of static TLS block */
     76        tls = tls_get();
     77        return tls + ti->ti_offset;
     78}
     79
    4980/** @}
    5081 */

  • uspace/lib/c/arch/ppc32/meson.build

    rb401b33 re28175d  
    2727#
    2828
    29 $(INITRD).img:
    30 ifeq ($(RDFMT),tmpfs)
    31         tar -c -f $@ -C $(DIST_PATH) .
    32 endif
    33 ifeq ($(RDFMT),fat)
    34         $(MKFAT) 1048576 $(DIST_PATH) $@
    35 endif
    36 ifeq ($(RDFMT),ext4fs)
    37         $(MKEXT4) 1048576 $(DIST_PATH) $@
    38 endif
     29arch_src += [ autocheck.process('include/libarch/fibril_context.h') ]
     30
     31arch_src += files(
     32        'src/entryjmp.S',
     33        'src/thread_entry.S',
     34        'src/syscall.c',
     35        'src/fibril.S',
     36        'src/tls.c',
     37        'src/stacktrace.c',
     38        'src/stacktrace_asm.S',
     39        'src/rtld/dynamic.c',
     40        'src/rtld/reloc.c',
     41)
     42
     43arch_start_src = files('src/crt0.S')

  • uspace/lib/c/arch/ppc32/src/rtld/reloc.c

    rb401b33 re28175d  
    418418}
    419419
     420/** Get the adress of a function.
     421 *
     422 * @param sym Symbol
     423 * @param m Module in which the symbol is located
     424 * @return Address of function
     425 */
     426void *func_get_addr(elf_symbol_t *sym, module_t *m)
     427{
     428        return symbol_get_addr(sym, m, __tcb_get());
     429}
     430
    420431/** @}
    421432 */

  • uspace/lib/c/arch/riscv64/meson.build

    rb401b33 re28175d  
    2727#
    2828
    29 ARCH_SOURCES = \
    30         arch/$(UARCH)/src/entryjmp.c \
    31         arch/$(UARCH)/src/thread_entry.c \
    32         arch/$(UARCH)/src/fibril.c \
    33         arch/$(UARCH)/src/tls.c \
    34         arch/$(UARCH)/src/syscall.c \
    35         arch/$(UARCH)/src/stacktrace.c
     29arch_src += [ autocheck.process('include/libarch/fibril_context.h') ]
    3630
    37 ARCH_AUTOCHECK_HEADERS = \
    38         arch/$(UARCH)/include/libarch/fibril_context.h
     31arch_src += files(
     32        'src/entryjmp.c',
     33        'src/thread_entry.c',
     34        'src/fibril.c',
     35        'src/tls.c',
     36        'src/syscall.c',
     37        'src/stacktrace.c',
     38)
     39
     40arch_start_src = files('src/crt0.c')

  • uspace/lib/c/arch/sparc64/meson.build

    rb401b33 re28175d  
    2727#
    2828
    29 ifeq ($(CONFIG_FPU),y)
    30         FLOATS=hard
    31 else
    32         FLOATS=soft
    33 endif
     29arch_src += [ autocheck.process('include/libarch/fibril_context.h') ]
    3430
    35 COMMON_CFLAGS += -mcpu=powerpc -m$(FLOATS)-float -m32 -Wl,-z,max-page-size=0x1000
    36 AFLAGS += -a32
    37 LDFLAGS += -Wl,--gc-sections
     31arch_src += files(
     32        'src/entryjmp.S',
     33        'src/thread_entry.S',
     34        'src/fibril.S',
     35        'src/tls.c',
     36        'src/stacktrace.c',
     37        'src/stacktrace_asm.S',
     38        'src/rtld/dynamic.c',
     39        'src/rtld/reloc.c',
     40)
    3841
    39 ENDIANESS = BE
    40 
    41 BFD_NAME = elf32-powerpc
    42 BFD_ARCH = powerpc:common
     42arch_start_src = files('src/crt0.S')

  • uspace/lib/c/arch/sparc64/src/rtld/reloc.c

    rb401b33 re28175d  
    299299}
    300300
     301/** Get the adress of a function.
     302 *
     303 * @param sym Symbol
     304 * @param m Module in which the symbol is located
     305 * @return Address of function
     306 */
     307void *func_get_addr(elf_symbol_t *sym, module_t *m)
     308{
     309        return symbol_get_addr(sym, m, __tcb_get());
     310}
     311
    301312/** @}
    302313 */

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

    rb401b33 re28175d  
    557557errno_t async_req_0_0(async_exch_t *exch, sysarg_t imethod)
    558558{
    559         return async_req_fast(exch, imethod, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL);
     559        return async_req_fast(exch, imethod, 0, 0, 0, 0, NULL, NULL, NULL, NULL,
     560            NULL);
    560561}
    561562
    562563errno_t async_req_0_1(async_exch_t *exch, sysarg_t imethod, sysarg_t *r1)
    563564{
    564         return async_req_fast(exch, imethod, 0, 0, 0, 0, r1, NULL, NULL, NULL, NULL);
    565 }
    566 
    567 errno_t async_req_0_2(async_exch_t *exch, sysarg_t imethod, sysarg_t *r1, sysarg_t *r2)
     565        return async_req_fast(exch, imethod, 0, 0, 0, 0, r1, NULL, NULL, NULL,
     566            NULL);
     567}
     568
     569errno_t async_req_0_2(async_exch_t *exch, sysarg_t imethod, sysarg_t *r1,
     570    sysarg_t *r2)
    568571{
    569572        return async_req_fast(exch, imethod, 0, 0, 0, 0, r1, r2, NULL, NULL, NULL);
    570573}
    571574
    572 errno_t async_req_0_3(async_exch_t *exch, sysarg_t imethod, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3)
     575errno_t async_req_0_3(async_exch_t *exch, sysarg_t imethod, sysarg_t *r1,
     576    sysarg_t *r2, sysarg_t *r3)
    573577{
    574578        return async_req_fast(exch, imethod, 0, 0, 0, 0, r1, r2, r3, NULL, NULL);
    575579}
    576580
    577 errno_t async_req_0_4(async_exch_t *exch, sysarg_t imethod, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4)
     581errno_t async_req_0_4(async_exch_t *exch, sysarg_t imethod, sysarg_t *r1,
     582    sysarg_t *r2, sysarg_t *r3, sysarg_t *r4)
    578583{
    579584        return async_req_fast(exch, imethod, 0, 0, 0, 0, r1, r2, r3, r4, NULL);
    580585}
    581586
    582 errno_t async_req_0_5(async_exch_t *exch, sysarg_t imethod, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
     587errno_t async_req_0_5(async_exch_t *exch, sysarg_t imethod, sysarg_t *r1,
     588    sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
    583589{
    584590        return async_req_fast(exch, imethod, 0, 0, 0, 0, r1, r2, r3, r4, r5);
    … …  
    587593errno_t async_req_1_0(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1)
    588594{
    589         return async_req_fast(exch, imethod, arg1, 0, 0, 0, NULL, NULL, NULL, NULL, NULL);
    590 }
    591 
    592 errno_t async_req_1_1(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t *r1)
    593 {
    594         return async_req_fast(exch, imethod, arg1, 0, 0, 0, r1, NULL, NULL, NULL, NULL);
    595 }
    596 
    597 errno_t async_req_1_2(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t *r1, sysarg_t *r2)
    598 {
    599         return async_req_fast(exch, imethod, arg1, 0, 0, 0, r1, r2, NULL, NULL, NULL);
    600 }
    601 
    602 errno_t async_req_1_3(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3)
    603 {
    604         return async_req_fast(exch, imethod, arg1, 0, 0, 0, r1, r2, r3, NULL, NULL);
    605 }
    606 
    607 errno_t async_req_1_4(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4)
     595        return async_req_fast(exch, imethod, arg1, 0, 0, 0, NULL, NULL, NULL, NULL,
     596            NULL);
     597}
     598
     599errno_t async_req_1_1(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     600    sysarg_t *r1)
     601{
     602        return async_req_fast(exch, imethod, arg1, 0, 0, 0, r1, NULL, NULL, NULL,
     603            NULL);
     604}
     605
     606errno_t async_req_1_2(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     607    sysarg_t *r1, sysarg_t *r2)
     608{
     609        return async_req_fast(exch, imethod, arg1, 0, 0, 0, r1, r2, NULL, NULL,
     610            NULL);
     611}
     612
     613errno_t async_req_1_3(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     614    sysarg_t *r1, sysarg_t *r2, sysarg_t *r3)
     615{
     616        return async_req_fast(exch, imethod, arg1, 0, 0, 0, r1, r2, r3, NULL,
     617            NULL);
     618}
     619
     620errno_t async_req_1_4(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     621    sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4)
    608622{
    609623        return async_req_fast(exch, imethod, arg1, 0, 0, 0, r1, r2, r3, r4, NULL);
    610624}
    611625
    612 errno_t async_req_1_5(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
     626errno_t async_req_1_5(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     627    sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
    613628{
    614629        return async_req_fast(exch, imethod, arg1, 0, 0, 0, r1, r2, r3, r4, r5);
    615630}
    616631
    617 errno_t async_req_2_0(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2)
    618 {
    619         return async_req_fast(exch, imethod, arg1, arg2, 0, 0, NULL, NULL, NULL, NULL, NULL);
    620 }
    621 
    622 errno_t async_req_2_1(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t *r1)
    623 {
    624         return async_req_fast(exch, imethod, arg1, arg2, 0, 0, r1, NULL, NULL, NULL, NULL);
    625 }
    626 
    627 errno_t async_req_2_2(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t *r1, sysarg_t *r2)
    628 {
    629         return async_req_fast(exch, imethod, arg1, arg2, 0, 0, r1, r2, NULL, NULL, NULL);
    630 }
    631 
    632 errno_t async_req_2_3(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3)
    633 {
    634         return async_req_fast(exch, imethod, arg1, arg2, 0, 0, r1, r2, r3, NULL, NULL);
    635 }
    636 
    637 errno_t async_req_2_4(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4)
    638 {
    639         return async_req_fast(exch, imethod, arg1, arg2, 0, 0, r1, r2, r3, r4, NULL);
    640 }
    641 
    642 errno_t async_req_2_5(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
     632errno_t async_req_2_0(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     633    sysarg_t arg2)
     634{
     635        return async_req_fast(exch, imethod, arg1, arg2, 0, 0, NULL, NULL, NULL,
     636            NULL, NULL);
     637}
     638
     639errno_t async_req_2_1(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     640    sysarg_t arg2, sysarg_t *r1)
     641{
     642        return async_req_fast(exch, imethod, arg1, arg2, 0, 0, r1, NULL, NULL,
     643            NULL, NULL);
     644}
     645
     646errno_t async_req_2_2(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     647    sysarg_t arg2, sysarg_t *r1, sysarg_t *r2)
     648{
     649        return async_req_fast(exch, imethod, arg1, arg2, 0, 0, r1, r2, NULL,
     650            NULL, NULL);
     651}
     652
     653errno_t async_req_2_3(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     654    sysarg_t arg2, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3)
     655{
     656        return async_req_fast(exch, imethod, arg1, arg2, 0, 0, r1, r2, r3, NULL,
     657            NULL);
     658}
     659
     660errno_t async_req_2_4(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     661    sysarg_t arg2, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4)
     662{
     663        return async_req_fast(exch, imethod, arg1, arg2, 0, 0, r1, r2, r3, r4,
     664            NULL);
     665}
     666
     667errno_t async_req_2_5(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     668    sysarg_t arg2, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
    643669{
    644670        return async_req_fast(exch, imethod, arg1, arg2, 0, 0, r1, r2, r3, r4, r5);
    645671}
    646672
    647 errno_t async_req_3_0(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3)
    648 {
    649         return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, NULL, NULL, NULL, NULL, NULL);
    650 }
    651 
    652 errno_t async_req_3_1(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t *r1)
    653 {
    654         return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, r1, NULL, NULL, NULL, NULL);
    655 }
    656 
    657 errno_t async_req_3_2(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t *r1, sysarg_t *r2)
    658 {
    659         return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, r1, r2, NULL, NULL, NULL);
    660 }
    661 
    662 errno_t async_req_3_3(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3)
    663 {
    664         return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, r1, r2, r3, NULL, NULL);
    665 }
    666 
    667 errno_t async_req_3_4(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4)
    668 {
    669         return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, r1, r2, r3, r4, NULL);
    670 }
    671 
    672 errno_t async_req_3_5(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
    673 {
    674         return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, r1, r2, r3, r4, r5);
    675 }
    676 
    677 errno_t async_req_4_0(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
    678 {
    679         return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, NULL, NULL, NULL, NULL, NULL);
    680 }
    681 
    682 errno_t async_req_4_1(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1)
    683 {
    684         return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, r1, NULL, NULL, NULL, NULL);
    685 }
    686 
    687 errno_t async_req_4_2(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2)
    688 {
    689         return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, r1, r2, NULL, NULL, NULL);
    690 }
    691 
    692 errno_t async_req_4_3(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3)
    693 {
    694         return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, r1, r2, r3, NULL, NULL);
    695 }
    696 
    697 errno_t async_req_4_4(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4)
    698 {
    699         return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, r1, r2, r3, r4, NULL);
    700 }
    701 
    702 errno_t async_req_4_5(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
    703 {
    704         return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, r1, r2, r3, r4, r5);
    705 }
    706 
    707 errno_t async_req_5_0(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5)
    708 {
    709         return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, NULL, NULL, NULL, NULL, NULL);
    710 }
    711 
    712 errno_t async_req_5_1(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1)
    713 {
    714         return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, r1, NULL, NULL, NULL, NULL);
    715 }
    716 
    717 errno_t async_req_5_2(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1, sysarg_t *r2)
    718 {
    719         return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, r1, r2, NULL, NULL, NULL);
    720 }
    721 
    722 errno_t async_req_5_3(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3)
    723 {
    724         return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, r1, r2, r3, NULL, NULL);
    725 }
    726 
    727 errno_t async_req_5_4(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4)
    728 {
    729         return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, r1, r2, r3, r4, NULL);
    730 }
    731 
    732 errno_t async_req_5_5(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
    733 {
    734         return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, r1, r2, r3, r4, r5);
     673errno_t async_req_3_0(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     674    sysarg_t arg2, sysarg_t arg3)
     675{
     676        return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, NULL, NULL, NULL,
     677            NULL, NULL);
     678}
     679
     680errno_t async_req_3_1(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     681    sysarg_t arg2, sysarg_t arg3, sysarg_t *r1)
     682{
     683        return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, r1, NULL, NULL,
     684            NULL, NULL);
     685}
     686
     687errno_t async_req_3_2(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     688    sysarg_t arg2, sysarg_t arg3, sysarg_t *r1, sysarg_t *r2)
     689{
     690        return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, r1, r2, NULL,
     691            NULL, NULL);
     692}
     693
     694errno_t async_req_3_3(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     695    sysarg_t arg2, sysarg_t arg3, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3)
     696{
     697        return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, r1, r2, r3, NULL,
     698            NULL);
     699}
     700
     701errno_t async_req_3_4(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     702    sysarg_t arg2, sysarg_t arg3, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3,
     703    sysarg_t *r4)
     704{
     705        return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, r1, r2, r3, r4,
     706            NULL);
     707}
     708
     709errno_t async_req_3_5(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     710    sysarg_t arg2, sysarg_t arg3, sysarg_t *r1, sysarg_t *r2, sysarg_t *r3,
     711    sysarg_t *r4, sysarg_t *r5)
     712{
     713        return async_req_fast(exch, imethod, arg1, arg2, arg3, 0, r1, r2, r3, r4,
     714            r5);
     715}
     716
     717errno_t async_req_4_0(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     718    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
     719{
     720        return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, NULL, NULL,
     721            NULL, NULL, NULL);
     722}
     723
     724errno_t async_req_4_1(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     725    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1)
     726{
     727        return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, r1, NULL,
     728            NULL, NULL, NULL);
     729}
     730
     731errno_t async_req_4_2(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     732    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2)
     733{
     734        return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, r1, r2, NULL,
     735            NULL, NULL);
     736}
     737
     738errno_t async_req_4_3(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     739    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2,
     740    sysarg_t *r3)
     741{
     742        return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, r1, r2, r3,
     743            NULL, NULL);
     744}
     745
     746errno_t async_req_4_4(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     747    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2,
     748    sysarg_t *r3, sysarg_t *r4)
     749{
     750        return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, r1, r2, r3,
     751            r4, NULL);
     752}
     753
     754errno_t async_req_4_5(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     755    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2,
     756    sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
     757{
     758        return async_req_fast(exch, imethod, arg1, arg2, arg3, arg4, r1, r2, r3,
     759            r4, r5);
     760}
     761
     762errno_t async_req_5_0(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     763    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5)
     764{
     765        return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, NULL,
     766            NULL, NULL, NULL, NULL);
     767}
     768
     769errno_t async_req_5_1(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     770    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1)
     771{
     772        return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, r1,
     773            NULL, NULL, NULL, NULL);
     774}
     775
     776errno_t async_req_5_2(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     777    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1,
     778    sysarg_t *r2)
     779{
     780        return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, r1, r2,
     781            NULL, NULL, NULL);
     782}
     783
     784errno_t async_req_5_3(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     785    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1,
     786    sysarg_t *r2, sysarg_t *r3)
     787{
     788        return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, r1, r2,
     789            r3, NULL, NULL);
     790}
     791
     792errno_t async_req_5_4(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     793    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1,
     794    sysarg_t *r2, sysarg_t *r3, sysarg_t *r4)
     795{
     796        return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, r1, r2,
     797            r3, r4, NULL);
     798}
     799
     800errno_t async_req_5_5(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     801    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1,
     802    sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
     803{
     804        return async_req_slow(exch, imethod, arg1, arg2, arg3, arg4, arg5, r1, r2,
     805            r3, r4, r5);
    735806}
    736807
    … …  
    818889 * @param arg2  User defined argument.
    819890 * @param arg3  User defined argument.
     891 * @param rc    Placeholder for return code. Unused if NULL.
    820892 *
    821893 * @return New session on success or NULL on error.
    … …  
    823895 */
    824896async_sess_t *async_connect_me_to(async_exch_t *exch, iface_t iface,
    825     sysarg_t arg2, sysarg_t arg3)
     897    sysarg_t arg2, sysarg_t arg3, errno_t *rc)
    826898{
    827899        if (exch == NULL) {
    828                 errno = ENOENT;
     900                if (rc != NULL)
     901                        *rc = ENOENT;
     902
    829903                return NULL;
    830904        }
    … …  
    832906        async_sess_t *sess = calloc(1, sizeof(async_sess_t));
    833907        if (sess == NULL) {
    834                 errno = ENOMEM;
     908                if (rc != NULL)
     909                        *rc = ENOMEM;
     910
    835911                return NULL;
    836912        }
    837913
    838914        cap_phone_handle_t phone;
    839         errno_t rc = async_connect_me_to_internal(exch->phone, iface, arg2,
     915        errno_t ret = async_connect_me_to_internal(exch->phone, iface, arg2,
    840916            arg3, 0, &phone);
    841         if (rc != EOK) {
    842                 errno = rc;
     917        if (ret != EOK) {
     918                if (rc != NULL)
     919                        *rc = ret;
     920
    843921                free(sess);
    844922                return NULL;
    … …  
    886964 * @param arg2  User defined argument.
    887965 * @param arg3  User defined argument.
     966 * @param rc    Placeholder for return code. Unused if NULL.
    888967 *
    889968 * @return New session on success or NULL on error.
    … …  
    891970 */
    892971async_sess_t *async_connect_me_to_blocking(async_exch_t *exch, iface_t iface,
    893     sysarg_t arg2, sysarg_t arg3)
     972    sysarg_t arg2, sysarg_t arg3, errno_t *rc)
    894973{
    895974        if (exch == NULL) {
    896                 errno = ENOENT;
     975                if (rc != NULL)
     976                        *rc = ENOENT;
     977
    897978                return NULL;
    898979        }
    … …  
    900981        async_sess_t *sess = calloc(1, sizeof(async_sess_t));
    901982        if (sess == NULL) {
    902                 errno = ENOMEM;
     983                if (rc != NULL)
     984                        *rc = ENOMEM;
     985
    903986                return NULL;
    904987        }
    905988
    906989        cap_phone_handle_t phone;
    907         errno_t rc = async_connect_me_to_internal(exch->phone, iface, arg2,
     990        errno_t ret = async_connect_me_to_internal(exch->phone, iface, arg2,
    908991            arg3, IPC_FLAG_BLOCKING, &phone);
    909         if (rc != EOK) {
    910                 errno = rc;
     992        if (ret != EOK) {
     993                if (rc != NULL)
     994                        *rc = ret;
     995
    911996                free(sess);
    912997                return NULL;
    … …  
    9281013/** Connect to a task specified by id.
    9291014 *
    930  */
    931 async_sess_t *async_connect_kbox(task_id_t id)
     1015 * @param id Task to which to connect.
     1016 * @param rc Placeholder for return code. Unused if NULL.
     1017 *
     1018 * @return New session on success or NULL on error.
     1019 *
     1020 */
     1021async_sess_t *async_connect_kbox(task_id_t id, errno_t *rc)
    9321022{
    9331023        async_sess_t *sess = calloc(1, sizeof(async_sess_t));
    9341024        if (sess == NULL) {
    935                 errno = ENOMEM;
     1025                if (rc != NULL)
     1026                        *rc = ENOMEM;
     1027
    9361028                return NULL;
    9371029        }
    9381030
    9391031        cap_phone_handle_t phone;
    940         errno_t rc = ipc_connect_kbox(id, &phone);
    941         if (rc != EOK) {
    942                 errno = rc;
     1032        errno_t ret = ipc_connect_kbox(id, &phone);
     1033        if (ret != EOK) {
     1034                if (rc != NULL)
     1035                        *rc = ret;
     1036
    9431037                free(sess);
    9441038                return NULL;

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

    rb401b33 re28175d  
    114114#include <stdlib.h>
    115115#include <mem.h>
    116 #include <stdlib.h>
    117116#include <macros.h>
    118117#include <str_error.h>

  • uspace/lib/c/generic/capa.c

    rb401b33 re28175d  
    3434 */
    3535
    36 #include <cap.h>
     36#include <capa.h>
    3737#include <errno.h>
    3838#include <imath.h>
    … …  
    4343enum {
    4444        /** Simplified capacity maximum integer digits */
    45         scap_max_idig = 3,
     45        scapa_max_idig = 3,
    4646        /** Simplified capacity maximum significant digits */
    47         scap_max_sdig = 4
     47        scapa_max_sdig = 4
    4848};
    4949
    … …  
    6060};
    6161
    62 void cap_from_blocks(uint64_t nblocks, size_t block_size, cap_spec_t *cap)
     62void capa_from_blocks(uint64_t nblocks, size_t block_size, capa_spec_t *capa)
    6363{
    6464        uint64_t tsize;
    6565
    6666        tsize = nblocks * block_size;
    67         cap->m = tsize;
    68         cap->dp = 0;
    69         cap->cunit = cu_byte;
     67        capa->m = tsize;
     68        capa->dp = 0;
     69        capa->cunit = cu_byte;
    7070}
    7171
    … …  
    8181 * and @c cv_max gives the maximum value.
    8282 */
    83 errno_t cap_to_blocks(cap_spec_t *cap, cap_vsel_t cvsel, size_t block_size,
     83errno_t capa_to_blocks(capa_spec_t *capa, capa_vsel_t cvsel, size_t block_size,
    8484    uint64_t *rblocks)
    8585{
    … …  
    9292        errno_t rc;
    9393
    94         exp = cap->cunit * 3 - cap->dp;
     94        exp = capa->cunit * 3 - capa->dp;
    9595        if (exp < 0) {
    9696                rc = ipow10_u64(-exp, &f);
    9797                if (rc != EOK)
    9898                        return ERANGE;
    99                 bytes = (cap->m + (f / 2)) / f;
    100                 if (bytes * f - (f / 2) != cap->m)
     99                bytes = (capa->m + (f / 2)) / f;
     100                if (bytes * f - (f / 2) != capa->m)
    101101                        return ERANGE;
    102102        } else {
    … …  
    118118                }
    119119
    120                 bytes = cap->m * f + adj;
    121                 if ((bytes - adj) / f != cap->m)
     120                bytes = capa->m * f + adj;
     121                if ((bytes - adj) / f != capa->m)
    122122                        return ERANGE;
    123123        }
    … …  
    138138 * digits and at most two fractional digits, e.g abc.xy <unit>.
    139139 */
    140 void cap_simplify(cap_spec_t *cap)
     140void capa_simplify(capa_spec_t *capa)
    141141{
    142142        uint64_t div;
    … …  
    146146        errno_t rc;
    147147
    148         /* Change units so that we have at most @c scap_max_idig integer digits */
    149         rc = ipow10_u64(scap_max_idig, &maxv);
     148        /* Change units so that we have at most @c scapa_max_idig integer digits */
     149        rc = ipow10_u64(scapa_max_idig, &maxv);
    150150        assert(rc == EOK);
    151151
    152         rc = ipow10_u64(cap->dp, &div);
     152        rc = ipow10_u64(capa->dp, &div);
    153153        assert(rc == EOK);
    154154
    155         while (cap->m / div >= maxv) {
    156                 ++cap->cunit;
    157                 cap->dp += 3;
     155        /* Change units until we have no more than scapa_max_idig integer digits */
     156        while (capa->m / div >= maxv) {
     157                ++capa->cunit;
     158                capa->dp += 3;
    158159                div = div * 1000;
    159160        }
    160161
    161         /* Round the number so that we have at most @c scap_max_sdig significant digits */
    162         sdig = 1 + ilog10_u64(cap->m); /* number of significant digits */
    163         if (sdig > scap_max_sdig) {
     162        /* Round the number so that we have at most @c scapa_max_sdig significant digits */
     163        sdig = 1 + ilog10_u64(capa->m); /* number of significant digits */
     164        if (sdig > scapa_max_sdig) {
    164165                /* Number of digits to remove */
    165                 rdig = sdig - scap_max_sdig;
    166                 if (rdig > cap->dp)
    167                         rdig = cap->dp;
     166                rdig = sdig - scapa_max_sdig;
     167                if (rdig > capa->dp)
     168                        rdig = capa->dp;
    168169
    169170                rc = ipow10_u64(rdig, &div);
    170171                assert(rc == EOK);
    171172
    172                 cap->m = (cap->m + (div / 2)) / div;
    173                 cap->dp -= rdig;
    174         }
    175 }
    176 
    177 errno_t cap_format(cap_spec_t *cap, char **rstr)
     173                /* Division with rounding */
     174                capa->m = (capa->m + (div / 2)) / div;
     175                capa->dp -= rdig;
     176        }
     177
     178        /*
     179         * If we rounded up from something like 999.95 to 1000.0,, we still
     180         * have more than scapa_max_idig integer digits and need to change
     181         * units once more.
     182         */
     183        rc = ipow10_u64(capa->dp, &div);
     184        assert(rc == EOK);
     185
     186        if (capa->m / div >= 1000) {
     187                ++capa->cunit;
     188                capa->dp += 3;
     189
     190                /*
     191                 * We now have one more significant digit than we want
     192                 * so round to one less digits
     193                 */
     194                capa->m = (capa->m + 5) / 10;
     195                --capa->dp;
     196        }
     197}
     198
     199errno_t capa_format(capa_spec_t *capa, char **rstr)
    178200{
    179201        errno_t rc;
    … …  
    186208        sunit = NULL;
    187209
    188         assert(cap->cunit < CU_LIMIT);
    189 
    190         rc = ipow10_u64(cap->dp, &div);
     210        assert(capa->cunit < CU_LIMIT);
     211
     212        rc = ipow10_u64(capa->dp, &div);
    191213        if (rc != EOK)
    192214                return rc;
    193215
    194         ipart = cap->m / div;
    195         fpart = cap->m % div;
    196 
    197         sunit = cu_str[cap->cunit];
    198         if (cap->dp > 0) {
     216        ipart = capa->m / div;
     217        fpart = capa->m % div;
     218
     219        sunit = cu_str[capa->cunit];
     220        if (capa->dp > 0) {
    199221                ret = asprintf(rstr, "%" PRIu64 ".%0*" PRIu64 " %s", ipart,
    200                     (int)cap->dp, fpart, sunit);
     222                    (int)capa->dp, fpart, sunit);
    201223        } else {
    202224                ret = asprintf(rstr, "%" PRIu64 " %s", ipart, sunit);
    203225        }
     226
    204227        if (ret < 0)
    205228                return ENOMEM;
    … …  
    208231}
    209232
    210 static errno_t cap_digit_val(char c, int *val)
     233static errno_t capa_digit_val(char c, int *val)
    211234{
    212235        switch (c) {
    … …  
    248271}
    249272
    250 errno_t cap_parse(const char *str, cap_spec_t *cap)
     273errno_t capa_parse(const char *str, capa_spec_t *capa)
    251274{
    252275        const char *eptr;
    … …  
    260283
    261284        eptr = str;
    262         while (cap_digit_val(*eptr, &d) == EOK) {
     285        while (capa_digit_val(*eptr, &d) == EOK) {
    263286                m = m * 10 + d;
    264287                ++eptr;
    … …  
    268291                ++eptr;
    269292                dp = 0;
    270                 while (cap_digit_val(*eptr, &d) == EOK) {
     293                while (capa_digit_val(*eptr, &d) == EOK) {
    271294                        m = m * 10 + d;
    272295                        ++dp;
    … …  
    281304
    282305        if (*eptr == '\0') {
    283                 cap->cunit = cu_byte;
     306                capa->cunit = cu_byte;
    284307        } else {
    285308                for (i = 0; i < CU_LIMIT; i++) {
    … …  
    296319                return EINVAL;
    297320        found:
    298                 cap->cunit = i;
    299         }
    300 
    301         cap->m = m;
    302         cap->dp = dp;
     321                capa->cunit = i;
     322        }
     323
     324        capa->m = m;
     325        capa->dp = dp;
    303326        return EOK;
    304327}

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

    rb401b33 re28175d  
    8989                                devman_driver_block_sess =
    9090                                    service_connect_blocking(SERVICE_DEVMAN,
    91                                     INTERFACE_DDF_DRIVER, 0);
     91                                    INTERFACE_DDF_DRIVER, 0, NULL);
    9292                }
    9393
    … …  
    108108                                devman_client_block_sess =
    109109                                    service_connect_blocking(SERVICE_DEVMAN,
    110                                     INTERFACE_DDF_CLIENT, 0);
     110                                    INTERFACE_DDF_CLIENT, 0, NULL);
    111111                }
    112112
    … …  
    138138                        devman_driver_sess =
    139139                            service_connect(SERVICE_DEVMAN,
    140                             INTERFACE_DDF_DRIVER, 0);
     140                            INTERFACE_DDF_DRIVER, 0, NULL);
    141141
    142142                fibril_mutex_unlock(&devman_driver_mutex);
    … …  
    152152                        devman_client_sess =
    153153                            service_connect(SERVICE_DEVMAN,
    154                             INTERFACE_DDF_CLIENT, 0);
     154                            INTERFACE_DDF_CLIENT, 0, NULL);
    155155
    156156                fibril_mutex_unlock(&devman_client_mutex);
    … …  
    292292        if (flags & IPC_FLAG_BLOCKING)
    293293                sess = service_connect_blocking(SERVICE_DEVMAN,
    294                     INTERFACE_DEVMAN_DEVICE, handle);
     294                    INTERFACE_DEVMAN_DEVICE, handle, NULL);
    295295        else
    296296                sess = service_connect(SERVICE_DEVMAN,
    297                     INTERFACE_DEVMAN_DEVICE, handle);
     297                    INTERFACE_DEVMAN_DEVICE, handle, NULL);
    298298
    299299        return sess;
    … …  
    350350        if (flags & IPC_FLAG_BLOCKING)
    351351                sess = service_connect_blocking(SERVICE_DEVMAN,
    352                     INTERFACE_DEVMAN_PARENT, handle);
     352                    INTERFACE_DEVMAN_PARENT, handle, NULL);
    353353        else
    354                 sess = service_connect_blocking(SERVICE_DEVMAN,
    355                     INTERFACE_DEVMAN_PARENT, handle);
     354                sess = service_connect(SERVICE_DEVMAN,
     355                    INTERFACE_DEVMAN_PARENT, handle, NULL);
    356356
    357357        return sess;

  • uspace/lib/c/generic/dlfcn.c

    rb401b33 re28175d  
    4545#include <rtld/module.h>
    4646#include <rtld/rtld.h>
     47#include <rtld/rtld_arch.h>
    4748#include <rtld/symbol.h>
    4849
    … …  
    7980        sd = symbol_bfs_find(sym_name, (module_t *) mod, &sm);
    8081        if (sd != NULL) {
    81                 return symbol_get_addr(sd, sm, __tcb_get());
     82                if (elf_st_type(sd->st_info) == STT_FUNC)
     83                        return func_get_addr(sd, sm);
     84                else
     85                        return symbol_get_addr(sd, sm, __tcb_get());
    8286        }
    8387

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

    rb401b33 re28175d  
    455455        exch = async_exchange_begin(conn->tcp->sess);
    456456        aid_t req = async_send_1(exch, TCP_CONN_SEND, conn->id, NULL);
    457 
    458457        rc = async_data_write_start(exch, data, bytes);
     458        async_exchange_end(exch);
     459
    459460        if (rc != EOK) {
    460461                async_forget(req);
    461462                return rc;
    462463        }
    463 
    464         async_exchange_end(exch);
    465464
    466465        if (rc != EOK) {

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

    rb401b33 re28175d  
    167167                return ENOMEM;
    168168
     169        errno_t rc;
    169170        logger_session = service_connect_blocking(SERVICE_LOGGER,
    170             INTERFACE_LOGGER_WRITER, 0);
    171         if (logger_session == NULL) {
    172                 return ENOMEM;
    173         }
     171            INTERFACE_LOGGER_WRITER, 0, &rc);
     172        if (logger_session == NULL)
     173                return rc;
    174174
    175175        default_log_id = log_create(prog_name, LOG_NO_PARENT);

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

    rb401b33 re28175d  
    4848
    4949        if (logger_session == NULL) {
     50                errno_t rc;
    5051                logger_session = service_connect_blocking(SERVICE_LOGGER,
    51                     INTERFACE_LOGGER_CONTROL, 0);
     52                    INTERFACE_LOGGER_CONTROL, 0, &rc);
    5253                if (logger_session == NULL)
    53                         return ENOMEM;
     54                        return rc;
    5455        }
    5556

  • uspace/lib/c/generic/loader.c

    rb401b33 re28175d  
    4646#include "private/loader.h"
    4747
    48 /** Connect to a new program loader.
    49  *
    50  * Spawns a new program loader task and returns the connection structure.
     48/** Spawn a new program loader.
     49 *
     50 * Spawn a new program loader task. The loader then independetly
     51 * connects to the naming service.
    5152 *
    5253 * @param name Symbolic name to set on the newly created task.
    5354 *
    5455 * @return Error code.
     56 *
    5557 */
    5658errno_t loader_spawn(const char *name)
    … …  
    6062}
    6163
    62 loader_t *loader_connect(void)
     64/** Connect to a program loader.
     65 *
     66 * @param rc Placeholder for return code. Unused if NULL.
     67 *
     68 * @return Loader structure.
     69 *
     70 */
     71loader_t *loader_connect(errno_t *rc)
    6372{
    6473        loader_t *ldr = malloc(sizeof(loader_t));
    … …  
    6776
    6877        async_sess_t *sess =
    69             service_connect_blocking(SERVICE_LOADER, INTERFACE_LOADER, 0);
     78            service_connect_blocking(SERVICE_LOADER, INTERFACE_LOADER, 0, rc);
    7079        if (sess == NULL) {
    7180                free(ldr);
    … …  
    345354}
    346355
     356/** Instruct loader to execute the program and do not wait for reply.
     357 *
     358 * This function does not block even if the loaded task is stopped
     359 * for debugging.
     360 *
     361 * After using this function, no further operations can be performed
     362 * on the loader structure and it is deallocated.
     363 *
     364 * @param ldr Loader connection structure.
     365 *
     366 * @return Zero on success or an error code.
     367 *
     368 */
     369void loader_run_nowait(loader_t *ldr)
     370{
     371        async_exch_t *exch = async_exchange_begin(ldr->sess);
     372        async_msg_0(exch, LOADER_RUN);
     373        async_exchange_end(exch);
     374
     375        async_hangup(ldr->sess);
     376        free(ldr);
     377}
     378
    347379/** Cancel the loader session.
    348380 *

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

    rb401b33 re28175d  
    153153                                loc_supp_block_sess =
    154154                                    service_connect_blocking(SERVICE_LOC,
    155                                     INTERFACE_LOC_SUPPLIER, 0);
     155                                    INTERFACE_LOC_SUPPLIER, 0, NULL);
    156156                }
    157157
    … …  
    172172                                loc_cons_block_sess =
    173173                                    service_connect_blocking(SERVICE_LOC,
    174                                     INTERFACE_LOC_CONSUMER, 0);
     174                                    INTERFACE_LOC_CONSUMER, 0, NULL);
    175175                }
    176176
    … …  
    202202                        loc_supplier_sess =
    203203                            service_connect(SERVICE_LOC,
    204                             INTERFACE_LOC_SUPPLIER, 0);
     204                            INTERFACE_LOC_SUPPLIER, 0, NULL);
    205205
    206206                fibril_mutex_unlock(&loc_supplier_mutex);
    … …  
    216216                        loc_consumer_sess =
    217217                            service_connect(SERVICE_LOC,
    218                             INTERFACE_LOC_CONSUMER, 0);
     218                            INTERFACE_LOC_CONSUMER, 0, NULL);
    219219
    220220                fibril_mutex_unlock(&loc_consumer_mutex);
    … …  
    567567
    568568        if (flags & IPC_FLAG_BLOCKING)
    569                 sess = service_connect_blocking(SERVICE_LOC, iface, handle);
     569                sess = service_connect_blocking(SERVICE_LOC, iface, handle, NULL);
    570570        else
    571                 sess = service_connect(SERVICE_LOC, iface, handle);
     571                sess = service_connect(SERVICE_LOC, iface, handle, NULL);
    572572
    573573        return sess;

  • uspace/lib/c/generic/ns.c

    rb401b33 re28175d  
    4949    async_port_handler_t handler, void *data)
    5050{
    51         async_sess_t *sess = ns_session_get();
    52         if (sess == NULL)
    53                 return EIO;
     51        errno_t rc;
     52        async_sess_t *sess = ns_session_get(&rc);
     53        if (sess == NULL)
     54                return rc;
    5455
    5556        port_id_t port;
    56         errno_t rc = async_create_port(iface, handler, data, &port);
     57        rc = async_create_port(iface, handler, data, &port);
    5758        if (rc != EOK)
    5859                return rc;
    … …  
    8182        async_set_fallback_port_handler(handler, data);
    8283
    83         async_sess_t *sess = ns_session_get();
    84         if (sess == NULL)
    85                 return EIO;
     84        errno_t rc;
     85        async_sess_t *sess = ns_session_get(&rc);
     86        if (sess == NULL)
     87                return rc;
    8688
    8789        async_exch_t *exch = async_exchange_begin(sess);
    … …  
    8991        ipc_call_t answer;
    9092        aid_t req = async_send_1(exch, NS_REGISTER_BROKER, service, &answer);
    91         errno_t rc = async_connect_to_me(exch, INTERFACE_ANY, service, 0);
     93        rc = async_connect_to_me(exch, INTERFACE_ANY, service, 0);
    9294
    9395        async_exchange_end(exch);
    … …  
    103105}
    104106
    105 async_sess_t *service_connect(service_t service, iface_t iface, sysarg_t arg3)
    106 {
    107         async_sess_t *sess = ns_session_get();
     107/** Connect to a singleton service.
     108 *
     109 * @param service Singleton service ID.
     110 * @param iface   Interface to connect to.
     111 * @param arg3    Custom connection argument.
     112 * @param rc      Placeholder for return code. Unused if NULL.
     113 *
     114 * @return New session on success or NULL on error.
     115 *
     116 */
     117async_sess_t *service_connect(service_t service, iface_t iface, sysarg_t arg3,
     118    errno_t *rc)
     119{
     120        async_sess_t *sess = ns_session_get(rc);
    108121        if (sess == NULL)
    109122                return NULL;
    … …  
    114127
    115128        async_sess_t *csess =
    116             async_connect_me_to(exch, iface, service, arg3);
     129            async_connect_me_to(exch, iface, service, arg3, rc);
    117130        async_exchange_end(exch);
    118131
    … …  
    130143}
    131144
     145/** Wait and connect to a singleton service.
     146 *
     147 * @param service Singleton service ID.
     148 * @param iface   Interface to connect to.
     149 * @param arg3    Custom connection argument.
     150 * @param rc      Placeholder for return code. Unused if NULL.
     151 *
     152 * @return New session on success or NULL on error.
     153 *
     154 */
    132155async_sess_t *service_connect_blocking(service_t service, iface_t iface,
    133     sysarg_t arg3)
    134 {
    135         async_sess_t *sess = ns_session_get();
     156    sysarg_t arg3, errno_t *rc)
     157{
     158        async_sess_t *sess = ns_session_get(rc);
    136159        if (sess == NULL)
    137160                return NULL;
    … …  
    139162        async_exch_t *exch = async_exchange_begin(sess);
    140163        async_sess_t *csess =
    141             async_connect_me_to_blocking(exch, iface, service, arg3);
     164            async_connect_me_to_blocking(exch, iface, service, arg3, rc);
    142165        async_exchange_end(exch);
    143166
    … …  
    157180errno_t ns_ping(void)
    158181{
    159         async_sess_t *sess = ns_session_get();
     182        errno_t rc;
     183        async_sess_t *sess = ns_session_get(&rc);
     184        if (sess == NULL)
     185                return rc;
     186
     187        async_exch_t *exch = async_exchange_begin(sess);
     188        rc = async_req_0_0(exch, NS_PING);
     189        async_exchange_end(exch);
     190
     191        return rc;
     192}
     193
     194errno_t ns_intro(task_id_t id)
     195{
     196        errno_t rc;
     197        async_sess_t *sess = ns_session_get(&rc);
    160198        if (sess == NULL)
    161199                return EIO;
    162200
    163201        async_exch_t *exch = async_exchange_begin(sess);
    164         errno_t rc = async_req_0_0(exch, NS_PING);
    165         async_exchange_end(exch);
    166 
    167         return rc;
    168 }
    169 
    170 errno_t ns_intro(task_id_t id)
    171 {
    172         async_exch_t *exch;
    173         async_sess_t *sess = ns_session_get();
    174         if (sess == NULL)
    175                 return EIO;
    176 
    177         exch = async_exchange_begin(sess);
    178         errno_t rc = async_req_2_0(exch, NS_ID_INTRO, LOWER32(id), UPPER32(id));
    179         async_exchange_end(exch);
    180 
    181         return rc;
    182 }
    183 
    184 async_sess_t *ns_session_get(void)
     202        rc = async_req_2_0(exch, NS_ID_INTRO, LOWER32(id), UPPER32(id));
     203        async_exchange_end(exch);
     204
     205        return rc;
     206}
     207
     208async_sess_t *ns_session_get(errno_t *rc)
    185209{
    186210        async_exch_t *exch;
    … …  
    188212        if (sess_ns == NULL) {
    189213                exch = async_exchange_begin(&session_ns);
    190                 sess_ns = async_connect_me_to(exch, 0, 0, 0);
     214                sess_ns = async_connect_me_to(exch, 0, 0, 0, rc);
    191215                async_exchange_end(exch);
    192216                if (sess_ns == NULL)

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

    rb401b33 re28175d  
    184184}
    185185
     186/** Get IPC connections statistics.
     187 *
     188 * @param count Number of records returned.
     189 *
     190 * @return Array of stats_ipcc_t structures.
     191 *         If non-NULL then it should be eventually freed
     192 *         by free().
     193 *
     194 */
     195stats_ipcc_t *stats_get_ipccs(size_t *count)
     196{
     197        size_t size = 0;
     198        stats_ipcc_t *stats_ipccs =
     199            (stats_ipcc_t *) sysinfo_get_data("system.ipccs", &size);
     200
     201        if ((size % sizeof(stats_ipcc_t)) != 0) {
     202                if (stats_ipccs != NULL)
     203                        free(stats_ipccs);
     204                *count = 0;
     205                return NULL;
     206        }
     207
     208        *count = size / sizeof(stats_ipcc_t);
     209        return stats_ipccs;
     210}
     211
    186212/** Get exception statistics.
    187213 *

  • uspace/lib/c/generic/str.c

    rb401b33 re28175d  
    801801
    802802        return false;
     803}
     804
     805/** Get a string suffix.
     806 *
     807 * Return a string suffix defined by the prefix length.
     808 *
     809 * @param s             The string to get the suffix from.
     810 * @param prefix_length Number of prefix characters to ignore.
     811 *
     812 * @return String suffix.
     813 *
     814 */
     815const char *str_suffix(const char *s, size_t prefix_length)
     816{
     817        size_t off = 0;
     818        size_t i = 0;
     819
     820        while (true) {
     821                str_decode(s, &off, STR_NO_LIMIT);
     822                i++;
     823
     824                if (i >= prefix_length)
     825                        break;
     826        }
     827
     828        return s + off;
    803829}
    804830

  • uspace/lib/c/generic/str_error.c

    rb401b33 re28175d  
    6363
    6464#undef __errno_entry
    65 #define __errno_entry(name, num, desc) "[" #name "]" desc,
     65#define __errno_entry(name, num, desc) "[" #name "] " desc,
    6666
    6767static const char *err_desc[] = {

  • uspace/lib/c/generic/task.c

    rb401b33 re28175d  
    3535 */
    3636
     37#include <async.h>
    3738#include <task.h>
    3839#include <loader/loader.h>
    … …  
    4647#include <ns.h>
    4748#include <stdlib.h>
     49#include <udebug.h>
    4850#include <libc.h>
    4951#include "private/ns.h"
    … …  
    9496 * This is really just a convenience wrapper over the more complicated
    9597 * loader API. Arguments are passed as a null-terminated array of strings.
     98 * A debug session is created optionally.
    9699 *
    97100 * @param id   If not NULL, the ID of the task is stored here on success.
    … …  
    100103 * @param path Pathname of the binary to execute.
    101104 * @param argv Command-line arguments.
    102  *
    103  * @return Zero on success or an error code.
    104  *
    105  */
    106 errno_t task_spawnv(task_id_t *id, task_wait_t *wait, const char *path,
    107     const char *const args[])
     105 * @param rsess   Place to store pointer to debug session or @c NULL
     106 *                not to start a debug session
     107 *
     108 * @return Zero on success or an error code.
     109 *
     110 */
     111errno_t task_spawnv_debug(task_id_t *id, task_wait_t *wait, const char *path,
     112    const char *const args[], async_sess_t **rsess)
    108113{
    109114        /* Send default files */
    … …  
    125130        }
    126131
    127         return task_spawnvf(id, wait, path, args, fd_stdin, fd_stdout,
    128             fd_stderr);
     132        return task_spawnvf_debug(id, wait, path, args, fd_stdin, fd_stdout,
     133            fd_stderr, rsess);
    129134}
    130135
    131136/** Create a new task by running an executable from the filesystem.
     137 *
     138 * This is really just a convenience wrapper over the more complicated
     139 * loader API. Arguments are passed as a null-terminated array of strings.
     140 *
     141 * @param id   If not NULL, the ID of the task is stored here on success.
     142 * @param wait If not NULL, setup waiting for task's return value and store
     143 *             the information necessary for waiting here on success.
     144 * @param path Pathname of the binary to execute.
     145 * @param argv Command-line arguments.
     146 *
     147 * @return Zero on success or an error code.
     148 *
     149 */
     150errno_t task_spawnv(task_id_t *id, task_wait_t *wait, const char *path,
     151    const char *const args[])
     152{
     153        return task_spawnv_debug(id, wait, path, args, NULL);
     154}
     155
     156/** Create a new task by loading an executable from the filesystem.
    132157 *
    133158 * This is really just a convenience wrapper over the more complicated
    134159 * loader API. Arguments are passed as a null-terminated array of strings.
    135160 * Files are passed as null-terminated array of pointers to fdi_node_t.
     161 * A debug session is created optionally.
    136162 *
    137163 * @param id      If not NULL, the ID of the task is stored here on success.
    138  * @param wait    If not NULL, setup waiting for task's return value and store
     164 * @param wait    If not NULL, setup waiting for task's return value and store.
    139165 * @param path    Pathname of the binary to execute.
    140  * @param argv    Command-line arguments.
    141  * @param std_in  File to use as stdin.
    142  * @param std_out File to use as stdout.
    143  * @param std_err File to use as stderr.
    144  *
    145  * @return Zero on success or an error code.
    146  *
    147  */
    148 errno_t task_spawnvf(task_id_t *id, task_wait_t *wait, const char *path,
    149     const char *const args[], int fd_stdin, int fd_stdout, int fd_stderr)
    150 {
     166 * @param argv    Command-line arguments
     167 * @param std_in  File to use as stdin
     168 * @param std_out File to use as stdout
     169 * @param std_err File to use as stderr
     170 * @param rsess   Place to store pointer to debug session or @c NULL
     171 *                not to start a debug session
     172 *
     173 * @return Zero on success or an error code
     174 *
     175 */
     176errno_t task_spawnvf_debug(task_id_t *id, task_wait_t *wait,
     177    const char *path, const char *const args[], int fd_stdin, int fd_stdout,
     178    int fd_stderr, async_sess_t **rsess)
     179{
     180        async_sess_t *ksess = NULL;
     181
    151182        /* Connect to a program loader. */
    152         loader_t *ldr = loader_connect();
     183        errno_t rc;
     184        loader_t *ldr = loader_connect(&rc);
    153185        if (ldr == NULL)
    154                 return EREFUSED;
     186                return rc;
    155187
    156188        bool wait_initialized = false;
    … …  
    158190        /* Get task ID. */
    159191        task_id_t task_id;
    160         errno_t rc = loader_get_task_id(ldr, &task_id);
     192        rc = loader_get_task_id(ldr, &task_id);
    161193        if (rc != EOK)
    162194                goto error;
    … …  
    217249        }
    218250
    219         /* Run it. */
    220         rc = loader_run(ldr);
    221         if (rc != EOK)
    222                 goto error;
     251        /* Start a debug session if requested */
     252        if (rsess != NULL) {
     253                ksess = async_connect_kbox(task_id, &rc);
     254                if (ksess == NULL) {
     255                        /* Most likely debugging support is not compiled in */
     256                        goto error;
     257                }
     258
     259                rc = udebug_begin(ksess);
     260                if (rc != EOK)
     261                        goto error;
     262
     263                /*
     264                 * Run it, not waiting for response. It would never come
     265                 * as the loader is stopped.
     266                 */
     267                loader_run_nowait(ldr);
     268        } else {
     269                /* Run it. */
     270                rc = loader_run(ldr);
     271                if (rc != EOK)
     272                        goto error;
     273        }
    223274
    224275        /* Success */
    225276        if (id != NULL)
    226277                *id = task_id;
    227 
     278        if (rsess != NULL)
     279                *rsess = ksess;
    228280        return EOK;
    229281
    230282error:
     283        if (ksess != NULL)
     284                async_hangup(ksess);
    231285        if (wait_initialized)
    232286                task_cancel_wait(wait);
    … …  
    235289        loader_abort(ldr);
    236290        return rc;
     291}
     292
     293/** Create a new task by running an executable from the filesystem.
     294 *
     295 * Arguments are passed as a null-terminated array of strings.
     296 * Files are passed as null-terminated array of pointers to fdi_node_t.
     297 *
     298 * @param id      If not NULL, the ID of the task is stored here on success.
     299 * @param wait    If not NULL, setup waiting for task's return value and store.
     300 * @param path    Pathname of the binary to execute
     301 * @param argv    Command-line arguments
     302 * @param std_in  File to use as stdin
     303 * @param std_out File to use as stdout
     304 * @param std_err File to use as stderr
     305 *
     306 * @return Zero on success or an error code.
     307 *
     308 */
     309errno_t task_spawnvf(task_id_t *id, task_wait_t *wait, const char *path,
     310    const char *const args[], int fd_stdin, int fd_stdout, int fd_stderr)
     311{
     312        return task_spawnvf_debug(id, wait, path, args, fd_stdin, fd_stdout,
     313            fd_stderr, NULL);
    237314}
    238315
    … …  
    325402errno_t task_setup_wait(task_id_t id, task_wait_t *wait)
    326403{
    327         async_sess_t *sess_ns = ns_session_get();
     404        errno_t rc;
     405        async_sess_t *sess_ns = ns_session_get(&rc);
    328406        if (sess_ns == NULL)
    329                 return EIO;
     407                return rc;
    330408
    331409        async_exch_t *exch = async_exchange_begin(sess_ns);
    … …  
    407485errno_t task_retval(int val)
    408486{
    409         async_sess_t *sess_ns = ns_session_get();
     487        errno_t rc;
     488        async_sess_t *sess_ns = ns_session_get(&rc);
    410489        if (sess_ns == NULL)
    411                 return EIO;
     490                return rc;
    412491
    413492        async_exch_t *exch = async_exchange_begin(sess_ns);
    414         errno_t rc = (errno_t) async_req_1_0(exch, NS_RETVAL, val);
     493        rc = (errno_t) async_req_1_0(exch, NS_RETVAL, val);
    415494        async_exchange_end(exch);
    416495

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

    rb401b33 re28175d  
    322322        while (vfs_sess == NULL) {
    323323                vfs_sess = service_connect_blocking(SERVICE_VFS, INTERFACE_VFS,
    324                     0);
     324                    0, NULL);
    325325        }
    326326

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

    rb401b33 re28175d  
    275275
    276276extern async_sess_t *async_connect_me_to(async_exch_t *, iface_t, sysarg_t,
    277     sysarg_t);
     277    sysarg_t, errno_t *);
    278278extern async_sess_t *async_connect_me_to_blocking(async_exch_t *, iface_t,
    279     sysarg_t, sysarg_t);
    280 extern async_sess_t *async_connect_kbox(task_id_t);
     279    sysarg_t, sysarg_t, errno_t *);
     280extern async_sess_t *async_connect_kbox(task_id_t, errno_t *);
    281281
    282282extern errno_t async_connect_to_me(async_exch_t *, iface_t, sysarg_t, sysarg_t);

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

    rb401b33 re28175d  
    3434 */
    3535
    36 #ifndef _LIBC_CAP_H_
    37 #define _LIBC_CAP_H_
     36#ifndef _LIBC_CAPA_H_
     37#define _LIBC_CAPA_H_
    3838
    3939#include <adt/list.h>
    … …  
    5555        cu_zbyte,
    5656        cu_ybyte
    57 } cap_unit_t;
     57} capa_unit_t;
    5858
    5959/** Which of values within the precision of the capacity */
    … …  
    6565        /** The maximum value */
    6666        cv_max
    67 } cap_vsel_t;
     67} capa_vsel_t;
    6868
    6969#define CU_LIMIT (cu_ybyte + 1)
    … …  
    8787        unsigned dp;
    8888        /** Capacity unit */
    89         cap_unit_t cunit;
    90 } cap_spec_t;
     89        capa_unit_t cunit;
     90} capa_spec_t;
    9191
    92 extern errno_t cap_format(cap_spec_t *, char **);
    93 extern errno_t cap_parse(const char *, cap_spec_t *);
    94 extern void cap_simplify(cap_spec_t *);
    95 extern void cap_from_blocks(uint64_t, size_t, cap_spec_t *);
    96 extern errno_t cap_to_blocks(cap_spec_t *, cap_vsel_t, size_t, uint64_t *);
     92extern errno_t capa_format(capa_spec_t *, char **);
     93extern errno_t capa_parse(const char *, capa_spec_t *);
     94extern void capa_simplify(capa_spec_t *);
     95extern void capa_from_blocks(uint64_t, size_t, capa_spec_t *);
     96extern errno_t capa_to_blocks(capa_spec_t *, capa_vsel_t, size_t, uint64_t *);
    9797
    9898#endif

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

    rb401b33 re28175d  
    4444
    4545extern errno_t loader_spawn(const char *);
    46 extern loader_t *loader_connect(void);
     46extern loader_t *loader_connect(errno_t *);
    4747extern errno_t loader_get_task_id(loader_t *, task_id_t *);
    4848extern errno_t loader_set_cwd(loader_t *);
    … …  
    5353extern errno_t loader_load_program(loader_t *);
    5454extern errno_t loader_run(loader_t *);
     55extern void loader_run_nowait(loader_t *);
    5556extern void loader_abort(loader_t *);
    5657

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

    rb401b33 re28175d  
    4343    void *);
    4444extern errno_t service_register_broker(service_t, async_port_handler_t, void *);
    45 extern async_sess_t *service_connect(service_t, iface_t, sysarg_t);
    46 extern async_sess_t *service_connect_blocking(service_t, iface_t, sysarg_t);
     45extern async_sess_t *service_connect(service_t, iface_t, sysarg_t, errno_t *);
     46extern async_sess_t *service_connect_blocking(service_t, iface_t, sysarg_t,
     47    errno_t *);
    4748
    4849extern errno_t ns_ping(void);
    4950extern errno_t ns_intro(task_id_t);
    50 extern async_sess_t *ns_session_get(void);
     51extern async_sess_t *ns_session_get(errno_t *);
    5152
    5253#endif

  • uspace/lib/c/include/rtld/rtld_arch.h

    rb401b33 re28175d  
    4343void rel_table_process(module_t *m, elf_rel_t *rt, size_t rt_size);
    4444void rela_table_process(module_t *m, elf_rela_t *rt, size_t rt_size);
     45void *func_get_addr(elf_symbol_t *, module_t *);
    4546
    4647void program_run(void *entry, pcb_t *pcb);

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

    rb401b33 re28175d  
    5252
    5353extern stats_thread_t *stats_get_threads(size_t *);
     54extern stats_ipcc_t *stats_get_ipccs(size_t *);
    5455
    5556extern stats_exc_t *stats_get_exceptions(size_t *);

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

    rb401b33 re28175d  
    9898
    9999extern bool str_test_prefix(const char *s, const char *p);
     100extern const char *str_suffix(const char *s, size_t prefix_length);
    100101
    101102extern void str_cpy(char *dest, size_t size, const char *src);

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

    rb401b33 re28175d  
    3636#define _LIBC_TASK_H_
    3737
     38#include <async.h>
    3839#include <stdint.h>
    3940#include <stdarg.h>
    … …  
    5657extern errno_t task_spawnv(task_id_t *, task_wait_t *, const char *path,
    5758    const char *const []);
     59extern errno_t task_spawnv_debug(task_id_t *, task_wait_t *, const char *path,
     60    const char *const [], async_sess_t **);
    5861extern errno_t task_spawnvf(task_id_t *, task_wait_t *, const char *path,
    5962    const char *const [], int, int, int);
     63extern errno_t task_spawnvf_debug(task_id_t *, task_wait_t *, const char *path,
     64    const char *const [], int, int, int, async_sess_t **);
    6065extern errno_t task_spawn(task_id_t *, task_wait_t *, const char *path, int,
    6166    va_list ap);

  • uspace/lib/c/test/capa.c

    rb401b33 re28175d  
    2828
    2929#include <pcut/pcut.h>
    30 #include <cap.h>
     30#include <capa.h>
    3131
    3232PCUT_INIT;
    3333
    34 PCUT_TEST_SUITE(cap);
    35 
    36 PCUT_TEST(cap_format)
     34PCUT_TEST_SUITE(capa);
     35
     36PCUT_TEST(capa_format)
    3737{
    3838        int block_size = 4;
    … …  
    8686        };
    8787
    88         cap_spec_t cap;
     88        capa_spec_t capa;
    8989        char *str;
    9090        errno_t rc;
    … …  
    9393        for (i = 0; i < input_size; i++) {
    9494                for (x = 0; x < block_size; x++) {
    95                         cap_from_blocks(input[i], block[x], &cap);
    96                         cap_simplify(&cap);
    97 
    98                         rc = cap_format(&cap, &str);
     95                        capa_from_blocks(input[i], block[x], &capa);
     96                        capa_simplify(&capa);
     97
     98                        rc = capa_format(&capa, &str);
    9999
    100100                        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    … …  
    102102                        free(str);
    103103
    104                         cap_from_blocks(block[x], input[i], &cap);
    105                         cap_simplify(&cap);
    106 
    107                         rc = cap_format(&cap, &str);
     104                        capa_from_blocks(block[x], input[i], &capa);
     105                        capa_simplify(&capa);
     106
     107                        rc = capa_format(&capa, &str);
    108108
    109109                        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    … …  
    114114}
    115115
    116 PCUT_TEST(cap_format_rounding)
     116PCUT_TEST(capa_format_rounding)
    117117{
    118118        int input_size = 8;
    … …  
    139139        };
    140140
    141         cap_spec_t cap;
     141        capa_spec_t capa;
    142142        char *str;
    143143        errno_t rc;
    … …  
    145145        int i;
    146146        for (i = 0; i < input_size; i++) {
    147                 cap_from_blocks(input[i], 1, &cap);
    148                 cap_simplify(&cap);
    149 
    150                 rc = cap_format(&cap, &str);
     147                capa_from_blocks(input[i], 1, &capa);
     148                capa_simplify(&capa);
     149
     150                rc = capa_format(&capa, &str);
    151151
    152152                PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    … …  
    154154                free(str);
    155155
    156                 cap_from_blocks(1, input[i], &cap);
    157                 cap_simplify(&cap);
    158 
    159                 rc = cap_format(&cap, &str);
     156                capa_from_blocks(1, input[i], &capa);
     157                capa_simplify(&capa);
     158
     159                rc = capa_format(&capa, &str);
    160160
    161161                PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    … …  
    165165}
    166166
    167 PCUT_TEST(cap_parse)
     167PCUT_TEST(capa_parse)
    168168{
    169169        int input_size = 4;
    … …  
    196196        };
    197197
    198         cap_spec_t cap;
     198        capa_spec_t capa;
    199199        errno_t rc;
    200200        int i;
    201201
    202202        for (i = 0; i < input_size; i++) {
    203                 rc = cap_parse(input[i], &cap);
    204 
    205                 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    206                 PCUT_ASSERT_INT_EQUALS(out_cunit[i], cap.cunit);
    207                 PCUT_ASSERT_INT_EQUALS(out_dp[i], cap.dp);
    208                 PCUT_ASSERT_INT_EQUALS(out_m[i], cap.m);
    209         }
    210 }
    211 
    212 PCUT_TEST(cap_to_blocks)
     203                rc = capa_parse(input[i], &capa);
     204
     205                PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     206                PCUT_ASSERT_INT_EQUALS(out_cunit[i], capa.cunit);
     207                PCUT_ASSERT_INT_EQUALS(out_dp[i], capa.dp);
     208                PCUT_ASSERT_INT_EQUALS(out_m[i], capa.m);
     209        }
     210}
     211
     212PCUT_TEST(capa_to_blocks)
    213213{
    214214        int input_size = 0;
    … …  
    261261        };
    262262
    263         cap_spec_t cap;
     263        capa_spec_t capa;
    264264        errno_t rc;
    265265        int i;
    … …  
    267267
    268268        for (i = 0; i < input_size; i++) {
    269                 cap.m = input_m[i];
    270                 cap.dp = input_dp[i];
    271                 cap.cunit = cu_kbyte;
    272 
    273                 rc = cap_to_blocks(&cap, cv_nom, block[i], &ret);
     269                capa.m = input_m[i];
     270                capa.dp = input_dp[i];
     271                capa.cunit = cu_kbyte;
     272
     273                rc = capa_to_blocks(&capa, cv_nom, block[i], &ret);
    274274                PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    275275                PCUT_ASSERT_INT_EQUALS(out_nom[i], ret);
    276276
    277                 rc = cap_to_blocks(&cap, cv_min, block[i], &ret);
     277                rc = capa_to_blocks(&capa, cv_min, block[i], &ret);
    278278                PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    279279                PCUT_ASSERT_INT_EQUALS(out_min[i], ret);
    280280
    281                 rc = cap_to_blocks(&cap, cv_max, block[i], &ret);
     281                rc = capa_to_blocks(&capa, cv_max, block[i], &ret);
    282282                PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    283283                PCUT_ASSERT_INT_EQUALS(out_max[i], ret);
    … …  
    285285}
    286286
    287 PCUT_EXPORT(cap);
     287PCUT_EXPORT(capa);

  • uspace/lib/c/test/getopt.c

    rb401b33 re28175d  
    278278                "get_opt_test",
    279279                "-f",
    280                 "-p",
    281                 "param"
     280                "-pparam"
    282281        };
    283282

  • uspace/lib/c/test/main.c

    rb401b33 re28175d  
    3232PCUT_INIT;
    3333
    34 PCUT_IMPORT(cap);
     34PCUT_IMPORT(capa);
    3535PCUT_IMPORT(casting);
    3636PCUT_IMPORT(circ_buf);

  • uspace/lib/c/test/stdio/scanf.c

    rb401b33 re28175d  
    4343
    4444#pragma GCC diagnostic ignored "-Wformat-zero-length"
     45#pragma GCC diagnostic ignored "-Wformat"
     46#pragma GCC diagnostic ignored "-Wformat-extra-args"
    4547
    4648PCUT_INIT;

  • uspace/lib/c/test/string.c

    rb401b33 re28175d  
    2828
    2929/* Prevent an error from being generated */
    30 #undef _HELENOS_SOURCE
     30#define _REALLY_WANT_STRING_H
    3131#include <string.h>
    32 #define _HELENOS_SOURCE
    3332#include <pcut/pcut.h>
    3433
Note: See TracChangeset for help on using the changeset viewer.