Changeset 2085 for Whitix/branches

Timestamp:

05/20/10 16:05:25 (2 years ago)

Author:

mwhitworth

Message:

Add to TCP/IP stack.

Location:

Whitix/branches/netchannel

Files:

• arch/i386/kernel/idtstubs.S (modified) (1 diff)
• arch/i386/kernel/ints.c (modified) (4 diffs)
• arch/i386/kernel/process.c (modified) (4 diffs)
• include/error.h (modified) (1 diff)
• include/sched.h (modified) (1 diff)
• include/sys.h (modified) (1 diff)
• include/task.h (modified) (3 diffs)
• include/timer.h (modified) (1 diff)
• include/wait.h (modified) (1 diff)
• kernel/Makefile (modified) (1 diff)
• kernel/main.c (modified) (2 diffs)
• kernel/process.c (modified) (3 diffs)
• kernel/sched.c (modified) (2 diffs)
• kernel/thread.c (modified) (3 diffs)
• kernel/timer.c (modified) (2 diffs)
• user/burn/builtins.c (modified) (1 diff)
• user/burn/main.c (modified) (1 diff)
• user/libc/include/syscalls.h (modified) (1 diff)
• user/libc/include/sysdefs.h (modified) (1 diff)
• user/linker/Makefile (modified) (1 diff)
• user/net/telnet.c (modified) (1 diff)
• user/posix/file/file.c (modified) (2 diffs)
• user/posix/socket/socket.c (modified) (1 diff)
• user/sdk/include/net/socket.h (modified) (1 diff)
• user/sdk/network/Makefile (modified) (1 diff)
• user/sdk/network/socket.c (modified) (1 diff)
• user/sdk/network/tcp_options.h (modified) (1 diff)

Whitix/branches/netchannel/arch/i386/kernel/idtstubs.S

@@ -217 +217 @@
 int $0x30
 endi386ExitThread:
+
+.globl i386RetFromEvent
+.globl endi386RetFromEvent
+
+i386RetFromEvent:
+mov $64, %eax /* SysEventReturn syscall number */
+xor %ecx, %ecx
+lea (%esp), %edx
+int $0x30
+endi386RetFromEvent:

Whitix/branches/netchannel/arch/i386/kernel/ints.c

@@ -268 +268 @@
 }
 
+void IrqDoEvent(struct Context* curr)
+{
+        if (curr->cs != 0x08)
+        {
+                PreemptDisable();
+
+                DWORD* esp;
+
+                currThread->oldEip = curr->eip;
+                currThread->esp3 = curr->esp3;
+                curr->esp3 = currThread->eventStack;
+                curr->eip = (DWORD)currThread->eventFunc;
+
+                /* Push onto stack */
+                esp = (DWORD*)curr->esp3;
+
+                extern DWORD retFromEvent;
+                *--esp = (DWORD)currThread->eventData;
+                *--esp = retFromEvent;
+
+                curr->esp3 = (DWORD)esp;
+                currThread->eventFunc = NULL;
+                currThread->eventData = NULL;
+                
+                PreemptFastEnable();
+        }
+}
+
 /***********************************************************************
  *
@@ -284 +312 @@
         DWORD irq=curr.irq;
 
+        /* FIXME: Unreliable, since we can be interrupted. */
         if (currThread)
                 currThread->currContext=&curr;
@@ -298 +327 @@
 
                 case 0x30:
-                        curr.eax=IrqSysCall(curr.eax,curr.edx,curr.ecx);
+                        curr.eax = IrqSysCall(curr.eax,curr.edx,curr.ecx);
                         break;
 
@@ -307 +336 @@
         if (thrNeedSchedule && PreemptCanSchedule())
                 ThrSchedule();
-}
-
+
+        if (currThread && (currThread->flags & THR_NEED_RESTORE))
+        {
+                curr.eip = currThread->oldEip;
+                curr.esp3 = currThread->esp3;
+                currThread->flags &= ~(THR_NEED_RESTORE);
+        }
+
+        if (currThread && currThread->eventFunc)
+                IrqDoEvent(&curr);
+}
+

Whitix/branches/netchannel/arch/i386/kernel/process.c

@@ -33 +33 @@
 void i386ExitThread();
 void endi386ExitThread();
+void i386RetFromEvent();
+void endi386RetFromEvent();
+
 DWORD exitCode=0xF8000000;
+DWORD retFromEvent;
 
 struct TSS* tss=(struct TSS*)(TSS_ADDR);
