文档章节

二、进程

o
 osc_fmg49rzg
发布于 2019/03/20 12:07
字数 3715
阅读 9
收藏 0

精选30+云产品,助力企业轻松上云!>>>

1.在Linux中轻量级进程就是线程,轻量级进程之间可以共享资源。

  进程描述符:task_struct 存放一个进程相关的所有信息。可以说一个进程描述符就代表一个进程。

  进程的七种状态:可运行状态、可中断等待状态、不可中断等待状态、暂停状态、跟踪状态、僵死状态、僵死撤销状态

  进程标识符(PID)

  进程描述符存放在动态内存中,便于内核管理。内核将线程描述符(thread_info)和内核态的进程堆栈一起存放于8K字节的两个页框中。

  线程描述符和进程描述符相互关联,即分别存在于对方的字段中。

  current宏标识运行在当前CPU上的进程。

  进程链表:双向链表,将所有进程的描述符链接起来。进程链表的头是init_task描述符,即所谓的0进程。

  Linux为每种进程优先权都建立一个对应的链表。prio_array_t 数据结构存放这些链表。

  进程间的关系:

    进程描述符中表示进程亲属关系的字段描述:

      real_parent、parent、children、sibling

  内核为加速从PID导出对应的进程描述符指针引入了4个散列表:PID,TGID,PGID,SID

  Linux利用链表来处理冲突的PID:每一个表项由冲突的进程描述符组成的双向链表。

  等待队列:当进程需要等待某个事件的发生而需要睡眠时,则当前进程就把自己放进合适的等待队列,等待内核唤醒他们。

  两种睡眠进程:互斥进程和非互斥进程

  进程资源的限制

2.进程切换

  硬件上下文切换,任务状态段的切换

  执行进程的切换:  http://home.ustc.edu.cn/~hchunhui/linux_sched.html#sec10

  保存和加载FPU、MMX、XMM寄存器的值

