fatdriver.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 <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 <jazmyn\i386.h>
#include <semaphore.h>
#include <drivers\console.h>
#include <drivers\keyboard.h>
#include <fs\devmgr.h>
#include <fs\fatbuffer.h>
#include <fs\fatvol.h>
#include <fs\fatdriver.h>

/*
 *This FAT driver has been coded in very few days.So, don`t expect it to be fast.Probably, in
 *the next version, (if i have the same kind of spirit) i will improve it.
 */

extern device_manager   _dev_mgr;
extern process          *curr_proc;

//#define __FATDRIVER_DEBUG

#define root	FATvolume::root
#define pwd     FATvolume::pwd
#define ppwd	FATvolume::ppwd

#define SAVE_ROOT(r) \
do {\
if(_fv != curr_fv) {\
        cout<<"save root";\
	FATvolume::save_root(r);\
	_fv->set_root();\
}\
}while(0)

#define RESTORE_ROOT(r) \
do {\
if(_fv != curr_fv) {\
	FATvolume::restore_root(r);\
}\
}while(0)
		
char            FATdriver::drives[24] = 
		{
			'C','D','E','F','G','H',
			'I','J','K','L','M','N',
			'O','P','Q','R','S','T',
			'U','V','W','X','Y','Z'
		};
char            FATdriver::fd[2] = {'A','B'};
FILE            FATdriver::FILE_tab[SYS_FILE_OPENMAX] = {{0,0,0,0,0}};
finode          FATdriver::FAT_inode[SYS_FILE_OPENMAX] = {{0,0}};


uint get_p_mem()
{
        disable_paging();

        ulong *ptr = (ulong*)0x100000;
        ulong temp;
        while(1)
        {
                temp = *ptr;
                *ptr = 0xAABBCCDD;
                if(*ptr != 0xAABBCCDD)
                        break;
                *ptr = temp;
                ptr = ptr + 4096;
        }
        enable_paging(0x100000);
        return (uint)ptr;
}



FATdriver::FATdriver():bsem(1)
{

}

FATdriver::~FATdriver()
{

}
void FATdriver::init_FATdriver(char boot_drive)
{
	tab dtab[10];
	int ndd;
	int d = 0;
        if((ndd = _dev_mgr.get_dsk_drivers(dtab)) < 0) return;
        if((num_drives = get_num_drives(dtab,ndd)) < 0) return;
       
	fv = new FATvolume[num_drives];
	int vi = 0;
	for(int i=0;i<ndd;i++)
	{
		switch(dtab[i].disk_type)
		{
		case FLOPPY_DISK:
                        for(int k=0;k<dtab[i].num_devices;k++)
			{
                                /*fv[vi].init_volume(0,2879,fd[k],SLOT(dtab[i].name),k);
                                if(boot_drive == fv[vi].get_drive()) curr_fv = &fv[vi];*/
                                vi++;
			}
			break;
		case HARD_DISK:
                        for(int k=0;k<dtab[i].num_devices;k++)
			{
				int num_part;
				if((num_part=get_num_partitions(SLOT(dtab[i].name),k))<0) return;
				for(int j=0;j<num_part;j++)
				{
					uint s,e;
					if(get_part_info(s,e,SLOT(dtab[i].name),k,j) < 0) return;
                                        fv[vi].init_volume(s,e,drives[d],SLOT(dtab[i].name),k);
                                        if(boot_drive == fv[vi].get_drive())
                                        {
                                                curr_fv = &fv[vi];
                                        }
					vi++;
                                        d++;
				}
			}
		}
	}
        cout<<"FAT 12/16/32 driver initialized                 [OK]\n";
        cout<<"Boot drive :"<<curr_fv->get_drive()<<endl;
        if(FATvolume::_fb.init_FATbuffer(FATvolume::totsz,get_p_mem()) < 0)
	{
		cout<<"Error initializing FAT buffer\n";
		while(1);
	}
        chroot(boot_drive);
}

int FATdriver::get_num_drives(tab *dtab,int ndd)
{
	int cnt = 0;
	for(int i=0;i<ndd;i++)
	{
		switch(dtab[i].disk_type)
		{
                case FLOPPY_DISK:
                        cnt += dtab[i].num_devices;break;
		case HARD_DISK:
                        for(int dev=0;dev<dtab[i].num_devices;dev++)
			{
				int p;
                                if((p = get_num_partitions(SLOT(dtab[i].name),dev)) < 0) return -1;
				cnt += p;
                        }
			break;
		}
	}
	return cnt;
}

