......................................
......................................
typedef struct _ZLOX_TASK ZLOX_TASK;

// This structure defines a 'task' - a process.
struct _ZLOX_TASK
{
	ZLOX_SINT32 id; // Process ID.
	ZLOX_UINT32 esp, ebp; // Stack and base pointers.
	ZLOX_UINT32 eip; // Instruction pointer.
	ZLOX_UINT32 init_esp; // stack top
	ZLOX_PAGE_DIRECTORY * page_directory; // Page directory.
	ZLOX_TASK * next; // The next task in a linked list.
};
......................................
......................................

# zlox_process.s some functions relate to process
.global _zlox_read_eip
_zlox_read_eip:
	pop %eax	# Get the return address
	jmp *%eax	# Return. Can't use RET because return address popped off the stack. 

.....................................
.....................................
ZLOX_VOID zlox_page_copy(ZLOX_UINT32 copy_address)
{
	ZLOX_UINT32 phys;
	ZLOX_PAGE_TABLE * newTable;
	copy_address /= 0x1000;
	ZLOX_UINT32 table_idx = copy_address / 1024;
	ZLOX_UINT32 page_idx = copy_address % 1024;
	if( (current_directory->tablesPhysical[table_idx] & 0x2) == 0)
	{
		newTable = zlox_clone_table(current_directory->tables[table_idx],&phys,0);
	}
	ZLOX_PAGE_TABLE * oldTable = current_directory->tables[table_idx];
	zlox_alloc_frame_do(&newTable->pages[page_idx], 0, 1);
	if (oldTable->pages[page_idx].present) newTable->pages[page_idx].present = 1;
	if (oldTable->pages[page_idx].user) newTable->pages[page_idx].user = 1;
	if (oldTable->pages[page_idx].accessed) newTable->pages[page_idx].accessed = 1;
	if (oldTable->pages[page_idx].dirty) newTable->pages[page_idx].dirty = 1;
	newTable->pages[page_idx].rw = 1;
	_zlox_copy_page_physical(oldTable->pages[page_idx].frame*0x1000, 
				newTable->pages[page_idx].frame*0x1000);
	current_directory->tables[table_idx] = newTable;
	current_directory->tablesPhysical[table_idx] = phys | 0x07;
}
.....................................
.....................................
static ZLOX_PAGE_TABLE * zlox_clone_table(ZLOX_PAGE_TABLE * src, ZLOX_UINT32 * physAddr, ZLOX_UINT32 needCopy)
{
	// Make a new page table, which is page aligned.
	ZLOX_PAGE_TABLE * table = (ZLOX_PAGE_TABLE *)zlox_kmalloc_ap(sizeof(ZLOX_PAGE_TABLE), physAddr);
	// Ensure that the new table is blank.
	zlox_memset((ZLOX_UINT8 *)table, 0, sizeof(ZLOX_PAGE_TABLE));

	// For every entry in the table...
	ZLOX_SINT32 i;
	for (i = 0; i < 1024; i++)
	{
		// If the source entry has a frame associated with it...
		if (src->pages[i].frame)
		{
			if(needCopy == 1)
			{
				// Get a new frame.
				zlox_alloc_frame(&table->pages[i], 0, 0);
				// Clone the flags from source to destination.
				if (src->pages[i].present) table->pages[i].present = 1;
				if (src->pages[i].rw) table->pages[i].rw = 1;
				if (src->pages[i].user) table->pages[i].user = 1;
				if (src->pages[i].accessed) table->pages[i].accessed = 1;
				if (src->pages[i].dirty) table->pages[i].dirty = 1;
				// Physically copy the data across. This function is in process.s.
				_zlox_copy_page_physical(src->pages[i].frame*0x1000, table->pages[i].frame*0x1000);
			}
			else
			{
				table->pages[i] = src->pages[i];
				table->pages[i].rw = 0; // 读写位清零,用于写时复制
			}
		}
	}
	return table;
}

