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


Ignore:
Files:
585 added
562 deleted
56 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    r71fe7e9d r5c1b3cd  
    6464@ "gta02" GTA02 / Neo FreeRunner
    6565@ "integratorcp" Integratorcp
    66 @ "beagleboardxm" BeogleBoard-xM
     66@ "beagleboardxm" BeagleBoard-xM
     67@ "beaglebone" BeagleBone
    6768! [PLATFORM=arm32] MACHINE (choice)
    6869
    … …  
    8889% CPU type
    8990@ "cortex_a8" ARM Cortex A-8
    90 ! [PLATFORM=arm32&MACHINE=beagleboardxm] PROCESSOR (choice)
     91! [PLATFORM=arm32&(MACHINE=beagleboardxm|MACHINE=beaglebone)] PROCESSOR (choice)
    9192
    9293% CPU type
    … …  
    441442% Output device class
    442443@ "generic" Monitor or serial line
    443 ! [PLATFORM=arm32&(MACHINE=gta02|MACHINE=integratorcp|MACHINE=beagleboardxm)] CONFIG_HID_OUT (choice)
     444! [PLATFORM=arm32&(MACHINE=gta02|MACHINE=integratorcp|MACHINE=beagleboardxm|MACHINE=beaglebone)] CONFIG_HID_OUT (choice)
    444445
    445446% Output device class
    … …  
    488489! [PLATFORM=arm32&MACHINE=gta02] CONFIG_S3C24XX_IRQC (y)
    489490
    490 % Support for TI AMDM37X on-chip UART
     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
    491498! [(CONFIG_HID_OUT=generic|CONFIG_HID_OUT=serial)&PLATFORM=arm32&MACHINE=beagleboardxm] CONFIG_AMDM37X_UART (y/n)
    492499
    … …  
    510517
    511518% Serial line input module
    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)
     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)
    513520
    514521% EGA support
    … …  
    635642% uImage OS type
    636643@ "2" NetBSD stage 2 boot loader
    637 ! [PLATFORM=arm32&MACHINE=beagleboardxm] UIMAGE_OS (choice)
     644! [PLATFORM=arm32&(MACHINE=beagleboardxm|MACHINE=beaglebone)] UIMAGE_OS (choice)
    638645
    639646% uImage OS type
    640647@ "5" Linux kernel
    641 ! [PLATFORM=arm32&MACHINE!=beagleboardxm] UIMAGE_OS (choice)
     648! [PLATFORM=arm32&MACHINE!=beagleboardxm&MACHINE!=beaglebone] UIMAGE_OS (choice)

  • boot/Makefile

    r71fe7e9d r5c1b3cd  
    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/"
    6365        cat "$(USPACE_PATH)/lib/c/arch/$(UARCH)/_link.ld" | sed 's/^STARTUP(.*)$$//g' > "$(DIST_PATH)/inc/_link.ld"
    6466endif

  • boot/arch/arm32/Makefile.inc

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

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

    r71fe7e9d r5c1b3cd  
    4444#elif defined MACHINE_beagleboardxm
    4545#define BOOT_BASE       0x80000000
     46#elif defined MACHINE_beaglebone
     47#define BOOT_BASE       0x80000000
    4648#else
    4749#define BOOT_BASE       0x00000000
    … …  
    5153
    5254#ifdef MACHINE_beagleboardxm
     55        #define PA_OFFSET 0
     56#elif defined MACHINE_beaglebone
    5357        #define PA_OFFSET 0
    5458#else

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

    r71fe7e9d r5c1b3cd  
    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
    5362
    5463/** GTA02 serial console UART register addresses.

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

    r71fe7e9d r5c1b3cd  
    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
    6570
    6671/* Page table level 0 entry - "section" format is used
    … …  
    7681        unsigned int access_permission_0 : 2;
    7782        unsigned int tex : 3;
    78         unsigned int access_permission_1 : 2;
     83        unsigned int access_permission_1 : 1;
     84        unsigned int shareable : 1;
    7985        unsigned int non_global : 1;
    8086        unsigned int should_be_zero_2 : 1;

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

    r71fe7e9d r5c1b3cd  
    3838#include <arch/mm.h>
    3939
     40/** Disable the MMU */
     41static 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
    4051/** Check if caching can be enabled for a given memory section.
    4152 *
    … …  
    5970        const unsigned long address = section << PTE_SECTION_SHIFT;
    6071        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)
    6176                return 1;
    6277#endif
    … …  
    88103        pte->tex = 0;
    89104        pte->access_permission_1 = 0;
     105        pte->shareable = 0;
    90106        pte->non_global = 0;
    91107        pte->should_be_zero_2 = 0;
    … …  
    102118        for (page = 0; page < split_page; page++)
    103119                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
    118120       
    119121        asm volatile (
    … …  
    132134                "ldr r0, =0x55555555\n"
    133135                "mcr p15, 0, r0, c3, c0, 0\n"
    134                
     136
    135137                /* Current settings */
    136138                "mrc p15, 0, r0, c1, c0, 0\n"
    … …  
    143145               
    144146                "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"
    145152               
    146                 /* Store settings */
     153                /* Store settings, enable the MMU */
    147154                "mcr p15, 0, r0, c1, c0, 0\n"
    148155                ::: "r0", "r1"
    … …  
    152159/** Start the MMU - initialize page table and enable paging. */
    153160void mmu_start() {
     161        disable_paging();
    154162        init_boot_pt();
    155163        enable_paging();

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

    r71fe7e9d r5c1b3cd  
    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 */
     49static 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
    4264
    4365#ifdef MACHINE_beagleboardxm
    … …  
    106128static void scons_sendb(uint8_t byte)
    107129{
     130#ifdef MACHINE_beaglebone
     131        scons_sendb_bbone(byte);
     132#endif
    108133#ifdef MACHINE_beagleboardxm
    109134        scons_sendb_bbxm(byte);

  • kernel/Makefile

    r71fe7e9d r5c1b3cd  
    3636COMMON_MAKEFILE = $(ROOT_PATH)/Makefile.common
    3737COMMON_HEADER = $(ROOT_PATH)/common.h
    38 COMMON_HEADER_ARCH = arch/$(KARCH)/include/common.h
     38COMMON_HEADER_ARCH = arch/$(KARCH)/include/arch/common.h
    3939
    4040CONFIG_MAKEFILE = $(ROOT_PATH)/Makefile.config
    … …  
    5959REAL_MAP = generic/src/debug/real_map
    6060
    61 ABI_INCLUDE = generic/include/abi
    62 ARCH_INCLUDE = generic/include/arch
    63 GENARCH_INCLUDE = generic/include/genarch
    64 
    6561GENMAP = tools/genmap.py
    6662JOBFILE = $(ROOT_PATH)/tools/jobfile.py
    … …  
    7672
    7773clean:
    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
     74        rm -f $(DEPEND) $(DEPEND_PREV) $(RAW) $(BIN) $(MAP) $(JOB) $(MAP_PREV) $(DISASM) $(DUMP) $(REAL_MAP).* arch/*/_link.ld arch/*/include/arch/common.h
    7975        find generic/src/ arch/*/src/ genarch/src/ test/ -name '*.o' -follow -exec rm \{\} \;
    8076
    … …  
    8278#
    8379
    84 INCLUDES = generic/include
     80INCLUDES = generic/include genarch/include arch/$(KARCH)/include ../abi/include
     81INCLUDES_FLAGS = $(addprefix -I,$(INCLUDES))
    8582
    8683ifeq ($(CONFIG_OPTIMIZE_FOR_SIZE),y)
    … …  
    9289DEFS = -DKERNEL -DRELEASE=$(RELEASE) "-DCOPYRIGHT=$(COPYRIGHT)" "-DNAME=$(NAME)" -D__$(BITS)_BITS__ -D__$(ENDIANESS)__
    9390
    94 GCC_CFLAGS = -I$(INCLUDES) -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
     91GCC_CFLAGS = $(INCLUDES_FLAGS) -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
    9592        -fexec-charset=UTF-8 -fwide-exec-charset=UTF-32$(ENDIANESS) \
    9693        -finput-charset=UTF-8 -ffreestanding -fno-builtin -nostdlib -nostdinc \
    … …  
    9996        -pipe
    10097
    101 ICC_CFLAGS = -I$(INCLUDES) -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
     98ICC_CFLAGS = $(INCLUDES_FLAGS) -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
    10299        -ffreestanding -fno-builtin -nostdlib -nostdinc -Wall -Wmissing-prototypes \
    103100        -Werror-implicit-function-declaration -wd170
    104101
    105 CLANG_CFLAGS = -I$(INCLUDES) -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
     102CLANG_CFLAGS = $(INCLUDES_FLAGS) -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
    106103        -fexec-charset=UTF-8 -fwide-exec-charset=UTF-32$(ENDIANESS) \
    107104        -finput-charset=UTF-8 -ffreestanding -fno-builtin -nostdlib -nostdinc \
    … …  
    435432        $(GENMAP) $(MAP_PREV) $(DUMP) $@
    436433
    437 $(DEPEND): $(ABI_INCLUDE) $(ARCH_INCLUDE) $(GENARCH_INCLUDE) $(COMMON_HEADER_ARCH)
     434$(DEPEND): $(COMMON_HEADER_ARCH)
    438435        makedepend -f - -- $(DEPEND_DEFS) $(CFLAGS) -- $(ARCH_SOURCES) $(GENARCH_SOURCES) $(GENERIC_SOURCES) > $@ 2> /dev/null
    439436        -[ -f $(DEPEND_PREV) ] && diff -q $(DEPEND_PREV) $@ && mv -f $(DEPEND_PREV) $@
    440437
    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 
    450438$(COMMON_HEADER_ARCH): $(COMMON_HEADER)
    451         ln -sfn ../../../$< $@
     439        ln -sfn ../../../../$< $@

  • kernel/arch/arm32/Makefile.inc

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

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

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

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

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

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

    r71fe7e9d r5c1b3cd  
    3535#include <arch/exception.h>
    3636#include <arch/mach/beagleboardxm/beagleboardxm.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>
     37#include <genarch/drivers/amdm37x/uart.h>
     38#include <genarch/drivers/amdm37x/irc.h>
     39#include <genarch/drivers/amdm37x/gpt.h>
    4040#include <genarch/fb/fb.h>
    4141#include <genarch/srln/srln.h>

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

    r71fe7e9d r5c1b3cd  
    4242#include <arch/mach/integratorcp/integratorcp.h>
    4343#include <arch/mach/beagleboardxm/beagleboardxm.h>
     44#include <arch/mach/beaglebone/beaglebone.h>
    4445
    4546/** Pointer to machine_ops structure being used. */
    … …  
    5556#elif defined(MACHINE_beagleboardxm)
    5657        machine_ops = &bbxm_machine_ops;
     58#elif defined(MACHINE_beaglebone)
     59        machine_ops = &bbone_machine_ops;
    5760#else
    5861#error Machine type not defined.

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

    r71fe7e9d r5c1b3cd  
    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

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

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

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

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

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

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

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

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

    r71fe7e9d r5c1b3cd  
    5252{
    5353        if (THREAD->uspace) {
     54                uint64_t sp;
     55
    5456                /*
    5557                 * Write kernel stack address to %g6 of the alternate and
    … …  
    6365                 *   before it explicitly uses %g7.
    6466                 */
    65                 uint64_t sp = (uintptr_t) THREAD->kstack + STACK_SIZE -
    66                     (STACK_BIAS + ALIGN_UP(STACK_ITEM_SIZE, STACK_ALIGNMENT));
     67                sp = (uintptr_t) THREAD->kstack + STACK_SIZE - STACK_BIAS;
    6768                write_to_ig_g6(sp);
    6869                write_to_ag_g6(sp);
    … …  
    7677        if (THREAD->uspace) {
    7778                /* sample the state of the userspace window buffer */
    78                 THREAD->arch.uspace_window_buffer = (uint8_t *) read_from_ag_g7();
     79                THREAD->arch.uspace_window_buffer =
     80                    (uint8_t *) read_from_ag_g7();
    7981        }
    8082}

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

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

  • kernel/genarch/Makefile.inc

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

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

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

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

    r71fe7e9d r5c1b3cd  
    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                                }
    254262                        }
    255263                       

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

    r71fe7e9d r5c1b3cd  
    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        }
    127137       
    128138        /* Repeat until there are any tasks except TASK */

  • uspace/Makefile.common

    r71fe7e9d r5c1b3cd  
    103103
    104104LIBC_PREFIX = $(LIB_PREFIX)/c
     105LIBC_INCLUDES_FLAGS = \
     106        -I$(LIBC_PREFIX)/include \
     107        -I$(LIBC_PREFIX)/arch/$(UARCH)/include \
     108        -I$(ROOT_PATH)/abi/include
    105109LIBSOFTFLOAT_PREFIX = $(LIB_PREFIX)/softfloat
    106110LIBSOFTINT_PREFIX = $(LIB_PREFIX)/softint
    … …  
    182186        find . -name '*.lo' -follow -exec rm \{\} \;
    183187
    184 GCC_CFLAGS = -I$(LIBC_PREFIX)/include -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
     188GCC_CFLAGS = $(LIBC_INCLUDES_FLAGS) -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
    185189        -fexec-charset=UTF-8 -fwide-exec-charset=UTF-32$(ENDIANESS) \
    186190        -finput-charset=UTF-8 -ffreestanding -fno-builtin -nostdlib -nostdinc \
    … …  
    189193        -pipe -g -D__$(ENDIANESS)__
    190194
    191 ICC_CFLAGS = -I$(LIBC_PREFIX)/include -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
     195ICC_CFLAGS = $(LIBC_INCLUDES_FLAGS) -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
    192196        -fexec-charset=UTF-8 -fwide-exec-charset=UTF-32$(ENDIANESS) \
    193197        -finput-charset=UTF-8 -ffreestanding -fno-builtin -nostdlib -nostdinc \
    … …  
    196200        -pipe -g -D__$(ENDIANESS)__
    197201
    198 CLANG_CFLAGS = -I$(LIBC_PREFIX)/include -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
     202CLANG_CFLAGS = $(LIBC_INCLUDES_FLAGS) -O$(OPTIMIZATION) -imacros $(CONFIG_HEADER) \
    199203        -fexec-charset=UTF-8 -fwide-exec-charset=UTF-32$(ENDIANESS) \
    200204        -finput-charset=UTF-8 -ffreestanding -fno-builtin -nostdlib -nostdinc \

  • uspace/app/netecho/netecho.c

    r71fe7e9d r5c1b3cd  
    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 send: ", "\n");
     314                                        socket_print_error(stderr, rc, "Socket sendto: ", "\n");
    315315                        }
    316316                }
    … …  
    394394                return listening_id;
    395395        }
    396 
     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       
    397404        /* if the stream socket is used */
    398405        if (type == SOCK_STREAM) {
    … …  
    402409                        backlog = 3;
    403410                }
    404 
     411               
    405412                /* Set the backlog */
    406413                rc = listen(listening_id, backlog);
    … …  
    409416                        return rc;
    410417                }
    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

    r71fe7e9d r5c1b3cd  
    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 
    127126/** @}
    128127 */

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

    r71fe7e9d r5c1b3cd  
    3636
    3737#include <libarch/inttypes.h>
     38#include <libarch/config.h>
    3839#include <ddf/driver.h>
    3940#include <device/hw_res_parsed.h>
    … …  
    4243#include <ddf/log.h>
    4344#include <stdio.h>
     45#include <async.h>
    4446#include "i8042.h"
    4547
    … …  
    152154        printf("%s: HelenOS PS/2 driver.\n", NAME);
    153155        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
    154163        return ddf_driver_main(&i8042_driver);
    155164}

  • uspace/lib/c/Makefile

    r71fe7e9d r5c1b3cd  
    3131ROOT_PATH = $(USPACE_PREFIX)/..
    3232
    33 INCLUDE_ABI = include/abi
    34 INCLUDE_LIBARCH = include/libarch
    35 
    3633COMMON_MAKEFILE = $(ROOT_PATH)/Makefile.common
    3734COMMON_HEADER = $(ROOT_PATH)/common.h
    38 COMMON_HEADER_ARCH = arch/$(UARCH)/include/common.h
     35COMMON_HEADER_ARCH = arch/$(UARCH)/include/libarch/common.h
    3936
    4037CONFIG_MAKEFILE = $(ROOT_PATH)/Makefile.config
    … …  
    4643        $(LIBC_PREFIX)/arch/$(UARCH)/_link-dlexe.ld
    4744
    48 PRE_DEPEND = $(INCLUDE_ABI) $(INCLUDE_LIBARCH) $(COMMON_HEADER_ARCH)
     45PRE_DEPEND = $(COMMON_HEADER_ARCH)
    4946EXTRA_OUTPUT = $(LINKER_SCRIPTS)
    50 EXTRA_CLEAN = $(INCLUDE_ABI) $(INCLUDE_LIBARCH) $(COMMON_HEADER_ARCH) $(LINKER_SCRIPTS)
     47EXTRA_CLEAN = $(COMMON_HEADER_ARCH) $(LINKER_SCRIPTS)
    5148LIBRARY = libc
    5249SLIBRARY = libc.so.0.0
    … …  
    162159include $(USPACE_PREFIX)/Makefile.common
    163160
    164 $(INCLUDE_LIBARCH): arch/$(UARCH)/include
    165         ln -sfn ../$< $@
    166 
    167 $(INCLUDE_ABI): ../../../abi/include/
    168         ln -sfn ../$< $@
    169161
    170162$(LIBC_PREFIX)/arch/$(UARCH)/_link.ld: $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld.in
    … …  
    181173
    182174$(COMMON_HEADER_ARCH): $(COMMON_HEADER)
    183         ln -sfn ../../../$< $@
     175        ln -sfn ../../../../$< $@

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    r71fe7e9d r5c1b3cd  
    350350static async_client_conn_t client_connection = default_client_connection;
    351351static async_interrupt_handler_t interrupt_received = default_interrupt_received;
     352static size_t interrupt_handler_stksz = FIBRIL_DFLT_STK_SIZE;
    352353
    353354/** Setter for client_connection function pointer.
    … …  
    370371{
    371372        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 */
     379void async_set_interrupt_handler_stack_size(size_t size)
     380{
     381        interrupt_handler_stksz = size;
    372382}
    373383
    … …  
    587597        msg->call = *call;
    588598       
    589         fid_t fid = fibril_create(notification_fibril, msg);
     599        fid_t fid = fibril_create_generic(notification_fibril, msg,
     600            interrupt_handler_stksz);
    590601        if (fid == 0) {
    591602                free(msg);
    … …  
    20572068       
    20582069        async_sess_t *sess = exch->sess;
     2070        assert(sess != NULL);
    20592071       
    20602072        atomic_dec(&sess->refcnt);

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

    r71fe7e9d r5c1b3cd  
    9595fibril_t *fibril_setup(void)
    9696{
    97         tcb_t *tcb = __make_tls();
     97        tcb_t *tcb = tls_make();
    9898        if (!tcb)
    9999                return NULL;
    … …  
    101101        fibril_t *fibril = malloc(sizeof(fibril_t));
    102102        if (!fibril) {
    103                 __free_tls(tcb);
     103                tls_free(tcb);
    104104                return NULL;
    105105        }
    … …  
    122122void fibril_teardown(fibril_t *fibril)
    123123{
    124         __free_tls(fibril->tcb);
     124        tls_free(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.
    258259 *
    259260 * @return 0 on failure or TLS of the new fibril.
    260261 *
    261262 */
    262 fid_t fibril_create(int (*func)(void *), void *arg)
     263fid_t fibril_create_generic(int (*func)(void *), void *arg, size_t stksz)
    263264{
    264265        fibril_t *fibril;
    … …  
    268269                return 0;
    269270       
    270         size_t stack_size = stack_size_get();
     271        size_t stack_size = (stksz == FIBRIL_DFLT_STK_SIZE) ?
     272            stack_size_get() : stksz;
    271273        fibril->stack = as_area_create((void *) -1, stack_size,
    272274            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE | AS_AREA_GUARD |

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

    r71fe7e9d r5c1b3cd  
    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.
     194 * @param[in] iid   The initial message identifier.
     195 * @param[in] icall The initial message call structure.
     196 * @param[in] arg   Local argument.
     197 *
    197198 */
    198199static void socket_connection(ipc_callid_t iid, ipc_call_t * icall, void *arg)
    199200{
    200         ipc_callid_t callid;
    201         ipc_call_t call;
    202         socket_t *socket;
    203         int rc;
    204 
    205 loop:
    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;
     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;
    221208                }
     209               
     210                int rc;
    222211               
    223212                switch (IPC_GET_IMETHOD(call)) {
    224213                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);
     214                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;
    233225                        }
    234                         fibril_mutex_unlock(&socket->receive_lock);
     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);
    235270                        break;
    236 
    237                 case NET_SOCKET_ACCEPTED:
    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);
    245                         }
    246                         fibril_mutex_unlock(&socket->accept_lock);
    247                         break;
    248 
     271                       
    249272                default:
    250273                        rc = ENOTSUP;
    251274                }
    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;
     275               
     276                async_answer_0(callid, (sysarg_t) rc);
     277        }
    274278}
    275279

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

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

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

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

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

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

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

    r71fe7e9d r5c1b3cd  
    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

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

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

    r71fe7e9d r5c1b3cd  
    354354{
    355355        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_find_ref(%p)", sp);
    356 
     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       
    357361        fibril_mutex_lock(&conn_list_lock);
    358 
     362       
    359363        list_foreach(conn_list, link) {
    360364                tcp_conn_t *conn = list_get_instance(link, tcp_conn_t, link);
    361365                tcp_sockpair_t *csp = &conn->ident;
    362                 log_msg(LOG_DEFAULT, LVL_DEBUG2, "compare with conn (f:(%x,%u), l:(%x,%u))",
     366               
     367                log_msg(LOG_DEFAULT, LVL_DEBUG2, " - with (f:(%x,%u), l:(%x,%u))",
    363368                    csp->foreign.addr.ipv4, csp->foreign.port,
    364369                    csp->local.addr.ipv4, csp->local.port);
     370               
    365371                if (tcp_sockpair_match(sp, csp)) {
    366372                        tcp_conn_addref(conn);
    … …  
    369375                }
    370376        }
    371 
     377       
    372378        fibril_mutex_unlock(&conn_list_lock);
    373379        return NULL;

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

    r71fe7e9d r5c1b3cd  
    203203{
    204204        int rc;
    205         struct sockaddr *addr;
    206         size_t addr_len;
     205        struct sockaddr_in *addr;
     206        size_t addr_size;
    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         rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_len);
     212       
     213        addr = NULL;
     214       
     215        rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_size);
    213216        if (rc != EOK) {
    214217                async_answer_0(callid, rc);
    215                 return;
    216         }
    217 
     218                goto out;
     219        }
     220       
     221        if (addr_size != sizeof(struct sockaddr_in)) {
     222                async_answer_0(callid, EINVAL);
     223                goto out;
     224        }
     225       
    218226        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_bind");
    219227        rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
    220             addr, addr_len, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
     228            addr, addr_size, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
    221229            last_used_port);
    222230        if (rc != EOK) {
    223231                async_answer_0(callid, rc);
    224                 return;
    225         }
    226 
     232                goto out;
     233        }
     234       
    227235        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_cores_find");
    228236        sock_core = socket_cores_find(&client->sockets, SOCKET_GET_SOCKET_ID(call));
    229         if (sock_core != NULL) {
    230                 socket = (tcp_sockdata_t *)sock_core->specific_data;
    231                 /* XXX Anything to do? */
    232                 (void) socket;
    233         }
    234 
     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       
    235246        log_msg(LOG_DEFAULT, LVL_DEBUG, " - success");
    236247        async_answer_0(callid, EOK);
     248       
     249out:
     250        if (addr != NULL)
     251                free(addr);
    237252}
    238253
    … …  
    249264        tcp_sock_lconn_t *lconn;
    250265        int i;
     266        int rc;
    251267
    252268        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_listen()");
    … …  
    268284                return;
    269285        }
    270 
    271         socket = (tcp_sockdata_t *)sock_core->specific_data;
    272 
     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       
    273301        /*
    274302         * Prepare @c backlog listening connections.
    275303         */
    276304        fibril_mutex_lock(&socket->lock);
    277 
     305       
    278306        socket->backlog = backlog;
    279307        socket->lconn = calloc(backlog, sizeof(tcp_conn_t *));
    … …  
    283311                return;
    284312        }
    285 
     313       
    286314        log_msg(LOG_DEFAULT, LVL_DEBUG, " - open connections");
    287 
     315       
    288316        lsocket.addr.ipv4 = TCP_IPV4_ANY;
    289317        lsocket.port = sock_core->port;
    290318        fsocket.addr.ipv4 = TCP_IPV4_ANY;
    291319        fsocket.port = TCP_PORT_ANY;
    292 
     320       
    293321        for (i = 0; i < backlog; i++) {
    294322
    … …  
    362390                        return;
    363391                }
    364 
     392               
    365393                last_used_port = sock_core->port;
    366394        }
    … …  
    441469                return;
    442470        }
     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        }
    443483
    444484        socket = (tcp_sockdata_t *)sock_core->specific_data;

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

    r71fe7e9d r5c1b3cd  
    200200/** Set local socket in association.
    201201 *
    202  * @param assoc         Association
    203  * @param fsock         Foreign socket (deeply copied)
     202 * @param assoc Association
     203 * @param lsock Local socket (deeply copied)
     204 *
    204205 */
    205206void udp_assoc_set_local(udp_assoc_t *assoc, udp_sock_t *lsock)
    … …  
    208209        fibril_mutex_lock(&assoc->lock);
    209210        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 */
     220void 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;
    210225        fibril_mutex_unlock(&assoc->lock);
    211226}
    … …  
    406421}
    407422
    408 
    409423/**
    410424 * @}

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

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

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

    r71fe7e9d r5c1b3cd  
    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 
     179       
     180        if (addr_size != sizeof(struct sockaddr_in)) {
     181                async_answer_0(callid, EINVAL);
     182                goto out;
     183        }
     184       
    180185        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_bind");
    181186        rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
    … …  
    186191                goto out;
    187192        }
    188 
    189         if (addr_size != sizeof(struct sockaddr_in)) {
    190                 async_answer_0(callid, EINVAL);
    191                 goto out;
    192         }
    193 
     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 
    266251        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_send()");
    267 
    268         addr = NULL;
    269 
     252       
     253        struct sockaddr_in *addr = NULL;
     254        udp_sock_t fsock;
     255        udp_sock_t *fsock_ptr;
     256       
    270257        if (IPC_GET_IMETHOD(call) == NET_SOCKET_SENDTO) {
    271                 rc = async_data_write_accept((void **) &addr, false,
     258                size_t addr_size;
     259                int rc = async_data_write_accept((void **) &addr, false,
    272260                    0, 0, 0, &addr_size);
    273261                if (rc != EOK) {
    … …  
    275263                        goto out;
    276264                }
    277 
     265               
    278266                if (addr_size != sizeof(struct sockaddr_in)) {
    279267                        async_answer_0(callid, EINVAL);
    280268                        goto out;
    281269                }
    282 
     270               
    283271                fsock.addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
    284272                fsock.port = uint16_t_be2host(addr->sin_port);
    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);
     273                fsock_ptr = &fsock;
     274        } else
     275                fsock_ptr = NULL;
     276       
     277        int socket_id = SOCKET_GET_SOCKET_ID(call);
     278       
    292279        SOCKET_GET_FLAGS(call);
    293 
    294         sock_core = socket_cores_find(&client->sockets, socket_id);
     280       
     281        socket_core_t *sock_core =
     282            socket_cores_find(&client->sockets, socket_id);
    295283        if (sock_core == NULL) {
    296284                async_answer_0(callid, ENOTSOCK);
    297285                goto out;
    298286        }
    299 
    300         if (sock_core->port == 0) {
     287       
     288        udp_sockdata_t *socket =
     289            (udp_sockdata_t *) sock_core->specific_data;
     290       
     291        if (sock_core->port <= 0) {
    301292                /* Implicitly bind socket to 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);
     293                int rc = socket_bind_free_port(&gsock, sock_core,
     294                    UDP_FREE_PORTS_START, UDP_FREE_PORTS_END, last_used_port);
    305295                if (rc != EOK) {
    306296                        async_answer_0(callid, rc);
    307297                        goto out;
    308298                }
    309         }
    310 
    311         socket = (udp_sockdata_t *)sock_core->specific_data;
     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       
    312314        fibril_mutex_lock(&socket->lock);
    313 
     315       
    314316        if (socket->assoc->ident.local.addr.ipv4 == UDP_IPV4_ANY) {
    315317                /* Determine local IP address */
    316318                inet_addr_t loc_addr, rem_addr;
    317 
    318                 rem_addr.ipv4 = fsockp ? fsock.addr.ipv4 :
     319               
     320                rem_addr.ipv4 = fsock_ptr ? fsock.addr.ipv4 :
    319321                    socket->assoc->ident.foreign.addr.ipv4;
    320 
    321                 rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
     322               
     323                int rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
    322324                if (rc != EOK) {
    323325                        fibril_mutex_unlock(&socket->lock);
    … …  
    327329                        return;
    328330                }
    329 
     331               
    330332                socket->assoc->ident.local.addr.ipv4 = loc_addr.ipv4;
    331333                log_msg(LOG_DEFAULT, LVL_DEBUG, "Local IP address is %x",
    332334                    socket->assoc->ident.local.addr.ipv4);
    333335        }
    334 
    335 
     336       
    336337        assert(socket->assoc != NULL);
    337 
    338         for (index = 0; index < fragments; index++) {
     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               
    339344                if (!async_data_write_receive(&wcallid, &length)) {
    340345                        fibril_mutex_unlock(&socket->lock);
    … …  
    342347                        goto out;
    343348                }
    344 
     349               
    345350                if (length > UDP_FRAGMENT_SIZE)
    346351                        length = UDP_FRAGMENT_SIZE;
    347 
    348                 rc = async_data_write_finalize(wcallid, buffer, length);
     352               
     353                uint8_t buffer[UDP_FRAGMENT_SIZE];
     354                int rc = async_data_write_finalize(wcallid, buffer, length);
    349355                if (rc != EOK) {
    350356                        fibril_mutex_unlock(&socket->lock);
    … …  
    352358                        goto out;
    353359                }
    354 
    355                 urc = udp_uc_send(socket->assoc, fsockp, buffer, length, 0);
    356 
     360               
     361                udp_error_t urc =
     362                    udp_uc_send(socket->assoc, fsock_ptr, buffer, length, 0);
     363               
    357364                switch (urc) {
    358365                case UDP_EOK:
    359366                        rc = EOK;
    360367                        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;*/
     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;
    370377                default:
    371378                        assert(false);
    372379                }
    373 
     380               
    374381                if (rc != EOK) {
    375382                        fibril_mutex_unlock(&socket->lock);
    … …  
    378385                }
    379386        }
     387       
     388        ipc_call_t answer;
    380389       
    381390        IPC_SET_ARG1(answer, 0);
    … …  
    526535static void udp_sock_close(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    527536{
    528         int socket_id;
    529         socket_core_t *sock_core;
    530         udp_sockdata_t *socket;
    531         int rc;
    532 
    533537        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close()");
    534         socket_id = SOCKET_GET_SOCKET_ID(call);
    535 
    536         sock_core = socket_cores_find(&client->sockets, socket_id);
     538        int socket_id = SOCKET_GET_SOCKET_ID(call);
     539       
     540        socket_core_t *sock_core =
     541            socket_cores_find(&client->sockets, socket_id);
    537542        if (sock_core == NULL) {
    538543                async_answer_0(callid, ENOTSOCK);
    539544                return;
    540545        }
    541 
    542         socket = (udp_sockdata_t *)sock_core->specific_data;
     546       
     547        udp_sockdata_t *socket =
     548            (udp_sockdata_t *) sock_core->specific_data;
    543549        fibril_mutex_lock(&socket->lock);
    544 
    545         rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
     550       
     551        int rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
    546552            udp_free_sock_data);
    547553        if (rc != EOK) {
    … …  
    550556                return;
    551557        }
    552 
     558       
    553559        fibril_mutex_unlock(&socket->lock);
    554560        async_answer_0(callid, EOK);
    … …  
    583589                            &sock->recv_buffer_lock);
    584590                }
    585 
     591               
    586592                log_msg(LOG_DEFAULT, LVL_DEBUG, "[] call udp_uc_receive()");
    587593                urc = udp_uc_receive(sock->assoc, sock->recv_buffer,
    588594                    UDP_FRAGMENT_SIZE, &rcvd, &xflags, &sock->recv_fsock);
    589595                sock->recv_error = urc;
    590 
     596               
    591597                udp_sock_notify_data(sock->sock_core);
    592 
     598               
    593599                if (urc != UDP_EOK) {
    594600                        fibril_condvar_broadcast(&sock->recv_buffer_cv);
    … …  
    596602                        break;
    597603                }
    598 
     604               
    599605                log_msg(LOG_DEFAULT, LVL_DEBUG, "[] got data - broadcast recv_buffer_cv");
    600 
     606               
    601607                sock->recv_buffer_used = rcvd;
    602608                fibril_mutex_unlock(&sock->recv_buffer_lock);

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

    r71fe7e9d r5c1b3cd  
    6868{
    6969        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_uc_set_local(%p, %p)", assoc, lsock);
     70       
     71        udp_assoc_set_local(assoc, lsock);
     72        return UDP_EOK;
     73}
    7074
    71         udp_assoc_set_local(assoc, lsock);
     75udp_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);
    7280        return UDP_EOK;
    7381}

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

    r71fe7e9d r5c1b3cd  
    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 *);
     44extern udp_error_t udp_uc_set_local_port(udp_assoc_t *, uint16_t);
    4445extern udp_error_t udp_uc_send(udp_assoc_t *, udp_sock_t *, void *, size_t,
    4546    xflags_t);

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

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

  • version

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