kernel.cpp

Jazmyn is a 32-bit, protected mode, multitasking OS which runs on i386 & above CPU`s. Its complete

/*
 * Copyright (C) 2004, Thejesh AP. All rights reserved.
 */

#include <sys\types.h>
#include <null.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <dirent.h>
#include <semaphore.h>

#include <mm\paging.h>
#include <mm\new.h>
#include <mm\heap.h>
#include <jazmyn\desc.h>
#include <mm\memory.h>
#include <fs\file_sys.h>
#include <jazmyn\process.h>
#include <fs\fatvol.h>
#include <fs\devmgr.h>

#include <fs\exe.h>
#include <fs\fatdriver.h>

#include <jazmyn\i386.h>
#include <jazmyn\gdt.h>
#include <drivers\console.h>
#include <drivers\keyboard.h>
#include <drivers\timer.h>
#include <jazmyn\sys_calls.h>
#include <jazmyn\kernel.h>
         

process proc[MAX_PROCESS];
process	*curr_proc = NULL;
process *fg_proc = NULL;
TSS _kernel_tss;

extern FATdriver _FAT_driver;
extern GDT      _gdt;
extern timer    _timer_obj;
int sched_ready = 0;
ushort _kernel_tss_sel;

struct
{
	int		(*__fork)(uint ebx,uint ecx,uint edx,uint esi,uint edi,
                        uint ebp,uint gs,uint fs,uint es,uint ds,uint eip,
                        uint cs,uint eflags,uint esp,uint ss);
	int		(*__exec)(char *path,char **argv,char **env);
	void		(*__exit)(int exit_code);
	int		(*__wait)(int child,int *status,int options);
	void*		(*__malloc)(size_t size);
	void		(*__free)(void *addrs);
        void            (*__delay)(uint millisecs);
	int		(*__open)(const char* path,int access,mode_t perm);
	off_t		(*__lseek)(int fd,off_t pos,int whence);
	ssize_t	(*__read)(int fd,void *buf,size_t size);
	ssize_t	(*__write)(int fd,const void *buf,size_t size);
	int		(*__close)(int fd);
	int		(*__unlink)(const char *link);
	int		(*__fstat)(int fd,stat *statv);
        DIR*        (*__opendir)(const char *path);
	dirent*     (*__readdir)(DIR *dir_fd);
	void		(*__rewinddir)(DIR *__dir_fd);
	int		(*__closedir)(DIR *dir_fd);
        int             (*__mkdir)(const char *path,mode_t mode);
	int		(*__rmdir)(const char *path);
	int		(*__chdir)(const char *path);
        int             (*__chroot)(char *root_drive);
        void            (*__utils)(int utilnr);

}sys_call={
	sys_fork,
	sys_exec,
	sys_exit,
	sys_wait,
	sys_malloc,
	sys_free,
        sys_delay,
	sys_open,
	sys_lseek,
	sys_read,
	sys_write,
	sys_close,
	sys_unlink,
	sys_fstat,
        sys_opendir,
	sys_readdir,
	sys_rewinddir,
	sys_closedir,
        sys_mkdir,
        sys_rmdir,
	sys_chdir,
        sys_chroot,
        sys_utils
};


char *environ[] =
{
        "PATH= :\\BIN\\",
        "BOOT= ",
        0
};

int main()
{
        sti();
        char *mem = (char*)0x6400000;
         _FAT_driver.init_FATdriver(*mem);
         environ[1][5] = *mem;
         environ[0][5] = *mem;
        _kernel_tss_sel = _gdt.set_tss((uint)&_kernel_tss,sizeof(_kernel_tss));
	LTR(_kernel_tss_sel);
        cout<<"\nStarting Init Process...\n";
        for(int i=0;i<5;i++)
        {
                if(start_init_process() == 0)
                break;
                cout<<"Err Loading Init :Retry NO :"<<i+1<<endl;
        }
        sched_ready = 1;
	while(1);
}

void disp_hdr(exe &hdr)
{
        cout<<"magic :"<<hdr.magic<<endl;
        cout<<"size  :"<<hdr.hdr_len<<endl;
        cout<<"ep    :"<<hdr.entry_point<<endl;
        cout<<"cs sz :"<<hdr.cs<<endl;
        cout<<"ds sz :"<<hdr.ds<<endl;
        cout<<"bss sz:"<<hdr.bss<<endl;
}

int start_init_process()
{
        cli();

	/* NOTE :Its not like Linux, there is no boot process.so init is assigned pid = 0 */
	
	process *init = &proc[0];
	void *buf;
        if(buf = _FAT_driver.open_init("init.com"))
	{
		exe exe_hdr;
                exe_hdr = *(exe*)buf;

                if(exe_hdr.magic != 0xDEADBEEF)
                {
                       delete buf;
                       return -1;
                }
		init->init_process(buf,exe_hdr.cs,exe_hdr.ds,exe_hdr.bss,PAGE_SIZE,
					exe_hdr.entry_point);
		fg_proc = init;
                delete buf;
                return 0;
	}
	else
	{
		cout<<"Err loading init process\n";while(1);
	}
        sti();
}

int next_proc_ind = 0;
int prev_proc_ind = -1;

void schedule()
{
	cli();
      int flag = 0;
      int i;
        int task_switch = 1;
	
        if(next_proc_ind == prev_proc_ind)
        task_switch = 0;
	curr_proc = &proc[next_proc_ind];
        prev_proc_ind = next_proc_ind;
      for(i=next_proc_ind+1;i<MAX_PROCESS;i++)
	{
	      if((proc[i].state == RUNNABLE))
		{
                        flag = 1;
			next_proc_ind = i;
			break;
		}
	}
	if(!flag)
	{
		for(i=0;i<next_proc_ind;i++)
		{
			if((proc[i].state == RUNNABLE))
			{
				next_proc_ind = i;
				break;
			}
		}
	}
      sti();
      if(task_switch)
      curr_proc->run();
}

void unhandled_intr()
{
        cout<<"hello"<<endl;
}