ZLOX_PAGE_DIRECTORY * zlox_clone_directory(ZLOX_PAGE_DIRECTORY * src , ZLOX_UINT32 needCopy)
{
	ZLOX_UINT32 phys;
	// Make a new page directory and obtain its physical address.
	ZLOX_PAGE_DIRECTORY * dir = (ZLOX_PAGE_DIRECTORY *)zlox_kmalloc_ap(sizeof(ZLOX_PAGE_DIRECTORY), &phys);
	// Ensure that it is blank.
	zlox_memset((ZLOX_UINT8 *)dir, 0, sizeof(ZLOX_PAGE_DIRECTORY));

	// Get the offset of tablesPhysical from the start of the page_directory_t structure.
	ZLOX_UINT32 offset = (ZLOX_UINT32)dir->tablesPhysical - (ZLOX_UINT32)dir;

	// Then the physical address of dir->tablesPhysical is:
	dir->physicalAddr = phys + offset;

	// Go through each page table. If the page table is in the kernel directory, do not make a new copy.
	ZLOX_SINT32 i;
	for (i = 0; i < 1024; i++)
	{
		if (!src->tables[i])
			continue;

		if (kernel_directory->tables[i] == src->tables[i])
		{
			// It's in the kernel, so just use the same pointer.
			dir->tables[i] = src->tables[i];
			dir->tablesPhysical[i] = src->tablesPhysical[i];
		}
		else
		{
			// Copy the table.
			ZLOX_UINT32 phys;
			if(needCopy == 1)
			{
				dir->tables[i] = zlox_clone_table(src->tables[i], &phys , 1);
				dir->tablesPhysical[i] = phys | 0x07;
			}
			else
			{
				dir->tables[i] = src->tables[i];
				// 读写位清零,用于写时复制
				dir->tablesPhysical[i] = src->tablesPhysical[i] & (~0x2);
			}
		}
	}
	return dir;
}

ZLOX_VOID zlox_initialise_tasking()
{
	// Rather important stuff happening, no interrupts please!
	asm volatile("cli");

	// Relocate the stack so we know where it is.
	zlox_move_stack((ZLOX_VOID *)0xE0000000, 0x2000);

	// Initialise the first task (kernel task)
	current_task = ready_queue = (ZLOX_TASK *)zlox_kmalloc(sizeof(ZLOX_TASK));
	current_task->id = next_pid++;
	current_task->esp = current_task->ebp = 0;
	current_task->eip = 0;
	current_task->init_esp = 0xE0000000;
	current_task->page_directory = current_directory;
	current_task->next = 0;

	// Reenable interrupts.
	asm volatile("sti");
}

static ZLOX_VOID zlox_timer_callback(/*ZLOX_ISR_REGISTERS regs*/)
{
	tick++;
	//zlox_monitor_write("zenglOX Tick: ");
	//zlox_monitor_write_dec(tick);
	//zlox_monitor_write("\n");

	zlox_switch_task();
	
}