int FATdriver::get_num_partitions(int slot,int dev)
{
	disk_req req;
	int cnt = 0;
        uint start,num_sec;
        uint ext_start = 0;
        uint endpart;
	byte buf[512];
	do
	{
                _CR(req,DISK_READ,dev,ext_start,1,buf);
                if(_dev_mgr.driver_tab[slot].main(&req) < 0)
                {
                        cout<<"failed\n";
                        return -1;
                }

                start = *(uint*)&buf[454] + ext_start;
                num_sec = *(uint*)&buf[458];
                ext_start = start + num_sec;
                endpart = *(uint*)&buf[470];
		cnt++;
        }while(endpart);
	return cnt;
}

int FATdriver::get_part_info(uint &s,uint &e,int slot,int dev,int part)
{
	disk_req req;
	int cnt = -1;
	uint start,num_sec;
	uint ext_start = 0;
	byte buf[512];
	do
	{
                _CR(req,DISK_READ,dev,ext_start,1,buf);
		if(_dev_mgr.driver_tab[slot].main(&req) < 0) return -1;


                start = *(uint*)&buf[454] + ext_start;
                num_sec = *(uint*)&buf[458];
                ext_start = start + num_sec;
		cnt ++;
	}while(cnt < part);
	s = start;
	e = start + num_sec - 1;
	return 0;
}

inline void* FATdriver::read_FAT(FATvolume &fv)
{
        return FATvolume::_fb.read_FAT(fv);
}

int FATdriver::chroot(char drive)
{
        bsem.down();
	int __ret = -1;
	FATvolume *_fv;
        if(_fv = get_FATvolume(drive))
	{
		if(!_fv->set_root())
		{
			curr_fv = _fv;
			__ret = 0;
		}
	}
        bsem.up();
	return __ret;
}

int FATdriver::chdir(char *path)
{
        bsem.down();
	int __ret = -1;
        if(curr_fv->mem_FAT = (byte*)read_FAT(*curr_fv))
	__ret = curr_fv->chdir(path);
        bsem.up();
	return __ret;
}

FATvolume* FATdriver::get_FATvolume(char drive)
{
	for(int i=0;i<num_drives;i++)
        if(fv[i].get_drive() == drive)
	{
                if(!fv[i].mounted) return NULL;
                if(!(fv[i].mem_FAT = (byte*)read_FAT(fv[i]))) return NULL;
		return &fv[i];
	}
	return NULL;
}

FATvolume* FATdriver::get_FATvolume(char* path)
{
	if(path[1] == ':')
	{
		for(int i=0;i<num_drives;i++)
                if(fv[i].get_drive() == path[0])
                {
			if(!fv[i].mounted) return NULL;
                        if(!(fv[i].mem_FAT = (byte*)read_FAT(fv[i]))) return NULL;
			return &fv[i];
		}
	}
	else
	{
                if(!(curr_fv->mem_FAT = (byte*)read_FAT(*curr_fv))) return NULL;
		return curr_fv;
	}
	return NULL;
}

int FATdriver::mkdir(char *path)
{
        bsem.down();
	int __ret = -1;

	FATvolume *_fv;
        if(_fv = get_FATvolume(path))
	{
		fdir cwd = pwd;
		fdir r;
		ppwd = pwd;
		char parent[1024],child[255];
                split_path(path,parent,child);
		SAVE_ROOT(r);
		if(!_fv->chdir(parent))
		if(!_fv->put_dir_entry(child,ATTR_DIRECTORY,0))
		{
			if(!_fv->chdir(child))
			if(!_fv->put_dir_entry(".",ATTR_DIRECTORY,0))
			if(!_fv->put_dir_entry("..",ATTR_DIRECTORY,0))
  			__ret = 0;
		}
		RESTORE_ROOT(r);
		pwd = cwd;
	}
        bsem.up();
	return __ret;
}

int FATdriver::rmdir(char *path)
{
        bsem.down();
	int __ret = -1;
	FATvolume *_fv;
	if(_fv = get_FATvolume(path))
	{
		fdir cwd = pwd;
		fdir r;
                char parent[1024],child[255];
		split_path(path,parent,child);
		SAVE_ROOT(r);	
		if(!_fv->chdir(parent))
                if(!_fv->del_dir_entry(child))
		__ret = 0;
		RESTORE_ROOT(r);
		pwd = cwd;
	}
        bsem.up();
	return __ret;
}		

DIR* FATdriver::opendir(char* path)
{
        bsem.down();

	void *__ret = NULL;
	FATvolume *_fv;
	if(_fv = get_FATvolume(path))
	{
		fdir cwd = pwd;
		fdir r;
                char parent[1024],child[255];
		split_path(path,parent,child);

                if(strcmp(child,"") == 0)
                {
                        strcpy(child,".");
                }

		SAVE_ROOT(r);