--- /dev/null
+acpica-unix-*
+include
--- /dev/null
+
+
+include $(dir $(lastword $(MAKEFILE_LIST)))../../Makefile.cfg
+
+BIN := ../bin-$(ARCH)/libacpica.a
+
+_VERS := $(patsubst acpica-unix-%.tar.gz,%,$(wildcard acpica-unix-*.tar.gz))
+_VERS := $(sort $(_VERS))
+_LATEST := $(lastword $(_VERS))
+
+ifeq ($(ACPICAVER),)
+ ifeq ($(_LATEST),)
+ $(warning Unable to find an archive matching acpica-unix-%.tar.gz)
+ $(warning Go to https://www.acpica.org/downloads/ to get it)
+ $(error No ACPICA archive found)
+ endif
+
+ ifneq ($(_LATEST),$(_VERS))
+ $(warning Multiple archvies found, picked $(_LATEST))
+ endif
+ ACPICAVER := $(_LATEST)
+endif
+
+ACPICAROOT := acpica-unix-$(ACPICAVER)/
+ACPICA_ARCHIVE := acpica-unix-$(ACPICAVER).tar.gz
+COMPDIR := $(ACPICAROOT)source/components/
+KERNELDIR := ../../KernelLand/Kernel/
+
+CPPFLAGS += -I $(KERNELDIR)include -I$(KERNELDIR)arch/$(ARCHDIR)/include -D_MODULE_NAME_=\"ACPICA\"
+CPPFLAGS += -I $(ACPICAROOT)source/include -D _ACESS -D __KERNEL__
+CPPFLAGS += -D ARCH=$(ARCH) -D ARCHDIR=$(ARCHDIR) -D PLATFORM=\"$(PLATFORM)\" -D ARCHDIR_IS_$(ARCHDIR)=1 -D PLATFORM_is_$(PLATFORM)=1
+CPPFLAGS += -D KERNEL_VERSION=$(KERNEL_VERSION) -ffreestanding
+CFLAGS += -Wall -fno-stack-protector -Wstrict-prototypes -std=gnu99 -g
+
+SRCS := $(wildcard $(COMPDIR)*/*.c)
+OBJS := $(SRCS:$(COMPDIR)%.c=obj-$(ARCH)/%.o)
+
+ACENV_H := $(ACPICAROOT)source/include/platform/acenv.h
+ACACESS_H := $(ACPICAROOT)source/include/platform/acacess.h
+
+.PHONY: all clean
+
+ifeq ($(words $(SRCS)),0)
+extract: $(ACPICAROOT)
+ @echo Re-run make to compile
+endif
+
+all: $(BIN) include
+
+clean:
+ $(RM) -r obj-$(ARCH)/ include
+
+purge: clean
+ $(RM) -r $(ACPICAROOT)
+
+$(BIN): $(OBJS)
+ @mkdir -p $(dir $@)
+ @echo [AR] $@
+ @ar rcu $@ $(OBJS)
+
+include:
+ ln -s $(ACPICAROOT)source/include
+
+$(ACPICAROOT): $(ACPICA_ARCHIVE)
+ tar -xf $(ACPICA_ARCHIVE)
+
+$(ACACESS_H): acacess.h
+ cp $< $@
+
+$(ACENV_H): $(ACPICA_ARCHIVE) Makefile
+ tar -x -O -f $(ACPICA_ARCHIVE) $(ACENV_H) | sed 's/aclinux/acacess/' | sed 's/_LINUX/_ACESS/' > $@
+
+obj-$(ARCH)/%.o: $(COMPDIR)%.c $(ACENV_H) $(ACACESS_H)
+ @mkdir -p $(dir $@)
+ @echo [CC] -o $@
+ @$(CC) $(CFLAGS) $(CPPFLAGS) -o $@ -c $<
+
+-include $(OBJS:%=%.dep)
+
--- /dev/null
+CPPFLAGS += -I $(ACESSDIR)/Externals/ACPICA/include -D_ACESS -D__KERNEL__
+EXTERN_OBJS += $(ACESSDIR)/Externals/bin-$(ARCH)/libacpica.a
+
+$(ACESSDIR)/Externals/bin-$(ARCH)/libacpica.a:
+ @make -C $(ACESSDIR)/Externals/ACPICA
+ @make -C $(ACESSDIR)/Externals/ACPICA
+
+
--- /dev/null
+/******************************************************************************
+ *
+ * Name: aclinux.h - OS specific defines, etc. for Linux
+ *
+ *****************************************************************************/
+
+#ifndef _ACPICA__ACACESS_H_
+#define _ACPICA__ACACESS_H_
+
+#define ACPI_USE_SYSTEM_CLIBRARY
+#define ACPI_USE_DO_WHILE_0
+#define ACPI_MUTEX_TYPE ACPI_OSL_MUTEX
+
+//#define ACPI_DEBUG_OUTPUT 1
+
+#ifdef __KERNEL__
+
+#include <acess.h>
+
+/* Host-dependent types and defines for in-kernel ACPICA */
+
+#define ACPI_MACHINE_WIDTH BITS
+
+typedef struct sACPICache tACPICache;
+
+#define ACPI_CACHE_T tACPICache
+#define ACPI_SPINLOCK tShortSpinlock*
+#define ACPI_CPU_FLAGS unsigned long
+
+#define COMPILER_DEPENDENT_UINT64 Uint64
+#define COMPILER_DEPENDENT_INT64 Sint64
+
+#define ACPI_DIV_64_BY_32(n_hi, n_lo, d32, q32, r32) do { \
+ Uint64 rem; \
+ Sint64 num = ((Sint64)n_hi<<32)|n_lo; \
+ int sgn = 1; \
+ if(num < 0) {num = -num; sgn = -sgn; } \
+ if(d32 < 0) {d32 = -d32; sgn = -sgn; } \
+ q32 = sgn * DivMod64U( num, d32, &rem ); \
+ r32 = rem; \
+ }while(0)
+#define ACPI_SHIFT_RIGHT_64(n_hi, n_lo) do { \
+ n_lo >>= 1; \
+ if(n_hi & 1) n_lo |= (1 << 31); \
+ n_hi >>= 1; \
+ }while(0)
+
+#else /* !__KERNEL__ */
+
+#error "Kernel only"
+
+#endif /* __KERNEL__ */
+
+/* Linux uses GCC */
+
+#include "acgcc.h"
+
+
+#if 0
+#ifdef __KERNEL__
+#define ACPI_SYSTEM_XFACE
+#include <actypes.h>
+/*
+ * Overrides for in-kernel ACPICA
+ */
+static inline acpi_thread_id acpi_os_get_thread_id(void)
+{
+ return (ACPI_THREAD_ID) (unsigned long) current;
+}
+
+/*
+ * The irqs_disabled() check is for resume from RAM.
+ * Interrupts are off during resume, just like they are for boot.
+ * However, boot has (system_state != SYSTEM_RUNNING)
+ * to quiet __might_sleep() in kmalloc() and resume does not.
+ */
+static inline void *acpi_os_allocate(acpi_size size)
+{
+ return malloc(size);
+}
+
+static inline void *acpi_os_allocate_zeroed(acpi_size size)
+{
+ return calloc(size, 1);
+}
+
+static inline void *acpi_os_acquire_object(acpi_cache_t * cache)
+{
+// return kmem_cache_zalloc(cache,
+// irqs_disabled() ? GFP_ATOMIC : GFP_KERNEL);
+}
+
+#define ACPI_ALLOCATE(a) acpi_os_allocate(a)
+#define ACPI_ALLOCATE_ZEROED(a) acpi_os_allocate_zeroed(a)
+#define ACPI_FREE(a) free(a)
+
+#ifndef CONFIG_PREEMPT
+/*
+ * Used within ACPICA to show where it is safe to preempt execution
+ * when CONFIG_PREEMPT=n
+ */
+#define ACPI_PREEMPTION_POINT() \
+ do { \
+ Threads_Yield(); \
+ } while (0)
+#endif
+
+/*
+ * When lockdep is enabled, the spin_lock_init() macro stringifies it's
+ * argument and uses that as a name for the lock in debugging.
+ * By executing spin_lock_init() in a macro the key changes from "lock" for
+ * all locks to the name of the argument of acpi_os_create_lock(), which
+ * prevents lockdep from reporting false positives for ACPICA locks.
+ */
+#define AcpiOsCreateLock(__handle) \
+({ \
+ tShortlock *lock = ACPI_ALLOCATE_ZEROED(sizeof(*lock)); \
+ \
+ if (lock) { \
+ *(__handle) = lock; \
+ } \
+ lock ? AE_OK : AE_NO_MEMORY; \
+})
+
+#endif /* __KERNEL__ */
+#endif
+
+#endif /* __ACLINUX_H__ */
@$(RM) $(BIN) ../Acess2.$(ARCH).gz $(BIN).dsm ../Map.$(ARCH).txt LineCounts.$(ARCH).txt
@$(RM) -r $(OBJDIR) $(OBJ) $(DEPFILES) $(BUILDINFO_SRC)
+# Lower to avoid taking default target from 'all'
+-include $(addprefix ../../Externals/,$(addsuffix /Makefile.kinc, $(EXTERNS)))
+
+
# Creates a stripped and compressed copy of the kernel
# and installs it to the target
install: $(BIN)
# - Disassembles it
# - Increments the build count
# - Does whatever architecture defined rules
-$(BIN): $(OBJ) $(MODS) arch/$(ARCHDIR)/link.ld Makefile ../../BuildConf/$(ARCH)/Makefile.cfg ../../BuildConf/$(ARCH)/$(PLATFORM).mk
+$(BIN): $(EXTERN_OBJS) $(OBJ) $(MODS) arch/$(ARCHDIR)/link.ld Makefile ../../BuildConf/$(ARCH)/Makefile.cfg ../../BuildConf/$(ARCH)/$(PLATFORM).mk
@echo --- LD -o $(BIN)
- @$(LD) $(LDFLAGS) -o $(BIN) $(OBJ) $(MODS) $(LIBGCC_PATH) --defsym __buildnum=$$(( $(BUILD_NUM) + 1 )) -Map ../Map.$(ARCH).txt
+ @$(LD) $(LDFLAGS) -o $(BIN) $(OBJ) $(MODS) $(EXTERN_OBJS) $(LIBGCC_PATH) --defsym __buildnum=$$(( $(BUILD_NUM) + 1 )) -Map ../Map.$(ARCH).txt
@$(DISASM) -S $(BIN) > $(BIN).dsm
@echo BUILD_NUM = $$(( $(BUILD_NUM) + 1 )) > Makefile.BuildNum.$(ARCH)
$(POSTBUILD)
AS_SUFFIX = asm
-CPPFLAGS =
+CPPFLAGS =
CFLAGS =
ASFLAGS = -f elf
A_OBJ += mm_phys.o mm_virt.o
A_OBJ += proc.o proc.ao time.o vm8086.o
A_OBJ += kpanic.o pci.o vpci.o
+#A_OBJ += acpica.o
+
+#EXTERNS += ACPICA
+
--- /dev/null
+/*
+ * Acess2 Kernel (x86 Core)
+ * - By John Hodge (thePowersGang)
+ *
+ * acpica.c
+ * - ACPICA Interface
+ */
+#define DEBUG 1
+#define _AcpiModuleName "Shim"
+#define _COMPONENT "Acess"
+#include <acpi.h>
+#include <timers.h>
+#include <mutex.h>
+#include <semaphore.h>
+
+#define ONEMEG (1024*1024)
+
+// === GLOBALS ===
+// - RSDP Address from uEFI
+tPAddr gACPI_RSDPOverride = 0;
+
+// === PROTOTYPES ===
+int ACPICA_Initialise(void);
+void ACPI_int_InterruptProxy(int IRQ, void *data);
+
+
+// === CODE ===
+int ACPICA_Initialise(void)
+{
+ ACPI_STATUS rv;
+
+ #ifdef ACPI_DEBUG_OUTPUT
+ AcpiDbgLevel = ACPI_DB_ALL;
+ #endif
+
+ rv = AcpiInitializeSubsystem();
+ if( ACPI_FAILURE(rv) )
+ {
+ Log_Error("ACPI", "AcpiInitializeSubsystem: %i", rv);
+ return -1;
+ }
+
+ rv = AcpiInitializeTables(NULL, 16, FALSE);
+ if( ACPI_FAILURE(rv) )
+ {
+ Log_Error("ACPI", "AcpiInitializeTables: %i", rv);
+ AcpiTerminate();
+ return -1;
+ }
+
+ // AcpiInitializeTables?
+ rv = AcpiLoadTables();
+ if( ACPI_FAILURE(rv) )
+ {
+ Log_Error("ACPI", "AcpiLoadTables: %i", rv);
+ AcpiTerminate();
+ return -1;
+ }
+
+ rv = AcpiEnableSubsystem(ACPI_FULL_INITIALIZATION);
+ if( ACPI_FAILURE(rv) )
+ {
+ Log_Error("ACPI", "AcpiEnableSubsystem: %i", rv);
+ AcpiTerminate();
+ return -1;
+ }
+
+ return 0;
+}
+
+// ---------------
+// --- Exports ---
+// ---------------
+ACPI_STATUS AcpiOsInitialize(void)
+{
+ return AE_OK;
+}
+
+ACPI_STATUS AcpiOsTerminate(void)
+{
+ return AE_OK;
+}
+
+ACPI_PHYSICAL_ADDRESS AcpiOsGetRootPointer(void)
+{
+ ACPI_SIZE val;
+ ACPI_STATUS rv;
+
+ if( gACPI_RSDPOverride )
+ return gACPI_RSDPOverride;
+
+ rv = AcpiFindRootPointer(&val);
+ if( ACPI_FAILURE(rv) )
+ return 0;
+
+ LOG("val=%x", val);
+
+ return val;
+ // (Or use EFI)
+}
+
+ACPI_STATUS AcpiOsPredefinedOverride(const ACPI_PREDEFINED_NAMES *PredefinedObject, ACPI_STRING *NewValue)
+{
+ *NewValue = NULL;
+ return AE_OK;
+}
+
+ACPI_STATUS AcpiOsTableOverride(ACPI_TABLE_HEADER *ExisitingTable, ACPI_TABLE_HEADER **NewTable)
+{
+ *NewTable = NULL;
+ return AE_OK;
+}
+
+ACPI_STATUS AcpiOsPhysicalTableOverride(ACPI_TABLE_HEADER *ExisitingTable, ACPI_PHYSICAL_ADDRESS *NewAddress, UINT32 *NewTableLength)
+{
+ *NewAddress = 0;
+ return AE_OK;
+}
+
+// -- Memory Management ---
+struct sACPICache
+{
+ Uint16 nObj;
+ Uint16 ObjectSize;
+ char *Name;
+ void *First;
+ char ObjectStates[];
+};
+
+ACPI_STATUS AcpiOsCreateCache(char *CacheName, UINT16 ObjectSize, UINT16 MaxDepth, ACPI_CACHE_T **ReturnCache)
+{
+ tACPICache *ret;
+ int namelen = (CacheName ? strlen(CacheName) : 0) + 1;
+ LOG("CacheName=%s, ObjSize=%x, MaxDepth=%x", CacheName, ObjectSize, MaxDepth);
+
+ ret = malloc(sizeof(*ret) + MaxDepth*sizeof(char) + namelen + MaxDepth*ObjectSize);
+ if( !ret ) return AE_NO_MEMORY;
+
+ ret->nObj = MaxDepth;
+ ret->ObjectSize = ObjectSize;
+ ret->Name = (char*)(ret->ObjectStates + MaxDepth);
+ ret->First = ret->Name + namelen;
+ if( CacheName )
+ strcpy(ret->Name, CacheName);
+ else
+ ret->Name[0] = 0;
+ memset(ret->ObjectStates, 0, sizeof(char)*MaxDepth);
+
+ LOG("Allocated cache '%s' (%i x 0x%x)", CacheName, MaxDepth, ObjectSize);
+
+ *ReturnCache = ret;
+
+ return AE_OK;
+}
+
+ACPI_STATUS AcpiOsDeleteCache(ACPI_CACHE_T *Cache)
+{
+ if( Cache == NULL )
+ return AE_BAD_PARAMETER;
+
+ free(Cache);
+ return AE_OK;
+}
+
+ACPI_STATUS AcpiOsPurgeCache(ACPI_CACHE_T *Cache)
+{
+ if( Cache == NULL )
+ return AE_BAD_PARAMETER;
+
+ memset(Cache->ObjectStates, 0, sizeof(char)*Cache->nObj);
+
+ return AE_OK;
+}
+
+void *AcpiOsAcquireObject(ACPI_CACHE_T *Cache)
+{
+ LOG("(Cache=%p)", Cache);
+ for(int i = 0; i < Cache->nObj; i ++ )
+ {
+ if( !Cache->ObjectStates[i] ) {
+ Cache->ObjectStates[i] = 1;
+ return (char*)Cache->First + i*Cache->ObjectSize;
+ }
+ }
+ // TODO
+ return NULL;
+}
+
+ACPI_STATUS AcpiOsReleaseObject(ACPI_CACHE_T *Cache, void *Object)
+{
+ if( Cache == NULL || Object == NULL )
+ return AE_BAD_PARAMETER;
+
+ tVAddr delta = (tVAddr)Object - (tVAddr)Cache->First;
+ delta /= Cache->ObjectSize;
+
+ if( delta > Cache->nObj )
+ return AE_BAD_PARAMETER;
+
+ Cache->ObjectStates[delta] = 0;
+
+ return AE_OK;
+}
+
+void *AcpiOsMapMemory(ACPI_PHYSICAL_ADDRESS PhysicalAddress, ACPI_SIZE Length)
+{
+ if( PhysicalAddress < ONEMEG )
+ return (void*)(KERNEL_BASE | PhysicalAddress);
+
+ Uint ofs = PhysicalAddress & (PAGE_SIZE-1);
+ int npages = (ofs + Length + (PAGE_SIZE-1)) / PAGE_SIZE;
+ void *rv = ((char*)MM_MapHWPages(PhysicalAddress, npages)) + ofs;
+ LOG("Map (%P+%i pg) to %p", PhysicalAddress, npages, rv);
+ return rv;
+}
+
+void AcpiOsUnmapMemory(void *LogicalAddress, ACPI_SIZE Length)
+{
+ if( (tVAddr)LogicalAddress - KERNEL_BASE < ONEMEG )
+ return ;
+
+ LOG("%p", LogicalAddress);
+
+ Uint ofs = (tVAddr)LogicalAddress & (PAGE_SIZE-1);
+ int npages = (ofs + Length + (PAGE_SIZE-1)) / PAGE_SIZE;
+ // TODO: Validate `Length` is the same as was passed to AcpiOsMapMemory
+ MM_UnmapHWPages( (tVAddr)LogicalAddress, npages);
+}
+
+ACPI_STATUS AcpiOsGetPhysicalAddress(void *LogicalAddress, ACPI_PHYSICAL_ADDRESS *PhysicalAddress)
+{
+ if( LogicalAddress == NULL || PhysicalAddress == NULL )
+ return AE_BAD_PARAMETER;
+
+ tPAddr rv = MM_GetPhysAddr(LogicalAddress);
+ if( rv == 0 )
+ return AE_ERROR;
+ *PhysicalAddress = rv;
+ return AE_OK;
+}
+
+void *AcpiOsAllocate(ACPI_SIZE Size)
+{
+ return malloc(Size);
+}
+
+void AcpiOsFree(void *Memory)
+{
+ return free(Memory);
+}
+
+BOOLEAN AcpiOsReadable(void *Memory, ACPI_SIZE Length)
+{
+ return CheckMem(Memory, Length);
+}
+
+BOOLEAN AcpiOsWritable(void *Memory, ACPI_SIZE Length)
+{
+ // TODO: Actually check if it's writable
+ return CheckMem(Memory, Length);
+}
+
+
+// --- Threads ---
+ACPI_THREAD_ID AcpiOsGetThreadId(void)
+{
+ return Threads_GetTID() + 1;
+}
+
+ACPI_STATUS AcpiOsExecute(ACPI_EXECUTE_TYPE Type, ACPI_OSD_EXEC_CALLBACK Function, void *Context)
+{
+ // TODO: Need to store currently executing functions
+ if( Function == NULL )
+ return AE_BAD_PARAMETER;
+ Proc_SpawnWorker(Function, Context);
+ return AE_OK;
+}
+
+void AcpiOsSleep(UINT64 Milliseconds)
+{
+ Time_Delay(Milliseconds);
+}
+
+void AcpiOsStall(UINT32 Microseconds)
+{
+ // TODO: need a microsleep function
+ Microseconds += (1000-1);
+ Microseconds /= 1000;
+ Time_Delay(Microseconds);
+}
+
+void AcpiOsWaitEventsComplete(void)
+{
+ // TODO:
+}
+
+// --- Mutexes etc ---
+ACPI_STATUS AcpiOsCreateMutex(ACPI_MUTEX *OutHandle)
+{
+ LOG("()");
+ if( !OutHandle )
+ return AE_BAD_PARAMETER;
+ tMutex *ret = calloc( sizeof(tMutex), 1 );
+ if( !ret )
+ return AE_NO_MEMORY;
+ ret->Name = "AcpiOsCreateMutex";
+ *OutHandle = ret;
+
+ return AE_OK;
+}
+
+void AcpiOsDeleteMutex(ACPI_MUTEX Handle)
+{
+ Mutex_Acquire(Handle);
+ free(Handle);
+}
+
+ACPI_STATUS AcpiOsAcquireMutex(ACPI_MUTEX Handle, UINT16 Timeout)
+{
+ if( Handle == NULL )
+ return AE_BAD_PARAMETER;
+
+ Mutex_Acquire(Handle);
+
+ return AE_OK;
+}
+
+void AcpiOsReleaseMutex(ACPI_MUTEX Handle)
+{
+ Mutex_Release(Handle);
+}
+
+ACPI_STATUS AcpiOsCreateSemaphore(UINT32 MaxUnits, UINT32 InitialUnits, ACPI_SEMAPHORE *OutHandle)
+{
+ LOG("(MaxUnits=%i,InitialUnits=%i)", MaxUnits, InitialUnits);
+ if( !OutHandle )
+ return AE_BAD_PARAMETER;
+ tSemaphore *ret = calloc( sizeof(tSemaphore), 1 );
+ if( !ret )
+ return AE_NO_MEMORY;
+
+ Semaphore_Init(ret, InitialUnits, MaxUnits, "AcpiOsCreateSemaphore", "");
+ *OutHandle = ret;
+ return AE_OK;
+}
+
+ACPI_STATUS AcpiOsDeleteSemaphore(ACPI_SEMAPHORE Handle)
+{
+ if( !Handle )
+ return AE_BAD_PARAMETER;
+
+ free(Handle);
+
+ return AE_OK;
+}
+
+ACPI_STATUS AcpiOsWaitSemaphore(ACPI_SEMAPHORE Handle, UINT32 Units, UINT16 Timeout)
+{
+ if( !Handle )
+ return AE_BAD_PARAMETER;
+
+ // Special case
+ if( Timeout == 0 )
+ {
+ // NOTE: Possible race condition
+ if( Semaphore_GetValue(Handle) >= Units ) {
+ Semaphore_Wait(Handle, Units);
+ return AE_OK;
+ }
+ return AE_TIME;
+ }
+
+ tTime start = now();
+ UINT32 rem = Units;
+ while(rem && now() - start < Timeout)
+ {
+ rem -= Semaphore_Wait(Handle, rem);
+ }
+
+ if( rem ) {
+ Semaphore_Signal(Handle, Units - rem);
+ return AE_TIME;
+ }
+
+ return AE_OK;
+}
+
+ACPI_STATUS AcpiOsSignalSemaphore(ACPI_SEMAPHORE Handle, UINT32 Units)
+{
+ if( !Handle )
+ return AE_BAD_PARAMETER;
+
+ // TODO: Support AE_LIMIT detection early (to avoid blocks)
+
+ // NOTE: Blocks
+ int rv = Semaphore_Signal(Handle, Units);
+ if( rv != Units )
+ return AE_LIMIT;
+
+ return AE_OK;
+}
+
+ACPI_STATUS AcpiOsCreateLock(ACPI_SPINLOCK *OutHandle)
+{
+ LOG("()");
+ if( !OutHandle )
+ return AE_BAD_PARAMETER;
+ tShortSpinlock *lock = calloc(sizeof(tShortSpinlock), 1);
+ if( !lock )
+ return AE_NO_MEMORY;
+
+ *OutHandle = lock;
+ return AE_OK;
+}
+
+void AcpiOsDeleteLock(ACPI_SPINLOCK Handle)
+{
+ free(Handle);
+}
+
+ACPI_CPU_FLAGS AcpiOsAcquireLock(ACPI_SPINLOCK Handle)
+{
+ SHORTLOCK(Handle);
+ return 0;
+}
+
+void AcpiOsReleaseLock(ACPI_SPINLOCK Handle, ACPI_CPU_FLAGS Flags)
+{
+ SHORTREL(Handle);
+}
+
+// --- Interrupt handling ---
+#define N_INT_LEVELS 16
+ACPI_OSD_HANDLER gaACPI_InterruptHandlers[N_INT_LEVELS];
+void *gaACPI_InterruptData[N_INT_LEVELS];
+ int gaACPI_InterruptHandles[N_INT_LEVELS];
+
+void ACPI_int_InterruptProxy(int IRQ, void *data)
+{
+ if( !gaACPI_InterruptHandlers[IRQ] )
+ return ;
+ gaACPI_InterruptHandlers[IRQ](gaACPI_InterruptData[IRQ]);
+}
+
+ACPI_STATUS AcpiOsInstallInterruptHandler(UINT32 InterruptLevel, ACPI_OSD_HANDLER Handler, void *Context)
+{
+ if( InterruptLevel >= N_INT_LEVELS || Handler == NULL )
+ return AE_BAD_PARAMETER;
+ if( gaACPI_InterruptHandlers[InterruptLevel] )
+ return AE_ALREADY_EXISTS;
+
+ gaACPI_InterruptHandlers[InterruptLevel] = Handler;
+ gaACPI_InterruptData[InterruptLevel] = Context;
+
+ gaACPI_InterruptHandles[InterruptLevel] = IRQ_AddHandler(InterruptLevel, ACPI_int_InterruptProxy, NULL);
+ return AE_OK;
+}
+
+ACPI_STATUS AcpiOsRemoveInterruptHandler(UINT32 InterruptLevel, ACPI_OSD_HANDLER Handler)
+{
+ if( InterruptLevel >= N_INT_LEVELS || Handler == NULL )
+ return AE_BAD_PARAMETER;
+ if( gaACPI_InterruptHandlers[InterruptLevel] != Handler )
+ return AE_NOT_EXIST;
+ gaACPI_InterruptHandlers[InterruptLevel] = NULL;
+ IRQ_RemHandler(gaACPI_InterruptHandles[InterruptLevel]);
+ return AE_OK;
+}
+
+// --- Memory Access ---
+ACPI_STATUS AcpiOsReadMemory(ACPI_PHYSICAL_ADDRESS Address, UINT64 *Value, UINT32 Width)
+{
+ void *ptr;
+ if( Address < ONEMEG ) {
+ ptr = (void*)(KERNEL_BASE | Address);
+ }
+ else {
+ ptr = (char*)MM_MapTemp(Address) + (Address & 0xFFF);
+ }
+
+ switch(Width)
+ {
+ case 8: *Value = *(Uint8 *)ptr; break;
+ case 16: *Value = *(Uint16*)ptr; break;
+ case 32: *Value = *(Uint32*)ptr; break;
+ case 64: *Value = *(Uint64*)ptr; break;
+ }
+
+ if( Address >= ONEMEG ) {
+ MM_FreeTemp(ptr);
+ }
+
+ return AE_OK;
+}
+
+ACPI_STATUS AcpiOsWriteMemory(ACPI_PHYSICAL_ADDRESS Address, UINT64 Value, UINT32 Width)
+{
+ void *ptr;
+ if( Address < ONEMEG ) {
+ ptr = (void*)(KERNEL_BASE | Address);
+ }
+ else {
+ ptr = (char*)MM_MapTemp(Address) + (Address & 0xFFF);
+ }
+
+ switch(Width)
+ {
+ case 8: *(Uint8 *)ptr = Value; break;
+ case 16: *(Uint16*)ptr = Value; break;
+ case 32: *(Uint32*)ptr = Value; break;
+ case 64: *(Uint64*)ptr = Value; break;
+ default:
+ return AE_BAD_PARAMETER;
+ }
+
+ if( Address >= 1024*1024 ) {
+ MM_FreeTemp(ptr);
+ }
+
+ return AE_OK;
+}
+
+// --- Port Input / Output ---
+ACPI_STATUS AcpiOsReadPort(ACPI_IO_ADDRESS Address, UINT32 *Value, UINT32 Width)
+{
+ switch(Width)
+ {
+ case 8: *Value = inb(Address); break;
+ case 16: *Value = inw(Address); break;
+ case 32: *Value = ind(Address); break;
+ default:
+ return AE_BAD_PARAMETER;
+ }
+ return AE_OK;
+}
+
+ACPI_STATUS AcpiOsWritePort(ACPI_IO_ADDRESS Address, UINT32 Value, UINT32 Width)
+{
+ switch(Width)
+ {
+ case 8: outb(Address, Value); break;
+ case 16: outw(Address, Value); break;
+ case 32: outd(Address, Value); break;
+ default:
+ return AE_BAD_PARAMETER;
+ }
+ return AE_OK;
+}
+
+// --- PCI Configuration Space Access ---
+ACPI_STATUS AcpiOsReadPciConfiguration(ACPI_PCI_ID *PciId, UINT32 Register, UINT64 *Value, UINT32 Width)
+{
+ UNIMPLEMENTED();
+ return AE_NOT_IMPLEMENTED;
+}
+
+ACPI_STATUS AcpiOsWritePciConfiguration(ACPI_PCI_ID *PciId, UINT32 Register, UINT64 Value, UINT32 Width)
+{
+ UNIMPLEMENTED();
+ return AE_NOT_IMPLEMENTED;
+}
+
+// --- Formatted Output ---
+void AcpiOsPrintf(const char *Format, ...)
+{
+ va_list args;
+ va_start(args, Format);
+
+ LogFV(Format, args);
+
+ va_end(args);
+}
+
+void AcpiOsVprintf(const char *Format, va_list Args)
+{
+ LogFV(Format, Args);
+}
+
+void AcpiOsRedirectOutput(void *Destination)
+{
+ // TODO: Do I even need to impliment this?
+}
+
+// --- Miscellaneous ---
+UINT64 AcpiOsGetTimer(void)
+{
+ return now() * 10 * 1000;
+}
+
+ACPI_STATUS AcpiOsSignal(UINT32 Function, void *Info)
+{
+ switch(Function)
+ {
+ case ACPI_SIGNAL_FATAL: {
+ ACPI_SIGNAL_FATAL_INFO *finfo = Info;
+ Log_Error("ACPI AML", "Fatal %x %x %x", finfo->Type, finfo->Code, finfo->Argument);
+ break; }
+ case ACPI_SIGNAL_BREAKPOINT: {
+ Log_Notice("ACPI AML", "Breakpoint %s", Info);
+ break; };
+ }
+ return AE_OK;
+}
+
+ACPI_STATUS AcpiOsGetLine(char *Buffer, UINT32 BufferLength, UINT32 *BytesRead)
+{
+ UNIMPLEMENTED();
+ return AE_NOT_IMPLEMENTED;
+}
+
#if LOCK_DISABLE_INTS
int IF; //!< Interrupt state on call to SHORTLOCK
#endif
+ void *LockedBy;
};
// === MACROS ===
typedef signed short Sint16;
typedef signed long Sint32;
typedef signed long long Sint64;
-typedef Uint size_t;
typedef char BOOL;
typedef Uint32 tPAddr;
Log_Log("IRQ", "Added IRQ%i Cb#%i %p", Num, i, Callback);
gIRQ_Handlers[Num][i] = Callback;
gaIRQ_DataPointers[Num][i] = Ptr;
- return 1;
+ return Num * MAX_CALLBACKS_PER_IRQ + i;
}
}
Log_Warning("IRQ", "No free callbacks on IRQ%i", Num);
- return 0;
+ return -1;
+}
+
+void IRQ_RemHandler(int Handle)
+{
+ int Num = Handle / MAX_CALLBACKS_PER_IRQ;
+ int id = Handle % MAX_CALLBACKS_PER_IRQ;
+ gIRQ_Handlers[Num][id] = NULL;
}
__ASM__ ("pushf;\n\tpop %0" : "=r"(IF));
IF &= 0x200; // AND out all but the interrupt flag
+ if( CPU_HAS_LOCK(Lock) )
+ {
+ Panic("Double lock of %p, %p req, %p has", Lock, __builtin_return_address(0), Lock->LockedBy);
+ for(;;);
+ }
+
#if TRACE_LOCKS
if( TRACE_LOCK_COND )
{
// Wait for another CPU to release
__AtomicTestSetLoop( (Uint*)&Lock->Lock, cpu );
Lock->IF = IF;
+ Lock->LockedBy = __builtin_return_address(0);
#if TRACE_LOCKS
if( TRACE_LOCK_COND )
extern void MM_Install(int NPMemRanges, tPMemMapEnt *PMemRanges);
extern void MM_InstallVirtual(void);
extern int Time_Setup(void);
+//extern int ACPICA_Initialise(void);
// === PROTOTYPES ===
int kmain(Uint MbMagic, void *MbInfoPtr);
MM_InstallVirtual(); // Clean up virtual address space
Heap_Install(); // Create initial heap
+ Time_Setup(); // Initialise timing
// Start Multitasking
Threads_Init();
-
- // Start Timers
- Time_Setup();
-
+
+ // Poke ACPICA
+// ACPICA_Initialise();
+
Log_Log("Arch", "Starting VFS...");
// Load Virtual Filesystem
VFS_Init();
gaPageReferences = (void*)MM_REFCOUNT_BASE;
+ Log_Debug("PMem", "maxAddr = %P", maxAddr);
Log_Log("PMem", "Physical memory set up (%lli pages of ~%lli MiB used)",
giPhysAlloc, (giTotalMemorySize*PAGE_SIZE)/(1024*1024)
);
Mutex_Release( &glPhysAlloc );
LEAVE('X', ret);
+ if( ret == 0x17FFE000 )
+ LogF("TRIP!\n");
#if TRACE_ALLOCS
if( now() > 4000 ) {
Log_Debug("PMem", "MM_AllocPhys: RETURN %P (%i free)", ret, giPageCount-giPhysAlloc);
*(Uint16*)(KERNEL_BASE|0x469) = 0xFFFF;
outb(0x70, 0x0F); outb(0x71, 0x0A); // Set warm reset flag
MP_SendIPI(gaCPUs[CPU].APICID, 0, 5); // Init IPI
-
- // Delay
- inb(0x80); inb(0x80); inb(0x80); inb(0x80);
-
+
+ // Take a quick nap (20ms)
+ Time_Delay(20);
+
// TODO: Use a better address, preferably registered with the MM
// - MM_AllocDMA mabye?
// Create a far jump
*(Uint8*)(KERNEL_BASE|0x11000) = 0xEA; // Far JMP
- *(Uint16*)(KERNEL_BASE|0x11001) = (Uint)&APStartup - (KERNEL_BASE|0xFFFF0); // IP
+ *(Uint16*)(KERNEL_BASE|0x11001) = (Uint16)&APStartup + 0x10; // IP
*(Uint16*)(KERNEL_BASE|0x11003) = 0xFFFF; // CS
+
+ giNumInitingCPUs ++;
+
// Send a Startup-IPI to make the CPU execute at 0x11000 (which we
// just filled)
MP_SendIPI(gaCPUs[CPU].APICID, 0x11, 6); // StartupIPI
- giNumInitingCPUs ++;
+ tTime timeout = now() + 2;
+ while( giNumInitingCPUs && now() > timeout )
+ HALT();
+
+ if( giNumInitingCPUs == 0 )
+ return ;
+
+ // First S-IPI failed, send again
+ MP_SendIPI(gaCPUs[CPU].APICID, 0x11, 6);
+ timeout = now() + 2;
+ while( giNumInitingCPUs && now() > timeout )
+ HALT();
+ if( giNumInitingCPUs == 0 )
+ return ;
+
+ Log_Notice("Proc", "CPU %i (APIC %x) didn't come up", CPU, gaCPUs[CPU].APICID);
+
+ // Oh dammit.
+ giNumInitingCPUs = 0;
}
void MP_SendIPIVector(int CPU, Uint8 Vector)
// Hi
val = (Uint)APICID << 24;
-// Log("%p = 0x%08x", &gpMP_LocalAPIC->ICR[1], val);
gpMP_LocalAPIC->ICR[1].Val = val;
// Low (and send)
val = ((DeliveryMode & 7) << 8) | (Vector & 0xFF);
-// Log("%p = 0x%08x", &gpMP_LocalAPIC->ICR[0], val);
gpMP_LocalAPIC->ICR[0].Val = val;
}
#endif
void Proc_Start(void)
{
#if USE_MP
- int i;
- #endif
+ // BSP still should run the current task
+ gaCPUs[giProc_BootProcessorID].Current = &gThreadZero;
+
+ __asm__ __volatile__ ("sti");
- #if USE_MP
// Start APs
- for( i = 0; i < giNumCPUs; i ++ )
+ for( int i = 0; i < giNumCPUs; i ++ )
{
- if(i) gaCPUs[i].Current = NULL;
-
+ if(i != giProc_BootProcessorID)
+ gaCPUs[i].Current = NULL;
+
// Create Idle Task
Proc_NewKThread(Proc_IdleThread, &gaCPUs[i]);
MP_StartAP( i );
}
}
-
- // BSP still should run the current task
- gaCPUs[0].Current = &gThreadZero;
-
- // Start interrupts and wait for APs to come up
- Log_Debug("Proc", "Waiting for APs to come up");
- __asm__ __volatile__ ("sti");
- while( giNumInitingCPUs ) __asm__ __volatile__ ("hlt");
#else
// Create Idle Task
Proc_NewKThread(Proc_IdleThread, &gaCPUs[0]);
; Load initial GDT
mov ax, 0xFFFF
mov ds, ax
- lgdt [DWORD ds:lGDTPtr-KERNEL_BASE-0xFFFF0]
+ lgdt [DWORD ds:lGDTPtr-0xFFFF0]
; Enable PMode in CR0
mov eax, cr0
or al, 1
}\r
#define AddLoaded(a,b) do{}while(0)\r
#define LoadLibrary(a,b,c) (Log_Debug("ELF", "Module requested lib '%s'",a),0)\r
-#define SysSetMemFlags(ad,f,m) do{}while(0)\r
+#define _SysSetMemFlags(ad,f,m) do{}while(0)\r
#include "../../../Usermode/Libraries/ld-acess.so_src/elf.c"\r
// ---- / ----\r
\r
SHORTREL(&glDebug_Lock);
#endif
}
-/**
- * \fn void Log(const char *Msg, ...)
- */
-void Log(const char *Fmt, ...)
+
+
+void LogFV(const char *Fmt, va_list args)
{
- va_list args;
+ #if LOCK_DEBUG_OUTPUT
+ SHORTLOCK(&glDebug_Lock);
+ #endif
+
+ Debug_Fmt(1, Fmt, args);
+ #if LOCK_DEBUG_OUTPUT
+ SHORTREL(&glDebug_Lock);
+ #endif
+}
+
+void LogV(const char *Fmt, va_list args)
+{
#if LOCK_DEBUG_OUTPUT
SHORTLOCK(&glDebug_Lock);
#endif
Debug_Puts(1, "Log: ");
- va_start(args, Fmt);
Debug_Fmt(1, Fmt, args);
- va_end(args);
Debug_Puts(1, "\r\n");
#if LOCK_DEBUG_OUTPUT
SHORTREL(&glDebug_Lock);
#endif
}
+
+/**
+ * \fn void Log(const char *Msg, ...)
+ */
+void Log(const char *Fmt, ...)
+{
+ va_list args;
+ va_start(args, Fmt);
+ LogV(Fmt, args);
+ va_end(args);
+}
+
void Warning(const char *Fmt, ...)
{
va_list args;
* \brief Acess2 Kernel API Core
*/
+#include <stddef.h>
#include <arch.h>
-//! NULL Pointer
-#define NULL ((void*)0)
//! Pack a structure
#define PACKED __attribute__((packed))
//! Mark a function as not returning
#define DEPRECATED __attribute__((deprecated))
//! Mark a parameter as unused
#define UNUSED(x) UNUSED_##x __attribute__((unused))
-//! Get the offset of a member in a structure
-#define offsetof(st, m) ((Uint)((char *)&((st *)(0))->m - (char *)0 ))
/**
* \name Boolean constants
#ifndef _ERRNO_H
#define _ERRNO_H
-enum eErrorNums
-{
- EOK,
-
- ENOSYS, // Invalid Instruction
- EINVAL, // Invalid Paramater
- ENOMEM, // No free memory
- EACCES, // Not permitted
- EBUSY, // Resource is busy
- ENOTFOUND, // Item not found
- EREADONLY, // Read only
- ENOTIMPL, // Not implemented
- ENOENT, // No entry?
- EEXIST, // Already exists
- ENFILE, // Too many open files
- ENOTDIR, // Not a directory
- EIO, // IO Error
- EINTR, // Operation interrupted (signal)
-
- EALREADY, // Operation was a NOP
- EINTERNAL, // Internal Error
-
- NUM_ERRS
-};
+#include "../../../Usermode/Libraries/libc.so_src/include_exp/errno.enum.h"
#endif
#define SYS_SETGID 42 // Set current Group ID
#define SYS_OPEN 64 // Open a file
#define SYS_REOPEN 65 // Close a file and reuse its handle
-#define SYS_CLOSE 66 // Close a file
-#define SYS_READ 67 // Read from an open file
-#define SYS_WRITE 68 // Write to an open file
-#define SYS_IOCTL 69 // Perform an IOCtl Call
-#define SYS_SEEK 70 // Seek to a new position in the file
-#define SYS_READDIR 71 // Read from an open directory
-#define SYS_OPENCHILD 72 // Open a child entry in a directory
-#define SYS_GETACL 73 // Get an ACL Value
-#define SYS_SETACL 74 // Set an ACL Value
-#define SYS_FINFO 75 // Get file information
-#define SYS_MKDIR 76 // Create a new directory
-#define SYS_LINK 77 // Create a new link to a file
-#define SYS_SYMLINK 78 // Create a symbolic link
-#define SYS_UNLINK 79 // Delete a file
-#define SYS_TELL 80 // Return the current file position
-#define SYS_CHDIR 81 // Change current directory
-#define SYS_GETCWD 82 // Get current directory
-#define SYS_MOUNT 83 // Mount a filesystem
-#define SYS_SELECT 84 // Wait for file handles
+#define SYS_OPENCHILD 66 // Open a child entry in a directory
+#define SYS_OPENPIPE 67 // Open a FIFO pipe pair
+#define SYS_CLOSE 68 // Close a file
+#define SYS_COPYFD 69 // Create a copy of a file handle
+#define SYS_FDCTL 70 // Modify properties of a file descriptor
+#define SYS_READ 71 // Read from an open file
+#define SYS_WRITE 72 // Write to an open file
+#define SYS_IOCTL 73 // Perform an IOCtl Call
+#define SYS_SEEK 74 // Seek to a new position in the file
+#define SYS_READDIR 75 // Read from an open directory
+#define SYS_GETACL 76 // Get an ACL Value
+#define SYS_SETACL 77 // Set an ACL Value
+#define SYS_FINFO 78 // Get file information
+#define SYS_MKDIR 79 // Create a new directory
+#define SYS_LINK 80 // Create a new link to a file
+#define SYS_SYMLINK 81 // Create a symbolic link
+#define SYS_UNLINK 82 // Delete a file
+#define SYS_TELL 83 // Return the current file position
+#define SYS_CHDIR 84 // Change current directory
+#define SYS_GETCWD 85 // Get current directory
+#define SYS_MOUNT 86 // Mount a filesystem
+#define SYS_SELECT 87 // Wait for file handles
-#define NUM_SYSCALLS 85
+#define NUM_SYSCALLS 88
#define SYS_DEBUG 0x100
#ifndef __ASSEMBLER__
"",
"SYS_OPEN",
"SYS_REOPEN",
+ "SYS_OPENCHILD",
+ "SYS_OPENPIPE",
"SYS_CLOSE",
+ "SYS_COPYFD",
+ "SYS_FDCTL",
"SYS_READ",
"SYS_WRITE",
"SYS_IOCTL",
"SYS_SEEK",
"SYS_READDIR",
- "SYS_OPENCHILD",
"SYS_GETACL",
"SYS_SETACL",
"SYS_FINFO",
%define SYS_SETGID 42 ;Set current Group ID
%define SYS_OPEN 64 ;Open a file
%define SYS_REOPEN 65 ;Close a file and reuse its handle
-%define SYS_CLOSE 66 ;Close a file
-%define SYS_READ 67 ;Read from an open file
-%define SYS_WRITE 68 ;Write to an open file
-%define SYS_IOCTL 69 ;Perform an IOCtl Call
-%define SYS_SEEK 70 ;Seek to a new position in the file
-%define SYS_READDIR 71 ;Read from an open directory
-%define SYS_OPENCHILD 72 ;Open a child entry in a directory
-%define SYS_GETACL 73 ;Get an ACL Value
-%define SYS_SETACL 74 ;Set an ACL Value
-%define SYS_FINFO 75 ;Get file information
-%define SYS_MKDIR 76 ;Create a new directory
-%define SYS_LINK 77 ;Create a new link to a file
-%define SYS_SYMLINK 78 ;Create a symbolic link
-%define SYS_UNLINK 79 ;Delete a file
-%define SYS_TELL 80 ;Return the current file position
-%define SYS_CHDIR 81 ;Change current directory
-%define SYS_GETCWD 82 ;Get current directory
-%define SYS_MOUNT 83 ;Mount a filesystem
-%define SYS_SELECT 84 ;Wait for file handles
+%define SYS_OPENCHILD 66 ;Open a child entry in a directory
+%define SYS_OPENPIPE 67 ;Open a FIFO pipe pair
+%define SYS_CLOSE 68 ;Close a file
+%define SYS_COPYFD 69 ;Create a copy of a file handle
+%define SYS_FDCTL 70 ;Modify properties of a file descriptor
+%define SYS_READ 71 ;Read from an open file
+%define SYS_WRITE 72 ;Write to an open file
+%define SYS_IOCTL 73 ;Perform an IOCtl Call
+%define SYS_SEEK 74 ;Seek to a new position in the file
+%define SYS_READDIR 75 ;Read from an open directory
+%define SYS_GETACL 76 ;Get an ACL Value
+%define SYS_SETACL 77 ;Set an ACL Value
+%define SYS_FINFO 78 ;Get file information
+%define SYS_MKDIR 79 ;Create a new directory
+%define SYS_LINK 80 ;Create a new link to a file
+%define SYS_SYMLINK 81 ;Create a symbolic link
+%define SYS_UNLINK 82 ;Delete a file
+%define SYS_TELL 83 ;Return the current file position
+%define SYS_CHDIR 84 ;Change current directory
+%define SYS_GETCWD 85 ;Get current directory
+%define SYS_MOUNT 86 ;Mount a filesystem
+%define SYS_SELECT 87 ;Wait for file handles
}
// Four Byte
- if( (*str & 0xF1) == 0xF0 ) {
+ if( (*str & 0xF8) == 0xF0 ) {
outval = (*str & 0x07) << 18; // Upper 3 Bits
str ++;
if( (*str & 0xC0) != 0x80) return 2; // Validity check
#define RANDOM_SPRUCE 0xf12b039
// === PROTOTYPES ===
+unsigned long long strtoull(const char *str, char **end, int base);
+unsigned long strtoul(const char *str, char **end, int base);
+signed long long strtoll(const char *str, char **end, int base);
+signed long strtol(const char *str, char **end, int base);
#if 0
int atoi(const char *string);
int ParseInt(const char *string, int *Val);
EXPORT(CheckMem);
// === CODE ===
-/**
- * \brief Convert a string into an integer
- */
-int atoi(const char *string)
-{
- int ret = 0;
- ParseInt(string, &ret);
- return ret;
-}
+// - Import userland stroi.c file
+#define _LIB_H_
+#include "../../Usermode/Libraries/libc.so_src/strtoi.c"
+
int ParseInt(const char *string, int *Val)
{
int ret = 0;
if(!p) p = "(null)";
len = strlen(p);
if( !bPadLeft ) while(len++ < minSize) PUTCH(pad);
- while(*p && precision--) PUTCH(*p++);
+ while(*p && precision--) { PUTCH(*p); p++;}
if( bPadLeft ) while(len++ < minSize) PUTCH(pad);
break;
p = va_arg(args, char*);
if( !CheckMem(p, minSize) ) continue; // No #PFs please
if(!p) goto printString;
- while(minSize--) PUTCH(*p++);
+ while(minSize--) {
+ PUTCH(*p);
+ p ++;
+ }
break;
// Single Character
{
for( int i = 0; i < NEnts; i ++ )
{
- Log_Debug("PMemMap", "%i: %i 0x%02x %08llx+%llx",
+ Log_Debug("PMemMap", "%i: %i 0x%02x %08llx+%llx (end %llx)",
i, map[i].Type, map[i].NUMADomain,
- map[i].Start, map[i].Length
+ map[i].Start, map[i].Length,
+ map[i].Start + map[i].Length
);
}
}
toWake->RetStatus = given;
// Wake the sleeper
- SHORTLOCK( &glThreadListLock );
if( toWake->Status != THREAD_STAT_ACTIVE )
Threads_AddActive(toWake);
- SHORTREL( &glThreadListLock );
}
SHORTREL( &Sem->Protector );
#include <threads.h>
#include <events.h>
+#if 1
+# define MERR(f,v...) Log_Debug("Syscalls", "0x%x "f, callNum ,## v)
+#else
+# define MERR(v...) do{}while(0)
+#endif
+
#define CHECK_NUM_NULLOK(v,size) \
- if((v)&&!Syscall_Valid((size),(v))){LOG("CHECK_NUM_NULLOK: %p(%x) FAIL",v,size);ret=-1;err=-EINVAL;break;}
+ if((v)&&!Syscall_Valid((size),(v))){MERR("CHECK_NUM_NULLOK: %p(%x) FAIL",v,size);ret=-1;err=-EINVAL;break;}
#define CHECK_STR_NULLOK(v) \
- if((v)&&!Syscall_ValidString((v))){LOG("CHECK_STR_NULLOK: %p FAIL",v);ret=-1;err=-EINVAL;break;}
+ if((v)&&!Syscall_ValidString((v))){MERR("CHECK_STR_NULLOK: %p FAIL",v);ret=-1;err=-EINVAL;break;}
#define CHECK_NUM_NONULL(v,size) \
- if(!(v)||!Syscall_Valid((size),(v))){LOG("CHECK_NUM_NONULL: %p(%x) FAIL",v,size);ret=-1;err=-EINVAL;break;}
+ if(!(v)||!Syscall_Valid((size),(v))){MERR("CHECK_NUM_NONULL: %p(%x) FAIL",v,size);ret=-1;err=-EINVAL;break;}
#define CHECK_STR_NONULL(v) \
- if(!(v)||!Syscall_ValidString((v))){LOG("CHECK_STR_NONULL: %p FAIL",v);ret=-1;err=-EINVAL;break;}
+ if(!(v)||!Syscall_ValidString((v))){MERR("CHECK_STR_NONULL: %p FAIL",v);ret=-1;err=-EINVAL;break;}
#define CHECK_STR_ARRAY(arr) do {\
int i;\
char **tmp = (char**)arr; \
case SYS_IOCTL:
// All sanity checking should be done by the driver
if( Regs->Arg3 && !MM_IsUser(Regs->Arg3) ) {
+ MERR("IOCtl Invalid arg %p", Regs->Arg3);
err = -EINVAL; ret = -1; break;
}
ret = VFS_IOCtl( Regs->Arg1, Regs->Arg2, (void*)Regs->Arg3 );
64
SYS_OPEN Open a file
SYS_REOPEN Close a file and reuse its handle
+SYS_OPENCHILD Open a child entry in a directory
+SYS_OPENPIPE Open a FIFO pipe pair
SYS_CLOSE Close a file
+SYS_COPYFD Create a copy of a file handle
+SYS_FDCTL Modify properties of a file descriptor
SYS_READ Read from an open file
SYS_WRITE Write to an open file
SYS_IOCTL Perform an IOCtl Call
SYS_SEEK Seek to a new position in the file
SYS_READDIR Read from an open directory
-SYS_OPENCHILD Open a child entry in a directory
SYS_GETACL Get an ACL Value
SYS_SETACL Set an ACL Value
SYS_FINFO Get file information
return -EALREADY;
case THREAD_STAT_SLEEPING:
- SHORTLOCK( &glThreadListLock );
// Remove from sleeping queue
+ SHORTLOCK( &glThreadListLock );
Threads_int_DelFromQueue(&gSleepingThreads, Thread);
-
SHORTREL( &glThreadListLock );
+
Threads_AddActive( Thread );
#if DEBUG_TRACE_STATE
return -ENOTIMPL;
default:
- Warning("Threads_Wake - Unknown process status (%i)\n", Thread->Status);
+ Log_Warning("Threads", "Threads_Wake - Unknown process status (%i)", Thread->Status);
return -EINTERNAL;
}
}
gBGA_CursorPos.x, gBGA_CursorPos.y\r
);\r
break;\r
+\r
+ case VIDEO_IOCTL_SETCURSORBITMAP:\r
+ DrvUtil_Video_SetCursor( &gBGA_DrvUtil_BufInfo, Data );\r
+ return 0;\r
\r
default:\r
LEAVE('i', -2);\r
File "liburi.so" "__BIN__/Libs/liburi.so"
File "libimage_sif.so" "__BIN__/Libs/libimage_sif.so"
File "libaxwin3.so" "__BIN__/Libs/libaxwin3.so"
+ File "libposix.so" "__BIN__/Libs/libposix.so"
+ File "libpsocket.so" "__BIN__/Libs/libpsocket.so"
}
Dir "Conf" {
File "BootConf.cfg" "__FS__/Conf/BootConf.cfg"
Dir "3.0" {
File "AxWinWM" "__BIN__/Apps/AxWin/3.0/AxWinWM"
File "AxWinUI" "__BIN__/Apps/AxWin/3.0/AxWinUI"
+ File "ate" "__BIN__/Apps/AxWin/3.0/ate"
File "AcessLogoSmall.sif" "__SRC__/Usermode/Applications/axwin3_src/AcessLogoSmall.sif"
}
}
const tUDPEndpoint *ep;
const void *data;
int ofs;
- if(chan->LocalPort == 0) return 0;
+
+ if(chan->LocalPort == 0) {
+ Log_Notice("UDP", "Write to channel %p with zero local port", chan);
+ return 0;
+ }
ep = Buffer;
ofs = 2 + 2 + IPStack_GetAddressSize( ep->AddrType );
/**
* \fn Uint ATA_ReadRaw(Uint64 Address, Uint Count, void *Buffer, Uint Disk)
*/
-int ATA_ReadRaw(void *Ptr, Uint64 Address, Uint Count, void *Buffer)
+int ATA_ReadRaw(void *Ptr, Uint64 Address, size_t Count, void *Buffer)
{
int Disk = (tVAddr)Ptr;
int ret;
/**
* \fn Uint ATA_WriteRaw(Uint64 Address, Uint Count, const void *Buffer, Uint Disk)
*/
-int ATA_WriteRaw(void *Ptr, Uint64 Address, Uint Count, const void *Buffer)
+int ATA_WriteRaw(void *Ptr, Uint64 Address, size_t Count, const void *Buffer)
{
int Disk = (tVAddr)Ptr;
int ret;
SUBMAKE = $(MAKE) --no-print-directory
-USRLIBS := crt0.o acess.ld ld-acess.so libc.so
+USRLIBS := crt0.o acess.ld ld-acess.so libc.so libposix.so
USRLIBS += libreadline.so libnet.so liburi.so libpsocket.so
USRLIBS += libimage_sif.so
{\r
GeneratePath(exefile, gsCurrentDirectory, sTmpBuffer);\r
// Check file existence\r
- fd = open(sTmpBuffer, OPENFLAG_EXEC);\r
+ fd = _SysOpen(sTmpBuffer, OPENFLAG_EXEC);\r
if(fd == -1) {\r
printf("Unknown Command: `%s'\n", Args[0]); // Error Message\r
return ;\r
}\r
\r
// Get File info and close file\r
- finfo( fd, &info, 0 );\r
- close( fd );\r
+ _SysFInfo( fd, &info, 0 );\r
+ _SysClose( fd );\r
\r
// Check if the file is a directory\r
if(info.flags & FILEFLAG_DIRECTORY) {\r
for( i = 0; i < giNumPathDirs; i++ )\r
{\r
GeneratePath(exefile, gasPathDirs[i], sTmpBuffer);\r
- fd = open(sTmpBuffer, OPENFLAG_EXEC);\r
+ fd = _SysOpen(sTmpBuffer, OPENFLAG_EXEC);\r
if(fd == -1) continue;\r
- finfo( fd, &info, 0 );\r
- close( fd );\r
+ _SysFInfo( fd, &info, 0 );\r
+ _SysClose( fd );\r
if(info.flags & FILEFLAG_DIRECTORY) continue;\r
// Woohoo! We found a valid command\r
break;\r
}\r
\r
// Create new process\r
- pid = clone(CLONE_VM, 0);\r
- // Start Task\r
- if(pid == 0) {\r
- execve(sTmpBuffer, Args, gasEnvironment);\r
- printf("Execve returned, ... oops\n");\r
- exit(-1);\r
- }\r
+ int fds[] = {0, 1, 2};\r
+ pid = _SysSpawn(sTmpBuffer, (const char **)Args, (const char **)gasEnvironment, 3, fds, NULL);\r
if(pid <= 0) {\r
printf("Unable to create process: `%s'\n", sTmpBuffer); // Error Message\r
}\r
else {\r
int status;\r
- waittid(pid, &status);\r
+ _SysWaitTID(pid, &status);\r
}\r
}\r
\r
*/\r
void Command_Clear(int argc, char **argv)\r
{\r
- write(_stdout, "\x1B[2J", 4); //Clear Screen\r
+ _SysWrite(_stdout, "\x1B[2J", 4); //Clear Screen\r
}\r
\r
/**\r
\r
GeneratePath(argv[1], gsCurrentDirectory, tmpPath);\r
\r
- fp = open(tmpPath, 0);\r
+ fp = _SysOpen(tmpPath, 0);\r
if(fp == -1) {\r
printf("Directory does not exist\n");\r
return;\r
}\r
- finfo(fp, &stats, 0);\r
- close(fp);\r
+ _SysFInfo(fp, &stats, 0);\r
+ _SysClose(fp);\r
\r
if( !(stats.flags & FILEFLAG_DIRECTORY) ) {\r
printf("Not a Directory\n");\r
strcpy(gsCurrentDirectory, tmpPath);\r
\r
// Register change with kernel\r
- chdir( gsCurrentDirectory );\r
+ _SysChdir( gsCurrentDirectory );\r
}\r
\r
/**\r
dirLen = strlen(tmpPath);\r
\r
// Open Directory\r
- dp = open(tmpPath, OPENFLAG_READ);\r
+ dp = _SysOpen(tmpPath, OPENFLAG_READ);\r
// Check if file opened\r
if(dp == -1)\r
{\r
return;\r
}\r
// Get File Stats\r
- if( finfo(dp, &info, 0) == -1 )\r
+ if( _SysFInfo(dp, &info, 0) == -1 )\r
{\r
- close(dp);\r
+ _SysClose(dp);\r
printf("stat Failed, Bad File Descriptor\n");\r
return;\r
}\r
// Check if it's a directory\r
if(!(info.flags & FILEFLAG_DIRECTORY))\r
{\r
- close(dp);\r
+ _SysClose(dp);\r
printf("Unable to open directory `%s', Not a directory\n", tmpPath);\r
return;\r
}\r
\r
fileName = (char*)(tmpPath+dirLen);\r
// Read Directory Content\r
- while( (fp = SysReadDir(dp, fileName)) )\r
+ while( (fp = _SysReadDir(dp, fileName)) )\r
{\r
if(fp < 0)\r
{\r
break;\r
}\r
// Open File\r
- fp = open(tmpPath, 0);\r
+ fp = _SysOpen(tmpPath, 0);\r
if(fp == -1) continue;\r
// Get File Stats\r
- finfo(fp, &info, 0);\r
+ _SysFInfo(fp, &info, 0);\r
\r
if(info.flags & FILEFLAG_DIRECTORY)\r
printf("d");\r
if(acl.perms & 2) modeStr[7] = 'w'; else modeStr[7] = '-';\r
if(acl.perms & 8) modeStr[8] = 'x'; else modeStr[8] = '-';\r
printf(modeStr);\r
- close(fp);\r
+ _SysClose(fp);\r
\r
// Colour Code\r
if(info.flags & FILEFLAG_DIRECTORY) // Directory: Green\r
printf("\n");\r
}\r
// Close Directory\r
- close(dp);\r
+ _SysClose(dp);\r
}\r
CPPFLAGS = -ffreestanding -I$(ACESSUSERDIR)/include/ -DARCHDIR_is_$(ARCHDIR)
CPPFLAGS += $(addprefix -I,$(wildcard $(ACESSUSERDIR)Libraries/*/include_exp/))
CFLAGS = -fno-stack-protector $(CPPFLAGS)
-LDFLAGS = -T $(OUTPUTDIR)Libs/acess.ld -rpath-link $(OUTPUTDIR)Libs -L $(OUTPUTDIR)Libs -I /Acess/Libs/ld-acess.so -lld-acess -lc $(OUTPUTDIR)Libs/crtbegin.o $(OUTPUTDIR)Libs/crtend.o
+LDFLAGS = -T $(OUTPUTDIR)Libs/acess.ld -rpath-link $(OUTPUTDIR)Libs -L $(OUTPUTDIR)Libs -I /Acess/Libs/ld-acess.so -lld-acess -lc $(OUTPUTDIR)Libs/crtbegin.o $(OUTPUTDIR)Libs/crtend.o -lposix
LIBGCC_PATH = $(shell $(CC) -print-libgcc-file-name)
# Extra-verbose errors!
@mkdir -p $(dir $@)
endif
@$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $@
- @$(CC) -M -MT $@ $(CPPFLAGS) $< -o $(_OBJPREFIX)$*.dep
+ @$(CC) -M -MP -MT $@ $(CPPFLAGS) $< -o $(_OBJPREFIX)$*.dep
$(OUTPUTDIR)Libs/libld-acess.so:
@make -C $(ACESSDIR)/Usermode/Libraries/ld-acess.so_src/
int Decorator_HandleMessage(tWindow *Window, int Message, int Length, const void *Data)
{
+ static tWindow *btn1_down;
switch(Message)
{
case WNDMSG_MOUSEMOVE: {
const struct sWndMsg_MouseMove *msg = Data;
+
+ if( btn1_down == Window ) {
+ WM_MoveWindow(Window, Window->X + msg->dX, Window->Y + msg->dY);
+ return 0;
+ }
+
if(msg->Y >= 0) return 1; // Pass
-
+
// TODO: Handle
return 0; }
case WNDMSG_MOUSEBTN: {
const struct sWndMsg_MouseButton *msg = Data;
+ if( msg->Button == 0 && !msg->bPressed )
+ btn1_down = 0;
+
if(msg->Y >= 0) return 1; // Pass
-
+
+ if( msg->Button == 0 && msg->bPressed )
+ btn1_down = Window;
+
// TODO: Handle
return 0; }
default: // Anything unhandled is passed on
tNumValue num_value;
// Open mouse for RW
- giMouseFD = open(gsMouseDevice, 3);
+ giMouseFD = _SysOpen(gsMouseDevice, 3);
// Set mouse limits
// TODO: Update these if the screen resolution changes
num_value.Num = 0; num_value.Value = giScreenWidth;
- ioctl(giMouseFD, JOY_IOCTL_GETSETAXISLIMIT, &num_value);
+ _SysIOCtl(giMouseFD, JOY_IOCTL_GETSETAXISLIMIT, &num_value);
num_value.Value = giScreenWidth/2;
giInput_MouseX = giScreenWidth/2;
- ioctl(giMouseFD, JOY_IOCTL_GETSETAXISPOSITION, &num_value);
+ _SysIOCtl(giMouseFD, JOY_IOCTL_GETSETAXISPOSITION, &num_value);
num_value.Num = 1; num_value.Value = giScreenHeight;
- ioctl(giMouseFD, JOY_IOCTL_GETSETAXISLIMIT, &num_value);
+ _SysIOCtl(giMouseFD, JOY_IOCTL_GETSETAXISLIMIT, &num_value);
num_value.Value = giScreenHeight/2;
giInput_MouseY = giScreenHeight/2;
- ioctl(giMouseFD, JOY_IOCTL_GETSETAXISPOSITION, &num_value);
+ _SysIOCtl(giMouseFD, JOY_IOCTL_GETSETAXISPOSITION, &num_value);
return 0;
}
static uint32_t scancode;
#define KEY_CODEPOINT_MASK 0x3FFFFFFF
- size_t readlen = read(giTerminalFD_Input, &codepoint, sizeof(codepoint));
+ size_t readlen = _SysRead(giTerminalFD_Input, &codepoint, sizeof(codepoint));
if( readlen != sizeof(codepoint) )
{
// oops, error
mouseinfo = (void*)data;
- seek(giMouseFD, 0, SEEK_SET);
- i = read(giMouseFD, data, sizeof(data));
+ _SysSeek(giMouseFD, 0, SEEK_SET);
+ i = _SysRead(giMouseFD, data, sizeof(data));
i -= sizeof(*mouseinfo);
if( i < 0 ) {
_SysDebug("Mouse data undersized (no header)");
{
int tmp;
// TODO: Check this
- giNetworkFileHandle = open("/Devices/ip/loop/udp", OPENFLAG_READ);
+ giNetworkFileHandle = _SysOpen("/Devices/ip/loop/udp", OPENFLAG_READ);
if( giNetworkFileHandle != -1 )
{
tmp = AXWIN_PORT;
- ioctl(giNetworkFileHandle, 4, &tmp); // TODO: Don't hard-code IOCtl number
+ _SysIOCtl(giNetworkFileHandle, 4, &tmp); // TODO: Don't hard-code IOCtl number
}
}
int readlen, identlen;
char *msg;
- readlen = read(giNetworkFileHandle, staticBuf, sizeof(staticBuf));
+ readlen = _SysRead(giNetworkFileHandle, staticBuf, sizeof(staticBuf));
identlen = 4 + Net_GetAddressSize( ((uint16_t*)staticBuf)[1] );
msg = staticBuf + identlen;
}
size_t len;
- pid_t tid;
- while( (len = SysGetMessage(&tid, 0, NULL)) )
+ int tid;
+ while( (len = _SysGetMessage(&tid, 0, NULL)) )
{
char data[len];
- SysGetMessage(NULL, len, data);
+ _SysGetMessage(NULL, len, data);
IPC_Handle(&gIPC_Type_SysMessage, &tid, len, (void*)data);
// _SysDebug("IPC_HandleSelect: Message handled");
memcpy(tmpbuf, Ident, identlen); // Header
memcpy(tmpbuf + identlen, Data, Length); // Data
// TODO: Handle fragmented packets
- write(giNetworkFileHandle, tmpbuf, sizeof(tmpbuf));
+ _SysWrite(giNetworkFileHandle, tmpbuf, sizeof(tmpbuf));
}
int IPC_Type_Sys_GetSize(const void *Ident)
void IPC_Type_Sys_Send(const void *Ident, size_t Length, const void *Data)
{
- SysSendMessage( *(const tid_t*)Ident, Length, Data );
+ _SysSendMessage( *(const tid_t*)Ident, Length, Data );
}
// --- Client -> Window Mappings
}
// Four Byte
- if( (*str & 0xF1) == 0xF0 ) {
+ if( (*str & 0xF8) == 0xF0 ) {
*Val = (*str & 0x07) << 18; // Upper 3 Bits
str ++;
if( (*str & 0xC0) != 0x80) return -1; // Validity check
// Open terminal
#if 0
- giTerminalFD = open(gsTerminalDevice, OPENFLAG_READ|OPENFLAG_WRITE);
+ giTerminalFD = _SysOpen(gsTerminalDevice, OPENFLAG_READ|OPENFLAG_WRITE);
if( giTerminalFD == -1 )
{
fprintf(stderr, "ERROR: Unable to open '%s' (%i)\n", gsTerminalDevice, _errno);
giTerminalFD = 1;
giTerminalFD_Input = 0;
// Check that the console is a VT
- // - ioctl(..., 0, NULL) returns the type, which should be 2
- if( ioctl(1, 0, NULL) != 2 )
+ // - _SysIOCtl(..., 0, NULL) returns the type, which should be 2
+ if( _SysIOCtl(1, 0, NULL) != 2 )
{
fprintf(stderr, "stdout is not an Acess VT, can't start");
_SysDebug("stdout is not an Acess VT, can't start");
// Set mode to video
tmpInt = TERM_MODE_FB;
- ioctl( giTerminalFD, TERM_IOCTL_MODETYPE, &tmpInt );
+ _SysIOCtl( giTerminalFD, TERM_IOCTL_MODETYPE, &tmpInt );
// Get dimensions
- giScreenWidth = ioctl( giTerminalFD, TERM_IOCTL_WIDTH, NULL );
- giScreenHeight = ioctl( giTerminalFD, TERM_IOCTL_HEIGHT, NULL );
+ giScreenWidth = _SysIOCtl( giTerminalFD, TERM_IOCTL_WIDTH, NULL );
+ giScreenHeight = _SysIOCtl( giTerminalFD, TERM_IOCTL_HEIGHT, NULL );
giVideo_LastDirtyLine = giScreenHeight;
// Force VT to be shown
- ioctl( giTerminalFD, TERM_IOCTL_FORCESHOW, NULL );
+ _SysIOCtl( giTerminalFD, TERM_IOCTL_FORCESHOW, NULL );
// Create local framebuffer (back buffer)
gpScreenBuffer = malloc( giScreenWidth*giScreenHeight*4 );
// Set cursor position and bitmap
- ioctl(giTerminalFD, TERM_IOCTL_SETCURSORBITMAP, &cCursorBitmap);
+ _SysIOCtl(giTerminalFD, TERM_IOCTL_SETCURSORBITMAP, &cCursorBitmap);
Video_SetCursorPos( giScreenWidth/2, giScreenHeight/2 );
}
_SysDebug("Video_Update - Updating lines %i to %i (0x%x+0x%x px)",
giVideo_FirstDirtyLine, giVideo_LastDirtyLine, ofs, size);
- seek(giTerminalFD, ofs*4, 1);
+ _SysSeek(giTerminalFD, ofs*4, 1);
_SysDebug("Video_Update - Sending FD %i %p 0x%x", giTerminalFD, gpScreenBuffer+ofs, size*4);
- write(giTerminalFD, gpScreenBuffer+ofs, size*4);
+ _SysWrite(giTerminalFD, gpScreenBuffer+ofs, size*4);
_SysDebug("Video_Update - Done");
giVideo_FirstDirtyLine = 0;
giVideo_LastDirtyLine = 0;
} pos;
pos.x = giVideo_CursorX = X;
pos.y = giVideo_CursorY = Y;
- ioctl(giTerminalFD, TERM_IOCTL_GETSETCURSOR, &pos);
+ _SysIOCtl(giTerminalFD, TERM_IOCTL_GETSETCURSOR, &pos);
}
void Video_FillRect(int X, int Y, int W, int H, uint32_t Colour)
void Video_Blit(uint32_t *Source, short DstX, short DstY, short W, short H)
{
uint32_t *buf;
+ short drawW = W;
if( DstX >= giScreenWidth) return ;
if( DstY >= giScreenHeight) return ;
- // TODO: Handle -ve X/Y by clipping
- if( DstX < 0 || DstY < 0 ) return ;
- // TODO: Handle out of bounds by clipping too
- if( DstX + W > giScreenWidth ) return;
+ // Drawing oob to left/top, clip
+ if( DstX < 0 ) {
+ Source += -DstX;
+ drawW -= -DstX;
+ DstX = 0;
+ }
+ if( DstY < 0 ) {
+ Source += (-DstY)*W;
+ H -= -DstY;
+ DstY = 0;
+ }
+ if( drawW < 0 ) return ;
+ // Drawing oob to the right, clip
+ if( DstX + drawW > giScreenWidth ) {
+ //int oldw = drawW;
+ drawW = giScreenWidth - DstX;
+ }
if( DstY + H > giScreenHeight )
H = giScreenHeight - DstY;
if( W <= 0 || H <= 0 ) return;
- if( DstX < giVideo_FirstDirtyLine )
+ if( DstY < giVideo_FirstDirtyLine )
giVideo_FirstDirtyLine = DstY;
if( DstY + H > giVideo_LastDirtyLine )
giVideo_LastDirtyLine = DstY + H;
buf = gpScreenBuffer + DstY*giScreenWidth + DstX;
- if(W != giScreenWidth)
+ if(drawW != giScreenWidth || W != giScreenWidth)
{
while( H -- )
{
- memcpy(buf, Source, W*4);
+ memcpy(buf, Source, drawW*4);
Source += W;
buf += giScreenWidth;
}
}
else
{
+ // Only valid if copying full scanlines on both ends
memcpy(buf, Source, giScreenWidth*H*4);
}
}
Window->PrevSibling = parent->LastChild;
Window->NextSibling = NULL;
parent->LastChild = Window;
+
+ _SysDebug("Raised %p", Window);
+}
+
+/*
+void WM_RaiseWindow(tWindow *Window)
+{
+ // Move to the last render position (move to top)
+ while(Window && Window->Parent)
+ {
+ if( Window->NextSibling )
+ {
+ // remove
+ if( Window->PrevSibling )
+ Window->PrevSibling->NextSibling = Window->NextSibling;
+ Window->NextSibling->PrevSibling = Window->PrevSibling;
+ // Mutate self
+ Window->PrevSibling = Window->Parent->LastChild;
+ Window->NextSibling = NULL;
+ // re-add
+ Window->PrevSibling->NextSibling = Window;
+ Window->Parent->LastChild = Window;
+ }
+ _SysDebug("WM_RaiseWindow: Raised %p", Window);
+ Window = Window->Parent;
+ }
}
+*/
void WM_FocusWindow(tWindow *Destination)
{
WM_Invalidate(gpWM_FocusedWindow);
WM_Invalidate(Destination);
- gpWM_FocusedWindow = Destination;
-
- // Get the owner of the focused window
-// while(Destination && Destination->Owner) Destination = Destination->Owner;
-// gpWM_HilightedWindow = Destination;
+ gpWM_FocusedWindow = Destination;
}
WM_SendMessage(NULL, Window, WNDMSG_SHOW, sizeof(_msg), &_msg);
// Update the flag
- if(bShow)
+ if(bShow) {
Window->Flags |= WINFLAG_SHOW;
+ _SysDebug("Window %p shown", Window);
+ }
else
{
Window->Flags &= ~WINFLAG_SHOW;
free(Window->RenderBuffer);
Window->RenderBuffer = NULL;
}
+ _SysDebug("Window %p hidden", Window);
}
WM_Invalidate(Window);
}
// TODO: Re-sanitise
+ _SysDebug("WM_MoveWindow: (%i,%i)", X, Y);
Window->X = X; Window->Y = Y;
- // TODO: Why invalidate buffer?
- WM_Invalidate(Window);
+ // Mark up the tree that a child window has changed
+ while( (Window = Window->Parent) )
+ Window->Flags &= ~WINFLAG_CHILDCLEAN;
return 0;
}
if( Window->W == W && Window->H == H )
return 0;
+ _SysDebug("WM_Resizeindow: %ix%i", W, H);
Window->W = W; Window->H = H;
if(Window->RenderBuffer) {
if( !(Window->Flags & WINFLAG_SHOW) )
return ;
+ if( (Window->Flags & WINFLAG_RELATIVE) && Window->Parent )
+ {
+ Window->RealX = Window->Parent->RealX + Window->Parent->BorderL + Window->X;
+ Window->RealY = Window->Parent->RealY + Window->Parent->BorderT + Window->Y;
+ }
+ else
+ {
+ Window->RealX = Window->X;
+ Window->RealY = Window->Y;
+ }
+
// Render
if( !(Window->Flags & WINFLAG_CLEAN) )
{
Window->RealW = Window->W;
Window->RealH = Window->H;
}
-
- if( (Window->Flags & WINFLAG_RELATIVE) && Window->Parent )
- {
- Window->RealX = Window->Parent->X + Window->Parent->BorderL + Window->X;
- Window->RealY = Window->Parent->Y + Window->Parent->BorderT + Window->Y;
- }
- else
- {
- Window->RealX = Window->X;
- Window->RealY = Window->Y;
- }
Window->Renderer->Redraw(Window);
Window->Flags |= WINFLAG_CLEAN;
// Ignore hidden windows
if( !(Window->Flags & WINFLAG_SHOW) )
return ;
+
+ // Duplicated position update to handle window moving
+ if( (Window->Flags & WINFLAG_RELATIVE) && Window->Parent )
+ {
+ Window->RealX = Window->Parent->RealX + Window->Parent->BorderL + Window->X;
+ Window->RealY = Window->Parent->RealY + Window->Parent->BorderT + Window->Y;
+ }
+ else
+ {
+ Window->RealX = Window->X;
+ Window->RealY = Window->Y;
+ }
// _SysDebug("Blit %p (%p) to (%i,%i) %ix%i", Window, Window->RenderBuffer,
// Window->RealX, Window->RealY, Window->RealW, Window->RealH);
for(win = ret->FirstChild; win; win = win->NextSibling)
{
if( !(win->Flags & WINFLAG_SHOW) ) continue ;
- if( X < win->X || X >= win->X + win->RealW ) continue;
- if( Y < win->Y || Y >= win->Y + win->RealH ) continue;
+ if( X < win->RealX || X >= win->RealX + win->RealW ) continue;
+ if( Y < win->RealY || Y >= win->RealY + win->RealH ) continue;
next_win = win; // Overwrite as we want the final rendered window
}
}
struct sWndMsg_MouseMove msg;
win = WM_int_GetWindowAtPos(OldX, OldY);
- msg.X = NewX - win->X - win->BorderL;
- msg.Y = NewY - win->Y - win->BorderT;
+ msg.X = NewX - win->RealX - win->BorderL;
+ msg.Y = NewY - win->RealY - win->BorderT;
msg.dX = NewX - OldX;
msg.dY = NewY - OldY;
WM_SendMessage(NULL, win, WNDMSG_MOUSEMOVE, sizeof(msg), &msg);
// TODO: Send mouseup to match mousedown if the cursor moves out of a window?
win = newWin;
- msg.X = NewX - win->X - win->BorderL;
- msg.Y = NewY - win->Y - win->BorderT;
+ msg.X = NewX - win->RealX - win->BorderL;
+ msg.Y = NewY - win->RealY - win->BorderT;
msg.dX = NewX - OldX;
msg.dY = NewY - OldY;
WM_SendMessage(NULL, win, WNDMSG_MOUSEMOVE, sizeof(msg), &msg);
{
struct sWndMsg_MouseButton msg;
- msg.X = X - Win->X - Win->BorderL;
- msg.Y = Y - Win->Y - Win->BorderT;
+ msg.X = X - Win->RealX - Win->BorderL;
+ msg.Y = Y - Win->RealY - Win->BorderT;
msg.Button = Index;
msg.bPressed = !!Pressed;
{
// _SysDebug("Gave focus to %p", win);
WM_FocusWindow(win);
- WM_RaiseWindow(win);
+ tWindow *tmpwin = win;
+ while( tmpwin )
+ {
+ WM_RaiseWindow(tmpwin);
+ tmpwin = tmpwin->Parent;
+ }
}
// Make sure that even if the mouse has moved out of the original window,
#include <wm_internals.h>
#include <stdlib.h>
#include <utf8.h>
+#include <limits.h> // INT_MAX
// === TYPES ===
typedef struct sGlyph tGlyph;
switch(giConnectionType)
{
case CONNTYPE_SENDMESSAGE:
- SysSendMessage(giConnectionNum, size, Msg);
+ _SysSendMessage(giConnectionNum, size, Msg);
break;
case CONNTYPE_UDP: {
// Create UDP header
char tmpbuf[giAxWin3_int_UDPHeaderLen + size];
memcpy(tmpbuf, gaAxWin3_int_UDPHeader, giAxWin3_int_UDPHeaderLen);
memcpy(tmpbuf + giAxWin3_int_UDPHeaderLen, Msg, size);
- write(giConnectionNum, tmpbuf, sizeof(tmpbuf));
+ _SysWrite(giConnectionNum, tmpbuf, sizeof(tmpbuf));
}
break;
case CONNTYPE_TCP:
- write(giConnectionNum, Msg, size);
+ _SysWrite(giConnectionNum, Msg, size);
break;
default:
break;
{
int len;
tAxWin_IPCMessage *ret = NULL;
- pid_t tid;
+ int tid;
_SysSelect(nFD, fds, NULL, NULL, NULL, THREAD_EVENT_IPCMSG);
// Clear out IPC messages
- while( (len = SysGetMessage(&tid, 0, NULL)) )
+ while( (len = _SysGetMessage(&tid, 0, NULL)) )
{
if( giConnectionType != CONNTYPE_SENDMESSAGE || tid != giConnectionNum )
{
if( gAxWin3_MessageCallback )
gAxWin3_MessageCallback(tid, len);
else
- SysGetMessage(NULL, 0, GETMSG_IGNORE);
+ _SysGetMessage(NULL, 0, GETMSG_IGNORE);
continue ;
}
ret = malloc(len);
if(ret == NULL) {
_SysDebug("malloc() failed, ignoring message");
- SysGetMessage(NULL, 0, GETMSG_IGNORE);
+ _SysGetMessage(NULL, 0, GETMSG_IGNORE);
return NULL;
}
- SysGetMessage(NULL, len, ret);
+ _SysGetMessage(NULL, len, ret);
break;
}
if(msg->ID >= info->nItems) return -1;
item = &info->Items[msg->ID];
if(item->Callback) item->Callback(item->CbPtr);
- return 0; }
+ return 1; }
}
- return 1;
+ return 0;
}
tHWND AxWin3_Menu_Create(tHWND Parent)
if( gbForkBomb )
{
- for(;;) clone(CLONE_VM, 0);
+ for(;;) _SysClone(CLONE_VM, 0);
}
else {
for(;;)
printf("Outta heap space!\n");
return 0;
}
- tid = clone(0, stack+stackSize-stackOffset);
+ tid = _SysClone(0, stack+stackSize-stackOffset);
//_SysDebug("tid = %i", tid);
if( tid == 0 )
{
// Sleep forever (TODO: Fix up the stack so it can nuke)
- for(;;) sleep();
+ for(;;) _SysWaitEvent(THREAD_EVENT_SIGNAL);
}
if( tid < 0 ) {
printf("Clone failed\n");
/*
* Acess2 CAT command
*/
-#include <acess/sys.h>
#include <stdlib.h>
#include <stdio.h>
*/
int main(int argc, char *argv[])
{
- int fd;
int num;
char buf[BUF_SIZE];
return -1;
}
- fd = open(argv[1], OPENFLAG_READ);
- if(fd == -1) {
+ FILE *fp = fopen(argv[1], "r");
+ if(!fp) {
printf("Unable to open '%s' for reading\n", argv[1]);
return -1;
}
do {
- num = read(fd, buf, BUF_SIZE);
+ num = fread(buf, BUF_SIZE, 1, fp);
if(num < 0) break;
- write(1, buf, num);
+ fwrite(buf, num, 1, stdout);
} while(num == BUF_SIZE);
- close(fd);
+ fclose(fp);
printf("\n");
return 0;
*
* http://www.ietf.org/rfc/rfc2131.txt
*/
-#include <unistd.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <net.h>
+#include <acess/sys.h>
#define FILENAME_MAX 255
// --- Translation functions ---
STATE_PREINIT,
STATE_DISCOVER_SENT,
STATE_REQUEST_SENT,
- STATE_COMPLETE
+ STATE_COMPLETE,
};
// === STRUCTURES ===
char HWAddr[6];
int64_t Timeout;
+ int nTimeouts;
} tInterface;
// === PROTOTYPES ===
int Start_Interface(tInterface *Iface);
void Send_DHCPDISCOVER(tInterface *Iface);
void Send_DHCPREQUEST(tInterface *Iface, void *OfferBuffer, int TypeOffset);
-int Handle_Packet(tInterface *Iface);
-void Handle_Timeout(tInterface *Iface);
+ int Handle_Packet(tInterface *Iface);
+ int Handle_Timeout(tInterface *Iface);
void Update_State(tInterface *Iface, int newState);
void SetAddress(tInterface *Iface, void *Addr, void *Mask, void *Router);
if( FD_ISSET(i->SocketFD, &fds) )
{
if( Handle_Packet( i ) )
- {
- close(i->SocketFD);
- close(i->IfaceFD);
- p->Next = i->Next;
- free(i);
- i = p;
- }
+ goto _remove;
}
if( _SysTimestamp() > i->Timeout )
{
- Handle_Timeout(i);
+ if( Handle_Timeout(i) )
+ {
+ fprintf(stderr, "%s timed out\n", i->Adapter);
+ goto _remove;
+ }
}
+ continue ;
+ _remove:
+ _SysClose(i->SocketFD);
+ _SysClose(i->IfaceFD);
+ p->Next = i->Next;
+ free(i);
+ i = p;
}
}
return 0;
void Scan_Dir(tInterface **IfaceList, const char *Directory)
{
- int dp = open(Directory, OPENFLAG_READ);
+ int dp = _SysOpen(Directory, OPENFLAG_READ);
char filename[FILENAME_MAX];
if( dp == -1 ) {
fprintf(stderr, "Unable to open directory '%s'\n", Directory);
+ return ;
}
- while( SysReadDir(dp, filename) )
+ while( _SysReadDir(dp, filename) )
{
if( filename[0] == '.' ) continue ;
if( strcmp(filename, "lo") == 0 ) continue ;
new->Next = *IfaceList;
*IfaceList = new;
}
- close(dp);
+ _SysClose(dp);
}
// RETURN: Client FD
{
char path[] = "/Devices/ip/adapters/ethXXXX";
sprintf(path, "/Devices/ip/adapters/%s", Iface->Adapter);
- fd = open(path, 0);
+ fd = _SysOpen(path, 0);
if(fd == -1) {
_SysDebug("Unable to open adapter %s", path);
return -1;
}
- ioctl(fd, 4, Iface->HWAddr);
+ _SysIOCtl(fd, 4, Iface->HWAddr);
// TODO: Check if ioctl() failed
- close(fd);
+ _SysClose(fd);
}
// Initialise an interface, with a dummy IP address (zero)
- fd = open("/Devices/ip", 0);
+ fd = _SysOpen("/Devices/ip", 0);
if( fd == -1 ) {
fprintf(stderr, "ERROR: Unable to open '/Devices/ip'\n");
return -1;
}
- Iface->Num = ioctl(fd, 4, (void*)Iface->Adapter); // Create interface
+ Iface->Num = _SysIOCtl(fd, 4, (void*)Iface->Adapter); // Create interface
if( Iface->Num == -1 ) {
fprintf(stderr, "ERROR: Unable to create new interface\n");
return -1;
}
- close(fd);
+ _SysClose(fd);
// Open new interface
snprintf(path, sizeof(path), "/Devices/ip/%i", Iface->Num);
- Iface->IfaceFD = fd = open(path, 0);
+ Iface->IfaceFD = fd = _SysOpen(path, 0);
if( fd == -1 ) {
fprintf(stderr, "ERROR: Unable to open '%s'\n", path);
return -1;
}
- tmp = 4; ioctl(fd, 4, &tmp); // Set to IPv4
- ioctl(fd, 6, addr); // Set address to 0.0.0.0
- tmp = 0; ioctl(fd, 7, &tmp); // Set subnet mask to 0
+ tmp = 4; _SysIOCtl(fd, 4, &tmp); // Set to IPv4
+ _SysIOCtl(fd, 6, addr); // Set address to 0.0.0.0
+ tmp = 0; _SysIOCtl(fd, 7, &tmp); // Set subnet mask to 0
// Open UDP Client
snprintf(path, sizeof(path), "/Devices/ip/%i/udp", Iface->Num);
- Iface->SocketFD = fd = open(path, O_RDWR);
+ Iface->SocketFD = fd = _SysOpen(path, OPENFLAG_READ|OPENFLAG_WRITE);
if( fd == -1 ) {
fprintf(stderr, "ERROR: Unable to open '%s'\n", path);
return -1;
}
- tmp = 68; ioctl(fd, 4, &tmp); // Local port
- tmp = 67; ioctl(fd, 5, &tmp); // Remote port
- tmp = 0; ioctl(fd, 7, &tmp); // Remote addr mask bits - we don't care where the reply comes from
+ tmp = 68; _SysIOCtl(fd, 4, &tmp); // Local port
+ tmp = 67; _SysIOCtl(fd, 5, &tmp); // Remote port
+ tmp = 0; _SysIOCtl(fd, 7, &tmp); // Remote addr mask bits - we don't care where the reply comes from
addr[0] = addr[1] = addr[2] = addr[3] = 255; // 255.255.255.255
- ioctl(fd, 8, addr); // Remote address
+ _SysIOCtl(fd, 8, addr); // Remote address
return 0;
}
data[2] = 4; data[3] = 0; // AddrType
data[4] = 255; data[5] = 255; data[6] = 255; data[7] = 255;
- write(Iface->SocketFD, data, sizeof(data));
+ i = _SysWrite(Iface->SocketFD, data, sizeof(data));
+ if( i != sizeof(data) ) {
+ _SysDebug("_SysWrite failed (%i != %i)", i, sizeof(data));
+ }
Update_State(Iface, STATE_DISCOVER_SENT);
}
((uint8_t*)OfferPacket)[6] = 255;
((uint8_t*)OfferPacket)[7] = 255;
- write(Iface->SocketFD, OfferPacket, 8 + sizeof(*msg) + i);
+ _SysWrite(Iface->SocketFD, OfferPacket, 8 + sizeof(*msg) + i);
Update_State(Iface, STATE_REQUEST_SENT);
}
void *subnet_mask = NULL;
_SysDebug("Doing read on %i", Iface->SocketFD);
- len = read(Iface->SocketFD, data, sizeof(data));
+ len = _SysRead(Iface->SocketFD, data, sizeof(data));
_SysDebug("len = %i", len);
_SysDebug("*msg = {");
return 0;
}
-void Handle_Timeout(tInterface *Iface)
+int Handle_Timeout(tInterface *Iface)
{
+ if( Iface->nTimeouts == 3 )
+ return 1;
switch(Iface->State)
{
case STATE_DISCOVER_SENT:
_SysDebug("Timeout with state = %i", Iface->State);
break;
}
+ return 0;
}
void Update_State(tInterface *Iface, int newState)
{
Iface->Timeout = _SysTimestamp() + 500;
Iface->State = newState;
+ Iface->nTimeouts = 0;
}
else
{
// TODO: Exponential backoff
Iface->Timeout = _SysTimestamp() + 3000;
+ Iface->nTimeouts ++;
_SysDebug("State %i repeated, timeout is 3000ms now", newState);
}
}
);
}
- ioctl(Iface->IfaceFD, 6, Addr);
- ioctl(Iface->IfaceFD, 7, &mask_bits);
+ _SysIOCtl(Iface->IfaceFD, 6, Addr);
+ _SysIOCtl(Iface->IfaceFD, 7, &mask_bits);
if( Router );
{
// Set default route
int fd;
- fd = open("/Devices/ip/routes/4:00000000:0:0", OPENFLAG_CREATE);
+ fd = _SysOpen("/Devices/ip/routes/4:00000000:0:0", OPENFLAG_CREATE);
if(fd == -1) {
fprintf(stderr, "ERROR: Unable to open default route\n");
}
else {
char ifname[snprintf(NULL,0,"%i",Iface->Num)+1];
sprintf(ifname, "%i", Iface->Num);
- ioctl(fd, ioctl(fd, 3, "set_nexthop"), Router);
- ioctl(fd, ioctl(fd, 3, "set_interface"), ifname);
- close(fd);
+ _SysIOCtl(fd, _SysIOCtl(fd, 3, "set_nexthop"), Router);
+ _SysIOCtl(fd, _SysIOCtl(fd, 3, "set_interface"), ifname);
+ _SysClose(fd);
}
}
}
#include <axwin3/menu.h>
#include <axwin3/richtext.h>
#include <stdio.h>
+#include "strings.h"
// === PROTOTYPES ===
int main(int argc, char *argv[]);
int len = read(giChildStdout, buf, sizeof(buf));
if( len <= 0 ) break;
- //Term_HandleOutput(len, buf);
+ Term_HandleOutput(len, buf);
}
}
// - Start virtual terminals
for( i = 0; i < NUM_TERMS; i++ )
{
- tid = clone(CLONE_VM, 0);
+ tid = _SysClone(CLONE_VM, 0);
if(tid == 0)
{
termpath[sizeof(DEFAULT_TERMINAL)-2] = '0' + i;
- open(termpath, OPENFLAG_READ); // Stdin
- open(termpath, OPENFLAG_WRITE); // Stdout
- open(termpath, OPENFLAG_WRITE); // Stderr
- execve(DEFAULT_SHELL, child_argv, NULL);
- for(;;) sleep();
+ _SysOpen(termpath, OPENFLAG_READ); // Stdin
+ _SysOpen(termpath, OPENFLAG_WRITE); // Stdout
+ _SysOpen(termpath, OPENFLAG_WRITE); // Stderr
+ _SysExecVE(DEFAULT_SHELL, child_argv, NULL);
+ for(;;) ;
}
}
// TODO: Implement message watching
- for(;;) sleep();
+ for(;;)
+ _SysWaitEvent(THREAD_EVENT_IPCMSG);
return 42;
}
{
int dp, ret;
- dp = open(IPSTACK_ROOT, OPENFLAG_READ);
- ret = ioctl(dp, 4, (void*)Device);
- close(dp);
+ dp = _SysOpen(IPSTACK_ROOT, OPENFLAG_READ);
+ ret = _SysIOCtl(dp, 4, (void*)Device);
+ _SysClose(dp);
if( ret < 0 ) {
fprintf(stderr, "Unable to add '%s' as a network interface\n", Device);
// Open file
sprintf(path, IPSTACK_ROOT"/%i", IFNum);
- fd = open(path, OPENFLAG_READ);
+ fd = _SysOpen(path, OPENFLAG_READ);
if( fd == -1 ) {
fprintf(stderr, "Unable to open '%s'\n", path);
return -1;
}
tmp = type;
- tmp = ioctl(fd, ioctl(fd, 3, "getset_type"), &tmp);
+ tmp = _SysIOCtl(fd, _SysIOCtl(fd, 3, "getset_type"), &tmp);
if( tmp != type ) {
fprintf(stderr, "Error in setting address type (got %i, expected %i)\n", tmp, type);
- close(fd);
+ _SysClose(fd);
return -1;
}
// Set Address
- ioctl(fd, ioctl(fd, 3, "set_address"), addr);
+ _SysIOCtl(fd, _SysIOCtl(fd, 3, "set_address"), addr);
// Set Subnet
- ioctl(fd, ioctl(fd, 3, "getset_subnet"), &subnet);
+ _SysIOCtl(fd, _SysIOCtl(fd, 3, "getset_subnet"), &subnet);
- close(fd);
+ _SysClose(fd);
// Dump!
//DumpInterface( path+sizeof(IPSTACK_ROOT)+1 );
int dp;
char filename[FILENAME_MAX+1];
- dp = open(IPSTACK_ROOT, OPENFLAG_READ);
+ dp = _SysOpen(IPSTACK_ROOT, OPENFLAG_READ);
- while( SysReadDir(dp, filename) )
+ while( _SysReadDir(dp, filename) )
{
if(filename[0] == '.') continue;
DumpInterface(filename);
}
- close(dp);
+ _SysClose(dp);
}
/**
strcat(path, Name);
- fd = open(path, OPENFLAG_READ);
+ fd = _SysOpen(path, OPENFLAG_READ);
if(fd == -1) {
fprintf(stderr, "Bad interface name '%s' (%s does not exist)\t", Name, path);
return ;
}
- type = ioctl(fd, 4, NULL);
+ type = _SysIOCtl(fd, 4, NULL);
// Ignore -1 values
if( type == -1 ) {
printf("%s:\t", Name);
{
- int call_num = ioctl(fd, 3, "get_device");
- int len = ioctl(fd, call_num, NULL);
+ int call_num = _SysIOCtl(fd, 3, "get_device");
+ int len = _SysIOCtl(fd, call_num, NULL);
char *buf = malloc(len+1);
- ioctl(fd, call_num, buf);
+ _SysIOCtl(fd, call_num, buf);
printf("'%s'\n", buf);
free(buf);
}
uint8_t ip[4];
int subnet;
printf("IPv4\t");
- ioctl(fd, 5, ip); // Get IP Address
- subnet = ioctl(fd, 7, NULL); // Get Subnet Bits
+ _SysIOCtl(fd, 5, ip); // Get IP Address
+ subnet = _SysIOCtl(fd, 7, NULL); // Get Subnet Bits
printf("%i.%i.%i.%i/%i\n", ip[0], ip[1], ip[2], ip[3], subnet);
}
break;
uint16_t ip[8];
int subnet;
printf("IPv6\t");
- ioctl(fd, 5, ip); // Get IP Address
- subnet = ioctl(fd, 7, NULL); // Get Subnet Bits
+ _SysIOCtl(fd, 5, ip); // Get IP Address
+ subnet = _SysIOCtl(fd, 7, NULL); // Get Subnet Bits
printf("%x:%x:%x:%x:%x:%x:%x:%x/%i\n",
ntohs(ip[0]), ntohs(ip[1]), ntohs(ip[2]), ntohs(ip[3]),
ntohs(ip[4]), ntohs(ip[5]), ntohs(ip[6]), ntohs(ip[7]),
break;
}
- close(fd);
+ _SysClose(fd);
}
// === PROTOTYPES ===
int Routes_main(int argc, char *argv[]);
void DumpRoutes(void);
-void DumpRoute(const char *Name);
+void DumpRoute(int PFD, const char *Name);
void AddRoute(const char *Interface, int AddressType, void *Dest, int MaskBits, int Metric, void *NextHop);
// === CODE ===
}
// Destination IP
- addrType = ParseIPAddress(argv[3], dest, &subnetBits);
+ addrType = ParseIPAddress(argv[2], dest, &subnetBits);
if( subnetBits == -1 ) {
subnetBits = Net_GetAddressSize(addrType)*8;
}
// Interface Name / Next Hop
- if( (nextHopType = ParseIPAddress(argv[4], nextHop, &nextHopBits)) == 0 )
+ if( (nextHopType = ParseIPAddress(argv[3], nextHop, &nextHopBits)) == 0 )
{
// Interface name
- ifaceName = argv[4];
+ ifaceName = argv[3];
}
else
{
// Metric
if( argc - 3 >= 3 )
{
- metric = atoi(argv[5]);
- if( metric == 0 && argv[5][0] != '0' ) {
+ metric = atoi(argv[4]);
+ if( metric == 0 && argv[4][0] != '0' ) {
fprintf(stderr, "ERROR: Metric should be a number\n");
return -1;
}
int dp;
char filename[FILENAME_MAX+1];
- dp = open(IPSTACK_ROOT"/routes", OPENFLAG_READ);
+ dp = _SysOpen(IPSTACK_ROOT"/routes", OPENFLAG_READ);
printf("Type\tNetwork \tGateway \tMetric\tIFace\n");
- while( SysReadDir(dp, filename) )
+ while( _SysReadDir(dp, filename) )
{
if(filename[0] == '.') continue;
- DumpRoute(filename);
+ DumpRoute(dp, filename);
}
- close(dp);
+ _SysClose(dp);
}
/**
* \brief Dump a route
*/
-void DumpRoute(const char *Name)
+void DumpRoute(int PFD, const char *Name)
{
int fd;
int type;
- char path[sizeof(IPSTACK_ROOT)+8+FILENAME_MAX+1] = IPSTACK_ROOT"/routes/";
- strcat(path, Name);
-
- fd = open(path, OPENFLAG_READ);
+ fd = _SysOpenChild(PFD, Name, OPENFLAG_READ);
if(fd == -1) {
- printf("%s:\tUnable to open ('%s')\n", Name, path);
+ printf("%s:\tUnable to open\n", Name);
return ;
}
subnet = atoi(Name+ofs);
ofs ++;
metric = atoi(Name+ofs);
- ioctl(fd, ioctl(fd, 3, "get_nexthop"), gw); // Get Gateway/NextHop
+ _SysIOCtl(fd, _SysIOCtl(fd, 3, "get_nexthop"), gw); // Get Gateway/NextHop
// Get the address type
switch(type)
// Interface
{
- int call_num = ioctl(fd, 3, "get_interface");
- int len = ioctl(fd, call_num, NULL);
+ int call_num = _SysIOCtl(fd, 3, "get_interface");
+ int len = _SysIOCtl(fd, call_num, NULL);
char *buf = malloc(len+1);
- ioctl(fd, call_num, buf);
+ _SysIOCtl(fd, call_num, buf);
printf("'%s'\t", buf);
free(buf);
}
printf("\n");
- close(fd);
+ _SysClose(fd);
}
void AddRoute(const char *Interface, int AddressType, void *Dest, int MaskBits, int Metric, void *NextHop)
// Open interface
strcpy(ifacePath, IPSTACK_ROOT"/");
strcat(ifacePath, Interface);
- fd = open(ifacePath, 0);
+ fd = _SysOpen(ifacePath, 0);
if( fd == -1 ) {
fprintf(stderr, "Error: Interface '%s' does not exist\n", Interface);
return ;
}
// Get and check type
- num = ioctl(fd, ioctl(fd, 3, "getset_type"), NULL);
+ num = _SysIOCtl(fd, _SysIOCtl(fd, 3, "getset_type"), NULL);
if( num != AddressType ) {
fprintf(stderr, "Error: Passed type does not match interface type (%i != %i)\n",
AddressType, num);
return ;
}
- close(fd);
+ _SysClose(fd);
}
// Create route
sprintf(path+ofs, ":%i:%i", MaskBits, Metric);
}
- fd = open(path, 0);
+ fd = _SysOpen(path, 0);
if( fd != -1 ) {
- close(fd);
+ _SysClose(fd);
fprintf(stderr, "Unable to create route '%s', already exists\n", path);
return ;
}
- fd = open(path, OPENFLAG_CREATE, 0);
+ fd = _SysOpen(path, OPENFLAG_CREATE, 0);
if( fd == -1 ) {
fprintf(stderr, "Unable to create '%s'\n", path);
return ;
}
if( NextHop )
- ioctl(fd, ioctl(fd, 3, "set_nexthop"), NextHop);
- ioctl(fd, ioctl(fd, 3, "set_interface"), (void*)Interface);
+ _SysIOCtl(fd, _SysIOCtl(fd, 3, "set_nexthop"), NextHop);
+ _SysIOCtl(fd, _SysIOCtl(fd, 3, "set_interface"), (void*)Interface);
- close(fd);
+ _SysClose(fd);
// Check if the interface name was allocated by us
if( ifaceToFree )
\r
atexit(ExitHandler);\r
\r
- giTerminal_Width = ioctl(1, 5, NULL); // getset_width\r
- giTerminal_Height = ioctl(1, 6, NULL); // getset_height\r
+ giTerminal_Width = _SysIOCtl(1, 5, NULL); // getset_width\r
+ giTerminal_Height = _SysIOCtl(1, 6, NULL); // getset_height\r
\r
printf("\x1B[?1047h");\r
printf("\x1B[%i;%ir", 0, giTerminal_Height-1);\r
{\r
tServer *srv;\r
for( srv = gpServers; srv; srv = srv->Next )\r
- close(srv->FD);\r
+ _SysClose(srv->FD);\r
}\r
return 0;\r
}\r
// ioctl#8 on a TCP client gets the number of bytes in the recieve buffer\r
// - Used to avoid blocking\r
#if NON_BLOCK_READ\r
- while( (len = ioctl(Server->FD, 8, NULL)) > 0 )\r
+ while( (len = _SysIOCtl(Server->FD, 8, NULL)) > 0 )\r
{\r
#endif\r
// Read data\r
- len = read(Server->FD, &Server->InBuf[Server->ReadPos], BUFSIZ - Server->ReadPos);\r
+ len = _SysRead(Server->FD, &Server->InBuf[Server->ReadPos], BUFSIZ - Server->ReadPos);\r
if( len == -1 ) {\r
return -1;\r
}\r
vsnprintf(buf, len+1, Format, args);\r
va_end(args);\r
\r
- return write(FD, buf, len);\r
+ return _SysWrite(FD, buf, len);\r
}\r
}\r
\r
\r
// Set remote port and address\r
// printf("Setting port and remote address\n");\r
- ioctl(fd, 5, &PortNumber);\r
- ioctl(fd, 6, addrBuffer);\r
+ _SysIOCtl(fd, 5, &PortNumber);\r
+ _SysIOCtl(fd, 6, addrBuffer);\r
\r
// Connect\r
// printf("Initiating connection\n");\r
- if( ioctl(fd, 7, NULL) == 0 ) {\r
+ if( _SysIOCtl(fd, 7, NULL) == 0 ) {\r
// Shouldn't happen :(\r
fprintf(stderr, "Unable to start connection\n");\r
return -1;\r
Row = Col / giTerminal_Width;\r
Col = Col % giTerminal_Width;\r
}\r
- rv = ioctl(1, 9, NULL); // Ugh, constants\r
+ rv = _SysIOCtl(1, 9, NULL); // Ugh, constants\r
printf("\x1B[%i;%iH", Col, Row);\r
return rv;\r
}\r
break;
}
printf("\n");
-
- // Create child process
- pid = clone(CLONE_VM, 0);
+
+ uinfo = GetUserInfo(uid);
+ struct s_sys_spawninfo spawninfo;
+ spawninfo.flags = 0;
+ spawninfo.gid = uinfo->GID;
+ spawninfo.uid = uinfo->UID;
+ const char *child_argv[2] = {"-", 0};
+ const char **child_envp = NULL;
+ int fds[] = {0, 1, 2};
+ pid = _SysSpawn(uinfo->Shell, child_argv, child_envp, 3, fds, &spawninfo);
// Error check
if(pid == -1) {
fprintf(stderr, "Unable to fork the login process!\n");
return -1;
}
- // Spawn shell in a child process
- if(pid == 0)
- {
- char *child_argv[2] = {NULL, 0};
- char **child_envp = NULL;
-
- // Get user information
- uinfo = GetUserInfo(uid);
-
- child_argv[0] = uinfo->Shell;
- // Set Environment
- setgid(uinfo->GID);
- //setuid(uid);
- setuid(uinfo->UID);
-
- execve(uinfo->Shell, child_argv, child_envp);
- exit(-1);
- }
-
// Wait for child to terminate
- waittid(pid, &status);
+ _SysWaitTID(pid, &status);
}
return 0;
ParseArguments(argc, argv);
// Open Directory
- fd = open(gsDirectory, OPENFLAG_READ|OPENFLAG_EXEC);
+ fd = _SysOpen(gsDirectory, OPENFLAG_READ|OPENFLAG_EXEC);
if(fd == -1) {
printf("Unable to open '%s' for reading\n", gsDirectory);
return EXIT_FAILURE;
}
// Check that it is a directory
- finfo(fd, &info, 0);
+ _SysFInfo(fd, &info, 0);
if( !(info.flags & FILEFLAG_DIRECTORY) ) {
fprintf(stderr, "'%s' is not a directory\n", gsDirectory);
- close(fd);
+ _SysClose(fd);
return EXIT_FAILURE;
}
}
// Traverse Directory
- while( (tmp = SysReadDir(fd, buf)) > 0 )
+ while( (tmp = _SysReadDir(fd, buf)) > 0 )
{
// Error check
if(tmp < 0) {
- close(fd);
+ _SysClose(fd);
return EXIT_FAILURE;
}
space += 16;
gFileList = realloc(gFileList, space*sizeof(char*));
if(gFileList == NULL) {
- close(fd);
+ _SysClose(fd);
return EXIT_FAILURE;
}
}
DisplayFile( gFileList[i] );
}
- close(fd);
+ _SysClose(fd);
printf("\n");
return EXIT_SUCCESS;
strcpy(&path[dirLen+1], Filename);
// Get file type
- fd = open(path, 0);
+ fd = _SysOpen(path, 0);
if(fd == -1) {
fprintf(stderr, "Unable to open '%s'\n", path);
}
else {
// Get Info
- finfo(fd, &info, 0);
+ _SysFInfo(fd, &info, 0);
// Get Type
if(info.flags & FILEFLAG_DIRECTORY) {
type = FTYPE_DIR;
if(acl.perms & 8) perms |= 0001; // X
// Close file
- close(fd);
+ _SysClose(fd);
}
free(path); // We're finished with it
*/
#include <stdlib.h>
#include <stdio.h>
-#include <unistd.h>
#include <acess/sys.h>
#define PCI_BASE "/Devices/pci"
// === CODE ===
int main(int argc, char *argv[])
{
- int fd = open(PCI_BASE, OPENFLAG_READ);
+ int fd = _SysOpen(PCI_BASE, OPENFLAG_READ);
char name[256];
- while( SysReadDir(fd, name) )
+ while( _SysReadDir(fd, name) )
{
if(name[0] == '.') continue ;
show_device(fd, name, 0);
}
+ _SysClose(fd);
+
return 0;
}
printf("%s - ERR (open failure)\n", File);
return ;
}
- rv = read(fd, &pciinfo, sizeof(pciinfo));
+ rv = _SysRead(fd, &pciinfo, sizeof(pciinfo));
if( rv != sizeof(pciinfo) ) {
printf("%s - ERR (read %i < %i)\n", File, rv, sizeof(pciinfo));
- close(fd);
+ _SysClose(fd);
return ;
}
uint32_t class_if = pciinfo.revclass >> 8;
printf("\n");
}
- close(fd);
+ _SysClose(fd);
}
}
// Check Device
- fd = open(sDevice, OPENFLAG_READ);
+ fd = _SysOpen(sDevice, OPENFLAG_READ);
if(fd == -1) {
printf("Device '%s' cannot be opened for reading\n", sDevice);
return EXIT_FAILURE;
}
- close(fd);
+ _SysClose(fd);
// Check Mount Point
- fd = open(sDir, OPENFLAG_EXEC);
+ fd = _SysOpen(sDir, OPENFLAG_EXEC);
if(fd == -1) {
printf("Directory '%s' does not exist\n", sDir);
return EXIT_FAILURE;
}
- close(fd);
+ _SysClose(fd);
// Replace sOptions with an empty string if it is still NULL
if(sOptions == NULL) sOptions = "";
free(iface); // TODO: Handle when this is not heap
iface = _iface;
printf("iface = '%s'\n", iface);
- fd = open(iface, OPENFLAG_EXEC);
+ fd = _SysOpen(iface, OPENFLAG_EXEC);
if(fd == -1) {
fprintf(stderr, "ERROR: Unable to open interface '%s'\n", iface);
return 1;
}
}
- call = ioctl(fd, 3, "ping");
+ call = _SysIOCtl(fd, 3, "ping");
if(call == 0) {
fprintf(stderr, "ERROR: '%s' does not have a 'ping' call\n", iface);
return 1;
for( i = 0; i < giNumberOfPings; i ++ )
{
- ping = ioctl(fd, call, addr);
+ ping = _SysIOCtl(fd, call, addr);
printf("ping = %i\n", ping);
}
- close(fd);
+ _SysClose(fd);
return 0;
}
// Read from server, and write to stdout\r
do\r
{\r
- len = read(server_fd, buffer, BUFSIZ);\r
- write(1, buffer, len);\r
+ len = _SysRead(server_fd, buffer, BUFSIZ);\r
+ _SysWrite(1, buffer, len);\r
} while( len == BUFSIZ );\r
}\r
\r
char *line = Readline_NonBlock(readline_info);\r
if( line )\r
{\r
- write(server_fd, line, strlen(line));\r
- write(server_fd, "\n", 1);\r
+ _SysWrite(server_fd, line, strlen(line));\r
+ _SysWrite(server_fd, "\n", 1);\r
}\r
}\r
else\r
{\r
do\r
{\r
- len = read(0, buffer, BUFSIZ);\r
- write(server_fd, buffer, len);\r
- write(1, buffer, len);\r
+ len = _SysRead(0, buffer, BUFSIZ);\r
+ _SysWrite(server_fd, buffer, len);\r
+ _SysWrite(1, buffer, len);\r
} while( len == BUFSIZ );\r
}\r
}\r
}\r
}\r
\r
- close(server_fd);\r
+ _SysClose(server_fd);\r
return 0;\r
}\r
\r
}\r
\r
// Set remote port and address\r
- ioctl(fd, 5, &PortNumber);\r
- ioctl(fd, 6, addrBuffer);\r
+ _SysIOCtl(fd, 5, &PortNumber);\r
+ _SysIOCtl(fd, 6, addrBuffer);\r
\r
// Connect\r
- if( ioctl(fd, 7, NULL) == 0 ) {\r
+ if( _SysIOCtl(fd, 7, NULL) == 0 ) {\r
fprintf(stderr, "Unable to start connection\n");\r
return -1;\r
}\r
/*
+ * Acess2 Telnet Server (TCP server test case)
+ * - By John Hodge (thePowersGang)
+ *
+ * main.c
+ * - All
*/
#include <stddef.h>
#include <net.h>
-#include <unistd.h>
#include <stdio.h>
+#include <acess/sys.h>
// === TYPES ===
typedef struct sClient
int addrtype = Net_ParseAddress("10.0.2.10", data);
int port = 23;
giServerFD = Net_OpenSocket(addrtype, data, "tcps");
- ioctl(giServerFD, 4, &port); // Set port and start listening
+ _SysIOCtl(giServerFD, 4, &port); // Set port and start listening
}
// Event loop
}
// Select!
- select( maxfd+1, &fds, NULL, NULL, NULL );
+ _SysSelect( maxfd+1, &fds, NULL, NULL, NULL, 0 );
// Check events
if( FD_ISSET(giServerFD, &fds) )
if( giNumClients == giConfig_MaxClients )
{
// Open, reject
- close( _SysOpenChild(FD, "", O_RDWR) );
+ _SysClose( _SysOpenChild(FD, "", OPENFLAG_READ) );
return ;
}
}
}
// Accept the connection
- clt->Socket = _SysOpenChild(FD, "", O_RDWR);
+ clt->Socket = _SysOpenChild(FD, "", OPENFLAG_READ|OPENFLAG_WRITE);
giNumClients ++;
// Create stdin/stdout
- clt->stdin = open("/Devices/fifo/anon", O_RDWR);
- clt->stdout = open("/Devices/fifo/anon", O_RDWR);
+ clt->stdin = _SysOpen("/Devices/fifo/anon", OPENFLAG_READ|OPENFLAG_WRITE);
+ clt->stdout = _SysOpen("/Devices/fifo/anon", OPENFLAG_READ|OPENFLAG_WRITE);
// TODO: Arguments and envp
{
char buf[BUFSIZ];
int len;
- len = read(Client->Socket, buf, BUFSIZ);
+ len = _SysRead(Client->Socket, buf, BUFSIZ);
if( len <= 0 ) return ;
- write(Client->stdin, buf, len);
+ _SysWrite(Client->stdin, buf, len);
}
void HandleClientBoundData(tClient *Client)
char buf[BUFSIZ];
int len;
- len = read(Client->stdout, buf, BUFSIZ);
+ len = _SysRead(Client->stdout, buf, BUFSIZ);
if( len <= 0 ) return ;
- write(Client->Socket, buf, len);
+ _SysWrite(Client->Socket, buf, len);
}
#include <string.h>
#include <unistd.h>
#include <netdb.h>
+#include <acess/sys.h> // _SysDebug
enum eProcols
{
if( state == 2 )
{
_SysDebug("RXing %i bytes to '%s'", bytes_wanted, outfile);
- int outfd = open(outfile, O_WR|O_CREAT, 0666);
+ int outfd = open(outfile, O_WRONLY|O_CREAT, 0666);
if( outfd == -1 ) {
fprintf(stderr, "Unable to open '%s' for writing\n", outfile);
}
@echo [CC] -o $@
@mkdir -p $(dir $@)
@$(CC) $(CFLAGS) $(CPPFLAGS) -o $@ -c $<
$(_OBJPREFIX)%.ao: %.$(ASSUFFIX)
@echo [AS] -o $@
INCFILES := sys/sys.h
CFLAGS = -g -Wall -fno-builtin -fno-leading-underscore -fno-stack-protector -fPIC
-CFLAGS += $(CPPFLAGS)
+CFLAGS += $(CPPFLAGS) -Werror
LDFLAGS = -g -T arch/$(ARCHDIR).ld -Map map.txt --export-dynamic
include ../Makefile.tpl
#define SYSCALL5(name,num) void name(void){}
#define SYSCALL6(name,num) void name(void){}
+#define NO_SYSCALL_STRS
#include "arch/syscalls.s.h"
// libgcc functions
// --- Process Control ---
SYSCALL1(_exit, SYS_EXIT)
-SYSCALL2(clone, SYS_CLONE)
-SYSCALL2(kill, SYS_KILL)
-SYSCALL0(yield, SYS_YIELD)
-SYSCALL0(sleep, SYS_SLEEP)
+SYSCALL2(_SysClone, SYS_CLONE)
+SYSCALL2(_SysKill, SYS_KILL)
+//SYSCALL0(yield, SYS_YIELD)
+//SYSCALL0(sleep, SYS_SLEEP)
SYSCALL1(_SysWaitEvent, SYS_WAITEVENT)
-SYSCALL2(waittid, SYS_WAITTID)
+SYSCALL2(_SysWaitTID, SYS_WAITTID)
SYSCALL0(gettid, SYS_GETTID)
SYSCALL0(getpid, SYS_GETPID)
SYSCALL1(setuid, SYS_SETUID)
SYSCALL1(setgid, SYS_SETGID)
-SYSCALL1(SysSetName, SYS_SETNAME)
-SYSCALL2(SysGetName, SYS_GETNAME)
+SYSCALL1(_SysSetName, SYS_SETNAME)
+SYSCALL2(_SysGetName, SYS_GETNAME)
SYSCALL0(_SysTimestamp, SYS_GETTIME)
-SYSCALL1(SysSetPri, SYS_SETPRI)
+SYSCALL1(_SysSetPri, SYS_SETPRI)
-SYSCALL3(SysSendMessage, SYS_SENDMSG)
-SYSCALL3(SysGetMessage, SYS_GETMSG)
+SYSCALL3(_SysSendMessage, SYS_SENDMSG)
+SYSCALL3(_SysGetMessage, SYS_GETMSG)
SYSCALL5(_SysSpawn, SYS_SPAWN)
-SYSCALL3(execve, SYS_EXECVE)
-SYSCALL2(SysLoadBin, SYS_LOADBIN)
-SYSCALL1(SysUnloadBin, SYS_UNLOADBIN)
+SYSCALL3(_SysExecVE, SYS_EXECVE)
+SYSCALL2(_SysLoadBin, SYS_LOADBIN)
+SYSCALL1(_SysUnloadBin, SYS_UNLOADBIN)
SYSCALL1(_SysSetFaultHandler, SYS_SETFAULTHANDLER)
SYSCALL6(_SysDebug, 0x100)
SYSCALL1(_SysGetPhys, SYS_GETPHYS) // uint64_t _SysGetPhys(uint addr)
SYSCALL1(_SysAllocate, SYS_ALLOCATE) // uint64_t _SysAllocate(uint addr)
-SYSCALL3(SysSetMemFlags, SYS_SETFLAGS) // uint32_t SysSetMemFlags(uint addr, uint flags, uint mask)
+SYSCALL3(_SysSetMemFlags, SYS_SETFLAGS) // uint32_t SysSetMemFlags(uint addr, uint flags, uint mask)
// VFS System calls
-SYSCALL2(open, SYS_OPEN) // char*, int
-SYSCALL3(reopen, SYS_REOPEN) // int, char*, int
-SYSCALL1(close, SYS_CLOSE) // int
-SYSCALL3(read, SYS_READ) // int, uint, void*
-SYSCALL3(write, SYS_WRITE) // int, uint, void*
-SYSCALL4(seek, SYS_SEEK) // int, uint64_t, int
-SYSCALL1(tell, SYS_TELL) // int
-SYSCALL3(finfo, SYS_FINFO) // int, void*, int
-SYSCALL2(SysReadDir, SYS_READDIR) // int, char*
+SYSCALL2(_SysOpen, SYS_OPEN) // char*, int
+SYSCALL3(_SysOpenChild, SYS_OPENCHILD) // int, char*, int
+SYSCALL3(_SysReopen, SYS_REOPEN) // int, char*, int
+SYSCALL1(_SysClose, SYS_CLOSE) // int
+SYSCALL3(_SysRead, SYS_READ) // int, uint, void*
+SYSCALL3(_SysWrite, SYS_WRITE) // int, uint, void*
+SYSCALL4(_SysSeek, SYS_SEEK) // int, uint64_t, int
+SYSCALL1(_SysTell, SYS_TELL) // int
+SYSCALL3(_SysFInfo, SYS_FINFO) // int, void*, int
+SYSCALL2(_SysReadDir, SYS_READDIR) // int, char*
SYSCALL2(_SysGetACL,SYS_GETACL) // int, void*
-SYSCALL1(chdir, SYS_CHDIR) // char*
-SYSCALL3(ioctl, SYS_IOCTL) // int, int, void*
+SYSCALL1(_SysChdir, SYS_CHDIR) // char*
+SYSCALL3(_SysIOCtl, SYS_IOCTL) // int, int, void*
SYSCALL4(_SysMount, SYS_MOUNT) // char*, char*, char*, char*
SYSCALL6(_SysSelect, SYS_SELECT) // int, fd_set*, fd_set*, fd_set*, tTime*, uint32_t
-SYSCALL1(unlink, SYS_UNLINK) // const char*
+SYSCALL1(_SysUnlink, SYS_UNLINK) // const char*
-SYSCALL3(_SysOpenChild, SYS_OPENCHILD)
#include <stddef.h>
#include <stdarg.h>
#include <stdint.h>
+#include <acess/sys.h>
typedef uintptr_t Uint;
typedef uint8_t Uint8;
extern void *memcpy(void *dest, const void *src, size_t len);
// === System Calls ===
-extern void _exit(int retval);
-extern void SysDebug(const char *fmt, ...); //!< Now implemented in main.c
-extern void SysDebugV(const char *fmt, ...);
-extern void *SysLoadBin(const char *path, void **entry);
-extern int SysUnloadBin(void *Base);
-extern void SysSetFaultHandler(int (*Hanlder)(int));
-extern int open(const char *filename, int flags, ...);
-extern int close(int fd);
// === ELF Loader ===
extern void *ElfRelocate(void *Base, char **envp, const char *Filename);
uintptr_t addr = phtab[i].VAddr + iBaseDiff;
uintptr_t end = addr + phtab[i].MemSize;
for( ; addr < end; addr += PAGE_SIZE )
- SysSetMemFlags(addr, 0, 1); // Unset RO
+ _SysSetMemFlags(addr, 0, 1); // Unset RO
}
}
uintptr_t addr = phtab[i].VAddr + iBaseDiff;
uintptr_t end = addr + phtab[i].MemSize;
for( ; addr < end; addr += PAGE_SIZE )
- SysSetMemFlags(addr, 1, 1); // Unset RO
+ _SysSetMemFlags(addr, 1, 1); // Unset RO
}
}
--- /dev/null
+/*
+ * Acess2 Dynamic Linker
+ * - By John Hodge (thePowersGang)
+ *
+ * acess/fd_set.h
+ * - fd_set structure used by select()
+ */
+#ifndef _ACESS__FD_SET_H_
+#define _ACESS__FD_SET_H_
+
+#define FD_SETSIZE 128
+
+typedef unsigned short fd_set_ent_t;
+
+/**
+ * \brief fd_set for select()
+ */
+typedef struct
+{
+ fd_set_ent_t flags[FD_SETSIZE/16];
+} fd_set;
+
+
+extern void FD_ZERO(fd_set *fdsetp);
+extern void FD_CLR(int fd, fd_set *fdsetp);
+extern void FD_SET(int fd, fd_set *fdsetp);
+extern int FD_ISSET(int fd, fd_set *fdsetp);
+
+#endif
+++ /dev/null
-/*
- */
-#ifndef _ACESS_INTDEFS_H_
-#define _ACESS_INTDEFS_H_
-
-#include <stdint.h>
-#include <limits.h>
-
-#if 0
-#define INT_MIN -0x80000000
-#define INT_MAX 0x7FFFFFFF
-
-typedef unsigned char __uint8_t;
-typedef unsigned short __uint16_t;
-typedef unsigned int __uint32_t;
-typedef unsigned long long __uint64_t;
-
-typedef signed char __int8_t;
-typedef signed short __int16_t;
-typedef signed int __int32_t;
-typedef signed long long __int64_t;
-
-#if defined(ARCHDIR_is_x86)
-typedef __int32_t __intptr_t;
-typedef __uint32_t __uintptr_t;
-#elif defined(ARCHDIR_is_x86_64)
-typedef __int64_t __intptr_t;
-typedef __uint64_t __uintptr_t;
-#elif defined(ARCHDIR_is_armv7) | defined(ARCHDIR_is_armv6)
-typedef __int32_t __intptr_t;
-typedef __uint32_t __uintptr_t;
-#else
-# error "Unknown pointer size"
-#endif
-
-#endif
-
-#endif
-
#define _ACESS_SYS_H_
#include <stdint.h>
-#include "../sys/types.h"
+#include <stddef.h> // size_t
+#include "syscall_types.h"
// === CONSTANTS ===
#ifndef NULL
#define OPENFLAG_EXEC 0x01
#define OPENFLAG_READ 0x02
#define OPENFLAG_WRITE 0x04
+#define OPENFLAG_RDWR (OPENFLAG_READ|OPENFLAG_WRITE)
#define OPENFLAG_TRUNCATE 0x10
#define OPENFLAG_APPEND 0x20
#define OPENFLAG_NOLINK 0x40
extern void _SysDebug(const char *format, ...);
// --- Proc ---
extern void _exit(int status) __attribute__((noreturn));
-extern void sleep(void);
-extern void yield(void);
-extern int kill(int pid, int sig);
-//extern void wait(int miliseconds);
+extern int _SysKill(int pid, int sig);
extern int _SysWaitEvent(int EventMask);
-extern int waittid(int id, int *status);
-extern int clone(int flags, void *stack);
-extern int execve(char *path, char **argv, char **envp);
+extern int _SysWaitTID(int id, int *status);
+extern int _SysClone(int flags, void *stack);
+extern int _SysExecVE(const char *path, char **argv, char **envp);
extern int _SysSpawn(const char *Path, const char **argv, const char **envp, int nFDs, int *FDs, struct s_sys_spawninfo *info);
extern int gettid(void);
extern int getpid(void);
extern int _SysSetFaultHandler(int (*Handler)(int));
-extern void SysSetName(const char *Name);
-extern int SysGetName(char *NameDest);
-extern int SysSetPri(int Priority);
+extern void _SysSetName(const char *Name);
+extern int _SysGetName(char *NameDest);
+extern int _SysSetPri(int Priority);
+// --- Timekeeping ---
extern int64_t _SysTimestamp(void);
// --- Permissions ---
extern void setgid(int id);
// --- VFS ---
-extern int chdir(const char *dir);
-extern int open(const char *path, int flags, ...);
-extern int reopen(int fd, const char *path, int flags);
-extern int close(int fd);
-extern uint read(int fd, void *buffer, uint length);
-extern uint write(int fd, const void *buffer, uint length);
-extern int seek(int fd, int64_t offset, int whence);
-extern uint64_t tell(int fd);
-extern int ioctl(int fd, int id, void *data);
-extern int finfo(int fd, t_sysFInfo *info, int maxacls);
-extern int SysReadDir(int fd, char *dest);
+extern int _SysChdir(const char *dir);
+extern int _SysChroot(const char *dir);
+
+extern int _SysOpen(const char *path, int flags, ...);
extern int _SysOpenChild(int fd, const char *name, int flags);
+extern int _SysOpenPipe(int *read, int *write, int flags);
+extern int _SysReopen(int fd, const char *path, int flags);
+extern int _SysCopyFD(int srcfd, int dstfd);
+extern size_t _SysRead(int fd, void *buffer, size_t length);
+extern int _SysClose(int fd);
+extern int _SysFDCtl(int fd, int option, ...);
+extern size_t _SysWrite(int fd, const void *buffer, size_t length);
+extern int _SysSeek(int fd, int64_t offset, int whence);
+extern uint64_t _SysTell(int fd);
+extern int _SysIOCtl(int fd, int id, void *data);
+extern int _SysFInfo(int fd, t_sysFInfo *info, int maxacls);
+extern int _SysReadDir(int fd, char *dest);
extern int _SysGetACL(int fd, t_sysACL *dest);
extern int _SysMount(const char *Device, const char *Directory, const char *Type, const char *Options);
extern int _SysSelect(int nfds, fd_set *read, fd_set *write, fd_set *err, int64_t *timeout, unsigned int extraevents);
#define select(nfs, rdfds, wrfds, erfds, timeout) _SysSelect(nfs, rdfds, wrfds, erfds, timeout, 0)
-extern int unlink(const char *pathname);
+extern int _SysUnlink(const char *pathname);
// --- IPC ---
-extern int SysSendMessage(pid_t dest, uint length, const void *Data);
-extern int SysGetMessage(pid_t *src, uint buflen, void *Data);
+extern int _SysSendMessage(int dest, size_t length, const void *Data);
+extern int _SysGetMessage(int *src, size_t buflen, void *Data);
// --- MEMORY ---
-uint64_t _SysGetPhys(uint vaddr);
-uint64_t _SysAllocate(uint vaddr);
-uint32_t SysSetMemFlags(uint vaddr, uint32_t flags, uint32_t mask);
+extern uint64_t _SysGetPhys(uintptr_t vaddr);
+extern uint64_t _SysAllocate(uintptr_t vaddr);
+extern uint32_t _SysSetMemFlags(uintptr_t vaddr, uint32_t flags, uint32_t mask);
+extern void *_SysLoadBin(const char *path, void **entry);
+extern int _SysUnloadBin(void *base);
+extern void SysSetFaultHandler(int (*Hanlder)(int));
#endif
* acess/syscall_types.h
* - Structures used for syscalls
*/
-
#ifndef _ACESS__SYSCALL_TYPES_H_
#define _ACESS__SYSCALL_TYPES_H_
+#include "fd_set.h"
+
struct s_sysACL {
unsigned long object; /*!< Group or user (bit 31 determines) */
unsigned long perms; /*!< Inverted by bit 31 */
unsigned int gid;
unsigned int flags;
unsigned long long size;
- time_t atime;
- time_t mtime;
- time_t ctime;
+ int64_t atime;
+ int64_t mtime;
+ int64_t ctime;
int numacls;
struct s_sysACL acls[];
} __attribute__((packed));
+++ /dev/null
-#ifndef _STDDEF_H_
-#define _STDDEF_H_
-
-#include "acess/intdefs.h"
-
-#ifndef NULL
-# define NULL ((void*)0)
-#endif
-
-typedef __intptr_t size_t;
-
-#endif
+++ /dev/null
-/*
- * Acess2 C Library
- * - By John Hodge (thePowersGang)
- */
-#ifndef _SYS_STAT_H_
-#define _SYS_STAT_H_
-
-//#include "../acess/intdefs.h" /* Evil */
-//#include "../stddef.h"
-#include <stdint.h>
-
-typedef void *dev_t; /* TODO: How to identify a device with Acess */
-typedef uint64_t ino_t;
-typedef unsigned int blksize_t;
-typedef uint64_t blkcnt_t;
-typedef unsigned int nlink_t;
-typedef uint32_t mode_t;
-
-typedef uint32_t uid_t;
-typedef uint32_t gid_t;
-
-#define S_IFMT 0170000 /* type of file */
-#define S_IFDIR 0040000 /* directory */
-#define S_IFCHR 0020000 /* character special */
-#define S_IFBLK 0060000 /* block special */
-#define S_IFREG 0100000 /* regular */
-#define S_IFLNK 0120000 /* symbolic link */
-#define S_IFSOCK 0140000 /* socket */
-#define S_IFIFO 0010000 /* fifo */
-
-
-struct stat
-{
- dev_t st_dev; /* ID of device containing file */
- ino_t st_ino; /* inode number */
- mode_t st_mode; /* protection */
- nlink_t st_nlink; /* number of hard links */
- uid_t st_uid; /* user ID of owner */
- gid_t st_gid; /* group ID of owner */
- dev_t st_rdev; /* device ID (if special file) */
- off_t st_size; /* total size, in bytes */
- blksize_t st_blksize; /* blocksize for file system I/O */
- blkcnt_t st_blocks; /* number of 512B blocks allocated */
- time_t st_atime; /* time of last access */
- time_t st_mtime; /* time of last modification */
- time_t st_ctime; /* time of last status change */
-};
-
-extern int stat(const char *path, struct stat *buf);
-extern int fstat(int fd, struct stat *buf);
-
-#endif
+++ /dev/null
-/*\r
- Syscall Definitions\r
-*/\r
-#ifndef _SYS_SYS_H_\r
-#define _SYS_SYS_H_\r
-\r
-#include <acess/sys.h>\r
-\r
-#include <sys/types.h>\r
-\r
-//#define O_RDONLY OPENFLAG_READ\r
-//#define O_WRONLY OPENFLAG_WRITE\r
-//#define O_CREAT (OPENFLAG_CREATE|OPENFLAG_WRITE)\r
-//#define O_TRUNC OPENFLAG_WRITE\r
-//#define O_APPEND OPENFLAG_WRITE\r
-\r
-\r
-#if 0\r
-#define OPEN_FLAG_READ 1\r
-#define OPEN_FLAG_WRITE 2\r
-#define OPEN_FLAG_EXEC 4\r
-\r
-enum {\r
- K_WAITPID_DIE = 0\r
-};\r
-\r
-// === System Calls ===\r
-extern void _exit(int ret);\r
-extern int brk(int bssend);\r
-extern int execve(char *file, char *args[], char *envp[]);\r
-extern int fork();\r
-extern int yield();\r
-extern int sleep();\r
-\r
-extern int open(char *file, int flags);\r
-extern int close(int fp);\r
-extern int read(int fp, int len, void *buf);\r
-extern int write(int fp, int len, void *buf);\r
-extern int tell(int fp);\r
-extern void seek(int fp, int64_t dist, int flag);\r
-extern int fstat(int fp, t_fstat *st);\r
-extern int ioctl(int fp, int call, void *arg);\r
-extern int readdir(int fp, char *file);\r
-\r
-extern int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *errfds, time_t *timeout);\r
-\r
-extern int kdebug(char *fmt, ...);\r
-extern int waitpid(int pid, int action);\r
-extern int gettid(); // Get Thread ID\r
-extern int getpid(); // Get Process ID\r
-extern int sendmsg(int dest, unsigned int *Data);\r
-extern int pollmsg(int *src, unsigned int *Data);\r
-extern int getmsg(int *src, unsigned int *Data);\r
-#endif\r
-\r
-#endif\r
+++ /dev/null
-/*
- */
-#ifndef _SYS_TYPES_H
-#define _SYS_TYPES_H
-
-#include "../acess/intdefs.h"
-
-typedef struct stat t_fstat;
-
-#define FD_SETSIZE 128
-
-
-#define CLONE_VM 0x10
-
-typedef unsigned int id_t;
-typedef unsigned long pid_t;
-typedef unsigned long tid_t;
-typedef signed long long int time_t;
-typedef long long int off_t;
-
-typedef unsigned int uint;
-
-typedef unsigned short fd_set_ent_t;
-
-/**
- * \brief fd_set for select()
- */
-typedef struct
-{
- fd_set_ent_t flags[FD_SETSIZE/16];
-} fd_set;
-
-#include "../acess/syscall_types.h"
-
-extern void FD_ZERO(fd_set *fdsetp);
-extern void FD_CLR(int fd, fd_set *fdsetp);
-extern void FD_SET(int fd, fd_set *fdsetp);
-extern int FD_ISSET(int fd, fd_set *fdsetp);
-
-#include "../sys/stat.h"
-
-#endif
+++ /dev/null
-#ifndef _UNISTD_H_
-#define _UNISTD_H_
-
-#define O_RDWR (OPENFLAG_READ|OPENFLAG_WRITE)
-#define O_WR (OPENFLAG_WRITE)
-#define O_RD (OPENFLAG_READ)
-#define O_CREAT (OPENFLAG_CREATE)
-#define O_RDONLY OPENFLAG_READ
-#define O_WRONLY OPENFLAG_WRITE
-#define O_TRUNC OPENFLAG_TRUNCATE
-#define O_APPEND OPENFLAG_APPEND
-
-//typedef intptr_t ssize_t;
-
-#include "acess/sys.h"
-
-
-#endif
-
int file_exists(const char *filename)
{
int fd;
- //fd = open(filename, OPENFLAG_READ);
- fd = open(filename, 0);
+ fd = _SysOpen(filename, 0);
if(fd == -1) return 0;
- close(fd);
+ _SysClose(fd);
return 1;
}
*/
#include "common.h"
#include <stdint.h>
+#include <acess/sys.h>
#define DEBUG 0
DEBUGS(" LoadLibrary: SysLoadBin()");
// Load Library
- base = SysLoadBin(filename, (void**)&fEntry);
+ base = _SysLoadBin(filename, (void**)&fEntry);
if(!base) {
DEBUGS("LoadLibrary: RETURN 0");
return 0;
if(id == MAX_LOADED_LIBRARIES) return;
// Unload Binary
- SysUnloadBin( Base );
+ _SysUnloadBin( Base );
// Save String Pointer
str = gLoadedLibraries[id].Name;
\r
INCFILES := stdio.h stdlib.h\r
\r
-OBJ = stub.o heap.o stdlib.o env.o fileIO.o string.o select.o rand.o\r
-OBJ += perror.o scanf.o signals.o\r
+OBJ = stub.o heap.o stdlib.o env.o stdio.o string.o select.o rand.o\r
+OBJ += perror.o scanf.o signals.o strtoi.o\r
OBJ += arch/$(ARCHDIR).ao\r
# signals.o\r
DEPFILES := $(OBJ:%.o=%.d)\r
+++ /dev/null
-/*\r
- * AcessOS Basic C Library\r
- * stdio.c\r
- */\r
-#include "config.h"\r
-#include <acess/sys.h>\r
-#include <stdlib.h>\r
-#include <stdio.h>\r
-#include <string.h>\r
-#include "lib.h"\r
-#include "stdio_int.h"\r
-\r
-#define WRITE_STR(_fd, _str) write(_fd, _str, sizeof(_str))\r
-\r
-#define DEBUG_BUILD 0\r
-\r
-// === CONSTANTS ===\r
-#define _stdin 0\r
-#define _stdout 1\r
-\r
-// === PROTOTYPES ===\r
-EXPORT void itoa(char *buf, uint64_t num, size_t base, int minLength, char pad, int bSigned);\r
-struct sFILE *get_file_struct();\r
-\r
-// === GLOBALS ===\r
-struct sFILE _iob[STDIO_MAX_STREAMS]; // IO Buffer\r
-struct sFILE *stdin; // Standard Input\r
-struct sFILE *stdout; // Standard Output\r
-struct sFILE *stderr; // Standard Error\r
-///\note Initialised in SoMain\r
-\r
-// === CODE ===\r
-int _fopen_modetoflags(const char *mode)\r
-{\r
- int flags = 0;\r
- \r
- // Get main mode\r
- switch(*mode)\r
- {\r
- case 'r': flags = FILE_FLAG_MODE_READ; break;\r
- case 'w': flags = FILE_FLAG_MODE_WRITE; break;\r
- case 'a': flags = FILE_FLAG_MODE_APPEND; break;\r
- case 'x': flags = FILE_FLAG_MODE_EXEC; break; // Acess addon\r
- default:\r
- return -1;\r
- }\r
- mode ++;\r
-\r
- // Get Modifiers\r
- for( ; *mode; mode ++ )\r
- {\r
- switch(*mode)\r
- {\r
- case 'b': flags |= FILE_FLAG_M_BINARY; break;\r
- case '+': flags |= FILE_FLAG_M_EXT; break;\r
- default:\r
- return -1;\r
- }\r
- }\r
- \r
- return flags;\r
-}\r
-\r
-/**\r
- * \fn FILE *freopen(char *file, char *mode, FILE *fp)\r
- */\r
-EXPORT FILE *freopen(const char *file, const char *mode, FILE *fp)\r
-{\r
- int openFlags = 0;\r
- \r
- // Sanity Check Arguments\r
- if(!fp || !file || !mode) return NULL;\r
- \r
- if(fp->FD != -1) {\r
- fflush(fp);\r
- }\r
-\r
- // Get stdio flags\r
- fp->Flags = _fopen_modetoflags(mode);\r
- if(fp->Flags == -1)\r
- return NULL;\r
- \r
- // Get Open Flags\r
- switch(fp->Flags & FILE_FLAG_MODE_MASK)\r
- {\r
- // Read\r
- case FILE_FLAG_MODE_READ:\r
- openFlags = OPENFLAG_READ;\r
- if(fp->Flags & FILE_FLAG_M_EXT)\r
- openFlags |= OPENFLAG_WRITE;\r
- break;\r
- // Write\r
- case FILE_FLAG_MODE_WRITE:\r
- openFlags = OPENFLAG_WRITE;\r
- if(fp->Flags & FILE_FLAG_M_EXT)\r
- openFlags |= OPENFLAG_READ;\r
- break;\r
- // Execute\r
- case FILE_FLAG_MODE_APPEND:\r
- openFlags = OPENFLAG_APPEND;\r
- if(fp->Flags & FILE_FLAG_M_EXT)\r
- openFlags |= OPENFLAG_READ;\r
- break;\r
- // Execute\r
- case FILE_FLAG_MODE_EXEC:\r
- openFlags = OPENFLAG_EXEC;\r
- break;\r
- }\r
-\r
- //Open File\r
- if(fp->FD != -1)\r
- fp->FD = reopen(fp->FD, file, openFlags);\r
- else\r
- fp->FD = open(file, openFlags);\r
- if(fp->FD == -1) {\r
- fp->Flags = 0;\r
- return NULL;\r
- }\r
- \r
- if( (fp->Flags & FILE_FLAG_MODE_MASK) == FILE_FLAG_MODE_APPEND ) {\r
- seek(fp->FD, 0, SEEK_END); //SEEK_END\r
- }\r
- \r
- return fp;\r
-}\r
-/**\r
- \fn FILE *fopen(const char *file, const char *mode)\r
- \brief Opens a file and returns the pointer\r
- \param file String - Filename to open\r
- \param mode Mode to open in\r
-*/\r
-EXPORT FILE *fopen(const char *file, const char *mode)\r
-{\r
- FILE *retFile;\r
- \r
- // Sanity Check Arguments\r
- if(!file || !mode) return NULL;\r
- \r
- // Create Return Structure\r
- retFile = get_file_struct();\r
- \r
- return freopen(file, mode, retFile);\r
-}\r
-\r
-EXPORT FILE *fmemopen(void *buffer, size_t length, const char *mode)\r
-{\r
- FILE *ret;\r
- \r
- if( !buffer || !mode ) return NULL;\r
- \r
- ret = get_file_struct();\r
- \r
- ret->FD = -2;\r
- ret->Flags = _fopen_modetoflags(mode);\r
- if(ret->Flags == -1) {\r
- ret->Flags = 0;\r
- return NULL;\r
- }\r
- \r
- ret->Buffer = buffer;\r
- ret->BufferStart = 0;\r
- ret->BufferSize = length;\r
- \r
- return ret;\r
-}\r
-\r
-EXPORT int fclose(FILE *fp)\r
-{\r
- fflush(fp);\r
- if( fp->FD != -1 ) {\r
- close(fp->FD);\r
- }\r
- fp->Flags = 0;\r
- fp->FD = -1;\r
- return 0;\r
-}\r
-\r
-EXPORT void fflush(FILE *fp)\r
-{\r
- if( !fp || fp->FD == -1 )\r
- return ;\r
- \r
- if( !(fp->Flags & FILE_FLAG_DIRTY) )\r
- return ;\r
- \r
- // Nothing to do for memory files\r
- if( fp->FD == -2 )\r
- return ;\r
-}\r
-\r
-EXPORT void clearerr(FILE *fp)\r
-{\r
- if( !fp || fp->FD == -1 )\r
- return ;\r
- \r
- // TODO: Impliment clearerr()\r
-}\r
-\r
-EXPORT int feof(FILE *fp)\r
-{\r
- if( !fp || fp->FD == -1 )\r
- return 0;\r
- return !!(fp->Flags & FILE_FLAG_EOF);\r
-}\r
-\r
-EXPORT int ferror(FILE *fp)\r
-{\r
- if( !fp || fp->FD == -1 )\r
- return 0;\r
- return 0;\r
-}\r
-EXPORT int fileno(FILE *stream)\r
-{\r
- return stream->FD;\r
-}\r
-\r
-EXPORT off_t ftell(FILE *fp)\r
-{\r
- if(!fp || fp->FD == -1) return -1;\r
-\r
- if( fp->FD == -2 )\r
- return fp->Pos; \r
- else\r
- return tell(fp->FD);\r
-}\r
-\r
-EXPORT int fseek(FILE *fp, long int amt, int whence)\r
-{\r
- if(!fp || fp->FD == -1) return -1;\r
-\r
- if( fp->FD == -2 ) {\r
- switch(whence)\r
- {\r
- case SEEK_CUR:\r
- fp->Pos += amt;\r
- break;\r
- case SEEK_SET:\r
- fp->Pos = amt;\r
- break;\r
- case SEEK_END:\r
- if( fp->BufferSize < (size_t)amt )\r
- fp->Pos = 0;\r
- else\r
- fp->Pos = fp->BufferSize - amt;\r
- break;\r
- }\r
- if(fp->Pos > (off_t)fp->BufferSize) {\r
- fp->Pos = fp->BufferSize;\r
- fp->Flags |= FILE_FLAG_EOF;\r
- }\r
- return 0;\r
- }\r
- else\r
- return seek(fp->FD, amt, whence);\r
-}\r
-\r
-\r
-/**\r
- * \fn EXPORT int vfprintf(FILE *fp, const char *format, va_list args)\r
- * \brief Print to a file from a variable argument list\r
- */\r
-EXPORT int vfprintf(FILE *fp, const char *format, va_list args)\r
-{\r
- va_list tmpList;\r
- int size;\r
-\r
- if(!fp || !format) return -1;\r
-\r
- va_copy(tmpList, args);\r
- \r
- size = vsnprintf(NULL, 0, (char*)format, tmpList);\r
- char buf[size+1];\r
- vsnprintf(buf, size+1, (char*)format, args);\r
- \r
- // Write to stream\r
- fwrite(buf, size, 1, fp);\r
- \r
- // Return written byte count\r
- return size;\r
-}\r
-\r
-/**\r
- * \fn int fprintf(FILE *fp, const char *format, ...)\r
- * \brief Print a formatted string to a stream\r
- */\r
-EXPORT int fprintf(FILE *fp, const char *format, ...)\r
-{\r
- va_list args;\r
- int ret;\r
- \r
- // Get Size\r
- va_start(args, format);\r
- ret = vfprintf(fp, (char*)format, args);\r
- va_end(args);\r
- \r
- return ret;\r
-}\r
-\r
-/**\r
- * \fn EXPORT size_t fwrite(void *ptr, size_t size, size_t num, FILE *fp)\r
- * \brief Write to a stream\r
- */\r
-EXPORT size_t fwrite(void *ptr, size_t size, size_t num, FILE *fp)\r
-{\r
- size_t ret;\r
- \r
- if(!fp || fp->FD == -1)\r
- return -1;\r
-\r
- if( fp->FD == -2 ) {\r
- size_t avail = (fp->BufferSize - fp->Pos) / size;\r
- if( avail == 0 )\r
- fp->Flags |= FILE_FLAG_EOF;\r
- if( num > avail ) num = avail;\r
- size_t bytes = num * size;\r
- memcpy((char*)fp->Buffer + fp->Pos, ptr, bytes);\r
- fp->Pos += bytes;\r
- ret = num;\r
- }\r
- else { \r
- ret = write(fp->FD, ptr, size*num);\r
- ret /= size;\r
- }\r
- \r
- return ret;\r
-}\r
-\r
-/**\r
- * \fn EXPORT size_t fread(void *ptr, size_t size, size_t num, FILE *fp)\r
- * \brief Read from a stream\r
- */\r
-EXPORT size_t fread(void *ptr, size_t size, size_t num, FILE *fp)\r
-{\r
- size_t ret;\r
- \r
- if(!fp || fp->FD == -1)\r
- return -1;\r
-\r
- if( fp->FD == -2 ) {\r
- size_t avail = (fp->BufferSize - fp->Pos) / size;\r
- if( avail == 0 )\r
- fp->Flags |= FILE_FLAG_EOF;\r
- if( num > avail ) num = avail;\r
- size_t bytes = num * size;\r
- memcpy(ptr, (char*)fp->Buffer + fp->Pos, bytes);\r
- fp->Pos += bytes;\r
- ret = num;\r
- }\r
- else {\r
- ret = read(fp->FD, ptr, size*num);\r
- ret /= size;\r
- }\r
- \r
- return ret;\r
-}\r
-\r
-/**\r
- * \fn EXPORT int fputc(int c, FILE *fp)\r
- * \brief Write a single character to the stream\r
- */\r
-EXPORT int fputc(int c, FILE *fp)\r
-{\r
- return fwrite(&c, 1, 1, fp);\r
-}\r
-\r
-EXPORT int putchar(int c)\r
-{\r
- c &= 0xFF;\r
- return write(_stdout, &c, 1);\r
-}\r
-\r
-/**\r
- * \fn EXPORT int fgetc(FILE *fp)\r
- * \brief Read a character from the stream\r
- */\r
-EXPORT int fgetc(FILE *fp)\r
-{\r
- char ret = 0;\r
- if( fread(&ret, 1, 1, fp) == (size_t)-1 )\r
- return -1;\r
- return ret;\r
-}\r
-\r
-EXPORT int getchar(void)\r
-{\r
- char ret = 0;\r
- if(read(_stdin, &ret, 1) != 1) return -1;\r
- return ret;\r
-}\r
-\r
-// --- INTERNAL ---\r
-/**\r
- * \fn FILE *get_file_struct()\r
- * \brief Returns a file descriptor structure\r
- */\r
-FILE *get_file_struct()\r
-{\r
- int i;\r
- for(i=0;i<STDIO_MAX_STREAMS;i++)\r
- {\r
- if(_iob[i].Flags & FILE_FLAG_ALLOC)\r
- continue ;\r
- _iob[i].Flags |= FILE_FLAG_ALLOC;\r
- _iob[i].FD = -1;\r
- _iob[i].Pos = 0;\r
- return &_iob[i];\r
- }\r
- return NULL;\r
-}\r
-\r
-EXPORT int puts(const char *str)\r
-{\r
- int len;\r
- \r
- if(!str) return 0;\r
- len = strlen(str);\r
- \r
- len = write(_stdout, str, len);\r
- write(_stdout, "\n", 1);\r
- return len;\r
-}\r
-\r
-EXPORT int vsprintf(char * __s, const char *__format, va_list __args)\r
-{\r
- return vsnprintf(__s, 0x7FFFFFFF, __format, __args);\r
-}\r
-\r
-//sprintfv\r
-/**\r
- * \fn EXPORT void vsnprintf(char *buf, const char *format, va_list args)\r
- * \brief Prints a formatted string to a buffer\r
- * \param buf Pointer - Destination Buffer\r
- * \param format String - Format String\r
- * \param args VarArgs List - Arguments\r
- */\r
-EXPORT int vsnprintf(char *buf, size_t __maxlen, const char *format, va_list args)\r
-{\r
- char tmp[65];\r
- int c, minSize, precision, len;\r
- size_t pos = 0;\r
- char *p;\r
- char pad;\r
- uint64_t arg;\r
- int bLongLong, bPadLeft;\r
-\r
- void _addchar(char ch)\r
- {\r
- if(buf && pos < __maxlen) buf[pos] = ch;\r
- pos ++;\r
- }\r
-\r
- tmp[32] = '\0';\r
- \r
- while((c = *format++) != 0)\r
- {\r
- // Non-control character\r
- if (c != '%') {\r
- _addchar(c);\r
- continue;\r
- }\r
- \r
- // Control Character\r
- c = *format++;\r
- if(c == '%') { // Literal %\r
- _addchar('%');\r
- continue;\r
- }\r
- \r
- bPadLeft = 0;\r
- bLongLong = 0;\r
- minSize = 0;\r
- precision = -1;\r
- pad = ' ';\r
- \r
- // Padding Character\r
- if(c == '0') {\r
- pad = '0';\r
- c = *format++;\r
- }\r
- // Padding length\r
- if( c == '*' ) {\r
- // Variable length\r
- minSize = va_arg(args, size_t);\r
- c = *format++;\r
- }\r
- else {\r
- if('1' <= c && c <= '9')\r
- {\r
- minSize = 0;\r
- while('0' <= c && c <= '9')\r
- {\r
- minSize *= 10;\r
- minSize += c - '0';\r
- c = *format++;\r
- }\r
- }\r
- }\r
-\r
- // Precision\r
- if(c == '.') {\r
- c = *format++;\r
- if(c == '*') {\r
- precision = va_arg(args, size_t);\r
- c = *format++;\r
- }\r
- else if('1' <= c && c <= '9')\r
- {\r
- precision = 0;\r
- while('0' <= c && c <= '9')\r
- {\r
- precision *= 10;\r
- precision += c - '0';\r
- c = *format++;\r
- }\r
- }\r
- }\r
- \r
- // Check for long long\r
- bLongLong = 0;\r
- if(c == 'l')\r
- {\r
- c = *format++;\r
- if(c == 'l') {\r
- bLongLong = 1;\r
- }\r
- }\r
- \r
- // Just help things along later\r
- p = tmp;\r
- \r
- // Get Type\r
- switch( c )\r
- {\r
- // Signed Integer\r
- case 'd': case 'i':\r
- // Get Argument\r
- if(bLongLong) arg = va_arg(args, int64_t);\r
- else arg = va_arg(args, int32_t);\r
- itoa(tmp, arg, 10, minSize, pad, 1);\r
- precision = -1;\r
- goto sprintf_puts;\r
- \r
- // Unsigned Integer\r
- case 'u':\r
- // Get Argument\r
- if(bLongLong) arg = va_arg(args, uint64_t);\r
- else arg = va_arg(args, uint32_t);\r
- itoa(tmp, arg, 10, minSize, pad, 0);\r
- precision = -1;\r
- goto sprintf_puts;\r
- \r
- // Pointer\r
- case 'p':\r
- _addchar('*');\r
- _addchar('0');\r
- _addchar('x');\r
- arg = va_arg(args, intptr_t);\r
- itoa(tmp, arg, 16, minSize, pad, 0);\r
- precision = -1;\r
- goto sprintf_puts;\r
- // Unsigned Hexadecimal\r
- case 'x':\r
- if(bLongLong) arg = va_arg(args, uint64_t);\r
- else arg = va_arg(args, uint32_t);\r
- itoa(tmp, arg, 16, minSize, pad, 0);\r
- precision = -1;\r
- goto sprintf_puts;\r
- \r
- // Unsigned Octal\r
- case 'o':\r
- if(bLongLong) arg = va_arg(args, uint64_t);\r
- else arg = va_arg(args, uint32_t);\r
- itoa(tmp, arg, 8, minSize, pad, 0);\r
- precision = -1;\r
- goto sprintf_puts;\r
- \r
- // Unsigned binary\r
- case 'b':\r
- if(bLongLong) arg = va_arg(args, uint64_t);\r
- else arg = va_arg(args, uint32_t);\r
- itoa(tmp, arg, 2, minSize, pad, 0);\r
- precision = -1;\r
- goto sprintf_puts;\r
-\r
- // String\r
- case 's':\r
- p = va_arg(args, char*);\r
- sprintf_puts:\r
- if(!p) p = "(null)";\r
- //_SysDebug("vsnprintf: p = '%s'", p);\r
- if(precision >= 0)\r
- len = strnlen(p, precision);\r
- else\r
- len = strlen(p);\r
- if(bPadLeft) while(minSize > len++) _addchar(pad);\r
- while( *p ) {\r
- if(precision >= 0 && precision -- == 0)\r
- break;\r
- _addchar(*p++);\r
- }\r
- if(!bPadLeft) while(minSize > len++) _addchar(pad);\r
- break;\r
-\r
- // Unknown, just treat it as a character\r
- default:\r
- arg = va_arg(args, uint32_t);\r
- _addchar(arg);\r
- break;\r
- }\r
- }\r
- _addchar('\0');\r
- pos --;\r
- \r
- //_SysDebug("vsnprintf: buf = '%s'", buf);\r
- \r
- return pos;\r
-}\r
-\r
-const char cUCDIGITS[] = "0123456789ABCDEF";\r
-/**\r
- * \fn static void itoa(char *buf, uint64_t num, int base, int minLength, char pad, int bSigned)\r
- * \brief Convert an integer into a character string\r
- * \param buf Destination Buffer\r
- * \param num Number to convert\r
- * \param base Base-n number output\r
- * \param minLength Minimum length of output\r
- * \param pad Padding used to ensure minLength\r
- * \param bSigned Signed number output?\r
- */\r
-EXPORT void itoa(char *buf, uint64_t num, size_t base, int minLength, char pad, int bSigned)\r
-{\r
- char tmpBuf[64];\r
- int pos=0, i;\r
-\r
- if(!buf) return;\r
- if(base > 16 || base < 2) {\r
- buf[0] = 0;\r
- return;\r
- }\r
- \r
- if(bSigned && (int64_t)num < 0)\r
- {\r
- num = -num;\r
- bSigned = 1;\r
- } else\r
- bSigned = 0;\r
- \r
- // Encode into reversed string\r
- while(num > base-1) {\r
- tmpBuf[pos++] = cUCDIGITS[ num % base ];\r
- num = (uint64_t) num / (uint64_t)base; // Shift {number} right 1 digit\r
- }\r
-\r
- tmpBuf[pos++] = cUCDIGITS[ num % base ]; // Last digit of {number}\r
- if(bSigned) tmpBuf[pos++] = '-'; // Append sign symbol if needed\r
- \r
- i = 0;\r
- minLength -= pos;\r
- while(minLength-- > 0) buf[i++] = pad;\r
- while(pos-- > 0) buf[i++] = tmpBuf[pos]; // Reverse the order of characters\r
- buf[i] = 0;\r
-}\r
-\r
-/**\r
- * \fn EXPORT int printf(const char *format, ...)\r
- * \brief Print a string to stdout\r
- */\r
-EXPORT int printf(const char *format, ...)\r
-{\r
- int size;\r
- va_list args;\r
- \r
- // Get final size\r
- va_start(args, format);\r
- size = vsnprintf(NULL, 0, (char*)format, args);\r
- va_end(args);\r
- char buf[size+1];\r
- // Fill Buffer\r
- va_start(args, format);\r
- vsnprintf(buf, size+1, (char*)format, args);\r
- va_end(args);\r
- \r
- // Send to stdout\r
- write(_stdout, buf, size+1);\r
- \r
- // Free buffer\r
- free(buf);\r
- // Return\r
- return size;\r
-}\r
-\r
-/**\r
- * \fn EXPORT int sprintf(const char *buf, char *format, ...)\r
- * \brief Print a formatted string to a buffer\r
- */\r
-EXPORT int sprintf(char *buf, const char *format, ...)\r
-{\r
- int ret;\r
- va_list args;\r
- va_start(args, format);\r
- ret = vsprintf((char*)buf, (char*)format, args);\r
- va_end(args);\r
- return ret;\r
-}\r
-\r
-/**\r
- * \fn EXPORT int snprintf(const char *buf, size_t maxlen, char *format, ...)\r
- * \brief Print a formatted string to a buffer\r
- */\r
-EXPORT int snprintf(char *buf, size_t maxlen, const char *format, ...)\r
-{\r
- int ret;\r
- va_list args;\r
- va_start(args, format);\r
- ret = vsnprintf((char*)buf, maxlen, (char*)format, args);\r
- va_end(args);\r
- return ret;\r
-}\r
--- /dev/null
+
+enum {
+ EOK,
+ ENOSYS, // Invalid Instruction
+ EINVAL, // Invalid Paramater
+ ENOMEM, // No free memory
+ EACCES, // Not permitted
+ EBUSY, // Resource is busy
+ ERANGE, // Value out of range
+ ENOTFOUND, // Item not found
+ EREADONLY, // Read only
+ ENOTIMPL, // Not implemented
+ ENOENT, // No entry?
+ EEXIST, // Already exists
+ ENFILE, // Too many open files
+ ENOTDIR, // Not a directory
+ EIO, // IO Error
+ EINTR, // Operation interrupted (signal)
+
+ EALREADY, // Operation was a NOP
+ EINTERNAL, // Internal Error
+
+ NUM_ERRNO
+};
+
#define strerror(_x) "Unimplemented"
-enum
-{
- EOK,
- EINVAL,
- ERANGE,
- ENODEV,
- EBADF,
- EINTR,
- EAGAIN,
- ENOMEM,
-
- EADDRNOTAVAIL,
- EINPROGRESS,
-
- E_LAST
-};
+#include "errno.enum.h"
#endif
\r
/* --- StdLib --- */\r
extern void _exit(int code) __attribute__((noreturn)); /* NOTE: Also defined in acess/sys.h */\r
+\r
extern long long strtoll(const char *ptr, char **end, int base);\r
extern long strtol(const char *ptr, char **end, int base);\r
+extern unsigned long long strtoull(const char *ptr, char **end, int base);\r
+extern unsigned long strtoul(const char *ptr, char **end, int base);\r
extern int atoi(const char *ptr);\r
extern void exit(int status) __attribute__((noreturn));\r
extern void abort(void);\r
--- /dev/null
+/*\r
+ * AcessOS Basic C Library\r
+ * stdio.c\r
+ */\r
+#include "config.h"\r
+#include <acess/sys.h>\r
+#include <stdlib.h>\r
+#include <stdio.h>\r
+#include <string.h>\r
+#include "lib.h"\r
+#include "stdio_int.h"\r
+\r
+#define WRITE_STR(_fd, _str) write(_fd, _str, sizeof(_str))\r
+\r
+#define DEBUG_BUILD 0\r
+\r
+// === CONSTANTS ===\r
+#define _stdin 0\r
+#define _stdout 1\r
+\r
+// === PROTOTYPES ===\r
+EXPORT void itoa(char *buf, uint64_t num, size_t base, int minLength, char pad, int bSigned);\r
+struct sFILE *get_file_struct();\r
+\r
+// === GLOBALS ===\r
+struct sFILE _iob[STDIO_MAX_STREAMS]; // IO Buffer\r
+struct sFILE *stdin; // Standard Input\r
+struct sFILE *stdout; // Standard Output\r
+struct sFILE *stderr; // Standard Error\r
+///\note Initialised in SoMain\r
+\r
+// === CODE ===\r
+int _fopen_modetoflags(const char *mode)\r
+{\r
+ int flags = 0;\r
+ \r
+ // Get main mode\r
+ switch(*mode)\r
+ {\r
+ case 'r': flags = FILE_FLAG_MODE_READ; break;\r
+ case 'w': flags = FILE_FLAG_MODE_WRITE; break;\r
+ case 'a': flags = FILE_FLAG_MODE_APPEND; break;\r
+ case 'x': flags = FILE_FLAG_MODE_EXEC; break; // Acess addon\r
+ default:\r
+ return -1;\r
+ }\r
+ mode ++;\r
+\r
+ // Get Modifiers\r
+ for( ; *mode; mode ++ )\r
+ {\r
+ switch(*mode)\r
+ {\r
+ case 'b': flags |= FILE_FLAG_M_BINARY; break;\r
+ case '+': flags |= FILE_FLAG_M_EXT; break;\r
+ default:\r
+ return -1;\r
+ }\r
+ }\r
+ \r
+ return flags;\r
+}\r
+\r
+/**\r
+ * \fn FILE *freopen(char *file, char *mode, FILE *fp)\r
+ */\r
+EXPORT FILE *freopen(const char *file, const char *mode, FILE *fp)\r
+{\r
+ int openFlags = 0;\r
+ \r
+ // Sanity Check Arguments\r
+ if(!fp || !file || !mode) return NULL;\r
+ \r
+ if(fp->FD != -1) {\r
+ fflush(fp);\r
+ }\r
+\r
+ // Get stdio flags\r
+ fp->Flags = _fopen_modetoflags(mode);\r
+ if(fp->Flags == -1)\r
+ return NULL;\r
+ \r
+ // Get Open Flags\r
+ switch(fp->Flags & FILE_FLAG_MODE_MASK)\r
+ {\r
+ // Read\r
+ case FILE_FLAG_MODE_READ:\r
+ openFlags = OPENFLAG_READ;\r
+ if(fp->Flags & FILE_FLAG_M_EXT)\r
+ openFlags |= OPENFLAG_WRITE;\r
+ break;\r
+ // Write\r
+ case FILE_FLAG_MODE_WRITE:\r
+ openFlags = OPENFLAG_WRITE;\r
+ if(fp->Flags & FILE_FLAG_M_EXT)\r
+ openFlags |= OPENFLAG_READ;\r
+ break;\r
+ // Execute\r
+ case FILE_FLAG_MODE_APPEND:\r
+ openFlags = OPENFLAG_APPEND;\r
+ if(fp->Flags & FILE_FLAG_M_EXT)\r
+ openFlags |= OPENFLAG_READ;\r
+ break;\r
+ // Execute\r
+ case FILE_FLAG_MODE_EXEC:\r
+ openFlags = OPENFLAG_EXEC;\r
+ break;\r
+ }\r
+\r
+ //Open File\r
+ if(fp->FD != -1)\r
+ fp->FD = _SysReopen(fp->FD, file, openFlags);\r
+ else\r
+ fp->FD = _SysOpen(file, openFlags);\r
+ if(fp->FD == -1) {\r
+ fp->Flags = 0;\r
+ return NULL;\r
+ }\r
+ \r
+ if( (fp->Flags & FILE_FLAG_MODE_MASK) == FILE_FLAG_MODE_APPEND ) {\r
+ _SysSeek(fp->FD, 0, SEEK_END); //SEEK_END\r
+ }\r
+ \r
+ return fp;\r
+}\r
+/**\r
+ \fn FILE *fopen(const char *file, const char *mode)\r
+ \brief Opens a file and returns the pointer\r
+ \param file String - Filename to open\r
+ \param mode Mode to open in\r
+*/\r
+EXPORT FILE *fopen(const char *file, const char *mode)\r
+{\r
+ FILE *retFile;\r
+ \r
+ // Sanity Check Arguments\r
+ if(!file || !mode) return NULL;\r
+ \r
+ // Create Return Structure\r
+ retFile = get_file_struct();\r
+ \r
+ return freopen(file, mode, retFile);\r
+}\r
+\r
+EXPORT FILE *fmemopen(void *buffer, size_t length, const char *mode)\r
+{\r
+ FILE *ret;\r
+ \r
+ if( !buffer || !mode ) return NULL;\r
+ \r
+ ret = get_file_struct();\r
+ \r
+ ret->FD = -2;\r
+ ret->Flags = _fopen_modetoflags(mode);\r
+ if(ret->Flags == -1) {\r
+ ret->Flags = 0;\r
+ return NULL;\r
+ }\r
+ \r
+ ret->Buffer = buffer;\r
+ ret->BufferStart = 0;\r
+ ret->BufferSize = length;\r
+ \r
+ return ret;\r
+}\r
+\r
+EXPORT int fclose(FILE *fp)\r
+{\r
+ fflush(fp);\r
+ if( fp->FD != -1 ) {\r
+ _SysClose(fp->FD);\r
+ }\r
+ fp->Flags = 0;\r
+ fp->FD = -1;\r
+ return 0;\r
+}\r
+\r
+EXPORT void fflush(FILE *fp)\r
+{\r
+ if( !fp || fp->FD == -1 )\r
+ return ;\r
+ \r
+ if( !(fp->Flags & FILE_FLAG_DIRTY) )\r
+ return ;\r
+ \r
+ // Nothing to do for memory files\r
+ if( fp->FD == -2 )\r
+ return ;\r
+}\r
+\r
+EXPORT void clearerr(FILE *fp)\r
+{\r
+ if( !fp || fp->FD == -1 )\r
+ return ;\r
+ \r
+ // TODO: Impliment clearerr()\r
+}\r
+\r
+EXPORT int feof(FILE *fp)\r
+{\r
+ if( !fp || fp->FD == -1 )\r
+ return 0;\r
+ return !!(fp->Flags & FILE_FLAG_EOF);\r
+}\r
+\r
+EXPORT int ferror(FILE *fp)\r
+{\r
+ if( !fp || fp->FD == -1 )\r
+ return 0;\r
+ return 0;\r
+}\r
+EXPORT int fileno(FILE *stream)\r
+{\r
+ return stream->FD;\r
+}\r
+\r
+EXPORT off_t ftell(FILE *fp)\r
+{\r
+ if(!fp || fp->FD == -1) return -1;\r
+\r
+ if( fp->FD == -2 )\r
+ return fp->Pos; \r
+ else\r
+ return _SysTell(fp->FD);\r
+}\r
+\r
+EXPORT int fseek(FILE *fp, long int amt, int whence)\r
+{\r
+ if(!fp || fp->FD == -1) return -1;\r
+\r
+ if( fp->FD == -2 ) {\r
+ switch(whence)\r
+ {\r
+ case SEEK_CUR:\r
+ fp->Pos += amt;\r
+ break;\r
+ case SEEK_SET:\r
+ fp->Pos = amt;\r
+ break;\r
+ case SEEK_END:\r
+ if( fp->BufferSize < (size_t)amt )\r
+ fp->Pos = 0;\r
+ else\r
+ fp->Pos = fp->BufferSize - amt;\r
+ break;\r
+ }\r
+ if(fp->Pos > (off_t)fp->BufferSize) {\r
+ fp->Pos = fp->BufferSize;\r
+ fp->Flags |= FILE_FLAG_EOF;\r
+ }\r
+ return 0;\r
+ }\r
+ else\r
+ return _SysSeek(fp->FD, amt, whence);\r
+}\r
+\r
+\r
+/**\r
+ * \fn EXPORT int vfprintf(FILE *fp, const char *format, va_list args)\r
+ * \brief Print to a file from a variable argument list\r
+ */\r
+EXPORT int vfprintf(FILE *fp, const char *format, va_list args)\r
+{\r
+ va_list tmpList;\r
+ int size;\r
+\r
+ if(!fp || !format) return -1;\r
+\r
+ va_copy(tmpList, args);\r
+ \r
+ size = vsnprintf(NULL, 0, (char*)format, tmpList);\r
+ char buf[size+1];\r
+ vsnprintf(buf, size+1, (char*)format, args);\r
+ \r
+ // Write to stream\r
+ fwrite(buf, size, 1, fp);\r
+ \r
+ // Return written byte count\r
+ return size;\r
+}\r
+\r
+/**\r
+ * \fn int fprintf(FILE *fp, const char *format, ...)\r
+ * \brief Print a formatted string to a stream\r
+ */\r
+EXPORT int fprintf(FILE *fp, const char *format, ...)\r
+{\r
+ va_list args;\r
+ int ret;\r
+ \r
+ // Get Size\r
+ va_start(args, format);\r
+ ret = vfprintf(fp, (char*)format, args);\r
+ va_end(args);\r
+ \r
+ return ret;\r
+}\r
+\r
+/**\r
+ * \fn EXPORT size_t fwrite(void *ptr, size_t size, size_t num, FILE *fp)\r
+ * \brief Write to a stream\r
+ */\r
+EXPORT size_t fwrite(void *ptr, size_t size, size_t num, FILE *fp)\r
+{\r
+ size_t ret;\r
+ \r
+ if(!fp || fp->FD == -1)\r
+ return -1;\r
+\r
+ if( fp->FD == -2 ) {\r
+ size_t avail = (fp->BufferSize - fp->Pos) / size;\r
+ if( avail == 0 )\r
+ fp->Flags |= FILE_FLAG_EOF;\r
+ if( num > avail ) num = avail;\r
+ size_t bytes = num * size;\r
+ memcpy((char*)fp->Buffer + fp->Pos, ptr, bytes);\r
+ fp->Pos += bytes;\r
+ ret = num;\r
+ }\r
+ else { \r
+ ret = _SysWrite(fp->FD, ptr, size*num);\r
+ ret /= size;\r
+ }\r
+ \r
+ return ret;\r
+}\r
+\r
+/**\r
+ * \fn EXPORT size_t fread(void *ptr, size_t size, size_t num, FILE *fp)\r
+ * \brief Read from a stream\r
+ */\r
+EXPORT size_t fread(void *ptr, size_t size, size_t num, FILE *fp)\r
+{\r
+ size_t ret;\r
+ \r
+ if(!fp || fp->FD == -1)\r
+ return -1;\r
+\r
+ if( fp->FD == -2 ) {\r
+ size_t avail = (fp->BufferSize - fp->Pos) / size;\r
+ if( avail == 0 )\r
+ fp->Flags |= FILE_FLAG_EOF;\r
+ if( num > avail ) num = avail;\r
+ size_t bytes = num * size;\r
+ memcpy(ptr, (char*)fp->Buffer + fp->Pos, bytes);\r
+ fp->Pos += bytes;\r
+ ret = num;\r
+ }\r
+ else {\r
+ ret = _SysRead(fp->FD, ptr, size*num);\r
+ ret /= size;\r
+ }\r
+ \r
+ return ret;\r
+}\r
+\r
+/**\r
+ * \fn EXPORT int fputc(int c, FILE *fp)\r
+ * \brief Write a single character to the stream\r
+ */\r
+EXPORT int fputc(int c, FILE *fp)\r
+{\r
+ return fwrite(&c, 1, 1, fp);\r
+}\r
+\r
+EXPORT int putchar(int c)\r
+{\r
+ c &= 0xFF;\r
+ return _SysWrite(_stdout, &c, 1);\r
+}\r
+\r
+/**\r
+ * \fn EXPORT int fgetc(FILE *fp)\r
+ * \brief Read a character from the stream\r
+ */\r
+EXPORT int fgetc(FILE *fp)\r
+{\r
+ char ret = 0;\r
+ if( fread(&ret, 1, 1, fp) == (size_t)-1 )\r
+ return -1;\r
+ return ret;\r
+}\r
+\r
+EXPORT int getchar(void)\r
+{\r
+ char ret = 0;\r
+ if(_SysRead(_stdin, &ret, 1) != 1) return -1;\r
+ return ret;\r
+}\r
+\r
+// --- INTERNAL ---\r
+/**\r
+ * \fn FILE *get_file_struct()\r
+ * \brief Returns a file descriptor structure\r
+ */\r
+FILE *get_file_struct()\r
+{\r
+ int i;\r
+ for(i=0;i<STDIO_MAX_STREAMS;i++)\r
+ {\r
+ if(_iob[i].Flags & FILE_FLAG_ALLOC)\r
+ continue ;\r
+ _iob[i].Flags |= FILE_FLAG_ALLOC;\r
+ _iob[i].FD = -1;\r
+ _iob[i].Pos = 0;\r
+ return &_iob[i];\r
+ }\r
+ return NULL;\r
+}\r
+\r
+EXPORT int puts(const char *str)\r
+{\r
+ int len;\r
+ \r
+ if(!str) return 0;\r
+ len = strlen(str);\r
+ \r
+ len = _SysWrite(_stdout, str, len);\r
+ _SysWrite(_stdout, "\n", 1);\r
+ return len;\r
+}\r
+\r
+EXPORT int vsprintf(char * __s, const char *__format, va_list __args)\r
+{\r
+ return vsnprintf(__s, 0x7FFFFFFF, __format, __args);\r
+}\r
+\r
+//sprintfv\r
+/**\r
+ * \fn EXPORT void vsnprintf(char *buf, const char *format, va_list args)\r
+ * \brief Prints a formatted string to a buffer\r
+ * \param buf Pointer - Destination Buffer\r
+ * \param format String - Format String\r
+ * \param args VarArgs List - Arguments\r
+ */\r
+EXPORT int vsnprintf(char *buf, size_t __maxlen, const char *format, va_list args)\r
+{\r
+ char tmp[65];\r
+ int c, minSize, precision, len;\r
+ size_t pos = 0;\r
+ char *p;\r
+ char pad;\r
+ uint64_t arg;\r
+ int bLongLong, bPadLeft;\r
+\r
+ void _addchar(char ch)\r
+ {\r
+ if(buf && pos < __maxlen) buf[pos] = ch;\r
+ pos ++;\r
+ }\r
+\r
+ tmp[32] = '\0';\r
+ \r
+ while((c = *format++) != 0)\r
+ {\r
+ // Non-control character\r
+ if (c != '%') {\r
+ _addchar(c);\r
+ continue;\r
+ }\r
+ \r
+ // Control Character\r
+ c = *format++;\r
+ if(c == '%') { // Literal %\r
+ _addchar('%');\r
+ continue;\r
+ }\r
+ \r
+ bPadLeft = 0;\r
+ bLongLong = 0;\r
+ minSize = 0;\r
+ precision = -1;\r
+ pad = ' ';\r
+ \r
+ // Padding Character\r
+ if(c == '0') {\r
+ pad = '0';\r
+ c = *format++;\r
+ }\r
+ // Padding length\r
+ if( c == '*' ) {\r
+ // Variable length\r
+ minSize = va_arg(args, size_t);\r
+ c = *format++;\r
+ }\r
+ else {\r
+ if('1' <= c && c <= '9')\r
+ {\r
+ minSize = 0;\r
+ while('0' <= c && c <= '9')\r
+ {\r
+ minSize *= 10;\r
+ minSize += c - '0';\r
+ c = *format++;\r
+ }\r
+ }\r
+ }\r
+\r
+ // Precision\r
+ if(c == '.') {\r
+ c = *format++;\r
+ if(c == '*') {\r
+ precision = va_arg(args, size_t);\r
+ c = *format++;\r
+ }\r
+ else if('1' <= c && c <= '9')\r
+ {\r
+ precision = 0;\r
+ while('0' <= c && c <= '9')\r
+ {\r
+ precision *= 10;\r
+ precision += c - '0';\r
+ c = *format++;\r
+ }\r
+ }\r
+ }\r
+ \r
+ // Check for long long\r
+ bLongLong = 0;\r
+ if(c == 'l')\r
+ {\r
+ c = *format++;\r
+ if(c == 'l') {\r
+ bLongLong = 1;\r
+ }\r
+ }\r
+ \r
+ // Just help things along later\r
+ p = tmp;\r
+ \r
+ // Get Type\r
+ switch( c )\r
+ {\r
+ // Signed Integer\r
+ case 'd': case 'i':\r
+ // Get Argument\r
+ if(bLongLong) arg = va_arg(args, int64_t);\r
+ else arg = va_arg(args, int32_t);\r
+ itoa(tmp, arg, 10, minSize, pad, 1);\r
+ precision = -1;\r
+ goto sprintf_puts;\r
+ \r
+ // Unsigned Integer\r
+ case 'u':\r
+ // Get Argument\r
+ if(bLongLong) arg = va_arg(args, uint64_t);\r
+ else arg = va_arg(args, uint32_t);\r
+ itoa(tmp, arg, 10, minSize, pad, 0);\r
+ precision = -1;\r
+ goto sprintf_puts;\r
+ \r
+ // Pointer\r
+ case 'p':\r
+ _addchar('*');\r
+ _addchar('0');\r
+ _addchar('x');\r
+ arg = va_arg(args, intptr_t);\r
+ itoa(tmp, arg, 16, minSize, pad, 0);\r
+ precision = -1;\r
+ goto sprintf_puts;\r
+ // Unsigned Hexadecimal\r
+ case 'x':\r
+ if(bLongLong) arg = va_arg(args, uint64_t);\r
+ else arg = va_arg(args, uint32_t);\r
+ itoa(tmp, arg, 16, minSize, pad, 0);\r
+ precision = -1;\r
+ goto sprintf_puts;\r
+ \r
+ // Unsigned Octal\r
+ case 'o':\r
+ if(bLongLong) arg = va_arg(args, uint64_t);\r
+ else arg = va_arg(args, uint32_t);\r
+ itoa(tmp, arg, 8, minSize, pad, 0);\r
+ precision = -1;\r
+ goto sprintf_puts;\r
+ \r
+ // Unsigned binary\r
+ case 'b':\r
+ if(bLongLong) arg = va_arg(args, uint64_t);\r
+ else arg = va_arg(args, uint32_t);\r
+ itoa(tmp, arg, 2, minSize, pad, 0);\r
+ precision = -1;\r
+ goto sprintf_puts;\r
+\r
+ // String\r
+ case 's':\r
+ p = va_arg(args, char*);\r
+ sprintf_puts:\r
+ if(!p) p = "(null)";\r
+ //_SysDebug("vsnprintf: p = '%s'", p);\r
+ if(precision >= 0)\r
+ len = strnlen(p, precision);\r
+ else\r
+ len = strlen(p);\r
+ if(bPadLeft) while(minSize > len++) _addchar(pad);\r
+ while( *p ) {\r
+ if(precision >= 0 && precision -- == 0)\r
+ break;\r
+ _addchar(*p++);\r
+ }\r
+ if(!bPadLeft) while(minSize > len++) _addchar(pad);\r
+ break;\r
+\r
+ // Unknown, just treat it as a character\r
+ default:\r
+ arg = va_arg(args, uint32_t);\r
+ _addchar(arg);\r
+ break;\r
+ }\r
+ }\r
+ _addchar('\0');\r
+ pos --;\r
+ \r
+ //_SysDebug("vsnprintf: buf = '%s'", buf);\r
+ \r
+ return pos;\r
+}\r
+\r
+const char cUCDIGITS[] = "0123456789ABCDEF";\r
+/**\r
+ * \fn static void itoa(char *buf, uint64_t num, int base, int minLength, char pad, int bSigned)\r
+ * \brief Convert an integer into a character string\r
+ * \param buf Destination Buffer\r
+ * \param num Number to convert\r
+ * \param base Base-n number output\r
+ * \param minLength Minimum length of output\r
+ * \param pad Padding used to ensure minLength\r
+ * \param bSigned Signed number output?\r
+ */\r
+EXPORT void itoa(char *buf, uint64_t num, size_t base, int minLength, char pad, int bSigned)\r
+{\r
+ char tmpBuf[64];\r
+ int pos=0, i;\r
+\r
+ if(!buf) return;\r
+ if(base > 16 || base < 2) {\r
+ buf[0] = 0;\r
+ return;\r
+ }\r
+ \r
+ if(bSigned && (int64_t)num < 0)\r
+ {\r
+ num = -num;\r
+ bSigned = 1;\r
+ } else\r
+ bSigned = 0;\r
+ \r
+ // Encode into reversed string\r
+ while(num > base-1) {\r
+ tmpBuf[pos++] = cUCDIGITS[ num % base ];\r
+ num = (uint64_t) num / (uint64_t)base; // Shift {number} right 1 digit\r
+ }\r
+\r
+ tmpBuf[pos++] = cUCDIGITS[ num % base ]; // Last digit of {number}\r
+ if(bSigned) tmpBuf[pos++] = '-'; // Append sign symbol if needed\r
+ \r
+ i = 0;\r
+ minLength -= pos;\r
+ while(minLength-- > 0) buf[i++] = pad;\r
+ while(pos-- > 0) buf[i++] = tmpBuf[pos]; // Reverse the order of characters\r
+ buf[i] = 0;\r
+}\r
+\r
+/**\r
+ * \fn EXPORT int printf(const char *format, ...)\r
+ * \brief Print a string to stdout\r
+ */\r
+EXPORT int printf(const char *format, ...)\r
+{\r
+ int size;\r
+ va_list args;\r
+ \r
+ // Get final size\r
+ va_start(args, format);\r
+ size = vsnprintf(NULL, 0, (char*)format, args);\r
+ va_end(args);\r
+ char buf[size+1];\r
+ // Fill Buffer\r
+ va_start(args, format);\r
+ vsnprintf(buf, size+1, (char*)format, args);\r
+ va_end(args);\r
+ \r
+ // Send to stdout\r
+ _SysWrite(_stdout, buf, size+1);\r
+ \r
+ // Free buffer\r
+ free(buf);\r
+ // Return\r
+ return size;\r
+}\r
+\r
+/**\r
+ * \fn EXPORT int sprintf(const char *buf, char *format, ...)\r
+ * \brief Print a formatted string to a buffer\r
+ */\r
+EXPORT int sprintf(char *buf, const char *format, ...)\r
+{\r
+ int ret;\r
+ va_list args;\r
+ va_start(args, format);\r
+ ret = vsprintf((char*)buf, (char*)format, args);\r
+ va_end(args);\r
+ return ret;\r
+}\r
+\r
+/**\r
+ * \fn EXPORT int snprintf(const char *buf, size_t maxlen, char *format, ...)\r
+ * \brief Print a formatted string to a buffer\r
+ */\r
+EXPORT int snprintf(char *buf, size_t maxlen, const char *format, ...)\r
+{\r
+ int ret;\r
+ va_list args;\r
+ va_start(args, format);\r
+ ret = vsnprintf((char*)buf, maxlen, (char*)format, args);\r
+ va_end(args);\r
+ return ret;\r
+}\r
#include <acess/sys.h>\r
#include <stdlib.h>\r
#include <stdio.h>\r
-#include <errno.h>\r
-#include <ctype.h>\r
-#include <limits.h>\r
#include "lib.h"\r
\r
-#define _stdout 1\r
-#define _stdin 0\r
-\r
extern void *_crt0_exit_handler;\r
\r
// === PROTOTYPES ===\r
}\r
}\r
\r
-EXPORT long long strtoll(const char *str, char **end, int base)\r
-{\r
- int neg = 0;\r
- long long ret = 0;\r
- \r
- if( !str || base < 0 || base > 36 || base == 1 ) {\r
- if(end)\r
- *end = (char*)str;\r
- errno = EINVAL;\r
- return 0;\r
- }\r
-\r
- while( isspace(*str) )\r
- str++;\r
- \r
- // Check for negative (or positive) sign\r
- if(*str == '-' || *str == '+') {\r
- neg = (*str == '-');\r
- str++;\r
- }\r
- \r
- if( base == 0 || base == 16 ) {\r
- if( *str == '0' && str[1] == 'x' ) {\r
- str += 2;\r
- base = 16;\r
- }\r
- }\r
- \r
- if( base == 0 && *str == '0' ) {\r
- str ++;\r
- base = 8;\r
- }\r
-\r
- if( base == 0 )\r
- base = 10;\r
-\r
- while( *str )\r
- {\r
- int next = -1;\r
- if( base <= 10 ) {\r
- if( '0' <= *str && *str <= '0'+base-1 )\r
- next = *str - '0';\r
- }\r
- else {\r
- if( '0' <= *str && *str <= '9' )\r
- next = *str - '0';\r
- if( 'A' <= *str && *str <= 'A'+base-10-1 )\r
- next = *str - 'A';\r
- if( 'a' <= *str && *str <= 'a'+base-10-1 )\r
- next = *str - 'a';\r
- }\r
- if( next < 0 )\r
- break;\r
- ret *= base;\r
- ret += next;\r
- str ++;\r
- }\r
-\r
- if( neg )\r
- ret = -ret; \r
-\r
- if(end)\r
- *end = (char*)str;\r
- return ret;\r
-}\r
-\r
-EXPORT long strtol(const char *str, char **end, int base)\r
-{\r
- long long tmp = strtoll(str, end, base);\r
- if( tmp > LONG_MAX || tmp < LONG_MIN ) {\r
- errno = ERANGE;\r
- return (tmp > LONG_MAX) ? LONG_MAX : LONG_MIN;\r
- }\r
- return tmp;\r
-}\r
-\r
-/**\r
- * \fn EXPORT int atoi(const char *str)\r
- * \brief Convert a string to an integer\r
- */\r
-EXPORT int atoi(const char *str)\r
-{\r
- long long tmp = strtoll(str, NULL, 0);\r
- if( tmp > INT_MAX || tmp < INT_MIN ) {\r
- errno = ERANGE;\r
- return (tmp > INT_MAX) ? INT_MAX : INT_MIN;\r
- }\r
- return tmp;\r
-}\r
\r
int abs(int j) { return j < 0 ? -j : j; }\r
long int labs(long int j) { return j < 0 ? -j : j; }\r
--- /dev/null
+/*
+ * Acess2 C Library
+ * - By John Hodge (thePowersGang)
+ *
+ * strtoi.c
+ * - strto[u][l]l/atoi implimentation
+ */
+#include <ctype.h>
+#include <errno.h>
+#include <limits.h>
+#include <stddef.h>
+
+unsigned long long strtoull(const char *str, char **end, int base)
+{
+ long long ret = 0;
+
+ if( !str || base < 0 || base > 36 || base == 1 ) {
+ if(end)
+ *end = (char*)str;
+ errno = EINVAL;
+ return 0;
+ }
+
+ // Trim leading spaces
+ while( isspace(*str) )
+ str++;
+
+ // Handle base detection for hex
+ if( base == 0 || base == 16 ) {
+ if( *str == '0' && str[1] == 'x' ) {
+ str += 2;
+ base = 16;
+ }
+ }
+
+ // Handle base detection for octal
+ if( base == 0 && *str == '0' ) {
+ str ++;
+ base = 8;
+ }
+
+ // Fall back on decimal when unknown
+ if( base == 0 )
+ base = 10;
+
+ while( *str )
+ {
+ int next = -1;
+ if( base <= 10 ) {
+ if( '0' <= *str && *str <= '0'+base-1 )
+ next = *str - '0';
+ }
+ else {
+ if( '0' <= *str && *str <= '9' )
+ next = *str - '0';
+ if( 'A' <= *str && *str <= 'A'+base-10-1 )
+ next = *str - 'A';
+ if( 'a' <= *str && *str <= 'a'+base-10-1 )
+ next = *str - 'a';
+ }
+ if( next < 0 )
+ break;
+ ret *= base;
+ ret += next;
+ str ++;
+ }
+
+ if(end)
+ *end = (char*)str;
+ return ret;
+}
+
+unsigned long strtoul(const char *ptr, char **end, int base)
+{
+ unsigned long long tmp = strtoull(ptr, end, base);
+
+ if( tmp > ULONG_MAX ) {
+ errno = ERANGE;
+ return ULONG_MAX;
+ }
+
+ return tmp;
+}
+
+long long strtoll(const char *str, char **end, int base)
+{
+ int neg = 0;
+ unsigned long long ret;
+
+ if( !str ) {
+ errno = EINVAL;
+ return 0;
+ }
+
+ while( isspace(*str) )
+ str++;
+
+ // Check for negative (or positive) sign
+ if(*str == '-' || *str == '+') {
+ neg = (*str == '-');
+ str++;
+ }
+
+ ret = strtoull(str, end, base);
+
+ if( neg )
+ return -ret;
+ else
+ return ret;
+}
+
+long strtol(const char *str, char **end, int base)
+{
+ long long tmp = strtoll(str, end, base);
+ if( tmp > LONG_MAX || tmp < LONG_MIN ) {
+ errno = ERANGE;
+ return (tmp > LONG_MAX) ? LONG_MAX : LONG_MIN;
+ }
+ return tmp;
+}
+
+/**
+ * \fn int atoi(const char *str)
+ * \brief Convert a string to an integer
+ */
+int atoi(const char *str)
+{
+ long long tmp = strtoll(str, NULL, 0);
+ if( tmp > INT_MAX || tmp < INT_MIN ) {
+ errno = ERANGE;
+ return (tmp > INT_MAX) ? INT_MAX : INT_MIN;
+ }
+ return tmp;
+}
#include "stdio_int.h"\r
#include "lib.h"\r
#include <stdio.h>\r
-#include <sys/sys.h>\r
+#include <acess/sys.h>\r
\r
#define USE_CPUID 0\r
\r
uint32_t *type = (void*)buf;
// Open
- fd = open("/Devices/ip/routes", 0);
+ fd = _SysOpen("/Devices/ip/routes", 0);
if( !fd ) {
fprintf(stderr, "ERROR: Unable to open '/Devices/ip/routes'\n");
return NULL;
// Make structure and ask
*type = AddressType;
memcpy(type+1, Address, size);
- routeNum = ioctl(fd, ioctl(fd, 3, "locate_route"), buf);
+ routeNum = _SysIOCtl(fd, _SysIOCtl(fd, 3, "locate_route"), buf);
// Close
- close(fd);
+ _SysClose(fd);
}
// Check answer validity
sprintf(buf, "/Devices/ip/routes/#%i", routeNum);
// Open route
- fd = open(buf, 0);
+ fd = _SysOpen(buf, 0);
if( fd == -1 ) {
fprintf(stderr, "Net_GetInterface - ERROR: Unable to open %s\n", buf);
return NULL; // Shouldn't happen :/
}
// Allocate space for name
- ret = malloc( ioctl(fd, ioctl(fd, 3, "get_interface"), NULL) + 1 );
+ ret = malloc( _SysIOCtl(fd, _SysIOCtl(fd, 3, "get_interface"), NULL) + 1 );
if( !ret ) {
fprintf(stderr, "malloc() failure - Allocating space for interface name\n");
return NULL;
}
// Get name
- ioctl(fd, ioctl(fd, 3, "get_interface"), ret);
+ _SysIOCtl(fd, _SysIOCtl(fd, 3, "get_interface"), ret);
// Close and return
- close(fd);
+ _SysClose(fd);
return ret;
}
char path[len+1];
snprintf(path, 100, "/Devices/ip/routes/@%i:%s/%s", AddrType, hexAddr, Filename);
_SysDebug("%s", path);
- return open(path, OPENFLAG_READ|OPENFLAG_WRITE);
+ return _SysOpen(path, OPENFLAG_READ|OPENFLAG_WRITE);
}
else
{
int len = snprintf(NULL, 100, "/Devices/ip/routes/@%i:%s", AddrType, hexAddr);
char path[len+1];
snprintf(path, 100, "/Devices/ip/routes/@%i:%s", AddrType, hexAddr);
- return open(path, OPENFLAG_READ);
+ return _SysOpen(path, OPENFLAG_READ);
}
}
int fd = Net_OpenSocket(AddrType, Addr, "tcpc");
if( fd == -1 ) return -1;
- ioctl(fd, 5, &Port); // Remote Port
- ioctl(fd, 6, Addr); // Remote address
- ioctl(fd, 7, NULL); // connect
+ _SysIOCtl(fd, 5, &Port); // Remote Port
+ _SysIOCtl(fd, 6, Addr); // Remote address
+ _SysIOCtl(fd, 7, NULL); // connect
return fd;
}
--- /dev/null
+# Acess2 POSIX Emulation\r
+# Makefile\r
+\r
+-include ../Makefile.cfg\r
+\r
+CPPFLAGS += \r
+CFLAGS += -Werror -Wextra\r
+ASFLAGS +=\r
+LDFLAGS += -soname libposix.so -Map map.txt\r
+\r
+OBJ = main.o unistd.o\r
+DEPFILES := $(OBJ:%.o=%.d)\r
+BIN = libposix.so\r
+\r
+include ../Makefile.tpl\r
+\r
// Acess doesn't implement lseek
#define lseek(_1,_2,_3) (seek(_1,_2,_3),tell(_1))
+enum e_fcntl_cmds
+{
+ F_SETFL
+};
+
+int fcntl(int fd, int cmd, ...) { return -1; }
+
#endif
rlim_t rlim_max;
};
+enum
+{
+ RLIMIT_AS, // Address space size
+ RLIMIT_CORE, // Max core file size
+ RLIMIT_CPU, // CPU time limit in s (SIGXCPU when reached)
+ RLIMIT_DATA,
+ // TODO: More?
+};
+
struct rusage
{
struct timeval ru_time;
--- /dev/null
+/*
+ * Acess2 POSIX Emulation Layer
+ * - By John Hodge
+ *
+ * sys/select.h
+ * - select(2)
+ */
+#ifndef _SYS__SELECT_H_
+#define _SYS__SELECT_H_
+
+#include <acess/fd_set.h>
+
+extern int select(int nfds, fd_set *readfds, fd_set *writefds, struct timeval *timeout);
+// TODO: pselect?
+
+#endif
+
--- /dev/null
+/*
+ * Acess2 C Library
+ * - By John Hodge (thePowersGang)
+ */
+#ifndef _SYS_STAT_H_
+#define _SYS_STAT_H_
+
+//#include "../acess/intdefs.h" /* Evil */
+//#include "../stddef.h"
+#include <stdint.h>
+#include "sys/types.h" // off_t
+
+typedef void *dev_t; /* TODO: How to identify a device with Acess */
+typedef uint64_t ino_t;
+typedef unsigned int blksize_t;
+typedef uint64_t blkcnt_t;
+typedef unsigned int nlink_t;
+typedef uint32_t mode_t;
+
+typedef uint32_t uid_t;
+typedef uint32_t gid_t;
+
+#define S_IFMT 0170000 /* type of file */
+#define S_IFDIR 0040000 /* directory */
+#define S_IFCHR 0020000 /* character special */
+#define S_IFBLK 0060000 /* block special */
+#define S_IFREG 0100000 /* regular */
+#define S_IFLNK 0120000 /* symbolic link */
+#define S_IFSOCK 0140000 /* socket */
+#define S_IFIFO 0010000 /* fifo */
+
+
+struct stat
+{
+ dev_t st_dev; /* ID of device containing file */
+ ino_t st_ino; /* inode number */
+ mode_t st_mode; /* protection */
+ nlink_t st_nlink; /* number of hard links */
+ uid_t st_uid; /* user ID of owner */
+ gid_t st_gid; /* group ID of owner */
+ dev_t st_rdev; /* device ID (if special file) */
+ off_t st_size; /* total size, in bytes */
+ blksize_t st_blksize; /* blocksize for file system I/O */
+ blkcnt_t st_blocks; /* number of 512B blocks allocated */
+ time_t st_atime; /* time of last access */
+ time_t st_mtime; /* time of last modification */
+ time_t st_ctime; /* time of last status change */
+};
+
+extern int stat(const char *path, struct stat *buf);
+extern int fstat(int fd, struct stat *buf);
+
+#endif
--- /dev/null
+/*
+ */
+#ifndef _SYS_TYPES_H
+#define _SYS_TYPES_H
+
+#include <stdint.h>
+
+//typedef signed int ssize_t;
+//#ifdef __USE_BSD
+typedef unsigned int u_int;
+//#endif
+
+typedef struct stat t_fstat;
+
+
+#define CLONE_VM 0x10
+
+typedef unsigned int id_t;
+typedef unsigned long pid_t;
+typedef unsigned long tid_t;
+typedef signed long long int time_t;
+typedef long long int off_t;
+
+typedef unsigned int uint;
+
+#include "stat.h"
+#include <acess/fd_set.h>
+
+#endif
--- /dev/null
+/*
+ * Acess2 POSIX Emulation Layer
+ * - By John Hodge
+ *
+ * unistd.h
+ * -
+ */
+#ifndef _UNISTD_H_
+#define _UNISTD_H_
+
+#include <stddef.h>
+
+//! \brief flags for open(2)
+#define O_WRONLY 0x01
+#define O_RDONLY 0x02
+#define O_RDWR 0x03
+#define O_APPEND 0x04
+#define O_CREAT 0x08
+#define O_DIRECTORY 0x10
+#define O_ASYNC 0x20
+#define O_TRUNC 0x40
+#define O_NOFOLLOW 0x80 // don't follow symlinks
+#define O_EXCL 0x100
+#define O_NOCTTY 0 // unsupported
+#define O_NONBLOCK 0x200
+#define O_SYNC 0 // not supported
+
+#define STDIN_FILENO 0
+#define STDOUT_FILENO 1
+#define STDERR_FILENO 2
+
+typedef signed long ssize_t;
+
+#include "sys/stat.h" // mode_t
+
+extern int open(const char *path, int flags, ...);
+extern int creat(const char *path, mode_t mode);
+extern int close(int fd);
+
+extern ssize_t write(int fd, const void *buf, size_t count);
+extern ssize_t read(int fd, void *buf, size_t count);
+
+extern int fork(void);
+extern int execv(const char *b, char *v[]);
+
+#endif
+
--- /dev/null
+/*
+ * Acess2 POSIX Emulation Layer
+ * - By John Hodge
+ *
+ * main.c
+ * - Stub Main
+ */
+
+// === CODE ===
+int SoMain(void)
+{
+ return 0;
+}
+
--- /dev/null
+/*
+ * Acess2 POSIX Emulation Layer
+ * - By John Hodge
+ *
+ * unistd.c
+ * - POSIX->Acess VFS call translation
+ */
+#include <unistd.h>
+#include <acess/sys.h>
+#include <stdarg.h>
+
+// === CODE ===
+int open(const char *path, int openmode, ...)
+{
+ mode_t create_mode = 0;
+ int openflags = 0;
+
+ switch( openmode & O_RDWR )
+ {
+ case 0: // Special
+ break;
+ case O_RDONLY: openflags |= OPENFLAG_READ; break;
+ case O_WRONLY: openflags |= OPENFLAG_WRITE; break;
+ case O_RDWR: openflags |= OPENFLAG_READ|OPENFLAG_WRITE; break;
+ }
+
+ if( openmode & O_CREAT ) {
+ openflags |= OPENFLAG_CREATE;
+ va_list args;
+ va_start(args, openmode);
+ create_mode = va_arg(args, mode_t);
+ va_end(args);
+ }
+
+ return _SysOpen(path, openflags, create_mode);
+}
+
+int creat(const char *path, mode_t mode)
+{
+ // TODO: Make native call to do this cheaper
+ int fd = _SysOpen(path, OPENFLAG_CREATE, mode);
+ if( fd == -1 ) return -1;
+ _SysClose(fd);
+ return 0;
+}
+
+int close(int fd)
+{
+ _SysClose(fd);
+ return 0;
+}
+
+ssize_t write(int fd, const void *buf, size_t count)
+{
+ return _SysWrite(fd, buf, count);
+}
+
+ssize_t read(int fd, void *buf, size_t count)
+{
+ return _SysRead(fd, buf, count);
+}
+
+int fork(void)
+{
+ return _SysClone(CLONE_VM, 0);
+}
+
+int execv(const char *b, char *v[])
+{
+ return _SysExecVE(b, v, NULL);
+}
--- /dev/null
+
+extern char *mkstr(const char *format, ...);
// getsockopt/setsockopt(level)
enum {
- IPPROTO_IP,
+ IPPROTO_IP = 1,
IPPROTO_ICMP,
IPPROTO_TCP,
IPPROTO_UDP
--- /dev/null
+/*
+ * Acess2 POSIX Sockets Emulation
+ * - By John Hodge (thePowersGang)
+ *
+ * netinet/tcp.h
+ * - TCP Options
+ */
+#ifndef _NETINET__TCP_H_
+#define _NETINET__TCP_H_
+
+
+/**
+ * \brief Values for \a option_name in setsockopt/getsockopt
+ */
+enum eSockOpts_TCP
+{
+ TCP_NODELAY
+};
+
+#endif
+
{
AF_UNSPEC = 0,
AF_PACKET = 1,
+ AF_LOCAL = 2,
AF_INET = 4,
AF_INET6 = 6,
} sa_family_t;
+#define AF_UNIX AF_LOCAL
struct sockaddr
{
*/
enum eSocketDomains
{
+ PF_UNSPEC,
PF_LOCAL, //!< Machine-local comms
PF_INET, //!< IPv4
PF_INET6, //!< IPv6
};
#define PF_UNIX PF_LOCAL
+// getsockopt/setsockopt level
+enum
+{
+ SOL_SOCKET
+};
+
+
+// SOL_SOCKET getsockopt/setsockopt names
+enum
+{
+ SO_REUSEADDR,
+ SO_LINGER
+};
+
/**
* \brief Create a new socket descriptor
* \param domain Address family
extern int setsockopt(int socket, int level, int option_name, const void *option_value, socklen_t option_len);
extern int getsockopt(int socket, int level, int option_name, void *option_value, socklen_t *option_len);
+extern int getsockname(int socket, struct sockaddr *addr, socklen_t *addrlen);
+extern int getpeername(int socket, struct sockaddr *addr, socklen_t *addrlen);
+
#endif
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
+#include "common.h"
int SoMain(void)
{
* - sys/socket.h calls
*/
#include <sys/socket.h>
-#include <unistd.h>
+#include <acess/sys.h>
#include <stdlib.h> // malloc/free
#include <string.h>
#include <netinet/in.h>
+#include "common.h"
#define MAXFD 32
si = _GetInfo(0);
if( !si ) return -1;
- int fd = open("/Devices/null", O_RDWR);
+ int fd = _SysOpen("/Devices/null", OPENFLAG_RDWR);
if( fd == -1 ) return -1;
giNumPreinit ++;
else
path = mkstr("/Devices/ip/*%i/%s", si->local->sa_family, file);
- reopen(si->fd, path, O_RDWR);
+ _SysReopen(si->fd, path, OPENFLAG_RDWR);
// TODO: Error-check
free(path);
int child;
- child = _SysOpenChild(sockfd, "", O_RDWR);
+ child = _SysOpenChild(sockfd, "", OPENFLAG_RDWR);
if( child == -1 ) return -1;
- ioctl(child, 8, clientaddr);
+ _SysIOCtl(child, 8, clientaddr);
+
return child;
}
{
_CommitClient(sockfd);
// TODO: Determine socket type (TCP/UDP) and use a bounce-buffer for UDP
- return read(sockfd, buffer, length);
+ return _SysRead(sockfd, buffer, length);
}
int recv(int sockfd, void *buffer, size_t length, int flags)
{
_CommitClient(sockfd);
- return read(sockfd, buffer, length);
+ return _SysRead(sockfd, buffer, length);
}
int sendto(int sockfd, const void *buffer, size_t length, int flags, const struct sockaddr *clientaddr, socklen_t addrlen)
{
_CommitClient(sockfd);
// TODO: Determine socket type (TCP/UDP) and use a bounce-buffer for UDP
- return write(sockfd, buffer, length);
+ return _SysWrite(sockfd, buffer, length);
}
int send(int sockfd, void *buffer, size_t length, int flags)
{
_CommitClient(sockfd);
- return write(sockfd, buffer, length);
+ return _SysWrite(sockfd, buffer, length);
}
int len, i;
// Read as much as possible (appending to remaining data)
- len = read(STDIN_FD, Info->ReadBuffer, READ_BUFFER_SIZE - 1 - Info->ReadBufferLen);
+ len = _SysRead(STDIN_FD, Info->ReadBuffer, READ_BUFFER_SIZE - 1 - Info->ReadBufferLen);
if( len <= 0 ) return NULL;
Info->ReadBuffer[Info->ReadBufferLen + len] = '\0';
// Move to the beginning of the line
pos = oldLen;
- while(pos--) write(STDOUT_FD, "\x1B[D", 3);
+ while(pos--) _SysWrite(STDOUT_FD, "\x1B[D", 3);
// Update state
Info->CurBuffer = Info->History[--Info->HistoryPos];
Info->BufferSize = Info->BufferUsed = strlen(Info->CurBuffer);
- write(STDOUT_FD, Info->CurBuffer, Info->BufferUsed);
+ _SysWrite(STDOUT_FD, Info->CurBuffer, Info->BufferUsed);
Info->BufferWritePos = Info->BufferUsed;
// Clear old characters (if needed)
if( oldLen > Info->BufferWritePos ) {
pos = oldLen - Info->BufferWritePos;
- while(pos--) write(STDOUT_FD, " ", 1);
+ while(pos--) _SysWrite(STDOUT_FD, " ", 1);
pos = oldLen - Info->BufferWritePos;
- while(pos--) write(STDOUT_FD, "\x1B[D", 3);
+ while(pos--) _SysWrite(STDOUT_FD, "\x1B[D", 3);
}
}
break;
// Move to the beginning of the line
pos = oldLen;
- while(pos--) write(STDOUT_FD, "\x1B[D", 3);
+ while(pos--) _SysWrite(STDOUT_FD, "\x1B[D", 3);
// Update state
Info->CurBuffer = Info->History[Info->HistoryPos++];
Info->BufferSize = Info->BufferUsed = strlen(Info->CurBuffer);
// Write new line
- write(STDOUT_FD, Info->CurBuffer, Info->BufferUsed);
+ _SysWrite(STDOUT_FD, Info->CurBuffer, Info->BufferUsed);
Info->BufferWritePos = Info->BufferUsed;
// Clear old characters (if needed)
if( oldLen > Info->BufferWritePos ) {
pos = oldLen - Info->BufferWritePos;
- while(pos--) write(STDOUT_FD, " ", 1);
+ while(pos--) _SysWrite(STDOUT_FD, " ", 1);
pos = oldLen - Info->BufferWritePos;
- while(pos--) write(STDOUT_FD, "\x1B[D", 3);
+ while(pos--) _SysWrite(STDOUT_FD, "\x1B[D", 3);
}
}
break;
case 'D': // Left
if(Info->BufferWritePos == 0) break;
Info->BufferWritePos --;
- write(STDOUT_FD, "\x1B[D", 3);
+ _SysWrite(STDOUT_FD, "\x1B[D", 3);
break;
case 'C': // Right
if(Info->BufferWritePos == Info->BufferUsed) break;
Info->BufferWritePos ++;
- write(STDOUT_FD, "\x1B[C", 3);
+ _SysWrite(STDOUT_FD, "\x1B[C", 3);
break;
}
break;
case '\b':
if(Info->BufferWritePos <= 0) break; // Protect against underflows
// Write the backsapce
- write(STDOUT_FD, &ch, 1);
+ _SysWrite(STDOUT_FD, &ch, 1);
if(Info->BufferWritePos == Info->BufferUsed) // Simple case: End of string
{
Info->BufferUsed --;
buf[3] += (delta/10) % 10;
buf[4] += (delta) % 10;
// Write everything save for the deleted character
- write(STDOUT_FD,
+ _SysWrite(STDOUT_FD,
&Info->CurBuffer[Info->BufferWritePos],
Info->BufferUsed - Info->BufferWritePos
);
- ch = ' '; write(STDOUT_FD, &ch, 1); ch = '\b'; // Clear old last character
- write(STDOUT_FD, buf, 7); // Update Cursor
+ ch = ' '; _SysWrite(STDOUT_FD, &ch, 1); ch = '\b'; // Clear old last character
+ _SysWrite(STDOUT_FD, buf, 7); // Update Cursor
// Alter Buffer
memmove(&Info->CurBuffer[Info->BufferWritePos-1],
&Info->CurBuffer[Info->BufferWritePos],
buf[2] += (delta/100) % 10;
buf[3] += (delta/10) % 10;
buf[4] += (delta) % 10;
- write(STDOUT_FD, &ch, 1); // Print new character
- write(STDOUT_FD,
+ _SysWrite(STDOUT_FD, &ch, 1); // Print new character
+ _SysWrite(STDOUT_FD,
&Info->CurBuffer[Info->BufferWritePos],
Info->BufferUsed - Info->BufferWritePos
);
- write(STDOUT_FD, buf, 7); // Update Cursor
+ _SysWrite(STDOUT_FD, buf, 7); // Update Cursor
// Move buffer right
memmove(
&Info->CurBuffer[Info->BufferWritePos+1],
}
// Simple append
else {
- write(STDOUT_FD, &ch, 1);
+ _SysWrite(STDOUT_FD, &ch, 1);
}
Info->CurBuffer[ Info->BufferWritePos ++ ] = ch;
Info->BufferUsed ++;
size_t URI_file_Read(int Handle, size_t Bytes, void *Buffer);
size_t URI_file_Write(int Handle, size_t Bytes, void *Buffer);
void URI_file_Close(int Handle);
-size_t URI_file_GetSize(int Handle);
+off_t URI_file_GetSize(int Handle);
// === CONSTANTS ===
// Builtin URI protocol handlers
// printf("URI_file_Open: open('%s', 0x%x)\n", Path, smode);
{
int ret;
- ret = open(Path, smode);
+ ret = _SysOpen(Path, smode);
return ret;
}
}
{
// printf("URI_file_Read: (Handle=%i, Buffer=%p, Bytes=%i)\n",
// Handle, Buffer, (int)Bytes);
- return read(Handle, Buffer, Bytes);
+ return _SysRead(Handle, Buffer, Bytes);
}
size_t URI_file_Write(int Handle, size_t Bytes, void *Buffer)
{
- return write(Handle, Buffer, Bytes);
+ return _SysWrite(Handle, Buffer, Bytes);
}
void URI_file_Close(int Handle)
{
- close(Handle);
+ _SysClose(Handle);
}
-size_t URI_file_GetSize(int Handle)
+off_t URI_file_GetSize(int Handle)
{
- uint64_t curpos = tell(Handle);
- size_t ret;
- seek(Handle, 0, SEEK_END);
- ret = tell(Handle);
- seek(Handle, curpos, SEEK_SET);
+ uint64_t curpos = _SysTell(Handle);
+ off_t ret;
+ _SysSeek(Handle, 0, SEEK_END);
+ ret = _SysTell(Handle);
+ _SysSeek(Handle, curpos, SEEK_SET);
return ret;
}
git.ucc.asn.au / tpg / acess2.git / commitdiff
UCC git Repository :: git.ucc.asn.au