@@ -56 +60 @@
 int ThrArchInit()
 {
+        int exitCodeSz = (DWORD)endi386ExitThread-(DWORD)i386ExitThread;
+        int retEventSz = (DWORD)endi386RetFromEvent - (DWORD)i386RetFromEvent;
+
         /* Setup up the TSS, only needed for ss0 and esp0 */
         tss->bitmap=0x8000; /* Bitmap offset. Past limit, so every IO instruction in userspace will produce a GPF. */
@@ -64 +71 @@
         /* Copy the exit code over to a user accessable page of memory. Add procesor-specific syscall method code into the page soon. */
         VirtMemMapPage(0xF8000000, PageAlloc()->physAddr, PAGE_PRESENT | PAGE_RW | PAGE_USER);
-        memcpy((void*)exitCode, i386ExitThread, (DWORD)endi386ExitThread-(DWORD)i386ExitThread);
+        memcpy((void*)exitCode, i386ExitThread, exitCodeSz);
+        memcpy((void*)(exitCode + exitCodeSz), i386RetFromEvent, retEventSz);
+
+        retFromEvent = (DWORD)(exitCode + exitCodeSz);
 
         return 0;
@@ -85 +95 @@
 
         ret->esp3=*stackP; /* User stack */
+        ret->eventStack = MMapDo(ret->parent, NULL, 0, 0x1000, PAGE_RW | PAGE_PRESENT | PAGE_USER, 0, MMAP_PRIVATE, NULL)+0x1000;
 
         IrqSaveFlags(flags);

Whitix/branches/netchannel/include/error.h

@@ -44 +44 @@
 #define EISDIR          17 /* Is a directory - cannot read or write to it */
 #define EINVAL          18 /* Invalid value */
-#define EINTR           19 /* Operation interrupted by signal */
+#define EINTR           19 /* Operation interrupted by event */
 
 /* Network errors */

Whitix/branches/netchannel/include/sched.h

@@ -49 +49 @@
 void ThrSetPriority(struct Thread* thread, int priority);
 void ThrSuspendThread(struct Thread* thread);
+void ThrSuspendThreadInt(struct Thread* thread);
 void ThrResumeThread(struct Thread* thread);
 char* ThrGetProcName(DWORD pid);

Whitix/branches/netchannel/include/sys.h

@@ -44 +44 @@
 #define SYS_SHUTDOWN_BASE               57
 #define SYS_IO_BASE                             58
+#define SYS_TIMER_BASE                  61
+#define SYS_EVENT_BASE                  64
 
-#define SYSCALL_MAX             62
+#define SYSCALL_MAX             65
 
 #define SysEntry(addr, bytes) { (DWORD)addr, bytes }

Whitix/branches/netchannel/include/task.h

@@ -29 +29 @@
 struct JournalHandle;
 
-#define THR_USED_MATH 1
+#define THR_USED_MATH           1
+#define THR_NEED_RESTORE        2
 
 struct Thread
 {
         DWORD currStack;
+
+        /* Event handling functions */
+        void (*eventFunc)(void* data);
+        void* eventData;
+        DWORD eventStack;
+        DWORD oldEip;
+
         struct Process* parent;
         DWORD state,entry,esp3;
@@ -53 +61 @@
 /* Thread defines go here */
 
-#define THR_RUNNING 1
-#define THR_PAUSED  2
-#define THR_DYING   4
+#define THR_RUNNING             1
+#define THR_PAUSED              2
+#define THR_INTERRUPTIBLE       4
+#define THR_DYING               8
 
 struct Process
@@ -61 +70 @@
         struct ListHead next,sibling,children;
         int exitCode, state;
+        
+        /* Resource lists */
         struct File* files; /* Dynamically allocated */
-        Spinlock fileListLock;
-        int numFds;
+        struct KeTimer** timers;
+        Spinlock fileListLock, timerListLock;
+        int numFds, numTimers;
+
+        /* Filesystem contexts */
         struct VNode *cwd,*root,*exec;
         char* name;

Whitix/branches/netchannel/include/timer.h

@@ -36 +36 @@
 void Sleep(int milliSeconds);
 
+/* Parameters for the system calls */
+#define TIMER_USER_PERIODIC             0x01
+
+struct UserTimerSpec
+{
+        DWORD secs, usecs;
+};
+
+struct UserTimer
+{
+        int flags;
+        void* data;
+        void (*func)(void* data);
+};
+
+struct KeTimer
+{
+        struct UserTimer uInfo;
+        struct Timer timer;
+        struct Thread* thread;
+};
+
+struct Process;
+int TimerProcessRemove(struct Process* current);
+
 #endif

Whitix/branches/netchannel/include/wait.h

@@ -77 +77 @@
 }while(0)
 
+#define WAIT_ON_INTERRUPTIBLE(waitQueue, condition) \
+do { \
+} while(0)
+
 #define SLEEP_ON(waitQueue) \
 do { \

Whitix/branches/netchannel/kernel/Makefile

@@ -1 +1 @@
 DEPTH=../
 OBJS = main.o sched.o sys.o reboot.o panic.o wait.o module.o print.o symbols.o timer.o preempt.o \
-        thread.o process.o startup.o tasklet.o
+        thread.o process.o startup.o tasklet.o event.o
 
 build: $(OBJS)

Whitix/branches/netchannel/kernel/main.c

@@ -47 +47 @@
 extern int KeyboardInit();
 extern int ConsoleInit();
+extern int TimerInit();
+extern int EventInit();
 
 void KernelMain()
@@ -56 +58 @@
         ShutdownInit();
         UserCodeInit();
+        TimerInit();
+        EventInit();
         
         /* Set up the device-related subsystems. */

Whitix/branches/netchannel/kernel/process.c

@@ -6 +6 @@
 #include <i386/process.h>
 #include <malloc.h>
+#include <event.h>
 #include <keobject.h>
 #include <user_acc.h>
 #include <print.h>
+#include <timer.h>
 #include <fs/icfs.h>
 #include <fs/vfs.h>
@@ -236 +238 @@
 
 repeat:
-        waitEntry.thread=currThread;
+        waitEntry.thread = currThread;
         WaitAddToQueue(&current->waitQueue, &waitEntry);
-        ThrSuspendThread(currThread);
+        ThrSuspendThreadInt(currThread);
         ThrSchedule();
+
+        if (EventWaiting(currThread))
+                return -EINTR;
 
         /* Is it the right one? */
@@ -361 +366 @@
         MmapProcessRemove(current);
         LoadReleaseFsContext();
+        TimerProcessRemove(current);
 
         /* Now get rid of the memory manager - leaving kernel memory pages intact */

Whitix/branches/netchannel/kernel/sched.c

@@ -19 +19 @@
 #include <sched.h>
 #include <error.h>
+#include <print.h>
 #include <i386/process.h>
 #include <slab.h>
@@ -96 +97 @@
                         thread=curr;
                 }
+
+                if ((curr->eventFunc != NULL) && curr->state == THR_INTERRUPTIBLE)
+                        ThrResumeThread(curr);
         }
                 

