do_fork-->copy_process（二）-526互联

  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 struct task_struct *copy_process(unsigned long clone_flags,
 10                  unsigned long stack_start,
 11                  struct pt_regs *regs,
 12                  unsigned long stack_size,
 13                  int __user *parent_tidptr,
 14                  int __user *child_tidptr)
 15 {
 16     int retval;
 17     struct task_struct *p = NULL;
 18 
 19     if ((clone_flags & (CLONE_NEWNS|CLONE_FS)) == (CLONE_NEWNS|CLONE_FS))
 20         return ERR_PTR(-EINVAL);
 21 
 22     /*
 23      * Thread groups must share signals as well, and detached threads
 24      * can only be started up within the thread group.
 25      */
 26     if ((clone_flags & CLONE_THREAD) && !(clone_flags & CLONE_SIGHAND))
 27         return ERR_PTR(-EINVAL);
 28 
 29     /*
 30      * Shared signal handlers imply shared VM. By way of the above,
 31      * thread groups also imply shared VM. Blocking this case allows
 32      * for various simplifications in other code.
 33      */
 34     if ((clone_flags & CLONE_SIGHAND) && !(clone_flags & CLONE_VM))
 35         return ERR_PTR(-EINVAL);
 36 
 37     /*
 38      * CLONE_DETACHED must match CLONE_THREAD: it's a historical
 39      * thing.
 40      */
 41     if (!(clone_flags & CLONE_DETACHED) != !(clone_flags & CLONE_THREAD)) {
 42         /* Warn about the old no longer supported case so that we see it */
 43         if (clone_flags & CLONE_THREAD) {
 44             static int count;
 45             if (count < 5) {
 46                 count++;
 47                 printk(KERN_WARNING "%s trying to use CLONE_THREAD without CLONE_DETACH\n", current->comm);
 48             }
 49         }
 50         return ERR_PTR(-EINVAL);
 51     }
 52 
 53     retval = security_task_create(clone_flags);
 54     if (retval)
 55         goto fork_out;
 56 
 57     retval = -ENOMEM;
 58     p = dup_task_struct(current);
 59     if (!p)
 60         goto fork_out;
 61 
 62     retval = -EAGAIN;
 63     if (atomic_read(&p->user->processes) >=
 64             p->rlim[RLIMIT_NPROC].rlim_cur) {
 65         if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RESOURCE) &&
 66                 p->user != &root_user)
 67             goto bad_fork_free;
 68     }
 69 
 70     atomic_inc(&p->user->__count);
 71     atomic_inc(&p->user->processes);
 72 
 73     /*
 74      * If multiple threads are within copy_process(), then this check
 75      * triggers too late. This doesn't hurt, the check is only there
 76      * to stop root fork bombs.
 77      */
 78     if (nr_threads >= max_threads)
 79         goto bad_fork_cleanup_count;
 80 
 81     if (!try_module_get(p->thread_info->exec_domain->module))
 82         goto bad_fork_cleanup_count;
 83 
 84     if (p->binfmt && !try_module_get(p->binfmt->module))
 85         goto bad_fork_cleanup_put_domain;
 86 
 87 #ifdef CONFIG_PREEMPT
 88     /*
 89      * schedule_tail drops this_rq()->lock so we compensate with a count
 90      * of 1.  Also, we want to start with kernel preemption disabled.
 91      */
 92     p->thread_info->preempt_count = 1;
 93 #endif
 94     p->did_exec = 0;
 95     p->state = TASK_UNINTERRUPTIBLE;
 96 
 97     copy_flags(clone_flags, p);
 98     if (clone_flags & CLONE_IDLETASK)
 99         p->pid = 0;
