New Scheduling / Syscalls!

5 files changed, 39 insertions, 29 deletions

diff --git a/kernel/interrupts.c b/kernel/interrupts.c
index 8bc4f47..702112c 100644
--- a/kernel/interrupts.c
+++ b/kernel/interrupts.c
@@ -122,9 +122,9 @@ uint32_t interrupt_handler(uint32_t esp, uint32_t irq)
     if(irq==INTERRUPT_SYSCALL)
     {
             int pid=task_get_current_pid();
-
             uint32_t *stack;
-            stack=esp;
+            stack=esp; 
+            task_set_esp(pid,esp); // this will get fucked if we get scheduled away...
 
             // extract variables from stack 
             // (NOTE we pass them in some fucked up order, 
@@ -148,11 +148,9 @@ uint32_t interrupt_handler(uint32_t esp, uint32_t irq)
             // it will also not work with SMP
             while(true)
             {
-    //            x86_cli(); 
                 int ok=syscall_generic_test(eax,edx,ecx,ebx,pid);
-      //          x86_sti(); 
                 if(ok)break;
-                else __asm__("int $0x81");
+                __asm__("int $0x81");// does NOT requie interrupts
             }
 
             // uff, once we got through we can do the syscall and get out
diff --git a/kernel/kernel.h b/kernel/kernel.h
index 5685f7d..263477a 100644
--- a/kernel/kernel.h
+++ b/kernel/kernel.h
@@ -33,13 +33,14 @@ REFERENCES
 #define HIDE_FIXME
 
 //#define RINGBUFFER_WARN
+//#define LOG_SCHEDULER
 
 #define FOOLOS_APIC_FREQ 60 // how many apic ticks per second
 //#define FOOLOS_APIC_FREQ 1 // how many apic ticks per second SLOW-MO
 
 #define MAX_MOUNTS 10
 
-#define BIN_INIT "/bin/xterm"
+#define BIN_INIT "/bin/init"
 #define VESA_FONT_PATH "/doc/fonts/binfont.bin"
 
 #define FIFO_MAX_RINGBUFFERS 20
diff --git a/kernel/scheduler.c b/kernel/scheduler.c
index 8cadcb8..694d81c 100644
--- a/kernel/scheduler.c
+++ b/kernel/scheduler.c
@@ -133,7 +133,9 @@ static uint32_t scheduler_schedule(uint32_t idx)
 
 	    current_task[cpu]=idx;
             
-//             klog("cpu %d rescheduled to %d",cpu,idx);
+#ifdef LOG_SCHEDULER
+             klog("cpu %d rescheduled to %d",cpu,idx);
+#endif
              //klog("name: %s",task_list[cpu][idx].name);
 
              //klog("cpu %d / idx %d / pid %d / name: %5s",cpu,idx,task_list[cpu][idx].pid,task_list[cpu][idx].name);
@@ -508,6 +510,13 @@ volatile int task_add_win(uint32_t pid,ringbuffer *r)
     return 0;
 }
 