Whitix/branches/netchannel/kernel/thread.c

@@ -142 +142 @@
 
         if (thread == currThread)
-                ArchSwitchStackCall(exitStack+PAGE_SIZE/4,_ThrFreeThread,thread);
+                ArchSwitchStackCall(exitStack + (PAGE_SIZE >> 2),_ThrFreeThread,thread);
         else{
                 MemFree((void*)(thread->currStack));
@@ -233 +233 @@
  ***********************************************************************/
 
-void ThrSuspendThread(struct Thread* thread)
+void ThrDoSuspendThread(struct Thread* thread, int state)
 {
         if (thread == idleTask)
                 KernelPanic("Idle task being suspended - driver sleeping in interrupt?");
 
+        SpinLockIrq(&thrListLock);
+
         if (LIKELY(thread->state == THR_RUNNING))
         {
-                SpinLockIrq(&thrListLock);
                 --nrRunning;
-                thread->state=THR_PAUSED;
-                SpinUnlockIrq(&thrListLock);
-        }
+                thread->state = state;
+        }
+
+        SpinUnlockIrq(&thrListLock);
+}
+
+void ThrSuspendThread(struct Thread* thread)
+{
+        ThrDoSuspendThread(thread, THR_PAUSED);
 }
 
 SYMBOL_EXPORT(ThrSuspendThread);
 
