sys_calls.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 <errno.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 <semaphore.h>
#include <fs\fatdriver.h>

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

extern process proc[MAX_PROCESS];
extern process *curr_proc;
extern process *fg_proc;
extern FATdriver _FAT_driver;


uint va2pa(void* arg)
{
        /*return (arg) ? (__VIRTUAL_BASE + (uint)arg) : 0;*/
        return (arg) ? (curr_proc->_m.get_pb() + (uint)arg) : 0;
}

uint va2pa2(void* arg)
{
        return (arg) ? (curr_proc->_m.get_pb() + (uint)arg) : 0;
}

int sys_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)
{
        cli();
        int free_slot;
	if((free_slot = get_free_slot()) < 0) return -1;
        process *child = &proc[free_slot];
        if(!child->copy_process(curr_proc,free_slot,0,ebx,ecx,edx,esi,edi,ebp,gs,fs,es,
                ds,eip,cs,eflags,esp,ss))
	{
		if(curr_proc == fg_proc) fg_proc = child;
                sti();
		return free_slot;
	}
        sti();
        return -1;
}

int sys_exec(char *path,char **argv,char **env)
{
        byte val = inportb(0x21);
        val = val | 1;
        outportb(0x21,val);

        int __ret = -1;
        path = (char*)va2pa(path);
        argv = (char**)va2pa(argv);
        env = (char**)va2pa(env);
        int i = 0;
        char **tmp;
        if(argv)
        {
                tmp = argv;
                while(*tmp)
                {
                        argv[i] = (char*)va2pa(argv[i]);
                        tmp++;
                        i++;
                }
        }

        extern char *environ[];
        char exec_path[255];
        strcpy(exec_path,(char*)&environ[0][5]);
        strcat(exec_path,path);

        int fd = _FAT_driver.open(exec_path,O_RDWR,0);
        if(fd >= 0)
	{
		exe exe_hdr;
                if(_FAT_driver.read(fd,&exe_hdr,sizeof(exe_hdr)))
		{

                        if(!curr_proc->try_to_replace(fd,argv,env,exe_hdr.cs,exe_hdr.ds,
                                                exe_hdr.bss,PAGE_SIZE*2,exe_hdr.entry_point))
                        {

                                 __ret = 0;
                                curr_proc->newrun();
                        }
		}
        }


        val = inportb(0x21);
        val = val & ~(1<<0);
        outportb(0x21,val);

        return __ret;
}

void sys_exit(int exit_code)
{
        process *parent = curr_proc->clear(exit_code);
        if(curr_proc == fg_proc) fg_proc = parent;
        schedule();
        while(1); //if no runnable process wait
}

int sys_wait(int child,int *status,int options)
{
        status = (int*)va2pa(status);
        cli();
        curr_proc->state =  WAITING;
        sti();
	while(1)
	{
                int child_cnt = 0;
                int children = curr_proc->get_nr_children();
                for(int i=0;i<MAX_PROCESS && child_cnt<children;i++)
		{
                        if(proc[i].get_ppid() == curr_proc->get_pid())
			{
				child_cnt++;
				if(proc[i].state == ZOMBIE)
				{
					*status = proc[i].get_exit_status();
					proc[i].state = CLEAR;
                                        proc[i].set_free();
                                        curr_proc->dec_child();
					return 0;
				}
			}
		}
        }
}

void *sys_malloc(size_t size)
{
        void *ret = curr_proc->malloc(size);
        return (void*)((uint)ret - curr_proc->_m.get_pb());
}

void sys_free(void *addrs)
{
       addrs = (void*)va2pa(addrs);
       curr_proc->freee(addrs);
}

int delay_serviced = 0;

void sys_delay(uint millisecs)
{
	extern timer _timer_obj;
        _timer_obj.call_after(millisecs,delayfun);
	while(!delay_serviced);
	delay_serviced = 0;
}

int sys_open(const char* path,int access,mode_t perm)
{
	return -ENOSYS;
}

off_t	sys_lseek(int fd,off_t pos,int whence)
{
	return -ENOSYS;
}

ssize_t sys_read(int fd,void *buf,size_t size)
{
	if(fd == 0)
	{
		buf = (char*)va2pa2(buf);
                keyboard_req kreq = {'\n',buf};
		int  __ret = keyboard_main(&kreq);
		return __ret;
	}
	else
		return -ENOSYS;
}

