ULK 进程

 1/**
 2 * list_for_each	-	iterate over a list
 3 * @pos:	the &struct list_head to use as a loop counter.
 4 * @head:	the head for your list.
 5 */
 6#define list_for_each(pos, head) \
 7    for (pos = (head)->next; prefetch(pos->next), pos != (head); \
 8            pos = pos->next)
 9
10/**
11 * __list_for_each	-	iterate over a list
12 * @pos:	the &struct list_head to use as a loop counter.
13 * @head:	the head for your list.
14 *
15 * This variant differs from list_for_each() in that it's the
16 * simplest possible list iteration code, no prefetching is done.
17 * Use this for code that knows the list to be very short (empty
18 * or 1 entry) most of the time.
19 */
20#define __list_for_each(pos, head) \
21    for (pos = (head)->next; pos != (head); pos = pos->next)

 1/**
 2 * list_for_each_safe	-	iterate over a list safe against removal of list entry
 3 * @pos:	the &struct list_head to use as a loop counter.
 4 * @n:		another &struct list_head to use as temporary storage
 5 * @head:	the head for your list.
 6 */
 7#define list_for_each_safe(pos, n, head) \
 8    for (pos = (head)->next, n = pos->next; pos != (head); \
 9        pos = n, n = pos->next)
10
11
12/**
13 * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
14 * @pos:	the type * to use as a loop counter.
15 * @n:		another type * to use as temporary storage
16 * @head:	the head for your list.
17 * @member:	the name of the list_struct within the struct.
18 */
19#define list_for_each_entry_safe(pos, n, head, member)			\
20    for (pos = list_entry((head)->next, typeof(*pos), member),	\
21        n = list_entry(pos->member.next, typeof(*pos), member);	\
22         &pos->member != (head); 					\
23         pos = n, n = list_entry(n->member.next, typeof(*n), member))

 1#define hlist_for_each_safe(pos, n, head) \
 2    for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \
 3         pos = n)
 4
 5/**
 6 * hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry
 7 * @tpos:	the type * to use as a loop counter.
 8 * @pos:	the &struct hlist_node to use as a loop counter.
 9 * @n:		another &struct hlist_node to use as temporary storage
10 * @head:	the head for your list.
11 * @member:	the name of the hlist_node within the struct.
12 */
13#define hlist_for_each_entry_safe(tpos, pos, n, head, member) 		 \
14    for (pos = (head)->first;					 \
15         pos && ({ n = pos->next; 1; }) && 				 \
16        ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
17         pos = n)

 1struct thread_info {
 2    struct task_struct	*task;		/* main task structure */
 3    struct exec_domain	*exec_domain;	/* execution domain */
 4    unsigned long		flags;		/* low level flags */
 5    unsigned long		status;		/* thread-synchronous flags */
 6    __u32			cpu;		/* current CPU */
 7    __s32			preempt_count; /* 0 => preemptable, <0 => BUG */
 8
 9
10    mm_segment_t		addr_limit;	/* thread address space:
11                            0-0xBFFFFFFF for user-thead
12                           0-0xFFFFFFFF for kernel-thread
13                        */
14    struct restart_block    restart_block;
15
16    unsigned long           previous_esp;   /* ESP of the previous stack in case
17                           of nested (IRQ) stacks
18                        */
19    __u8			supervisor_stack[0];
20};

 1/*
 2 * The pid hash table is scaled according to the amount of memory in the
 3 * machine.  From a minimum of 16 slots up to 4096 slots at one gigabyte or
 4 * more.
 5 */
 6void __init pidhash_init(void)
 7{
 8    int i, j, pidhash_size;
 9    unsigned long megabytes = nr_kernel_pages >> (20 - PAGE_SHIFT);
10
11    pidhash_shift = max(4, fls(megabytes * 4));
12    pidhash_shift = min(12, pidhash_shift);
13    pidhash_size = 1 << pidhash_shift;
14
15    printk("PID hash table entries: %d (order: %d, %Zd bytes)\n",
16        pidhash_size, pidhash_shift,
17        PIDTYPE_MAX * pidhash_size * sizeof(struct hlist_head));
18
19    for (i = 0; i < PIDTYPE_MAX; i++) {
20        pid_hash[i] = alloc_bootmem(pidhash_size *
21                    sizeof(*(pid_hash[i])));
22        if (!pid_hash[i])
23            panic("Could not alloc pidhash!\n");
24        for (j = 0; j < pidhash_size; j++)
25            INIT_HLIST_HEAD(&pid_hash[i][j]);
26    }
27}

 1/*
 2 * fls: find last bit set.
 3 */
 4
 5static __inline__ int generic_fls(int x)
 6{
 7    int r = 32;
 8
 9    if (!x)
10        return 0;
11    if (!(x & 0xffff0000u)) {
12        x <<= 16;
13        r -= 16;
14    }
15    if (!(x & 0xff000000u)) {
16        x <<= 8;
17        r -= 8;
18    }
19    if (!(x & 0xf0000000u)) {
20        x <<= 4;
21        r -= 4;
22    }
23    if (!(x & 0xc0000000u)) {
24        x <<= 2;
25        r -= 2;
26    }
27    if (!(x & 0x80000000u)) {
28        x <<= 1;
29        r -= 1;
30    }
31    return r;
32}

 1#if BITS_PER_LONG == 32
 2/* 2^31 + 2^29 - 2^25 + 2^22 - 2^19 - 2^16 + 1 */
 3#define GOLDEN_RATIO_PRIME 0x9e370001UL
 4#elif BITS_PER_LONG == 64
 5/*  2^63 + 2^61 - 2^57 + 2^54 - 2^51 - 2^18 + 1 */
 6#define GOLDEN_RATIO_PRIME 0x9e37fffffffc0001UL
 7#else
 8
 9static inline unsigned long hash_long(unsigned long val, unsigned int bits)