100     else {
101         p->pid = alloc_pidmap();
102         if (p->pid == -1)
103             goto bad_fork_cleanup;
104     }
105     retval = -EFAULT;
106     if (clone_flags & CLONE_PARENT_SETTID)
107         if (put_user(p->pid, parent_tidptr))
108             goto bad_fork_cleanup;
109 
110     p->proc_dentry = NULL;
111 
112     INIT_LIST_HEAD(&p->run_list);
113 
114     INIT_LIST_HEAD(&p->children);
115     INIT_LIST_HEAD(&p->sibling);
116     INIT_LIST_HEAD(&p->posix_timers);
117     init_waitqueue_head(&p->wait_chldexit);
118     p->vfork_done = NULL;
119     spin_lock_init(&p->alloc_lock);
120     spin_lock_init(&p->switch_lock);
121     spin_lock_init(&p->proc_lock);
122 
123     clear_tsk_thread_flag(p, TIF_SIGPENDING);
124     init_sigpending(&p->pending);
125 
126     p->it_real_value = p->it_virt_value = p->it_prof_value = 0;
127     p->it_real_incr = p->it_virt_incr = p->it_prof_incr = 0;
128     init_timer(&p->real_timer);
129     p->real_timer.data = (unsigned long) p;
130 
131     p->leader = 0;        /* session leadership doesn't inherit */
132     p->tty_old_pgrp = 0;
133     p->utime = p->stime = 0;
134     p->cutime = p->cstime = 0;
135     p->array = NULL;
136     p->lock_depth = -1;        /* -1 = no lock */
137     p->start_time = get_jiffies_64();
138     p->security = NULL;
139     p->io_context = NULL;
140 
141     retval = -ENOMEM;
142     if ((retval = security_task_alloc(p)))
143         goto bad_fork_cleanup;
144     /* copy all the process information */
145     if ((retval = copy_semundo(clone_flags, p)))
146         goto bad_fork_cleanup_security;
147     if ((retval = copy_files(clone_flags, p)))
148         goto bad_fork_cleanup_semundo;
149     if ((retval = copy_fs(clone_flags, p)))
150         goto bad_fork_cleanup_files;
151     if ((retval = copy_sighand(clone_flags, p)))
152         goto bad_fork_cleanup_fs;
153     if ((retval = copy_signal(clone_flags, p)))
154         goto bad_fork_cleanup_sighand;
155     if ((retval = copy_mm(clone_flags, p)))
156         goto bad_fork_cleanup_signal;
157     if ((retval = copy_namespace(clone_flags, p)))
158         goto bad_fork_cleanup_mm;
159     retval = copy_thread(0, clone_flags, stack_start, stack_size, p, regs);
160     if (retval)
161         goto bad_fork_cleanup_namespace;
162 
163     p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL;
164     /*
165      * Clear TID on mm_release()?
166      */
167     p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr: NULL;
168 
169     /*
170      * Syscall tracing should be turned off in the child regardless
171      * of CLONE_PTRACE.
172      */
173     clear_tsk_thread_flag(p, TIF_SYSCALL_TRACE);
174 
175     /* Our parent execution domain becomes current domain
176        These must match for thread signalling to apply */
177        
178     p->parent_exec_id = p->self_exec_id;
179 
180     /* ok, now we should be set up.. */
181     p->exit_signal = (clone_flags & CLONE_THREAD) ? -1 : (clone_flags & CSIGNAL);
182     p->pdeath_signal = 0;
183 
184     /*
185      * Share the timeslice between parent and child, thus the
186      * total amount of pending timeslices in the system doesn't change,
187      * resulting in more scheduling fairness.
188      */
189     local_irq_disable();
190         p->time_slice = (current->time_slice + 1) >> 1;
191     /*
192      * The remainder of the first timeslice might be recovered by
193      * the parent if the child exits early enough.
194      */
195     p->first_time_slice = 1;
196     current->time_slice >>= 1;
197     p->timestamp = sched_clock();
198     if (!current->time_slice) {
199         /*
200           * This case is rare, it happens when the parent has only
201           * a single jiffy left from its timeslice. Taking the
202          * runqueue lock is not a problem.
203          */
204         current->time_slice = 1;
205         preempt_disable();
206         scheduler_tick(0, 0);
207         local_irq_enable();
208         preempt_enable();
209     } else
210         local_irq_enable();
211     /*
212      * Ok, add it to the run-queues and make it
213      * visible to the rest of the system.
214      *
215      * Let it rip!
216      */
217     p->tgid = p->pid;
218     p->group_leader = p;
219     INIT_LIST_HEAD(&p->ptrace_children);
220     INIT_LIST_HEAD(&p->ptrace_list);
221 
222     /* Need tasklist lock for parent etc handling! */
223     write_lock_irq(&tasklist_lock);
224     /*
225      * Check for pending SIGKILL! The new thread should not be allowed
226      * to slip out of an OOM kill. (or normal SIGKILL.)
227      */
228     if (sigismember(&current->pending.signal, SIGKILL)) {
229         write_unlock_irq(&tasklist_lock);
230         retval = -EINTR;
231         goto bad_fork_cleanup_namespace;
232     }
233 
234     /* CLONE_PARENT re-uses the old parent */
235     if (clone_flags & CLONE_PARENT)
236         p->real_parent = current->real_parent;
237     else
238         p->real_parent = current;
239     p->parent = p->real_parent;
240 
241     if (clone_flags & CLONE_THREAD) {
242         spin_lock(&current->sighand->siglock);
243         /*
244          * Important: if an exit-all has been started then
245          * do not create this new thread - the whole thread
246          * group is supposed to exit anyway.
247          */
248         if (current->signal->group_exit) {
249             spin_unlock(&current->sighand->siglock);
250             write_unlock_irq(&tasklist_lock);
251             retval = -EAGAIN;
252             goto bad_fork_cleanup_namespace;
253         }
254         p->tgid = current->tgid;
255         p->group_leader = current->group_leader;
256 
257         if (current->signal->group_stop_count > 0) {
258             /*
259              * There is an all-stop in progress for the group.
260              * We ourselves will stop as soon as we check signals.
261              * Make the new thread part of that group stop too.
262              */
263             current->signal->group_stop_count++;
264             set_tsk_thread_flag(p, TIF_SIGPENDING);
265         }
266 
267         spin_unlock(&current->sighand->siglock);
268     }
269 
270     SET_LINKS(p);
271     if (p->ptrace & PT_PTRACED)
272         __ptrace_link(p, current->parent);
273 
274     attach_pid(p, PIDTYPE_PID, p->pid);
275     if (thread_group_leader(p)) {
276         attach_pid(p, PIDTYPE_TGID, p->tgid);
277         attach_pid(p, PIDTYPE_PGID, process_group(p));
278         attach_pid(p, PIDTYPE_SID, p->session);
279         if (p->pid)
280             __get_cpu_var(process_counts)++;
281     } else
282         link_pid(p, p->pids + PIDTYPE_TGID, &p->group_leader->pids[PIDTYPE_TGID].pid);
283 
284     nr_threads++;
285     write_unlock_irq(&tasklist_lock);
286     retval = 0;
287 
288 fork_out:
289     if (retval)
290         return ERR_PTR(retval);
291     return p;
292 
293 bad_fork_cleanup_namespace:
294     exit_namespace(p);
295 bad_fork_cleanup_mm:
296     exit_mm(p);
297 bad_fork_cleanup_signal:
298     exit_signal(p);
299 bad_fork_cleanup_sighand:
300     exit_sighand(p);
301 bad_fork_cleanup_fs:
302     exit_fs(p); /* blocking */
303 bad_fork_cleanup_files:
304     exit_files(p); /* blocking */
305 bad_fork_cleanup_semundo:
306     exit_sem(p);
307 bad_fork_cleanup_security:
308     security_task_free(p);
309 bad_fork_cleanup:
310     if (p->pid > 0)
311         free_pidmap(p->pid);
312     if (p->binfmt)
313         module_put(p->binfmt->module);
314 bad_fork_cleanup_put_domain:
315     module_put(p->thread_info->exec_domain->module);
316 bad_fork_cleanup_count:
317     atomic_dec(&p->user->processes);
318     free_uid(p->user);
319 bad_fork_free:
320     free_task(p);
321     goto fork_out;
322 }