ssize_t sys_write(int fd,const void *buf,size_t size)
{
	if(fd == 1)
	{
                buf = (char*)va2pa((void*)buf);
                cout<<(char*)buf;
                return strlen((char*)buf);
	}
	else
		return -ENOSYS;
}

int sys_close(int fd)
{
	return -ENOSYS;
}

int sys_unlink(const char *link)
{
	return -ENOSYS;
}

int sys_fstat(int fd,stat *statv)
{
	return -ENOSYS;
}

DIR* sys_opendir(const char *path)
{
        path = (const char*)va2pa((void*)path);
        return _FAT_driver.opendir((char*)path);
}

dirent *ret = NULL;

dirent* sys_readdir(DIR *dir_fd)
{
        if(ret) delete ret;
        ret = (dirent*)curr_proc->malloc(sizeof(dirent));
        if(!ret)
        {
                cout<<"malloc failed\n";
                getch();
        }
        dirent *t;
        if(t = _FAT_driver.readdir(dir_fd))
        {
                *ret = *t;
        }
        else
        {
                ret = NULL;
                return NULL;
        }
        return (dirent*)((uint)ret - curr_proc->_m.get_pb());
}

void sys_rewinddir(DIR *dir_fd)
{
        _FAT_driver.rewinddir(dir_fd);
}

int sys_closedir(DIR *dir_fd)
{
        return _FAT_driver.closedir(dir_fd);
}

int sys_mkdir(const char *path,mode_t mode)
{
	return -ENOSYS;
}

int sys_rmdir(const char *path)
{
	return -ENOSYS;
}

int sys_chdir(const char *path)
{
        path = (const char*)va2pa((void*)path);
        cout<<"on sys chder:"<<(char*)path<<endl;
        getch();
        return _FAT_driver.chdir((char*)path);
}

int sys_chroot(char *root_drive)
{
	return -ENOSYS;
}

void sys_utils(int utilnr)
{
        switch(utilnr)
        {
                case 0:displaydate();break;
                case 1:displaytime();break;
                case 2:displayps();break;
                case 3:cout.clrscr();break;
                case 4:
                        disable_paging();
                        outportb(0x64,0xFE);
                        break;
                case 5:list_dir();break;
                default:cout<<"Unrecognized\n";
        }
}

void list_dir()
{
        cout<<endl;
        DIR *dir = _FAT_driver.opendir("\\");
        if(!dir)
        {
                cout<<"Dir listing failed\n";
        }
        dirent *d;
        cout<<"*****DIR LISTING*****\n\n";
        while((d = _FAT_driver.readdir(dir)))
        {
                cout<<d->d_name<<endl;
        }
        _FAT_driver.closedir(dir);
        cout<<endl;;
}


void displayps()
{
        cout<<endl;
        cout<<"PID        PPID       CHILD\n";
        for(int i=0;i<MAX_PROCESS;i++)
        {
                if(proc[i].state & RUNNABLE)
                {
                        cout<<proc[i].get_pid()<<"           "
                            <<proc[i].get_ppid()<<"            "
                            <<proc[i].get_nr_children()<<endl;
                }
        }
        cout<<endl;
}
                        
void displaydate()
{
        cout<<endl;
        cout<<"Date:  ";
        char *days[] = {"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"};
        uint out;

        outportb(0x70,0x6);
        out = inportb(0x71);
        cout<<days[out-1]<<"  ";

        outportb(0x70,0x7);
        out = inportb(0x71);
        cout.dispnum(out,16);
        cout<<'-';

        outportb(0x70,0x8);
        out = inportb(0x71);
        cout.dispnum(out,16);
        cout<<'-';

        outportb(0x70,0x9);
        out = inportb(0x71);
        cout<<"200";
        cout.dispnum(out,16);
        cout<<endl;
        cout<<endl;
}

void displaytime()
{
        cout<<endl;
        cout<<"Time:  ";
        uint out;

        outportb(0x70,0x4);
        out = inportb(0x71);
        cout.dispnum(out,16);
        cout<<':';

        outportb(0x70,0x2);
        out = inportb(0x71);
        cout.dispnum(out,16);
        cout<<':';

        outportb(0x70,0x0);
        out = inportb(0x71);
        cout.dispnum(out,16);
        cout<<endl;
        cout<<endl;
}


void delayfun()
{
	delay_serviced = 1;
}

int get_free_slot()
{
        for(int i=0;i<MAX_PROCESS;i++)
        if(proc[i].is_free()) 
	return i;
        return -1;
}