Changeset 694ca93f in mainline for uspace/lib


Ignore:
Timestamp:
2011-05-01T19:34:26Z (15 years ago)
Author:
Martin Sucha <sucha14@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
0e26444
Parents:
1ff896e (diff), 042fbe0 (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
Files:
16 added
69 edited
16 moved

Legend:

Unmodified
Added
Removed

  • uspace/lib/block/libblock.c

    r1ff896e r694ca93f  
    5252#include <macros.h>
    5353#include <mem.h>
     54#include <malloc.h>
     55#include <stdio.h>
    5456#include <sys/typefmt.h>
    5557#include <stacktrace.h>

  • uspace/lib/c/Makefile

    r1ff896e r694ca93f  
    4141CONFIG_MAKEFILE = $(ROOT_PATH)/Makefile.config
    4242
     43LINKER_SCRIPTS = \
     44        $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld \
     45        $(LIBC_PREFIX)/arch/$(UARCH)/_link-loader.ld \
     46        $(LIBC_PREFIX)/arch/$(UARCH)/_link-shlib.ld \
     47        $(LIBC_PREFIX)/arch/$(UARCH)/_link-dlexe.ld
     48
    4349PRE_DEPEND = $(INCLUDE_KERNEL) $(INCLUDE_ARCH) $(INCLUDE_LIBARCH) $(COMMON_HEADER_ARCH)
    44 EXTRA_OUTPUT = $(LINKER_SCRIPT)
    45 EXTRA_CLEAN = $(INCLUDE_KERNEL) $(INCLUDE_ARCH) $(INCLUDE_LIBARCH) $(COMMON_HEADER_ARCH) $(LINKER_SCRIPT)
     50EXTRA_OUTPUT = $(LINKER_SCRIPTS)
     51EXTRA_CLEAN = $(INCLUDE_KERNEL) $(INCLUDE_ARCH) $(INCLUDE_LIBARCH) $(COMMON_HEADER_ARCH) $(LINKER_SCRIPTS)
    4652LIBRARY = libc
     53SLIBRARY = libc.so.0.0
     54LSONAME = libc.so0
     55
    4756
    4857-include $(COMMON_MAKEFILE)
    4958-include $(CONFIG_MAKEFILE)
    5059-include arch/$(UARCH)/Makefile.inc
     60
     61EXTRA_CFLAGS += -I../../srv/loader/include
    5162
    5263GENERIC_SOURCES = \
    … …  
    7687        generic/io/io.c \
    7788        generic/io/printf.c \
     89        generic/io/log.c \
    7890        generic/io/klog.c \
    7991        generic/io/snprintf.c \
    … …  
    112124        generic/arg_parse.c \
    113125        generic/sort.c \
    114         generic/stats.c
     126        generic/stats.c \
     127        generic/assert.c
     128
     129ifeq ($(CONFIG_RTLD), y)
     130        GENERIC_SOURCES += \
     131                generic/dlfcn.c \
     132                generic/rtld/rtld.c \
     133                generic/rtld/elf_load.c \
     134                generic/rtld/dynamic.c \
     135                generic/rtld/module.c \
     136                generic/rtld/symbol.c
     137endif
    115138
    116139SOURCES = \
    … …  
    131154        ln -sfn ../$< $@
    132155
    133 $(LINKER_SCRIPT): $(LINKER_SCRIPT).in
     156$(LIBC_PREFIX)/arch/$(UARCH)/_link.ld: $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld.in
    134157        $(GCC) $(DEFS) $(CFLAGS) -DLIBC_PATH=$(CURDIR) -E -x c $< | grep -v "^\#" > $@
     158
     159$(LIBC_PREFIX)/arch/$(UARCH)/_link-loader.ld: $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld.in
     160        $(GCC) $(DEFS) $(CFLAGS) -DLIBC_PATH=$(CURDIR) -DLOADER -E -x c $< | grep -v "^\#" > $@
     161
     162$(LIBC_PREFIX)/arch/$(UARCH)/_link-shlib.ld: $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld.in
     163        $(GCC) $(DEFS) $(CFLAGS) -DLIBC_PATH=$(CURDIR) -DSHLIB -E -x c $< | grep -v "^\#" > $@
     164
     165$(LIBC_PREFIX)/arch/$(UARCH)/_link-dlexe.ld: $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld.in
     166        $(GCC) $(DEFS) $(CFLAGS) -DLIBC_PATH=$(CURDIR) -DDLEXE -E -x c $< | grep -v "^\#" > $@
    135167
    136168$(COMMON_HEADER_ARCH): $(COMMON_HEADER)

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

    r1ff896e r694ca93f  
    2929ARCH_SOURCES = \
    3030        arch/$(UARCH)/src/entry.c \
     31        arch/$(UARCH)/src/entryjmp.c \
    3132        arch/$(UARCH)/src/thread_entry.c \
    3233        arch/$(UARCH)/src/fibril.c \

  • uspace/lib/c/arch/abs32le/_link.ld.in

    r1ff896e r694ca93f  
    33
    44PHDRS {
     5#ifdef LOADER
     6        interp PT_INTERP;
     7        text PT_LOAD FILEHDR PHDRS FLAGS(5);
     8#else
    59        text PT_LOAD FLAGS(5);
     10#endif
    611        data PT_LOAD FLAGS(6);
    712}
    813
    914SECTIONS {
     15#ifdef LOADER
     16        .interp : {
     17                *(.interp);
     18        } :interp
     19       
     20        . = 0x70001000 + SIZEOF_HEADERS;
     21#else
    1022        . = 0x1000 + SIZEOF_HEADERS;
    11        
     23#endif
    1224        .text : {
    13                 *(.text);
    14                 *(.rodata*);
     25                *(.text .text.*);
     26                *(.rodata .rodata.*);
    1527        } :text
    1628       

  • uspace/lib/c/arch/abs32le/src/entryjmp.c

    r1ff896e r694ca93f  
    3131
    3232#include <bool.h>
    33 #include "arch.h"
     33#include <entry_point.h>
    3434
    35 void program_run(void *entry_point, void *pcb)
     35/** Jump to program entry point. */
     36void entry_point_jmp(void *entry_point, void *pcb)
    3637{
    3738        while (true);

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

    r1ff896e r694ca93f  
    2929ARCH_SOURCES = \
    3030        arch/$(UARCH)/src/entry.s \
     31        arch/$(UARCH)/src/entryjmp.s \
    3132        arch/$(UARCH)/src/thread_entry.s \
    3233        arch/$(UARCH)/src/syscall.S \

  • uspace/lib/c/arch/amd64/_link.ld.in

    r1ff896e r694ca93f  
    33
    44PHDRS {
     5#ifdef LOADER
     6        interp PT_INTERP;
     7        text PT_LOAD FILEHDR PHDRS FLAGS(5);
     8#else
    59        text PT_LOAD FLAGS(5);
     10#endif
    611        data PT_LOAD FLAGS(6);
    712        debug PT_NOTE;
    … …  
    914
    1015SECTIONS {
     16#ifdef LOADER
     17        .interp : {
     18                *(.interp);
     19        } :interp
     20       
     21        . = 0x70001000 + SIZEOF_HEADERS;
     22#else
    1123        . = 0x1000 + SIZEOF_HEADERS;
    12        
     24#endif
    1325        .init : {
    1426                *(.init);
    … …  
    1628       
    1729        .text : {
    18                 *(.text);
    19                 *(.rodata*);
     30                *(.text .text.*);
     31                *(.rodata .rodata.*);
    2032        } :text
    2133       

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

    r1ff896e r694ca93f  
    2727#
    2828
    29 .globl program_run
     29.globl entry_point_jmp
    3030
    31 ## void program_run(void *entry_point, void *pcb);
     31## void entry_point_jmp(void *entry_point, void *pcb);
    3232#
    3333# %rdi  contains entry_point
    3434# %rsi  contains pcb
    3535#
    36 # Jump to a program entry point
    37 program_run:
     36# Jump to program entry point
     37entry_point_jmp:
    3838        # pcb must be passed in %rdi, use %rdx as a scratch register
    3939        mov %rdi, %rdx

  • uspace/lib/c/arch/arm32/Makefile.inc

    r1ff896e r694ca93f  
    3030ARCH_SOURCES = \
    3131        arch/$(UARCH)/src/entry.s \
     32        arch/$(UARCH)/src/entryjmp.s \
    3233        arch/$(UARCH)/src/thread_entry.s \
    3334        arch/$(UARCH)/src/syscall.c \

  • uspace/lib/c/arch/arm32/_link.ld.in

    r1ff896e r694ca93f  
    33
    44PHDRS {
     5#ifdef LOADER
     6        interp PT_INTERP;
     7        text PT_LOAD FILEHDR PHDRS FLAGS(5);
     8#else
    59        text PT_LOAD FLAGS(5);
     10#endif
    611        data PT_LOAD FLAGS(6);
    712}
    813
    914SECTIONS {
     15#ifdef LOADER
     16        .interp : {
     17                *(.interp);
     18        } :interp
     19       
     20        . = 0x70001000 + SIZEOF_HEADERS;
     21#else
    1022        . = 0x1000 + SIZEOF_HEADERS;
    11        
     23#endif
    1224        .init : {
    1325                *(.init);
    … …  
    1527       
    1628        .text : {
    17                 *(.text);
    18                 *(.rodata*);
     29                *(.text .text.*);
     30                *(.rodata .rodata.*);
    1931        } :text
    2032       

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

    r1ff896e r694ca93f  
    2727#
    2828
    29 .globl program_run
     29.globl entry_point_jmp
    3030
    31 ## void program_run(void *entry_point, void *pcb);
     31## void entry_point_jmp(void *entry_point, void *pcb);
    3232#
    3333# r0    contains entry_point
    3434# r1    contains pcb
    3535#
    36 # Jump to a program entry point
    37 program_run:
     36# Jump to program entry point
     37entry_point_jmp:
    3838        # load ras_page address to r2
    3939        ldr r2, =ras_page

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

    r1ff896e r694ca93f  
    2929ARCH_SOURCES = \
    3030        arch/$(UARCH)/src/entry.s \
     31        arch/$(UARCH)/src/entryjmp.s \
    3132        arch/$(UARCH)/src/thread_entry.s \
    3233        arch/$(UARCH)/src/syscall.S \
    … …  
    3536        arch/$(UARCH)/src/setjmp.S \
    3637        arch/$(UARCH)/src/stacktrace.c \
    37         arch/$(UARCH)/src/stacktrace_asm.S
     38        arch/$(UARCH)/src/stacktrace_asm.S \
     39        arch/$(UARCH)/src/rtld/dynamic.c \
     40        arch/$(UARCH)/src/rtld/reloc.c
    3841
    3942.PRECIOUS: arch/$(UARCH)/src/entry.o

  • uspace/lib/c/arch/ia32/_link.ld.in

    r1ff896e r694ca93f  
     1#ifndef SHLIB
    12STARTUP(LIBC_PATH/arch/UARCH/src/entry.o)
    23ENTRY(__entry)
     4#endif
    35
    46PHDRS {
     7#if defined(LOADER) || defined(DLEXE)
     8        interp PT_INTERP;
     9        text PT_LOAD FILEHDR PHDRS FLAGS(5);
     10#else
    511        text PT_LOAD FLAGS(5);
     12#endif
    613        data PT_LOAD FLAGS(6);
     14#if defined(SHLIB) || defined(DLEXE)
     15        dynamic PT_DYNAMIC;
     16#endif
    717        debug PT_NOTE;
    818}
    919
    1020SECTIONS {
     21#if defined(LOADER) || defined(DLEXE)
     22        .interp : {
     23                *(.interp);
     24        } :interp
     25#endif
     26#ifdef LOADER
     27        . = 0x70001000 + SIZEOF_HEADERS;
     28#else
    1129        . = 0x1000 + SIZEOF_HEADERS;
    12        
     30#endif
    1331        .init : {
    1432                *(.init);
    … …  
    1634       
    1735        .text : {
    18                 *(.text);
    19                 *(.rodata*);
     36                *(.text .text.*);
     37                *(.rodata .rodata.*);
     38        } :text
     39
     40#if defined(SHLIB) || defined(DLEXE)
     41        .rel.plt : {
     42                *(.rel.plt);
     43        }
     44        /*
     45         *.rel.dyn MUST FOLLOW IMMEDIATELY after .rel.plt
     46         * without alignment gap or DT_REL will be broken
     47         */
     48        .rel.dyn : {
     49                *(.rel.*);
    2050        } :text
    2151       
     52        .plt : {
     53                *(.plt);
     54        } :text
     55       
     56        .dynsym : {
     57                *(.dynsym);
     58        } :text
     59       
     60        .dynstr : {
     61                *(.dynstr);
     62        } :text
     63       
     64        .hash : {
     65                *(.hash);
     66        } :text
     67#endif
    2268        . = . + 0x1000;
     69       
     70#if defined(SHLIB) || defined(DLEXE)
     71        .dynamic : {
     72                *(.dynamic);
     73        } :data :dynamic
     74#endif
    2375       
    2476        .data : {
    … …  
    2678        } :data
    2779       
     80#if defined(SHLIB) || defined(DLEXE)
     81        .data.rel : {
     82                *(.data.rel .data.rel.*);
     83        } :data
     84
     85        .got : {
     86                *(.got);
     87        } :data
     88        .got.plt : {
     89                *(.got.plt);
     90        } :data
     91#endif
     92       
     93#ifndef DLEXE
    2894        .tdata : {
    2995                _tdata_start = .;
    … …  
    37103       
    38104        _tls_alignment = ALIGNOF(.tdata);
     105#endif
    39106       
    40107        .bss : {
     108                *(.dynbss);
    41109                *(COMMON);
    42110                *(.bss);

  • uspace/lib/c/arch/ia32/include/config.h

    r1ff896e r694ca93f  
    3636#define LIBC_ia32_CONFIG_H_
    3737
    38 #define PAGE_WIDTH      12
    39 #define PAGE_SIZE       (1 << PAGE_WIDTH)
     38#define PAGE_WIDTH  12
     39#define PAGE_SIZE   (1 << PAGE_WIDTH)
     40
     41#define USER_ADDRESS_SPACE_START_ARCH  UINT32_C(0x00000000)
     42#define USER_ADDRESS_SPACE_END_ARCH    UINT32_C(0x7fffffff)
    4043
    4144#endif

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

    r1ff896e r694ca93f  
    3737#include <libarch/types.h>
    3838
    39 #define IO_SPACE_BOUNDARY       ((void *) (64 * 1024))
     39#define IO_SPACE_BOUNDARY  ((void *) (64 * 1024))
    4040
    4141static inline uint8_t pio_read_8(ioport8_t *port)

  • uspace/lib/c/arch/ia32/include/faddr.h

    r1ff896e r694ca93f  
    3838#include <libarch/types.h>
    3939
    40 #define FADDR(fptr)             ((uintptr_t) (fptr))
     40#define FADDR(fptr)  ((uintptr_t) (fptr))
    4141
    4242#endif

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

    r1ff896e r694ca93f  
    4242 * panic sooner or later
    4343 */
    44 #define SP_DELTA     (12)
     44#define SP_DELTA  12
    4545
    4646#define context_set(c, _pc, stack, size, ptls) \
    … …  
    5151                (c)->ebp = 0; \
    5252        } while (0)
    53        
    54 /* We include only registers that must be preserved
     53
     54/*
     55 * We include only registers that must be preserved
    5556 * during function call
    5657 */

  • uspace/lib/c/arch/ia32/include/rtld/dynamic.h

    r1ff896e r694ca93f  
    2727 */
    2828
    29 /** @addtogroup fs
     29/** @addtogroup generic
    3030 * @{
    3131 */
    3232/** @file
    33  * @brief
    3433 */
    3534
    36 #ifndef LOADER_ARCH_H_
    37 #define LOADER_ARCH_H_
     35#ifndef LIBC_ia32_RTLD_DYNAMIC_H_
     36#define LIBC_ia32_RTLD_DYNAMIC_H_
    3837
    39 extern void program_run(void *entry_point, void *pcb);
     38#include <sys/types.h>
     39
     40typedef struct {
     41        /* Empty. */
     42} dyn_info_arch_t;
    4043
    4144#endif
    4245
    43 /**
    44  * @}
     46/** @}
    4547 */

  • uspace/lib/c/arch/ia32/include/rtld/elf_dyn.h

    r1ff896e r694ca93f  
    11/*
    2  * Copyright (c) 2005 Sergey Bondari
     2 * Copyright (c) 2008 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup arm32
     29/** @addtogroup generic
    3030 * @{
    3131 */
    3232/** @file
    33  *  @brief Memory manipulating functions declarations.
    3433 */
    3534
    36 #ifndef KERN_arm32_MEMSTR_H_
    37 #define KERN_arm32_MEMSTR_H_
     35#ifndef LIBC_ia32_RTLD_ELF_DYN_H_
     36#define LIBC_ia32_RTLD_ELF_DYN_H_
    3837
    39 #define memcpy(dst, src, cnt)  __builtin_memcpy((dst), (src), (cnt))
     38/*
     39 * ia32 dynamic relocation types
     40 */
    4041
    41 extern void memsetw(void *, size_t, uint16_t);
    42 extern void memsetb(void *, size_t, uint8_t);
     42#define R_386_32        1
     43#define R_386_PC32      2
     44#define R_386_COPY      5
     45#define R_386_GLOB_DAT  6
     46#define R_386_JUMP_SLOT 7
     47#define R_386_RELATIVE  8
     48
     49#define R_386_TLS_DTPMOD32 35
    4350
    4451#endif

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

    r1ff896e r694ca93f  
    2727#
    2828
    29 .globl program_run
     29.globl entry_point_jmp
    3030
    31 ## void program_run(void *entry_point, void *pcb);
     31## void entry_point_jmp(void *entry_point, void *pcb);
    3232#
    33 # Jump to a program entry point
    34 program_run:
     33# Jump to program entry point
     34entry_point_jmp:
    3535        # Use standard ia32 prologue not to confuse anybody
    3636        push %ebp

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

    r1ff896e r694ca93f  
    11/*
    2  * Copyright (c) 2005 Sergey Bondari
     2 * Copyright (c) 2008 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup ia64
     29/** @addtogroup libcia32
     30 * @brief
    3031 * @{
    3132 */
    32 /** @file
     33/**
     34 * @file
    3335 */
    3436
    35 #ifndef KERN_ia64_MEMSTR_H_
    36 #define KERN_ia64_MEMSTR_H_
     37#include <stdio.h>
     38#include <stdlib.h>
    3739
    38 #define memcpy(dst, src, cnt)  __builtin_memcpy((dst), (src), (cnt))
     40#include <rtld/elf_dyn.h>
     41#include <rtld/dynamic.h>
    3942
    40 extern void memsetw(void *, size_t, uint16_t);
    41 extern void memsetb(void *, size_t, uint8_t);
    42 
    43 #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}
    4449
    4550/** @}

  • uspace/lib/c/arch/ia32/src/stacktrace.c

    r1ff896e r694ca93f  
    3535 */
    3636
     37#include <libarch/config.h>
    3738#include <sys/types.h>
    3839#include <bool.h>
    39 
    4040#include <stacktrace.h>
    4141
    42 #define FRAME_OFFSET_FP_PREV    0
    43 #define FRAME_OFFSET_RA         4
     42#define FRAME_OFFSET_FP_PREV  0
     43#define FRAME_OFFSET_RA       4
    4444
    4545bool stacktrace_fp_valid(stacktrace_t *st, uintptr_t fp)
    4646{
    4747        (void) st;
    48         return fp != 0;
     48        return (fp != 0) && (fp <= USER_ADDRESS_SPACE_END_ARCH);
    4949}
    5050

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

    r1ff896e r694ca93f  
    3232__syscall_fast_func:
    3333        .long __syscall_slow
     34        .size __syscall_fast_func, . - __syscall_fast_func
    3435
    3536.text
    … …  
    7172 */
    7273.global __syscall_fast
     74        .type __syscall_fast, @function
     75
    7376__syscall_fast:
    7477        pushl %ebx
    … …  
    9598        popl %ebx
    9699        ret
     100
     101        .size __syscall_fast, . - __syscall_fast

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

    r1ff896e r694ca93f  
    3737#include <tls.h>
    3838#include <sys/types.h>
     39#include <align.h>
    3940
    4041tcb_t * __alloc_tls(void **data, size_t size)
    … …  
    4849}
    4950
     51/*
     52 * Rtld TLS support
     53 */
     54
     55typedef struct {
     56        unsigned long int ti_module;
     57        unsigned long int ti_offset;
     58} tls_index;
     59
     60void __attribute__ ((__regparm__ (1)))
     61    *___tls_get_addr(tls_index *ti);
     62
     63void __attribute__ ((__regparm__ (1)))
     64    *___tls_get_addr(tls_index *ti)
     65{
     66        size_t tls_size;
     67        uint8_t *tls;
     68
     69        /* Calculate size of TLS block */
     70        tls_size = ALIGN_UP(&_tbss_end - &_tdata_start, &_tls_alignment);
     71
     72        /* The TLS block is just before TCB */
     73        tls = (uint8_t *)__tcb_get() - tls_size;
     74
     75        return tls + ti->ti_offset;
     76}
     77
    5078/** @}
    5179 */

  • uspace/lib/c/arch/ia64/Makefile.inc

    r1ff896e r694ca93f  
    2929ARCH_SOURCES = \
    3030        arch/$(UARCH)/src/entry.s \
     31        arch/$(UARCH)/src/entryjmp.s \
    3132        arch/$(UARCH)/src/thread_entry.s \
    3233        arch/$(UARCH)/src/syscall.S \

  • uspace/lib/c/arch/ia64/_link.ld.in

    r1ff896e r694ca93f  
    33
    44PHDRS {
     5#ifdef LOADER
     6        interp PT_INTERP;
    57        text PT_LOAD FLAGS(5);
     8#else
     9        text PT_LOAD FLAGS(5);
     10#endif
    611        data PT_LOAD FLAGS(6);
    712}
    813
    914SECTIONS {
     15#ifdef LOADER
     16        .interp : {
     17                *(.interp);
     18        } :interp
     19       
     20        . = 0x800000000 + SIZEOF_HEADERS;
     21#else
    1022        . = 0x4000 + SIZEOF_HEADERS;
    11        
     23#endif
     24        /*
     25         * XXX This is just a work around. Problem: .init section does not
     26         * have the proper alignment.
     27         */
     28        . = ALIGN(., 16);
     29
    1230        .init : {
    1331                *(.init);
    … …  
    1533       
    1634        .text : {
    17                 *(.text);
    18                 *(.rodata*);
     35                *(.text .text.*);
     36                *(.rodata .rodata.*);
    1937        } :text
    2038       
    … …  
    2240       
    2341        .got : {
    24                 _gp = .;
    25                 *(.got*);
     42                /* Tell the linker where we expect GP to point. */
     43                __gp = .;
     44                *(.got .got.*);
    2645        } :data
    2746       

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

    r1ff896e r694ca93f  
    3939__entry:
    4040        alloc loc0 = ar.pfs, 0, 1, 2, 0
    41         movl gp = _gp
     41        movl gp = __gp
    4242       
    4343        # Pass PCB pointer as the first argument to __main

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

    r1ff896e r694ca93f  
    2828
    2929.text
    30 .globl program_run
     30.globl entry_point_jmp
    3131
    32 ## void program_run(void *entry_point, void *pcb);
     32## void entry_point_jmp(void *entry_point, void *pcb);
    3333#
    3434# in0 (r32)     contains entry_point
    3535# in1 (r33)     contains pcb
    3636#
    37 # Jump to a program entry point
    38 program_run:
     37# Jump to program entry point
     38entry_point_jmp:
    3939        # Pass pcb to the entry point in r2
    4040

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

    r1ff896e r694ca93f  
    3737        alloc loc0 = ar.pfs, 0, 1, 1, 0
    3838
    39         movl gp = _gp
     39        movl gp = __gp
    4040       
    4141        #

  • uspace/lib/c/arch/mips32/Makefile.inc

    r1ff896e r694ca93f  
    2929ARCH_SOURCES = \
    3030        arch/$(UARCH)/src/entry.s \
     31        arch/$(UARCH)/src/entryjmp.s \
    3132        arch/$(UARCH)/src/thread_entry.s \
    3233        arch/$(UARCH)/src/syscall.c \

  • uspace/lib/c/arch/mips32/_link.ld.in

    r1ff896e r694ca93f  
    33
    44PHDRS {
     5#ifdef LOADER
     6        interp PT_INTERP;
     7        text PT_LOAD FILEHDR PHDRS FLAGS(5);
     8#else
    59        text PT_LOAD FLAGS(5);
     10#endif
    611        data PT_LOAD FLAGS(6);
    712}
    813
    914SECTIONS {
     15#ifdef LOADER
     16        .interp : {
     17                *(.interp);
     18        } :interp
     19       
     20        . = 0x70004000 + SIZEOF_HEADERS;
     21#else
    1022        . = 0x4000 + SIZEOF_HEADERS;
    11        
     23#endif
    1224        .init : {
    1325                *(.init);
    … …  
    1527       
    1628        .text : {
    17                 *(.text);
    18                 *(.rodata*);
     29                *(.text .text.*);
     30                *(.rodata .rodata.*);
    1931        } :text
    2032       

  • uspace/lib/c/arch/mips32/include/atomic.h

    r1ff896e r694ca93f  
    7070                "       sc %0, %1\n"
    7171                "       beq %0, %4, 1b\n"       /* if the atomic operation failed, try again */
    72                 /*      nop     */              /* nop is inserted automatically by compiler */
    7372                "       nop\n"
    7473                : "=&r" (tmp),

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

    r1ff896e r694ca93f  
    2929.text
    3030.section .text
    31 .global program_run
     31.global entry_point_jmp
    3232.set noreorder
    3333
    34 ## void program_run(void *entry_point, void *pcb);
     34## void entry_point_jmp(void *entry_point, void *pcb);
    3535#
    3636# $a0 (=$4)     contains entry_point
    3737# $a1 (=$5)     contains pcb
    3838#
    39 # Jump to a program entry point
    40 .ent program_run
    41 program_run:
     39# Jump to program entry point
     40.ent entry_point_jmp
     41entry_point_jmp:
    4242        # tmp := entry_point
    4343        move $25, $a0

  • uspace/lib/c/arch/mips32eb/Makefile.inc

    r1ff896e r694ca93f  
    2929ARCH_SOURCES = \
    3030        arch/$(UARCH)/src/entry.s \
     31        arch/$(UARCH)/src/entryjmp.s \
    3132        arch/$(UARCH)/src/thread_entry.s \
    3233        arch/$(UARCH)/src/syscall.c \

  • uspace/lib/c/arch/ppc32/Makefile.inc

    r1ff896e r694ca93f  
    2929ARCH_SOURCES = \
    3030        arch/$(UARCH)/src/entry.s \
     31        arch/$(UARCH)/src/entryjmp.s \
    3132        arch/$(UARCH)/src/thread_entry.s \
    3233        arch/$(UARCH)/src/syscall.c \

  • uspace/lib/c/arch/ppc32/_link.ld.in

    r1ff896e r694ca93f  
    33
    44PHDRS {
     5#ifdef LOADER
     6        interp PT_INTERP;
     7        text PT_LOAD FILEHDR PHDRS FLAGS(5);
     8#else
    59        text PT_LOAD FLAGS(5);
     10#endif
    611        data PT_LOAD FLAGS(6);
    712}
    813
    914SECTIONS {
     15#ifdef LOADER
     16        .interp : {
     17                *(.interp);
     18        } :interp
     19       
     20        . = 0x70001000 + SIZEOF_HEADERS;
     21#else
    1022        . = 0x1000 + SIZEOF_HEADERS;
    11        
     23#endif
    1224        .init : {
    1325                *(.init);
    … …  
    1527       
    1628        .text : {
    17                 *(.text);
    18                 *(.rodata*);
     29                *(.text .text.*);
     30                *(.rodata .rodata.*);
    1931        } :text
    2032       

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

    r1ff896e r694ca93f  
    2727#
    2828
    29 .globl program_run
     29.globl entry_point_jmp
    3030
    31 ## void program_run(void *entry_point, void *pcb);
     31## void entry_point_jmp(void *entry_point, void *pcb);
    3232#
    3333# %r3   contains entry_point
    3434# %r4   contains pcb
    3535#
    36 # Jump to a program entry point
    37 program_run:
     36# Jump to program entry point
     37entry_point_jmp:
    3838        mtctr %r3
    3939        mr %r6, %r4     # Pass pcb to the entry point in %r6

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

    r1ff896e r694ca93f  
    2929ARCH_SOURCES = \
    3030        arch/$(UARCH)/src/entry.s \
     31        arch/$(UARCH)/src/entryjmp.s \
    3132        arch/$(UARCH)/src/thread_entry.s \
    3233        arch/$(UARCH)/src/fibril.S \

  • uspace/lib/c/arch/sparc64/_link.ld.in

    r1ff896e r694ca93f  
    33
    44PHDRS {
     5#ifdef LOADER
     6        interp PT_INTERP;
     7        text PT_LOAD FILEHDR PHDRS FLAGS(5);
     8#else
    59        text PT_LOAD FLAGS(5);
     10#endif
    611        data PT_LOAD FLAGS(6);
    712}
    813
    914SECTIONS {
     15#ifdef LOADER
     16        .interp : {
     17                *(.interp);
     18        } :interp
     19       
     20        . = 0x70004000 + SIZEOF_HEADERS;
     21#else
    1022        . = 0x4000 + SIZEOF_HEADERS;
    11        
     23#endif
    1224        .init : {
    1325                *(.init);
    … …  
    1527       
    1628        .text : {
    17                 *(.text);
    18                 *(.rodata*);
     29                *(.text .text.*);
     30                *(.rodata .rodata.*);
    1931        } :text
    2032       

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

    r1ff896e r694ca93f  
    2727#
    2828
    29 .globl program_run
     29.globl entry_point_jmp
    3030
    31 ## void program_run(void *entry_point, void *pcb);
     31## void entry_point_jmp(void *entry_point, void *pcb);
    3232#
    3333# %o0   contains entry_point
    3434# %o1   contains pcb
    3535#
    36 # Jump to a program entry point
    37 program_run:
     36# Jump to program entry point
     37entry_point_jmp:
    3838        # Pass pcb pointer to entry point in %o1. As it is already
    3939        # there, no action is needed.

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

    r1ff896e r694ca93f  
    7474        new->length = length;
    7575        new->value = ((uint8_t *) new) + sizeof(measured_string_t);
    76         // append terminating zero explicitly - to be safe
     76        /* Append terminating zero explicitly - to be safe */
    7777        memcpy(new->value, string, new->length);
    7878        new->value[new->length] = '\0';

  • uspace/lib/c/generic/assert.c

    r1ff896e r694ca93f  
    11/*
    2  * Copyright (c) 2010 Martin Decky
     2 * Copyright (c) 2011 Martin Decky
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup abs32le
     29/** @addtogroup libc
    3030 * @{
    3131 */
    32 /** @file
    33  */
    3432
    35 #ifndef KERN_abs32le_MEMSTR_H_
    36 #define KERN_abs32le_MEMSTR_H_
     33#include <assert.h>
     34#include <stdio.h>
     35#include <stdlib.h>
     36#include <stacktrace.h>
    3737
    38 #define memcpy(dst, src, cnt)   _memcpy((dst), (src), (cnt))
    39 #define memsetb(dst, cnt, val)  _memsetb((dst), (cnt), (val))
    40 #define memsetw(dst, cnt, val)  _memsetw((dst), (cnt), (val))
    41 
    42 #endif
     38void assert_abort(const char *cond, const char *file, unsigned int line)
     39{
     40        printf("Assertion failed (%s) in file \"%s\", line %u.\n",
     41            cond, file, line);
     42        stacktrace_print();
     43        abort();
     44}
    4345
    4446/** @}

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

    r1ff896e r694ca93f  
    102102#include <arch/barrier.h>
    103103#include <bool.h>
     104#include <stdlib.h>
     105#include <malloc.h>
    104106#include "private/async.h"
    105107
    … …  
    15721574 * @param dst     Address of the beginning of the destination buffer.
    15731575 * @param size    Size of the destination buffer.
     1576 * @param flags   Flags to control the data transfer.
    15741577 *
    15751578 * @return Zero on success or a negative error code from errno.h.
    15761579 *
    15771580 */
    1578 int async_data_read_start(int phoneid, void *dst, size_t size)
    1579 {
    1580         return async_req_2_0(phoneid, IPC_M_DATA_READ, (sysarg_t) dst,
    1581             (sysarg_t) size);
     1581int
     1582async_data_read_start_generic(int phoneid, void *dst, size_t size, int flags)
     1583{
     1584        return async_req_3_0(phoneid, IPC_M_DATA_READ, (sysarg_t) dst,
     1585            (sysarg_t) size, (sysarg_t) flags);
    15821586}
    15831587
    … …  
    16691673 * @param src     Address of the beginning of the source buffer.
    16701674 * @param size    Size of the source buffer.
     1675 * @param flags   Flags to control the data transfer.
    16711676 *
    16721677 * @return Zero on success or a negative error code from errno.h.
    16731678 *
    16741679 */
    1675 int async_data_write_start(int phoneid, const void *src, size_t size)
    1676 {
    1677         return async_req_2_0(phoneid, IPC_M_DATA_WRITE, (sysarg_t) src,
    1678             (sysarg_t) size);
     1680int
     1681async_data_write_start_generic(int phoneid, const void *src, size_t size,
     1682    int flags)
     1683{
     1684        return async_req_3_0(phoneid, IPC_M_DATA_WRITE, (sysarg_t) src,
     1685            (sysarg_t) size, (sysarg_t) flags);
    16791686}
    16801687

  • uspace/lib/c/generic/async_sess.c

    r1ff896e r694ca93f  
    105105#include <errno.h>
    106106#include <assert.h>
     107#include <async.h>
    107108#include "private/async_sess.h"
    108109

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

    r1ff896e r694ca93f  
    147147                ret = devman_send_match_id(phone, match_id);
    148148                if (ret != EOK) {
    149                         printf("Driver failed to send match id, error %d\n",
    150                             ret);
    151149                        return ret;
    152150                }
    … …  
    195193        }
    196194       
    197         devman_send_match_ids(phone, match_ids);
    198        
    199         async_wait_for(req, &retval);
    200        
    201         async_serialize_end();
    202        
     195        int match_ids_rc = devman_send_match_ids(phone, match_ids);
     196       
     197        async_wait_for(req, &retval);
     198       
     199        async_serialize_end();
     200       
     201        /* Prefer the answer to DEVMAN_ADD_FUNCTION in case of errors. */
     202        if ((match_ids_rc != EOK) && (retval == EOK)) {
     203                retval = match_ids_rc;
     204        }
     205
    203206        if (retval == EOK)
    204207                fun_handle = (int) IPC_GET_ARG1(answer);
    … …  
    326329}
    327330
     331int devman_device_get_handle_by_class(const char *classname,
     332    const char *devname, devman_handle_t *handle, unsigned int flags)
     333{
     334        int phone = devman_get_phone(DEVMAN_CLIENT, flags);
     335
     336        if (phone < 0)
     337                return phone;
     338
     339        async_serialize_start();
     340
     341        ipc_call_t answer;
     342        aid_t req = async_send_1(phone, DEVMAN_DEVICE_GET_HANDLE_BY_CLASS,
     343            flags, &answer);
     344
     345        sysarg_t retval = async_data_write_start(phone, classname,
     346            str_size(classname));
     347        if (retval != EOK) {
     348                async_wait_for(req, NULL);
     349                async_serialize_end();
     350                return retval;
     351        }
     352        retval = async_data_write_start(phone, devname,
     353            str_size(devname));
     354        if (retval != EOK) {
     355                async_wait_for(req, NULL);
     356                async_serialize_end();
     357                return retval;
     358        }
     359
     360        async_wait_for(req, &retval);
     361
     362        async_serialize_end();
     363
     364        if (retval != EOK) {
     365                if (handle != NULL)
     366                        *handle = (devman_handle_t) -1;
     367                return retval;
     368        }
     369
     370        if (handle != NULL)
     371                *handle = (devman_handle_t) IPC_GET_ARG1(answer);
     372
     373        return retval;
     374}
     375
    328376
    329377/** @}

  • uspace/lib/c/generic/errno.c

    r1ff896e r694ca93f  
    3636#include <fibril.h>
    3737
    38 int _errno;
     38static fibril_local int fibril_errno;
     39
     40int *__errno(void)
     41{
     42        return &fibril_errno;
     43}
    3944
    4045/** @}

  • uspace/lib/c/generic/fibril_synch.c

    r1ff896e r694ca93f  
    4343#include <stacktrace.h>
    4444#include <stdlib.h>
     45#include <stdio.h>
    4546#include "private/async.h"
    4647

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

    r1ff896e r694ca93f  
    173173                }
    174174                *flags = (O_APPEND | O_CREAT) | (plus ? O_RDWR : O_WRONLY);
     175                break;
    175176        default:
    176177                errno = EINVAL;

  • uspace/lib/c/generic/libc.c

    r1ff896e r694ca93f  
    5353#include "private/io.h"
    5454
     55#ifdef CONFIG_RTLD
     56#include <rtld/rtld.h>
     57#endif
     58
    5559static bool env_setup = false;
    5660
    … …  
    7781        char **argv;
    7882       
     83#ifdef __IN_SHARED_LIBC__
     84        if (__pcb != NULL && __pcb->rtld_runtime != NULL) {
     85                runtime_env = (runtime_env_t *) __pcb->rtld_runtime;
     86        }
     87#endif
    7988        /*
    8089         * Get command line arguments and initialize

  • uspace/lib/c/generic/malloc.c

    r1ff896e r694ca93f  
    4444#include <mem.h>
    4545#include <futex.h>
     46#include <stdlib.h>
    4647#include <adt/gcdlcm.h>
    4748#include "private/malloc.h"

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

    r1ff896e r694ca93f  
    190190                }
    191191        }
    192         gpm_destroy(&pm_globals.packet_map);
     192        gpm_destroy(&pm_globals.packet_map, free);
    193193        /* leave locked */
    194194}

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

    r1ff896e r694ca93f  
    749749        dyn_fifo_destroy(&socket->received);
    750750        dyn_fifo_destroy(&socket->accepted);
    751         sockets_exclude(socket_get_sockets(), socket->socket_id);
     751        sockets_exclude(socket_get_sockets(), socket->socket_id, free);
    752752}
    753753

  • uspace/lib/c/generic/stacktrace.c

    r1ff896e r694ca93f  
    6161        stacktrace_prepare();
    6262        stacktrace_print_fp_pc(stacktrace_fp_get(), stacktrace_pc_get());
     63       
    6364        /*
    6465         * Prevent the tail call optimization of the previous call by
    6566         * making it a non-tail call.
    6667         */
    67         (void) stacktrace_fp_get();
     68       
     69        printf("-- end of stack trace --\n");
    6870}
    6971

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

    r1ff896e r694ca93f  
    12151215void order_suffix(const uint64_t val, uint64_t *rv, char *suffix)
    12161216{
    1217         if (val > 10000000000000000000ULL) {
    1218                 *rv = val / 1000000000000000000ULL;
     1217        if (val > UINT64_C(10000000000000000000)) {
     1218                *rv = val / UINT64_C(1000000000000000000);
    12191219                *suffix = 'Z';
    1220         } else if (val > 1000000000000000000ULL) {
    1221                 *rv = val / 1000000000000000ULL;
     1220        } else if (val > UINT64_C(1000000000000000000)) {
     1221                *rv = val / UINT64_C(1000000000000000);
    12221222                *suffix = 'E';
    1223         } else if (val > 1000000000000000ULL) {
    1224                 *rv = val / 1000000000000ULL;
     1223        } else if (val > UINT64_C(1000000000000000)) {
     1224                *rv = val / UINT64_C(1000000000000);
    12251225                *suffix = 'T';
    1226         } else if (val > 1000000000000ULL) {
    1227                 *rv = val / 1000000000ULL;
     1226        } else if (val > UINT64_C(1000000000000)) {
     1227                *rv = val / UINT64_C(1000000000);
    12281228                *suffix = 'G';
    1229         } else if (val > 1000000000ULL) {
    1230                 *rv = val / 1000000ULL;
     1229        } else if (val > UINT64_C(1000000000)) {
     1230                *rv = val / UINT64_C(1000000);
    12311231                *suffix = 'M';
    1232         } else if (val > 1000000ULL) {
    1233                 *rv = val / 1000ULL;
     1232        } else if (val > UINT64_C(1000000)) {
     1233                *rv = val / UINT64_C(1000);
    12341234                *suffix = 'k';
    12351235        } else {
    … …  
    12391239}
    12401240
     1241void bin_order_suffix(const uint64_t val, uint64_t *rv, const char **suffix,
     1242    bool fixed)
     1243{
     1244        if (val > UINT64_C(1152921504606846976)) {
     1245                *rv = val / UINT64_C(1125899906842624);
     1246                *suffix = "EiB";
     1247        } else if (val > UINT64_C(1125899906842624)) {
     1248                *rv = val / UINT64_C(1099511627776);
     1249                *suffix = "TiB";
     1250        } else if (val > UINT64_C(1099511627776)) {
     1251                *rv = val / UINT64_C(1073741824);
     1252                *suffix = "GiB";
     1253        } else if (val > UINT64_C(1073741824)) {
     1254                *rv = val / UINT64_C(1048576);
     1255                *suffix = "MiB";
     1256        } else if (val > UINT64_C(1048576)) {
     1257                *rv = val / UINT64_C(1024);
     1258                *suffix = "KiB";
     1259        } else {
     1260                *rv = val;
     1261                if (fixed)
     1262                        *suffix = "B  ";
     1263                else
     1264                        *suffix = "B";
     1265        }
     1266}
     1267
    12411268/** @}
    12421269 */

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

    r1ff896e r694ca93f  
    378378       
    379379        req = async_send_1(vfs_phone, VFS_IN_READ, fildes, &answer);
    380         rc = async_data_read_start(vfs_phone, (void *)buf, nbyte);
     380        rc = async_data_read_start_generic(vfs_phone, (void *) buf, nbyte,
     381            IPC_XF_RESTRICT);
    381382        if (rc != EOK) {
    382383                vfs_exchange_end(vfs_phone);
    … …  
    407408       
    408409        req = async_send_1(vfs_phone, VFS_IN_WRITE, fildes, &answer);
    409         rc = async_data_write_start(vfs_phone, (void *)buf, nbyte);
     410        rc = async_data_write_start_generic(vfs_phone, (void *) buf, nbyte,
     411            IPC_XF_RESTRICT);
    410412        if (rc != EOK) {
    411413                vfs_exchange_end(vfs_phone);
    … …  
    756758{
    757759        struct stat stat;
    758         int rc;
    759 
    760         rc = fstat(fildes, &stat);
    761 
     760       
     761        int rc = fstat(fildes, &stat);
     762        if (rc != 0)
     763                return rc;
     764       
    762765        if (!stat.device)
    763766                return -1;

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

    r1ff896e r694ca93f  
    4747#define GENERIC_CHAR_MAP_MAGIC_VALUE    0x12345622
    4848
     49/** Generic destructor function pointer. */
     50#define DTOR_T(identifier) \
     51        void (*identifier)(const void *)
     52
    4953/** Character string to generic type map declaration.
    5054 *  @param[in] name     Name of the map.
    … …  
    6468        int name##_add(name##_t *, const uint8_t *, const size_t, type *); \
    6569        int name##_count(name##_t *); \
    66         void name##_destroy(name##_t *); \
    67         void name##_exclude(name##_t *, const uint8_t *, const size_t); \
     70        void name##_destroy(name##_t *, DTOR_T()); \
     71        void name##_exclude(name##_t *, const uint8_t *, const size_t, DTOR_T()); \
    6872        type *name##_find(name##_t *, const uint8_t *, const size_t); \
    6973        int name##_initialize(name##_t *); \
    … …  
    8488             type *value) \
    8589        { \
    86                 int rc; \
    8790                int index; \
    8891                if (!name##_is_valid(map)) \
    … …  
    9194                if (index < 0) \
    9295                        return index; \
    93                 rc = char_map_add(&map->names, name, length, index); \
    94                 if (rc != EOK) { \
    95                         name##_items_exclude_index(&map->values, index); \
    96                         return rc; \
    97                 } \
    98                 return EOK; \
     96                return char_map_add(&map->names, name, length, index); \
    9997        } \
    10098        \
    … …  
    105103        } \
    106104        \
    107         void name##_destroy(name##_t *map) \
     105        void name##_destroy(name##_t *map, DTOR_T(dtor)) \
    108106        { \
    109107                if (name##_is_valid(map)) { \
    110108                        char_map_destroy(&map->names); \
    111                         name##_items_destroy(&map->values); \
     109                        name##_items_destroy(&map->values, dtor); \
    112110                } \
    113111        } \
    114112        \
    115113        void name##_exclude(name##_t *map, const uint8_t *name, \
    116             const size_t length) \
     114            const size_t length, DTOR_T(dtor)) \
    117115        { \
    118116                if (name##_is_valid(map)) { \
    … …  
    121119                        if (index != CHAR_MAP_NULL) \
    122120                                name##_items_exclude_index(&map->values, \
    123                                      index); \
     121                                     index, dtor); \
    124122                } \
    125123        } \

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

    r1ff896e r694ca93f  
    4646#define GENERIC_FIELD_MAGIC_VALUE               0x55667788
    4747
     48/** Generic destructor function pointer. */
     49#define DTOR_T(identifier) \
     50        void (*identifier)(const void *)
     51
    4852/** Generic type field declaration.
    4953 *
    … …  
    6367        int name##_add(name##_t *, type *); \
    6468        int name##_count(name##_t *); \
    65         void name##_destroy(name##_t *); \
    66         void name##_exclude_index(name##_t *, int); \
     69        void name##_destroy(name##_t *, DTOR_T()); \
     70        void name##_exclude_index(name##_t *, int, DTOR_T()); \
    6771        type **name##_get_field(name##_t *); \
    6872        type *name##_get_index(name##_t *, int); \
    … …  
    103107        } \
    104108        \
    105         void name##_destroy(name##_t *field) \
     109        void name##_destroy(name##_t *field, DTOR_T(dtor)) \
    106110        { \
    107111                if (name##_is_valid(field)) { \
    108112                        int index; \
    109113                        field->magic = 0; \
    110                         for (index = 0; index < field->next; index++) { \
    111                                 if (field->items[index]) \
    112                                         free(field->items[index]); \
     114                        if (dtor) { \
     115                                for (index = 0; index < field->next; index++) { \
     116                                        if (field->items[index]) \
     117                                                dtor(field->items[index]); \
     118                                } \
    113119                        } \
    114120                        free(field->items); \
    … …  
    116122        } \
    117123         \
    118         void name##_exclude_index(name##_t *field, int index) \
     124        void name##_exclude_index(name##_t *field, int index, DTOR_T(dtor)) \
    119125        { \
    120126                if (name##_is_valid(field) && (index >= 0) && \
    121127                    (index < field->next) && (field->items[index])) { \
    122                         free(field->items[index]); \
     128                        if (dtor) \
     129                                dtor(field->items[index]); \
    123130                        field->items[index] = NULL; \
    124131                } \

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

    r1ff896e r694ca93f  
    4949#define INT_MAP_ITEM_MAGIC_VALUE        0x55667788
    5050
     51/** Generic destructor function pointer. */
     52#define DTOR_T(identifier) \
     53        void (*identifier)(const void *)
     54
    5155/** Integer to generic type map declaration.
    5256 *
    … …  
    7276        \
    7377        int name##_add(name##_t *, int, type *); \
    74         void name##_clear(name##_t *); \
     78        void name##_clear(name##_t *, DTOR_T()); \
    7579        int name##_count(name##_t *); \
    76         void name##_destroy(name##_t *); \
    77         void name##_exclude(name##_t *, int); \
    78         void name##_exclude_index(name##_t *, int); \
     80        void name##_destroy(name##_t *, DTOR_T()); \
     81        void name##_exclude(name##_t *, int, DTOR_T()); \
     82        void name##_exclude_index(name##_t *, int, DTOR_T()); \
    7983        type *name##_find(name##_t *, int); \
    8084        int name##_update(name##_t *, int, int); \
    … …  
    8286        int name##_initialize(name##_t *); \
    8387        int name##_is_valid(name##_t *); \
    84         void name##_item_destroy(name##_item_t *); \
     88        void name##_item_destroy(name##_item_t *, DTOR_T()); \
    8589        int name##_item_is_valid(name##_item_t *);
    8690
    … …  
    115119        } \
    116120        \
    117         void name##_clear(name##_t *map) \
     121        void name##_clear(name##_t *map, DTOR_T(dtor)) \
    118122        { \
    119123                if (name##_is_valid(map)) { \
    … …  
    122126                                if (name##_item_is_valid(&map->items[index])) { \
    123127                                        name##_item_destroy( \
    124                                             &map->items[index]); \
     128                                            &map->items[index], dtor); \
    125129                                } \
    126130                        } \
    … …  
    135139        } \
    136140        \
    137         void name##_destroy(name##_t *map) \
     141        void name##_destroy(name##_t *map, DTOR_T(dtor)) \
    138142        { \
    139143                if (name##_is_valid(map)) { \
    … …  
    143147                                if (name##_item_is_valid(&map->items[index])) { \
    144148                                        name##_item_destroy( \
    145                                             &map->items[index]); \
     149                                            &map->items[index], dtor); \
    146150                                } \
    147151                        } \
    … …  
    150154        } \
    151155        \
    152         void name##_exclude(name##_t *map, int key) \
     156        void name##_exclude(name##_t *map, int key, DTOR_T(dtor)) \
    153157        { \
    154158                if (name##_is_valid(map)) { \
    … …  
    158162                                    (map->items[index].key == key)) { \
    159163                                        name##_item_destroy( \
    160                                             &map->items[index]); \
    161                                 } \
    162                         } \
    163                 } \
    164         } \
    165         \
    166         void name##_exclude_index(name##_t *map, int index) \
     164                                            &map->items[index], dtor); \
     165                                } \
     166                        } \
     167                } \
     168        } \
     169        \
     170        void name##_exclude_index(name##_t *map, int index, DTOR_T(dtor)) \
    167171        { \
    168172                if (name##_is_valid(map) && (index >= 0) && \
    169173                    (index < map->next) && \
    170174                    name##_item_is_valid(&map->items[index])) { \
    171                         name##_item_destroy(&map->items[index]); \
     175                        name##_item_destroy(&map->items[index], dtor); \
    172176                } \
    173177        } \
    … …  
    236240        } \
    237241        \
    238         void name##_item_destroy(name##_item_t *item) \
     242        void name##_item_destroy(name##_item_t *item, DTOR_T(dtor)) \
    239243        { \
    240244                if (name##_item_is_valid(item)) { \
    241245                        item->magic = 0; \
    242246                        if (item->value) { \
    243                                 free(item->value); \
     247                                if (dtor) \
     248                                        dtor(item->value); \
    244249                                item->value = NULL; \
    245250                        } \

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

    r1ff896e r694ca93f  
    4040 *
    4141 * If NDEBUG is not set, the assert() macro
    42  * evaluates expr and if it is false prints 
     42 * evaluates expr and if it is false prints
    4343 * error message and terminate program.
    4444 *
    … …  
    4747 */
    4848
    49 #include <stdio.h>
    50 #include <stdlib.h>
    51 
    5249#ifndef NDEBUG
    5350
    5451#define assert(expr) \
    5552        do { \
    56                 if (!(expr)) { \
    57                         printf("Assertion failed (%s) at file '%s', " \
    58                             "line %d.\n", #expr, __FILE__, __LINE__); \
    59                         abort(); \
    60                 } \
     53                if (!(expr)) \
     54                        assert_abort(#expr, __FILE__, __LINE__); \
    6155        } while (0)
    6256
    … …  
    6761#endif /* NDEBUG */
    6862
     63extern void assert_abort(const char *, const char *, unsigned int)
     64    __attribute__((noreturn));
     65
    6966#endif
    7067

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

    r1ff896e r694ca93f  
    340340            (arg4), (answer))
    341341
    342 extern int async_data_read_start(int, void *, size_t);
     342#define async_data_read_start(p, buf, len) \
     343        async_data_read_start_generic((p), (buf), (len), IPC_XF_NONE)
     344
     345extern int async_data_read_start_generic(int, void *, size_t, int);
    343346extern bool async_data_read_receive(ipc_callid_t *, size_t *);
    344347extern int async_data_read_finalize(ipc_callid_t, const void *, size_t);
    … …  
    379382            (arg4), (answer))
    380383
    381 extern int async_data_write_start(int, const void *, size_t);
     384#define async_data_write_start(p, buf, len) \
     385        async_data_write_start_generic((p), (buf), (len), IPC_XF_NONE)
     386
     387extern int async_data_write_start_generic(int, const void *, size_t, int);
    382388extern bool async_data_write_receive(ipc_callid_t *, size_t *);
    383389extern int async_data_write_finalize(ipc_callid_t, void *, size_t);

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

    r1ff896e r694ca93f  
    5353extern int devman_device_get_handle(const char *, devman_handle_t *,
    5454    unsigned int);
     55extern int devman_device_get_handle_by_class(const char *, const char *,
     56    devman_handle_t *, unsigned int);
    5557
    5658extern int devman_add_device_to_class(devman_handle_t, const char *);

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

    r1ff896e r694ca93f  
    11/*
    2  * Copyright (c) 2006 Jakub Jermar
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup sparc64mm       
     29/** @addtogroup libc
    3030 * @{
    3131 */
    … …  
    3333 */
    3434
    35 #ifndef KERN_sparc64_CACHE_H_
    36 #define KERN_sparc64_CACHE_H_
     35#ifndef LIBC_ENTRY_POINT_H_
     36#define LIBC_ENTRY_POINT_H_
    3737
    38 #include <mm/page.h>
    39 #include <mm/frame.h>
     38/* Defined in arch/ARCH/src/entryjmp.[c|s] */
     39void entry_point_jmp(void *, void *);
    4040
    4141#endif

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

    r1ff896e r694ca93f  
    3939#include <fibril.h>
    4040
    41 #define errno _errno
     41#define errno  (*(__errno()))
    4242
    43 extern int _errno;
     43extern int *__errno(void) __attribute__((const));
    4444
    4545#define EMFILE        (-18)

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

    r1ff896e r694ca93f  
    3636#define LIBC_FIBRIL_SYNCH_H_
    3737
    38 #include <async.h>
    3938#include <fibril.h>
    4039#include <adt/list.h>
    4140#include <libarch/tls.h>
    4241#include <sys/time.h>
     42#include <bool.h>
    4343
    4444typedef struct {
    45         fibril_owner_info_t oi;         /* Keep this the first thing. */
     45        fibril_owner_info_t oi;  /**< Keep this the first thing. */
    4646        int counter;
    4747        link_t waiters;
    … …  
    6464
    6565typedef struct {
    66         fibril_owner_info_t oi; /* Keep this the first thing. */
     66        fibril_owner_info_t oi;  /**< Keep this the first thing. */
    6767        unsigned writers;
    6868        unsigned readers;

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

    r1ff896e r694ca93f  
    148148
    149149typedef enum {
    150         DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD
     150        DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD,
     151        DEVMAN_DEVICE_GET_HANDLE_BY_CLASS
    151152} client_to_devman_t;
    152153

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

    r1ff896e r694ca93f  
    4747        SERVICE_DEVMAP,
    4848        SERVICE_DEVMAN,
    49         SERVICE_FHC,
    50         SERVICE_OBIO,
    51         SERVICE_APIC,
    52         SERVICE_I8259,
     49        SERVICE_IRC,
    5350        SERVICE_CLIPBOARD,
    5451        SERVICE_NETWORKING,

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

    r1ff896e r694ca93f  
    7272        /** Pointer to ELF dynamic section of the program. */
    7373        void *dynamic;
     74        /** Pointer to dynamic linker state structure (runtime_env_t). */
     75        void *rtld_runtime;
    7476} pcb_t;
    7577

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

    r1ff896e r694ca93f  
    3939#define max(a, b)  ((a) > (b) ? (a) : (b))
    4040
    41 #define SIZE2KB(size)  ((size) >> 10)
    42 #define SIZE2MB(size)  ((size) >> 20)
    43 
    44 #define KB2SIZE(kb)  ((kb) << 10)
    45 #define MB2SIZE(mb)  ((mb) << 20)
     41#define KiB2SIZE(kb)  ((kb) << 10)
     42#define MiB2SIZE(mb)  ((mb) << 20)
    4643
    4744#define STRING(arg)      STRING_ARG(arg)

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

    r1ff896e r694ca93f  
    11/*
    2  * Copyright (c) 2007 Jan Hudecek
    3  * Copyright (c) 2008 Martin Decky
     2 * Copyright (c) 2008 Jiri Svoboda
    43 * All rights reserved.
    54 *
    … …  
    2827 */
    2928
    30 /** @addtogroup genericproc
     29/** @addtogroup libc
    3130 * @{
    3231 */
    33 /** @file tasklet.h
    34  * @brief Tasklets declarations
     32/** @file
    3533 */
    3634
    37 #ifndef KERN_TASKLET_H_
    38 #define KERN_TASKLET_H_
     35#ifndef LIBC_RTLD_MODULE_H_
     36#define LIBC_RTLD_MODULE_H_
    3937
     38#include <sys/types.h>
     39#include <rtld/dynamic.h>
    4040#include <adt/list.h>
    4141
    42 /** Tasklet callback type */
    43 typedef void (* tasklet_callback_t)(void *arg);
     42typedef struct module {
     43        dyn_info_t dyn;
     44        size_t bias;
    4445
    45 /** Tasklet state */
    46 typedef enum {
    47         NotActive,
    48         Scheduled,
    49         InProgress,
    50         Disabled
    51 } tasklet_state_t;
     46        /** Array of pointers to directly dependent modules */
     47        struct module **deps;
     48        /** Number of fields in deps */
     49        size_t n_deps;
    5250
    53 /** Structure describing a tasklet */
    54 typedef struct tasklet_descriptor {
    55         link_t link;
    56        
    57         /** Callback to call */
    58         tasklet_callback_t callback;
    59        
    60         /** Argument passed to the callback */
    61         void *arg;
    62        
    63         /** State of the tasklet */
    64         tasklet_state_t state;
    65 } tasklet_descriptor_t;
     51        /** True iff relocations have already been processed in this module. */
     52        bool relocated;
    6653
     54        /** Link to list of all modules in runtime environment */
     55        link_t modules_link;
    6756
    68 extern void tasklet_init(void);
     57        /** Link to BFS queue. Only used when doing a BFS of the module graph */
     58        link_t queue_link;
     59        /** Tag for modules already processed during a BFS */
     60        bool bfs_tag;
     61} module_t;
     62
     63void module_process_relocs(module_t *m);
     64module_t *module_find(const char *name);
     65module_t *module_load(const char *name);
     66void module_load_deps(module_t *m);
     67
     68void modules_process_relocs(module_t *start);
     69void modules_untag(void);
    6970
    7071#endif

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

    r1ff896e r694ca93f  
    11/*
    2  * Copyright (c) 2005 Sergey Bondari
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup amd64
     29/** @addtogroup libc
    3030 * @{
    3131 */
    … …  
    3333 */
    3434
    35 #ifndef KERN_amd64_MEMSTR_H_
    36 #define KERN_amd64_MEMSTR_H_
     35#ifndef LIBC_RTLD_RTLD_DEBUG_H_
     36#define LIBC_RTLD_RTLD_DEBUG_H_
    3737
    38 #define memcpy(dst, src, cnt)  __builtin_memcpy((dst), (src), (cnt))
     38/* Define to enable debugging mode. */
     39#undef RTLD_DEBUG
    3940
    40 extern void memsetw(void *, size_t, uint16_t);
    41 extern void memsetb(void *, size_t, uint8_t);
     41#ifdef RTLD_DEBUG
     42        #define DPRINTF(format, ...) printf(format, ##__VA_ARGS__)
     43#else
     44        #define DPRINTF(format, ...) if (0) printf(format, ##__VA_ARGS__)
     45#endif
    4246
    4347#endif

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

    r1ff896e r694ca93f  
    8989extern int str_size_t(const char *, char **, unsigned int, bool, size_t *);
    9090
    91 extern void order_suffix(const uint64_t val, uint64_t *rv, char *suffix);
     91extern void order_suffix(const uint64_t, uint64_t *, char *);
     92extern void bin_order_suffix(const uint64_t, uint64_t *, const char **, bool);
    9293
    9394/*

  • uspace/lib/drv/Makefile

    r1ff896e r694ca93f  
    3535        generic/driver.c \
    3636        generic/dev_iface.c \
     37        generic/log.c \
    3738        generic/remote_hw_res.c \
    3839        generic/remote_char_dev.c

  • uspace/lib/drv/generic/driver.c

    r1ff896e r694ca93f  
    4747#include <stdlib.h>
    4848#include <str.h>
     49#include <str_error.h>
    4950#include <ctype.h>
    5051#include <errno.h>
    … …  
    273274       
    274275        res = driver->driver_ops->add_device(dev);
    275         if (res == EOK) {
    276                 printf("%s: new device with handle=%" PRIun " was added.\n",
    277                     driver->name, dev_handle);
    278         } else {
    279                 printf("%s: failed to add a new device with handle = %" PRIun ".\n",
    280                     driver->name, dev_handle);
     276        if (res != EOK)
    281277                delete_device(dev);
    282         }
    283278       
    284279        async_answer_0(iid, res);
    … …  
    408403                            get_remote_method(rem_iface, iface_method_idx);
    409404                        if (iface_method_ptr == NULL) {
    410                                 // the interface has not such method
     405                                /* The interface has not such method */
    411406                                printf("%s: driver_connection_gen error - "
    412407                                    "invalid interface method.", driver->name);
    … …  
    661656int ddf_driver_main(driver_t *drv)
    662657{
     658        int rc;
     659
    663660        /*
    664661         * Remember the driver structure - driver_ops will be called by generic
    … …  
    674671       
    675672        /*
    676          * Register driver by device manager with generic handler for incoming
    677          * connections.
     673         * Register driver with device manager using generic handler for
     674         * incoming connections.
    678675         */
    679         devman_driver_register(driver->name, driver_connection);
    680        
     676        rc = devman_driver_register(driver->name, driver_connection);
     677        if (rc != EOK) {
     678                printf("Error: Failed to register driver with device manager "
     679                    "(%s).\n", (rc == EEXISTS) ? "driver already started" :
     680                    str_error(rc));
     681               
     682                return 1;
     683        }
     684       
     685        /* Return success from the task since server has started. */
     686        rc = task_retval(0);
     687        if (rc != EOK)
     688                return 1;
     689
    681690        async_manager();
    682691       

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

    r1ff896e r694ca93f  
    11/*
    2  * Copyright (c) 2007 Jan Hudecek
    3  * Copyright (c) 2008 Martin Decky
     2 * Copyright (c) 2011 Jiri Svoboda
    43 * All rights reserved.
    54 *
    … …  
    2827 */
    2928
    30 /** @addtogroup genericproc
     29/** @addtogroup libdrv
    3130 * @{
    3231 */
    33 /** @file tasklet.c
    34  *  @brief Tasklet implementation
     32
     33#include <io/log.h>
     34#include <stdarg.h>
     35
     36#include <ddf/log.h>
     37
     38/** Initialize the logging system.
     39 *
     40 * @param drv_name      Driver name, will be printed as part of message
     41 * @param level         Minimum message level to print
    3542 */
    36 
    37 #include <proc/tasklet.h>
    38 #include <synch/spinlock.h>
    39 #include <mm/slab.h>
    40 #include <config.h>
    41 
    42 /** Spinlock protecting list of tasklets */
    43 SPINLOCK_INITIALIZE(tasklet_lock);
    44 
    45 /** Array of tasklet lists for every CPU */
    46 tasklet_descriptor_t **tasklet_list;
    47 
    48 void tasklet_init(void)
     43int ddf_log_init(const char *drv_name, log_level_t level)
    4944{
    50         unsigned int i;
    51        
    52         tasklet_list = malloc(sizeof(tasklet_descriptor_t *) * config.cpu_count, 0);
    53         if (!tasklet_list)
    54                 panic("Error initializing tasklets.");
    55        
    56         for (i = 0; i < config.cpu_count; i++)
    57                 tasklet_list[i] = NULL;
    58        
    59         spinlock_initialize(&tasklet_lock, "tasklet_lock");
     45        return log_init(drv_name, level);
    6046}
    6147
     48/** Log a driver message.
     49 *
     50 * @param level         Message verbosity level. Message is only printed
     51 *                      if verbosity is less than or equal to current
     52 *                      reporting level.
     53 * @param fmt           Format string (no trailing newline)
     54 */
     55void ddf_msg(log_level_t level, const char *fmt, ...)
     56{
     57        va_list args;
     58
     59        va_start(args, fmt);
     60        log_msgv(level, fmt, args);
     61        va_end(args);
     62}
    6263
    6364/** @}

  • uspace/lib/fs/libfs.c

    r1ff896e r694ca93f  
    391391                                                if (lflag & L_CREATE)
    392392                                                        (void) ops->destroy(fn);
     393                                                else
     394                                                        (void) ops->node_put(fn);
    393395                                                async_answer_0(rid, rc);
    394396                                        } else {
    … …  
    473475                                        if (lflag & L_CREATE)
    474476                                                (void) ops->destroy(fn);
     477                                        else
     478                                                (void) ops->node_put(fn);
    475479                                        async_answer_0(rid, rc);
    476480                                } else {

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

    r1ff896e r694ca93f  
    106106                return EBADMEM;
    107107
    108         // request the address
     108        /* Request the address */
    109109        message_id = async_send_1(phone, (sysarg_t) message,
    110110            (sysarg_t) device_id, NULL);
    … …  
    112112        async_wait_for(message_id, &result);
    113113
    114         // if not successful
     114        /* If not successful */
    115115        if ((string == EOK) && (result != EOK)) {
    116                 // clear the data
     116                /* Clear the data */
    117117                free(*address);
    118118                free(*data);
    … …  
    242242                return EBADMEM;
    243243
    244         // request the translation
     244        /* Request the translation */
    245245        message_id = async_send_3(phone, (sysarg_t) message,
    246246            (sysarg_t) device_id, (sysarg_t) count, (sysarg_t) service, NULL);
    … …  
    249249        async_wait_for(message_id, &result);
    250250
    251         // if not successful
     251        /* If not successful */
    252252        if ((string == EOK) && (result != EOK)) {
    253                 // clear the data
     253                /* Clear the data */
    254254                free(*translation);
    255255                free(*data);

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

    r1ff896e r694ca93f  
    5252uint16_t compact_checksum(uint32_t sum)
    5353{
    54         // shorten to the 16 bits
     54        /* Shorten to the 16 bits */
    5555        while (sum >> 16)
    5656                sum = (sum & 0xffff) + (sum >> 16);
    … …  
    7272        size_t index;
    7373
    74         // sum all the 16 bit fields
     74        /* Sum all the 16 bit fields */
    7575        for (index = 0; index + 1 < length; index += 2)
    7676                seed += (data[index] << 8) + data[index + 1];
    7777
    78         // last odd byte with zero padding
     78        /* Last odd byte with zero padding */
    7979        if (index + 1 == length)
    8080                seed += data[index] << 8;
    … …  
    9494        size_t index;
    9595
    96         // process full bytes
     96        /* Process full bytes */
    9797        while (length >= 8) {
    98                 // add the data
     98                /* Add the data */
    9999                seed ^= (*data) << 24;
    100100               
    101                 // for each added bit
     101                /* For each added bit */
    102102                for (index = 0; index < 8; ++index) {
    103                         // if the first bit is set
     103                        /* If the first bit is set */
    104104                        if (seed & 0x80000000) {
    105                                 // shift and divide the checksum
     105                                /* Shift and divide the checksum */
    106106                                seed = (seed << 1) ^ ((uint32_t) CRC_DIVIDER_BE);
    107107                        } else {
    108                                 // shift otherwise
     108                                /* Shift otherwise */
    109109                                seed <<= 1;
    110110                        }
    111111                }
    112112               
    113                 // move to the next byte
     113                /* Move to the next byte */
    114114                ++data;
    115115                length -= 8;
    116116        }
    117117
    118         // process the odd bits
     118        /* Process the odd bits */
    119119        if (length > 0) {
    120                 // add the data with zero padding
     120                /* Add the data with zero padding */
    121121                seed ^= ((*data) & (0xff << (8 - length))) << 24;
    122122               
    123                 // for each added bit
     123                /* For each added bit */
    124124                for (index = 0; index < length; ++index) {
    125                         // if the first bit is set
     125                        /* If the first bit is set */
    126126                        if (seed & 0x80000000) {
    127                                 // shift and divide the checksum
     127                                /* Shift and divide the checksum */
    128128                                seed = (seed << 1) ^ ((uint32_t) CRC_DIVIDER_BE);
    129129                        } else {
    130                                 // shift otherwise
     130                                /* Shift otherwise */
    131131                                seed <<= 1;
    132132                        }
    … …  
    148148        size_t index;
    149149
    150         // process full bytes
     150        /* Process full bytes */
    151151        while (length >= 8) {
    152                 // add the data
     152                /* Add the data */
    153153                seed ^= (*data);
    154154               
    155                 // for each added bit
     155                /* For each added bit */
    156156                for (index = 0; index < 8; ++index) {
    157                         // if the last bit is set
     157                        /* If the last bit is set */
    158158                        if (seed & 1) {
    159                                 // shift and divide the checksum
     159                                /* Shift and divide the checksum */
    160160                                seed = (seed >> 1) ^ ((uint32_t) CRC_DIVIDER_LE);
    161161                        } else {
    162                                 // shift otherwise
     162                                /* Shift otherwise */
    163163                                seed >>= 1;
    164164                        }
    165165                }
    166166               
    167                 // move to the next byte
     167                /* Move to the next byte */
    168168                ++data;
    169169                length -= 8;
    170170        }
    171171
    172         // process the odd bits
     172        /* Process the odd bits */
    173173        if (length > 0) {
    174                 // add the data with zero padding
     174                /* Add the data with zero padding */
    175175                seed ^= (*data) >> (8 - length);
    176176               
    177177                for (index = 0; index < length; ++index) {
    178                         // if the last bit is set
     178                        /* If the last bit is set */
    179179                        if (seed & 1) {
    180                                 // shift and divide the checksum
     180                                /* Shift and divide the checksum */
    181181                                seed = (seed >> 1) ^ ((uint32_t) CRC_DIVIDER_LE);
    182182                        } else {
    183                                 // shift otherwise
     183                                /* Shift otherwise */
    184184                                seed >>= 1;
    185185                        }
    … …  
    198198uint16_t flip_checksum(uint16_t checksum)
    199199{
    200         // flip, zero is returned as 0xFFFF (not flipped)
     200        /* Flip, zero is returned as 0xFFFF (not flipped) */
    201201        checksum = ~checksum;
    202202        return checksum ? checksum : IP_CHECKSUM_ZERO;
    … …  
    216216uint16_t ip_checksum(uint8_t *data, size_t length)
    217217{
    218         // compute, compact and flip the data checksum
     218        /* Compute, compact and flip the data checksum */
    219219        return flip_checksum(compact_checksum(compute_checksum(0, data,
    220220            length)));

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

    r1ff896e r694ca93f  
    267267                return NULL;
    268268
    269         // get a new packet
     269        /* Get a new packet */
    270270        copy = packet_get_4_remote(phone, PACKET_DATA_LENGTH(packet),
    271271            PACKET_MAX_ADDRESS_LENGTH(packet), packet->max_prefix,
    … …  
    274274                return NULL;
    275275
    276         // get addresses
     276        /* Get addresses */
    277277        addrlen = packet_get_addr(packet, &src, &dest);
    278         // copy data
     278        /* Copy data */
    279279        if ((packet_copy_data(copy, packet_get_data(packet),
    280280            PACKET_DATA_LENGTH(packet)) == EOK) &&
    281             // copy addresses if present
     281            /* Copy addresses if present */
    282282            ((addrlen <= 0) ||
    283283            (packet_set_addr(copy, src, dest, addrlen) == EOK))) {

  • uspace/lib/net/il/ip_client.c

    r1ff896e r694ca93f  
    124124
    125125        // TODO IPv6
    126 /*      case AF_INET6:
     126#if 0
     127        case AF_INET6:
    127128                if (addrlen != sizeof(struct sockaddr_in6))
    128129                        return EINVAL;
    … …  
    130131                address_in6 = (struct sockaddr_in6 *) addr;
    131132                return EOK;
    132 */
     133#endif
    133134
    134135        default:
    … …  
    159160        size_t padding;
    160161
    161         // compute the padding if IP options are set
    162         // multiple of 4 bytes
     162        /*
     163         * Compute the padding if IP options are set
     164         * multiple of 4 bytes
     165         */
    163166        padding =  ipopt_length % 4;
    164167        if (padding) {
    … …  
    167170        }
    168171
    169         // prefix the header
     172        /* Prefix the header */
    170173        data = (uint8_t *) packet_prefix(packet, sizeof(ip_header_t) + padding);
    171174        if (!data)
    172175                return ENOMEM;
    173176
    174         // add the padding
     177        /* Add the padding */
    175178        while (padding--)
    176179                data[sizeof(ip_header_t) + padding] = IPOPT_NOOP;
    177180
    178         // set the header
     181        /* Set the header */
    179182        header = (ip_header_t *) data;
    180183        header->header_length = IP_COMPUTE_HEADER_LENGTH(sizeof(ip_header_t) +

  • uspace/lib/net/tl/icmp_client.c

    r1ff896e r694ca93f  
    8181                *mtu = header->un.frag.mtu;
    8282
    83         // remove debug dump
     83        /* Remove debug dump */
    8484#ifdef CONFIG_DEBUG
    8585        printf("ICMP error %d (%d) in packet %d\n", header->type, header->code,

  • uspace/lib/net/tl/socket_core.c

    r1ff896e r694ca93f  
    9191        int packet_id;
    9292
    93         // if bound
     93        /* If bound */
    9494        if (socket->port) {
    95                 // release the port
     95                /* Release the port */
    9696                socket_port_release(global_sockets, socket);
    9797        }
    9898       
    99         // release all received packets
     99        /* Release all received packets */
    100100        while ((packet_id = dyn_fifo_pop(&socket->received)) >= 0)
    101101                pq_release_remote(packet_phone, packet_id);
    … …  
    107107                socket_release(socket);
    108108
    109         socket_cores_exclude(local_sockets, socket->socket_id);
     109        socket_cores_exclude(local_sockets, socket->socket_id, free);
    110110}
    111111
    … …  
    166166        int rc;
    167167
    168         // create a wrapper
     168        /* Create a wrapper */
    169169        socket_ref = malloc(sizeof(*socket_ref));
    170170        if (!socket_ref)
    … …  
    172172
    173173        *socket_ref = socket;
    174         // add the wrapper
     174        /* Add the wrapper */
    175175        rc = socket_port_map_add(&socket_port->map, key, key_length,
    176176            socket_ref);
    … …  
    206206        int rc;
    207207
    208         // create a wrapper
     208        /* Create a wrapper */
    209209        socket_port = malloc(sizeof(*socket_port));
    210210        if (!socket_port)
    … …  
    221221                goto fail;
    222222       
    223         // register the incomming port
     223        /* Register the incoming port */
    224224        rc = socket_ports_add(global_sockets, port, socket_port);
    225225        if (rc < 0)
    … …  
    230230
    231231fail:
    232         socket_port_map_destroy(&socket_port->map);
     232        socket_port_map_destroy(&socket_port->map, free);
    233233        free(socket_port);
    234234        return rc;
    … …  
    277277               
    278278                address_in = (struct sockaddr_in *) addr;
    279                 // find the socket
     279                /* Find the socket */
    280280                socket = socket_cores_find(local_sockets, socket_id);
    281281                if (!socket)
    282282                        return ENOTSOCK;
    283283               
    284                 // bind a free port?
     284                /* Bind a free port? */
    285285                if (address_in->sin_port <= 0)
    286286                        return socket_bind_free_port(global_sockets, socket,
    287287                             free_ports_start, free_ports_end, last_used_port);
    288288               
    289                 // try to find the port
     289                /* Try to find the port */
    290290                socket_port = socket_ports_find(global_sockets,
    291291                    ntohs(address_in->sin_port));
    292292                if (socket_port) {
    293                         // already used
     293                        /* Already used */
    294294                        return EADDRINUSE;
    295295                }
    296296               
    297                 // if bound
     297                /* If bound */
    298298                if (socket->port) {
    299                         // release the port
     299                        /* Release the port */
    300300                        socket_port_release(global_sockets, socket);
    301301                }
    … …  
    333333        int index;
    334334
    335         // from the last used one
     335        /* From the last used one */
    336336        index = last_used_port;
    337337       
    … …  
    339339                ++index;
    340340               
    341                 // til the range end
     341                /* Till the range end */
    342342                if (index >= free_ports_end) {
    343                         // start from the range beginning
     343                        /* Start from the range beginning */
    344344                        index = free_ports_start - 1;
    345345                        do {
    346346                                ++index;
    347                                 // til the last used one
     347                                /* Till the last used one */
    348348                                if (index >= last_used_port) {
    349                                         // none found
     349                                        /* None found */
    350350                                        return ENOTCONN;
    351351                                }
    352352                        } while (socket_ports_find(global_sockets, index));
    353353                       
    354                         // found, break immediately
     354                        /* Found, break immediately */
    355355                        break;
    356356                }
    … …  
    376376
    377377        count = 0;
    378 //      socket_id = socket_globals.last_id;
     378#if 0
     379        socket_id = socket_globals.last_id;
     380#endif
    379381        do {
    380382                if (count < SOCKET_ID_TRIES) {
    … …  
    384386                        socket_id = 1;
    385387                        ++count;
    386                 // only this branch for last_id
     388                /* Only this branch for last_id */
    387389                } else {
    388390                        if (socket_id < INT_MAX) {
    389391                                ++ socket_id;
    390 /*                      } else if(socket_globals.last_id) {
    391 *                               socket_globals.last_id = 0;
    392 *                               socket_id = 1;
    393 */                      } else {
     392#if 0
     393                        } else if(socket_globals.last_id) {
     394                                socket_globals.last_id = 0;
     395                                socket_id = 1;
     396#endif
     397                        } else {
    394398                                return ELIMIT;
    395399                        }
    … …  
    425429                return EINVAL;
    426430       
    427         // store the socket
     431        /* Store the socket */
    428432        if (*socket_id <= 0) {
    429433                positive = (*socket_id == 0);
    … …  
    441445                return ENOMEM;
    442446       
    443         // initialize
     447        /* Initialize */
    444448        socket->phone = app_phone;
    445449        socket->port = -1;
    … …  
    493497        int accepted_id;
    494498
    495         // find the socket
     499        /* Find the socket */
    496500        socket = socket_cores_find(local_sockets, socket_id);
    497501        if (!socket)
    498502                return ENOTSOCK;
    499503       
    500         // destroy all accepted sockets
     504        /* Destroy all accepted sockets */
    501505        while ((accepted_id = dyn_fifo_pop(&socket->accepted)) >= 0)
    502506                socket_destroy(packet_phone, accepted_id, local_sockets,
    … …  
    535539        next_packet = pq_next(packet);
    536540        if (!next_packet) {
    537                 // write all if only one fragment
     541                /* Write all if only one fragment */
    538542                rc = data_reply(packet_get_data(packet),
    539543                    packet_get_data_length(packet));
    540544                if (rc != EOK)
    541545                        return rc;
    542                 // store the total length
     546                /* Store the total length */
    543547                *length = packet_get_data_length(packet);
    544548        } else {
    545                 // count the packet fragments
     549                /* Count the packet fragments */
    546550                fragments = 1;
    547551                next_packet = pq_next(packet);
    … …  
    549553                        ++fragments;
    550554               
    551                 // compute and store the fragment lengths
     555                /* Compute and store the fragment lengths */
    552556                lengths = (size_t *) malloc(sizeof(size_t) * fragments +
    553557                    sizeof(size_t));
    … …  
    565569                }
    566570               
    567                 // write the fragment lengths
     571                /* Write the fragment lengths */
    568572                rc = data_reply(lengths, sizeof(int) * (fragments + 1));
    569573                if (rc != EOK) {
    … …  
    573577                next_packet = packet;
    574578               
    575                 // write the fragments
     579                /* Write the fragments */
    576580                for (index = 0; index < fragments; ++index) {
    577581                        rc = data_reply(packet_get_data(next_packet),
    … …  
    584588                }
    585589               
    586                 // store the total length
     590                /* Store the total length */
    587591                *length = lengths[fragments];
    588592                free(lengths);
    … …  
    636640                return;
    637641       
    638         // find ports
     642        /* Find ports */
    639643        socket_port = socket_ports_find(global_sockets, socket->port);
    640644        if (socket_port) {
    641                 // find the socket
     645                /* Find the socket */
    642646                socket_ref = socket_port_map_find(&socket_port->map,
    643647                    socket->key, socket->key_length);
    … …  
    646650                        --socket_port->count;
    647651                       
    648                         // release if empty
     652                        /* Release if empty */
    649653                        if (socket_port->count <= 0) {
    650                                 // destroy the map
    651                                 socket_port_map_destroy(&socket_port->map);
    652                                 // release the port
     654                                /* Destroy the map */
     655                                socket_port_map_destroy(&socket_port->map, free);
     656                                /* Release the port */
    653657                                socket_ports_exclude(global_sockets,
    654                                     socket->port);
     658                                    socket->port, free);
    655659                        } else {
    656                                 // remove
     660                                /* Remove */
    657661                                socket_port_map_exclude(&socket_port->map,
    658                                     socket->key, socket->key_length);
     662                                    socket->key, socket->key_length, free);
    659663                        }
    660664                }
    … …  
    685689        int rc;
    686690
    687         // find ports
     691        /* Find ports */
    688692        socket_port = socket_ports_find(global_sockets, port);
    689693        if (!socket_port)
    690694                return ENOENT;
    691695       
    692         // add the socket
     696        /* Add the socket */
    693697        rc = socket_port_add_core(socket_port, socket, key, key_length);
    694698        if (rc != EOK)

  • uspace/lib/net/tl/tl_common.c

    r1ff896e r694ca93f  
    182182                        else
    183183                                packet_dimensions_exclude(packet_dimensions,
    184                                     DEVICE_INVALID_ID);
     184                                    DEVICE_INVALID_ID, free);
    185185                }
    186186        }
    … …  
    255255        int length;
    256256
    257         // detach the first packet and release the others
     257        /* Detach the first packet and release the others */
    258258        next = pq_detach(packet);
    259259        if (next)
    … …  
    262262        length = packet_get_addr(packet, &src, NULL);
    263263        if ((length > 0) && (!error) && (icmp_phone >= 0) &&
    264             // set both addresses to the source one (avoids the source address
    265             // deletion before setting the destination one)
     264            /*
     265             * Set both addresses to the source one (avoids the source address
     266             * deletion before setting the destination one)
     267             */
    266268            (packet_set_addr(packet, src, src, (size_t) length) == EOK)) {
    267269                return EOK;
    … …  
    299301                return EINVAL;
    300302
    301         // get the data length
     303        /* Get the data length */
    302304        if (!async_data_write_receive(&callid, &length))
    303305                return EINVAL;
    304306
    305         // get a new packet
     307        /* Get a new packet */
    306308        *packet = packet_get_4_remote(packet_phone, length, dimension->addr_len,
    307309            prefix + dimension->prefix, dimension->suffix);
    … …  
    309311                return ENOMEM;
    310312
    311         // allocate space in the packet
     313        /* Allocate space in the packet */
    312314        data = packet_suffix(*packet, length);
    313315        if (!data) {
    … …  
    316318        }
    317319
    318         // read the data into the packet
     320        /* Read the data into the packet */
    319321        rc = async_data_write_finalize(callid, data, length);
    320322        if (rc != EOK) {
    … …  
    323325        }
    324326       
    325         // set the packet destination address
     327        /* Set the packet destination address */
    326328        rc = packet_set_addr(*packet, NULL, (uint8_t *) addr, addrlen);
    327329        if (rc != EOK) {

  • uspace/lib/packet/generic/packet_server.c

    r1ff896e r694ca93f  
    112112    size_t max_content, size_t max_suffix)
    113113{
    114         // clear the packet content
     114        /* Clear the packet content */
    115115        bzero(((void *) packet) + sizeof(packet_t),
    116116            packet->length - sizeof(packet_t));
    117117       
    118         // clear the packet header
     118        /* Clear the packet header */
    119119        packet->order = 0;
    120120        packet->metric = 0;
    … …  
    151151        assert(fibril_mutex_is_locked(&ps_globals.lock));
    152152
    153         // already locked
     153        /* Already locked */
    154154        packet = (packet_t *) mmap(NULL, length, PROTO_READ | PROTO_WRITE,
    155155            MAP_SHARED | MAP_ANONYMOUS, 0, 0);

  • uspace/lib/softint/Makefile

    r1ff896e r694ca93f  
    3131EXTRA_CFLAGS = -Iinclude
    3232LIBRARY = libsoftint
     33SLIBRARY = libsoftint.so.0.0
     34LSONAME = libsofti.so0
    3335
    3436SOURCES = \
    35         generic/division.c\
     37        generic/division.c \
    3638        generic/multiplication.c
    3739

  • uspace/lib/softint/generic/multiplication.c

    r1ff896e r694ca93f  
    109109         * result does not fit in signed one */
    110110        if (SOFTINT_CHECK_OF && ((t2 < t1) || (t2 & (1ull << 63)))) {
    111                 // error, overflow
     111                /* Error, overflow */
    112112                return (neg ? INT64_MIN : INT64_MAX);
    113113        }
Note: See TracChangeset for help on using the changeset viewer.