+void ThrSuspendThreadInt(struct Thread* thread)
+{
+        ThrDoSuspendThread(thread, THR_INTERRUPTIBLE);
+}
+
+SYMBOL_EXPORT(ThrSuspendThreadInt);
+
 /***********************************************************************
  *
  * FUNCTION:    ThrResumeThread
  *
- * DESCRIPTION: Resume a paused thread, and signal scheduling if it's of
- *                              a higher priority.
+ * DESCRIPTION: Resume a paused thread.
  *
  * PARAMETERS:  thread - the thread in question.
@@ -268 +281 @@
                 ThrStartThread(thread);
                 if (thread->quantums >= currThread->quantums)
-                        thrNeedSchedule=true;
+                        thrNeedSchedule = true;
         }
 }

Whitix/branches/netchannel/kernel/timer.c

@@ -23 +23 @@
 #include <error.h>
 #include <task.h>
+#include <sys.h>
 #include <malloc.h>
+#include <event.h>
+#include <print.h>
 
 LIST_HEAD(timerList);
@@ -185 +188 @@
 SYMBOL_EXPORT(Sleep);
 
+#define KE_TIMER_ALLOC_STEP             10
+
+void TimerWakeup(void* data)
+{
+        struct KeTimer* timer = (struct KeTimer*)data;
+
+        EventFire(timer->thread, timer->uInfo.func, timer->uInfo.data);
+}
+
 /* Kernel system calls for timers */
-int SysTimerCreate()
-{
-        return 0;
-}
-
-int SysTimerDestroy()
-{
-        return 0;
-}
+int SysTimerCreate(struct UserTimer* timerDesc)
+{
+        int i;
+        struct KeTimer* curr;
+
+        SpinLock(&current->timerListLock);
+
+        if (!current->timers)
+        {
+                current->numTimers = KE_TIMER_ALLOC_STEP;
+                current->timers = (struct KeTimer**)MemAlloc(sizeof(struct KeTimer) * KE_TIMER_ALLOC_STEP);
+        }
+
+        for (i = 0; i < current->numTimers; i++)
+                if (!current->timers[i])
+                        break;
+
+        if (i == current->numTimers)
+        {
+                KePrint("TODO: Extend array\n");
+        }
+
+        current->timers[i] = (struct KeTimer*)MemAlloc(sizeof(struct KeTimer));
+        curr = current->timers[i];
+
+        curr->thread = currThread;
+        memcpy(&curr->uInfo, timerDesc, sizeof(struct UserTimer));
+        curr->timer.func = TimerWakeup;
+        curr->timer.data = curr;
+
+        SpinUnlock(&current->timerListLock);
+
+        return i;
+}
+
+struct KeTimer* TimerGet(struct Process* process, int timer)
+{
+        if (timer < 0 || timer > process->numTimers)
+                return NULL;
+
+        return process->timers[timer];
+}
+
+int SysTimerModify(int tid, struct UserTimerSpec* newValue, struct UserTimerSpec* oldValue)
+{
+        struct KeTimer* timer;
+
+        timer = TimerGet(current, tid);
+
+        if (oldValue)
+        {
+                KePrint("oldValue != NULL\n");
+                return -ENOTIMPL;
+        }
+
+        if (!newValue)
+                return -EFAULT;
+
+        /* TODO: Check if timer is already on list */
+
+        timer->timer.expires = newValue->secs * 1000;
+        /* useconds */
+        TimerAdd(&timer->timer);
+
+        return 0;
+}
+
+int SysTimerDestroy(int timer)
+{
+        KePrint("SysTimerDestroy(%d)\n", timer);
+        return 0;
+}
+
+int TimerProcessRemove(struct Process* process)
+{
+        if (process->timers)
+        {
+                KePrint("Free timers\n");
+        }
+
+        return 0;
+}
+
+static struct SysCall timerSysCallTable[]=
+{
+        SysEntry(SysTimerCreate, 4),
+        SysEntry(SysTimerModify, 12),
+        SysEntry(SysTimerDestroy, 4),
+        SysEntryEnd()
+};
+
+int TimerInit()
+{
+        SysRegisterRange(SYS_TIMER_BASE, timerSysCallTable);
+        return 0;
+}

Whitix/branches/netchannel/user/burn/builtins.c

@@ -560 +560 @@
 //                      SysClose(fd);
                 return 1;
-        }else
-                SysWaitForProcessFinish(pid,NULL);
+        }else{
+                int ret;
+                
+                do
+                {
+                        ret = SysWaitForProcessFinish(pid,NULL);
+                } while (ret == -EINTR);
+        }
 
 //      if (redirOut)

Whitix/branches/netchannel/user/burn/main.c

@@ -445 +445 @@
     ConsSetTabSetup(&context, TabCompletionSetup);
     ConsSetBufferUpdate(&context, BurnTokenUpdate);
-    
+
         printf("Burn shell V%d.%d\n---------------\nType 'help intro' for an introduction to the shell\n",
          MAJOR_BURN_VERSION, MINOR_BURN_VERSION);

Whitix/branches/netchannel/user/libc/include/syscalls.h