10{
11    unsigned long hash = val;
12
13#if BITS_PER_LONG == 64
14    /*  Sigh, gcc can't optimise this alone like it does for 32 bits. */
15    unsigned long n = hash;
16    n <<= 18;
17    hash -= n;
18    n <<= 33;
19    hash -= n;
20    n <<= 3;
21    hash += n;
22    n <<= 3;
23    hash -= n;
24    n <<= 4;
25    hash += n;
26    n <<= 2;
27    hash += n;
28#else
29    /* On some cpus multiply is faster, on others gcc will do shifts */
30    hash *= GOLDEN_RATIO_PRIME;
31#endif
32
33    /* High bits are more random, so use them. */
34    return hash >> (BITS_PER_LONG - bits);
35}

 1int fastcall attach_pid(task_t *task, enum pid_type type, int nr)
 2{
 3    struct pid *pid, *task_pid;
 4
 5    task_pid = &task->pids[type];
 6    pid = find_pid(type, nr);
 7    if (pid == NULL) {
 8        hlist_add_head(&task_pid->pid_chain,
 9                &pid_hash[type][pid_hashfn(nr)]);
10        INIT_LIST_HEAD(&task_pid->pid_list);
11    } else {
12        INIT_HLIST_NODE(&task_pid->pid_chain);
13        list_add_tail(&task_pid->pid_list, &pid->pid_list);
14    }
15    task_pid->nr = nr;
16
17    return 0;
18}

 1static fastcall int __detach_pid(task_t *task, enum pid_type type)
 2{
 3    struct pid *pid, *pid_next;
 4    int nr = 0;
 5
 6    pid = &task->pids[type];
 7    if (!hlist_unhashed(&pid->pid_chain)) {
 8        hlist_del(&pid->pid_chain);
 9
10        if (list_empty(&pid->pid_list))
11            nr = pid->nr;
12        else {
13            pid_next = list_entry(pid->pid_list.next,
14                        struct pid, pid_list);
15            /* insert next pid from pid_list to hash */
16            hlist_add_head(&pid_next->pid_chain,
17                &pid_hash[tynext_threadpe][pid_hashfn(pid_next->nr)]);
18        }
19    }
20
21    list_del(&pid->pid_list);
22    pid->nr = 0;
23
24    return nr;
25}
26
27void fastcall detach_pid(task_t *task, enum pid_type type)
28{
29    int tmp, nr;
30
31    nr = __detach_pid(task, type);
32    if (!nr)
33        return;
34
35    for (tmp = PIDTYPE_MAX; --tmp >= 0; )
36        if (tmp != type && find_pid(tmp, nr))
37            return;
38
39    free_pidmap(nr);
40}

 1// 等待队列元素
 2typedef struct __wait_queue wait_queue_t;
 3struct __wait_queue {
 4    unsigned int flags;
 5#define WQ_FLAG_EXCLUSIVE	0x01
 6    struct task_struct * task;
 7    wait_queue_func_t func;
 8    struct list_head task_list;
 9};
