migrate.c

国内一位牛人自己开发的操作系统

#include"kernel.h"

#define WRONG_PROCESS		-1
#define NO_RETURN_STACK		-2
#define WRONG_THREAD		-3
#define WRONG_CAPABILITY	-4
#define WRONG_THREAD_STATE	-5
	
int thread_migrate_with_physical_block(
	int thread_id,
	int process_id,int process_v_flag,
	struct thread_physical_block *pb,
	struct capability *capability)
{
	struct thread *t;
	struct return_stack *rt;
	int return_value;

	return_value=thread_migrate(thread_id,
		process_id,TRUE,FALSE,process_v_flag);
	if(return_value<0)
		return return_value;

	t=&(os->thread[thread_id]);
	rt=&(t->return_stack[t->return_stack_top-1]);

	if(!KERNEL_COMPARE_CAPABILITY(
		(os->system_capability),(*capability)))
	{
		thread_return(thread_id,TRUE);
		return WRONG_CAPABILITY;
	}

	COPY_THREAD_PHYSICAL_BLOCK((*pb),(rt->physical_block));
	
	return return_value;
}

int thread_migrate(int thread_id,int destination_process_id,
	int stack_flag,int exception_flag,int process_v_flag)
{
	int process_id,old_process_id,sem_value,process_p_flag;
	struct thread *t;
	struct return_stack *rt,*old_rt;
	struct process *process,*old_process;
	
	if((thread_id<0)||(thread_id>=THREAD_NUMBER))
		return WRONG_THREAD;
	t=&(os->thread[thread_id]);
	if((t->state!=RUN)&&(t->state!=READY))
		return WRONG_THREAD_STATE;
	old_rt=&(t->return_stack[t->return_stack_top-1]);
	old_process_id=old_rt->current_process;
	old_process=&(os->process[old_process_id]);
	rt=old_rt;
	if(destination_process_id==0)
		process_id=old_rt->current_process;
	else
		process_id=destination_process_id;

	if((process_id<=0)||(process_id>=PROCESS_NUMBER))
		return  WRONG_PROCESS;
	process=&(os->process[process_id]);
	if(!stack_flag){
		old_process->enter_thread_number--;
	}else{
		if(t->return_stack_top>=RETURN_BLOCK_NUMBER)
			return NO_RETURN_STACK;
		t->return_stack_top++;
		rt=&(t->return_stack[t->return_stack_top-1]);
		COPY_THREAD_PHYSICAL_BLOCK((old_rt->physical_block),
			(rt->physical_block));
		rt->exception.flag=exception_flag;
		if(!exception_flag)
			COPY_THREAD_ENVIRONMENT((old_rt->environment),
				(rt->environment));
	}
	process->enter_thread_number++;
	if(destination_process_id==0){
		COPY_RUN_POINT((old_rt->environment.point),
			(rt->environment.point));
	}else
		COPY_RUN_POINT((process->start_point),
			(rt->environment.point));
	RESET_THREAD_PARAMETER(rt->environment);

	rt->current_process=process_id;
	rt->process_id=process->id;

	rt->environment.system_call=t->return_stack_top;
	if(exception_flag)
		rt->environment.system_call_arg1=0-(t->semaphore);
	else
		rt->environment.system_call_arg1=t->semaphore;
	
	COPY_CAPABILITY((process->capability),
		(os->semaphore[t->semaphore].capability));
	if(rt->current_process==old_rt->current_process){
		process_p_flag=old_rt->process_p_flag;
		old_rt->process_p_flag=TRUE;
		rt->process_p_flag=process_p_flag;
	}else{
		if(process_v_flag)
		if(!(old_rt->process_p_flag))
		if(old_process->semaphore>0){
			sem_value=1;
			if(system_call_v(
				old_process->semaphore,&sem_value,
				&(old_process->capability))>=0)
					old_rt->process_p_flag=TRUE;
		}
		rt->process_p_flag=TRUE;
	}
	return	(rt->environment.system_call);
}