3.创建进程

   创建进程时,子进程共享父进程的大多数资源。

    通过写时复制技术允许父子进程读相同的物理页,只有当子进程需要实际写物理页时才给子进程分配新的物理页。

    轻量级进程允许父子进程共享在内核的很多数据结构,如页表、打开文件表、信号处理等。

    vfork()系统调用创建的子进程共享其父进程的内存地址空间,并且阻塞父进程的执行,直到子进程退出或子进程分离父进程为止。

  clone()、fork()、vfork()系统调用

    clone():创建轻量级进程。

        参数: fn  -----子进程的执行函数。该函数返回时子进程终止。函数的返回值代表子进程的退出代码。

           arg -----指向传递给fn()函数的参数

           flags -----低字节指定子进程结束时发送到父进程的信号代码。

           child-stack -----表示把用户态堆栈指针赋给子进程的esp寄存器。调用进程应该为子进程分配新的堆栈

           tls -----表示线程局部存储段数据结构的地址

           ptid -----表示父进程的用户态变量地址,父进程具有与子进程相同的PID

           ctid -----表示子进程的用户态变量地址,该进程具有这一类进程的PID

     根据下列Linux源码可以看出clone()、fork()、vfork()、kernel_thread()、do_fork() 函数都是由_do_fork()函数实现的,区别仅在于传递的参数不同。

  1 SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
  2          int __user *, parent_tidptr,
  3          int __user *, child_tidptr,
  4          unsigned long, tls)
  5
  6 {
  7     return _do_fork(clone_flags, newsp, 0, parent_tidptr, child_tidptr, tls);
  8 }
  9 /*
 10  * Create a kernel thread.
 11  */
 12 pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
 13 {
 14     return _do_fork(flags|CLONE_VM|CLONE_UNTRACED, (unsigned long)fn,
 15         (unsigned long)arg, NULL, NULL, 0);
 16 }
 17 
 18 #ifdef __ARCH_WANT_SYS_FORK
 19 SYSCALL_DEFINE0(fork)
 20 {
 21 #ifdef CONFIG_MMU
 22     return _do_fork(SIGCHLD, 0, 0, NULL, NULL, 0);
 23 #else
 24     /* can not support in nommu mode */
 25     return -EINVAL;
 26 #endif
 27 }
 28 #endif
 29 
 30 #ifdef __ARCH_WANT_SYS_VFORK
 31 SYSCALL_DEFINE0(vfork)
 32 {
 33     return _do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, 0,
 34             0, NULL, NULL, 0);
 35 }
 36 #endif
 37  
 38 
 39 long do_fork(unsigned long clone_flags,
 40           unsigned long stack_start,
 41           unsigned long stack_size,
 42           int __user *parent_tidptr,
 43           int __user *child_tidptr)
 44 {
 45     return _do_fork(clone_flags, stack_start, stack_size,
 46             parent_tidptr, child_tidptr, 0);
 47 }
 48 
 49 
 50 long _do_fork(unsigned long clone_flags,
 51           unsigned long stack_start,
 52           unsigned long stack_size,
 53           int __user *parent_tidptr,
 54           int __user *child_tidptr,
 55           unsigned long tls)
 56 {
 57     struct completion vfork;
 58     struct pid *pid;
 59     struct task_struct *p;
 60     int trace = 0;
 61     long nr;
 62 
 63     /*
 64      * Determine whether and which event to report to ptracer.  When
 65      * called from kernel_thread or CLONE_UNTRACED is explicitly
 66      * requested, no event is reported; otherwise, report if the event
 67      * for the type of forking is enabled.
 68      */
 69     if (!(clone_flags & CLONE_UNTRACED)) {
 70         if (clone_flags & CLONE_VFORK)
 71             trace = PTRACE_EVENT_VFORK;
 72         else if ((clone_flags & CSIGNAL) != SIGCHLD)
 73             trace = PTRACE_EVENT_CLONE;
 74         else
 75             trace = PTRACE_EVENT_FORK;
 76 
 77         if (likely(!ptrace_event_enabled(current, trace)))
 78             trace = 0;
 79     }
 80 
 81     p = copy_process(clone_flags, stack_start, stack_size,
 82              child_tidptr, NULL, trace, tls, NUMA_NO_NODE);
 83     add_latent_entropy();
 84 
 85     if (IS_ERR(p))
 86         return PTR_ERR(p);
 87 
 88     /*
 89      * Do this prior waking up the new thread - the thread pointer
 90      * might get invalid after that point, if the thread exits quickly.
 91      */
 92     trace_sched_process_fork(current, p);
 93 
 94     pid = get_task_pid(p, PIDTYPE_PID);
 95     nr = pid_vnr(pid);
 96 
 97     if (clone_flags & CLONE_PARENT_SETTID)
 98         put_user(nr, parent_tidptr);
 99 
100     if (clone_flags & CLONE_VFORK) {
101         p->vfork_done = &vfork;
102         init_completion(&vfork);
103         get_task_struct(p);
104     }
105 
106     wake_up_new_task(p);
107 
108     /* forking complete and child started to run, tell ptracer */
109     if (unlikely(trace))
110         ptrace_event_pid(trace, pid);
111 
112     if (clone_flags & CLONE_VFORK) {
113         if (!wait_for_vfork_done(p, &vfork))
114             ptrace_event_pid(PTRACE_EVENT_VFORK_DONE, pid);
115     }
116 
117     put_pid(pid);
118     return nr;
119 }

    cpoy_process()函数具体实现如下源代码所示:

 

  1 /*
  2  * This creates a new process as a copy of the old one,
  3  * but does not actually start it yet.
  4  *
  5  * It copies the registers, and all the appropriate
  6  * parts of the process environment (as per the clone
  7  * flags). The actual kick-off is left to the caller.
  8  */
  9 static __latent_entropy struct task_struct *copy_process(
 10                     unsigned long clone_flags,
 11                     unsigned long stack_start,
 12                     unsigned long stack_size,
 13                     int __user *child_tidptr,
 14                     struct pid *pid,
 15                     int trace,
 16                     unsigned long tls,
 17                     int node)
 18 {
 19     int retval;
 20     struct task_struct *p;
 21 
 22     /*
 23      * Don't allow sharing the root directory with processes in a different
 24      * namespace
 25      */
 26     if ((clone_flags & (CLONE_NEWNS|CLONE_FS)) == (CLONE_NEWNS|CLONE_FS))
 27         return ERR_PTR(-EINVAL);
 28 
 29     if ((clone_flags & (CLONE_NEWUSER|CLONE_FS)) == (CLONE_NEWUSER|CLONE_FS))
 30         return ERR_PTR(-EINVAL);
 31 
 32     /*
 33      * Thread groups must share signals as well, and detached threads
 34      * can only be started up within the thread group.
 35      */
 36     if ((clone_flags & CLONE_THREAD) && !(clone_flags & CLONE_SIGHAND))
 37         return ERR_PTR(-EINVAL);
 38 
 39     /*
 40      * Shared signal handlers imply shared VM. By way of the above,
 41      * thread groups also imply shared VM. Blocking this case allows
 42      * for various simplifications in other code.
 43      */
 44     if ((clone_flags & CLONE_SIGHAND) && !(clone_flags & CLONE_VM))
 45         return ERR_PTR(-EINVAL);
 46 
 47     /*
 48      * Siblings of global init remain as zombies on exit since they are
 49      * not reaped by their parent (swapper). To solve this and to avoid
 50      * multi-rooted process trees, prevent global and container-inits
 51      * from creating siblings.
 52      */
 53     if ((clone_flags & CLONE_PARENT) &&
 54                 current->signal->flags & SIGNAL_UNKILLABLE)
 55         return ERR_PTR(-EINVAL);
 56 
 57     /*
 58      * If the new process will be in a different pid or user namespace
 59      * do not allow it to share a thread group with the forking task.
 60      */
 61     if (clone_flags & CLONE_THREAD) {
 62         if ((clone_flags & (CLONE_NEWUSER | CLONE_NEWPID)) ||
 63             (task_active_pid_ns(current) !=
 64                 current->nsproxy->pid_ns_for_children))
 65             return ERR_PTR(-EINVAL);
 66     }
 67 
 68     retval = -ENOMEM;
 69     p = dup_task_struct(current, node);
 70     if (!p)
 71         goto fork_out;
 72 
 73     /*
 74      * This _must_ happen before we call free_task(), i.e. before we jump
 75      * to any of the bad_fork_* labels. This is to avoid freeing
 76      * p->set_child_tid which is (ab)used as a kthread's data pointer for
 77      * kernel threads (PF_KTHREAD).
 78      */
 79     p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL;
 80     /*
 81      * Clear TID on mm_release()?
 82      */
 83     p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr : NULL;
 84 
 85     ftrace_graph_init_task(p);
 86 
 87     rt_mutex_init_task(p);
 88 
 89 #ifdef CONFIG_PROVE_LOCKING
 90     DEBUG_LOCKS_WARN_ON(!p->hardirqs_enabled);
 91     DEBUG_LOCKS_WARN_ON(!p->softirqs_enabled);
 92 #endif
 93     retval = -EAGAIN;
 94     if (atomic_read(&p->real_cred->user->processes) >=
 95             task_rlimit(p, RLIMIT_NPROC)) {
 96         if (p->real_cred->user != INIT_USER &&
 97             !capable(CAP_SYS_RESOURCE) && !capable(CAP_SYS_ADMIN))
 98             goto bad_fork_free;
 99     }
100     current->flags &= ~PF_NPROC_EXCEEDED;
101 
102     retval = copy_creds(p, clone_flags);
103     if (retval < 0)
104         goto bad_fork_free;
105 
106     /*
107      * If multiple threads are within copy_process(), then this check
108      * triggers too late. This doesn't hurt, the check is only there
109      * to stop root fork bombs.
110      */
111     retval = -EAGAIN;
112     if (nr_threads >= max_threads)
113         goto bad_fork_cleanup_count;
114 
115     delayacct_tsk_init(p);    /* Must remain after dup_task_struct() */
116     p->flags &= ~(PF_SUPERPRIV | PF_WQ_WORKER | PF_IDLE);
117     p->flags |= PF_FORKNOEXEC;
118     INIT_LIST_HEAD(&p->children);
119     INIT_LIST_HEAD(&p->sibling);
120     rcu_copy_process(p);
121     p->vfork_done = NULL;
122     spin_lock_init(&p->alloc_lock);
123 
124     init_sigpending(&p->pending);
125 
126     p->utime = p->stime = p->gtime = 0;
127 #ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
128     p->utimescaled = p->stimescaled = 0;
129 #endif
130     prev_cputime_init(&p->prev_cputime);
131 
132 #ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
133     seqcount_init(&p->vtime.seqcount);
134     p->vtime.starttime = 0;
135     p->vtime.state = VTIME_INACTIVE;
136 #endif
137 
138 #if defined(SPLIT_RSS_COUNTING)
139     memset(&p->rss_stat, 0, sizeof(p->rss_stat));
140 #endif
141 
142     p->default_timer_slack_ns = current->timer_slack_ns;
143 
144     task_io_accounting_init(&p->ioac);
145     acct_clear_integrals(p);
146 
147     posix_cpu_timers_init(p);
148 
149     p->start_time = ktime_get_ns();
150     p->real_start_time = ktime_get_boot_ns();
151     p->io_context = NULL;
152     p->audit_context = NULL;
153     cgroup_fork(p);
154 #ifdef CONFIG_NUMA
155     p->mempolicy = mpol_dup(p->mempolicy);
156     if (IS_ERR(p->mempolicy)) {
157         retval = PTR_ERR(p->mempolicy);
158         p->mempolicy = NULL;
159         goto bad_fork_cleanup_threadgroup_lock;
160     }
161 #endif
162 #ifdef CONFIG_CPUSETS
163     p->cpuset_mem_spread_rotor = NUMA_NO_NODE;
164     p->cpuset_slab_spread_rotor = NUMA_NO_NODE;
165     seqcount_init(&p->mems_allowed_seq);
166 #endif
167 #ifdef CONFIG_TRACE_IRQFLAGS
168     p->irq_events = 0;
169     p->hardirqs_enabled = 0;
170     p->hardirq_enable_ip = 0;
171     p->hardirq_enable_event = 0;
172     p->hardirq_disable_ip = _THIS_IP_;
173     p->hardirq_disable_event = 0;
174     p->softirqs_enabled = 1;
175     p->softirq_enable_ip = _THIS_IP_;
176     p->softirq_enable_event = 0;
177     p->softirq_disable_ip = 0;
178     p->softirq_disable_event = 0;
179     p->hardirq_context = 0;
180     p->softirq_context = 0;
181 #endif
182 
183     p->pagefault_disabled = 0;
184 
185 #ifdef CONFIG_LOCKDEP
186     p->lockdep_depth = 0; /* no locks held yet */
187     p->curr_chain_key = 0;
188     p->lockdep_recursion = 0;
189     lockdep_init_task(p);
190 #endif
191 
192 #ifdef CONFIG_DEBUG_MUTEXES
193     p->blocked_on = NULL; /* not blocked yet */
194 #endif
195 #ifdef CONFIG_BCACHE
196     p->sequential_io    = 0;
197     p->sequential_io_avg    = 0;
198 #endif
199 
200     /* Perform scheduler related setup. Assign this task to a CPU. */
201     retval = sched_fork(clone_flags, p);
202     if (retval)
203         goto bad_fork_cleanup_policy;
204 
205     retval = perf_event_init_task(p);
206     if (retval)
207         goto bad_fork_cleanup_policy;
208     retval = audit_alloc(p);
209     if (retval)
210         goto bad_fork_cleanup_perf;
211     /* copy all the process information */
212     shm_init_task(p);
213     retval = security_task_alloc(p, clone_flags);
214     if (retval)
215         goto bad_fork_cleanup_audit;
216     retval = copy_semundo(clone_flags, p);
217     if (retval)
218         goto bad_fork_cleanup_security;
219     retval = copy_files(clone_flags, p);
220     if (retval)
221         goto bad_fork_cleanup_semundo;
222     retval = copy_fs(clone_flags, p);
223     if (retval)
224         goto bad_fork_cleanup_files;
225     retval = copy_sighand(clone_flags, p);
226     if (retval)
227         goto bad_fork_cleanup_fs;
228     retval = copy_signal(clone_flags, p);
229     if (retval)
230         goto bad_fork_cleanup_sighand;
231     retval = copy_mm(clone_flags, p);
232     if (retval)
233         goto bad_fork_cleanup_signal;
234     retval = copy_namespaces(clone_flags, p);
235     if (retval)
236         goto bad_fork_cleanup_mm;
237     retval = copy_io(clone_flags, p);
238     if (retval)
239         goto bad_fork_cleanup_namespaces;
240     retval = copy_thread_tls(clone_flags, stack_start, stack_size, p, tls);
241     if (retval)
242         goto bad_fork_cleanup_io;
243 
244     if (pid != &init_struct_pid) {
245         pid = alloc_pid(p->nsproxy->pid_ns_for_children);
246         if (IS_ERR(pid)) {
247             retval = PTR_ERR(pid);
248             goto bad_fork_cleanup_thread;
249         }
250     }
251 
252 #ifdef CONFIG_BLOCK
253     p->plug = NULL;
254 #endif
255 #ifdef CONFIG_FUTEX
256     p->robust_list = NULL;
257 #ifdef CONFIG_COMPAT
258     p->compat_robust_list = NULL;
259 #endif
260     INIT_LIST_HEAD(&p->pi_state_list);
261     p->pi_state_cache = NULL;
262 #endif
263     /*
264      * sigaltstack should be cleared when sharing the same VM
265      */
266     if ((clone_flags & (CLONE_VM|CLONE_VFORK)) == CLONE_VM)
267         sas_ss_reset(p);
268 
269     /*
270      * Syscall tracing and stepping should be turned off in the
271      * child regardless of CLONE_PTRACE.
272      */
273     user_disable_single_step(p);
274     clear_tsk_thread_flag(p, TIF_SYSCALL_TRACE);
275 #ifdef TIF_SYSCALL_EMU
276     clear_tsk_thread_flag(p, TIF_SYSCALL_EMU);
277 #endif
278     clear_all_latency_tracing(p);
279 
280     /* ok, now we should be set up.. */
281     p->pid = pid_nr(pid);
282     if (clone_flags & CLONE_THREAD) {
283         p->exit_signal = -1;
284         p->group_leader = current->group_leader;
285         p->tgid = current->tgid;
286     } else {
287         if (clone_flags & CLONE_PARENT)
288             p->exit_signal = current->group_leader->exit_signal;
289         else
290             p->exit_signal = (clone_flags & CSIGNAL);
291         p->group_leader = p;
292         p->tgid = p->pid;
293     }
294 
295     p->nr_dirtied = 0;
296     p->nr_dirtied_pause = 128 >> (PAGE_SHIFT - 10);
297     p->dirty_paused_when = 0;
298 
299     p->pdeath_signal = 0;
300     INIT_LIST_HEAD(&p->thread_group);
301     p->task_works = NULL;
302 
303     cgroup_threadgroup_change_begin(current);
304     /*
305      * Ensure that the cgroup subsystem policies allow the new process to be
306      * forked. It should be noted the the new process's css_set can be changed
307      * between here and cgroup_post_fork() if an organisation operation is in
308      * progress.
309      */
310     retval = cgroup_can_fork(p);
311     if (retval)
312         goto bad_fork_free_pid;
313 
314     /*
315      * Make it visible to the rest of the system, but dont wake it up yet.
316      * Need tasklist lock for parent etc handling!
317      */
318     write_lock_irq(&tasklist_lock);
319 
320     /* CLONE_PARENT re-uses the old parent */
321     if (clone_flags & (CLONE_PARENT|CLONE_THREAD)) {
322         p->real_parent = current->real_parent;
323         p->parent_exec_id = current->parent_exec_id;
324     } else {
325         p->real_parent = current;
326         p->parent_exec_id = current->self_exec_id;
327     }
328 
329     klp_copy_process(p);
330 
331     spin_lock(&current->sighand->siglock);
332 
333     /*
334      * Copy seccomp details explicitly here, in case they were changed
335      * before holding sighand lock.
336      */
337     copy_seccomp(p);
338 
339     /*
340      * Process group and session signals need to be delivered to just the
341      * parent before the fork or both the parent and the child after the
342      * fork. Restart if a signal comes in before we add the new process to
343      * it's process group.
344      * A fatal signal pending means that current will exit, so the new
345      * thread can't slip out of an OOM kill (or normal SIGKILL).
346     */
347     recalc_sigpending();
348     if (signal_pending(current)) {
349         retval = -ERESTARTNOINTR;
350         goto bad_fork_cancel_cgroup;
351     }
352     if (unlikely(!(ns_of_pid(pid)->pid_allocated & PIDNS_ADDING))) {
353         retval = -ENOMEM;
354         goto bad_fork_cancel_cgroup;
355     }
356 
357     if (likely(p->pid)) {
358         ptrace_init_task(p, (clone_flags & CLONE_PTRACE) || trace);
359 
360         init_task_pid(p, PIDTYPE_PID, pid);
361         if (thread_group_leader(p)) {
362             init_task_pid(p, PIDTYPE_PGID, task_pgrp(current));
363             init_task_pid(p, PIDTYPE_SID, task_session(current));
364 
365             if (is_child_reaper(pid)) {
366                 ns_of_pid(pid)->child_reaper = p;
367                 p->signal->flags |= SIGNAL_UNKILLABLE;
368             }
369 
370             p->signal->leader_pid = pid;
371             p->signal->tty = tty_kref_get(current->signal->tty);
372             /*
373              * Inherit has_child_subreaper flag under the same
374              * tasklist_lock with adding child to the process tree
375              * for propagate_has_child_subreaper optimization.
376              */
377             p->signal->has_child_subreaper = p->real_parent->signal->has_child_subreaper ||
378                              p->real_parent->signal->is_child_subreaper;
379             list_add_tail(&p->sibling, &p->real_parent->children);
380             list_add_tail_rcu(&p->tasks, &init_task.tasks);
381             attach_pid(p, PIDTYPE_PGID);
382             attach_pid(p, PIDTYPE_SID);
383             __this_cpu_inc(process_counts);
384         } else {
385             current->signal->nr_threads++;
386             atomic_inc(&current->signal->live);
387             atomic_inc(&current->signal->sigcnt);
388             list_add_tail_rcu(&p->thread_group,
389                       &p->group_leader->thread_group);
390             list_add_tail_rcu(&p->thread_node,
391                       &p->signal->thread_head);
392         }
393         attach_pid(p, PIDTYPE_PID);
394         nr_threads++;
395     }
396 
397     total_forks++;
398     spin_unlock(&current->sighand->siglock);
399     syscall_tracepoint_update(p);
400     write_unlock_irq(&tasklist_lock);
401 
402     proc_fork_connector(p);
403     cgroup_post_fork(p);
404     cgroup_threadgroup_change_end(current);
405     perf_event_fork(p);
406 
407     trace_task_newtask(p, clone_flags);
408     uprobe_copy_process(p, clone_flags);
409 
410     return p;
411 
412 bad_fork_cancel_cgroup:
413     spin_unlock(&current->sighand->siglock);
414     write_unlock_irq(&tasklist_lock);
415     cgroup_cancel_fork(p);
416 bad_fork_free_pid:
417     cgroup_threadgroup_change_end(current);
418     if (pid != &init_struct_pid)
419         free_pid(pid);
420 bad_fork_cleanup_thread:
421     exit_thread(p);
422 bad_fork_cleanup_io:
423     if (p->io_context)
424         exit_io_context(p);
425 bad_fork_cleanup_namespaces:
426     exit_task_namespaces(p);
427 bad_fork_cleanup_mm:
428     if (p->mm)
429         mmput(p->mm);
430 bad_fork_cleanup_signal:
431     if (!(clone_flags & CLONE_THREAD))
432         free_signal_struct(p->signal);
433 bad_fork_cleanup_sighand:
434     __cleanup_sighand(p->sighand);
435 bad_fork_cleanup_fs:
436     exit_fs(p); /* blocking */
437 bad_fork_cleanup_files:
438     exit_files(p); /* blocking */
439 bad_fork_cleanup_semundo:
440     exit_sem(p);
441 bad_fork_cleanup_security:
442     security_task_free(p);
443 bad_fork_cleanup_audit:
444     audit_free(p);
445 bad_fork_cleanup_perf:
446     perf_event_free_task(p);
447 bad_fork_cleanup_policy:
448     lockdep_free_task(p);
449 #ifdef CONFIG_NUMA
450     mpol_put(p->mempolicy);
451 bad_fork_cleanup_threadgroup_lock:
452 #endif
453     delayacct_tsk_free(p);
454 bad_fork_cleanup_count:
455     atomic_dec(&p->cred->user->processes);
456     exit_creds(p);
457 bad_fork_free:
458     p->state = TASK_DEAD;
459     put_task_stack(p);
460     free_task(p);
461 fork_out:
462     return ERR_PTR(retval);
463 }

 