10
11// 等待队列头元素
12struct __wait_queue_head {
13    spinlock_t lock;
14    struct list_head task_list;
15};
16typedef struct __wait_queue_head wait_queue_head_t;

 1// 等待队列元素的声明&初始化
 2#define __WAITQUEUE_INITIALIZER(name, tsk) {				\
 3    .task		= tsk,						\
 4    .func		= default_wake_function,			\
 5    .task_list	= { NULL, NULL } }
 6
 7#define DECLARE_WAITQUEUE(name, tsk)					\
 8    wait_queue_t name = __WAITQUEUE_INITIALIZER(name, tsk)
 9
10// 等待队列头元素的声明&初始化
11#define __WAIT_QUEUE_HEAD_INITIALIZER(name) {				\
12    .lock		= SPIN_LOCK_UNLOCKED,				\
13    .task_list	= { &(name).task_list, &(name).task_list } }
14
15#define DECLARE_WAIT_QUEUE_HEAD(name) \
16    wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)
17
18// 函数型初始化
19static inline void init_waitqueue_head(wait_queue_head_t *q)
20{
21    q->lock = SPIN_LOCK_UNLOCKED;
22    INIT_LIST_HEAD(&q->task_list);
23}
24
25static inline void init_waitqueue_entry(wait_queue_t *q, struct task_struct *p)
26{
27    q->flags = 0;
28    q->task = p;
29    q->func = default_wake_function;
30}
31
32static inline void init_waitqueue_func_entry(wait_queue_t *q,
33                    wait_queue_func_t func)
34{
35    q->flags = 0;
36    q->task = NULL;
37    q->func = func;
38}

 1#define	SLEEP_ON_VAR					\
 2    unsigned long flags;				\
 3    wait_queue_t wait;				\
 4    init_waitqueue_entry(&wait, current);
 5
 6#define SLEEP_ON_HEAD					\
 7    spin_lock_irqsave(&q->lock,flags);		\
 8    __add_wait_queue(q, &wait);			\
 9    spin_unlock(&q->lock);
10    
11#define	SLEEP_ON_TAIL					\
12    spin_lock_irq(&q->lock);			\
13    __remove_wait_queue(q, &wait);			\
14    spin_unlock_irqrestore(&q->lock, flags);
15
16
17void fastcall __sched sleep_on(wait_queue_head_t *q)
18{
19    SLEEP_ON_VAR
20
21    current->state = TASK_UNINTERRUPTIBLE;
22
23    SLEEP_ON_HEAD
24    schedule();
25    SLEEP_ON_TAIL
26}

 1void fastcall
 2prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state)
 3{
 4    unsigned long flags;
 5
 6    wait->flags &= ~WQ_FLAG_EXCLUSIVE;
 7    spin_lock_irqsave(&q->lock, flags);
 8    if (list_empty(&wait->task_list))
 9        __add_wait_queue(q, wait);
10    /*
11     * don't alter the task state if this is just going to
12     * queue an async wait queue callback
13     */
14    if (is_sync_wait(wait))
15        set_current_state(state);
16    spin_unlock_irqrestore(&q->lock, flags);
17}
18
19void fastcall finish_wait(wait_queue_head_t *q, wait_queue_t *wait)
20{
21    unsigned long flags;
22
23    __set_current_state(TASK_RUNNING);
24    /*
25     * We can check for list emptiness outside the lock
26     * IFF:
27     *  - we use the "careful" check that verifies both
28     *    the next and prev pointers, so that there cannot
29     *    be any half-pending updates in progress on other
30     *    CPU's that we haven't seen yet (and that might
31     *    still change the stack area.
32     * and
33     *  - all other users take the lock (ie we can only
34     *    have _one_ other CPU that looks at or modifies
35     *    the list).
36     */
37    if (!list_empty_careful(&wait->task_list)) {
38        spin_lock_irqsave(&q->lock, flags);
39        list_del_init(&wait->task_list);
40        spin_unlock_irqrestore(&q->lock, flags);
41    }
42}

 1#define __wait_event(wq, condition) 					\
 2do {									\
 3    DEFINE_WAIT(__wait);						\
 4                                    \
 5    for (;;) {							\
 6        prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE);	\
 7        if (condition)						\
 8            break;						\
 9        schedule();						\
10    }								\
11    finish_wait(&wq, &__wait);					\
12} while (0)
13
14#define wait_event(wq, condition) 					\
15do {									\
16    if (condition)	 						\
17        break;							\
18    __wait_event(wq, condition);					\
19} while (0)

 1/*
 2 * The core wakeup function.  Non-exclusive wakeups (nr_exclusive == 0) just
 3 * wake everything up.  If it's an exclusive wakeup (nr_exclusive == small +ve
 4 * number) then we wake all the non-exclusive tasks and one exclusive task.
 5 *
 6 * There are circumstances in which we can try to wake a task which has already
 7 * started to run but is not in state TASK_RUNNING.  try_to_wake_up() returns
 8 * zero in this (rare) case, and we handle it by continuing to scan the queue.
 9 */
