process.h

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

#ifndef OS_PROCESS_STRUCT
#define OS_PROCESS_STRUCT

struct thread_physical_block {
	int stack_memory_id,stack_block_id;
	int memory_id,block_id;
};

#define RESET_PHYSICAL_BLOCK(b,v)			\
{							\
	(b).stack_memory_id=(v);			\
	(b).stack_block_id=(v);				\
	(b).memory_id=(v);				\
	(b).block_id=(v);				\
}

#define COPY_THREAD_PHYSICAL_BLOCK(s,d)			\
{							\
	(d).stack_memory_id	=(s).stack_memory_id;	\
	(d).stack_block_id	=(s).stack_block_id;	\
	(d).memory_id		=(s).memory_id;		\
	(d).block_id		=(s).block_id;		\
}

#define COMPARE_THREAD_PHYSICAL_BLOCK(s,d)		\
(							\
	  ((d).stack_memory_id ==(s).stack_memory_id)	\
	&&((d).stack_block_id  ==(s).stack_block_id)	\
	&&((d).memory_id       ==(s).memory_id)		\
	&&((d).block_id        ==(s).block_id)		\
)

struct network_address{
	int a;
};

#define COPY_NETWORK_ADDRESS(s,d)	{(d).a=(s).a;}

struct file{
	struct{
		struct network_address network_node;
		int server_processor,server_process,file_handler;
	}file;
	struct{
		int processor,process;
	}proxy;
	int memory_process,open_window_id;
	int window_base_1,window_base_2,window_length,right;
	struct capability capability;
	int read_in_flag,swap_out_flag;
};

#define COPY_FILE(s,d)						\
{								\
	COPY_NETWORK_ADDRESS(((s).file.network_node),		\
		((d).file.network_node));			\
	(d).file.server_processor=(s).file.server_processor;	\
	(d).file.server_process	=(s).file.server_process;	\
	(d).file.file_handler	=(s).file.file_handler;		\
	(d).proxy.processor	=(s).proxy.processor;		\
	(d).proxy.process	=(s).proxy.process;		\
	(d).memory_process	=(s).memory_process;		\
	(d).open_window_id	=(s).open_window_id;		\
	(d).window_base_1	=(s).window_base_1;		\
	(d).window_base_2	=(s).window_base_2;		\
	(d).window_length	=(s).window_length;		\
	(d).right		=(s).right;			\
	COPY_CAPABILITY((s).capability,(d).capability);		\
	(d).read_in_flag	=(s).read_in_flag;		\
	(d).swap_out_flag	=(s).swap_out_flag;		\
}

union file_system_operation_parameter{
	struct {
		int begin_rw,end_rw;
	}read_write;
};

#define COPY_OPERATION_PARAMETER(s,d)				\
{								\
	char *ps=(char *)&(s),*pd=(char *)&(d);			\
	int i,length;						\
	length=sizeof(union file_system_operation_parameter);	\
	for(i=0;i<length;i++,ps++,pd++)				\
		*pd=(*ps);					\
};

struct file_system_call_parameter {
	int command,sleep_semaphore;
	struct file file;
	struct thread_physical_block block;
	union file_system_operation_parameter parameter;
};

#define OPEN_FILE		0
#define CLOSE_FILE		1
#define READ_FILE		2
#define WRITE_FILE		3
#define OPERATE_FILE		4
	
struct process{
	run_point start_point;
	int (*driver)(struct file_system_call_parameter *par);
	int priority;
	int semaphore;
	int enter_thread_number,id;
	int max_thread_number,thread_number,thread_ring;
	int max_semaphore_number,semaphore_number,semaphore_ring;
	struct user_file_information file[USER_FILE_NUMBER];
	struct capability capability;
};

#define COPY_PROCESS_ATTRIBUTE(s,d)				\
{								\
	COPY_RUN_POINT(((s).start_point),((d).start_point));	\
	(d).priority=(s).priority;				\
	(d).driver=(s).driver;					\
	(d).semaphore=(s).semaphore;				\
	(d).enter_thread_number=(s).enter_thread_number;	\
	(d).id=(s).id;						\
	(d).max_thread_number=(s).max_thread_number;		\
	(d).thread_number=(s).thread_number;			\
	(d).thread_ring=(s).thread_ring;			\
	(d).max_semaphore_number=(s).max_semaphore_number;	\
	(d).semaphore_number=(s).semaphore_number;		\
	(d).semaphore_ring=(s).semaphore_ring;			\
	COPY_CAPABILITY(((s).capability),((d).capability));	\
}

#endif