@@ -18 +18 @@
 {
         unsigned long seconds,useconds;
+};
+
+struct UserTimer
+{
+        int flags;
+        void* data;
+        void (*func)(void* data);
+};
+
+struct UserTimerSpec
+{
+        unsigned long seconds, useconds;
 };
 

Whitix/branches/netchannel/user/libc/include/sysdefs.h

@@ -80 +80 @@
 SYSCALL(58,int,SysIoAccess,4,(int on));
 
+/* Channel system calls */
 SYSCALL(59, int, SysChannelCreate, 16, (int family, void* src, void* dest, void*
                         options));
 SYSCALL(60, int, SysChannelControl, 12, (int fd, unsigned long code, void* data));
+
+/* Timer system calls */
+SYSCALL(61, int, SysTimerCreate, 4, (struct UserTimer* timer));
+SYSCALL(62, int, SysTimerModify, 12, (int timer, struct UserTimerSpec* newSpec, struct UserTimerSpec* oldSpec));
+SYSCALL(63, int, SysTimerDestroy, 4, (int timer));
+
+/* Event system calls */
+SYSCALL(64, int, SysEventReturn, 0, ());

Whitix/branches/netchannel/user/linker/Makefile

@@ -19 +19 @@
         $(CC) $(BASE_CFLAGS) -c $*.S -o $*.o
 
-liblinker.so: $(OBJS)
+liblinker.so: $(OBJS) ../libc/rtl/syscall.o
         gcc $(BASE_LDFLAGS) $(LINKER_LDFLAGS) -shared $(OBJS) ../libc/rtl/syscall.o -o liblinker.so     
 

Whitix/branches/netchannel/user/net/telnet.c

@@ -96 +96 @@
         }
 
-//      printf("offset = %d, ret = %d\n", offset, ret);
 
         if (ret > 0)

Whitix/branches/netchannel/user/posix/file/file.c

@@ -10 +10 @@
 #include <syscalls.h>
 
+#include "internal.h"
+
 /* Sanity check these functions */
 
@@ -89 +91 @@
 int close(int fd)
 {
-        return SysClose(fd);
+        struct PosixFile* file = PosixHandleToFile(fd);
+        int ret = -1;
+
+        if (file && file->type && file->type->close)
+        {
+                ret = file->type->close(file);
+
+                if (ret == 0)
+                {
+                        printf("close: free entry in table.\n");
+                }
+        }
+        
+        return ret;
 }
 

Whitix/branches/netchannel/user/posix/socket/socket.c

@@ -11 +11 @@
 #include "../file/internal.h"
 
+static int PosixSocketClose(struct PosixFile* file)
+{
+        Socket* socket = (Socket*)PosixFilePriv(file);
+
+        return SocketClose(socket);
+}
+
 /* POSIX file operations */
 struct PosixFileType socketType =
 {
+        .close = PosixSocketClose,
 };
 

Whitix/branches/netchannel/user/sdk/include/net/socket.h

@@ -52 +52 @@
 }
 
+static inline void SocketFree(Socket* socket)
+{
+        free(socket);
+}
+
 /* General functions. */
 int SocketCreate(Socket* socket, int domain, int type, int protocol);

Whitix/branches/netchannel/user/sdk/network/Makefile

@@ -1 @@
-CFLAGS = -Wall -I../include -I../../libc/include -nostdlib -ffreestanding -fno-builtin -fPIC -m32 
+CFLAGS = -Wall -I../include -I../../libc/include -nostdlib -ffreestanding -fno-builtin -fPIC -m32 -O3
 
 OBJS = byteorder.o ipv4.o udp.o memory.o dns.o icmp.o tcp.o tcp_options.o channels.o init.o socket.o

Whitix/branches/netchannel/user/sdk/network/socket.c

@@ -11 +11 @@
         if (type == NET_TYPE_STREAM)
         {
-                _TcpSocketCreate(socket);
-                return 0;
+                return _TcpSocketCreate(socket);
         }else{
-                _UdpSocketCreate(socket);
-                return 0;
+                return _UdpSocketCreate(socket);
         }
 

Whitix/branches/netchannel/user/sdk/network/tcp_options.h

@@ -27 +27 @@
 void* TcpOptionAdd(struct TcpHeaderBuild* build, int type);
 int TcpFinishHeader(struct TcpHeaderBuild* build);
-int TcpParseOptions(struct TcpSocketInfo* info, struct TcpHeader* header);
+int TcpParseOptions(struct TcpSocketInfo* info, struct TcpHeader* header, ushort packetLength);
 
 #endif