4.内核线程

  内核线程与普通进程的区别:

    内核线程只运行在内核态,普通进程既可以运行在内核态也可以运行在用户态。

    内核线程只运行在内核态,只使用大于PAGE_OFFSET(即3GB~4GB之间)的线性地址空间,普通进程可以用4GB地址空间

  创建内核线程:调用kernel_thread()函数,该函数本质也是调用_do_fork()函数。_do_fork(flags|CLONE_VM|CLONE_UNTRACED,0,pregs,0,NULL,NULL)

  进程0--所有进程的祖先,idle进程  进程1--由进程0创建的内核线程执行init()函数

  其他内核线程:keventd、kapmd、kswapd、pdflush、kblockd、ksoftirqd

5.撤销进程

  进程终止:

  系统调用:exit_group() -----> do_group_exit() :终止整个线程组,也是C库函数exit()调用的系统调用

  系统调用:exit() -----> do_exit() :终止某一个线程,不管该线程所属线程组中的其他线程。

6.进程删除

  子进程结束后,父进程必须调用wait()族函数来回收子进程的系统资源。然后内核才会丢弃子进程的进程描述符。

  孤儿进程:父进程先于子进程退出,则子进程成为孤儿进程。内核会强制将孤儿进程设为init进程的子进程来解决孤儿问题。

  release_task()函数:

    该函数从僵死进程的描述符中分离出最后的数据结构,对僵死进程的处理有两种方式:

        1.如果父进程不需要接收子进程的信号,则直接调用do_exit()

        2.如果已经给父进程发送了一个信号,则调用wait4()或waitpid()系统调用

    

 1 void release_task(struct task_struct *p)
 2 {
 3     struct task_struct *leader;
 4     int zap_leader;
 5 repeat:
 6     /* don't need to get the RCU readlock here - the process is dead and
 7      * can't be modifying its own credentials. But shut RCU-lockdep up */
 8     rcu_read_lock();
 9     atomic_dec(&__task_cred(p)->user->processes);
10     rcu_read_unlock();
11 
12     proc_flush_task(p);
13 
14     write_lock_irq(&tasklist_lock);
15     ptrace_release_task(p);
16     __exit_signal(p);
17 
18     /*
19      * If we are the last non-leader member of the thread
20      * group, and the leader is zombie, then notify the
21      * group leader's parent process. (if it wants notification.)
22      */
23     zap_leader = 0;
24     leader = p->group_leader;
25     if (leader != p && thread_group_empty(leader)
26             && leader->exit_state == EXIT_ZOMBIE) {
27         /*
28          * If we were the last child thread and the leader has
29          * exited already, and the leader's parent ignores SIGCHLD,
30          * then we are the one who should release the leader.
31          */
32         zap_leader = do_notify_parent(leader, leader->exit_signal);
33         if (zap_leader)
34             leader->exit_state = EXIT_DEAD;
35     }
36 
37     write_unlock_irq(&tasklist_lock);
38     release_thread(p);
39     call_rcu(&p->rcu, delayed_put_task_struct);
40 
41     p = leader;
42     if (unlikely(zap_leader))
43         goto repeat;
44 }

 

 

 

 

 

 

 

 

 

