init.c

虚地址空间基于文件OS内核源代码和文件

#include"memory.h"

#define WRONG_FLAG		-1
#define WRONG_MEMORY_BODY	-2
#define NO_FREE_BLOCK		-3
#define WRONG_CAPABILITY	-4

static int init_memory_body_routine(
	struct memory_body_struct *b,int flag,
	struct install_memory_body_parameter *par)
{
	char *pointer=par->base;
	int i;

	switch(flag){
	case 0:	/*return the size needed*/
		break;
	case 1: /*return the size needed and initialize 
		both local and remote information of the memory*/
	case 2: /* just initialize the local information */
		break;
	default:
		return WRONG_FLAG;
	}

	b->free_physical_block=(int *)pointer;
		pointer=pointer+sizeof(*(b->free_physical_block));
	b->free_file=(int *)pointer;
		pointer=pointer+sizeof(*(b->free_file));
	b->block_number=(int *)pointer;	
		pointer=pointer+sizeof(*(b->block_number));
	b->free_block_number=(int *)pointer;
		pointer=pointer+sizeof(*(b->free_block_number));
	b->file_number=(int *)pointer;	
		pointer=pointer+sizeof(*(b->file_number));
	b->process_number=(int *)pointer;
		pointer=pointer+sizeof(*(b->process_number));
	b->hash_number=(int *)pointer;
		pointer=pointer+sizeof(*(b->hash_number));
	if(flag==2){
		par->block_number=*(b->block_number);
		par->file_number=*(b->file_number);
		par->process_number=*(b->process_number);
		par->hash_number=*(b->hash_number);
	}
	b->physical_block=(struct physical_block *)pointer;
		pointer=pointer+sizeof(struct physical_block)
			*par->block_number;
	b->file_window=(struct file_window *)pointer;
		pointer=pointer+sizeof(struct file_window)
			*par->file_number;
	b->memory_process=(struct memory_process *)pointer;
		pointer=pointer+sizeof(struct memory_process)
			*par->process_number;
	b->hash=(struct memory_hash *)pointer;
		pointer=pointer+sizeof(struct memory_hash)
			*par->hash_number;
	b->wait_block=(struct memory_sleep_semaphore *)pointer;
		pointer=pointer+sizeof(struct memory_sleep_semaphore);

	b->hash_function=par->hash_function;
	b->my_processor=par->my_processor;
	b->my_memory_body=par->my_memory_body;

	if(flag==1){
		*(b->block_number)=par->block_number-1;
		*(b->free_block_number)=par->block_number-1;
		*(b->file_number)=par->file_number;
		*(b->process_number)=par->process_number;
		*(b->hash_number)=par->hash_number;

		b->wait_block->processor=(-1);
		b->wait_block->semaphore=(-1);

		for(i=0;i<par->block_number;i++){
			(b->physical_block+i)->state=FREE_BLOCK;
			(b->physical_block+i)->buf_back=i+1;
			(b->physical_block+i)->physical_number
				=i+par->first_block;
			(b->physical_block+i)
				->sleep_semaphore.processor=-1;
			(b->physical_block+i)
				->sleep_semaphore.semaphore=-1;
		};

		(b->physical_block+(par->block_number-1))
			->buf_back=(-1);
		*(b->free_physical_block)=0;
	
		for(i=0;i<par->file_number;i++){
			(b->file_window+i)->state=FILE_CLOSE;
			(b->file_window+i)->file_front=i-1;
			(b->file_window+i)->file_back =i+1;
		};
		(b->file_window+(par->file_number-1))->file_back=0;
		b->file_window->file_front=par->file_number-1;
		*(b->free_file)=0;

		for(i=0;i<par->hash_number;i++)
			(b->hash+i)->hash_ring=(-1);
		for(i=0;i<par->process_number;i++){
			struct memory_process *p;
			p=b->memory_process+i;
			RESET_CAPABILITY(p->capability);

			p->file_number=0;
			p->max_file_number=0;
			p->file_ring=-1;

			p->block_number=0;
			p->read_block_number=0;
			p->write_block_number=0;
			p->max_block_number=0;
			p->trigger_block_number=0;
			p->block_ring=-1;
			p->read_block_ring=-1;
			p->write_block_ring=-1;
		}
	}
	{
		int amount=pointer-(par->base)+PAGE_SIZE;
		amount=(amount/PAGE_SIZE)*PAGE_SIZE;
		return amount;
	}
}

int get_memory_body_size(
	struct install_memory_body_parameter *par)
{
	struct memory_body_struct b;
	if(!KERNEL_COMPARE_CAPABILITY((os->system_capability),
			(par->capability)))
		return WRONG_CAPABILITY;
	else
		return init_memory_body_routine(&b,0,par);
		
}

int init_memory_body(struct memory_body_struct *my_memory_body,
	struct install_memory_body_parameter *par)
{
	if(!KERNEL_COMPARE_CAPABILITY((os->system_capability),
			(par->capability)))
		return WRONG_CAPABILITY;
	else
		return init_memory_body_routine(my_memory_body,1,par);

}

int install_memory_body(struct memory_body_struct *my_memory_body,
	struct install_memory_body_parameter *par,int set_stack_flag)
{
	if(!KERNEL_COMPARE_CAPABILITY((os->system_capability),
			(par->capability)))
		return WRONG_CAPABILITY;
	else
		return init_memory_body_routine(my_memory_body,2,par);
}