proc.c

/***************************************************************************
                          proc.c  -  description
                             -------------------
    begin                : Sat Dec 27 2003
    copyright            : (C) 2003 by Dynacube Team
    email                : mdshah82@yahoo.com
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

 #include "proc/proc.h"
 #include "core/kerror.h"
 #include "common/ktypes.h"
 #include "mm/mm.h"
 #include "common/kconst.h"
 #include "core/ktask.h"
 #include "core/kinit.h"
 #include "common/ds/queue.h"
 #include "core/kint.h"
 #include "gui/svga.h"
 #include "fs/fat12.h"

 LDT _ldt[MAX_PROC] __attribute__((aligned (8)));
 SEG_DESC _ldte[MAX_PROC][3] __attribute__((aligned (8)));

 PROC _proc[MAX_PROC];

 DW cur_pid = MAX_PROC+1;

 DB which_task = 0; //Currently used USR_TSS
 
 SDB create(char *pathname)
 {
         DB pid, i, j;
         DD addr, base, limit;
         DW flags = 0;
   SDD pg_num[MAX_PROC_SIZE/_4KB] = {-1}; 

         SEG_DESC temp;
         char *c;

         for(pid=0 ; pid < MAX_PROC ; pid++)
         {
                 if(_proc[pid].avl == _true)
                 {
                          _proc[pid].avl = _false;
                                break;
                 }
         }

         printf("\nPID: %d\n",pid);
   
         if(pid == MAX_PROC)
         {
                        printf("\nFork Failure");
                        return FORK_FAILURE;
   }
   
         for(i = 0 ; i < (MAX_PROC_SIZE/_4KB) ; i++)
         {
                 pg_num[i] = findpage();

                 if(pg_num[i] == PAGE_NOT_FOUND)
                 {
                          for(j = 0 ; j < i ; j++)
                                freepage(pg_num[j]);

                        return FORK_FAILURE;
     }

                 addr = KERNEL_SIZE + (pg_num[i] * _4KB); //Physical

                 printf("\tA %x Pg %d",addr,pg_num[i]);
                 _pgte[pid][i] = addr | 7; //User R/W Present
         }

   //Only variables here & the rest in proc_init
   _proc[pid].esp    = MAX_PROC_SIZE-1;
   _proc[pid].eip    = 0;

   enq(&ready_q,pid);
   load(pathname,pid);
   return pid;
 }

 void schedule()
 {
         SEG_DESC tmp, *t;
         clearDESC(&tmp);
         DW ldt_flags = 0x882;//IA32 - 74 LDT_TYPE = 0010        0x4E2
         
        //       Choose ready_q and set cur_pid
    if(findq(&ready_q,GUI_PID) == 0)
    {
     cur_pid = GUI_PID; 
    }
    else
    {
      cur_pid = deq(&ready_q);
    
      if(cur_pid == NULL_PID)    
        cur_pid = deq(&ready_q);
    }
    
    if(_proc[cur_pid].avl)
     {
        if(_proc[NULL_PID].avl)
        {
          while(1)
           printf("in where it shouldn't be\n");
          memcpy((void *)(KERNEL_SIZE),(void *)null_proc,512);
        } 

        cur_pid = NULL_PID;
     }

         createDESC(&tmp,(_ldt[cur_pid].hibase<<16)|_ldt[cur_pid].lobase,_ldt[cur_pid].limit,ldt_flags);
         addDesc(LDT_USR_SEL,&tmp);

   _task[which_task].eip    = _proc[cur_pid].eip;
   _task[which_task].es     = _proc[cur_pid].es;
   _task[which_task].fs     = _proc[cur_pid].fs;
   _task[which_task].gs     = _proc[cur_pid].gs;
   
   _task[which_task].eax    = _proc[cur_pid].eax;
   _task[which_task].ebx    = _proc[cur_pid].ebx;
   _task[which_task].ecx    = _proc[cur_pid].ecx;
   _task[which_task].edx    = _proc[cur_pid].edx;
   _task[which_task].esi    = _proc[cur_pid].esi;
   _task[which_task].edi    = _proc[cur_pid].edi;
   _task[which_task].ebp    = _proc[cur_pid].ebp;
                            
   _task[which_task].cs                 = _proc[cur_pid].cs;
   _task[which_task].ds                 = _proc[cur_pid].ds;
   _task[which_task].ss                 = _proc[cur_pid].ss;
   _task[which_task].esp                = _proc[cur_pid].esp;
   _task[which_task].ss0                = _system.ss0;
   _task[which_task].esp0               = _system.esp0;
   _task[which_task].ldt_sel = LDT_USR_SEL*8;
   _task[which_task].eflags  = _proc[cur_pid].eflags;  //|(1<<9)
   _task[which_task].cr3                        = _proc[cur_pid].cr3; //(_system.cr3 & 0xFFF) | (((DD)_pgde) & 0xFFFFF000);

   _task[which_task].io_map  = 0x70;

   which_task = !which_task;

   //Clearing Busy Bit
    t = (SEG_DESC*)(GDT_BASE+SYS_TSS_SEL*8);
    t->flags_8_15 &= ~0x2;
    asm("ltr %%ax"::"a"(SYS_TSS_SEL*8));
    t->flags_8_15 &= ~0x2;  

  if(which_task)
  {
   t = (SEG_DESC*)(GDT_BASE+TASK1_TSS_SEL*8);
   t->flags_8_15 &= ~0x2;
   asm("lcall %0,$0"::"i"(TASK1_TSS_SEL*8));
  }
  else
  {
   t = (SEG_DESC*)(GDT_BASE+TASK2_TSS_SEL*8);
   t->flags_8_15 &= ~0x2;
   asm("lcall %0,$0"::"i"(TASK2_TSS_SEL*8));
  }
 }


 void proc_init()
 {
         DB pid;
   DB pg_dir_offset = (KERNEL_SIZE/_4MB)+((KERNEL_SIZE%_4MB)?1:0);
         DW flags = 0;
         DD base, limit;
   
         for(pid=0 ; pid < MAX_PROC ; pid++)
         {
                 _proc[pid].avl = _true;
     _proc[pid].msg_q_delim  = 0;
     _proc[pid].wait_int_num = 0xFFFF;
     _proc[pid].time_out     = 0;

   _pgde[pid+pg_dir_offset] = ((DD)_pgte[pid]) | 7; // _pgde[0 to 2] for kernel

   clearDESC(&_ldte[pid][0]);
   clearDESC(&_ldte[pid][1]);
   clearDESC(&_ldte[pid][2]);

   flags = ((F_G|F_D_B)<<8)|F_P|F_S|F_TYPE_CODE|F_TYPE_R|F_SD_DPL_3; //CODE
   base  = (pid+pg_dir_offset) << 22;
   limit = (MAX_PROC_SIZE/_4KB);
   createDESC(&_ldte[pid][0],base,limit,flags);

   flags = ((F_G|F_D_B)<<8)|F_P|F_S|F_TYPE_DATA|F_TYPE_W|F_SD_DPL_3;//|F_TYPE_E;//; //DATA
   base  = (pid+pg_dir_offset) << 22;
   limit = (MAX_PROC_SIZE/_4KB);
   createDESC(&_ldte[pid][1],base,limit,flags);

   flags = ((F_G|F_D_B)<<8)|F_P|F_S|F_TYPE_DATA|F_TYPE_W|F_SD_DPL_3|F_TYPE_E; //Stack
   base  = (pid+pg_dir_offset) << 22;
   limit = 0;
   createDESC(&_ldte[pid][2],base,limit,flags);

   _ldt[pid].hibase = (((DD)&_ldte[pid][0]) >> 16);
   _ldt[pid].lobase = (((DD)&_ldte[pid][0]) & 0xFFFF);
   _ldt[pid].limit  = 3*8 - 1;

   _proc[pid].cs = (0x0<<3)|(0x1<<2)|0x3;
   _proc[pid].ds = (0x1<<3)|(0x1<<2)|0x3;
   _proc[pid].ss = (0x2<<3)|(0x1<<2)|0x3;
   _proc[pid].es = (0x1<<3)|(0x1<<2)|0x3;
   _proc[pid].fs = (0x1<<3)|(0x1<<2)|0x3;

   _proc[pid].cr3 = (_system.cr3 & 0xFFF) | (((DD)_pgde) & 0xFFFFF000);
   _proc[pid].eflags = 2 | (1<<9);
         }       
 }


void do_exit(DW pid)
 {
   DD i;
   printf("exit called\n");
   ginfo(400,350,"Exit Called");
   ginfo(400,400,itoa(pid,10));

   remove(&ready_q,pid);

   _proc[pid].avl = _true;
   _proc[pid].msg_q_delim  = 0;
   _proc[pid].wait_int_num = 0xFFFF;
   _proc[pid].time_out     = 0;

   for(i = 0; i<(MAX_PROC_SIZE/_4KB);i++)
   {
     freepage(((_pgte[pid][i] ^ 7) - KERNEL_SIZE)/_4KB);
   }
   printf("exit pid : %d",pid);

   //Close all windows
   _Z11destroy_wint(pid);

   //Close all files
   fscloseAll(pid);
 }

SDB fork()
{
  SDB pid;// = create();
  
  if(pid != FORK_FAILURE)  
  {
   //Setting the pid in the Child Process
   _proc[pid].eax = 0;
   // and the pid of child in the Parent Process
   _proc[cur_pid].eax = pid;
  }
        return pid;
}

SDW load(char *fname,DW pid)
{
  fs_request fs_r;
  fs_r.type = LOAD;

        fs_r.load.fname = (DB *)fname;
  fs_r.from_pid = pid;
        if(addfsreq(&fs_r) != 0)
  {
    do_exit(pid);
  }
  else
  {
   remove(&ready_q,pid);
   enq(&fs_q,pid);
  }
}

void forkNULL()
{
         DB pid, i, j;
         DD addr, base, limit;
         DW flags = 0;
   SDD pg_num[MAX_PROC_SIZE/_4KB] = {-1};

         SEG_DESC temp;
         char *c;

         for(pid=0 ; pid < MAX_PROC ; pid++)
         {
                 if(_proc[pid].avl == _true)
                 {
                          _proc[pid].avl = _false;
                                break;
                 }
         }

         printf("\nPID: %d\n",pid);

         if(pid == MAX_PROC)
         {
                        printf("\nforkNULL Failure");
                        return FORK_FAILURE;
   }

         for(i = 0 ; i < (MAX_PROC_SIZE/_4KB) ; i++)
         {
                 pg_num[i] = findpage();

                 if(pg_num[i] == PAGE_NOT_FOUND)
                 {
                          for(j = 0 ; j < i ; j++)
                                freepage(pg_num[j]);

                        return FORK_FAILURE;
     }

                 addr = KERNEL_SIZE + (pg_num[i] * _4KB); //Physical

                 printf("\tA %x Pg %d",addr,pg_num[i]);
                 _pgte[pid][i] = addr | 7; //User R/W Present
         }

   addr = KERNEL_SIZE + (pg_num[0] * _4KB); //Physical Addr
   kmemcpy((void *)(addr),null_proc,512);

   //Only variables here & the rest in proc_init
   _proc[pid].esp    = MAX_PROC_SIZE-1;
   _proc[pid].eip    = 0;
}

void reti()
{
 DD i = 0 , j = 0, _delay = 0x1000;
 DB c;
 DW data = 0xFF, port = 0x60;

 asm("movl $0,%eax");
 asm("int %0"::"i"(0x30));
 
 BLOCK
}

void rogue()
{
 DD i = 0 , j = 0, _delay = 0x1000;
 DB c;
 DW data = 0xFF, port = 0x60;
 
 asm("int $200");

 BLOCK  
}


void null_proc()
{
  DB i = 0;

  char *str = "Hello";

  BLOCK
}

---