process.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 <jazmyn\i386.h>
#include <jazmyn\desc.h>
#include <jazmyn\gdt.h>
#include <mm\heap.h>
#include <mm\memory.h>
#include <fs\file_sys.h>
#include <jazmyn\process.h>
#include <drivers\console.h>
#include <drivers\keyboard.h>

extern process proc[100];
extern GDT _gdt;
TSS dummy_tss;
ushort dummy_sel = 0;

process::process():_m(),_f()
{
	nr_child = 0;
	free = TRUE;
        state = BLOCKED;
}

process::~process()
{

}


void process::init_process(void *buf,uint cs,uint ds,uint bss,uint ss,uint ep)
{
        dummy_sel =  _gdt.set_tss((uint)&dummy_tss,sizeof(dummy_tss));
	free = FALSE;
	pid = 0;
	ppid = -1;
	state = RUNNABLE;
	counter = TIME_QUANTUM;
        _m.init_memory(buf,cs,ds,bss,ss,ep);
	_f.init_fs();

}

int process::run()
{
       /* _m.set_table_entries();*/

	uint sel[2];
	sel[0] = 0;
	sel[1] = _m._tss_sel;

        byte val = inportb(0x21);
        val = val & ~(1<<0);
        outportb(0x21,val);
        __asm__ __volatile__("ljmp %0"::"m" (*sel));
}


void process::block()
{
        state = BLOCKED;
}

void process::unblock()
{
	state = RUNNABLE;
}


int process::copy_process(process *parent,int pid,uint eax,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)
{
        parent->nr_child++;
	free = FALSE;
        this->pid = pid;
	ppid = parent->pid;
	state = RUNNABLE;
	counter = TIME_QUANTUM;
        _m.set_tss(eax,ebx,ecx,edx,esi,edi,ebp,gs,fs,es,ds,eip,cs,eflags,esp,ss);
	_m = parent->_m;
        _f = parent->_f;
        return 0;
}


int process::try_to_replace(int fd,char **argv,char **env,uint cs,uint ds,uint bss,uint ss,
				uint ep)
{
	int __ret =  -1;
        int argc = 0;
        if(argv)
        {
                char **tmp = argv;
                while(*tmp)
                {
                        argc++;
                        tmp++;
                }
        }
        if(!_m.try_to_replace(fd,argc,argv,env,cs,ds,bss,ss,ep))
	{
		_f.reset_file_sys();
		__ret = 0;
	}
	return __ret;
}


process* process::clear(int exit_code)
{

	exit_status = exit_code;
	process *parent_proc = &proc[ppid];

	_m.clear();
	_f.clear();
        if(parent_proc->state == WAITING)
                parent_proc->state = RUNNABLE;
        else if(parent_proc->state == ZOMBIE || parent_proc->state == CLEAR)
		ppid = 0;
	state = ZOMBIE;
	
	process *ret = parent_proc;
        while(parent_proc != &proc[0])
	{
		if(parent_proc->state == CLEAR)
		{
			ret = &proc[1];
			break;
		}
		else if(parent_proc->state == RUNNABLE || parent_proc->state == BLOCKED)
		{
			ret = parent_proc;
			break;
		}
		else
		{
                        parent_proc = &proc[parent_proc->ppid];
                        ret = parent_proc;
		}
	}
	return ret;		
}


void* process::malloc(size_t size)
{
	return _m._heap.malloc(size);
}

void process::freee(void *addrs)
{
	_m._heap.free(addrs);
}

void process::newrun()
{
        _gdt.change_to_avail(_m._tss_sel);
        LTR(dummy_sel);

	uint sel[2];
	sel[0] = 0;
	sel[1] = _m._tss_sel;


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

        __asm__ __volatile__("ljmp %0"::"m" (*sel));
}