pvouy64kf
/
os2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

实现 pthread_create

Browse Source
master
p9ya4sf57 2 years ago
parent 121f6425be
commit 0cfb717e49
1 changed files with 262 additions and 0 deletions
Show Stats Download Patch File Download Diff File

262
fork.c
Unescape View File

@ -0,0 +1,262 @@
/*
* linux/kernel/fork.c
*
* (C) 1991 Linus Torvalds
*/
/*
* 'fork.c' contains the help-routines for the 'fork' system call
* (see also system_call.s), and some misc functions ('verify_area').
* Fork is rather simple, once you get the hang of it, but the memory
* management can be a bitch. See 'mm/mm.c': 'copy_page_tables()'
*/
#include <errno.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <asm/segment.h>
#include <asm/system.h>
#include <signal.h>
#include <sys/wait.h>
#include <linux/tty.h>
extern void write_verify(unsigned long address);
long last_pid=0;
void verify_area(void * addr,int size)
{
unsigned long start;
start = (unsigned long) addr;
size += start & 0xfff;
start &= 0xfffff000;
start += get_base(current->ldt[2]);
while (size>0) {
size -= 4096;
write_verify(start);
start += 4096;
}
}
int copy_mem(int nr,struct task_struct * p)
{
unsigned long old_data_base,new_data_base,data_limit;
unsigned long old_code_base,new_code_base,code_limit;
code_limit=get_limit(0x0f);
data_limit=get_limit(0x17);
old_code_base = get_base(current->ldt[1]);
old_data_base = get_base(current->ldt[2]);
if (old_data_base != old_code_base)
panic("We don't support separate I&D");
if (data_limit < code_limit)
panic("Bad data_limit");
new_data_base = new_code_base = nr * 0x4000000;
p->start_code = new_code_base;
set_base(p->ldt[1],new_code_base);
set_base(p->ldt[2],new_data_base);
if (copy_page_tables(old_data_base,new_data_base,data_limit)) {
free_page_tables(new_data_base,data_limit);
return -ENOMEM;
}
return 0;
}
/*
* Ok, this is the main fork-routine. It copies the system process
* information (task[nr]) and sets up the necessary registers. It
* also copies the data segment in it's entirety.
*/
int copy_process(int nr,long ebp,long edi,long esi,long gs,long none,
long ebx,long ecx,long edx,
long fs,long es,long ds,
long eip,long cs,long eflags,long esp,long ss)
{
struct task_struct *p;
int i;
struct file *f;
p = (struct task_struct *) get_free_page();
if (!p)
return -EAGAIN;
task[nr] = p;
__asm__ volatile ("cld"); /* by wyj */
*p = *current; /* NOTE! this doesn't copy the supervisor stack */
p->state = TASK_UNINTERRUPTIBLE;
p->pid = last_pid;
p->father = current->pid;
p->counter = p->priority;
p->signal = 0;
p->alarm = 0;
p->leader = 0; /* process leadership doesn't inherit */
p->utime = p->stime = 0;
p->cutime = p->cstime = 0;
p->start_time = jiffies;
p->tss.back_link = 0;
p->tss.esp0 = PAGE_SIZE + (long) p;
p->tss.ss0 = 0x10;
p->tss.eip = eip;
p->tss.eflags = eflags;
p->tss.eax = 0;
p->tss.ecx = ecx;
p->tss.edx = edx;
p->tss.ebx = ebx;
p->tss.esp = esp;
p->tss.ebp = ebp;
p->tss.esi = esi;
p->tss.edi = edi;
p->tss.es = es & 0xffff;
p->tss.cs = cs & 0xffff;
p->tss.ss = ss & 0xffff;
p->tss.ds = ds & 0xffff;
p->tss.fs = fs & 0xffff;
p->tss.gs = gs & 0xffff;
p->tss.ldt = _LDT(nr);
p->tss.trace_bitmap = 0x80000000;
if (last_task_used_math == current)
__asm__("clts ; fnsave %0"::"m" (p->tss.i387));
if (copy_mem(nr,p)) {
task[nr] = NULL;
free_page((long) p);
return -EAGAIN;
}
for (i=0; i<NR_OPEN;i++)
if (f=p->filp[i])
f->f_count++;
if (current->pwd)
current->pwd->i_count++;
if (current->root)
current->root->i_count++;
if (current->executable)
current->executable->i_count++;
set_tss_desc(gdt+(nr<<1)+FIRST_TSS_ENTRY,&(p->tss));
set_ldt_desc(gdt+(nr<<1)+FIRST_LDT_ENTRY,&(p->ldt));
short int tmp = NR_TASKS;
while (tmp--) /*<2A><><EFBFBD>̳<EFBFBD>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>Ҫ<EFBFBD><D2AA>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>Щ<EFBFBD><D0A9><EFBFBD><EFBFBD>*/
p->threads[tmp] = NULL;
p->index = 0;
p->process_or_thread = 0;
p->state = TASK_RUNNING; /* do this last, just in case */
return last_pid;
}
int find_empty_process(void)
{
int i;
repeat:
if ((++last_pid)<0) last_pid=1;
for(i=0 ; i<NR_TASKS ; i++)
if (task[i] && task[i]->pid == last_pid) goto repeat;
for(i=1 ; i<NR_TASKS ; i++)
if (!task[i])
return i;
return -EAGAIN;
}
//new
int create_thread(long eax, long ebp, long edi, long esi, long gs, long none,
long ebx, long ecx, long edx,
long fs, long es, long ds,
long eip, long cs, long eflags, long esp, long ss)
{
struct task_struct* p;
int i;
struct file* f;
int nr = find_empty_process();
p = (struct task_struct*)get_free_page();
if (!p)
return -EAGAIN;
task[nr] = p;
*p = *current; /* NOTE! this doesn't copy the supervisor stack */
p->state = TASK_UNINTERRUPTIBLE;
p->counter = p->priority;
p->signal = 0;
int index = 33;
while (index--)
p->sigaction[index] = current->sigaction[index];
p->blocked = current->blocked;
p->exit_code = p->exit_code;
p->start_code = current->start_code;
p->end_code = current->end_code;
p->end_data = current->end_data;
p->brk = current->brk;
current->brk += PAGE_SIZE;
p->start_stack = current->brk;
p->pid = nr;
p->father = current->pid;
p->pgrp = current->pgrp;
p->session = current->session;
p->leader = 0; /* process leadership doesn't inherit */
p->uid = current->uid;
p->euid = current->euid;
p->suid = current->suid;
p->gid = current->gid;
p->egid = current->egid;
p->sgid = current->sgid;
p->alarm = 0;
p->utime = p->stime = 0;
p->cutime = p->cstime = 0;
p->start_time = jiffies;
p->used_math = current->used_math;
p->tty = current->tty;
p->umask = current->umask;
p->close_on_exec = current->close_on_exec;
p->tss.back_link = 0;
p->tss.esp0 = PAGE_SIZE + (long)p;
p->tss.ss0 = 0x10;
p->tss.eip = ebx;
p->tss.eflags = eflags;
p->tss.eax = eax;
p->tss.ecx = ecx;
p->tss.edx = edx;
p->tss.ebx = ebx;
p->tss.esp = p->start_stack;
p->tss.ebp = ebp;
p->tss.esi = esi;
p->tss.edi = edi;
p->tss.es = es & 0xffff;
p->tss.cs = cs & 0xffff;
p->tss.ss = ss & 0xffff;
p->tss.ds = ds & 0xffff;
p->tss.fs = fs & 0xffff;
p->tss.gs = gs & 0xffff;
//p->tss.ldt = _LDT(nr);
p->tss.ldt = current->tss.ldt; // <20><><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD>׽<EFBFBD><D7BD>̵<EFBFBD>ldt<64><74>ַ
p->tss.trace_bitmap = 0x80000000;
if (last_task_used_math == current)
__asm__("clts ; fnsave %0"::"m" (p->tss.i387));
if (copy_mem(nr, p)) {
task[nr] = NULL;
free_page((long)p);
return -EAGAIN;
}
for (i = 0; i < NR_OPEN;i++)
if ((f = p->filp[i]))
f->f_count++;
if (current->pwd)
current->pwd->i_count++;
if (current->root)
current->root->i_count++;
if (current->executable)
current->executable->i_count++;
set_tss_desc(gdt + (nr << 1) + FIRST_TSS_ENTRY, &(p->tss));
set_ldt_desc(gdt + (nr << 1) + FIRST_LDT_ENTRY, &(p->ldt));
// <20><><EFBFBD>ݲ<EFBFBD><DDB2><EFBFBD>
//put_fs_long<6E><67><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>µ<EFBFBD><C2B5>̵߳Ķ<CCB5>ջ<EFBFBD><D5BB>ջ<EFBFBD><D5BB>
put_fs_long(ecx, p->tss.esp); // ecx<63><78><EFBFBD><EFBFBD>ŵ<EFBFBD><C5B5>ǽ<EFBFBD><C7BD><EFBFBD>Ҫ<EFBFBD><D2AA><EFBFBD>ݸ<EFBFBD><DDB8>̵߳IJ<CCB5><C4B2><EFBFBD>
p->tss.esp -= 4; // <20><>ջָ<D5BB><D6B8><EFBFBD>ٻ<EFBFBD><D9BB><EFBFBD>4<EFBFBD><34><EFBFBD>µ<EFBFBD><C2B5>߳<EFBFBD><DFB3><EFBFBD>תʱ<D7AA>򣬾Ϳ<F2A3ACBE><CDBF>Ի<EFBFBD><D4BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
current->threads[index] = p; // <20><>¼<EFBFBD><C2BC><EFBFBD>߳<EFBFBD>
current->index++; // <20><><EFBFBD><EFBFBD><EFBFBD>±<EFBFBD>++
p->process_or_thread = 1; // <20>´<EFBFBD><C2B4><EFBFBD><EFBFBD>߳<EFBFBD>
p->state = TASK_RUNNING; // <20><><EFBFBD>߳<EFBFBD>״̬<D7B4><CCAC><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȴ<EFBFBD><C8B4><EFBFBD><EFBFBD><EFBFBD>
return nr; /*<2A><><EFBFBD><EFBFBD><EFBFBD>̺߳<DFB3>*/
}
Write Preview
Loading…
Cancel
Save