10static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
11                 int nr_exclusive, int sync, void *key)
12{
13    struct list_head *tmp, *next;
14
15    list_for_each_safe(tmp, next, &q->task_list) {
16        wait_queue_t *curr;
17        unsigned flags;
18        curr = list_entry(tmp, wait_queue_t, task_list);
19        flags = curr->flags;
20        if (curr->func(curr, mode, sync, key) &&
21            (flags & WQ_FLAG_EXCLUSIVE) &&
22            !--nr_exclusive)
23            break;
24    }
25}
26
27/**
28 * __wake_up - wake up threads blocked on a waitqueue.
29 * @q: the waitqueue
30 * @mode: which threads
31 * @nr_exclusive: how many wake-one or wake-many threads to wake up
32 */
33void fastcall __wake_up(wait_queue_head_t *q, unsigned int mode,
34                int nr_exclusive, void *key)
35{
36    unsigned long flags;
37
38    spin_lock_irqsave(&q->lock, flags);
39    __wake_up_common(q, mode, nr_exclusive, 0, key);
40    spin_unlock_irqrestore(&q->lock, flags);
41}

 1struct rlimit {
 2    unsigned long	rlim_cur;
 3    unsigned long	rlim_max;
 4};
 5
 6
 7struct rlimit rlim[RLIM_NLIMITS];
 8
 9