ZLOX_VOID zlox_switch_task()
{
	// If we haven't initialised tasking yet, just return.
	if (!current_task)
		return;

	// Read esp, ebp now for saving later on.
	ZLOX_UINT32 esp, ebp, eip;
	asm volatile("mov %%esp, %0" : "=r"(esp));
	asm volatile("mov %%ebp, %0" : "=r"(ebp));

	// Read the instruction pointer. We do some cunning logic here:
	// One of two things could have happened when this function exits - 
	//   (a) We called the function and it returned the EIP as requested.
	//   (b) We have just switched tasks, and because the saved EIP is essentially
	//	   the instruction after read_eip(), it will seem as if read_eip has just
	//	   returned.
	// In the second case we need to return immediately. To detect it we put a dummy
	// value in EAX further down at the end of this function. As C returns values in EAX,
	// it will look like the return value is this dummy value! (0x12345).
	eip = _zlox_read_eip();

	// Have we just switched tasks?
	if (eip == 0x12345)
		return;

	// No, we didn't switch tasks. Let's save some register values and switch.
	current_task->eip = eip;
	current_task->esp = esp;
	current_task->ebp = ebp;
	
	// Get the next task to run.
	current_task = current_task->next;
	// If we fell off the end of the linked list start again at the beginning.
	if (!current_task) 
		current_task = ready_queue;

	eip = current_task->eip;
	esp = current_task->esp;
	ebp = current_task->ebp;

	// Make sure the memory manager knows we've changed page directory.
	current_directory = current_task->page_directory;
	// Here we:
	// * Stop interrupts so we don't get interrupted.
	// * Temporarily puts the new EIP location in ECX.
	// * Loads the stack and base pointers from the new task struct.
	// * Changes page directory to the physical address (physicalAddr) of the new directory.
	// * Puts a dummy value (0x12345) in EAX so that above we can recognise that we've just
	//   switched task.
	// * Restarts interrupts. The STI instruction has a delay - it doesn't take effect until after
	//   the next instruction.
	// * Jumps to the location in ECX (remember we put the new EIP in there).
	/*asm volatile(
	  //"pushf\n\t"
	  //"cli\n\t"
	  "movl %0, %%ecx\n\t"
	  "movl %1, %%esp\n\t"
	  "movl %2, %%ebp\n\t"
	  "movl %3, %%cr3\n\t"
	  "movl $0x12345, %%eax\n\t"
	  //"popf\n\t"
	  "jmp *%%ecx"
	: : "m"(eip), "m"(esp), "m"(ebp), "m"(current_directory->physicalAddr));*/

	_zlox_switch_task_do(eip,esp,ebp,current_directory->physicalAddr);
}

.global _zlox_switch_task_do
_zlox_switch_task_do:
	cli
	movl 4(%esp),%ecx	# eip
	movl 8(%esp),%edx	# esp tmp
	movl 12(%esp),%ebp	# ebp
	movl 16(%esp),%eax	# cr3 tmp
	movl %eax,%cr3		# cr3
	movl $0x12345, %eax	# eax
	movl %edx,%esp		# esp
	jmp *%ecx

// Copy len bytes from src to dest.
ZLOX_VOID zlox_memcpy(ZLOX_UINT8 *dest, const ZLOX_UINT8 *src, ZLOX_UINT32 len)
{
	const ZLOX_UINT8 *sp = (const ZLOX_UINT8 *)src;
	ZLOX_UINT8 *dp = (ZLOX_UINT8 *)dest;
	if(len == 0)
		return;
	//for(; len != 0; len--) 
	//	*dp++ = *sp++;
	
	// 使用movsl和movsb来提高内存拷贝的效率
	asm volatile (
	"pushf\n\t"
	"movl %%edx,%%ecx\n\t"
	"shrl $2, %%ecx\n\t"	// 长度除以4,得到的商使用movsl进行拷贝,因为每次movsl可以拷贝4个字节
	"cld\n\t"
	"rep movsl\n\t"
	"movl %%edx, %%ecx\n\t"
	"andl $3, %%ecx\n\t"	// and运算得到除以4的余数,余数使用movsb每次拷贝一个字节
	"rep movsb\n\t"
	"popf"			// 恢复eflags里的标志,主要是将上面cld清零的DF标志恢复为原始值
	::"S"(sp),"D"(dp),"d"(len):"%ecx");
}

//zenglOX kernel main entry
ZLOX_SINT32 zlox_kernel_main(ZLOX_MULTIBOOT * mboot_ptr, ZLOX_UINT32 initial_stack)
{
...................................
...................................
	//初始化任务系统
	zlox_initialise_tasking();

	// Write out a sample string
	zlox_monitor_write("hello world!\nwelcome to zenglOX v0.0.8!\n");

	// Initialise the initial ramdisk, and set it as the filesystem root.
	fs_root = zlox_initialise_initrd(initrd_location);

	ZLOX_SINT32 ret = zlox_fork();

	zlox_monitor_write("fork() returned ");
	zlox_monitor_write_hex(ret);
	zlox_monitor_write(", and getpid() returned ");
	zlox_monitor_write_hex(zlox_getpid());
	zlox_monitor_write("\n============================================================================\n");

	// The next section of code is not reentrant so make sure we aren't interrupted during.
	asm volatile("cli");
...................................
...................................
}