Changes in / [5c1b3cd:71fe7e9d] in mainline


Ignore:
Files:
562 added
585 deleted
56 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    r5c1b3cd r71fe7e9d  
    6464@ "gta02" GTA02 / Neo FreeRunner
    6565@ "integratorcp" Integratorcp
    66 @ "beagleboardxm" BeagleBoard-xM
    67 @ "beaglebone" BeagleBone
     66@ "beagleboardxm" BeogleBoard-xM
    6867! [PLATFORM=arm32] MACHINE (choice)
    6968
    … …  
    8988% CPU type
    9089@ "cortex_a8" ARM Cortex A-8
    91 ! [PLATFORM=arm32&(MACHINE=beagleboardxm|MACHINE=beaglebone)] PROCESSOR (choice)
     90! [PLATFORM=arm32&MACHINE=beagleboardxm] PROCESSOR (choice)
    9291
    9392% CPU type
    … …  
    442441% Output device class
    443442@ "generic" Monitor or serial line
    444 ! [PLATFORM=arm32&(MACHINE=gta02|MACHINE=integratorcp|MACHINE=beagleboardxm|MACHINE=beaglebone)] CONFIG_HID_OUT (choice)
     443! [PLATFORM=arm32&(MACHINE=gta02|MACHINE=integratorcp|MACHINE=beagleboardxm)] CONFIG_HID_OUT (choice)
    445444
    446445% Output device class
    … …  
    489488! [PLATFORM=arm32&MACHINE=gta02] CONFIG_S3C24XX_IRQC (y)
    490489
    491 % Support for TI AM335x on-chip UART
    492 ! [(CONFIG_HID_OUT=generic|CONFIG_HID_OUT=serial)&PLATFORM=arm32&MACHINE=beaglebone] CONFIG_AM335X_UART (y/n)
    493 
    494 % Support for TI AM335x timers support
    495 ! [PLATFORM=arm32&MACHINE=beaglebone] CONFIG_AM335X_TIMERS (y)
    496 
    497 % Support for TI AMDM37x on-chip UART
     490% Support for TI AMDM37X on-chip UART
    498491! [(CONFIG_HID_OUT=generic|CONFIG_HID_OUT=serial)&PLATFORM=arm32&MACHINE=beagleboardxm] CONFIG_AMDM37X_UART (y/n)
    499492
    … …  
    517510
    518511% Serial line input module
    519 ! [CONFIG_DSRLNIN=y|(PLATFORM=arm32&MACHINE=gta02)|(PLATFORM=arm32&MACHINE=integratorcp&CONFIG_ARM926_UART=y)|(PLATFORM=arm32&MACHINE=beaglebone&CONFIG_AM335X_UART=y)|(PLATFORM=arm32&MACHINE=beagleboardxm&CONFIG_AMDM37X_UART=y)|(PLATFORM=ia64&MACHINE=i460GX&CONFIG_NS16550=y)|(PLATFORM=ia64&MACHINE=ski)|(PLATFORM=sparc64&PROCESSOR=sun4v)] CONFIG_SRLN (y)
     512! [CONFIG_DSRLNIN=y|(PLATFORM=arm32&MACHINE=gta02)|(PLATFORM=arm32&MACHINE=integratorcp&CONFIG_ARM926_UART=y)|(PLATFORM=arm32&MACHINE=beagleboardxm&CONFIG_AMDM37X_UART=y)|(PLATFORM=ia64&MACHINE=i460GX&CONFIG_NS16550=y)|(PLATFORM=ia64&MACHINE=ski)|(PLATFORM=sparc64&PROCESSOR=sun4v)] CONFIG_SRLN (y)
    520513
    521514% EGA support
    … …  
    642635% uImage OS type
    643636@ "2" NetBSD stage 2 boot loader
    644 ! [PLATFORM=arm32&(MACHINE=beagleboardxm|MACHINE=beaglebone)] UIMAGE_OS (choice)
     637! [PLATFORM=arm32&MACHINE=beagleboardxm] UIMAGE_OS (choice)
    645638
    646639% uImage OS type
    647640@ "5" Linux kernel
    648 ! [PLATFORM=arm32&MACHINE!=beagleboardxm&MACHINE!=beaglebone] UIMAGE_OS (choice)
     641! [PLATFORM=arm32&MACHINE!=beagleboardxm] UIMAGE_OS (choice)

  • boot/Makefile

    r5c1b3cd r71fe7e9d  
    6161        mkdir "$(DIST_PATH)/inc/c/"
    6262        cp -r -L "$(USPACE_PATH)/lib/c/include/." "$(DIST_PATH)/inc/c/"
    63         cp -r -L "$(ROOT_PATH)/abi/include/." "$(DIST_PATH)/inc/c/"
    64         cp -r -L "$(USPACE_PATH)/lib/c/arch/$(UARCH)/include/." "$(DIST_PATH)/inc/c/"
    6563        cat "$(USPACE_PATH)/lib/c/arch/$(UARCH)/_link.ld" | sed 's/^STARTUP(.*)$$//g' > "$(DIST_PATH)/inc/_link.ld"
    6664endif

  • boot/arch/arm32/Makefile.inc

    r5c1b3cd r71fe7e9d  
    3535endif
    3636
    37 ifeq ($(MACHINE), $(filter $(MACHINE),beagleboardxm beaglebone))
     37ifeq ($(MACHINE), beagleboardxm)
    3838        BOOT_OUTPUT = image.boot
    3939        POST_OUTPUT = $(ROOT_PATH)/uImage.bin

  • boot/arch/arm32/include/arch.h

    r5c1b3cd r71fe7e9d  
    4444#elif defined MACHINE_beagleboardxm
    4545#define BOOT_BASE       0x80000000
    46 #elif defined MACHINE_beaglebone
    47 #define BOOT_BASE       0x80000000
    4846#else
    4947#define BOOT_BASE       0x00000000
    … …  
    5351
    5452#ifdef MACHINE_beagleboardxm
    55         #define PA_OFFSET 0
    56 #elif defined MACHINE_beaglebone
    5753        #define PA_OFFSET 0
    5854#else

  • boot/arch/arm32/include/main.h

    r5c1b3cd r71fe7e9d  
    5151#define BBXM_THR_FULL           0x00000001
    5252
    53 /** Beaglebone UART register addresses
    54  *
    55  * This is UART0 of AM335x CPU
    56  */
    57 #define BBONE_SCONS_THR         0x44E09000
    58 #define BBONE_SCONS_SSR         0x44E09044
    59 
    60 /** Check this bit before writing (tx fifo full) */
    61 #define BBONE_TXFIFO_FULL       0x00000001
    6253
    6354/** GTA02 serial console UART register addresses.

  • boot/arch/arm32/include/mm.h

    r5c1b3cd r71fe7e9d  
    6363#define BBXM_RAM_END   0xc0000000
    6464
    65 /** Start of ram memory on AM335x */
    66 #define AM335x_RAM_START   0x80000000
    67 /** End of ram memory on AM335x */
    68 #define AM335x_RAM_END     0xC0000000
    69 
    7065
    7166/* Page table level 0 entry - "section" format is used
    … …  
    8176        unsigned int access_permission_0 : 2;
    8277        unsigned int tex : 3;
    83         unsigned int access_permission_1 : 1;
    84         unsigned int shareable : 1;
     78        unsigned int access_permission_1 : 2;
    8579        unsigned int non_global : 1;
    8680        unsigned int should_be_zero_2 : 1;

  • boot/arch/arm32/src/mm.c

    r5c1b3cd r71fe7e9d  
    3838#include <arch/mm.h>
    3939
    40 /** Disable the MMU */
    41 static void disable_paging(void)
    42 {
    43         asm volatile (
    44                 "mrc p15, 0, r0, c1, c0, 0\n"
    45                 "bic r0, r0, #1\n"
    46                 "mcr p15, 0, r0, c1, c0, 0\n"
    47                 ::: "r0"
    48         );
    49 }
    50 
    5140/** Check if caching can be enabled for a given memory section.
    5241 *
    … …  
    7059        const unsigned long address = section << PTE_SECTION_SHIFT;
    7160        if (address >= BBXM_RAM_START && address < BBXM_RAM_END)
    72                 return 1;
    73 #elif defined MACHINE_beaglebone
    74         const unsigned long address = section << PTE_SECTION_SHIFT;
    75         if (address >= AM335x_RAM_START && address < AM335x_RAM_END)
    7661                return 1;
    7762#endif
    … …  
    10388        pte->tex = 0;
    10489        pte->access_permission_1 = 0;
    105         pte->shareable = 0;
    10690        pte->non_global = 0;
    10791        pte->should_be_zero_2 = 0;
    … …  
    118102        for (page = 0; page < split_page; page++)
    119103                init_ptl0_section(&boot_pt[page], page);
     104       
     105        /*
     106         * Create 1:1 virtual-physical mapping in kernel space
     107         * (upper 2 GB), physical addresses start from 0.
     108         */
     109        /* BeagleBoard-xM (DM37x) memory starts at 2GB border,
     110         * thus mapping only lower 2GB is not not enough.
     111         * Map entire AS 1:1 instead and hope it works. */
     112        for (page = split_page; page < PTL0_ENTRIES; page++)
     113#ifndef MACHINE_beagleboardxm
     114                init_ptl0_section(&boot_pt[page], page - split_page);
     115#else
     116                init_ptl0_section(&boot_pt[page], page);
     117#endif
    120118       
    121119        asm volatile (
    … …  
    134132                "ldr r0, =0x55555555\n"
    135133                "mcr p15, 0, r0, c3, c0, 0\n"
    136 
     134               
    137135                /* Current settings */
    138136                "mrc p15, 0, r0, c1, c0, 0\n"
    … …  
    145143               
    146144                "orr r0, r0, r1\n"
    147 
    148                 /* Invalidate the TLB content before turning on the MMU.
    149                  * ARMv7-A Reference manual, B3.10.3
    150                  */
    151                 "mcr p15, 0, r0, c8, c7, 0\n"
    152145               
    153                 /* Store settings, enable the MMU */
     146                /* Store settings */
    154147                "mcr p15, 0, r0, c1, c0, 0\n"
    155148                ::: "r0", "r1"
    … …  
    159152/** Start the MMU - initialize page table and enable paging. */
    160153void mmu_start() {
    161         disable_paging();
    162154        init_boot_pt();
    163155        enable_paging();

  • boot/arch/arm32/src/putchar.c

    r5c1b3cd r71fe7e9d  
    4040#include <putchar.h>
    4141#include <str.h>
    42 
    43 #ifdef MACHINE_beaglebone
    44 
    45 /** Send a byte to the am335x serial console.
    46  *
    47  * @param byte          Byte to send.
    48  */
    49 static void scons_sendb_bbone(uint8_t byte)
    50 {
    51         volatile uint32_t *thr =
    52                 (volatile uint32_t *) BBONE_SCONS_THR;
    53         volatile uint32_t *ssr =
    54                 (volatile uint32_t *) BBONE_SCONS_SSR;
    55 
    56         /* Wait until transmitter is empty */
    57         while (*ssr & BBONE_TXFIFO_FULL);
    58 
    59         /* Transmit byte */
    60         *thr = (uint32_t) byte;
    61 }
    62 
    63 #endif
    6442
    6543#ifdef MACHINE_beagleboardxm
    … …  
    128106static void scons_sendb(uint8_t byte)
    129107{
    130 #ifdef MACHINE_beaglebone
    131         scons_sendb_bbone(byte);
    132 #endif
    133108#ifdef MACHINE_beagleboardxm
    134109        scons_sendb_bbxm(byte);

  • kernel/Makefile

    r5c1b3cd r71fe7e9d  
    3636COMMON_MAKEFILE = $(ROOT_PATH)/Makefile.common
    3737COMMON_HEADER = $(ROOT_PATH)/common.h
    38 COMMON_HEADER_ARCH = arch/$(KARCH)/include/arch/common.h
     38COMMON_HEADER_ARCH = arch/$(KARCH)/include/common.h
    3939
    4040CONFIG_MAKEFILE = $(ROOT_PATH)/Makefile.config
    … …  
    5959REAL_MAP = generic/src/debug/real_map
    6060
     61ABI_INCLUDE = generic/include/abi
     62ARCH_INCLUDE = generic/include/arch
     63GENARCH_INCLUDE = generic/include/genarch
     64
    6165GENMAP = tools/genmap.py
    6266JOBFILE = $(ROOT_PATH)/tools/jobfile.py
    … …  
    7276
    7377clean:
    74         rm -f $(DEPEND) $(DEPEND_PREV) $(RAW) $(BIN) $(MAP) $(JOB) $(MAP_PREV) $(DISASM) $(DUMP) $(REAL_MAP).* arch/*/_link.ld arch/*/include/arch/common.h
     78        rm -f $(DEPEND) $(DEPEND_PREV) $(RAW) $(BIN) $(MAP) $(JOB) $(MAP_PREV) $(DISASM) $(DUMP) $(REAL_MAP).* $(ABI_INCLUDE) $(ARCH_INCLUDE) $(GENARCH_INCLUDE) arch/*/_link.ld arch/*/include/common.h
    7579        find generic/src/ arch/*/src/ genarch/src/ test/ -name '*.o' -follow -exec rm \{\} \;
    7680
    … …  
    7882#
    7983
    80 INCLUDES = generic/include genarch/include arch/$(KARCH)/include ../abi/include
    81 INCLUDES_FLAGS = $(addprefix -I,$(INCLUDES))
     84INCLUDES = generic/include
    8285
    8386ifeq ($(CONFIG_OPTIMIZE_FOR_SIZE),y)
    … …  
    8992DEFS = -DKERNEL -DRELEASE=$(RELEASE) "-DCOPYRIGHT=$(COPYRIGHT)" "-DNAME=$(NAME)" -D__$(BITS)_BITS__ -D__$(ENDIANESS)__
    9093
    91 GCC_CFLAGS = $(INCLUDES_FLAGS) -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
     94GCC_CFLAGS = -I$(INCLUDES) -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
    9295        -fexec-charset=UTF-8 -fwide-exec-charset=UTF-32$(ENDIANESS) \
    9396        -finput-charset=UTF-8 -ffreestanding -fno-builtin -nostdlib -nostdinc \
    … …  
    9699        -pipe
    97100
    98 ICC_CFLAGS = $(INCLUDES_FLAGS) -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
     101ICC_CFLAGS = -I$(INCLUDES) -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
    99102        -ffreestanding -fno-builtin -nostdlib -nostdinc -Wall -Wmissing-prototypes \
    100103        -Werror-implicit-function-declaration -wd170
    101104
    102 CLANG_CFLAGS = $(INCLUDES_FLAGS) -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
     105CLANG_CFLAGS = -I$(INCLUDES) -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
    103106        -fexec-charset=UTF-8 -fwide-exec-charset=UTF-32$(ENDIANESS) \
    104107        -finput-charset=UTF-8 -ffreestanding -fno-builtin -nostdlib -nostdinc \
    … …  
    432435        $(GENMAP) $(MAP_PREV) $(DUMP) $@
    433436
    434 $(DEPEND): $(COMMON_HEADER_ARCH)
     437$(DEPEND): $(ABI_INCLUDE) $(ARCH_INCLUDE) $(GENARCH_INCLUDE) $(COMMON_HEADER_ARCH)
    435438        makedepend -f - -- $(DEPEND_DEFS) $(CFLAGS) -- $(ARCH_SOURCES) $(GENARCH_SOURCES) $(GENERIC_SOURCES) > $@ 2> /dev/null
    436439        -[ -f $(DEPEND_PREV) ] && diff -q $(DEPEND_PREV) $@ && mv -f $(DEPEND_PREV) $@
    437440
     441$(ABI_INCLUDE): ../abi/include/
     442        ln -sfn ../../$< $@
     443
     444$(ARCH_INCLUDE): arch/$(KARCH)/include/
     445        ln -sfn ../../$< $@
     446
     447$(GENARCH_INCLUDE): genarch/include/
     448        ln -sfn ../../$< $@
     449
    438450$(COMMON_HEADER_ARCH): $(COMMON_HEADER)
    439         ln -sfn ../../../../$< $@
     451        ln -sfn ../../../$< $@

  • kernel/arch/arm32/Makefile.inc

    r5c1b3cd r71fe7e9d  
    8585endif
    8686
    87 ifeq ($(MACHINE),beaglebone)
    88         ARCH_SOURCES += arch/$(KARCH)/src/mach/beaglebone/beaglebone.c
    89 endif
    90 
    9187ifeq ($(CONFIG_PL050),y)
    9288        ARCH_SOURCES += genarch/src/drivers/pl050/pl050.c

  • kernel/arch/arm32/_link.ld.in

    r5c1b3cd r71fe7e9d  
    1010#define KERNEL_LOAD_ADDRESS 0xb0a08000
    1111#elif defined MACHINE_beagleboardxm
    12 #define KERNEL_LOAD_ADDRESS 0x80a00000
    13 #elif defined MACHINE_beaglebone
    1412#define KERNEL_LOAD_ADDRESS 0x80a00000
    1513#else

  • kernel/arch/arm32/src/arm32.c

    r5c1b3cd r71fe7e9d  
    138138        uint8_t *stck;
    139139       
    140         stck = &THREAD->kstack[STACK_SIZE];
     140        stck = &THREAD->kstack[STACK_SIZE - SP_DELTA];
    141141        supervisor_sp = (uintptr_t) stck;
    142142}

  • kernel/arch/arm32/src/mach/beagleboardxm/beagleboardxm.c

    r5c1b3cd r71fe7e9d  
    3535#include <arch/exception.h>
    3636#include <arch/mach/beagleboardxm/beagleboardxm.h>
    37 #include <genarch/drivers/amdm37x/uart.h>
    38 #include <genarch/drivers/amdm37x/irc.h>
    39 #include <genarch/drivers/amdm37x/gpt.h>
     37#include <genarch/drivers/amdm37x_irc/amdm37x_irc.h>
     38#include <genarch/drivers/amdm37x_uart/amdm37x_uart.h>
     39#include <genarch/drivers/amdm37x_gpt/amdm37x_gpt.h>
    4040#include <genarch/fb/fb.h>
    4141#include <genarch/srln/srln.h>

  • kernel/arch/arm32/src/machine_func.c

    r5c1b3cd r71fe7e9d  
    4242#include <arch/mach/integratorcp/integratorcp.h>
    4343#include <arch/mach/beagleboardxm/beagleboardxm.h>
    44 #include <arch/mach/beaglebone/beaglebone.h>
    4544
    4645/** Pointer to machine_ops structure being used. */
    … …  
    5655#elif defined(MACHINE_beagleboardxm)
    5756        machine_ops = &bbxm_machine_ops;
    58 #elif defined(MACHINE_beaglebone)
    59         machine_ops = &bbone_machine_ops;
    6057#else
    6158#error Machine type not defined.

  • kernel/arch/ia64/src/ivt.S

    r5c1b3cd r71fe7e9d  
    3535#define FRS_TO_SAVE 30
    3636#define STACK_ITEMS             (21 + FRS_TO_SAVE * 2)
    37 #define STACK_FRAME_SIZE        ALIGN_UP((STACK_ITEMS * STACK_ITEM_SIZE) + STACK_SCRATCH_AREA_SIZE, STACK_ALIGNMENT)
     37#define STACK_FRAME_SIZE        ALIGN_UP((STACK_ITEMS*STACK_ITEM_SIZE) + STACK_SCRATCH_AREA_SIZE, STACK_ALIGNMENT)
    3838
    3939#if (STACK_ITEMS % 2 == 0)

  • kernel/arch/ia64/src/proc/scheduler.c

    r5c1b3cd r71fe7e9d  
    9090                :
    9191                : "r" (&THREAD->kstack[STACK_SIZE / 2]),
    92                   "r" (&THREAD->kstack[STACK_SIZE / 2])
     92                  "r" (&THREAD->kstack[STACK_SIZE / 2 - SP_DELTA])
    9393                );
    9494}

  • kernel/arch/mips32/src/mips32.c

    r5c1b3cd r71fe7e9d  
    228228{
    229229        supervisor_sp =
    230             (uintptr_t) &THREAD->kstack[STACK_SIZE];
     230            (uintptr_t) &THREAD->kstack[STACK_SIZE - SP_DELTA];
    231231}
    232232

  • kernel/arch/mips64/src/mips64.c

    r5c1b3cd r71fe7e9d  
    205205{
    206206        supervisor_sp =
    207             (uintptr_t) &THREAD->kstack[STACK_SIZE];
     207            (uintptr_t) &THREAD->kstack[STACK_SIZE - SP_DELTA];
    208208}
    209209

  • kernel/arch/ppc32/src/proc/scheduler.c

    r5c1b3cd r71fe7e9d  
    5555        asm volatile (
    5656                "mtsprg0 %[ksp]\n"
    57                 :: [ksp] "r" (KA2PA(&THREAD->kstack[STACK_SIZE]))
     57                :: [ksp] "r" (KA2PA(&THREAD->kstack[STACK_SIZE - SP_DELTA]))
    5858        );
    5959}

  • kernel/arch/sparc64/src/proc/sun4u/scheduler.c

    r5c1b3cd r71fe7e9d  
    5252{
    5353        if (THREAD->uspace) {
    54                 uint64_t sp;
    55 
    5654                /*
    5755                 * Write kernel stack address to %g6 of the alternate and
    … …  
    6563                 *   before it explicitly uses %g7.
    6664                 */
    67                 sp = (uintptr_t) THREAD->kstack + STACK_SIZE - STACK_BIAS;
     65                uint64_t sp = (uintptr_t) THREAD->kstack + STACK_SIZE -
     66                    (STACK_BIAS + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT));
    6867                write_to_ig_g6(sp);
    6968                write_to_ag_g6(sp);
    … …  
    7776        if (THREAD->uspace) {
    7877                /* sample the state of the userspace window buffer */
    79                 THREAD->arch.uspace_window_buffer =
    80                     (uint8_t *) read_from_ag_g7();
     78                THREAD->arch.uspace_window_buffer = (uint8_t *) read_from_ag_g7();
    8179        }
    8280}

  • kernel/arch/sparc64/src/proc/sun4v/scheduler.c

    r5c1b3cd r71fe7e9d  
    5555{
    5656        if (THREAD->uspace) {
    57                 uint64_t sp;
    58 
    59                 sp = (uintptr_t) THREAD->kstack + STACK_SIZE - STACK_BIAS;
     57                uint64_t sp = (uintptr_t) THREAD->kstack + STACK_SIZE -
     58                    (STACK_BIAS + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT));
    6059                asi_u64_write(ASI_SCRATCHPAD, SCRATCHPAD_KSTACK, sp);
    6160                asi_u64_write(ASI_SCRATCHPAD, SCRATCHPAD_WBUF,

  • kernel/genarch/Makefile.inc

    r5c1b3cd r71fe7e9d  
    106106endif
    107107
    108 ifeq ($(CONFIG_AM335X_UART),y)
    109         GENARCH_SOURCES += \
    110                 genarch/src/drivers/am335x/uart.c
    111 endif
    112 
    113 ifeq ($(CONFIG_AM335X_TIMERS),y)
    114         GENARCH_SOURCES += \
    115                 genarch/src/drivers/am335x/timer.c
    116 endif
    117 
    118108ifeq ($(CONFIG_AMDM37X_UART),y)
    119109        GENARCH_SOURCES += \
    120                 genarch/src/drivers/amdm37x/uart.c
     110                genarch/src/drivers/amdm37x_uart/amdm37x_uart.c
    121111endif
    122112

  • kernel/generic/src/interrupt/interrupt.c

    r5c1b3cd r71fe7e9d  
    5454#include <proc/thread.h>
    5555#include <arch/cycle.h>
    56 #include <arch/stack.h>
    5756#include <str.h>
    5857#include <trace.h>
    … …  
    223222        /*
    224223         * The istate structure should be right at the bottom of the kernel
    225          * memory stack.
     224         * stack.
    226225         */
    227         return (istate_t *) &thread->kstack[MEM_STACK_SIZE - sizeof(istate_t)];
     226        return (istate_t *) ((uint8_t *)
     227            thread->kstack + STACK_SIZE - sizeof(istate_t));
    228228}
    229229

  • kernel/generic/src/main/kinit.c

    r5c1b3cd r71fe7e9d  
    250250                                    CAP_IO_MANAGER | CAP_IRQ_REG);
    251251                               
    252                                 if (!ipc_phone_0) {
     252                                if (!ipc_phone_0)
    253253                                        ipc_phone_0 = &programs[i].task->answerbox;
    254                                         /*
    255                                          * Hold the first task so that the
    256                                          * ipc_phone_0 remains a valid pointer
    257                                          * even if the first task exits for
    258                                          * whatever reason.
    259                                          */
    260                                         task_hold(programs[i].task);
    261                                 }
    262254                        }
    263255                       

  • kernel/generic/src/proc/task.c

    r5c1b3cd r71fe7e9d  
    125125{
    126126        size_t tasks_left;
    127 
    128         if (ipc_phone_0) {
    129                 task_t *task_0 = ipc_phone_0->task;
    130                 ipc_phone_0 = NULL;
    131                 /*
    132                  * The first task is held by kinit(), we need to release it or
    133                  * it will never finish cleanup.
    134                  */
    135                 task_release(task_0);
    136         }
    137127       
    138128        /* Repeat until there are any tasks except TASK */

  • uspace/Makefile.common

    r5c1b3cd r71fe7e9d  
    103103
    104104LIBC_PREFIX = $(LIB_PREFIX)/c
    105 LIBC_INCLUDES_FLAGS = \
    106         -I$(LIBC_PREFIX)/include \
    107         -I$(LIBC_PREFIX)/arch/$(UARCH)/include \
    108         -I$(ROOT_PATH)/abi/include
    109105LIBSOFTFLOAT_PREFIX = $(LIB_PREFIX)/softfloat
    110106LIBSOFTINT_PREFIX = $(LIB_PREFIX)/softint
    … …  
    186182        find . -name '*.lo' -follow -exec rm \{\} \;
    187183
    188 GCC_CFLAGS = $(LIBC_INCLUDES_FLAGS) -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
     184GCC_CFLAGS = -I$(LIBC_PREFIX)/include -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
    189185        -fexec-charset=UTF-8 -fwide-exec-charset=UTF-32$(ENDIANESS) \
    190186        -finput-charset=UTF-8 -ffreestanding -fno-builtin -nostdlib -nostdinc \
    … …  
    193189        -pipe -g -D__$(ENDIANESS)__
    194190
    195 ICC_CFLAGS = $(LIBC_INCLUDES_FLAGS) -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
     191ICC_CFLAGS = -I$(LIBC_PREFIX)/include -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
    196192        -fexec-charset=UTF-8 -fwide-exec-charset=UTF-32$(ENDIANESS) \
    197193        -finput-charset=UTF-8 -ffreestanding -fno-builtin -nostdlib -nostdinc \
    … …  
    200196        -pipe -g -D__$(ENDIANESS)__
    201197
    202 CLANG_CFLAGS = $(LIBC_INCLUDES_FLAGS) -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
     198CLANG_CFLAGS = -I$(LIBC_PREFIX)/include -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
    203199        -fexec-charset=UTF-8 -fwide-exec-charset=UTF-32$(ENDIANESS) \
    204200        -finput-charset=UTF-8 -ffreestanding -fno-builtin -nostdlib -nostdinc \

  • uspace/app/netecho/netecho.c

    r5c1b3cd r71fe7e9d  
    243243                if (verbose)
    244244                        printf("accept()\n");
    245                 socket_id = accept(listening_id, (void *) address_buf, &addrlen);
     245                socket_id = accept(listening_id, (void *) address_buf, &addrlen);
    246246                if (socket_id <= 0) {
    247247                        socket_print_error(stderr, socket_id, "Socket accept: ", "\n");
    … …  
    312312                                rc = sendto(socket_id, reply ? reply : data, reply ? reply_length : length, 0, address, addrlen);
    313313                                if (rc != EOK)
    314                                         socket_print_error(stderr, rc, "Socket sendto: ", "\n");
     314                                        socket_print_error(stderr, rc, "Socket send: ", "\n");
    315315                        }
    316316                }
    … …  
    394394                return listening_id;
    395395        }
    396        
    397         /* Bind the listening socket */
    398         rc = bind(listening_id, address, addrlen);
    399         if (rc != EOK) {
    400                 socket_print_error(stderr, rc, "Socket bind: ", "\n");
    401                 return rc;
    402         }
    403        
     396
    404397        /* if the stream socket is used */
    405398        if (type == SOCK_STREAM) {
    … …  
    409402                        backlog = 3;
    410403                }
    411                
     404
    412405                /* Set the backlog */
    413406                rc = listen(listening_id, backlog);
    … …  
    416409                        return rc;
    417410                }
     411        }
     412
     413        /* Bind the listening socket */
     414        rc = bind(listening_id, address, addrlen);
     415        if (rc != EOK) {
     416                socket_print_error(stderr, rc, "Socket bind: ", "\n");
     417                return rc;
    418418        }
    419419

  • uspace/app/nettest3/nettest3.c

    r5c1b3cd r71fe7e9d  
    6363        port = 7;
    6464
    65         data = (char *) "Hello World!";
     65        data = (char *)"Hello World!";
    6666        size = str_size(data);
    6767
    … …  
    9898
    9999        printf("connect()\n");
    100         rc = connect(fd, (struct sockaddr *) &addr, sizeof(addr));
     100        rc = connect(fd, (struct sockaddr *)&addr, sizeof(addr));
    101101        printf(" -> %d\n", rc);
    102102        if (rc != 0)
    … …  
    115115        } while (rc > 0);
    116116
    117         async_usleep(1000 * 1000);
     117        async_usleep(1000*1000);
    118118
    119119        printf("closesocket()\n");
    … …  
    124124}
    125125
     126
    126127/** @}
    127128 */

  • uspace/drv/char/i8042/main.c

    r5c1b3cd r71fe7e9d  
    3636
    3737#include <libarch/inttypes.h>
    38 #include <libarch/config.h>
    3938#include <ddf/driver.h>
    4039#include <device/hw_res_parsed.h>
    … …  
    4342#include <ddf/log.h>
    4443#include <stdio.h>
    45 #include <async.h>
    4644#include "i8042.h"
    4745
    … …  
    154152        printf("%s: HelenOS PS/2 driver.\n", NAME);
    155153        ddf_log_init(NAME);
    156        
    157         /*
    158          * Alleviate the virtual memory / page table pressure caused by
    159          * interrupt storms when the default large stacks are used.
    160          */
    161         async_set_interrupt_handler_stack_size(PAGE_SIZE);
    162 
    163154        return ddf_driver_main(&i8042_driver);
    164155}

  • uspace/lib/c/Makefile

    r5c1b3cd r71fe7e9d  
    3131ROOT_PATH = $(USPACE_PREFIX)/..
    3232
     33INCLUDE_ABI = include/abi
     34INCLUDE_LIBARCH = include/libarch
     35
    3336COMMON_MAKEFILE = $(ROOT_PATH)/Makefile.common
    3437COMMON_HEADER = $(ROOT_PATH)/common.h
    35 COMMON_HEADER_ARCH = arch/$(UARCH)/include/libarch/common.h
     38COMMON_HEADER_ARCH = arch/$(UARCH)/include/common.h
    3639
    3740CONFIG_MAKEFILE = $(ROOT_PATH)/Makefile.config
    … …  
    4346        $(LIBC_PREFIX)/arch/$(UARCH)/_link-dlexe.ld
    4447
    45 PRE_DEPEND = $(COMMON_HEADER_ARCH)
     48PRE_DEPEND = $(INCLUDE_ABI) $(INCLUDE_LIBARCH) $(COMMON_HEADER_ARCH)
    4649EXTRA_OUTPUT = $(LINKER_SCRIPTS)
    47 EXTRA_CLEAN = $(COMMON_HEADER_ARCH) $(LINKER_SCRIPTS)
     50EXTRA_CLEAN = $(INCLUDE_ABI) $(INCLUDE_LIBARCH) $(COMMON_HEADER_ARCH) $(LINKER_SCRIPTS)
    4851LIBRARY = libc
    4952SLIBRARY = libc.so.0.0
    … …  
    159162include $(USPACE_PREFIX)/Makefile.common
    160163
     164$(INCLUDE_LIBARCH): arch/$(UARCH)/include
     165        ln -sfn ../$< $@
     166
     167$(INCLUDE_ABI): ../../../abi/include/
     168        ln -sfn ../$< $@
    161169
    162170$(LIBC_PREFIX)/arch/$(UARCH)/_link.ld: $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld.in
    … …  
    173181
    174182$(COMMON_HEADER_ARCH): $(COMMON_HEADER)
    175         ln -sfn ../../../../$< $@
     183        ln -sfn ../../../$< $@

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

    r5c1b3cd r71fe7e9d  
    3434#include <unistd.h>
    3535
    36 tcb_t * tls_alloc_arch(void **data, size_t size)
     36tcb_t * __alloc_tls(void **data, size_t size)
    3737{
    3838        return tls_alloc_variant_2(data, size);
    3939}
    4040
    41 void tls_free_arch(tcb_t *tcb, size_t size)
     41void __free_tls_arch(tcb_t *tcb, size_t size)
    4242{
    4343        tls_free_variant_2(tcb, size);

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

    r5c1b3cd r71fe7e9d  
    3838#include <sys/types.h>
    3939
    40 tcb_t *tls_alloc_arch(void **data, size_t size)
     40tcb_t * __alloc_tls(void **data, size_t size)
    4141{
    4242        return tls_alloc_variant_2(data, size);
    4343}
    4444
    45 void tls_free_arch(tcb_t *tcb, size_t size)
     45void __free_tls_arch(tcb_t *tcb, size_t size)
    4646{
    4747        tls_free_variant_2(tcb, size);

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

    r5c1b3cd r71fe7e9d  
    3838#include <sys/types.h>
    3939
    40 tcb_t *tls_alloc_arch(void **data, size_t size)
     40tcb_t * __alloc_tls(void **data, size_t size)
    4141{
    4242        return tls_alloc_variant_1(data, size);
    4343}
    4444
    45 void tls_free_arch(tcb_t *tcb, size_t size)
     45void __free_tls_arch(tcb_t *tcb, size_t size)
    4646{
    4747        tls_free_variant_1(tcb, size);

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

    r5c1b3cd r71fe7e9d  
    3939#include <align.h>
    4040
    41 tcb_t *tls_alloc_arch(void **data, size_t size)
     41tcb_t * __alloc_tls(void **data, size_t size)
    4242{
    4343        return tls_alloc_variant_2(data, size);
    4444}
    4545
    46 void tls_free_arch(tcb_t *tcb, size_t size)
     46void __free_tls_arch(tcb_t *tcb, size_t size)
    4747{
    4848        tls_free_variant_2(tcb, size);

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

    r5c1b3cd r71fe7e9d  
    3838#include <malloc.h>
    3939
    40 tcb_t *tls_alloc_arch(void **data, size_t size)
     40tcb_t * __alloc_tls(void **data, size_t size)
    4141{
    4242        return tls_alloc_variant_1(data, size);
    4343}
    4444
    45 void tls_free_arch(tcb_t *tcb, size_t size)
     45void __free_tls_arch(tcb_t *tcb, size_t size)
    4646{
    4747        tls_free_variant_1(tcb, size);

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

    r5c1b3cd r71fe7e9d  
    3737#include <sys/types.h>
    3838
    39 tcb_t * tls_alloc_arch(void **data, size_t size)
     39tcb_t * __alloc_tls(void **data, size_t size)
    4040{
    4141        return tls_alloc_variant_1(data, size);
    4242}
    4343
    44 void tls_free_arch(tcb_t *tcb, size_t size)
     44void __free_tls_arch(tcb_t *tcb, size_t size)
    4545{
    4646        tls_free_variant_1(tcb, size);

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

    r5c1b3cd r71fe7e9d  
    3737#include <sys/types.h>
    3838
    39 tcb_t *tls_alloc_arch(void **data, size_t size)
     39tcb_t * __alloc_tls(void **data, size_t size)
    4040{
    4141        return tls_alloc_variant_1(data, size);
    4242}
    4343
    44 void tls_free_arch(tcb_t *tcb, size_t size)
     44void __free_tls_arch(tcb_t *tcb, size_t size)
    4545{
    4646        tls_free_variant_1(tcb, size);

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

    r5c1b3cd r71fe7e9d  
    3636#include <sys/types.h>
    3737
    38 tcb_t *tls_alloc_arch(void **data, size_t size)
     38tcb_t * __alloc_tls(void **data, size_t size)
    3939{
    4040        return tls_alloc_variant_1(data, size);
    4141}
    4242
    43 void tls_free_arch(tcb_t *tcb, size_t size)
     43void __free_tls_arch(tcb_t *tcb, size_t size)
    4444{
    4545        tls_free_variant_1(tcb, size);

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

    r5c1b3cd r71fe7e9d  
    3838#include <sys/types.h>
    3939
    40 tcb_t *tls_alloc_arch(void **data, size_t size)
     40tcb_t * __alloc_tls(void **data, size_t size)
    4141{
    4242        return tls_alloc_variant_2(data, size);
    4343}
    4444
    45 void tls_free_arch(tcb_t *tcb, size_t size)
     45void __free_tls_arch(tcb_t *tcb, size_t size)
    4646{
    4747        tls_free_variant_2(tcb, size);

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

    r5c1b3cd r71fe7e9d  
    350350static async_client_conn_t client_connection = default_client_connection;
    351351static async_interrupt_handler_t interrupt_received = default_interrupt_received;
    352 static size_t interrupt_handler_stksz = FIBRIL_DFLT_STK_SIZE;
    353352
    354353/** Setter for client_connection function pointer.
    … …  
    371370{
    372371        interrupt_received = intr;
    373 }
    374 
    375 /** Set the stack size for the interrupt handler notification fibrils.
    376  *
    377  * @param size Stack size in bytes.
    378  */
    379 void async_set_interrupt_handler_stack_size(size_t size)
    380 {
    381         interrupt_handler_stksz = size;
    382372}
    383373
    … …  
    597587        msg->call = *call;
    598588       
    599         fid_t fid = fibril_create_generic(notification_fibril, msg,
    600             interrupt_handler_stksz);
     589        fid_t fid = fibril_create(notification_fibril, msg);
    601590        if (fid == 0) {
    602591                free(msg);
    … …  
    20682057       
    20692058        async_sess_t *sess = exch->sess;
    2070         assert(sess != NULL);
    20712059       
    20722060        atomic_dec(&sess->refcnt);

  • uspace/lib/c/generic/fibril.c

    r5c1b3cd r71fe7e9d  
    9595fibril_t *fibril_setup(void)
    9696{
    97         tcb_t *tcb = tls_make();
     97        tcb_t *tcb = __make_tls();
    9898        if (!tcb)
    9999                return NULL;
    … …  
    101101        fibril_t *fibril = malloc(sizeof(fibril_t));
    102102        if (!fibril) {
    103                 tls_free(tcb);
     103                __free_tls(tcb);
    104104                return NULL;
    105105        }
    … …  
    122122void fibril_teardown(fibril_t *fibril)
    123123{
    124         tls_free(fibril->tcb);
     124        __free_tls(fibril->tcb);
    125125        free(fibril);
    126126}
    … …  
    256256 * @param func Implementing function of the new fibril.
    257257 * @param arg Argument to pass to func.
    258  * @param stksz Stack size in bytes.
    259258 *
    260259 * @return 0 on failure or TLS of the new fibril.
    261260 *
    262261 */
    263 fid_t fibril_create_generic(int (*func)(void *), void *arg, size_t stksz)
     262fid_t fibril_create(int (*func)(void *), void *arg)
    264263{
    265264        fibril_t *fibril;
    … …  
    269268                return 0;
    270269       
    271         size_t stack_size = (stksz == FIBRIL_DFLT_STK_SIZE) ?
    272             stack_size_get() : stksz;
     270        size_t stack_size = stack_size_get();
    273271        fibril->stack = as_area_create((void *) -1, stack_size,
    274272            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE | AS_AREA_GUARD |

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

    r5c1b3cd r71fe7e9d  
    192192/** Default thread for new connections.
    193193 *
    194  * @param[in] iid   The initial message identifier.
    195  * @param[in] icall The initial message call structure.
    196  * @param[in] arg   Local argument.
    197  *
     194 * @param[in] iid       The initial message identifier.
     195 * @param[in] icall     The initial message call structure.
     196 * @param[in] arg       Local argument.
    198197 */
    199198static void socket_connection(ipc_callid_t iid, ipc_call_t * icall, void *arg)
    200199{
    201         while (true) {
    202                 ipc_call_t call;
    203                 ipc_callid_t callid = async_get_call(&call);
    204                
    205                 if (!IPC_GET_IMETHOD(call)) {
    206                         async_answer_0(callid, 0);
    207                         return;
     200        ipc_callid_t callid;
     201        ipc_call_t call;
     202        socket_t *socket;
     203        int rc;
     204
     205loop:
     206        callid = async_get_call(&call);
     207
     208        switch (IPC_GET_IMETHOD(call)) {
     209        case NET_SOCKET_RECEIVED:
     210        case NET_SOCKET_ACCEPTED:
     211        case NET_SOCKET_DATA_FRAGMENT_SIZE:
     212                fibril_rwlock_read_lock(&socket_globals.lock);
     213
     214                /* Find the socket */
     215                socket = sockets_find(socket_get_sockets(),
     216                    SOCKET_GET_SOCKET_ID(call));
     217                if (!socket) {
     218                        rc = ENOTSOCK;
     219                        fibril_rwlock_read_unlock(&socket_globals.lock);
     220                        break;
    208221                }
    209                
    210                 int rc;
    211222               
    212223                switch (IPC_GET_IMETHOD(call)) {
    213224                case NET_SOCKET_RECEIVED:
     225                        fibril_mutex_lock(&socket->receive_lock);
     226                        /* Push the number of received packet fragments */
     227                        rc = dyn_fifo_push(&socket->received,
     228                            SOCKET_GET_DATA_FRAGMENTS(call),
     229                            SOCKET_MAX_RECEIVED_SIZE);
     230                        if (rc == EOK) {
     231                                /* Signal the received packet */
     232                                fibril_condvar_signal(&socket->receive_signal);
     233                        }
     234                        fibril_mutex_unlock(&socket->receive_lock);
     235                        break;
     236
    214237                case NET_SOCKET_ACCEPTED:
    215                 case NET_SOCKET_DATA_FRAGMENT_SIZE:
    216                         fibril_rwlock_read_lock(&socket_globals.lock);
    217                        
    218                         /* Find the socket */
    219                         socket_t *socket = sockets_find(socket_get_sockets(),
    220                             SOCKET_GET_SOCKET_ID(call));
    221                         if (!socket) {
    222                                 rc = ENOTSOCK;
    223                                 fibril_rwlock_read_unlock(&socket_globals.lock);
    224                                 break;
     238                        /* Push the new socket identifier */
     239                        fibril_mutex_lock(&socket->accept_lock);
     240                        rc = dyn_fifo_push(&socket->accepted, 1,
     241                            SOCKET_MAX_ACCEPTED_SIZE);
     242                        if (rc == EOK) {
     243                                /* Signal the accepted socket */
     244                                fibril_condvar_signal(&socket->accept_signal);
    225245                        }
    226                        
    227                         switch (IPC_GET_IMETHOD(call)) {
    228                         case NET_SOCKET_RECEIVED:
    229                                 fibril_mutex_lock(&socket->receive_lock);
    230                                 /* Push the number of received packet fragments */
    231                                 rc = dyn_fifo_push(&socket->received,
    232                                     SOCKET_GET_DATA_FRAGMENTS(call),
    233                                     SOCKET_MAX_RECEIVED_SIZE);
    234                                 if (rc == EOK) {
    235                                         /* Signal the received packet */
    236                                         fibril_condvar_signal(&socket->receive_signal);
    237                                 }
    238                                 fibril_mutex_unlock(&socket->receive_lock);
    239                                 break;
    240                                
    241                         case NET_SOCKET_ACCEPTED:
    242                                 /* Push the new socket identifier */
    243                                 fibril_mutex_lock(&socket->accept_lock);
    244                                 rc = dyn_fifo_push(&socket->accepted, 1,
    245                                     SOCKET_MAX_ACCEPTED_SIZE);
    246                                 if (rc == EOK) {
    247                                         /* Signal the accepted socket */
    248                                         fibril_condvar_signal(&socket->accept_signal);
    249                                 }
    250                                 fibril_mutex_unlock(&socket->accept_lock);
    251                                 break;
    252                        
    253                         default:
    254                                 rc = ENOTSUP;
    255                         }
    256                        
    257                         if ((SOCKET_GET_DATA_FRAGMENT_SIZE(call) > 0) &&
    258                             (SOCKET_GET_DATA_FRAGMENT_SIZE(call) !=
    259                             socket->data_fragment_size)) {
    260                                 fibril_rwlock_write_lock(&socket->sending_lock);
    261                                
    262                                 /* Set the data fragment size */
    263                                 socket->data_fragment_size =
    264                                     SOCKET_GET_DATA_FRAGMENT_SIZE(call);
    265                                
    266                                 fibril_rwlock_write_unlock(&socket->sending_lock);
    267                         }
    268                        
    269                         fibril_rwlock_read_unlock(&socket_globals.lock);
     246                        fibril_mutex_unlock(&socket->accept_lock);
    270247                        break;
    271                        
     248
    272249                default:
    273250                        rc = ENOTSUP;
    274251                }
    275                
    276                 async_answer_0(callid, (sysarg_t) rc);
    277         }
     252
     253                if ((SOCKET_GET_DATA_FRAGMENT_SIZE(call) > 0) &&
     254                    (SOCKET_GET_DATA_FRAGMENT_SIZE(call) !=
     255                    socket->data_fragment_size)) {
     256                        fibril_rwlock_write_lock(&socket->sending_lock);
     257
     258                        /* Set the data fragment size */
     259                        socket->data_fragment_size =
     260                            SOCKET_GET_DATA_FRAGMENT_SIZE(call);
     261
     262                        fibril_rwlock_write_unlock(&socket->sending_lock);
     263                }
     264
     265                fibril_rwlock_read_unlock(&socket_globals.lock);
     266                break;
     267
     268        default:
     269                rc = ENOTSUP;
     270        }
     271
     272        async_answer_0(callid, (sysarg_t) rc);
     273        goto loop;
    278274}
    279275

  • uspace/lib/c/generic/tls.c

    r5c1b3cd r71fe7e9d  
    5151 * @return Pointer to TCB.
    5252 */
    53 tcb_t *tls_make(void)
     53tcb_t *__make_tls(void)
    5454{
    5555        void *data;
    … …  
    5757        size_t tls_size = &_tbss_end - &_tdata_start;
    5858       
    59         tcb = tls_alloc_arch(&data, tls_size);
     59        tcb = __alloc_tls(&data, tls_size);
    6060        if (!tcb)
    6161                return NULL;
    … …  
    7474}
    7575
    76 void tls_free(tcb_t *tcb)
     76void __free_tls(tcb_t *tcb)
    7777{
    7878        size_t tls_size = &_tbss_end - &_tdata_start;
    79         tls_free_arch(tcb, tls_size);
     79        __free_tls_arch(tcb, tls_size);
    8080}
    8181

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

    r5c1b3cd r71fe7e9d  
    156156extern void async_set_client_connection(async_client_conn_t);
    157157extern void async_set_interrupt_received(async_interrupt_handler_t);
    158 extern void async_set_interrupt_handler_stack_size(size_t);
    159158
    160159/*

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

    r5c1b3cd r71fe7e9d  
    8686extern void context_restore(context_t *ctx) __attribute__((noreturn));
    8787
    88 #define FIBRIL_DFLT_STK_SIZE    0
    89 
    90 #define fibril_create(func, arg) \
    91         fibril_create_generic((func), (arg), FIBRIL_DFLT_STK_SIZE)
    92 extern fid_t fibril_create_generic(int (*func)(void *), void *arg, size_t);
     88extern fid_t fibril_create(int (*func)(void *), void *arg);
    9389extern void fibril_destroy(fid_t fid);
    9490extern fibril_t *fibril_setup(void);

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

    r5c1b3cd r71fe7e9d  
    3838#define min(a, b)  ((a) < (b) ? (a) : (b))
    3939#define max(a, b)  ((a) > (b) ? (a) : (b))
    40 #define abs(a)     ((a) >= 0 ? (a) : -(a))
     40#define abs(a)     ((a) >= 0 ? (a) : (-a))
    4141
    4242#define ARRAY_SIZE(array)   (sizeof(array) / sizeof(array[0]))

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

    r5c1b3cd r71fe7e9d  
    4848extern char _tbss_end;
    4949
    50 extern tcb_t *tls_make(void);
    51 extern tcb_t *tls_alloc_arch(void **, size_t);
    52 extern void tls_free(tcb_t *);
    53 extern void tls_free_arch(tcb_t *, size_t);
     50extern tcb_t *__make_tls(void);
     51extern tcb_t *__alloc_tls(void **, size_t);
     52extern void __free_tls(tcb_t *);
     53extern void __free_tls_arch(tcb_t *, size_t);
    5454
    5555#ifdef CONFIG_TLS_VARIANT_1

  • uspace/srv/net/tcp/conn.c

    r5c1b3cd r71fe7e9d  
    354354{
    355355        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_find_ref(%p)", sp);
    356        
    357         log_msg(LOG_DEFAULT, LVL_DEBUG2, "compare conn (f:(%x,%u), l:(%x,%u))",
    358             sp->foreign.addr.ipv4, sp->foreign.port,
    359             sp->local.addr.ipv4, sp->local.port);
    360        
     356
    361357        fibril_mutex_lock(&conn_list_lock);
    362        
     358
    363359        list_foreach(conn_list, link) {
    364360                tcp_conn_t *conn = list_get_instance(link, tcp_conn_t, link);
    365361                tcp_sockpair_t *csp = &conn->ident;
    366                
    367                 log_msg(LOG_DEFAULT, LVL_DEBUG2, " - with (f:(%x,%u), l:(%x,%u))",
     362                log_msg(LOG_DEFAULT, LVL_DEBUG2, "compare with conn (f:(%x,%u), l:(%x,%u))",
    368363                    csp->foreign.addr.ipv4, csp->foreign.port,
    369364                    csp->local.addr.ipv4, csp->local.port);
    370                
    371365                if (tcp_sockpair_match(sp, csp)) {
    372366                        tcp_conn_addref(conn);
    … …  
    375369                }
    376370        }
    377        
     371
    378372        fibril_mutex_unlock(&conn_list_lock);
    379373        return NULL;

  • uspace/srv/net/tcp/sock.c

    r5c1b3cd r71fe7e9d  
    203203{
    204204        int rc;
    205         struct sockaddr_in *addr;
    206         size_t addr_size;
     205        struct sockaddr *addr;
     206        size_t addr_len;
    207207        socket_core_t *sock_core;
    208208        tcp_sockdata_t *socket;
    209        
     209
    210210        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_bind()");
    211211        log_msg(LOG_DEFAULT, LVL_DEBUG, " - async_data_write_accept");
    212        
    213         addr = NULL;
    214        
    215         rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_size);
     212        rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_len);
    216213        if (rc != EOK) {
    217214                async_answer_0(callid, rc);
    218                 goto out;
    219         }
    220        
    221         if (addr_size != sizeof(struct sockaddr_in)) {
    222                 async_answer_0(callid, EINVAL);
    223                 goto out;
    224         }
    225        
     215                return;
     216        }
     217
    226218        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_bind");
    227219        rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
    228             addr, addr_size, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
     220            addr, addr_len, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
    229221            last_used_port);
    230222        if (rc != EOK) {
    231223                async_answer_0(callid, rc);
    232                 goto out;
    233         }
    234        
     224                return;
     225        }
     226
    235227        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_cores_find");
    236228        sock_core = socket_cores_find(&client->sockets, SOCKET_GET_SOCKET_ID(call));
    237         if (sock_core == NULL) {
    238                 async_answer_0(callid, ENOENT);
    239                 goto out;
    240         }
    241        
    242         socket = (tcp_sockdata_t *)sock_core->specific_data;
    243         /* XXX Anything to do? */
    244         (void) socket;
    245        
     229        if (sock_core != NULL) {
     230                socket = (tcp_sockdata_t *)sock_core->specific_data;
     231                /* XXX Anything to do? */
     232                (void) socket;
     233        }
     234
    246235        log_msg(LOG_DEFAULT, LVL_DEBUG, " - success");
    247236        async_answer_0(callid, EOK);
    248        
    249 out:
    250         if (addr != NULL)
    251                 free(addr);
    252237}
    253238
    … …  
    264249        tcp_sock_lconn_t *lconn;
    265250        int i;
    266         int rc;
    267251
    268252        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_listen()");
    … …  
    284268                return;
    285269        }
    286        
    287         if (sock_core->port <= 0) {
    288                 rc = socket_bind_free_port(&gsock, sock_core,
    289                     TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
    290                     last_used_port);
    291                 if (rc != EOK) {
    292                         async_answer_0(callid, rc);
    293                         return;
    294                 }
    295                
    296                 last_used_port = sock_core->port;
    297         }
    298        
    299         socket = (tcp_sockdata_t *) sock_core->specific_data;
    300        
     270
     271        socket = (tcp_sockdata_t *)sock_core->specific_data;
     272
    301273        /*
    302274         * Prepare @c backlog listening connections.
    303275         */
    304276        fibril_mutex_lock(&socket->lock);
    305        
     277
    306278        socket->backlog = backlog;
    307279        socket->lconn = calloc(backlog, sizeof(tcp_conn_t *));
    … …  
    311283                return;
    312284        }
    313        
     285
    314286        log_msg(LOG_DEFAULT, LVL_DEBUG, " - open connections");
    315        
     287
    316288        lsocket.addr.ipv4 = TCP_IPV4_ANY;
    317289        lsocket.port = sock_core->port;
    318290        fsocket.addr.ipv4 = TCP_IPV4_ANY;
    319291        fsocket.port = TCP_PORT_ANY;
    320        
     292
    321293        for (i = 0; i < backlog; i++) {
    322294
    … …  
    390362                        return;
    391363                }
    392                
     364
    393365                last_used_port = sock_core->port;
    394366        }
    … …  
    469441                return;
    470442        }
    471        
    472         if (sock_core->port <= 0) {
    473                 rc = socket_bind_free_port(&gsock, sock_core,
    474                     TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
    475                     last_used_port);
    476                 if (rc != EOK) {
    477                         async_answer_0(callid, rc);
    478                         return;
    479                 }
    480                
    481                 last_used_port = sock_core->port;
    482         }
    483443
    484444        socket = (tcp_sockdata_t *)sock_core->specific_data;

  • uspace/srv/net/udp/assoc.c

    r5c1b3cd r71fe7e9d  
    200200/** Set local socket in association.
    201201 *
    202  * @param assoc Association
    203  * @param lsock Local socket (deeply copied)
    204  *
     202 * @param assoc         Association
     203 * @param fsock         Foreign socket (deeply copied)
    205204 */
    206205void udp_assoc_set_local(udp_assoc_t *assoc, udp_sock_t *lsock)
    … …  
    209208        fibril_mutex_lock(&assoc->lock);
    210209        assoc->ident.local = *lsock;
    211         fibril_mutex_unlock(&assoc->lock);
    212 }
    213 
    214 /** Set local port in association.
    215  *
    216  * @param assoc Association
    217  * @param lport Local port
    218  *
    219  */
    220 void udp_assoc_set_local_port(udp_assoc_t *assoc, uint16_t lport)
    221 {
    222         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_set_local(%p, %" PRIu16 ")", assoc, lport);
    223         fibril_mutex_lock(&assoc->lock);
    224         assoc->ident.local.port = lport;
    225210        fibril_mutex_unlock(&assoc->lock);
    226211}
    … …  
    421406}
    422407
     408
    423409/**
    424410 * @}

  • uspace/srv/net/udp/assoc.h

    r5c1b3cd r71fe7e9d  
    4747extern void udp_assoc_set_foreign(udp_assoc_t *, udp_sock_t *);
    4848extern void udp_assoc_set_local(udp_assoc_t *, udp_sock_t *);
    49 extern void udp_assoc_set_local_port(udp_assoc_t *, uint16_t);
    5049extern int udp_assoc_send(udp_assoc_t *, udp_sock_t *, udp_msg_t *);
    5150extern int udp_assoc_recv(udp_assoc_t *, udp_msg_t **, udp_sock_t *);

  • uspace/srv/net/udp/sock.c

    r5c1b3cd r71fe7e9d  
    9090        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_notify_data(%d)", sock_core->socket_id);
    9191        async_exch_t *exch = async_exchange_begin(sock_core->sess);
    92         async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t) sock_core->socket_id,
     92        async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t)sock_core->socket_id,
    9393            UDP_FRAGMENT_SIZE, 0, 0, 1);
    9494        async_exchange_end(exch);
    … …  
    177177                goto out;
    178178        }
    179        
    180         if (addr_size != sizeof(struct sockaddr_in)) {
    181                 async_answer_0(callid, EINVAL);
    182                 goto out;
    183         }
    184        
     179
    185180        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_bind");
    186181        rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
    … …  
    191186                goto out;
    192187        }
    193        
     188
     189        if (addr_size != sizeof(struct sockaddr_in)) {
     190                async_answer_0(callid, EINVAL);
     191                goto out;
     192        }
     193
    194194        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_cores_find");
    195195        sock_core = socket_cores_find(&client->sockets, SOCKET_GET_SOCKET_ID(call));
    … …  
    249249static void udp_sock_sendto(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    250250{
     251        int socket_id;
     252        int fragments;
     253        int index;
     254        struct sockaddr_in *addr;
     255        size_t addr_size;
     256        socket_core_t *sock_core;
     257        udp_sockdata_t *socket;
     258        udp_sock_t fsock, *fsockp;
     259        ipc_call_t answer;
     260        ipc_callid_t wcallid;
     261        size_t length;
     262        uint8_t buffer[UDP_FRAGMENT_SIZE];
     263        udp_error_t urc;
     264        int rc;
     265
    251266        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_send()");
    252        
    253         struct sockaddr_in *addr = NULL;
    254         udp_sock_t fsock;
    255         udp_sock_t *fsock_ptr;
    256        
     267
     268        addr = NULL;
     269
    257270        if (IPC_GET_IMETHOD(call) == NET_SOCKET_SENDTO) {
    258                 size_t addr_size;
    259                 int rc = async_data_write_accept((void **) &addr, false,
     271                rc = async_data_write_accept((void **) &addr, false,
    260272                    0, 0, 0, &addr_size);
    261273                if (rc != EOK) {
    … …  
    263275                        goto out;
    264276                }
    265                
     277
    266278                if (addr_size != sizeof(struct sockaddr_in)) {
    267279                        async_answer_0(callid, EINVAL);
    268280                        goto out;
    269281                }
    270                
     282
    271283                fsock.addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
    272284                fsock.port = uint16_t_be2host(addr->sin_port);
    273                 fsock_ptr = &fsock;
    274         } else
    275                 fsock_ptr = NULL;
    276        
    277         int socket_id = SOCKET_GET_SOCKET_ID(call);
    278        
     285                fsockp = &fsock;
     286        } else {
     287                fsockp = NULL;
     288        }
     289
     290        socket_id = SOCKET_GET_SOCKET_ID(call);
     291        fragments = SOCKET_GET_DATA_FRAGMENTS(call);
    279292        SOCKET_GET_FLAGS(call);
    280        
    281         socket_core_t *sock_core =
    282             socket_cores_find(&client->sockets, socket_id);
     293
     294        sock_core = socket_cores_find(&client->sockets, socket_id);
    283295        if (sock_core == NULL) {
    284296                async_answer_0(callid, ENOTSOCK);
    285297                goto out;
    286298        }
    287        
    288         udp_sockdata_t *socket =
    289             (udp_sockdata_t *) sock_core->specific_data;
    290        
    291         if (sock_core->port <= 0) {
     299
     300        if (sock_core->port == 0) {
    292301                /* Implicitly bind socket to port */
    293                 int rc = socket_bind_free_port(&gsock, sock_core,
    294                     UDP_FREE_PORTS_START, UDP_FREE_PORTS_END, last_used_port);
     302                rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
     303                    addr, addr_size, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
     304                    last_used_port);
    295305                if (rc != EOK) {
    296306                        async_answer_0(callid, rc);
    297307                        goto out;
    298308                }
    299                
    300                 assert(sock_core->port > 0);
    301                
    302                 udp_error_t urc = udp_uc_set_local_port(socket->assoc,
    303                     sock_core->port);
    304                
    305                 if (urc != UDP_EOK) {
    306                         // TODO: better error handling
    307                         async_answer_0(callid, EINTR);
    308                         goto out;
    309                 }
    310                
    311                 last_used_port = sock_core->port;
    312         }
    313        
     309        }
     310
     311        socket = (udp_sockdata_t *)sock_core->specific_data;
    314312        fibril_mutex_lock(&socket->lock);
    315        
     313
    316314        if (socket->assoc->ident.local.addr.ipv4 == UDP_IPV4_ANY) {
    317315                /* Determine local IP address */
    318316                inet_addr_t loc_addr, rem_addr;
    319                
    320                 rem_addr.ipv4 = fsock_ptr ? fsock.addr.ipv4 :
     317
     318                rem_addr.ipv4 = fsockp ? fsock.addr.ipv4 :
    321319                    socket->assoc->ident.foreign.addr.ipv4;
    322                
    323                 int rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
     320
     321                rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
    324322                if (rc != EOK) {
    325323                        fibril_mutex_unlock(&socket->lock);
    … …  
    329327                        return;
    330328                }
    331                
     329
    332330                socket->assoc->ident.local.addr.ipv4 = loc_addr.ipv4;
    333331                log_msg(LOG_DEFAULT, LVL_DEBUG, "Local IP address is %x",
    334332                    socket->assoc->ident.local.addr.ipv4);
    335333        }
    336        
     334
     335
    337336        assert(socket->assoc != NULL);
    338        
    339         int fragments = SOCKET_GET_DATA_FRAGMENTS(call);
    340         for (int index = 0; index < fragments; index++) {
    341                 ipc_callid_t wcallid;
    342                 size_t length;
    343                
     337
     338        for (index = 0; index < fragments; index++) {
    344339                if (!async_data_write_receive(&wcallid, &length)) {
    345340                        fibril_mutex_unlock(&socket->lock);
    … …  
    347342                        goto out;
    348343                }
    349                
     344
    350345                if (length > UDP_FRAGMENT_SIZE)
    351346                        length = UDP_FRAGMENT_SIZE;
    352                
    353                 uint8_t buffer[UDP_FRAGMENT_SIZE];
    354                 int rc = async_data_write_finalize(wcallid, buffer, length);
     347
     348                rc = async_data_write_finalize(wcallid, buffer, length);
    355349                if (rc != EOK) {
    356350                        fibril_mutex_unlock(&socket->lock);
    … …  
    358352                        goto out;
    359353                }
    360                
    361                 udp_error_t urc =
    362                     udp_uc_send(socket->assoc, fsock_ptr, buffer, length, 0);
    363                
     354
     355                urc = udp_uc_send(socket->assoc, fsockp, buffer, length, 0);
     356
    364357                switch (urc) {
    365358                case UDP_EOK:
    366359                        rc = EOK;
    367360                        break;
    368                 case UDP_ENORES:
    369                         rc = ENOMEM;
    370                         break;
    371                 case UDP_EUNSPEC:
    372                         rc = EINVAL;
    373                         break;
    374                 case UDP_ENOROUTE:
    375                         rc = EIO;
    376                         break;
     361/*              case TCP_ENOTEXIST:
     362                        rc = ENOTCONN;
     363                        break;
     364                case TCP_ECLOSING:
     365                        rc = ENOTCONN;
     366                        break;
     367                case TCP_ERESET:
     368                        rc = ECONNABORTED;
     369                        break;*/
    377370                default:
    378371                        assert(false);
    379372                }
    380                
     373
    381374                if (rc != EOK) {
    382375                        fibril_mutex_unlock(&socket->lock);
    … …  
    385378                }
    386379        }
    387        
    388         ipc_call_t answer;
    389380       
    390381        IPC_SET_ARG1(answer, 0);
    … …  
    535526static void udp_sock_close(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    536527{
     528        int socket_id;
     529        socket_core_t *sock_core;
     530        udp_sockdata_t *socket;
     531        int rc;
     532
    537533        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close()");
    538         int socket_id = SOCKET_GET_SOCKET_ID(call);
    539        
    540         socket_core_t *sock_core =
    541             socket_cores_find(&client->sockets, socket_id);
     534        socket_id = SOCKET_GET_SOCKET_ID(call);
     535
     536        sock_core = socket_cores_find(&client->sockets, socket_id);
    542537        if (sock_core == NULL) {
    543538                async_answer_0(callid, ENOTSOCK);
    544539                return;
    545540        }
    546        
    547         udp_sockdata_t *socket =
    548             (udp_sockdata_t *) sock_core->specific_data;
     541
     542        socket = (udp_sockdata_t *)sock_core->specific_data;
    549543        fibril_mutex_lock(&socket->lock);
    550        
    551         int rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
     544
     545        rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
    552546            udp_free_sock_data);
    553547        if (rc != EOK) {
    … …  
    556550                return;
    557551        }
    558        
     552
    559553        fibril_mutex_unlock(&socket->lock);
    560554        async_answer_0(callid, EOK);
    … …  
    589583                            &sock->recv_buffer_lock);
    590584                }
    591                
     585
    592586                log_msg(LOG_DEFAULT, LVL_DEBUG, "[] call udp_uc_receive()");
    593587                urc = udp_uc_receive(sock->assoc, sock->recv_buffer,
    594588                    UDP_FRAGMENT_SIZE, &rcvd, &xflags, &sock->recv_fsock);
    595589                sock->recv_error = urc;
    596                
     590
    597591                udp_sock_notify_data(sock->sock_core);
    598                
     592
    599593                if (urc != UDP_EOK) {
    600594                        fibril_condvar_broadcast(&sock->recv_buffer_cv);
    … …  
    602596                        break;
    603597                }
    604                
     598
    605599                log_msg(LOG_DEFAULT, LVL_DEBUG, "[] got data - broadcast recv_buffer_cv");
    606                
     600
    607601                sock->recv_buffer_used = rcvd;
    608602                fibril_mutex_unlock(&sock->recv_buffer_lock);

  • uspace/srv/net/udp/ucall.c

    r5c1b3cd r71fe7e9d  
    6868{
    6969        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_uc_set_local(%p, %p)", assoc, lsock);
    70        
     70
    7171        udp_assoc_set_local(assoc, lsock);
    72         return UDP_EOK;
    73 }
    74 
    75 udp_error_t udp_uc_set_local_port(udp_assoc_t *assoc, uint16_t lport)
    76 {
    77         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_uc_set_local(%p, %" PRIu16 ")", assoc, lport);
    78        
    79         udp_assoc_set_local_port(assoc, lport);
    8072        return UDP_EOK;
    8173}

  • uspace/srv/net/udp/ucall.h

    r5c1b3cd r71fe7e9d  
    4242extern udp_error_t udp_uc_set_foreign(udp_assoc_t *, udp_sock_t *);
    4343extern udp_error_t udp_uc_set_local(udp_assoc_t *, udp_sock_t *);
    44 extern udp_error_t udp_uc_set_local_port(udp_assoc_t *, uint16_t);
    4544extern udp_error_t udp_uc_send(udp_assoc_t *, udp_sock_t *, void *, size_t,
    4645    xflags_t);

  • uspace/srv/net/udp/udp_type.h

    r5c1b3cd r71fe7e9d  
    6666};
    6767
    68 enum udp_port {
     68enum tcp_port {
    6969        UDP_PORT_ANY = 0
    7070};

  • version

    r5c1b3cd r71fe7e9d  
    4646
    4747NAME = Fajtl
    48 COPYRIGHT = Copyright (c) 2001-2013 HelenOS project
    49 
     48COPYRIGHT = Copyright (c) 2001-2012 HelenOS project
Note: See TracChangeset for help on using the changeset viewer.