+int task_set_esp(uint32_t pid, uint32_t esp)
+{
+            uint32_t cpu=smp_get(SMP_APIC_ID);
+            uint32_t idx=task_idx(pid);
+            task_list[cpu][idx].esp=esp;
+            return 0;
+}
 volatile int task_reset(uint32_t pid, uint32_t entry, uint32_t stack,uint32_t brk)
 {
     uint32_t cpu=smp_get(SMP_APIC_ID);
@@ -517,7 +526,8 @@ volatile int task_reset(uint32_t pid, uint32_t entry, uint32_t stack,uint32_t br
 
     stk[14]=entry;
     stk[17]=stack;
-    __asm__("int $0x81"); // now we also reschedule (at least for execve sake...)
+
+//    __asm__("int $0x81"); // now we also reschedule (for execve sake...)
     return 1;
 }
 
diff --git a/kernel/scheduler.h b/kernel/scheduler.h
index 1b260d8..7650f01 100644
--- a/kernel/scheduler.h
+++ b/kernel/scheduler.h
@@ -22,3 +22,4 @@ uint32_t task_idx(uint32_t pid);
 void task_exit(uint32_t pid);
 void task_set_name(uint32_t pid, char *name);
 volatile int task_add_win(uint32_t pid,ringbuffer *);
+int task_set_esp(uint32_t pid, uint32_t esp);
diff --git a/kernel/syscalls.c b/kernel/syscalls.c
index 23c88a7..9fc1a7f 100644
--- a/kernel/syscalls.c
+++ b/kernel/syscalls.c
@@ -307,11 +307,8 @@ int syscall_select(int maxxfd,struct timeval *tv, fd_set **fd_sets, uint32_t pid
 
     if(!test)FD_ZERO(fd_sets[2]); // we dont give a shit about exceptions! :P TODO!!!
 
-
     return ret;
 
-
-
 }
 
 //TODO: use fd and inode (instead of path)... now this is a crazy trick how it works.. 
@@ -331,7 +328,7 @@ struct dirent *syscall_opendir(const char *name,struct dirent *dirs,int none,uin
     if(ret==-1)
     {
         // no it does not!
-	set_errno(ENOENT);
+        set_errno(ENOENT);
         return NULL;
     }
 
@@ -392,29 +389,33 @@ int copy_args(char **in, char **out)
 int syscall_execve(const char *name, char *const argv[], char *const env[], int pid)
 {
     uint32_t alloc;
-    uint32_t entry_global=load_elf(name,&alloc);
-
-    fixme("not overwrite yourself?");
+    char **argv1= VMEM_USER_ENV;
+    char **env1 = VMEM_USER_ENV+1024*2;
     int arg_count=0;
-    while(argv[arg_count]!=NULL)arg_count++;
+    //*argv1=NULL;
+    //*env1=NULL;
 
-    char **argv1=VMEM_USER_ENV;
+    // TODO!
+    fixme("not overwrite yourself badly here!?");
+    while(argv[arg_count]!=NULL)arg_count++;
     if(argv!=NULL)copy_args(argv,argv1);
-    else argv1=NULL;
-
-    char **env1=VMEM_USER_ENV+1024*2;
     if(env!=NULL)copy_args(env,env1);
-    else env1=NULL;
 
-    if(!entry_global){
-	set_errno(ENOENT);
-	return -1;
+    uint32_t entry_global=load_elf(name,&alloc); // overwrites ourselves (in userspace)
+
+    if(!entry_global)
+    {
+        kpanic("no entry point!"); // TODO: rem
+        set_errno(ENOENT);
+        return -1;
     }
 
-    uint32_t *stack=VMEM_USER_STACK_TOP-4*32;
+    // here we might overwrite our CURRENT stack!!! oh fuck TODO: check it!
+    uint32_t *stack=VMEM_USER_STACK_TOP-4*32; 
     *--stack=argv1;
     *--stack=arg_count;
     *--stack=env1;
+
     task_set_name(pid,name);
     task_reset(pid,entry_global,stack,alloc);
 
@@ -444,10 +445,11 @@ uint32_t syscall_fork(int none1, int none2, int none3, int pid)
 	fds[newpid][i]=fd_dupl(&fds[pid][i]);
 	open_fd[newpid][i]=true;
     }
+
     tty[newpid]=tty[pid];
     invl[newpid]=invl[pid];
-//    fds[newpid][0]=fd_from_ringbuffer(); // TODO fix
-//    open_fd[newpid][0]=true;
+//  fds[newpid][0]=fd_from_ringbuffer(); // TODO fix
+//  open_fd[newpid][0]=true;
 
     return newpid;
 }
@@ -747,9 +749,7 @@ uint32_t syscall_generic(uint32_t nr,uint32_t p1, uint32_t p2, uint32_t p3, uint
             if(!strcmp(p1,"fcntl")){
                 klog("todo: quickfix hack for fcntl");
             }
-
     }
     klog("unknown syscall %s / %d we just return 0",p1,nr);
     return 0;
 }
-