o
粉丝 0
博文 500
码字总数 0
作品 0
私信 提问
加载中
请先登录后再评论。
利用OGG实现Oracle数据库双向同步

环境: 服务器一(RAC实例一的任意一个节点) IP地址: 10.19.100.91 Oracle数据库版本 11.2.0.4 Oracle数据库实例名 aegisdb Oracle数据库端口 1521 待同步数据库schema aegis OGG端口 7809 服...

osc_pfth9njc
2018/05/17
8
0
window 杀固定端口的进程

window 杀固定端口的进程 一、 查看所有进程占用的端口 在开始-运行-cmd,输入:netstat –ano可以查看所有进程 二、查看占用指定端口的程序 当你在用tomcat发布程序时,经常会遇到端口被占用...

osc_my2aqmiz
2019/03/29
13
0
Window 通过cmd查看端口占用、相应进程、杀死进程等的命令

一、 查看所有进程占用的端口 在开始-运行-cmd,输入:netstat –ano可以查看所有进程 二、查看占用指定端口的程序 当你在用tomcat发布程序时,经常会遇到端口被占用的情况,我们想知道是哪个...

osc_9jqxcs7q
2018/04/18
2
0
如何查看程序占用的端口 

如何查看程序占用的端口 一、 查看所有进程占用的端口 在开始-运行-cmd,输入:netstat –ano可以查看所有进程 二、查看占用指定端口的程序 当你在用tomcat发布程序时,经常会遇到端口被占用的...

