Index: HelenOS.config =================================================================== --- HelenOS.config (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ HelenOS.config (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -462,4 +462,7 @@ ! [(CONFIG_HID_IN=generic|CONFIG_HID_IN=serial)&PLATFORM=ia64&MACHINE=i460GX] CONFIG_NS16550 (y/n) +% Support for ARM926 on-chip UART +! [(CONFIG_HID_OUT=generic|CONFIG_HID_OUT=serial)&PLATFORM=arm32&MACHINE=integratorcp] CONFIG_ARM926_UART (y/n) + % Support for Samsung S3C24XX on-chip UART ! [(CONFIG_HID_OUT=generic|CONFIG_HID_OUT=serial)&PLATFORM=arm32&MACHINE=gta02] CONFIG_S3C24XX_UART (y/n) @@ -487,5 +490,5 @@ % Serial line input module -! [CONFIG_DSRLNIN=y|(PLATFORM=arm32&MACHINE=gta02)|(PLATFORM=ia64&MACHINE=i460GX&CONFIG_NS16550=y)|(PLATFORM=ia64&MACHINE=ski)|(PLATFORM=sparc64&PROCESSOR=sun4v)] CONFIG_SRLN (y) +! [CONFIG_DSRLNIN=y|(PLATFORM=arm32&MACHINE=gta02)|(PLATFORM=arm32&MACHINE=integratorcp&CONFIG_ARM926_UART=y)|(PLATFORM=ia64&MACHINE=i460GX&CONFIG_NS16550=y)|(PLATFORM=ia64&MACHINE=ski)|(PLATFORM=sparc64&PROCESSOR=sun4v)] CONFIG_SRLN (y) % EGA support @@ -584,7 +587,4 @@ # USB settings -% USB verbose messages -! CONFIG_USB_VERBOSE (n/y) - % Start virtual USB host controller ! CONFIG_RUN_VIRTUAL_USB_HC (n/y) Index: Makefile =================================================================== --- Makefile (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ Makefile (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -45,5 +45,5 @@ CONFIG_HEADER = config.h -.PHONY: all precheck cscope autotool config_auto config_default config distclean clean check releasefile release +.PHONY: all precheck cscope cscope_parts autotool config_auto config_default config distclean clean check releasefile release all: $(COMMON_MAKEFILE) $(COMMON_HEADER) $(CONFIG_MAKEFILE) $(CONFIG_HEADER) @@ -58,4 +58,10 @@ cscope: find abi kernel boot uspace -regex '^.*\.[chsS]$$' | xargs $(CSCOPE) -b -k -u -f$(CSCOPE).out + +cscope_parts: + find abi -regex '^.*\.[chsS]$$' | xargs $(CSCOPE) -b -k -u -f$(CSCOPE)_abi.out + find kernel -regex '^.*\.[chsS]$$' | xargs $(CSCOPE) -b -k -u -f$(CSCOPE)_kernel.out + find boot -regex '^.*\.[chsS]$$' | xargs $(CSCOPE) -b -k -u -f$(CSCOPE)_boot.out + find uspace -regex '^.*\.[chsS]$$' | xargs $(CSCOPE) -b -k -u -f$(CSCOPE)_uspace.out # Pre-integration build check Index: abi/include/ipc/ipc.h =================================================================== --- abi/include/ipc/ipc.h (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ abi/include/ipc/ipc.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -57,9 +57,6 @@ #define IPC_CALL_FORWARDED (1 << 2) -/** Identify connect_me_to answer */ -#define IPC_CALL_CONN_ME_TO (1 << 3) - /** Interrupt notification */ -#define IPC_CALL_NOTIF (1 << 4) +#define IPC_CALL_NOTIF (1 << 3) Index: abi/include/mm/as.h =================================================================== --- abi/include/mm/as.h (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ abi/include/mm/as.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -37,8 +37,9 @@ /** Address space area flags. */ -#define AS_AREA_READ 1 -#define AS_AREA_WRITE 2 -#define AS_AREA_EXEC 4 -#define AS_AREA_CACHEABLE 8 +#define AS_AREA_READ 0x01 +#define AS_AREA_WRITE 0x02 +#define AS_AREA_EXEC 0x04 +#define AS_AREA_CACHEABLE 0x08 +#define AS_AREA_GUARD 0x10 /** Address space area info exported to uspace. */ Index: boot/Makefile.common =================================================================== --- boot/Makefile.common (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ boot/Makefile.common (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -74,5 +74,6 @@ $(USPACE_PATH)/srv/locsrv/locsrv \ $(USPACE_PATH)/srv/bd/rd/rd \ - $(USPACE_PATH)/srv/vfs/vfs + $(USPACE_PATH)/srv/vfs/vfs \ + $(USPACE_PATH)/srv/logger/logger ifeq ($(RDFMT),tmpfs) @@ -107,4 +108,5 @@ $(USPACE_PATH)/srv/fs/cdfs/cdfs \ $(USPACE_PATH)/srv/fs/exfat/exfat \ + $(USPACE_PATH)/srv/fs/udf/udf \ $(USPACE_PATH)/srv/fs/ext2fs/ext2fs \ $(USPACE_PATH)/srv/fs/ext4fs/ext4fs \ @@ -157,4 +159,5 @@ RD_APPS_NON_ESSENTIAL = \ + $(USPACE_PATH)/app/bithenge/bithenge \ $(USPACE_PATH)/app/blkdump/blkdump \ $(USPACE_PATH)/app/bnchmark/bnchmark \ @@ -169,8 +172,8 @@ $(USPACE_PATH)/app/killall/killall \ $(USPACE_PATH)/app/loc/loc \ + $(USPACE_PATH)/app/logset/logset \ $(USPACE_PATH)/app/mkfat/mkfat \ $(USPACE_PATH)/app/mkexfat/mkexfat \ $(USPACE_PATH)/app/mkmfs/mkmfs \ - $(USPACE_PATH)/app/lsusb/lsusb \ $(USPACE_PATH)/app/sbi/sbi \ $(USPACE_PATH)/app/sportdmp/sportdmp \ @@ -195,4 +198,5 @@ $(USPACE_PATH)/app/mkbd/mkbd \ $(USPACE_PATH)/app/websrv/websrv \ + $(USPACE_PATH)/app/date/date \ $(USPACE_PATH)/app/vdemo/vdemo Index: boot/arch/amd64/Makefile.inc =================================================================== --- boot/arch/amd64/Makefile.inc (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ boot/arch/amd64/Makefile.inc (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -42,4 +42,5 @@ char/ps2mouse \ char/xtkbd \ + time/cmos-rtc \ bus/usb/ehci\ bus/usb/ohci \ Index: boot/arch/arm32/include/main.h =================================================================== --- boot/arch/arm32/include/main.h (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ boot/arch/arm32/include/main.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -52,8 +52,8 @@ /** GXemul testarm serial console output register */ -#define TESTARM_SCONS_ADDR 0x10000000 +#define TESTARM_SCONS_ADDR 0x10000000 /** IntegratorCP serial console output register */ -#define ICP_SCONS_ADDR 0x16000000 +#define ICP_SCONS_ADDR 0x16000000 extern void bootstrap(void); Index: boot/arch/ppc32/_link.ld.in =================================================================== --- boot/arch/ppc32/_link.ld.in (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ boot/arch/ppc32/_link.ld.in (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -2,5 +2,5 @@ SECTIONS { - . = 0x01000000; + . = 0x02000000; .text : { *(BOOTSTRAP); Index: boot/arch/ppc32/include/arch.h =================================================================== --- boot/arch/ppc32/include/arch.h (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ boot/arch/ppc32/include/arch.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -35,5 +35,5 @@ #define BOOT_OFFSET 0x8000 -#define LOADER_ADDRESS 0x01000000 +#define LOADER_ADDRESS 0x02000000 #ifndef __ASM__ Index: boot/arch/ppc32/src/main.c =================================================================== --- boot/arch/ppc32/src/main.c (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ boot/arch/ppc32/src/main.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -103,4 +103,10 @@ } + if (top >= (size_t) loader_address_pa) { + printf("Inflated components overlap loader area.\n"); + printf("The boot image is too large. Halting.\n"); + halt(); + } + void *balloc_base; void *balloc_base_pa; Index: boot/generic/include/printf.h =================================================================== --- boot/generic/include/printf.h (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ boot/generic/include/printf.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -35,15 +35,5 @@ #include #include - -#ifndef NVERIFY_PRINTF - -#define PRINTF_ATTRIBUTE(start, end) \ - __attribute__((format(gnu_printf, start, end))) - -#else /* NVERIFY_PRINTF */ - -#define PRINTF_ATTRIBUTE(start, end) - -#endif /* NVERIFY_PRINTF */ +#include #define EOF (-1) Index: boot/generic/include/printf_verify.h =================================================================== --- boot/generic/include/printf_verify.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ boot/generic/include/printf_verify.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2012 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @file + */ + +#ifndef BOOT_PRINTF_VERIFY_H_ +#define BOOT_PRINTF_VERIFY_H_ + +#ifndef NVERIFY_PRINTF + +#define PRINTF_ATTRIBUTE(start, end) \ + __attribute__((format(gnu_printf, start, end))) + +#else /* NVERIFY_PRINTF */ + +#define PRINTF_ATTRIBUTE(start, end) + +#endif /* NVERIFY_PRINTF */ + +#endif + +/** @} + */ Index: contrib/bazaar/bzreml/__init__.py =================================================================== --- contrib/bazaar/bzreml/__init__.py (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ contrib/bazaar/bzreml/__init__.py (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -52,5 +52,5 @@ from bzrlib import errors -from bzrlib import revision +from bzrlib import revision as _mod_revision from bzrlib import __version__ as bzrlib_version Index: contrib/bazaar/mbprotect/__init__.py =================================================================== --- contrib/bazaar/mbprotect/__init__.py (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ contrib/bazaar/mbprotect/__init__.py (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -44,4 +44,5 @@ import bzrlib.branch from bzrlib.errors import TipChangeRejected +from bzrlib import revision as _mod_revision def iter_reverse_revision_history(repository, revision_id): Index: contrib/conf/sparc64-qe =================================================================== --- contrib/conf/sparc64-qe (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ contrib/conf/sparc64-qe (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,3 @@ +#!/bin/sh + +qemu-system-sparc64 $@ -M sun4u -boot d -cdrom image.iso Index: defaults/amd64/Makefile.config =================================================================== --- defaults/amd64/Makefile.config (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ defaults/amd64/Makefile.config (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -57,5 +57,5 @@ # Default framebuffer mode -CONFIG_BFB_MODE = 800x600 +CONFIG_BFB_MODE = 1024x768 # Default framebuffer depth Index: defaults/ia32/Makefile.config =================================================================== --- defaults/ia32/Makefile.config (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ defaults/ia32/Makefile.config (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -63,5 +63,5 @@ # Default framebuffer mode -CONFIG_BFB_MODE = 800x600 +CONFIG_BFB_MODE = 1024x768 # Default framebuffer depth Index: kernel/Makefile =================================================================== --- kernel/Makefile (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/Makefile (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -262,4 +262,15 @@ generic/src/ipc/ipc.c \ generic/src/ipc/sysipc.c \ + generic/src/ipc/sysipc_ops.c \ + generic/src/ipc/ops/clnestab.c \ + generic/src/ipc/ops/conctmeto.c \ + generic/src/ipc/ops/concttome.c \ + generic/src/ipc/ops/connclone.c \ + generic/src/ipc/ops/dataread.c \ + generic/src/ipc/ops/datawrite.c \ + generic/src/ipc/ops/debug.c \ + generic/src/ipc/ops/sharein.c \ + generic/src/ipc/ops/shareout.c \ + generic/src/ipc/ops/stchngath.c \ generic/src/ipc/ipcrsc.c \ generic/src/ipc/irq.c \ Index: kernel/arch/arm32/Makefile.inc =================================================================== --- kernel/arch/arm32/Makefile.inc (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/arch/arm32/Makefile.inc (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -33,5 +33,5 @@ ATSIGN = % -GCC_CFLAGS += -march=armv4 +GCC_CFLAGS += -march=armv4 -fno-omit-frame-pointer -mapcs-frame BITS = 32 Index: kernel/arch/arm32/include/istate.h =================================================================== --- kernel/arch/arm32/include/istate.h (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/arch/arm32/include/istate.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -49,4 +49,5 @@ /** Struct representing CPU state saved when an exception occurs. */ typedef struct istate { + uint32_t dummy; uint32_t spsr; uint32_t sp; Index: kernel/arch/arm32/src/exc_handler.S =================================================================== --- kernel/arch/arm32/src/exc_handler.S (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/arch/arm32/src/exc_handler.S (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -130,7 +130,9 @@ stmfd r13!, {r2} 2: + sub sp, sp, #4 .endm .macro LOAD_REGS_FROM_STACK + add sp, sp, #4 ldmfd r13!, {r0} msr spsr, r0 Index: kernel/arch/arm32/src/exception.c =================================================================== --- kernel/arch/arm32/src/exception.c (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/arch/arm32/src/exception.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -123,5 +123,5 @@ asm volatile ( - "mrc p15, 0, %[control_reg], c1, c1" + "mrc p15, 0, %[control_reg], c1, c0" : [control_reg] "=r" (control_reg) ); @@ -131,5 +131,5 @@ asm volatile ( - "mcr p15, 0, %[control_reg], c1, c1" + "mcr p15, 0, %[control_reg], c1, c0" :: [control_reg] "r" (control_reg) ); Index: kernel/arch/arm32/src/mach/integratorcp/integratorcp.c =================================================================== --- kernel/arch/arm32/src/mach/integratorcp/integratorcp.c (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/arch/arm32/src/mach/integratorcp/integratorcp.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -38,5 +38,7 @@ #include #include +#include #include +#include #include #include @@ -53,7 +55,15 @@ #include + #define SDRAM_SIZE (sdram[((*(uint32_t *)(ICP_CMCR+ICP_SDRAMCR_OFFSET) & ICP_SDRAM_MASK) >> 2)]) -static icp_hw_map_t icp_hw_map; -static irq_t icp_timer_irq; + +static struct { + icp_hw_map_t hw_map; + irq_t timer_irq; + arm926_uart_t uart; +} icp; + + + struct arm_machine_ops icp_machine_ops = { icp_init, @@ -70,5 +80,4 @@ static bool hw_map_init_called = false; -static bool vga_init = false; uint32_t sdram[8] = { 16777216, /* 16mb */ @@ -89,12 +98,12 @@ void icp_vga_init(void) { - *(uint32_t*)((char *)(icp_hw_map.cmcr)+0x14) = 0xA05F0000; - *(uint32_t*)((char *)(icp_hw_map.cmcr)+0x1C) = 0x12C11000; - *(uint32_t*)icp_hw_map.vga = 0x3F1F3F9C; - *(uint32_t*)((char *)(icp_hw_map.vga) + 0x4) = 0x080B61DF; - *(uint32_t*)((char *)(icp_hw_map.vga) + 0x8) = 0x067F3800; - *(uint32_t*)((char *)(icp_hw_map.vga) + 0x10) = ICP_FB; - *(uint32_t *)((char *)(icp_hw_map.vga) + 0x1C) = 0x182B; - *(uint32_t*)((char *)(icp_hw_map.cmcr)+0xC) = 0x33805000; + *(uint32_t*)((char *)(icp.hw_map.cmcr)+0x14) = 0xA05F0000; + *(uint32_t*)((char *)(icp.hw_map.cmcr)+0x1C) = 0x12C11000; + *(uint32_t*)icp.hw_map.vga = 0x3F1F3F9C; + *(uint32_t*)((char *)(icp.hw_map.vga) + 0x4) = 0x080B61DF; + *(uint32_t*)((char *)(icp.hw_map.vga) + 0x8) = 0x067F3800; + *(uint32_t*)((char *)(icp.hw_map.vga) + 0x10) = ICP_FB; + *(uint32_t *)((char *)(icp.hw_map.vga) + 0x1C) = 0x182B; + *(uint32_t*)((char *)(icp.hw_map.cmcr)+0xC) = 0x33805000; } @@ -103,5 +112,5 @@ static inline uint32_t icp_irqc_get_sources(void) { - return *((uint32_t *) icp_hw_map.irqc); + return *((uint32_t *) icp.hw_map.irqc); } @@ -113,5 +122,5 @@ static inline void icp_irqc_mask(uint32_t irq) { - *((uint32_t *) icp_hw_map.irqc_mask) = (1 << irq); + *((uint32_t *) icp.hw_map.irqc_mask) = (1 << irq); } @@ -123,33 +132,33 @@ static inline void icp_irqc_unmask(uint32_t irq) { - *((uint32_t *) icp_hw_map.irqc_unmask) |= (1 << irq); -} - -/** Initializes icp_hw_map. */ + *((uint32_t *) icp.hw_map.irqc_unmask) |= (1 << irq); +} + +/** Initializes icp.hw_map. */ void icp_init(void) { - icp_hw_map.uart = km_map(ICP_UART, PAGE_SIZE, - PAGE_WRITE | PAGE_NOT_CACHEABLE); - icp_hw_map.kbd_ctrl = km_map(ICP_KBD, PAGE_SIZE, PAGE_NOT_CACHEABLE); - icp_hw_map.kbd_stat = icp_hw_map.kbd_ctrl + ICP_KBD_STAT; - icp_hw_map.kbd_data = icp_hw_map.kbd_ctrl + ICP_KBD_DATA; - icp_hw_map.kbd_intstat = icp_hw_map.kbd_ctrl + ICP_KBD_INTR_STAT; - icp_hw_map.rtc = km_map(ICP_RTC, PAGE_SIZE, - PAGE_WRITE | PAGE_NOT_CACHEABLE); - icp_hw_map.rtc1_load = icp_hw_map.rtc + ICP_RTC1_LOAD_OFFSET; - icp_hw_map.rtc1_read = icp_hw_map.rtc + ICP_RTC1_READ_OFFSET; - icp_hw_map.rtc1_ctl = icp_hw_map.rtc + ICP_RTC1_CTL_OFFSET; - icp_hw_map.rtc1_intrclr = icp_hw_map.rtc + ICP_RTC1_INTRCLR_OFFSET; - icp_hw_map.rtc1_bgload = icp_hw_map.rtc + ICP_RTC1_BGLOAD_OFFSET; - icp_hw_map.rtc1_intrstat = icp_hw_map.rtc + ICP_RTC1_INTRSTAT_OFFSET; - - icp_hw_map.irqc = km_map(ICP_IRQC, PAGE_SIZE, - PAGE_WRITE | PAGE_NOT_CACHEABLE); - icp_hw_map.irqc_mask = icp_hw_map.irqc + ICP_IRQC_MASK_OFFSET; - icp_hw_map.irqc_unmask = icp_hw_map.irqc + ICP_IRQC_UNMASK_OFFSET; - icp_hw_map.cmcr = km_map(ICP_CMCR, PAGE_SIZE, - PAGE_WRITE | PAGE_NOT_CACHEABLE); - icp_hw_map.sdramcr = icp_hw_map.cmcr + ICP_SDRAMCR_OFFSET; - icp_hw_map.vga = km_map(ICP_VGA, PAGE_SIZE, + icp.hw_map.uart = km_map(ICP_UART, PAGE_SIZE, + PAGE_WRITE | PAGE_NOT_CACHEABLE); + icp.hw_map.kbd_ctrl = km_map(ICP_KBD, PAGE_SIZE, PAGE_NOT_CACHEABLE); + icp.hw_map.kbd_stat = icp.hw_map.kbd_ctrl + ICP_KBD_STAT; + icp.hw_map.kbd_data = icp.hw_map.kbd_ctrl + ICP_KBD_DATA; + icp.hw_map.kbd_intstat = icp.hw_map.kbd_ctrl + ICP_KBD_INTR_STAT; + icp.hw_map.rtc = km_map(ICP_RTC, PAGE_SIZE, + PAGE_WRITE | PAGE_NOT_CACHEABLE); + icp.hw_map.rtc1_load = icp.hw_map.rtc + ICP_RTC1_LOAD_OFFSET; + icp.hw_map.rtc1_read = icp.hw_map.rtc + ICP_RTC1_READ_OFFSET; + icp.hw_map.rtc1_ctl = icp.hw_map.rtc + ICP_RTC1_CTL_OFFSET; + icp.hw_map.rtc1_intrclr = icp.hw_map.rtc + ICP_RTC1_INTRCLR_OFFSET; + icp.hw_map.rtc1_bgload = icp.hw_map.rtc + ICP_RTC1_BGLOAD_OFFSET; + icp.hw_map.rtc1_intrstat = icp.hw_map.rtc + ICP_RTC1_INTRSTAT_OFFSET; + + icp.hw_map.irqc = km_map(ICP_IRQC, PAGE_SIZE, + PAGE_WRITE | PAGE_NOT_CACHEABLE); + icp.hw_map.irqc_mask = icp.hw_map.irqc + ICP_IRQC_MASK_OFFSET; + icp.hw_map.irqc_unmask = icp.hw_map.irqc + ICP_IRQC_UNMASK_OFFSET; + icp.hw_map.cmcr = km_map(ICP_CMCR, PAGE_SIZE, + PAGE_WRITE | PAGE_NOT_CACHEABLE); + icp.hw_map.sdramcr = icp.hw_map.cmcr + ICP_SDRAMCR_OFFSET; + icp.hw_map.vga = km_map(ICP_VGA, PAGE_SIZE, PAGE_WRITE | PAGE_NOT_CACHEABLE); @@ -164,7 +173,7 @@ { icp_irqc_mask(ICP_TIMER_IRQ); - *((uint32_t*) icp_hw_map.rtc1_load) = frequency; - *((uint32_t*) icp_hw_map.rtc1_bgload) = frequency; - *((uint32_t*) icp_hw_map.rtc1_ctl) = ICP_RTC_CTL_VALUE; + *((uint32_t*) icp.hw_map.rtc1_load) = frequency; + *((uint32_t*) icp.hw_map.rtc1_bgload) = frequency; + *((uint32_t*) icp.hw_map.rtc1_ctl) = ICP_RTC_CTL_VALUE; icp_irqc_unmask(ICP_TIMER_IRQ); } @@ -172,6 +181,6 @@ static irq_ownership_t icp_timer_claim(irq_t *irq) { - if (icp_hw_map.rtc1_intrstat) { - *((uint32_t*) icp_hw_map.rtc1_intrclr) = 1; + if (icp.hw_map.rtc1_intrstat) { + *((uint32_t*) icp.hw_map.rtc1_intrclr) = 1; return IRQ_ACCEPT; } else @@ -200,11 +209,11 @@ static void icp_timer_irq_init(void) { - irq_initialize(&icp_timer_irq); - icp_timer_irq.devno = device_assign_devno(); - icp_timer_irq.inr = ICP_TIMER_IRQ; - icp_timer_irq.claim = icp_timer_claim; - icp_timer_irq.handler = icp_timer_irq_handler; - - irq_register(&icp_timer_irq); + irq_initialize(&icp.timer_irq); + icp.timer_irq.devno = device_assign_devno(); + icp.timer_irq.inr = ICP_TIMER_IRQ; + icp.timer_irq.claim = icp_timer_claim; + icp.timer_irq.handler = icp_timer_irq_handler; + + irq_register(&icp.timer_irq); } @@ -231,5 +240,5 @@ if (hw_map_init_called) { - *size = (sdram[((*(uint32_t *)icp_hw_map.sdramcr & + *size = (sdram[((*(uint32_t *)icp.hw_map.sdramcr & ICP_SDRAM_MASK) >> 2)]); } else { @@ -286,4 +295,5 @@ { #ifdef CONFIG_FB + static bool vga_init = false; if (!vga_init) { icp_vga_init(); @@ -304,4 +314,9 @@ stdout_wire(fbdev); #endif +#ifdef CONFIG_ARM926_UART + if (arm926_uart_init(&icp.uart, ARM926_UART0_IRQ, + ARM926_UART0_BASE_ADDRESS, sizeof(arm926_uart_regs_t))) + stdout_wire(&icp.uart.outdev); +#endif } @@ -310,7 +325,7 @@ pl050_t *pl050 = malloc(sizeof(pl050_t), FRAME_ATOMIC); - pl050->status = (ioport8_t *)icp_hw_map.kbd_stat; - pl050->data = (ioport8_t *)icp_hw_map.kbd_data; - pl050->ctrl = (ioport8_t *)icp_hw_map.kbd_ctrl; + pl050->status = (ioport8_t *)icp.hw_map.kbd_stat; + pl050->data = (ioport8_t *)icp.hw_map.kbd_data; + pl050->ctrl = (ioport8_t *)icp.hw_map.kbd_ctrl; pl050_instance_t *pl050_instance = pl050_init(pl050, ICP_KBD_IRQ); @@ -335,4 +350,13 @@ ICP_KBD); +#ifdef CONFIG_ARM926_UART + srln_instance_t *srln_instance = srln_init(); + if (srln_instance) { + indev_t *sink = stdin_wire(); + indev_t *srln = srln_wire(srln_instance, sink); + arm926_uart_input_wire(&icp.uart, srln); + icp_irqc_unmask(ARM926_UART0_IRQ); + } +#endif } Index: kernel/arch/arm32/src/mm/page_fault.c =================================================================== --- kernel/arch/arm32/src/mm/page_fault.c (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/arch/arm32/src/mm/page_fault.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -77,49 +77,4 @@ } -/** Decides whether the instruction is load/store or not. - * - * @param instr Instruction - * - * @return true when instruction is load/store, false otherwise - * - */ -static inline bool is_load_store_instruction(instruction_t instr) -{ - /* load store immediate offset */ - if (instr.type == 0x2) - return true; - - /* load store register offset */ - if ((instr.type == 0x3) && (instr.bit4 == 0)) - return true; - - /* load store multiple */ - if (instr.type == 0x4) - return true; - - /* oprocessor load/store */ - if (instr.type == 0x6) - return true; - - return false; -} - -/** Decides whether the instruction is swap or not. - * - * @param instr Instruction - * - * @return true when instruction is swap, false otherwise - */ -static inline bool is_swap_instruction(instruction_t instr) -{ - /* swap, swapb instruction */ - if ((instr.type == 0x0) && - ((instr.opcode == 0x8) || (instr.opcode == 0xa)) && - (instr.access == 0x0) && (instr.bits567 == 0x4) && (instr.bit4 == 1)) - return true; - - return false; -} - /** Decides whether read or write into memory is requested. * @@ -128,5 +83,5 @@ * * @return Type of access into memory, PF_ACCESS_EXEC if no memory access is - * requested. + * requested. */ static pf_access_t get_memory_access_type(uint32_t instr_addr, @@ -146,23 +101,38 @@ } - /* load store instructions */ - if (is_load_store_instruction(instr)) { - if (instr.access == 1) { - return PF_ACCESS_READ; - } else { - return PF_ACCESS_WRITE; + /* See ARM Architecture reference manual ARMv7-A and ARMV7-R edition + * A5.3 (PDF p. 206) */ + static const struct { + uint32_t mask; + uint32_t value; + pf_access_t access; + } ls_inst[] = { + /* Store word/byte */ + { 0x0e100000, 0x04000000, PF_ACCESS_WRITE }, /*STR(B) imm*/ + { 0x0e100010, 0x06000000, PF_ACCESS_WRITE }, /*STR(B) reg*/ + /* Load word/byte */ + { 0x0e100000, 0x04100000, PF_ACCESS_READ }, /*LDR(B) imm*/ + { 0x0e100010, 0x06100000, PF_ACCESS_READ }, /*LDR(B) reg*/ + /* Store half-word/dual A5.2.8 */ + { 0x0e1000b0, 0x000000b0, PF_ACCESS_WRITE }, /*STRH imm reg*/ + /* Load half-word/dual A5.2.8 */ + { 0x0e0000f0, 0x000000d0, PF_ACCESS_READ }, /*LDRH imm reg*/ + { 0x0e1000b0, 0x001000b0, PF_ACCESS_READ }, /*LDRH imm reg*/ + /* Block data transfer, Store */ + { 0x0e100000, 0x08000000, PF_ACCESS_WRITE }, /* STM variants */ + { 0x0e100000, 0x08100000, PF_ACCESS_READ }, /* LDM variants */ + /* Swap */ + { 0x0fb00000, 0x01000000, PF_ACCESS_WRITE }, + }; + const uint32_t inst = *(uint32_t*)instr_addr; + for (unsigned i = 0; i < sizeof(ls_inst) / sizeof(ls_inst[0]); ++i) { + if ((inst & ls_inst[i].mask) == ls_inst[i].value) { + return ls_inst[i].access; } - } - - /* swap, swpb instruction */ - if (is_swap_instruction(instr)) { - return PF_ACCESS_WRITE; } panic("page_fault - instruction doesn't access memory " "(instr_code: %#0" PRIx32 ", badvaddr:%p).", - instr_union.pc, (void *) badvaddr); - - return PF_ACCESS_EXEC; + inst, (void *) badvaddr); } Index: kernel/genarch/Makefile.inc =================================================================== --- kernel/genarch/Makefile.inc (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/genarch/Makefile.inc (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -91,4 +91,9 @@ endif +ifeq ($(CONFIG_ARM926_UART),y) + GENARCH_SOURCES += \ + genarch/src/drivers/arm926_uart/arm926_uart.c +endif + ifeq ($(CONFIG_S3C24XX_IRQC),y) GENARCH_SOURCES += \ Index: kernel/genarch/include/drivers/arm926_uart/arm926_uart.h =================================================================== --- kernel/genarch/include/drivers/arm926_uart/arm926_uart.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ kernel/genarch/include/drivers/arm926_uart/arm926_uart.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,169 @@ +/* + * Copyright (c) 2012 Jan Vesely + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup genarch + * @{ + */ +/** + * @file + * @brief ARM926 on-chip UART (PrimeCell UART, PL011) driver. + */ + +#ifndef KERN_ARM926_UART_H_ +#define KERN_ARM926_UART_H_ + +#include +#include +#include + + +/** ARM926 User Guide ch. 4.8.5 (p. 106 in the pdf) */ +#define ARM926_UART0_BASE_ADDRESS 0x16000000 +#define ARM926_UART1_BASE_ADDRESS 0x16000000 + +/** ARM926 User Guide ch. A.1 (p. 124 in the pdf) */ +#define ARM926_UART0_IRQ 1 +#define ARM926_UART1_IRQ 2 + +/** PrimeCell UART TRM ch. 3.3 (p. 49 in the pdf) */ +typedef struct { + /** UART data register */ + ioport32_t data; +#define ARM926_UART_DATA_DATA_MASK 0xff +#define ARM926_UART_DATA_FE_FLAG (1 << 7) +#define ARM926_UART_DATA_PE_FLAG (1 << 9) +#define ARM926_UART_DATA_BE_FLAG (1 << 10) +#define ARM926_UART_DATA_OE_FLAG (1 << 11) + + union { + /* Same values that are in upper bits of data register*/ + const ioport32_t status; +#define ARM926_UART_STATUS_FE_FLAG (1 << 0) +#define ARM926_UART_STATUS_PE_FLAG (1 << 1) +#define ARM926_UART_STATUS_BE_FLAG (1 << 2) +#define ARM926_UART_STATUS_OE_FLAG (1 << 3) + /* Writing anything clears all errors */ + ioport32_t error_clear; + }; + uint32_t padd0_[4]; + + const ioport32_t flag; +#define ARM926_UART_FLAG_CTS_FLAG (1 << 0) +#define ARM926_UART_FLAG_DSR_FLAG (1 << 1) +#define ARM926_UART_FLAG_DCD_FLAG (1 << 2) +#define ARM926_UART_FLAG_BUSY_FLAG (1 << 3) +#define ARM926_UART_FLAG_RXFE_FLAG (1 << 4) +#define ARM926_UART_FLAG_TXFF_FLAG (1 << 5) +#define ARM926_UART_FLAG_RXFF_FLAG (1 << 6) +#define ARM926_UART_FLAG_TXFE_FLAG (1 << 7) +#define ARM926_UART_FLAG_RI_FLAG (1 << 8) + uint32_t padd1_; + + ioport32_t irda_low_power; +#define ARM926_UART_IRDA_LOW_POWER_MASK 0xff + + ioport32_t int_baud_divisor; +#define ARM926_UART_INT_BAUD_DIVISOR_MASK 0xffff + + ioport32_t fract_baud_divisor; +#define ARM926_UART_FRACT_BAUD_DIVISOR_MASK 0x1f + + ioport32_t line_control_high; +#define ARM926_UART_CONTROLHI_BRK_FLAG (1 << 0) +#define ARM926_UART_CONTROLHI_PEN_FLAG (1 << 1) +#define ARM926_UART_CONTROLHI_EPS_FLAG (1 << 2) +#define ARM926_UART_CONTROLHI_STP2_FLAG (1 << 3) +#define ARM926_UART_CONTROLHI_FEN_FLAG (1 << 4) +#define ARM926_UART_CONTROLHI_WLEN_MASK 0x3 +#define ARM926_UART_CONTROLHI_WLEN_SHIFT 5 +#define ARM926_UART_CONTROLHI_SPS_FLAG (1 << 5) + + ioport32_t control; +#define ARM926_UART_CONTROL_UARTEN_FLAG (1 << 0) +#define ARM926_UART_CONTROL_SIREN_FLAG (1 << 1) +#define ARM926_UART_CONTROL_SIRLP_FLAG (1 << 2) +#define ARM926_UART_CONTROL_LBE_FLAG (1 << 7) +#define ARM926_UART_CONTROL_TXE_FLAG (1 << 8) +#define ARM926_UART_CONTROL_RXE_FLAG (1 << 9) +#define ARM926_UART_CONTROL_DTR_FLAG (1 << 10) +#define ARM926_UART_CONTROL_RTS_FLAG (1 << 11) +#define ARM926_UART_CONTROL_OUT1_FLAG (1 << 12) +#define ARM926_UART_CONTROL_OUT2_FLAG (1 << 13) +#define ARM926_UART_CONTROL_RTSE_FLAG (1 << 14) +#define ARM926_UART_CONTROL_CTSE_FLAG (1 << 15) + + ioport32_t interrupt_fifo; +#define ARM926_UART_INTERRUPTFIFO_TX_MASK 0x7 +#define ARM926_UART_INTERRUPTFIFO_TX_SHIFT 0 +#define ARM926_UART_INTERRUPTFIFO_RX_MASK 0x7 +#define ARM926_UART_INTERRUPTFIFO_RX_SHIFT 3 + + /** Interrupt mask register */ + ioport32_t interrupt_mask; + /** Pending interrupts before applying the mask */ + const ioport32_t raw_interrupt_status; + /** Pending interrupts after applying the mask */ + const ioport32_t masked_interrupt_status; + /** Write 1s to clear pending interrupts */ + ioport32_t interrupt_clear; +#define ARM926_UART_INTERRUPT_RIM_FLAG (1 << 0) +#define ARM926_UART_INTERRUPT_CTSM_FLAG (1 << 1) +#define ARM926_UART_INTERRUPT_DCDM_FLAG (1 << 2) +#define ARM926_UART_INTERRUPT_DSRM_FLAG (1 << 3) +#define ARM926_UART_INTERRUPT_RX_FLAG (1 << 4) +#define ARM926_UART_INTERRUPT_TX_FLAG (1 << 5) +#define ARM926_UART_INTERRUPT_RT_FLAG (1 << 6) +#define ARM926_UART_INTERRUPT_FE_FLAG (1 << 7) +#define ARM926_UART_INTERRUPT_PE_FLAG (1 << 8) +#define ARM926_UART_INTERRUPT_BE_FLAG (1 << 9) +#define ARM926_UART_INTERRUPT_OE_FLAG (1 << 10) +#define ARM926_UART_INTERRUPT_ALL 0x3ff + + ioport32_t dma_control; +#define ARM926_UART_DMACONTROL_RXDMAEN_FLAG (1 << 0) +#define ARM926_UART_DMACONTROL_TXDMAEN_FLAG (1 << 1) +#define ARM926_UART_DMACONTROL_DMAONERR_FLAG (1 << 2) + + // TODO There is some reserved space here followed by + // peripheral identification registers. +} arm926_uart_regs_t; + +typedef struct { + arm926_uart_regs_t *regs; + indev_t *indev; + outdev_t outdev; + irq_t irq; +} arm926_uart_t; + +bool arm926_uart_init(arm926_uart_t *, inr_t, uintptr_t, size_t); +void arm926_uart_input_wire(arm926_uart_t *, indev_t *); + +#endif +/** + * @} + */ Index: kernel/genarch/include/multiboot/multiboot.h =================================================================== --- kernel/genarch/include/multiboot/multiboot.h (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/genarch/include/multiboot/multiboot.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -99,4 +99,5 @@ extern void multiboot_extract_command(char *, size_t, const char *); +extern void multiboot_extract_argument(char *, size_t, const char *); extern void multiboot_info_parse(uint32_t, const multiboot_info_t *); Index: kernel/genarch/src/drivers/arm926_uart/arm926_uart.c =================================================================== --- kernel/genarch/src/drivers/arm926_uart/arm926_uart.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ kernel/genarch/src/drivers/arm926_uart/arm926_uart.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,140 @@ +/* + * Copyright (c) 2012 Jan Vesely + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup genarch + * @{ + */ +/** + * @file + * @brief ARM926 on-chip UART (PrimeCell UART, PL011) driver. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void arm926_uart_sendb(arm926_uart_t *uart, uint8_t byte) +{ + /* Wait for space becoming available in Tx FIFO. */ + // TODO make pio_read accept consts pointers and remove the cast + while ((pio_read_32((ioport32_t*)&uart->regs->flag) & ARM926_UART_FLAG_TXFF_FLAG) != 0) + ; + + pio_write_32(&uart->regs->data, byte); +} + +static void arm926_uart_putchar(outdev_t *dev, wchar_t ch) +{ + arm926_uart_t *uart = dev->data; + + if (!ascii_check(ch)) { + arm926_uart_sendb(uart, U_SPECIAL); + } else { + if (ch == '\n') + arm926_uart_sendb(uart, (uint8_t) '\r'); + arm926_uart_sendb(uart, (uint8_t) ch); + } +} + +static outdev_operations_t arm926_uart_ops = { + .write = arm926_uart_putchar, + .redraw = NULL, +}; + +static irq_ownership_t arm926_uart_claim(irq_t *irq) +{ + return IRQ_ACCEPT; +} + +static void arm926_uart_irq_handler(irq_t *irq) +{ + arm926_uart_t *uart = irq->instance; + + // TODO make pio_read accept const pointers and remove the cast + while ((pio_read_32((ioport32_t*)&uart->regs->flag) & ARM926_UART_FLAG_RXFE_FLAG) == 0) { + /* We ignore all error flags here */ + const uint8_t data = pio_read_32(&uart->regs->data); + if (uart->indev) + indev_push_character(uart->indev, data); + } + /* Ack interrupts */ + pio_write_32(&uart->regs->interrupt_clear, ARM926_UART_INTERRUPT_ALL); +} + +bool arm926_uart_init( + arm926_uart_t *uart, inr_t interrupt, uintptr_t addr, size_t size) +{ + ASSERT(uart); + uart->regs = (void*)km_map(addr, size, PAGE_NOT_CACHEABLE); + + ASSERT(uart->regs); + + /* Enable hw flow control */ + uart->regs->control = 0 | + ARM926_UART_CONTROL_UARTEN_FLAG | + ARM926_UART_CONTROL_RTSE_FLAG | + ARM926_UART_CONTROL_CTSE_FLAG; + + /* Mask all interrupts */ + uart->regs->interrupt_mask = 0; + + outdev_initialize("arm926_uart_dev", &uart->outdev, &arm926_uart_ops); + uart->outdev.data = uart; + + /* Initialize IRQ */ + irq_initialize(&uart->irq); + uart->irq.devno = device_assign_devno(); + uart->irq.inr = interrupt; + uart->irq.claim = arm926_uart_claim; + uart->irq.handler = arm926_uart_irq_handler; + uart->irq.instance = uart; + + return true; +} + +void arm926_uart_input_wire(arm926_uart_t *uart, indev_t *indev) +{ + ASSERT(uart); + ASSERT(indev); + + uart->indev = indev; + irq_register(&uart->irq); + /* Enable receive interrupt */ + uart->regs->interrupt_mask |= ARM926_UART_INTERRUPT_RX_FLAG; +} + +/** @} + */ + Index: kernel/genarch/src/multiboot/multiboot.c =================================================================== --- kernel/genarch/src/multiboot/multiboot.c (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/genarch/src/multiboot/multiboot.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -71,4 +71,33 @@ } +/** Extract arguments from the multiboot module command line. + * + * @param buf Destination buffer (will be always NULL-terminated). + * @param size Size of destination buffer (in bytes). + * @param cmd_line Input string (the command line). + * + */ +void multiboot_extract_argument(char *buf, size_t size, const char *cmd_line) +{ + /* Start after first space. */ + const char *start = str_chr(cmd_line, ' '); + if (start == NULL) { + str_cpy(buf, size, ""); + return; + } + + const char *end = cmd_line + str_size(cmd_line); + + /* Skip the space(s). */ + while (start != end) { + if (start[0] == ' ') + start++; + else + break; + } + + str_ncpy(buf, size, start, (size_t) (end - start)); +} + static void multiboot_modules(uint32_t count, multiboot_module_t *mods) { @@ -84,6 +113,10 @@ multiboot_extract_command(init.tasks[init.cnt].name, CONFIG_TASK_NAME_BUFLEN, MULTIBOOT_PTR(mods[i].string)); - } else + multiboot_extract_argument(init.tasks[init.cnt].arguments, + CONFIG_TASK_ARGUMENTS_BUFLEN, MULTIBOOT_PTR(mods[i].string)); + } else { init.tasks[init.cnt].name[0] = 0; + init.tasks[init.cnt].arguments[0] = 0; + } init.cnt++; Index: kernel/genarch/src/multiboot/multiboot2.c =================================================================== --- kernel/genarch/src/multiboot/multiboot2.c (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/genarch/src/multiboot/multiboot2.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -49,4 +49,6 @@ multiboot_extract_command(init.tasks[init.cnt].name, CONFIG_TASK_NAME_BUFLEN, module->string); + multiboot_extract_argument(init.tasks[init.cnt].arguments, + CONFIG_TASK_ARGUMENTS_BUFLEN, module->string); init.cnt++; Index: kernel/generic/include/config.h =================================================================== --- kernel/generic/include/config.h (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/generic/include/config.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -47,4 +47,11 @@ #define CONFIG_INIT_TASKS 32 #define CONFIG_TASK_NAME_BUFLEN 32 +#define CONFIG_TASK_ARGUMENTS_BUFLEN 64 + +/** + * Maximum buffer size allowed for IPC_M_DATA_WRITE and IPC_M_DATA_READ + * requests. + */ +#define DATA_XFER_LIMIT (64 * 1024) #ifndef __ASM__ @@ -56,4 +63,5 @@ size_t size; char name[CONFIG_TASK_NAME_BUFLEN]; + char arguments[CONFIG_TASK_ARGUMENTS_BUFLEN]; } init_task_t; Index: kernel/generic/include/interrupt.h =================================================================== --- kernel/generic/include/interrupt.h (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/generic/include/interrupt.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -59,5 +59,6 @@ extern exc_table_t exc_table[]; -extern void fault_from_uspace(istate_t *, const char *, ...); +extern void fault_from_uspace(istate_t *, const char *, ...) + PRINTF_ATTRIBUTE(2, 3); extern void fault_if_from_uspace(istate_t *, const char *, ...) PRINTF_ATTRIBUTE(2, 3); Index: kernel/generic/include/ipc/ipc.h =================================================================== --- kernel/generic/include/ipc/ipc.h (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/generic/include/ipc/ipc.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -65,4 +65,5 @@ mutex_t lock; link_t link; + struct task *caller; struct answerbox *callee; ipc_phone_state_t state; @@ -72,4 +73,7 @@ typedef struct answerbox { IRQ_SPINLOCK_DECLARE(lock); + + /** Answerbox is active until it enters cleanup. */ + bool active; struct task *task; @@ -106,10 +110,43 @@ typedef struct { - link_t link; + /** + * Task link. + * Valid only when the call is not forgotten. + * Protected by the task's active_calls_lock. + */ + link_t ta_link; + + atomic_t refcnt; + + /** Answerbox link. */ + link_t ab_link; unsigned int flags; + + /** Protects the forget member. */ + SPINLOCK_DECLARE(forget_lock); + + /** + * True if the caller 'forgot' this call and donated it to the callee. + * Forgotten calls are discarded upon answering (the answer is not + * delivered) and answered calls cannot be forgotten. Forgotten calls + * also do not figure on the task's active call list. + * + * We keep this separate from the flags so that it is not necessary + * to take a lock when accessing them. + */ + bool forget; + + /** True if the call is in the active list. */ + bool active; - /** Identification of the caller. */ + /** + * Identification of the caller. + * Valid only when the call is not forgotten. + */ struct task *sender; + + /** Phone which was used to send the call. */ + phone_t *caller_phone; /** Private data to internal IPC. */ @@ -118,14 +155,10 @@ /** Data passed from/to userspace. */ ipc_data_t data; - + + /** Method as it was sent in the request. */ + sysarg_t request_method; + /** Buffer for IPC_M_DATA_WRITE and IPC_M_DATA_READ. */ uint8_t *buffer; - - /* - * The forward operation can masquerade the caller phone. For those - * cases, we must keep it aside so that the answer is processed - * correctly. - */ - phone_t *caller_phone; } call_t; @@ -136,4 +169,6 @@ extern call_t *ipc_call_alloc(unsigned int); extern void ipc_call_free(call_t *); +extern void ipc_call_hold(call_t *); +extern void ipc_call_release(call_t *); extern int ipc_call(phone_t *, call_t *); @@ -141,7 +176,8 @@ extern int ipc_forward(call_t *, phone_t *, answerbox_t *, unsigned int); extern void ipc_answer(answerbox_t *, call_t *); +extern void _ipc_answer_free_call(call_t *, bool); -extern void ipc_phone_init(phone_t *); -extern void ipc_phone_connect(phone_t *, answerbox_t *); +extern void ipc_phone_init(phone_t *, struct task *); +extern bool ipc_phone_connect(phone_t *, answerbox_t *); extern int ipc_phone_hangup(phone_t *); @@ -151,5 +187,5 @@ extern void ipc_backsend_err(phone_t *, call_t *, sysarg_t); extern void ipc_answerbox_slam_phones(answerbox_t *, bool); -extern void ipc_cleanup_call_list(list_t *); +extern void ipc_cleanup_call_list(answerbox_t *, list_t *); extern void ipc_print_task(task_id_t); Index: kernel/generic/include/ipc/ipcrsc.h =================================================================== --- kernel/generic/include/ipc/ipcrsc.h (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/generic/include/ipc/ipcrsc.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -40,6 +40,7 @@ extern call_t *get_call(sysarg_t); +extern int phone_get(sysarg_t, phone_t **); extern int phone_alloc(task_t *); -extern void phone_connect(int, answerbox_t *); +extern bool phone_connect(int, answerbox_t *); extern void phone_dealloc(int); Index: kernel/generic/include/ipc/sysipc_ops.h =================================================================== --- kernel/generic/include/ipc/sysipc_ops.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ kernel/generic/include/ipc/sysipc_ops.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,165 @@ +/* + * Copyright (c) 2012 Jakub Jermar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup genericipc + * @{ + */ +/** @file + */ + +#ifndef KERN_SYSIPC_OPS_H_ +#define KERN_SYSIPC_OPS_H_ + +#include + +#define SYSIPC_OP(op, call, ...) \ + ({ \ + int rc = EOK; \ + \ + sysipc_ops_t *ops; \ + ops = sysipc_ops_get((call)->request_method); \ + if (ops->op) \ + rc = ops->op((call), ##__VA_ARGS__); \ + rc; \ + }) + +/** + * This header declares the per-method IPC callbacks. Using these callbacks, + * each IPC method (but system methods in particular), can define actions that + * will be called at specific moments in the call life-cycle. + * + * Normally, the kernel will attempt to invoke the following callbacks in the + * following order on each call: + * + * request_preprocess() + * request_process() + * answer_preprocess() + * answer_process() + * + * This callback invocation sequence is a natural order of processing. Note, + * however, that due to various special circumstances, callbacks may be called + * also in a different than natural order of processing. This means that some + * callbacks may be skipped and some others may be called instead. + * + * The additional callbacks that may be called are as follows: + * + * request_forget() + * answer_cleanup() + * + * There are several notable scenarios in which some callbacks of the natural + * order of processing will be skipped. + * + * The request_process(), answer_preprocess() and answer_process() callbacks + * will be skipped if the call cannot be delivered to the callee. This may + * happen when e.g. the request_preprocess() callback fails or the connection + * to the callee is not functional. The next callback that will be invoked on + * the call is request_forget(). + * + * The comments for each callback type describe the specifics of each callback + * such as the context in which it is invoked and various constraints. + */ + +typedef struct { + /** + * This callback is called from request_preprocess(). + * + * Context: caller + * Caller alive: guaranteed + * Races with: N/A + * Invoked on: all calls + */ + int (* request_preprocess)(call_t *, phone_t *); + + /** + * This callback is called when the IPC cleanup code wins the race to + * forget the call. + * + * Context: caller + * Caller alive: guaranteed + * Races with: request_process(), answer_cleanup(), + * _ipc_answer_free_call() + * Invoked on: all forgotten calls + */ + int (* request_forget)(call_t *); + + /** + * This callback is called from process_request(). + * + * Context: callee + * Caller alive: no guarantee + * Races with: request_forget() + * Invoked on: all calls delivered to the callee + */ + int (* request_process)(call_t *, answerbox_t *); + + /** + * This callback is called when answer_preprocess() loses the race to + * answer the call. + * + * Context: callee + * Caller alive: no guarantee + * Races with: request_forget() + * Invoked on: all forgotten calls + */ + int (* answer_cleanup)(call_t *, ipc_data_t *); + + /** + * This callback is called when answer_preprocess() wins the race to + * answer the call. + * + * Context: callee + * Caller alive: guaranteed + * Races with: N/A + * Invoked on: all answered calls + */ + int (* answer_preprocess)(call_t *, ipc_data_t *); + + /** + * This callback is called from process_answer(). + * + * Context: caller + * Caller alive: guaranteed + * Races with: N/A + * Invoked on: all answered calls + */ + int (* answer_process)(call_t *); +} sysipc_ops_t; + +extern sysipc_ops_t *sysipc_ops_get(sysarg_t); + +extern int null_request_preprocess(call_t *, phone_t *); +extern int null_request_forget(call_t *); +extern int null_request_process(call_t *, answerbox_t *); +extern int null_answer_cleanup(call_t *, ipc_data_t *); +extern int null_answer_preprocess(call_t *, ipc_data_t *); +extern int null_answer_process(call_t *); + +#endif + +/** @} + */ Index: kernel/generic/include/ipc/sysipc_priv.h =================================================================== --- kernel/generic/include/ipc/sysipc_priv.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ kernel/generic/include/ipc/sysipc_priv.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2012 Jakub Jermar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup genericipc + * @{ + */ +/** @file + */ + +#ifndef KERN_SYSIPC_PRIV_H_ +#define KERN_SYSIPC_PRIV_H_ + +#include + +extern int answer_preprocess(call_t *, ipc_data_t *); + +#endif + +/** @} + */ Index: kernel/generic/include/lib/elf_load.h =================================================================== --- kernel/generic/include/lib/elf_load.h (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/generic/include/lib/elf_load.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -42,16 +42,15 @@ * ELF error return codes */ -#define EE_OK 0 /* No error */ -#define EE_INVALID 1 /* Invalid ELF image */ -#define EE_MEMORY 2 /* Cannot allocate address space */ -#define EE_INCOMPATIBLE 3 /* ELF image is not compatible with current architecture */ -#define EE_UNSUPPORTED 4 /* Non-supported ELF (e.g. dynamic ELFs) */ -#define EE_LOADER 5 /* The image is actually a program loader. */ -#define EE_IRRECOVERABLE 6 +#define EE_OK 0 /* No error */ +#define EE_INVALID 1 /* Invalid ELF image */ +#define EE_MEMORY 2 /* Cannot allocate address space */ +#define EE_INCOMPATIBLE 3 /* ELF image is not compatible with current architecture */ +#define EE_UNSUPPORTED 4 /* Non-supported ELF (e.g. dynamic ELFs) */ +#define EE_LOADER 5 /* The image is actually a program loader. */ +#define EE_IRRECOVERABLE 6 /* Irrecoverable error. */ /** * This flags is passed when running the loader, otherwise elf_load() * would return with a EE_LOADER error code. - * */ #define ELD_F_NONE 0 Index: kernel/generic/include/macros.h =================================================================== --- kernel/generic/include/macros.h (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/generic/include/macros.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -52,8 +52,19 @@ uint64_t sz2) { - uint64_t e1 = s1 + sz1; - uint64_t e2 = s2 + sz2; - - return ((s1 < e2) && (s2 < e1)); + uint64_t e1 = s1 + sz1 - 1; + uint64_t e2 = s2 + sz2 - 1; + + /* both sizes are non-zero */ + if (sz1 && sz2) + return ((s1 <= e2) && (s2 <= e1)); + + /* one size is non-zero */ + if (sz2) + return ((s1 >= s2) && (s1 <= e2)); + if (sz1) + return ((s2 >= s1) && (s2 <= e1)); + + /* both are zero */ + return (s1 == s2); } @@ -119,4 +130,12 @@ | ((((uint64_t) (up)) & UINT32_C(0xffffffff)) << 32)) +/* Test for sum overflow. */ +#define overflows(a, b) \ + ((a) + (b) < (a)) + +/* Test for sum overflow into positive numbers. */ +#define overflows_into_positive(a, b) \ + (overflows((a), (b)) && ((a) + (b) > 0)) + /** Pseudorandom generator * Index: kernel/generic/include/print.h =================================================================== --- kernel/generic/include/print.h (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/generic/include/print.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -38,15 +38,5 @@ #include #include - -#ifndef NVERIFY_PRINTF - -#define PRINTF_ATTRIBUTE(start, end) \ - __attribute__((format(gnu_printf, start, end))) - -#else /* NVERIFY_PRINTF */ - -#define PRINTF_ATTRIBUTE(start, end) - -#endif /* NVERIFY_PRINTF */ +#include #define EOF (-1) Index: kernel/generic/include/printf/verify.h =================================================================== --- kernel/generic/include/printf/verify.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ kernel/generic/include/printf/verify.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2012 Martin Decky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup generic + * @{ + */ +/** @file + */ + +#ifndef KERN_PRINTF_VERIFY_H_ +#define KERN_PRINTF_VERIFY_H_ + +#ifndef NVERIFY_PRINTF + +#define PRINTF_ATTRIBUTE(start, end) \ + __attribute__((format(gnu_printf, start, end))) + +#else /* NVERIFY_PRINTF */ + +#define PRINTF_ATTRIBUTE(start, end) + +#endif /* NVERIFY_PRINTF */ + +#endif + +/** @} + */ Index: kernel/generic/include/proc/task.h =================================================================== --- kernel/generic/include/proc/task.h (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/generic/include/proc/task.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -95,8 +95,24 @@ /* IPC stuff */ - answerbox_t answerbox; /**< Communication endpoint */ + + /** Receiving communication endpoint */ + answerbox_t answerbox; + + /** Sending communication endpoints */ phone_t phones[IPC_MAX_PHONES]; - stats_ipc_t ipc_info; /**< IPC statistics */ + + /** Spinlock protecting the active_calls list. */ + SPINLOCK_DECLARE(active_calls_lock); + + /** + * List of all calls sent by this task that have not yet been + * answered. + */ + list_t active_calls; + event_t events[EVENT_TASK_END - EVENT_END]; + + /** IPC statistics */ + stats_ipc_t ipc_info; #ifdef CONFIG_UDEBUG Index: kernel/generic/src/ipc/event.c =================================================================== --- kernel/generic/src/ipc/event.c (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/generic/src/ipc/event.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -163,9 +163,13 @@ call->data.task_id = TASK ? TASK->taskid : 0; - irq_spinlock_lock(&event->answerbox->irq_lock, true); - list_append(&call->link, &event->answerbox->irq_notifs); - irq_spinlock_unlock(&event->answerbox->irq_lock, true); - - waitq_wakeup(&event->answerbox->wq, WAKEUP_FIRST); + irq_spinlock_lock(&event->answerbox->irq_lock, + true); + list_append(&call->ab_link, + &event->answerbox->irq_notifs); + irq_spinlock_unlock(&event->answerbox->irq_lock, + true); + + waitq_wakeup(&event->answerbox->wq, + WAKEUP_FIRST); if (mask) Index: kernel/generic/src/ipc/ipc.c =================================================================== --- kernel/generic/src/ipc/ipc.c (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/generic/src/ipc/ipc.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -45,4 +45,6 @@ #include #include +#include +#include #include #include @@ -71,6 +73,23 @@ { memsetb(call, sizeof(*call), 0); - call->sender = TASK; + spinlock_initialize(&call->forget_lock, "forget_lock"); + call->active = false; + call->forget = false; + call->sender = NULL; call->buffer = NULL; +} + +void ipc_call_hold(call_t *call) +{ + atomic_inc(&call->refcnt); +} + +void ipc_call_release(call_t *call) +{ + if (atomic_predec(&call->refcnt) == 0) { + if (call->buffer) + free(call->buffer); + slab_free(ipc_call_slab, call); + } } @@ -83,5 +102,5 @@ * * @return If flags permit it, return NULL, or initialized kernel - * call structure. + * call structure with one reference. * */ @@ -89,6 +108,8 @@ { call_t *call = slab_alloc(ipc_call_slab, flags); - if (call) + if (call) { _ipc_call_init(call); + ipc_call_hold(call); + } return call; @@ -102,8 +123,5 @@ void ipc_call_free(call_t *call) { - /* Check to see if we have data in the IPC_M_DATA_SEND buffer. */ - if (call->buffer) - free(call->buffer); - slab_free(ipc_call_slab, call); + ipc_call_release(call); } @@ -132,18 +150,24 @@ * @param phone Initialized phone structure. * @param box Initialized answerbox structure. - * - */ -void ipc_phone_connect(phone_t *phone, answerbox_t *box) -{ + * @return True if the phone was connected, false otherwise. + */ +bool ipc_phone_connect(phone_t *phone, answerbox_t *box) +{ + bool active; + mutex_lock(&phone->lock); - - phone->state = IPC_PHONE_CONNECTED; - phone->callee = box; - irq_spinlock_lock(&box->lock, true); - list_append(&phone->link, &box->connected_phones); + + active = box->active; + if (active) { + phone->state = IPC_PHONE_CONNECTED; + phone->callee = box; + list_append(&phone->link, &box->connected_phones); + } + irq_spinlock_unlock(&box->lock, true); - mutex_unlock(&phone->lock); + + return active; } @@ -151,9 +175,11 @@ * * @param phone Phone structure to be initialized. - * - */ -void ipc_phone_init(phone_t *phone) + * @param caller Owning task. + * + */ +void ipc_phone_init(phone_t *phone, task_t *caller) { mutex_initialize(&phone->lock, MUTEX_PASSIVE); + phone->caller = caller; phone->callee = NULL; phone->state = IPC_PHONE_FREE; @@ -167,23 +193,36 @@ * */ -static void _ipc_answer_free_call(call_t *call, bool selflocked) -{ - answerbox_t *callerbox = &call->sender->answerbox; - bool do_lock = ((!selflocked) || callerbox != (&TASK->answerbox)); - +void _ipc_answer_free_call(call_t *call, bool selflocked) +{ /* Count sent answer */ irq_spinlock_lock(&TASK->lock, true); TASK->ipc_info.answer_sent++; irq_spinlock_unlock(&TASK->lock, true); + + spinlock_lock(&call->forget_lock); + if (call->forget) { + /* This is a forgotten call and call->sender is not valid. */ + spinlock_unlock(&call->forget_lock); + ipc_call_free(call); + return; + } else { + /* + * If the call is still active, i.e. it was answered + * in a non-standard way, remove the call from the + * sender's active call list. + */ + if (call->active) { + spinlock_lock(&call->sender->active_calls_lock); + list_remove(&call->ta_link); + spinlock_unlock(&call->sender->active_calls_lock); + } + } + spinlock_unlock(&call->forget_lock); + + answerbox_t *callerbox = &call->sender->answerbox; + bool do_lock = ((!selflocked) || (callerbox != &TASK->answerbox)); call->flags |= IPC_CALL_ANSWERED; - if (call->flags & IPC_CALL_FORWARDED) { - if (call->caller_phone) { - /* Demasquerade the caller phone. */ - call->data.phone = call->caller_phone; - } - } - call->data.task_id = TASK->taskid; @@ -191,5 +230,5 @@ irq_spinlock_lock(&callerbox->lock, true); - list_append(&call->link, &callerbox->answers); + list_append(&call->ab_link, &callerbox->answers); if (do_lock) @@ -209,9 +248,26 @@ /* Remove from active box */ irq_spinlock_lock(&box->lock, true); - list_remove(&call->link); + list_remove(&call->ab_link); irq_spinlock_unlock(&box->lock, true); /* Send back answer */ _ipc_answer_free_call(call, false); +} + +static void _ipc_call_actions_internal(phone_t *phone, call_t *call) +{ + task_t *caller = phone->caller; + + atomic_inc(&phone->active_calls); + call->caller_phone = phone; + call->sender = caller; + + call->active = true; + spinlock_lock(&caller->active_calls_lock); + list_append(&call->ta_link, &caller->active_calls); + spinlock_unlock(&caller->active_calls_lock); + + call->data.phone = phone; + call->data.task_id = caller->taskid; } @@ -228,6 +284,5 @@ void ipc_backsend_err(phone_t *phone, call_t *call, sysarg_t err) { - call->data.phone = phone; - atomic_inc(&phone->active_calls); + _ipc_call_actions_internal(phone, call); IPC_SET_RETVAL(call->data, err); _ipc_answer_free_call(call, false); @@ -243,17 +298,16 @@ static void _ipc_call(phone_t *phone, answerbox_t *box, call_t *call) { + task_t *caller = phone->caller; + /* Count sent ipc call */ - irq_spinlock_lock(&TASK->lock, true); - TASK->ipc_info.call_sent++; - irq_spinlock_unlock(&TASK->lock, true); - - if (!(call->flags & IPC_CALL_FORWARDED)) { - atomic_inc(&phone->active_calls); - call->data.phone = phone; - call->data.task_id = TASK->taskid; - } + irq_spinlock_lock(&caller->lock, true); + caller->ipc_info.call_sent++; + irq_spinlock_unlock(&caller->lock, true); + + if (!(call->flags & IPC_CALL_FORWARDED)) + _ipc_call_actions_internal(phone, call); irq_spinlock_lock(&box->lock, true); - list_append(&call->link, &box->calls); + list_append(&call->ab_link, &box->calls); irq_spinlock_unlock(&box->lock, true); @@ -275,8 +329,5 @@ if (phone->state != IPC_PHONE_CONNECTED) { mutex_unlock(&phone->lock); - if (call->flags & IPC_CALL_FORWARDED) { - IPC_SET_RETVAL(call->data, EFORWARD); - _ipc_answer_free_call(call, false); - } else { + if (!(call->flags & IPC_CALL_FORWARDED)) { if (phone->state == IPC_PHONE_HUNGUP) ipc_backsend_err(phone, call, EHANGUP); @@ -325,4 +376,5 @@ call_t *call = ipc_call_alloc(0); IPC_SET_IMETHOD(call->data, IPC_M_PHONE_HUNGUP); + call->request_method = IPC_M_PHONE_HUNGUP; call->flags |= IPC_CALL_DISCARD_ANSWER; _ipc_call(phone, box, call); @@ -356,10 +408,8 @@ TASK->ipc_info.forwarded++; irq_spinlock_pass(&TASK->lock, &oldbox->lock); - list_remove(&call->link); + list_remove(&call->ab_link); irq_spinlock_unlock(&oldbox->lock, true); if (mode & IPC_FF_ROUTE_FROM_ME) { - if (!call->caller_phone) - call->caller_phone = call->data.phone; call->data.phone = newphone; call->data.task_id = TASK->taskid; @@ -406,6 +456,6 @@ request = list_get_instance(list_first(&box->irq_notifs), - call_t, link); - list_remove(&request->link); + call_t, ab_link); + list_remove(&request->ab_link); irq_spinlock_unlock(&box->irq_lock, false); @@ -416,7 +466,7 @@ /* Handle asynchronous answers */ request = list_get_instance(list_first(&box->answers), - call_t, link); - list_remove(&request->link); - atomic_dec(&request->data.phone->active_calls); + call_t, ab_link); + list_remove(&request->ab_link); + atomic_dec(&request->caller_phone->active_calls); } else if (!list_empty(&box->calls)) { /* Count received call */ @@ -425,9 +475,9 @@ /* Handle requests */ request = list_get_instance(list_first(&box->calls), - call_t, link); - list_remove(&request->link); + call_t, ab_link); + list_remove(&request->ab_link); /* Append request to dispatch queue */ - list_append(&request->link, &box->dispatched_calls); + list_append(&request->ab_link, &box->dispatched_calls); } else { /* This can happen regularly after ipc_cleanup */ @@ -449,19 +499,29 @@ /** Answer all calls from list with EHANGUP answer. * + * @param box Answerbox with the list. * @param lst Head of the list to be cleaned up. - * - */ -void ipc_cleanup_call_list(list_t *lst) -{ + */ +void ipc_cleanup_call_list(answerbox_t *box, list_t *lst) +{ + irq_spinlock_lock(&box->lock, true); while (!list_empty(lst)) { - call_t *call = list_get_instance(list_first(lst), call_t, link); - if (call->buffer) - free(call->buffer); - - list_remove(&call->link); - + call_t *call = list_get_instance(list_first(lst), call_t, + ab_link); + + list_remove(&call->ab_link); + + irq_spinlock_unlock(&box->lock, true); + + if (lst == &box->calls) + SYSIPC_OP(request_process, call, box); + + ipc_data_t old = call->data; IPC_SET_RETVAL(call->data, EHANGUP); + answer_preprocess(call, &old); _ipc_answer_free_call(call, true); - } + + irq_spinlock_lock(&box->lock, true); + } + irq_spinlock_unlock(&box->lock, true); } @@ -501,5 +561,7 @@ mutex_unlock(&phone->lock); irq_spinlock_unlock(&box->lock, true); - + + // FIXME: phone can become deallocated at any time now + /* * Send one message to the answerbox for each @@ -509,4 +571,5 @@ */ IPC_SET_IMETHOD(call->data, IPC_M_PHONE_HUNGUP); + call->request_method = IPC_M_PHONE_HUNGUP; call->flags |= IPC_CALL_DISCARD_ANSWER; _ipc_call(phone, box, call); @@ -529,4 +592,127 @@ } +static void ipc_forget_all_active_calls(void) +{ + call_t *call; + +restart: + spinlock_lock(&TASK->active_calls_lock); + if (list_empty(&TASK->active_calls)) { + /* + * We are done, there are no more active calls. + * Nota bene: there may still be answers waiting for pick up. + */ + spinlock_unlock(&TASK->active_calls_lock); + return; + } + + call = list_get_instance(list_first(&TASK->active_calls), call_t, + ta_link); + + if (!spinlock_trylock(&call->forget_lock)) { + /* + * Avoid deadlock and let async_answer() or + * _ipc_answer_free_call() win the race to dequeue the first + * call on the list. + */ + spinlock_unlock(&TASK->active_calls_lock); + goto restart; + } + + /* + * Forget the call and donate it to the task which holds up the answer. + */ + + call->forget = true; + call->sender = NULL; + list_remove(&call->ta_link); + + /* + * The call may be freed by _ipc_answer_free_call() before we are done + * with it; to avoid working with a destroyed call_t structure, we + * must hold a reference to it. + */ + ipc_call_hold(call); + + spinlock_unlock(&call->forget_lock); + spinlock_unlock(&TASK->active_calls_lock); + + atomic_dec(&call->caller_phone->active_calls); + + SYSIPC_OP(request_forget, call); + + ipc_call_release(call); + + goto restart; +} + +/** Wait for all answers to asynchronous calls to arrive. */ +static void ipc_wait_for_all_answered_calls(void) +{ + call_t *call; + size_t i; + +restart: + /* + * Go through all phones, until they are all free. + * Locking is needed as there may be connection handshakes in progress. + */ + for (i = 0; i < IPC_MAX_PHONES; i++) { + phone_t *phone = &TASK->phones[i]; + + mutex_lock(&phone->lock); + if ((phone->state == IPC_PHONE_HUNGUP) && + (atomic_get(&phone->active_calls) == 0)) { + phone->state = IPC_PHONE_FREE; + phone->callee = NULL; + } + + /* + * We might have had some IPC_PHONE_CONNECTING phones at the + * beginning of ipc_cleanup(). Depending on whether these were + * forgotten or answered, they will eventually enter the + * IPC_PHONE_FREE or IPC_PHONE_CONNECTED states, respectively. + * In the latter case, the other side may slam the open phones + * at any time, in which case we will get an IPC_PHONE_SLAMMED + * phone. + */ + if ((phone->state == IPC_PHONE_CONNECTED) || + (phone->state == IPC_PHONE_SLAMMED)) { + mutex_unlock(&phone->lock); + ipc_phone_hangup(phone); + /* + * Now there may be one extra active call, which needs + * to be forgotten. + */ + ipc_forget_all_active_calls(); + goto restart; + } + + /* + * If the hangup succeeded, it has sent a HANGUP message, the + * IPC is now in HUNGUP state, we wait for the reply to come + */ + if (phone->state != IPC_PHONE_FREE) { + mutex_unlock(&phone->lock); + break; + } + + mutex_unlock(&phone->lock); + } + + /* Got into cleanup */ + if (i == IPC_MAX_PHONES) + return; + + call = ipc_wait_for_call(&TASK->answerbox, SYNCH_NO_TIMEOUT, + SYNCH_FLAGS_NONE); + ASSERT(call->flags & (IPC_CALL_ANSWERED | IPC_CALL_NOTIF)); + + SYSIPC_OP(answer_process, call); + + ipc_call_free(call); + goto restart; +} + /** Clean up all IPC communication of the current task. * @@ -537,7 +723,16 @@ void ipc_cleanup(void) { + /* + * Mark the answerbox as inactive. + * + * The main purpose for doing this is to prevent any pending callback + * connections from getting established beyond this point. + */ + irq_spinlock_lock(&TASK->answerbox.lock, true); + TASK->answerbox.active = false; + irq_spinlock_unlock(&TASK->answerbox.lock, true); + /* Disconnect all our phones ('ipc_phone_hangup') */ - size_t i; - for (i = 0; i < IPC_MAX_PHONES; i++) + for (size_t i = 0; i < IPC_MAX_PHONES; i++) ipc_phone_hangup(&TASK->phones[i]); @@ -557,51 +752,10 @@ /* Answer all messages in 'calls' and 'dispatched_calls' queues */ - irq_spinlock_lock(&TASK->answerbox.lock, true); - ipc_cleanup_call_list(&TASK->answerbox.dispatched_calls); - ipc_cleanup_call_list(&TASK->answerbox.calls); - irq_spinlock_unlock(&TASK->answerbox.lock, true); - - /* Wait for all answers to asynchronous calls to arrive */ - while (true) { - /* - * Go through all phones, until they are all FREE - * Locking is not needed, no one else should modify - * it when we are in cleanup - */ - for (i = 0; i < IPC_MAX_PHONES; i++) { - if (TASK->phones[i].state == IPC_PHONE_HUNGUP && - atomic_get(&TASK->phones[i].active_calls) == 0) { - TASK->phones[i].state = IPC_PHONE_FREE; - TASK->phones[i].callee = NULL; - } - - /* - * Just for sure, we might have had some - * IPC_PHONE_CONNECTING phones - */ - if (TASK->phones[i].state == IPC_PHONE_CONNECTED) - ipc_phone_hangup(&TASK->phones[i]); - - /* - * If the hangup succeeded, it has sent a HANGUP - * message, the IPC is now in HUNGUP state, we - * wait for the reply to come - */ - - if (TASK->phones[i].state != IPC_PHONE_FREE) - break; - } - - /* Got into cleanup */ - if (i == IPC_MAX_PHONES) - break; - - call_t *call = ipc_wait_for_call(&TASK->answerbox, SYNCH_NO_TIMEOUT, - SYNCH_FLAGS_NONE); - ASSERT((call->flags & IPC_CALL_ANSWERED) || - (call->flags & IPC_CALL_NOTIF)); - - ipc_call_free(call); - } + ipc_cleanup_call_list(&TASK->answerbox, &TASK->answerbox.calls); + ipc_cleanup_call_list(&TASK->answerbox, + &TASK->answerbox.dispatched_calls); + + ipc_forget_all_active_calls(); + ipc_wait_for_all_answered_calls(); } @@ -615,4 +769,38 @@ ipc_answerbox_slab = slab_cache_create("answerbox_t", sizeof(answerbox_t), 0, NULL, NULL, 0); +} + + +static void ipc_print_call_list(list_t *list) +{ + list_foreach(*list, cur) { + call_t *call = list_get_instance(cur, call_t, ab_link); + +#ifdef __32_BITS__ + printf("%10p ", call); +#endif + +#ifdef __64_BITS__ + printf("%18p ", call); +#endif + + spinlock_lock(&call->forget_lock); + + printf("%-8" PRIun " %-6" PRIun " %-6" PRIun " %-6" PRIun + " %-6" PRIun " %-6" PRIun " %-7x", + IPC_GET_IMETHOD(call->data), IPC_GET_ARG1(call->data), + IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data), + IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data), + call->flags); + + if (call->forget) { + printf(" ? (call forgotten)\n"); + } else { + printf(" %" PRIu64 " (%s)\n", + call->sender->taskid, call->sender->name); + } + + spinlock_unlock(&call->forget_lock); + } } @@ -688,62 +876,9 @@ printf(" --- incomming calls ---\n"); - list_foreach(task->answerbox.calls, cur) { - call_t *call = list_get_instance(cur, call_t, link); - -#ifdef __32_BITS__ - printf("%10p ", call); -#endif - -#ifdef __64_BITS__ - printf("%18p ", call); -#endif - - printf("%-8" PRIun " %-6" PRIun " %-6" PRIun " %-6" PRIun - " %-6" PRIun " %-6" PRIun " %-7x %" PRIu64 " (%s)\n", - IPC_GET_IMETHOD(call->data), IPC_GET_ARG1(call->data), - IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data), - IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data), - call->flags, call->sender->taskid, call->sender->name); - } - + ipc_print_call_list(&task->answerbox.calls); printf(" --- dispatched calls ---\n"); - list_foreach(task->answerbox.dispatched_calls, cur) { - call_t *call = list_get_instance(cur, call_t, link); - -#ifdef __32_BITS__ - printf("%10p ", call); -#endif - -#ifdef __64_BITS__ - printf("%18p ", call); -#endif - - printf("%-8" PRIun " %-6" PRIun " %-6" PRIun " %-6" PRIun - " %-6" PRIun " %-6" PRIun " %-7x %" PRIu64 " (%s)\n", - IPC_GET_IMETHOD(call->data), IPC_GET_ARG1(call->data), - IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data), - IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data), - call->flags, call->sender->taskid, call->sender->name); - } - + ipc_print_call_list(&task->answerbox.dispatched_calls); printf(" --- incoming answers ---\n"); - list_foreach(task->answerbox.answers, cur) { - call_t *call = list_get_instance(cur, call_t, link); - -#ifdef __32_BITS__ - printf("%10p ", call); -#endif - -#ifdef __64_BITS__ - printf("%18p ", call); -#endif - - printf("%-8" PRIun " %-6" PRIun " %-6" PRIun " %-6" PRIun - " %-6" PRIun " %-6" PRIun " %-7x %" PRIu64 " (%s)\n", - IPC_GET_IMETHOD(call->data), IPC_GET_ARG1(call->data), - IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data), - IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data), - call->flags, call->sender->taskid, call->sender->name); - } + ipc_print_call_list(&task->answerbox.answers); irq_spinlock_unlock(&task->answerbox.lock, false); Index: kernel/generic/src/ipc/ipcrsc.c =================================================================== --- kernel/generic/src/ipc/ipcrsc.c (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/generic/src/ipc/ipcrsc.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -132,4 +132,5 @@ #include #include +#include /** Find call_t * in call table according to callid. @@ -151,5 +152,5 @@ list_foreach(TASK->answerbox.dispatched_calls, lst) { - call_t *call = list_get_instance(lst, call_t, link); + call_t *call = list_get_instance(lst, call_t, ab_link); if ((sysarg_t) call == callid) { result = call; @@ -162,4 +163,21 @@ } +/** Get phone from the current task by ID. + * + * @param phoneid Phone ID. + * @param phone Place to store pointer to phone. + * + * @return EOK on success, EINVAL if ID is invalid. + * + */ +int phone_get(sysarg_t phoneid, phone_t **phone) +{ + if (phoneid >= IPC_MAX_PHONES) + return EINVAL; + + *phone = &TASK->phones[phoneid]; + return EOK; +} + /** Allocate new phone slot in the specified task. * @@ -176,10 +194,12 @@ size_t i; for (i = 0; i < IPC_MAX_PHONES; i++) { - if ((task->phones[i].state == IPC_PHONE_HUNGUP) && - (atomic_get(&task->phones[i].active_calls) == 0)) - task->phones[i].state = IPC_PHONE_FREE; + phone_t *phone = &task->phones[i]; + + if ((phone->state == IPC_PHONE_HUNGUP) && + (atomic_get(&phone->active_calls) == 0)) + phone->state = IPC_PHONE_FREE; - if (task->phones[i].state == IPC_PHONE_FREE) { - task->phones[i].state = IPC_PHONE_CONNECTING; + if (phone->state == IPC_PHONE_FREE) { + phone->state = IPC_PHONE_CONNECTING; break; } @@ -223,4 +243,5 @@ * @param phoneid Phone handle to be connected. * @param box Answerbox to which to connect the phone handle. + * @return True if the phone was connected, false otherwise. * * The procedure _enforces_ that the user first marks the phone @@ -229,10 +250,10 @@ * */ -void phone_connect(int phoneid, answerbox_t *box) +bool phone_connect(int phoneid, answerbox_t *box) { phone_t *phone = &TASK->phones[phoneid]; ASSERT(phone->state == IPC_PHONE_CONNECTING); - ipc_phone_connect(phone, box); + return ipc_phone_connect(phone, box); } Index: kernel/generic/src/ipc/irq.c =================================================================== --- kernel/generic/src/ipc/irq.c (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/generic/src/ipc/irq.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -510,5 +510,5 @@ { irq_spinlock_lock(&irq->notif_cfg.answerbox->irq_lock, false); - list_append(&call->link, &irq->notif_cfg.answerbox->irq_notifs); + list_append(&call->ab_link, &irq->notif_cfg.answerbox->irq_notifs); irq_spinlock_unlock(&irq->notif_cfg.answerbox->irq_lock, false); Index: kernel/generic/src/ipc/kbox.c =================================================================== --- kernel/generic/src/ipc/kbox.c (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/generic/src/ipc/kbox.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -49,4 +49,12 @@ { /* + * Not really needed, just to be consistent with the meaning of + * answerbox_t.active. + */ + irq_spinlock_lock(&TASK->kb.box.lock, true); + TASK->kb.box.active = false; + irq_spinlock_unlock(&TASK->kb.box.lock, true); + + /* * Only hold kb.cleanup_lock while setting kb.finished - * this is enough. @@ -89,8 +97,6 @@ /* Answer all messages in 'calls' and 'dispatched_calls' queues. */ - irq_spinlock_lock(&TASK->kb.box.lock, true); - ipc_cleanup_call_list(&TASK->kb.box.dispatched_calls); - ipc_cleanup_call_list(&TASK->kb.box.calls); - irq_spinlock_unlock(&TASK->kb.box.lock, true); + ipc_cleanup_call_list(&TASK->kb.box, &TASK->kb.box.calls); + ipc_cleanup_call_list(&TASK->kb.box, &TASK->kb.box.dispatched_calls); } @@ -163,5 +169,5 @@ while (!done) { call_t *call = ipc_wait_for_call(&TASK->kb.box, SYNCH_NO_TIMEOUT, - SYNCH_FLAGS_NONE); + SYNCH_FLAGS_NONE); if (call == NULL) @@ -237,5 +243,5 @@ /* Connect the newly allocated phone to the kbox */ - ipc_phone_connect(&TASK->phones[newphid], &task->kb.box); + (void) ipc_phone_connect(&TASK->phones[newphid], &task->kb.box); if (task->kb.thread != NULL) { Index: kernel/generic/src/ipc/ops/clnestab.c =================================================================== --- kernel/generic/src/ipc/ops/clnestab.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ kernel/generic/src/ipc/ops/clnestab.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2012 Jakub Jermar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup genericipc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include + +static int request_preprocess(call_t *call, phone_t *phone) +{ + IPC_SET_ARG5(call->data, (sysarg_t) phone); + + return EOK; +} + +static int answer_cleanup(call_t *answer, ipc_data_t *olddata) +{ + phone_t *phone = (phone_t *) IPC_GET_ARG5(*olddata); + + mutex_lock(&phone->lock); + if (phone->state == IPC_PHONE_CONNECTED) { + irq_spinlock_lock(&phone->callee->lock, true); + list_remove(&phone->link); + phone->state = IPC_PHONE_SLAMMED; + irq_spinlock_unlock(&phone->callee->lock, true); + } + mutex_unlock(&phone->lock); + + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + + if (IPC_GET_RETVAL(answer->data) != EOK) { + /* + * The other party on the cloned phone rejected our request + * for connection on the protocol level. We need to break the + * connection without sending IPC_M_HUNGUP back. + */ + answer_cleanup(answer, olddata); + } + + return EOK; +} + +sysipc_ops_t ipc_m_clone_establish_ops = { + .request_preprocess = request_preprocess, + .request_forget = null_request_forget, + .request_process = null_request_process, + .answer_cleanup = answer_cleanup, + .answer_preprocess = answer_preprocess, + .answer_process = null_answer_process, +}; + +/** @} + */ Index: kernel/generic/src/ipc/ops/conctmeto.c =================================================================== --- kernel/generic/src/ipc/ops/conctmeto.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ kernel/generic/src/ipc/ops/conctmeto.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2006 Ondrej Palkovsky + * Copyright (c) 2012 Jakub Jermar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup genericipc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include + +static int request_preprocess(call_t *call, phone_t *phone) +{ + int newphid = phone_alloc(TASK); + + if (newphid < 0) + return ELIMIT; + + /* Set arg5 for server */ + IPC_SET_ARG5(call->data, (sysarg_t) &TASK->phones[newphid]); + call->priv = newphid; + + return EOK; +} + +static int request_forget(call_t *call) +{ + phone_dealloc(call->priv); + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + phone_t *phone = (phone_t *) IPC_GET_ARG5(*olddata); + + /* If the user accepted call, connect */ + if (IPC_GET_RETVAL(answer->data) == EOK) + (void) ipc_phone_connect(phone, &TASK->answerbox); + + return EOK; +} + +static int answer_process(call_t *answer) +{ + if (IPC_GET_RETVAL(answer->data)) + phone_dealloc(answer->priv); + else + IPC_SET_ARG5(answer->data, answer->priv); + + return EOK; +} + +sysipc_ops_t ipc_m_connect_me_to_ops = { + .request_preprocess = request_preprocess, + .request_forget = request_forget, + .request_process = null_request_process, + .answer_cleanup = null_answer_cleanup, + .answer_preprocess = answer_preprocess, + .answer_process = answer_process, +}; + +/** @} + */ Index: kernel/generic/src/ipc/ops/concttome.c =================================================================== --- kernel/generic/src/ipc/ops/concttome.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ kernel/generic/src/ipc/ops/concttome.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,97 @@ +/* + * Copyright (c) 2006 Ondrej Palkovsky + * Copyright (c) 2012 Jakub Jermar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup genericipc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include + +static int request_process(call_t *call, answerbox_t *box) +{ + int phoneid = phone_alloc(TASK); + + IPC_SET_ARG5(call->data, phoneid); + + return EOK; +} + +static int answer_cleanup(call_t *answer, ipc_data_t *olddata) +{ + int phoneid = (int) IPC_GET_ARG5(*olddata); + + if (phoneid >= 0) + phone_dealloc(phoneid); + + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + int phoneid = (int) IPC_GET_ARG5(*olddata); + + if (IPC_GET_RETVAL(answer->data) != EOK) { + /* The connection was not accepted */ + answer_cleanup(answer, olddata); + } else if (phoneid >= 0) { + /* The connection was accepted */ + if (phone_connect(phoneid, &answer->sender->answerbox)) { + /* Set 'phone hash' as arg5 of response */ + IPC_SET_ARG5(answer->data, + (sysarg_t) &TASK->phones[phoneid]); + } else { + /* The answerbox is shutting down. */ + IPC_SET_RETVAL(answer->data, ENOENT); + answer_cleanup(answer, olddata); + } + } else { + IPC_SET_RETVAL(answer->data, ELIMIT); + } + + return EOK; +} + + +sysipc_ops_t ipc_m_connect_to_me_ops = { + .request_preprocess = null_request_preprocess, + .request_forget = null_request_forget, + .request_process = request_process, + .answer_cleanup = answer_cleanup, + .answer_preprocess = answer_preprocess, + .answer_process = null_answer_process, +}; + +/** @} + */ Index: kernel/generic/src/ipc/ops/connclone.c =================================================================== --- kernel/generic/src/ipc/ops/connclone.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ kernel/generic/src/ipc/ops/connclone.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,144 @@ +/* + * Copyright (c) 2012 Jakub Jermar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup genericipc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include +#include + +static void phones_lock(phone_t *p1, phone_t *p2) +{ + if (p1 < p2) { + mutex_lock(&p1->lock); + mutex_lock(&p2->lock); + } else if (p1 > p2) { + mutex_lock(&p2->lock); + mutex_lock(&p1->lock); + } else + mutex_lock(&p1->lock); +} + +static void phones_unlock(phone_t *p1, phone_t *p2) +{ + mutex_unlock(&p1->lock); + if (p1 != p2) + mutex_unlock(&p2->lock); +} + +static int request_preprocess(call_t *call, phone_t *phone) +{ + phone_t *cloned_phone; + + if (phone_get(IPC_GET_ARG1(call->data), &cloned_phone) != EOK) + return ENOENT; + + phones_lock(cloned_phone, phone); + + if ((cloned_phone->state != IPC_PHONE_CONNECTED) || + phone->state != IPC_PHONE_CONNECTED) { + phones_unlock(cloned_phone, phone); + return EINVAL; + } + + /* + * We can be pretty sure now that both tasks exist and we are + * connected to them. As we continue to hold the phone locks, + * we are effectively preventing them from finishing their + * potential cleanup. + * + */ + int newphid = phone_alloc(phone->callee->task); + if (newphid < 0) { + phones_unlock(cloned_phone, phone); + return ELIMIT; + } + + (void) ipc_phone_connect(&phone->callee->task->phones[newphid], + cloned_phone->callee); + phones_unlock(cloned_phone, phone); + + /* Set the new phone for the callee. */ + IPC_SET_ARG1(call->data, newphid); + + return EOK; +} + +static int answer_cleanup(call_t *answer, ipc_data_t *olddata) +{ + int phoneid = (int) IPC_GET_ARG1(*olddata); + phone_t *phone = &TASK->phones[phoneid]; + + /* + * In this case, the connection was established at the request + * time and therefore we need to slam the phone. We don't + * merely hangup as that would result in sending IPC_M_HUNGUP + * to the third party on the other side of the cloned phone. + */ + mutex_lock(&phone->lock); + if (phone->state == IPC_PHONE_CONNECTED) { + irq_spinlock_lock(&phone->callee->lock, true); + list_remove(&phone->link); + phone->state = IPC_PHONE_SLAMMED; + irq_spinlock_unlock(&phone->callee->lock, true); + } + mutex_unlock(&phone->lock); + + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + if (IPC_GET_RETVAL(answer->data) != EOK) { + /* + * The recipient of the cloned phone rejected the offer. + */ + answer_cleanup(answer, olddata); + } + + return EOK; +} + +sysipc_ops_t ipc_m_connection_clone_ops = { + .request_preprocess = request_preprocess, + .request_forget = null_request_forget, + .request_process = null_request_process, + .answer_cleanup = answer_cleanup, + .answer_preprocess = answer_preprocess, + .answer_process = null_answer_process, +}; + +/** @} + */ Index: kernel/generic/src/ipc/ops/dataread.c =================================================================== --- kernel/generic/src/ipc/ops/dataread.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ kernel/generic/src/ipc/ops/dataread.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,121 @@ +/* + * Copyright (c) 2012 Jakub Jermar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup genericipc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include +#include + +static int request_preprocess(call_t *call, phone_t *phone) +{ + size_t size = IPC_GET_ARG2(call->data); + + if (size > DATA_XFER_LIMIT) { + int flags = IPC_GET_ARG3(call->data); + + if (flags & IPC_XF_RESTRICT) + IPC_SET_ARG2(call->data, DATA_XFER_LIMIT); + else + return ELIMIT; + } + + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + ASSERT(!answer->buffer); + + if (!IPC_GET_RETVAL(answer->data)) { + /* The recipient agreed to send data. */ + uintptr_t src = IPC_GET_ARG1(answer->data); + uintptr_t dst = IPC_GET_ARG1(*olddata); + size_t max_size = IPC_GET_ARG2(*olddata); + size_t size = IPC_GET_ARG2(answer->data); + + if (size && size <= max_size) { + /* + * Copy the destination VA so that this piece of + * information is not lost. + */ + IPC_SET_ARG1(answer->data, dst); + + answer->buffer = malloc(size, 0); + int rc = copy_from_uspace(answer->buffer, + (void *) src, size); + if (rc) { + IPC_SET_RETVAL(answer->data, rc); + /* + * answer->buffer will be cleaned up in + * ipc_call_free(). + */ + } + } else if (!size) { + IPC_SET_RETVAL(answer->data, EOK); + } else { + IPC_SET_RETVAL(answer->data, ELIMIT); + } + } + + return EOK; +} + +static int answer_process(call_t *answer) +{ + if (answer->buffer) { + uintptr_t dst = IPC_GET_ARG1(answer->data); + size_t size = IPC_GET_ARG2(answer->data); + int rc; + + rc = copy_to_uspace((void *) dst, answer->buffer, size); + if (rc) + IPC_SET_RETVAL(answer->data, rc); + } + + return EOK; +} + +sysipc_ops_t ipc_m_data_read_ops = { + .request_preprocess = request_preprocess, + .request_forget = null_request_forget, + .request_process = null_request_process, + .answer_cleanup = null_answer_cleanup, + .answer_preprocess = answer_preprocess, + .answer_process = answer_process, +}; + +/** @} + */ Index: kernel/generic/src/ipc/ops/datawrite.c =================================================================== --- kernel/generic/src/ipc/ops/datawrite.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ kernel/generic/src/ipc/ops/datawrite.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,104 @@ +/* + * Copyright (c) 2012 Jakub Jermar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup genericipc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include +#include + +static int request_preprocess(call_t *call, phone_t *phone) +{ + uintptr_t src = IPC_GET_ARG1(call->data); + size_t size = IPC_GET_ARG2(call->data); + + if (size > DATA_XFER_LIMIT) { + int flags = IPC_GET_ARG3(call->data); + + if (flags & IPC_XF_RESTRICT) { + size = DATA_XFER_LIMIT; + IPC_SET_ARG2(call->data, size); + } else + return ELIMIT; + } + + call->buffer = (uint8_t *) malloc(size, 0); + int rc = copy_from_uspace(call->buffer, (void *) src, size); + if (rc != 0) { + /* + * call->buffer will be cleaned up in ipc_call_free() at the + * latest. + */ + return rc; + } + + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + ASSERT(answer->buffer); + + if (!IPC_GET_RETVAL(answer->data)) { + /* The recipient agreed to receive data. */ + uintptr_t dst = (uintptr_t)IPC_GET_ARG1(answer->data); + size_t size = (size_t)IPC_GET_ARG2(answer->data); + size_t max_size = (size_t)IPC_GET_ARG2(*olddata); + + if (size <= max_size) { + int rc = copy_to_uspace((void *) dst, + answer->buffer, size); + if (rc) + IPC_SET_RETVAL(answer->data, rc); + } else { + IPC_SET_RETVAL(answer->data, ELIMIT); + } + } + + return EOK; +} + + +sysipc_ops_t ipc_m_data_write_ops = { + .request_preprocess = request_preprocess, + .request_forget = null_request_forget, + .request_process = null_request_process, + .answer_cleanup = null_answer_cleanup, + .answer_preprocess = answer_preprocess, + .answer_process = null_answer_process, +}; + +/** @} + */ Index: kernel/generic/src/ipc/ops/debug.c =================================================================== --- kernel/generic/src/ipc/ops/debug.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ kernel/generic/src/ipc/ops/debug.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2008 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup genericipc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include + +static int request_process(call_t *call, answerbox_t *box) +{ + return -1; +} + +static int answer_process(call_t *answer) +{ + if (answer->buffer) { + uintptr_t dst = IPC_GET_ARG1(answer->data); + size_t size = IPC_GET_ARG2(answer->data); + int rc; + + rc = copy_to_uspace((void *) dst, answer->buffer, size); + if (rc) + IPC_SET_RETVAL(answer->data, rc); + } + + return EOK; +} + +sysipc_ops_t ipc_m_debug_ops = { +#ifdef CONFIG_UDEBUG + .request_preprocess = udebug_request_preprocess, +#else + .request_preprocess = null_request_preprocess, +#endif + .request_forget = null_request_forget, + .request_process = request_process, + .answer_cleanup = null_answer_cleanup, + .answer_preprocess = null_answer_preprocess, + .answer_process = answer_process, +}; + +/** @} + */ Index: kernel/generic/src/ipc/ops/sharein.c =================================================================== --- kernel/generic/src/ipc/ops/sharein.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ kernel/generic/src/ipc/ops/sharein.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2012 Jakub Jermar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup genericipc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include +#include +#include + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + if (!IPC_GET_RETVAL(answer->data)) { + irq_spinlock_lock(&answer->sender->lock, true); + as_t *as = answer->sender->as; + irq_spinlock_unlock(&answer->sender->lock, true); + + uintptr_t dst_base = (uintptr_t) -1; + int rc = as_area_share(AS, IPC_GET_ARG1(answer->data), + IPC_GET_ARG1(*olddata), as, IPC_GET_ARG2(answer->data), + &dst_base, IPC_GET_ARG3(answer->data)); + IPC_SET_ARG4(answer->data, dst_base); + IPC_SET_RETVAL(answer->data, rc); + } + + return EOK; +} + +sysipc_ops_t ipc_m_share_in_ops = { + .request_preprocess = null_request_preprocess, + .request_forget = null_request_forget, + .request_process = null_request_process, + .answer_cleanup = null_answer_cleanup, + .answer_preprocess = answer_preprocess, + .answer_process = null_answer_process, +}; + +/** @} + */ Index: kernel/generic/src/ipc/ops/shareout.c =================================================================== --- kernel/generic/src/ipc/ops/shareout.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ kernel/generic/src/ipc/ops/shareout.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2012 Jakub Jermar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup genericipc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +static int request_preprocess(call_t *call, phone_t *phone) +{ + size_t size = as_area_get_size(IPC_GET_ARG1(call->data)); + + if (!size) + return EPERM; + IPC_SET_ARG2(call->data, size); + + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + int rc = EOK; + + if (!IPC_GET_RETVAL(answer->data)) { + /* Accepted, handle as_area receipt */ + + irq_spinlock_lock(&answer->sender->lock, true); + as_t *as = answer->sender->as; + irq_spinlock_unlock(&answer->sender->lock, true); + + uintptr_t dst_base = (uintptr_t) -1; + rc = as_area_share(as, IPC_GET_ARG1(*olddata), + IPC_GET_ARG2(*olddata), AS, IPC_GET_ARG3(*olddata), + &dst_base, IPC_GET_ARG1(answer->data)); + + if (rc == EOK) { + rc = copy_to_uspace((void *) IPC_GET_ARG2(answer->data), + &dst_base, sizeof(dst_base)); + } + + IPC_SET_RETVAL(answer->data, rc); + } + + return rc; +} + +sysipc_ops_t ipc_m_share_out_ops = { + .request_preprocess = request_preprocess, + .request_forget = null_request_forget, + .request_process = null_request_process, + .answer_cleanup = null_answer_cleanup, + .answer_preprocess = answer_preprocess, + .answer_process = null_answer_process, +}; + +/** @} + */ Index: kernel/generic/src/ipc/ops/stchngath.c =================================================================== --- kernel/generic/src/ipc/ops/stchngath.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ kernel/generic/src/ipc/ops/stchngath.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,128 @@ +/* + * Copyright (c) 2012 Jakub Jermar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup genericipc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include +#include +#include + +static int request_preprocess(call_t *call, phone_t *phone) +{ + phone_t *sender_phone; + task_t *other_task_s; + + if (phone_get(IPC_GET_ARG5(call->data), &sender_phone) != EOK) + return ENOENT; + + mutex_lock(&sender_phone->lock); + if (sender_phone->state != IPC_PHONE_CONNECTED) { + mutex_unlock(&sender_phone->lock); + return EINVAL; + } + + other_task_s = sender_phone->callee->task; + + mutex_unlock(&sender_phone->lock); + + /* Remember the third party task hash. */ + IPC_SET_ARG5(call->data, (sysarg_t) other_task_s); + + return EOK; +} + +static int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + int rc = EOK; + + if (!IPC_GET_RETVAL(answer->data)) { + /* The recipient authorized the change of state. */ + phone_t *recipient_phone; + task_t *other_task_s; + task_t *other_task_r; + + rc = phone_get(IPC_GET_ARG1(answer->data), + &recipient_phone); + if (rc != EOK) { + IPC_SET_RETVAL(answer->data, ENOENT); + return ENOENT; + } + + mutex_lock(&recipient_phone->lock); + if (recipient_phone->state != IPC_PHONE_CONNECTED) { + mutex_unlock(&recipient_phone->lock); + IPC_SET_RETVAL(answer->data, EINVAL); + return EINVAL; + } + + other_task_r = recipient_phone->callee->task; + other_task_s = (task_t *) IPC_GET_ARG5(*olddata); + + /* + * See if both the sender and the recipient meant the + * same third party task. + */ + if (other_task_r != other_task_s) { + IPC_SET_RETVAL(answer->data, EINVAL); + rc = EINVAL; + } else { + rc = event_task_notify_5(other_task_r, + EVENT_TASK_STATE_CHANGE, false, + IPC_GET_ARG1(*olddata), + IPC_GET_ARG2(*olddata), + IPC_GET_ARG3(*olddata), + LOWER32(olddata->task_id), + UPPER32(olddata->task_id)); + IPC_SET_RETVAL(answer->data, rc); + } + + mutex_unlock(&recipient_phone->lock); + } + + return rc; +} + +sysipc_ops_t ipc_m_state_change_authorize_ops = { + .request_preprocess = request_preprocess, + .request_forget = null_request_forget, + .request_process = null_request_process, + .answer_cleanup = null_answer_cleanup, + .answer_preprocess = answer_preprocess, + .answer_process = null_answer_process, +}; + +/** @} + */ Index: kernel/generic/src/ipc/sysipc.c =================================================================== --- kernel/generic/src/ipc/sysipc.c (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/generic/src/ipc/sysipc.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -34,12 +34,11 @@ #include -#include -#include #include #include -#include #include #include #include +#include +#include #include #include @@ -47,37 +46,12 @@ #include #include -#include #include #include #include #include -#include #include #include -/** - * Maximum buffer size allowed for IPC_M_DATA_WRITE and IPC_M_DATA_READ - * requests. - */ -#define DATA_XFER_LIMIT (64 * 1024) - #define STRUCT_TO_USPACE(dst, src) copy_to_uspace((dst), (src), sizeof(*(src))) - -/** Get phone from the current task by ID. - * - * @param phoneid Phone ID. - * @param phone Place to store pointer to phone. - * - * @return EOK on success, EINVAL if ID is invalid. - * - */ -static int phone_get(sysarg_t phoneid, phone_t **phone) -{ - if (phoneid >= IPC_MAX_PHONES) - return EINVAL; - - *phone = &TASK->phones[phoneid]; - return EOK; -} /** Decide if the interface and method is a system method. @@ -181,235 +155,59 @@ * @param olddata Saved data of the request. * - * @return Return 0 on success or an error code. - * - */ -static inline int answer_preprocess(call_t *answer, ipc_data_t *olddata) -{ + * @return Return EOK on success or a negative error code. + * + */ +int answer_preprocess(call_t *answer, ipc_data_t *olddata) +{ + int rc = EOK; + + spinlock_lock(&answer->forget_lock); + if (answer->forget) { + /* + * This is a forgotten call and answer->sender is not valid. + */ + spinlock_unlock(&answer->forget_lock); + + SYSIPC_OP(answer_cleanup, answer, olddata); + return rc; + } else { + ASSERT(answer->active); + + /* + * Mark the call as inactive to prevent _ipc_answer_free_call() + * from attempting to remove the call from the active list + * itself. + */ + answer->active = false; + + /* + * Remove the call from the sender's active call list. + * We enforce this locking order so that any potential + * concurrently executing forget operation is forced to + * release its active_calls_lock and lose the race to + * forget this soon to be answered call. + */ + spinlock_lock(&answer->sender->active_calls_lock); + list_remove(&answer->ta_link); + spinlock_unlock(&answer->sender->active_calls_lock); + } + spinlock_unlock(&answer->forget_lock); + if ((native_t) IPC_GET_RETVAL(answer->data) == EHANGUP) { - /* In case of forward, hangup the forwared phone, - * not the originator - */ - mutex_lock(&answer->data.phone->lock); - irq_spinlock_lock(&TASK->answerbox.lock, true); - if (answer->data.phone->state == IPC_PHONE_CONNECTED) { - list_remove(&answer->data.phone->link); - answer->data.phone->state = IPC_PHONE_SLAMMED; + phone_t *phone = answer->caller_phone; + mutex_lock(&phone->lock); + if (phone->state == IPC_PHONE_CONNECTED) { + irq_spinlock_lock(&phone->callee->lock, true); + list_remove(&phone->link); + phone->state = IPC_PHONE_SLAMMED; + irq_spinlock_unlock(&phone->callee->lock, true); } - irq_spinlock_unlock(&TASK->answerbox.lock, true); - mutex_unlock(&answer->data.phone->lock); + mutex_unlock(&phone->lock); } if (!olddata) - return 0; - - if (IPC_GET_IMETHOD(*olddata) == IPC_M_CONNECTION_CLONE) { - int phoneid = IPC_GET_ARG1(*olddata); - phone_t *phone = &TASK->phones[phoneid]; - - if (IPC_GET_RETVAL(answer->data) != EOK) { - /* - * The recipient of the cloned phone rejected the offer. - * In this case, the connection was established at the - * request time and therefore we need to slam the phone. - * We don't merely hangup as that would result in - * sending IPC_M_HUNGUP to the third party on the - * other side of the cloned phone. - */ - mutex_lock(&phone->lock); - if (phone->state == IPC_PHONE_CONNECTED) { - irq_spinlock_lock(&phone->callee->lock, true); - list_remove(&phone->link); - phone->state = IPC_PHONE_SLAMMED; - irq_spinlock_unlock(&phone->callee->lock, true); - } - mutex_unlock(&phone->lock); - } - } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_CLONE_ESTABLISH) { - phone_t *phone = (phone_t *) IPC_GET_ARG5(*olddata); - - if (IPC_GET_RETVAL(answer->data) != EOK) { - /* - * The other party on the cloned phoned rejected our - * request for connection on the protocol level. - * We need to break the connection without sending - * IPC_M_HUNGUP back. - */ - mutex_lock(&phone->lock); - if (phone->state == IPC_PHONE_CONNECTED) { - irq_spinlock_lock(&phone->callee->lock, true); - list_remove(&phone->link); - phone->state = IPC_PHONE_SLAMMED; - irq_spinlock_unlock(&phone->callee->lock, true); - } - mutex_unlock(&phone->lock); - } - } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_CONNECT_TO_ME) { - int phoneid = IPC_GET_ARG5(*olddata); - - if (IPC_GET_RETVAL(answer->data) != EOK) { - /* The connection was not accepted */ - phone_dealloc(phoneid); - } else { - /* The connection was accepted */ - phone_connect(phoneid, &answer->sender->answerbox); - /* Set 'phone hash' as arg5 of response */ - IPC_SET_ARG5(answer->data, - (sysarg_t) &TASK->phones[phoneid]); - } - } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_CONNECT_ME_TO) { - /* If the users accepted call, connect */ - if (IPC_GET_RETVAL(answer->data) == EOK) { - ipc_phone_connect((phone_t *) IPC_GET_ARG5(*olddata), - &TASK->answerbox); - } - } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_SHARE_OUT) { - if (!IPC_GET_RETVAL(answer->data)) { - /* Accepted, handle as_area receipt */ - - irq_spinlock_lock(&answer->sender->lock, true); - as_t *as = answer->sender->as; - irq_spinlock_unlock(&answer->sender->lock, true); - - uintptr_t dst_base = (uintptr_t) -1; - int rc = as_area_share(as, IPC_GET_ARG1(*olddata), - IPC_GET_ARG2(*olddata), AS, IPC_GET_ARG3(*olddata), - &dst_base, IPC_GET_ARG1(answer->data)); - - if (rc == EOK) - rc = copy_to_uspace((void *) IPC_GET_ARG2(answer->data), - &dst_base, sizeof(dst_base)); - - IPC_SET_RETVAL(answer->data, rc); - return rc; - } - } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_SHARE_IN) { - if (!IPC_GET_RETVAL(answer->data)) { - irq_spinlock_lock(&answer->sender->lock, true); - as_t *as = answer->sender->as; - irq_spinlock_unlock(&answer->sender->lock, true); - - uintptr_t dst_base = (uintptr_t) -1; - int rc = as_area_share(AS, IPC_GET_ARG1(answer->data), - IPC_GET_ARG1(*olddata), as, IPC_GET_ARG2(answer->data), - &dst_base, IPC_GET_ARG3(answer->data)); - IPC_SET_ARG4(answer->data, dst_base); - IPC_SET_RETVAL(answer->data, rc); - } - } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_DATA_READ) { - ASSERT(!answer->buffer); - if (!IPC_GET_RETVAL(answer->data)) { - /* The recipient agreed to send data. */ - uintptr_t src = IPC_GET_ARG1(answer->data); - uintptr_t dst = IPC_GET_ARG1(*olddata); - size_t max_size = IPC_GET_ARG2(*olddata); - size_t size = IPC_GET_ARG2(answer->data); - if (size && size <= max_size) { - /* - * Copy the destination VA so that this piece of - * information is not lost. - */ - IPC_SET_ARG1(answer->data, dst); - - answer->buffer = malloc(size, 0); - int rc = copy_from_uspace(answer->buffer, - (void *) src, size); - if (rc) { - IPC_SET_RETVAL(answer->data, rc); - free(answer->buffer); - answer->buffer = NULL; - } - } else if (!size) { - IPC_SET_RETVAL(answer->data, EOK); - } else { - IPC_SET_RETVAL(answer->data, ELIMIT); - } - } - } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_DATA_WRITE) { - ASSERT(answer->buffer); - if (!IPC_GET_RETVAL(answer->data)) { - /* The recipient agreed to receive data. */ - uintptr_t dst = (uintptr_t)IPC_GET_ARG1(answer->data); - size_t size = (size_t)IPC_GET_ARG2(answer->data); - size_t max_size = (size_t)IPC_GET_ARG2(*olddata); - - if (size <= max_size) { - int rc = copy_to_uspace((void *) dst, - answer->buffer, size); - if (rc) - IPC_SET_RETVAL(answer->data, rc); - } else { - IPC_SET_RETVAL(answer->data, ELIMIT); - } - } - free(answer->buffer); - answer->buffer = NULL; - } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_STATE_CHANGE_AUTHORIZE) { - if (!IPC_GET_RETVAL(answer->data)) { - /* The recipient authorized the change of state. */ - phone_t *recipient_phone; - task_t *other_task_s; - task_t *other_task_r; - int rc; - - rc = phone_get(IPC_GET_ARG1(answer->data), - &recipient_phone); - if (rc != EOK) { - IPC_SET_RETVAL(answer->data, ENOENT); - return ENOENT; - } - - mutex_lock(&recipient_phone->lock); - if (recipient_phone->state != IPC_PHONE_CONNECTED) { - mutex_unlock(&recipient_phone->lock); - IPC_SET_RETVAL(answer->data, EINVAL); - return EINVAL; - } - - other_task_r = recipient_phone->callee->task; - other_task_s = (task_t *) IPC_GET_ARG5(*olddata); - - /* - * See if both the sender and the recipient meant the - * same third party task. - */ - if (other_task_r != other_task_s) { - IPC_SET_RETVAL(answer->data, EINVAL); - rc = EINVAL; - } else { - rc = event_task_notify_5(other_task_r, - EVENT_TASK_STATE_CHANGE, false, - IPC_GET_ARG1(*olddata), - IPC_GET_ARG2(*olddata), - IPC_GET_ARG3(*olddata), - LOWER32(olddata->task_id), - UPPER32(olddata->task_id)); - IPC_SET_RETVAL(answer->data, rc); - } - - mutex_unlock(&recipient_phone->lock); - return rc; - } - } - - return 0; -} - -static void phones_lock(phone_t *p1, phone_t *p2) -{ - if (p1 < p2) { - mutex_lock(&p1->lock); - mutex_lock(&p2->lock); - } else if (p1 > p2) { - mutex_lock(&p2->lock); - mutex_lock(&p1->lock); - } else - mutex_lock(&p1->lock); -} - -static void phones_unlock(phone_t *p1, phone_t *p2) -{ - mutex_unlock(&p1->lock); - if (p1 != p2) - mutex_unlock(&p2->lock); + return rc; + + return SYSIPC_OP(answer_preprocess, answer, olddata); } @@ -424,124 +222,6 @@ static int request_preprocess(call_t *call, phone_t *phone) { - switch (IPC_GET_IMETHOD(call->data)) { - case IPC_M_CONNECTION_CLONE: { - phone_t *cloned_phone; - if (phone_get(IPC_GET_ARG1(call->data), &cloned_phone) != EOK) - return ENOENT; - - phones_lock(cloned_phone, phone); - - if ((cloned_phone->state != IPC_PHONE_CONNECTED) || - phone->state != IPC_PHONE_CONNECTED) { - phones_unlock(cloned_phone, phone); - return EINVAL; - } - - /* - * We can be pretty sure now that both tasks exist and we are - * connected to them. As we continue to hold the phone locks, - * we are effectively preventing them from finishing their - * potential cleanup. - * - */ - int newphid = phone_alloc(phone->callee->task); - if (newphid < 0) { - phones_unlock(cloned_phone, phone); - return ELIMIT; - } - - ipc_phone_connect(&phone->callee->task->phones[newphid], - cloned_phone->callee); - phones_unlock(cloned_phone, phone); - - /* Set the new phone for the callee. */ - IPC_SET_ARG1(call->data, newphid); - break; - } - case IPC_M_CLONE_ESTABLISH: - IPC_SET_ARG5(call->data, (sysarg_t) phone); - break; - case IPC_M_CONNECT_ME_TO: { - int newphid = phone_alloc(TASK); - if (newphid < 0) - return ELIMIT; - - /* Set arg5 for server */ - IPC_SET_ARG5(call->data, (sysarg_t) &TASK->phones[newphid]); - call->flags |= IPC_CALL_CONN_ME_TO; - call->priv = newphid; - break; - } - case IPC_M_SHARE_OUT: { - size_t size = as_area_get_size(IPC_GET_ARG1(call->data)); - if (!size) - return EPERM; - - IPC_SET_ARG2(call->data, size); - break; - } - case IPC_M_DATA_READ: { - size_t size = IPC_GET_ARG2(call->data); - if (size > DATA_XFER_LIMIT) { - int flags = IPC_GET_ARG3(call->data); - if (flags & IPC_XF_RESTRICT) - IPC_SET_ARG2(call->data, DATA_XFER_LIMIT); - else - return ELIMIT; - } - break; - } - case IPC_M_DATA_WRITE: { - uintptr_t src = IPC_GET_ARG1(call->data); - size_t size = IPC_GET_ARG2(call->data); - - if (size > DATA_XFER_LIMIT) { - int flags = IPC_GET_ARG3(call->data); - if (flags & IPC_XF_RESTRICT) { - size = DATA_XFER_LIMIT; - IPC_SET_ARG2(call->data, size); - } else - return ELIMIT; - } - - call->buffer = (uint8_t *) malloc(size, 0); - int rc = copy_from_uspace(call->buffer, (void *) src, size); - if (rc != 0) { - free(call->buffer); - return rc; - } - - break; - } - case IPC_M_STATE_CHANGE_AUTHORIZE: { - phone_t *sender_phone; - task_t *other_task_s; - - if (phone_get(IPC_GET_ARG5(call->data), &sender_phone) != EOK) - return ENOENT; - - mutex_lock(&sender_phone->lock); - if (sender_phone->state != IPC_PHONE_CONNECTED) { - mutex_unlock(&sender_phone->lock); - return EINVAL; - } - - other_task_s = sender_phone->callee->task; - - mutex_unlock(&sender_phone->lock); - - /* Remember the third party task hash. */ - IPC_SET_ARG5(call->data, (sysarg_t) other_task_s); - break; - } -#ifdef CONFIG_UDEBUG - case IPC_M_DEBUG: - return udebug_request_preprocess(call, phone); -#endif - default: - break; - } - - return 0; + call->request_method = IPC_GET_IMETHOD(call->data); + return SYSIPC_OP(request_preprocess, call, phone); } @@ -561,26 +241,7 @@ IPC_SET_RETVAL(call->data, EFORWARD); - if (call->flags & IPC_CALL_CONN_ME_TO) { - if (IPC_GET_RETVAL(call->data)) - phone_dealloc(call->priv); - else - IPC_SET_ARG5(call->data, call->priv); - } - - if (call->buffer) { - /* - * This must be an affirmative answer to IPC_M_DATA_READ - * or IPC_M_DEBUG/UDEBUG_M_MEM_READ... - * - */ - uintptr_t dst = IPC_GET_ARG1(call->data); - size_t size = IPC_GET_ARG2(call->data); - int rc = copy_to_uspace((void *) dst, call->buffer, size); - if (rc) - IPC_SET_RETVAL(call->data, rc); - free(call->buffer); - call->buffer = NULL; - } -} + SYSIPC_OP(answer_process, call); +} + /** Do basic kernel processing of received call request. @@ -595,23 +256,5 @@ static int process_request(answerbox_t *box, call_t *call) { - if (IPC_GET_IMETHOD(call->data) == IPC_M_CONNECT_TO_ME) { - int phoneid = phone_alloc(TASK); - if (phoneid < 0) { /* Failed to allocate phone */ - IPC_SET_RETVAL(call->data, ELIMIT); - ipc_answer(box, call); - return -1; - } - - IPC_SET_ARG5(call->data, phoneid); - } - - switch (IPC_GET_IMETHOD(call->data)) { - case IPC_M_DEBUG: - return -1; - default: - break; - } - - return 0; + return SYSIPC_OP(request_process, call, box); } @@ -745,21 +388,27 @@ { call_t *call = get_call(callid); + phone_t *phone; + bool need_old = answer_need_old(call); + bool after_forward = false; + ipc_data_t old; + int rc; + if (!call) return ENOENT; - + + if (need_old) + old = call->data; + + if (phone_get(phoneid, &phone) != EOK) { + rc = ENOENT; + goto error; + } + + if (!method_is_forwardable(IPC_GET_IMETHOD(call->data))) { + rc = EPERM; + goto error; + } + call->flags |= IPC_CALL_FORWARDED; - - phone_t *phone; - if (phone_get(phoneid, &phone) != EOK) { - IPC_SET_RETVAL(call->data, EFORWARD); - ipc_answer(&TASK->answerbox, call); - return ENOENT; - } - - if (!method_is_forwardable(IPC_GET_IMETHOD(call->data))) { - IPC_SET_RETVAL(call->data, EFORWARD); - ipc_answer(&TASK->answerbox, call); - return EPERM; - } /* @@ -797,5 +446,21 @@ } - return ipc_forward(call, phone, &TASK->answerbox, mode); + rc = ipc_forward(call, phone, &TASK->answerbox, mode); + if (rc != EOK) { + after_forward = true; + goto error; + } + + return EOK; + +error: + IPC_SET_RETVAL(call->data, EFORWARD); + (void) answer_preprocess(call, need_old ? &old : NULL); + if (after_forward) + _ipc_answer_free_call(call, false); + else + ipc_answer(&TASK->answerbox, call); + + return rc; } Index: kernel/generic/src/ipc/sysipc_ops.c =================================================================== --- kernel/generic/src/ipc/sysipc_ops.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ kernel/generic/src/ipc/sysipc_ops.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,112 @@ +/* + * Copyright (c) 2012 Jakub Jermar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup genericipc + * @{ + */ +/** @file + */ + +#include +#include +#include + +/* Forward declarations. */ +sysipc_ops_t ipc_m_connection_clone_ops; +sysipc_ops_t ipc_m_clone_establish_ops; +sysipc_ops_t ipc_m_connect_to_me_ops; +sysipc_ops_t ipc_m_connect_me_to_ops; +sysipc_ops_t ipc_m_share_out_ops; +sysipc_ops_t ipc_m_share_in_ops; +sysipc_ops_t ipc_m_data_write_ops; +sysipc_ops_t ipc_m_data_read_ops; +sysipc_ops_t ipc_m_state_change_authorize_ops; +sysipc_ops_t ipc_m_debug_ops; + +static sysipc_ops_t *sysipc_ops[] = { + [IPC_M_CONNECTION_CLONE] = &ipc_m_connection_clone_ops, + [IPC_M_CLONE_ESTABLISH] = &ipc_m_clone_establish_ops, + [IPC_M_CONNECT_TO_ME] = &ipc_m_connect_to_me_ops, + [IPC_M_CONNECT_ME_TO] = &ipc_m_connect_me_to_ops, + [IPC_M_SHARE_OUT] = &ipc_m_share_out_ops, + [IPC_M_SHARE_IN] = &ipc_m_share_in_ops, + [IPC_M_DATA_WRITE] = &ipc_m_data_write_ops, + [IPC_M_DATA_READ] = &ipc_m_data_read_ops, + [IPC_M_STATE_CHANGE_AUTHORIZE] = &ipc_m_state_change_authorize_ops, + [IPC_M_DEBUG] = &ipc_m_debug_ops +}; + +static sysipc_ops_t null_ops = { + .request_preprocess = null_request_preprocess, + .request_forget = null_request_forget, + .request_process = null_request_process, + .answer_cleanup = null_answer_cleanup, + .answer_preprocess = null_answer_preprocess, + .answer_process = null_answer_process, +}; + +int null_request_preprocess(call_t *call, phone_t *phone) +{ + return EOK; +} + +int null_request_forget(call_t *call) +{ + return EOK; +} + +int null_request_process(call_t *call, answerbox_t *box) +{ + return EOK; +} + +int null_answer_cleanup(call_t *call, ipc_data_t *data) +{ + return EOK; +} + +int null_answer_preprocess(call_t *call, ipc_data_t *data) +{ + return EOK; +} + +int null_answer_process(call_t *call) +{ + return EOK; +} + +sysipc_ops_t *sysipc_ops_get(sysarg_t imethod) +{ + if (imethod < sizeof(sysipc_ops) / (sizeof(sysipc_ops_t *))) + return sysipc_ops[imethod] ? sysipc_ops[imethod] : &null_ops; + + return &null_ops; +} + +/** @} + */ Index: kernel/generic/src/main/kinit.c =================================================================== --- kernel/generic/src/main/kinit.c (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/generic/src/main/kinit.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -69,4 +69,5 @@ #include #include +#include #include @@ -189,4 +190,26 @@ program_t programs[CONFIG_INIT_TASKS]; + // FIXME: do not propagate arguments through sysinfo + // but pass them directly to the tasks + for (i = 0; i < init.cnt; i++) { + const char *arguments = init.tasks[i].arguments; + if (str_length(arguments) == 0) + continue; + if (str_length(init.tasks[i].name) == 0) + continue; + size_t arguments_size = str_size(arguments); + + void *arguments_copy = malloc(arguments_size, 0); + if (arguments_copy == NULL) + continue; + memcpy(arguments_copy, arguments, arguments_size); + + char item_name[CONFIG_TASK_NAME_BUFLEN + 15]; + snprintf(item_name, CONFIG_TASK_NAME_BUFLEN + 15, + "init_args.%s", init.tasks[i].name); + + sysinfo_set_item_data(item_name, NULL, arguments_copy, arguments_size); + } + for (i = 0; i < init.cnt; i++) { if (init.tasks[i].paddr % FRAME_SIZE) { Index: kernel/generic/src/mm/as.c =================================================================== --- kernel/generic/src/mm/as.c (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/generic/src/mm/as.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -285,8 +285,9 @@ /** Check area conflicts with other areas. * - * @param as Address space. - * @param addr Starting virtual address of the area being tested. - * @param count Number of pages in the area being tested. - * @param avoid Do not touch this area. + * @param as Address space. + * @param addr Starting virtual address of the area being tested. + * @param count Number of pages in the area being tested. + * @param guarded True if the area being tested is protected by guard pages. + * @param avoid Do not touch this area. * * @return True if there is no conflict, false otherwise. @@ -294,8 +295,15 @@ */ NO_TRACE static bool check_area_conflicts(as_t *as, uintptr_t addr, - size_t count, as_area_t *avoid) + size_t count, bool guarded, as_area_t *avoid) { ASSERT((addr % PAGE_SIZE) == 0); ASSERT(mutex_locked(&as->lock)); + + /* + * If the addition of the supposed area address and size overflows, + * report conflict. + */ + if (overflows_into_positive(addr, P2SZ(count))) + return false; /* @@ -304,5 +312,5 @@ if (overlaps(addr, P2SZ(count), (uintptr_t) NULL, PAGE_SIZE)) return false; - + /* * The leaf node is found in O(log n), where n is proportional to @@ -328,6 +336,51 @@ if (area != avoid) { mutex_lock(&area->lock); - + + /* + * If at least one of the two areas are protected + * by the AS_AREA_GUARD flag then we must be sure + * that they are separated by at least one unmapped + * page. + */ + int const gp = (guarded || + (area->flags & AS_AREA_GUARD)) ? 1 : 0; + + /* + * The area comes from the left neighbour node, which + * means that there already are some areas in the leaf + * node, which in turn means that adding gp is safe and + * will not cause an integer overflow. + */ if (overlaps(addr, P2SZ(count), area->base, + P2SZ(area->pages + gp))) { + mutex_unlock(&area->lock); + return false; + } + + mutex_unlock(&area->lock); + } + } + + node = btree_leaf_node_right_neighbour(&as->as_area_btree, leaf); + if (node) { + area = (as_area_t *) node->value[0]; + + if (area != avoid) { + int gp; + + mutex_lock(&area->lock); + + gp = (guarded || (area->flags & AS_AREA_GUARD)) ? 1 : 0; + if (gp && overflows(addr, P2SZ(count))) { + /* + * Guard page not needed if the supposed area + * is adjacent to the end of the address space. + * We already know that the following test is + * going to fail... + */ + gp--; + } + + if (overlaps(addr, P2SZ(count + gp), area->base, P2SZ(area->pages))) { mutex_unlock(&area->lock); @@ -339,25 +392,10 @@ } - node = btree_leaf_node_right_neighbour(&as->as_area_btree, leaf); - if (node) { - area = (as_area_t *) node->value[0]; - - if (area != avoid) { - mutex_lock(&area->lock); - - if (overlaps(addr, P2SZ(count), area->base, - P2SZ(area->pages))) { - mutex_unlock(&area->lock); - return false; - } - - mutex_unlock(&area->lock); - } - } - /* Second, check the leaf node. */ btree_key_t i; for (i = 0; i < leaf->keys; i++) { area = (as_area_t *) leaf->value[i]; + int agp; + int gp; if (area == avoid) @@ -365,7 +403,18 @@ mutex_lock(&area->lock); - - if (overlaps(addr, P2SZ(count), area->base, - P2SZ(area->pages))) { + + gp = (guarded || (area->flags & AS_AREA_GUARD)) ? 1 : 0; + agp = gp; + + /* + * Sanitize the two possible unsigned integer overflows. + */ + if (gp && overflows(addr, P2SZ(count))) + gp--; + if (agp && overflows(area->base, P2SZ(area->pages))) + agp--; + + if (overlaps(addr, P2SZ(count + gp), area->base, + P2SZ(area->pages + agp))) { mutex_unlock(&area->lock); return false; @@ -392,7 +441,8 @@ * this function. * - * @param as Address space. - * @param bound Lowest address bound. - * @param size Requested size of the allocation. + * @param as Address space. + * @param bound Lowest address bound. + * @param size Requested size of the allocation. + * @param guarded True if the allocation must be protected by guard pages. * * @return Address of the beginning of unmapped address space area. @@ -401,5 +451,5 @@ */ NO_TRACE static uintptr_t as_get_unmapped_area(as_t *as, uintptr_t bound, - size_t size) + size_t size, bool guarded) { ASSERT(mutex_locked(&as->lock)); @@ -423,7 +473,15 @@ /* First check the bound address itself */ uintptr_t addr = ALIGN_UP(bound, PAGE_SIZE); - if ((addr >= bound) && - (check_area_conflicts(as, addr, pages, NULL))) - return addr; + if (addr >= bound) { + if (guarded) { + /* Leave an unmapped page between the lower + * bound and the area's start address. + */ + addr += P2SZ(1); + } + + if (check_area_conflicts(as, addr, pages, guarded, NULL)) + return addr; + } /* Eventually check the addresses behind each area */ @@ -439,7 +497,15 @@ addr = ALIGN_UP(area->base + P2SZ(area->pages), PAGE_SIZE); + + if (guarded || area->flags & AS_AREA_GUARD) { + /* We must leave an unmapped page + * between the two areas. + */ + addr += P2SZ(1); + } + bool avail = ((addr >= bound) && (addr >= area->base) && - (check_area_conflicts(as, addr, pages, area))); + (check_area_conflicts(as, addr, pages, guarded, area))); mutex_unlock(&area->lock); @@ -481,5 +547,5 @@ if (size == 0) return NULL; - + size_t pages = SIZE2FRAMES(size); @@ -487,9 +553,11 @@ if ((flags & AS_AREA_EXEC) && (flags & AS_AREA_WRITE)) return NULL; + + bool const guarded = flags & AS_AREA_GUARD; mutex_lock(&as->lock); if (*base == (uintptr_t) -1) { - *base = as_get_unmapped_area(as, bound, size); + *base = as_get_unmapped_area(as, bound, size, guarded); if (*base == (uintptr_t) -1) { mutex_unlock(&as->lock); @@ -497,6 +565,9 @@ } } - - if (!check_area_conflicts(as, *base, pages, NULL)) { + + if (overflows_into_positive(*base, size)) + return NULL; + + if (!check_area_conflicts(as, *base, pages, guarded, NULL)) { mutex_unlock(&as->lock); return NULL; @@ -776,7 +847,14 @@ /* * Growing the area. + */ + + if (overflows_into_positive(address, P2SZ(pages))) + return EINVAL; + + /* * Check for overlaps with other address space areas. */ - if (!check_area_conflicts(as, address, pages, area)) { + bool const guarded = area->flags & AS_AREA_GUARD; + if (!check_area_conflicts(as, address, pages, guarded, area)) { mutex_unlock(&area->lock); mutex_unlock(&as->lock); Index: kernel/generic/src/proc/task.c =================================================================== --- kernel/generic/src/proc/task.c (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ kernel/generic/src/proc/task.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -161,5 +161,8 @@ size_t i; for (i = 0; i < IPC_MAX_PHONES; i++) - ipc_phone_init(&task->phones[i]); + ipc_phone_init(&task->phones[i], task); + + spinlock_initialize(&task->active_calls_lock, "active_calls_lock"); + list_initialize(&task->active_calls); #ifdef CONFIG_UDEBUG @@ -203,4 +206,6 @@ event_task_init(task); + task->answerbox.active = true; + #ifdef CONFIG_UDEBUG /* Init debugging stuff */ @@ -208,4 +213,5 @@ /* Init kbox stuff */ + task->kb.box.active = true; task->kb.finished = false; #endif @@ -213,5 +219,5 @@ if ((ipc_phone_0) && (container_check(ipc_phone_0->task->container, task->container))) - ipc_phone_connect(&task->phones[0], ipc_phone_0); + (void) ipc_phone_connect(&task->phones[0], ipc_phone_0); btree_create(&task->futexes); Index: tools/toolchain.sh =================================================================== --- tools/toolchain.sh (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ tools/toolchain.sh (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -43,6 +43,6 @@ MPFR_MAIN=< +#include +#include +#include +#include +#include +#include +#include + +#include "cmds.h" +#include "cmp.h" +#include "config.h" +#include "entry.h" +#include "errors.h" +#include "util.h" + +static const char *cmdname = "cmp"; +#define CMP_VERSION "0.0.1" +#define CMP_BUFLEN 1024 + +static struct option const long_options[] = { + { "help", no_argument, 0, 'h' }, + { "version", no_argument, 0, 'v' }, + { 0, 0, 0, 0 } +}; + +/* Dispays help for cat in various levels */ +void help_cmd_cmp(unsigned int level) +{ + if (level == HELP_SHORT) { + printf("`%s' compares the contents of two files\n", cmdname); + } else { + help_cmd_cmp(HELP_SHORT); + printf( + "Usage: %s [options] \n" + "Options:\n" + " -h, --help A short option summary\n" + " -v, --version Print version information and exit\n" + "No output is printed; the return code is 1 if the files differ.\n", + cmdname); + } + + return; +} + +static int cmp_files(const char *fn0, const char *fn1) +{ + int rc = 0; + const char *fn[2] = {fn0, fn1}; + int fd[2] = {-1, -1}; + char buffer[2][CMP_BUFLEN]; + ssize_t offset[2]; + + for (int i = 0; i < 2; i++) { + fd[i] = open(fn[i], O_RDONLY); + if (fd[i] < 0) { + rc = errno; + printf("Unable to open %s\n", fn[i]); + goto end; + } + } + + do { + for (int i = 0; i < 2; i++) { + offset[i] = 0; + ssize_t size; + do { + size = read(fd[i], buffer[i] + offset[i], + CMP_BUFLEN - offset[i]); + if (size < 0) { + rc = errno; + printf("Error reading from %s\n", + fn[i]); + goto end; + } + offset[i] += size; + } while (size && offset[i] < CMP_BUFLEN); + } + + if (offset[0] != offset[1] || + bcmp(buffer[0], buffer[1], offset[0])) { + rc = 1; + goto end; + } + } while (offset[0] == CMP_BUFLEN); + +end: + if (fd[0] >= 0) + close(fd[0]); + if (fd[1] >= 0) + close(fd[1]); + return rc; +} + +/* Main entry point for cmd, accepts an array of arguments */ +int cmd_cmp(char **argv) +{ + int rc; + unsigned int argc; + int c, opt_ind; + + argc = cli_count_args(argv); + + for (c = 0, optind = 0, opt_ind = 0; c != -1;) { + c = getopt_long(argc, argv, "hv", long_options, &opt_ind); + switch (c) { + case 'h': + help_cmd_cmp(HELP_LONG); + return CMD_SUCCESS; + case 'v': + printf("%s\n", CMP_VERSION); + return CMD_SUCCESS; + } + } + + if (argc - optind != 2) { + printf("%s - incorrect number of arguments. Try `%s --help'\n", + cmdname, cmdname); + return CMD_FAILURE; + } + + rc = cmp_files(argv[optind], argv[optind + 1]); + if (rc) + return CMD_FAILURE; + else + return CMD_SUCCESS; +} Index: uspace/app/bdsh/cmds/modules/cmp/cmp.h =================================================================== --- uspace/app/bdsh/cmds/modules/cmp/cmp.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ uspace/app/bdsh/cmds/modules/cmp/cmp.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,7 @@ +#ifndef CMP_H +#define CMP_H + +/* Prototypes for the cmp command, excluding entry points */ + +#endif /* CMP_H */ + Index: uspace/app/bdsh/cmds/modules/cmp/cmp_def.h =================================================================== --- uspace/app/bdsh/cmds/modules/cmp/cmp_def.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ uspace/app/bdsh/cmds/modules/cmp/cmp_def.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,7 @@ +{ + "cmp", + "Compare the contents of two files", + &cmd_cmp, + &help_cmd_cmp, +}, + Index: uspace/app/bdsh/cmds/modules/cmp/entry.h =================================================================== --- uspace/app/bdsh/cmds/modules/cmp/entry.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ uspace/app/bdsh/cmds/modules/cmp/entry.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,9 @@ +#ifndef CMP_ENTRY_H +#define CMP_ENTRY_H + +/* Entry points for the cat command */ +extern int cmd_cmp(char **); +extern void help_cmd_cmp(unsigned int); + +#endif /* CAT_ENTRY_H */ + Index: uspace/app/bdsh/cmds/modules/modules.h =================================================================== --- uspace/app/bdsh/cmds/modules/modules.h (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ uspace/app/bdsh/cmds/modules/modules.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -63,4 +63,5 @@ #include "printf/entry.h" #include "echo/entry.h" +#include "cmp/entry.h" /* Each .def function fills the module_t struct with the individual name, entry @@ -86,4 +87,5 @@ #include "printf/printf_def.h" #include "echo/echo_def.h" +#include "cmp/cmp_def.h" {NULL, NULL, NULL, NULL} Index: uspace/app/bdsh/config.h =================================================================== --- uspace/app/bdsh/config.h (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ uspace/app/bdsh/config.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -55,6 +55,3 @@ #define PACKAGE_STRING "The brain dead shell" #define PACKAGE_TARNAME "bdsh" -#define PACKAGE_VERSION "0.0.1" - - - +#define PACKAGE_VERSION "0.1.0" Index: uspace/app/bdsh/errors.h =================================================================== --- uspace/app/bdsh/errors.h (revision fc89e32010e50e34041343fec03821fd9d0b07df) +++ uspace/app/bdsh/errors.h (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -30,4 +30,6 @@ #define ERRORS_H +#include + /* Various error levels */ #define CL_EFATAL -1 @@ -46,5 +48,6 @@ extern volatile int cli_errno; -extern void cli_error(int, const char *, ...); +extern void cli_error(int, const char *, ...) + PRINTF_ATTRIBUTE(2, 3); #endif Index: uspace/app/bithenge/Makefile =================================================================== --- uspace/app/bithenge/Makefile (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ uspace/app/bithenge/Makefile (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,37 @@ +# +# Copyright (c) 2012 Sean Bartell +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../.. +LIBS = $(LIBBITHENGE_PREFIX)/libbithenge.a $(LIBBLOCK_PREFIX)/libblock.a +EXTRA_CFLAGS = -I$(LIBBITHENGE_PREFIX)/include -D__HELENOS__ +BINARY = bithenge + +SOURCES = \ + test.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/app/bithenge/Makefile.linux =================================================================== --- uspace/app/bithenge/Makefile.linux (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ uspace/app/bithenge/Makefile.linux (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,54 @@ +# +# Copyright (c) 2012 Sean Bartell +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +CFLAGS += -fexec-charset=UTF-8 -finput-charset=UTF-8 -std=gnu99 -pipe +CFLAGS += -Wall -Wextra -Werror -Wno-clobbered -Wno-unused-parameter -Wmissing-prototypes -Werror-implicit-function-declaration -Wwrite-strings +CFLAGS += -ftrapv +CFLAGS += -g + +LIBBITHENGE_PREFIX = ../../lib/bithenge +CFLAGS += -I$(LIBBITHENGE_PREFIX)/include +LIBS += $(LIBBITHENGE_PREFIX)/libbithenge.a + +BINARY = bithenge + +SOURCES = \ + test.c + +ifdef COVERAGE + CFLAGS += -fprofile-arcs -ftest-coverage +endif + +OBJECTS := $(addsuffix .o,$(basename $(SOURCES))) + +$(BINARY): $(OBJECTS) + $(CC) $(CFLAGS) -o $@ $^ $(LIBS) + +clean: + find . -name '*.o' -follow -exec rm \{\} \; + rm -f $(BINARY) Index: uspace/app/bithenge/test.c =================================================================== --- uspace/app/bithenge/test.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) +++ uspace/app/bithenge/test.c (revision 33c29521d96b892e096419a2fd8beb867e2596f6) @@ -0,0 +1,129 @@ +/* + * Copyright (c) 2012 Sean Bartell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup bithenge + * @{ + */ +/** + * @file + * Simple program to test Bithenge. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __HELENOS__ +#include +#else +#include +#define str_error strerror +#endif + +int main(int argc, char *argv[]) +{ + int rc; + if (argc < 3) { + fprintf(stderr, "Usage: %s