1235struct task_struct {

    volatile long state;    /* -1 unrunnable, 0 runnable, >0 stopped */

    void *stack;

    atomic_t usage;

    unsigned int flags;    /* per process flags, defined below */

    unsigned int ptrace;

#ifdef CONFIG_SMP

    struct llist_node wake_entry;

    int on_cpu;

    struct task_struct *last_wakee;

    unsigned long wakee_flips;

    unsigned long wakee_flip_decay_ts;

    int wake_cpu;

#endif

    int on_rq;

    int prio, static_prio, normal_prio;

    unsigned int rt_priority;

    const struct sched_class *sched_class;

    struct sched_entity se;

    struct sched_rt_entity rt;

#ifdef CONFIG_CGROUP_SCHED

    struct task_group *sched_task_group;

#endif

    struct sched_dl_entity dl;

#ifdef CONFIG_PREEMPT_NOTIFIERS

    /* list of struct preempt_notifier: */

    struct hlist_head preempt_notifiers;

#endif

#ifdef CONFIG_BLK_DEV_IO_TRACE

    unsigned int btrace_seq;

#endif

    unsigned int policy;

    int nr_cpus_allowed;

    cpumask_t cpus_allowed;

#ifdef CONFIG_PREEMPT_RCU

    int rcu_read_lock_nesting;

    union rcu_special rcu_read_unlock_special;

    struct list_head rcu_node_entry;

#endif /* #ifdef CONFIG_PREEMPT_RCU */

#ifdef CONFIG_TREE_PREEMPT_RCU

    struct rcu_node *rcu_blocked_node;

#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */

#ifdef CONFIG_TASKS_RCU

    unsigned long rcu_tasks_nvcsw;

    bool rcu_tasks_holdout;

    struct list_head rcu_tasks_holdout_list;

    int rcu_tasks_idle_cpu;

#endif /* #ifdef CONFIG_TASKS_RCU */

#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)

    struct sched_info sched_info;

#endif

    struct list_head tasks;

#ifdef CONFIG_SMP

    struct plist_node pushable_tasks;

    struct rb_node pushable_dl_tasks;

#endif

    struct mm_struct *mm, *active_mm;

#ifdef CONFIG_COMPAT_BRK

    unsigned brk_randomized:;

#endif

    /* per-thread vma caching */

    u32 vmacache_seqnum;

    struct vm_area_struct *vmacache[VMACACHE_SIZE];

#if defined(SPLIT_RSS_COUNTING)

    struct task_rss_stat    rss_stat;

#endif

/* task state */

    int exit_state;

    int exit_code, exit_signal;

    int pdeath_signal;  /*  The signal sent when the parent dies  */

    unsigned int jobctl;    /* JOBCTL_*, siglock protected */

    /* Used for emulating ABI behavior of previous Linux versions */

    unsigned int personality;

    unsigned in_execve:;    /* Tell the LSMs that the process is doing an

1321                 * execve */

    unsigned in_iowait:;

    /* Revert to default priority/policy when forking */

    unsigned sched_reset_on_fork:;

    unsigned sched_contributes_to_load:;

    unsigned long atomic_flags; /* Flags needing atomic access. */

    pid_t pid;

    pid_t tgid;

#ifdef CONFIG_CC_STACKPROTECTOR

    /* Canary value for the -fstack-protector gcc feature */

    unsigned long stack_canary;

#endif

    /*

1338     * pointers to (original) parent process, youngest child, younger sibling,

1339     * older sibling, respectively.  (p->father can be replaced with

1340     * p->real_parent->pid)

1341     */

    struct task_struct __rcu *real_parent; /* real parent process */

    struct task_struct __rcu *parent; /* recipient of SIGCHLD, wait4() reports */

    /*

1345     * children/sibling forms the list of my natural children

1346     */

    struct list_head children;    /* list of my children */

    struct list_head sibling;    /* linkage in my parent's children list */

    struct task_struct *group_leader;    /* threadgroup leader */

    /*

1352     * ptraced is the list of tasks this task is using ptrace on.

1353     * This includes both natural children and PTRACE_ATTACH targets.

1354     * p->ptrace_entry is p's link on the p->parent->ptraced list.

1355     */

    struct list_head ptraced;

    struct list_head ptrace_entry;

    /* PID/PID hash table linkage. */

    struct pid_link pids[PIDTYPE_MAX];

    struct list_head thread_group;

    struct list_head thread_node;

    struct completion *vfork_done;        /* for vfork() */

    int __user *set_child_tid;        /* CLONE_CHILD_SETTID */

    int __user *clear_child_tid;        /* CLONE_CHILD_CLEARTID */

    cputime_t utime, stime, utimescaled, stimescaled;

    cputime_t gtime;

#ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE

    struct cputime prev_cputime;

#endif

#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN

    seqlock_t vtime_seqlock;

    unsigned long long vtime_snap;

    enum {

        VTIME_SLEEPING = ,

        VTIME_USER,

        VTIME_SYS,

    } vtime_snap_whence;

#endif

    unsigned long nvcsw, nivcsw; /* context switch counts */

    u64 start_time;        /* monotonic time in nsec */

    u64 real_start_time;    /* boot based time in nsec */

/* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */

    unsigned long min_flt, maj_flt;

    struct task_cputime cputime_expires;

    struct list_head cpu_timers[];

/* process credentials */

    const struct cred __rcu *real_cred; /* objective and real subjective task

1393                     * credentials (COW) */

    const struct cred __rcu *cred;    /* effective (overridable) subjective task

1395                     * credentials (COW) */

    char comm[TASK_COMM_LEN]; /* executable name excluding path

1397                     - access with [gs]et_task_comm (which lock

1398                       it with task_lock())

1399                     - initialized normally by setup_new_exec */

/* file system info */

    int link_count, total_link_count;

#ifdef CONFIG_SYSVIPC

/* ipc stuff */

    struct sysv_sem sysvsem;

    struct sysv_shm sysvshm;

#endif

#ifdef CONFIG_DETECT_HUNG_TASK

/* hung task detection */

    unsigned long last_switch_count;

#endif

/* CPU-specific state of this task */

    struct thread_struct thread;

/* filesystem information */

    struct fs_struct *fs;

/* open file information */

    struct files_struct *files;

/* namespaces */

    struct nsproxy *nsproxy;

/* signal handlers */

    struct signal_struct *signal;

    struct sighand_struct *sighand;

    sigset_t blocked, real_blocked;

    sigset_t saved_sigmask;    /* restored if set_restore_sigmask() was used */

    struct sigpending pending;

    unsigned long sas_ss_sp;

    size_t sas_ss_size;

    int (*notifier)(void *priv);

    void *notifier_data;

    sigset_t *notifier_mask;

    struct callback_head *task_works;

    struct audit_context *audit_context;

#ifdef CONFIG_AUDITSYSCALL

    kuid_t loginuid;

    unsigned int sessionid;

#endif

    struct seccomp seccomp;

/* Thread group tracking */

       u32 parent_exec_id;

       u32 self_exec_id;

/* Protection of (de-)allocation: mm, files, fs, tty, keyrings, mems_allowed,

1445 * mempolicy */

    spinlock_t alloc_lock;

    /* Protection of the PI data structures: */

    raw_spinlock_t pi_lock;

#ifdef CONFIG_RT_MUTEXES

    /* PI waiters blocked on a rt_mutex held by this task */

    struct rb_root pi_waiters;

    struct rb_node *pi_waiters_leftmost;

    /* Deadlock detection and priority inheritance handling */

    struct rt_mutex_waiter *pi_blocked_on;

#endif

#ifdef CONFIG_DEBUG_MUTEXES

    /* mutex deadlock detection */

    struct mutex_waiter *blocked_on;

#endif

#ifdef CONFIG_TRACE_IRQFLAGS

    unsigned int irq_events;

    unsigned long hardirq_enable_ip;

    unsigned long hardirq_disable_ip;

    unsigned int hardirq_enable_event;

    unsigned int hardirq_disable_event;

    int hardirqs_enabled;

    int hardirq_context;

    unsigned long softirq_disable_ip;

    unsigned long softirq_enable_ip;

    unsigned int softirq_disable_event;

    unsigned int softirq_enable_event;

    int softirqs_enabled;

    int softirq_context;

#endif

#ifdef CONFIG_LOCKDEP

# define MAX_LOCK_DEPTH 48UL

    u64 curr_chain_key;

    int lockdep_depth;

    unsigned int lockdep_recursion;

    struct held_lock held_locks[MAX_LOCK_DEPTH];

    gfp_t lockdep_reclaim_gfp;

#endif

/* journalling filesystem info */

    void *journal_info;

/* stacked block device info */

    struct bio_list *bio_list;

#ifdef CONFIG_BLOCK

/* stack plugging */

    struct blk_plug *plug;

#endif

/* VM state */

    struct reclaim_state *reclaim_state;

    struct backing_dev_info *backing_dev_info;

    struct io_context *io_context;

    unsigned long ptrace_message;

    siginfo_t *last_siginfo; /* For ptrace use.  */

    struct task_io_accounting ioac;

#if defined(CONFIG_TASK_XACCT)

    u64 acct_rss_mem1;    /* accumulated rss usage */

    u64 acct_vm_mem1;    /* accumulated virtual memory usage */

    cputime_t acct_timexpd;    /* stime + utime since last update */

#endif

#ifdef CONFIG_CPUSETS

    nodemask_t mems_allowed;    /* Protected by alloc_lock */

    seqcount_t mems_allowed_seq;    /* Seqence no to catch updates */

    int cpuset_mem_spread_rotor;

    int cpuset_slab_spread_rotor;

#endif

#ifdef CONFIG_CGROUPS

    /* Control Group info protected by css_set_lock */

    struct css_set __rcu *cgroups;

    /* cg_list protected by css_set_lock and tsk->alloc_lock */

    struct list_head cg_list;

#endif

#ifdef CONFIG_FUTEX

    struct robust_list_head __user *robust_list;

#ifdef CONFIG_COMPAT

    struct compat_robust_list_head __user *compat_robust_list;

#endif

    struct list_head pi_state_list;

    struct futex_pi_state *pi_state_cache;

#endif

#ifdef CONFIG_PERF_EVENTS

    struct perf_event_context *perf_event_ctxp[perf_nr_task_contexts];

    struct mutex perf_event_mutex;

    struct list_head perf_event_list;

#endif

#ifdef CONFIG_DEBUG_PREEMPT

    unsigned long preempt_disable_ip;

#endif

#ifdef CONFIG_NUMA

    struct mempolicy *mempolicy;    /* Protected by alloc_lock */

    short il_next;

    short pref_node_fork;

#endif

#ifdef CONFIG_NUMA_BALANCING

    int numa_scan_seq;

    unsigned int numa_scan_period;

    unsigned int numa_scan_period_max;

    int numa_preferred_nid;

    unsigned long numa_migrate_retry;

    u64 node_stamp;            /* migration stamp  */

    u64 last_task_numa_placement;

    u64 last_sum_exec_runtime;

    struct callback_head numa_work;

    struct list_head numa_entry;

    struct numa_group *numa_group;

    /*

1561     * Exponential decaying average of faults on a per-node basis.

1562     * Scheduling placement decisions are made based on the these counts.

1563     * The values remain static for the duration of a PTE scan

1564     */

    unsigned long *numa_faults_memory;

    unsigned long total_numa_faults;

    /*

1569     * numa_faults_buffer records faults per node during the current

1570     * scan window. When the scan completes, the counts in

1571     * numa_faults_memory decay and these values are copied.

1572     */

    unsigned long *numa_faults_buffer_memory;

    /*

1576     * Track the nodes the process was running on when a NUMA hinting

1577     * fault was incurred.

1578     */

    unsigned long *numa_faults_cpu;

    unsigned long *numa_faults_buffer_cpu;

    /*

1583     * numa_faults_locality tracks if faults recorded during the last

1584     * scan window were remote/local. The task scan period is adapted

1585     * based on the locality of the faults with different weights

1586     * depending on whether they were shared or private faults

1587     */

    unsigned long numa_faults_locality[];

    unsigned long numa_pages_migrated;

#endif /* CONFIG_NUMA_BALANCING */

    struct rcu_head rcu;

    /*

1596     * cache last used pipe for splice

1597     */

    struct pipe_inode_info *splice_pipe;

    struct page_frag task_frag;

#ifdef    CONFIG_TASK_DELAY_ACCT

    struct task_delay_info *delays;

#endif

#ifdef CONFIG_FAULT_INJECTION

    int make_it_fail;

#endif

    /*

1609     * when (nr_dirtied >= nr_dirtied_pause), it's time to call

1610     * balance_dirty_pages() for some dirty throttling pause

1611     */

    int nr_dirtied;

    int nr_dirtied_pause;

    unsigned long dirty_paused_when; /* start of a write-and-pause period */

#ifdef CONFIG_LATENCYTOP

    int latency_record_count;

    struct latency_record latency_record[LT_SAVECOUNT];

#endif

    /*

1621     * time slack values; these are used to round up poll() and

1622     * select() etc timeout values. These are in nanoseconds.

1623     */

    unsigned long timer_slack_ns;

    unsigned long default_timer_slack_ns;

#ifdef CONFIG_FUNCTION_GRAPH_TRACER

    /* Index of current stored address in ret_stack */

    int curr_ret_stack;

    /* Stack of return addresses for return function tracing */

    struct ftrace_ret_stack    *ret_stack;

    /* time stamp for last schedule */

    unsigned long long ftrace_timestamp;

    /*

1635     * Number of functions that haven't been traced

1636     * because of depth overrun.

1637     */

    atomic_t trace_overrun;

    /* Pause for the tracing */

    atomic_t tracing_graph_pause;

#endif

#ifdef CONFIG_TRACING

    /* state flags for use by tracers */

    unsigned long trace;

    /* bitmask and counter of trace recursion */

    unsigned long trace_recursion;

#endif /* CONFIG_TRACING */

#ifdef CONFIG_MEMCG /* memcg uses this to do batch job */

    unsigned int memcg_kmem_skip_account;

    struct memcg_oom_info {

        struct mem_cgroup *memcg;

        gfp_t gfp_mask;

        int order;

        unsigned int may_oom:;

    } memcg_oom;

#endif

#ifdef CONFIG_UPROBES

    struct uprobe_task *utask;

#endif

#if defined(CONFIG_BCACHE) || defined(CONFIG_BCACHE_MODULE)

    unsigned int    sequential_io;

    unsigned int    sequential_io_avg;

#endif

};

   #include <stdio.h>

   #include <stdlib.h>

   #include <unistd.h>

   int main(int argc, char * argv[])

   {

       int pid;

       /* fork another process */

       pid = fork();

       if (pid < )   出错处理

      {

          /* error occurred */

          fprintf(stderr,"Fork Failed!");

          exit(-);

      }

      else if (pid == )

      {

          /* child process */  子进程   pid=0时 if和else都会执行  fork系统调用在父进程和子进程各返回一次

          printf("This is Child Process!\n");

      }

      else

      {

          /* parent process  */

          printf("This is Parent Process!\n");

          /* parent will wait for the child to complete*/

          wait(NULL);

          printf("Child Complete!\n");

      }

  }

ti = alloc_thread_info_node(tsk, node);

tsk->stack = ti;

setup_thread_stack(tsk, orig); //这里只是复制thread_info，而非复制内核堆栈

1 *childregs = *current_pt_regs(); //复制内核堆栈

2 childregs->ax = 0; //为什么子进程的fork返回0，这里就是原因！

3

4 p->thread.sp = (unsigned long) childregs; //调度到子进程时的内核栈顶

5 p->thread.ip = (unsigned long) ret_from_fork; //调度到子进程时的第一条指令地址