10/*
11 * Resource limits
12 */
13#define RLIMIT_CPU 0			/* CPU time in ms */
14#define RLIMIT_FSIZE 1			/* Maximum filesize */
15#define RLIMIT_DATA 2			/* max data size */
16#define RLIMIT_STACK 3			/* max stack size */
17#define RLIMIT_CORE 4			/* max core file size */
18#define RLIMIT_NOFILE 5			/* max number of open files */
19#define RLIMIT_AS 6			/* mapped memory */
20#define RLIMIT_RSS 7			/* max resident set size */
21#define RLIMIT_NPROC 8			/* max number of processes */
22#define RLIMIT_MEMLOCK 9		/* max locked-in-memory address space */
23#define RLIMIT_LOCKS 10			/* maximum file locks held */
24#define RLIMIT_SIGPENDING 11		/* max number of pending signals */
25#define RLIMIT_MSGQUEUE 12		/* maximum bytes in POSIX mqueues */
26
27#define RLIM_NLIMITS 13			/* Number of limit flavors.  */

 1struct thread_struct {
 2/* cached TLS descriptors. */
 3    struct desc_struct tls_array[GDT_ENTRY_TLS_ENTRIES];
 4    unsigned long	esp0;
 5
 6    unsigned long	sysenter_cs;
 7    unsigned long	eip;
 8    unsigned long	esp;
 9    unsigned long	fs;
10    unsigned long	gs;
11/* Hardware debugging registers */
12    unsigned long	debugreg[8];  /* %%db0-7 debug registers */
13/* fault info */
14    unsigned long	cr2, trap_no, error_code;
15/* floating point info */
16    union i387_union	i387;
17/* virtual 86 mode info */
18    struct vm86_struct __user * vm86_info;
19    unsigned long		screen_bitmap;
20    unsigned long		v86flags, v86mask, saved_esp0;
21    unsigned int		saved_fs, saved_gs;
22/* IO permissions */
23    unsigned long	*io_bitmap_ptr;
24/* max allowed port in the bitmap, in bytes: */
25    unsigned long	io_bitmap_max;
26};

 1#define switch_to(prev,next,last) do {					\
 2    unsigned long esi,edi;						\
 3    asm volatile("pushfl\n\t"					\
 4             "pushl %%ebp\n\t"					\
 5             "movl %%esp,%0\n\t"	/* save ESP */		\
 6             "movl %5,%%esp\n\t"	/* restore ESP */	\
 7             "movl $1f,%1\n\t"		/* save EIP */		\
 8             "pushl %6\n\t"		/* restore EIP */	\
 9             "jmp __switch_to\n"				\
10             "1:\t"						\
11             "popl %%ebp\n\t"					\
12             "popfl"						\
13             :"=m" (prev->thread.esp),"=m" (prev->thread.eip),	\
14              "=a" (last),"=S" (esi),"=D" (edi)			\
15             :"m" (next->thread.esp),"m" (next->thread.eip),	\
16              "2" (prev), "d" (next));				\
17} while (0)

 1#include <stdio.h>
 2#include <stdlib.h>
 3          "=a" (last),"=S" (esi),"=D" (edi)			\
 4             :"m" (next->thread.esp),"m" (next->thread.eip),	\
 5              "2" (prev), "d" (next));	
 6int main(int argc,char **argv){
 7    int x = 1145;
 8    void *y, *z;
 9    __asm__ volatile(
10        "lea %2, %%eax\n\t"
11        "movl %%eax, %0 \n\t"
12        "movl $1f, %1\n\t"
13        "1:"
14        "xorl %%eax, %%eax"
15        : "=m"(y), "=m"(z)
16        : "m"(x)
17        : "eax"
18    );
19    printf("%p %p %p\n", y, &x, z);
20    return 0;
21}

 1/*
 2 *	switch_to(x,yn) should switch tasks from x to y.
 3 *
 4 * We fsave/fwait so that an exception goes off at the right time
 5 * (as a call from the fsave or fwait in effect) rather than to
 6 * the wrong process. Lazy FP saving no longer makes any sense
 7 * with modern CPU's, and this simplifies a lot of things (SMP
 8 * and UP become the same).
 9 *
10 * NOTE! We used to use the x86 hardware context switching. The
11 * reason for not using it any more becomes apparent when you
12 * try to recover gracefully from saved state that is no longer
13 * valid (stale segment register values in particular). With the
14 * hardware task-switch, there is no way to fix up bad state in
15 * a reasonable manner.
16 *
17 * The fact that Intel documents the hardware task-switching to
18 * be slow is a fairly red herring - this code is not noticeably
19 * faster. However, there _is_ some room for improvement here,
20 * so the performance issues may eventually be a valid point.
21 * More important, however, is the fact that this allows us much
22 * more flexibility.
23 *
24 * The return value (in %eax) will be the "prev" task after
25 * the task-switch, and shows up in ret_from_fork in entry.S,
26 * for example.
27 */
28struct task_struct fastcall * __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
29{
30    struct thread_struct *prev = &prev_p->thread,
31                 *next = &next_p->thread;
32    int cpu = smp_processor_id();
33    struct tss_struct *tss = &per_cpu(init_tss, cpu);
34
35    /* never put a printk in __switch_to... printk() calls wake_up*() indirectly */
36
37    __unlazy_fpu(prev_p);
38
39    /*
40     * Reload esp0, LDT and the page table pointer:
41     */
42    load_esp0(tss, next);
43
44    /*
45     * Load the per-thread Thread-Local Storage descriptor.
46     */
47    load_TLS(next, cpu);
48
49    /*
50     * Save away %fs and %gs. No need to save %es and %ds, as
51     * those are always kernel segments while inside the kernel.
52     */
53    asm volatile("movl %%fs,%0":"=m" (*(int *)&prev->fs));
54    asm volatile("movl %%gs,%0":"=m" (*(int *)&prev->gs));
55
56    /*
57     * Restore %fs and %gs if needed.
58     */
59    if (unlikely(prev->fs | prev->gs | next->fs | next->gs)) {
60        loadsegment(fs, next->fs);
61        loadsegment(gs, next->gs);
62    }
63
64    /*
65     * Now maybe reload the debug registers
66     */
67    if (unlikely(next->debugreg[7])) {
68        loaddebug(next, 0);
69        loaddebug(next, 1);
70        loaddebug(next, 2);
71        loaddebug(next, 3);
72        /* no 4 and 5 */
73        loaddebug(next, 6);
74        loaddebug(next, 7);
75    }
76
77    if (unlikely(prev->io_bitmap_ptr || next->io_bitmap_ptr))
78        handle_io_bitmap(next, tss);
79
80    return prev_p;
81}

 1#define IO_BITMAP_OFFSET offsetof(struct tss_struct,io_bitmap)
 2#define INVALID_IO_BITMAP_OFFSET 0x8000
 3#define INVALID_IO_BITMAP_OFFSET_LAZY 0x9000
 4
 5
 6static inline void
 7handle_io_bitmap(struct thread_struct *next, struct tss_struct *tss)
 8{
 9    if (!next->io_bitmap_ptr) {
10        tss->io_bitmap_base = INVALID_IO_BITMAP_OFFSET;
11        return;
12    }
13    if (likely(next == tss->io_bitmap_owner)) {
14        tss->io_bitmap_base = IO_BITMAP_OFFSET;
15        return;
16    }
17    tss->io_bitmap_base = INVALID_IO_BITMAP_OFFSET_LAZY;
18}

 1#define stts() write_cr0(8 | read_cr0())
 2
 3/*
 4 * These must be called with preempt disabled
 5 */
 6static inline void __save_init_fpu( struct task_struct *tsk )
 7{
 8    if ( cpu_has_fxsr ) {
 9        asm volatile( "fxsave %0 ; fnclex"
10                  : "=m" (tsk->thread.i387.fxsave) );
11    } else {
12        asm volatile( "fnsave %0 ; fwait"
13                  : "=m" (tsk->thread.i387.fsave) );
14    }
15    tsk->thread_info->status &= ~TS_USEDFPU;
16}
17
18
19/*
20 * These disable preemption on their own and are safe
21 */
22static inline void save_init_fpu( struct task_struct *tsk )
23{
24    preempt_disable();
25    __save_init_fpu(tsk);
26    stts();
27    preempt_enable();
28}

 1/*
 2 *  'math_state_restore()' saves the current math information in the
 3 * old math state array, and gets the new ones from the current task
 4 *
 5 * Careful.. There are problems with IBM-designed IRQ13 behaviour.
 6 * Don't touch unless you *really* know how it works.
 7 *
 8 * Must be called with kernel preemption disabled (in this case,
 9 * local interrupts are disabled at the call-site in entry.S).
10 */
11asmlinkage void math_state_restore(struct pt_regs regs)
12{
13    struct thread_info *thread = current_thread_info();
14    struct task_struct *tsk = thread->task;
15
16    clts();		/* Allow maths ops (or we recurse) */
17    if (!tsk_used_math(tsk))
18        init_fpu(tsk);
19    restore_fpu(tsk);
20    thread->status |= TS_USEDFPU;	/* So we fnsave on switch_to() */
21}

 1asmlinkage int sys_fork(struct pt_regs regs)
 2{
 3    return do_fork(SIGCHLD, regs.esp, &regs, 0, NULL, NULL);
 4}
 5
 6asmlinkage int sys_clone(struct pt_regs regs)
 7{
 8    unsigned long clone_flags;
 9    unsigned long newsp;
10    int __user *parent_tidptr, *child_tidptr;
11
12    clone_flags = regs.ebx;
13    newsp = regs.ecx;
14    parent_tidptr = (int __user *)regs.edx;
15    child_tidptr = (int __user *)regs.edi;
16    if (!newsp)
17        newsp = regs.esp;
18    return do_fork(clone_flags, newsp, &regs, 0, parent_tidptr, child_tidptr);
19}
20
21/*
22 * This is trivial, and on the face of it looks like it
23 * could equally well be done in user mode.
24 *
25 * Not so, for quite unobvious reasons - register pressure.
26 * In user mode vfork() cannot have a stack frame, and if
27 * done by calling the "clone()" system call directly, you
28 * do not have enough call-clobbered registers to hold all
29 * the information you need.
30 */
31asmlinkage int sys_vfork(struct pt_regs regs)
32{
33    return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs.esp, &regs, 0, NULL, NULL);
34}

 1/*
 2 *  Ok, this is the main fork-routine.
 3 *
 4 * It copies the process, and if successful kick-starts
 5 * it and waits for it to finish using the VM if required.
 6 */
 7long do_fork(unsigned long clone_flags,
 8          unsigned long stack_start,
 9          struct pt_regs *regs,
10          unsigned long stack_size,
11          int __user *parent_tidptr,
12          int __user *child_tidptr)
13{
14    struct task_struct *p;
15    int trace = 0;
16    long pid = alloc_pidmap();
17
18    if (pid < 0)
19        return -EAGAIN;
20    if (unlikely(current->ptrace)) {
21        trace = fork_traceflag (clone_flags);
22        if (trace)
23            clone_flags |= CLONE_PTRACE;
24    }
25
26    p = copy_process(clone_flags, stack_start, regs, stack_size, parent_tidptr, child_tidptr, pid);
27    /*
28     * Do this prior waking up the new thread - the thread pointer
29     * might get invalid after that point, if the thread exits quickly.
30     */
31    if (!IS_ERR(p)) {
32        struct completion vfork;
33
34        if (clone_flags & CLONE_VFORK) {
35            p->vfork_done = &vfork;
36            init_completion(&vfork);
37        }
38
39        if ((p->ptrace & PT_PTRACED) || (clone_flags & CLONE_STOPPED)) {
40            /*
41             * We'll start up with an immediate SIGSTOP.
42             */
43            sigaddset(&p->pending.signal, SIGSTOP);
44            set_tsk_thread_flag(p, TIF_SIGPENDING);
45        }
46
47        if (!(clone_flags & CLONE_STOPPED))
48            wake_up_new_task(p, clone_flags);
49        else
50            p->state = TASK_STOPPED;
51
52        if (unlikely (trace)) {
53            current->ptrace_message = pid;
54            ptrace_notify ((trace << 8) | SIGTRAP);
55        }
56
57        if (clone_flags & CLONE_VFORK) {
58            wait_for_completion(&vfork);
59            if (unlikely (current->ptrace & PT_TRACE_VFORK_DONE))
60                ptrace_notify ((PTRACE_EVENT_VFORK_DONE << 8) | SIGTRAP);
61        }
62    } else {
63        free_pidmap(pid);
64        pid = PTR_ERR(p);
65    }
66    return pid;
67}

 1#define PIDMAP_ENTRIES		((PID_MAX_LIMIT + 8*PAGE_SIZE - 1)/PAGE_SIZE/8)
 2#define BITS_PER_PAGE		(PAGE_SIZE*8)
 3#define BITS_PER_PAGE_MASK	(BITS_PER_PAGE-1)
 4#define mk_pid(map, off)	(((map) - pidmap_array)*BITS_PER_PAGE + (off))
 5#define find_next_offset(map, off)					\
 6        find_next_zero_bit((map)->page, BITS_PER_PAGE, off)
 7
 8/*
 9 * PID-map pages start out as NULL, they get allocated upon
10 * first use and are never deallocated. This way a low pid_max
11 * value does not cause lots of bitmaps to be allocated, but
12 * the scheme scales to up to 4 million PIDs, runtime.
13 */
14typedef struct pidmap {
15    atomic_t nr_free;
16    void *page;
17} pidmap_t;
18
19static pidmap_t pidmap_array[PIDMAP_ENTRIES] =
20     { [ 0 ... PIDMAP_ENTRIES-1 ] = { ATOMIC_INIT(BITS_PER_PAGE), NULL } };
21
22     
23int alloc_pidmap(void)
24{
25    int i, offset, max_scan, pid, last = last_pid;
26    pidmap_t *map;
27
28    pid = last + 1;
29    if (pid >= pid_max)
30        pid = RESERVED_PIDS;
31    offset = pid & BITS_PER_PAGE_MASK;
32    map = &pidmap_array[pid/BITS_PER_PAGE];
33    max_scan = (pid_max + BITS_PER_PAGE - 1)/BITS_PER_PAGE - !offset;
34    for (i = 0; i <= max_scan; ++i) {
35        if (unlikely(!map->page)) {
36            unsigned long page = get_zeroed_page(GFP_KERNEL);
37            /*
38             * Free the page if someone raced with us
39             * installing it:
40             */
41            spin_lock(&pidmap_lock);
42            if (map->page)
43                free_page(page);
44            else
45                map->page = (void *)page;
46            spin_unlock(&pidmap_lock);
47            if (unlikely(!map->page))
48                break;
49        }
50        if (likely(atomic_read(&map->nr_free))) {
51            do {
52                if (!test_and_set_bit(offset, map->page)) {
53                    atomic_dec(&map->nr_free);
54                    last_pid = pid;
55                    return pid;
56                }
57                offset = find_next_offset(map, offset);
58                pid = mk_pid(map, offset);
59            /*
60             * find_next_offset() found a bit, the pid from it
61             * is in-bounds, and if we fell back to the last
62             * bitmap block and the final block was the same
63             * as the starting point, pid is before last_pid.
64             */
65            } while (offset < BITS_PER_PAGE && pid < pid_max &&
66                    (i != max_scan || pid < last ||
67                        !((last+1) & BITS_PER_PAGE_MASK)));
68        }
69        if (map < &pidmap_array[(pid_max-1)/BITS_PER_PAGE]) {
70            ++map;
71            offset = 0;
72        } else {
73            map = &pidmap_array[0];
74            offset = RESERVED_PIDS;
75            if (unlikely(last == offset))
76                break;
77        }
78        pid = mk_pid(map, offset);
79    }
80    return -1;
81}

 1/*
 2 * This gets called before we allocate a new thread and copy
 3 * the current task into it.
 4 */
 5void prepare_to_copy(struct task_struct *tsk)
 6{
 7    unlazy_fpu(tsk);
 8}
 9
