#include <lib.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>

#define DEPTH 10

void forktree(const char *cur);

void forkchild(const char *cur, char branch)
{
	char nxt[DEPTH+1];
	int i;
	if (strlen(cur) >= DEPTH)
		return;

	snprintf(nxt, DEPTH+1, "%s%c", cur, branch);
	if ((i = fork()) == 0) {
		forktree(nxt);
		exit();
	} else if (i < 0)
		printf("forktree fork error! pid :%d err:%d\n",getpid(),i);
}

void forktree(const char *cur)
{
	printf("%08d: I am '%s'\n", getpid(), cur);

	forkchild(cur, '0');
	forkchild(cur, '1');
}

int main(int argc, char **argv)
{
	//open("/dev/tty",O_RDWR,0);
	forktree("");
	//printf("forktree over!%d\n",getpid());
	return 0;
}

static void bootmm_init()
{
   ...
   //分配内核页目录
   kpgd = alloc_bootmm_pages(1);
   memset(kpgd,0,PAGE_SIZE);
   
   //映射内核页目录 0xc0000000 ~ 0xf0000000 = 0x00000000 ~ 0x30000000
   boot_map_region(kpgd, KERNEL_BASE_ADDR, NORMAL_ADDR, 0, _PAGE_RW | _PAGE_PRESENT);
   
   //映射内核VAG映射区
   boot_map_region(kpgd, KERNEL_VIDEO, PT_SIZE, 0xb8000, _PAGE_RW | _PAGE_PRESENT);
   
   ....
   
   //映射内核栈区域
   for(i = 0;i < CPUNUMS; i++) {
   	boot_map_region(kpgd, KERNEL_STACK_TOP -KERNEL_STKSIZE - (KERNEL_STKSIZE + PAGE_SIZE) * i, 
   		KERNEL_STKSIZE, v2p(percpu_kstacks[i]),_PAGE_PRESENT|_PAGE_RW);
   }

   lcr3(pgd2p(kpgd));
   
   .....	
}

struct page* alloc_buddy(struct zone_struct *,uint8_t); 物理页分配函数 一次分配2的0~10次方个页，也就是4KB～4BM
void free_buddy(struct zone_struct *,struct page*,uint8_t);释放函数
void zone_init();初始化函数

void slab_init();初始化函数
void* kmalloc(size_t size);内存分配函数
void kfree(void* );释放函数

struct task_struct
{
	struct mm_struct* mm; //进程的内存描述符
	struct files_struct* files;//关于进程文件的结构体
	struct fs_struct* fs;
	struct frame frame; //进程切换时保存的上下文
	pgd_t* task_pgd;//进程的页表
	pid_t pid;	//进程ID		
	pid_t ppid;	//父进程ID
	
	.....
	
	int32_t timeslice;//进程所剩的时间片
	
	.....
	int pwait;
};

kernel/task.c

static int load_icode(struct task_struct *, uint8_t *);
static int region_alloc(struct task_struct *, viraddr_t, size_t ,int );
static int task_alloc(struct task_struct **, pid_t);
struct task_struct* task_pidmap[PID_MAX_DEFAULT];
static int alloc_files_struct(struct task_struct *);

struct mm_struct
{
	struct vm_area_struct* mmap;//进程的线性地址空间的链表
	struct rb_root mm_rb;
	pgd_t* mm_pgd;

	viraddr_t free_area_cache;

	viraddr_t start_code;//起始代码段
	viraddr_t end_code;

	viraddr_t start_data;//起始数据段段
	viraddr_t end_data;
	
	viraddr_t start_brk;//起始堆段
	viraddr_t end_brk;

	viraddr_t start_stack;//栈段

	int mmap_count;
	atomic_t mm_count;
	spinlock_t page_table_lock;
};

struct vm_area_struct
{
	struct mm_struct* vm_mm;
	struct vm_area_struct* vm_next;
	struct rb_node vm_rb;

	viraddr_t vm_start;//线性区起始地址
	viraddr_t vm_end;
	uint32_t vm_flags;
};

//配置任务状态段
void trap_init_percpu()
{
	extern struct seg_descriptor gdt[CPUNUMS + 5];
	extern int ncpu;
	uint32_t cid = get_cpuid();
	struct taskstate *pts = &(thiscpu->cpu_ts);
	pts->ts_ss0 = _KERNEL_DS_;
	pts->ts_esp0 = KERNEL_STACK_TOP - (KERNEL_STKSIZE + PAGE_SIZE) * cid;
	
	gdt[(_TSS0_ >> 3) + cid] = set_seg(STS_T32A, (uint32_t) (pts), sizeof(struct taskstate), 0);
	gdt[(_TSS0_ >> 3) + cid].s = 0;
	
	ltr(_TSS0_ + cid * sizeof(struct seg_descriptor));
	lidt(&idt_pd);
}

//配置中断描述符表
void trap_init()
{
	int i;
	extern uint32_t trap_handlers[];
	for(i = 0;i < 255; i++) {
		setgate(idt[i], 0, _KERNEL_CS_, trap_handlers[i], 0);
	}
	setgate(idt[T_SYSCALL], 0, _KERNEL_CS_, trap_handlers[T_SYSCALL], 3);
	trap_init_percpu();
}

kernel/trap/page_fault.c
void page_fault_handler(struct frame *tf)
{
	viraddr_t va;
	struct vm_area_struct *vma;
	pte_t *pte;

	va  = rcr2();

	vma = find_vma(curtask->mm, va);

	if (!vma || vma->vm_start > va)
		goto exit;
	
	pte = page_walk(curtask->task_pgd,va,true);
	
	if(!pte)
		goto exit;

	handle_pte_fault(curtask->mm, vma, va, pte, tf->tf_err);

	return;
exit:
	exit(curtask);
	schedule();
}

kernel/trap/syscall.c
//一下为实现的系统服务例程
static int sys_exit(pid_t);
static pid_t sys_clone(int ,int (*)(void*));
static pid_t sys_getpid();
static void sys_cputs(const char *,size_t );
static viraddr_t sys_brk(viraddr_t);
static int sys_read(uint32_t,int8_t*,int32_t);
static int sys_open(char * ,int ,int, int);
static int sys_create(char * ,int,int);
static int sys_mkdir(char *filename, int len,int mode);
static int sys_write(int, char *,int);
static int sys_dup(int);
static int sys_dup2(int,int);
static void sys_close(int);
static int sys_pipe(int fd[2],int flags);
static int sys_wait(pid_t pid);
static int sys_execve(char *filename,char ** argv);
static int sys_fdtype(int);

//文件kernel/syscall/fork.c

extern int alloc_pidmap();
extern void free_pidmap(pid_t);

extern int exit_task(struct task_struct *);
extern int exit_mm(struct mm_struct *);

static int copy_files(struct task_struct *task,int flags);
static int copy_task(struct task_struct *,struct task_struct *);
static int alloc_task(struct task_struct **,pid_t);
static int task_set_vm(int,struct task_struct *);

//fuckOS/lib/malloc.c
static struct malloc_chunk *find_malloc(uint32_t);
static struct malloc_chunk *extend_malloc(uint32_t);
static void split_malloc(struct malloc_chunk *,uint32_t);
static void merger_malloc(struct malloc_chunk *);

//kernel/trap/lapic.c
void ap_startup()；
void lapic_init()

//kernel/trap/irq_timer.c
void timer_handler(struct frame *tf)
{
	lapic_eoi();
	time_tick();
	schedule_tick();//减少进程的时间片
}

void trap(struct frame *tf)
{
        ...
	schedule();//调度
}