飞雪无痕
2016/12/07
98
0
Window 通过cmd查看端口占用、相应进程、杀死进程等的命令【转】

一、 查看所有进程占用的端口 在开始-运行-cmd,输入:netstat –ano可以查看所有进程 二、查看占用指定端口的程序 当你在用tomcat发布程序时,经常会遇到端口被占用的情况,我们想知道是哪个...

我是温浩然
2016/07/11
9
0

没有更多内容

加载失败,请刷新页面

加载更多

使用amoeba实现mysql读写分离

转载马士兵连老师笔记 使用amoeba实现mysql读写分离 1、什么是amoeba? Amoeba(变形虫)项目,专注 分布式数据库 proxy 开发。座落与Client、DB Server(s)之间。对客户端透明。具有负载均衡、...

兵荒马乱的青春
1分钟前
0
0
学Vue,就要学会vue JSX(二)

学习JSX,先了解一下createElement 提到JSX,不可避免的就要提到createElement,当你看完本节,你会发现,奇怪的知识又增多了。ok,我们接着上一部分继续讲。这一次的准备工作是了解createEleme...

osc_kurqu050
2分钟前
0
0
学Vue,就要学会vue JSX(三)

是时候使用JSX代替createElement了 接着上面的讲,当我们看到上面用createElement去实现组件,太麻烦了,别说工作效率提高了,就是那些嵌套可以嵌套正确就很赞了,所以我们需要用JSX去简化整...

osc_tq5hz9vv
3分钟前
0
0
protocol buffer使用

protocol buffer使用例子 protocol buffer是什么 https://developers.google.com/protocol-buffers 这是protocol buffer的官方网站,上边有详细的使用方式。 一般常见的序列和反序列方式就是...

RandomObject
4分钟前
0
0
小白的前端之路-HTMl

HTML——超文本标记语言 HTMl里面有标签,标签又分为单标签和双标签,也分为行级元素和块级元素 标签是用<>包裹起来的,而且必须要有<>,否则会直接显示在浏览器上面哦 现在介绍一下常用标签...

osc_e45irv7l
4分钟前
0
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部