10static struct task_struct *dup_task_struct(struct task_struct *orig)
11{
12    struct task_struct *tsk;
13    struct thread_info *ti;
14
15    prepare_to_copy(orig);
16
17    tsk = alloc_task_struct();
18    if (!tsk)
19        return NULL;
20
21    ti = alloc_thread_info(tsk);
22    if (!ti) {
23        free_task_struct(tsk);
24        return NULL;
25    }
26
27    *ti = *orig->thread_info;
28    *tsk = *orig;
29    tsk->thread_info = ti;
30    ti->task = tsk;
31
32    /* One for us, one for whoever does the "release_task()" (usually parent) */
33    atomic_set(&tsk->usage,2);
34    return tsk;
35}

 1/*
 2 * This gets run with %ebx containing the
 3 * function to call, and %edx containing
 4 * the "args".
 5 */
 6extern void kernel_thread_helper(void);
 7__asm__(".section .text\n"
 8    ".align 4\n"
 9    "kernel_thread_helper:\n\t"
10    "movl %edx,%eax\n\t"
11    "pushl %edx\n\t"
12    "call *%ebx\n\t"
13    "pushl %eax\n\t"
14    "call do_exit\n"
15    ".previous");
16
17/*
18 * Create a kernel thread
19 */
20int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
21{
22    struct pt_regs regs;
23
24    memset(&regs, 0, sizeof(regs));
25
26    regs.ebx = (unsigned long) fn;
27    regs.edx = (unsigned long) arg;
28
29    regs.xds = __USER_DS;
30    regs.xes = __USER_DS;
31    regs.orig_eax = -1;
32    regs.eip = (unsigned long) kernel_thread_helper;
33    regs.xcs = __KERNEL_CS;
34    regs.eflags = X86_EFLAGS_IF | X86_EFLAGS_SF | X86_EFLAGS_PF | 0x2;
35
36    /* Ok, create the new process.. */
37    return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);
38}

 1void release_task(struct task_struct * p)
 2{
 3    int zap_leader;
 4    task_t *leader;
 5    struct dentry *proc_dentry;
 6
 7repeat: 
 8    atomic_dec(&p->user->processes);
 9    spin_lock(&p->proc_lock);
10    proc_dentry = proc_pid_unhash(p);
11    write_lock_irq(&tasklist_lock);
12    if (unlikely(p->ptrace))
13        __ptrace_unlink(p);
14    BUG_ON(!list_empty(&p->ptrace_list) || !list_empty(&p->ptrace_children));
15    __exit_signal(p);
16    __exit_sighand(p);
17    __unhash_process(p);
18
19    /*
20     * If we are the last non-leader member of the thread
21     * group, and the leader is zombie, then notify the
22     * group leader's parent process. (if it wants notification.)
23     */
24    zap_leader = 0;
25    leader = p->group_leader;
26    if (leader != p && thread_group_empty(leader) && leader->exit_state == EXIT_ZOMBIE) {
27        BUG_ON(leader->exit_signal == -1);
28        do_notify_parent(leader, leader->exit_signal);
29        /*
30         * If we were the last child thread and the leader has
31         * exited already, and the leader's parent ignores SIGCHLD,
32         * then we are the one who should release the leader.
33         *
34         * do_notify_parent() will have marked it self-reaping in
35         * that case.
36         */
37        zap_leader = (leader->exit_signal == -1);
38    }
39
40    sched_exit(p);  //调整父进程的时间片
41    write_unlock_irq(&tasklist_lock);
42    spin_unlock(&p->proc_lock);
43    proc_pid_flush(proc_dentry);
44    release_thread(p);
45    put_task_struct(p);
46
47    p = leader;
48    if (unlikely(zap_leader))
49        goto repeat;
50}