Вы находитесь на странице: 1из 13

Создание процессов

Создать процесс в системе можно несколькими способами, здесь я опишу как происходит создание процесса начиная с функции fork():

#include <sys/types.h> #include <unistd.h> pid_t fork(void);

fork() создает дочерний процесс, который является практически точной копией родительского процесса. Одним из различий являются значения PID и PPID. fork() при успешном вызове возвращает два значения, одно в родительский — PID созданного потомка, а второе в дочерний — 0. Если же вызов оказался неудачным, то родителю возвращается -1, потомок не создается, а в errno устанавливается код ошибки. Возвращаемое значение имеет тип pid_t, хотя на самом деле это обычное целое (int). Это можно проследить в коде ядра:

#define pid_t

pid_t

(<sys/types.h>)

#define

pid_t

PID_T_TYPE

(<bits/types.h>)

#define

PID_T_TYPE

S32_TYPE

(<bits/typesizes.h>)

#define

S32_TYPE

int

(<bits/types.h>)

Приведем простой пример использования функции fork():

/* fork_1.c --- простой пример использования fork() */

#include <stdio.h> #include <sys/wait.h> #include <errno.h> #include <sys/types.h> #include <unistd.h>

/* printf */ /* waitpid */ /* perror */ /* fork */ /* fork */

int main(void) { pid_t pid; int status;

switch(pid = fork()) { case -1:

perror("fork"); return -1; case 0:

printf("Выполняется дочерний процесс\n");

}

exit(4);

printf("Выполняется родительский процесс\n"); printf("Идентификатор дочернего процесса - %d\n", pid); if ((pid = waitpid(pid, &status, 0)) && WIFEXITED(status)) { printf("Дочерний процесс с PID = %d \ завершил выполнение", pid); printf("Код статуса завершения \ равен %d", WEXITSTATUS(status));

}

return 0;

}

Функция fork(), в свою очередь, вызывает системный вызов sys_clone(). В этом можно убедиться, если выполнить трассировку программы с помощью команды strace или ltrace:

$ strace ./fork_1

clone(Выполняется дочерний процесс child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0xb7eab708) = 9500

$ ltrace -S ./fork_1

SYS_clone(0x1200011, 0, 0, 0, 0xb7eab708 Выполняется дочерний процесс ) = 9500

Системный вызов sys_clone (определен в файле arch/x86/kernel/ process_XX.c), о котором можно прочитать на страницах справочного руководства man, является архитектурно-зависимым, вот его прототип (прототипы приводятся только для архитектуры x86):

/*** arch/x86/kernel/process_32.c ***/ int sys_clone(struct pt_regs *regs)

/*** arch/x86/kernel/process_64.c ***/ asmlinkage longa

sys_clone(unsigned long clone_flags, unsigned long newsp,

В

void

struct pt_regs *regs)

user

*parent_tid, void

любом

случае

sys_clone

независимую функцию do_fork():

user *child_tid,

ссылается

на

архитектурно-

return do_fork(clone_flags, newsp, regs, 0, parent_tidptr,child_tidptr);

было сказано, является

архитектурно-независимой функцией и несет ответственность за процесс дублирования. Она определена в файле kernel/fork.c, вот ее прототип:

Функция

do_fork(),

как

уже

long do_fork(unsigned long clone_flags, unsigned long stack_start, struct pt_regs *regs, unsigned long stack_size,

int

user

*parent_tidptr,

int

user

*child_tidptr)

do_fork() в свою очередь вызывает функцию copy_process(), которая выполняет фактическую работу по созданию нового процесса и повторному использованию данных родительского процесса. Ее вызов происходит следующим образом:

p = copy_process(clone_flags, stack_start, regs, stack_size, child_tidptr, NULL, trace);

В

приложениях А

и

Б

даны

copy_process() соответственно.

описания функций do_fork и

В итоге выстраивается следующая схема:

vfork() → fork () → sys_clone() → do_fork() → copy_process() clone() →

ПРИЛОЖЕНИЕ А

/*** kernel/fork.c — do_fork() ***/ long do_fork(unsigned long clone_flags, unsigned long stack_start, struct pt_regs *regs, unsigned long stack_size,

int

user

*parent_tidptr,

int

user

*child_tidptr)

{

struct task_struct *p; int trace = 0; long nr;

/*

*

Do some preliminary argument and permissions checking before we

*

actually start allocating stuff

*/ if (clone_flags & CLONE_NEWUSER) { if (clone_flags & CLONE_THREAD) return -EINVAL; /* hopefully this check will go away when userns support is * complete */ if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SETUID) || !capable(CAP_SETGID)) return -EPERM;

}

/*

*

We hope to recycle these flags after 2.6.26

*/

if (unlikely(clone_flags & CLONE_STOPPED)) {

static int

read_mostly count = 100;

if (count > 0 && printk_ratelimit()) { char comm[TASK_COMM_LEN];

count--; printk(KERN_INFO "fork(): process `%s' used deprecated clone flags 0x%lx\n", get_task_comm(comm, current), clone_flags & CLONE_STOPPED);

}

}

/*

*

When called from kernel_thread, don't do user tracing stuff.

*/ if (likely(user_mode(regs))) trace = tracehook_prepare_clone(clone_flags);

p = copy_process(clone_flags, stack_start, regs, stack_size, child_tidptr, NULL, trace);

/*

*

Do this prior waking up the new thread - the thread pointer

*

might get invalid after that point, if the thread exits quickly.

*/ if (!IS_ERR(p)) { struct completion vfork;

trace_sched_process_fork(current, p);

nr = task_pid_vnr(p);

if (clone_flags & CLONE_PARENT_SETTID) put_user(nr, parent_tidptr);

if (clone_flags & CLONE_VFORK) { p->vfork_done = &vfork; init_completion(&vfork);

}

audit_finish_fork(p); tracehook_report_clone(regs, clone_flags, nr, p);

/*

* We set PF_STARTING at creation in case tracing wants to

* use this to distinguish a fully live task from one that

* hasn't gotten to tracehook_report_clone() yet. Now we

* clear it and set the child going.

*/ p->flags &= ~PF_STARTING;

if (unlikely(clone_flags & CLONE_STOPPED)) { /* * We'll start up with an immediate SIGSTOP. */ sigaddset(&p->pending.signal, SIGSTOP); set_tsk_thread_flag(p, TIF_SIGPENDING);

set_task_state(p,

TASK_STOPPED);

} else { wake_up_new_task(p, clone_flags);

}

tracehook_report_clone_complete(trace, regs, clone_flags, nr, p);

if (clone_flags & CLONE_VFORK) { freezer_do_not_count(); wait_for_completion(&vfork); freezer_count(); tracehook_report_vfork_done(p, nr);

}

} else { nr = PTR_ERR(p);

}

return nr;

}

Комментарий

Первым делом do_fork() выполняет проверку установленных флагов: запускается ли процесс в остановленном состоянии (устаревший флаг, но все еще используется) и будет ли процесс работать в режиме трассировки. После вызывается функция copy_process(), о которой уже было сказано. Далее вызывается функция wake_up_new_task(). Функции wake_up_new_task (определена в файле kernel/sched.c) помещает новый процесс в очередь выполнения и инициирует его выполнение. Затем происходит вызов функции task_pid_vnr() (определена в файле include/linux/sched.h), которая возвращает новый PID. В итоге функция do_fork() завершает создание процесса и свою работу, возвращая значение PID.

ПРИЛОЖЕНИЕ Б

/*** kernel/fork.c — copy_process() ***/ static struct task_struct *copy_process(unsigned long clone_flags, unsigned long stack_start, struct pt_regs *regs, unsigned long stack_size,

{

int

struct pid *pid, int trace)

user

*child_tidptr,

int retval; struct task_struct *p; int cgroup_callbacks_done = 0;

if ((clone_flags & (CLONE_NEWNS|CLONE_FS)) == (CLONE_NEWNS|CLONE_FS)) return ERR_PTR(-EINVAL);

/*

*

Thread groups must share signals as well, and detached threads

*

can only be started up within the thread group.

*/ if ((clone_flags & CLONE_THREAD) && !(clone_flags & CLONE_SIGHAND)) return ERR_PTR(-EINVAL);

/*

*

Shared signal handlers imply shared VM. By way of the above,

*

thread groups also imply shared VM. Blocking this case allows

*

for various simplifications in other code.

*/ if ((clone_flags & CLONE_SIGHAND) && !(clone_flags & CLONE_VM)) return ERR_PTR(-EINVAL);

retval = security_task_create(clone_flags); if (retval) goto fork_out;

retval = -ENOMEM; p = dup_task_struct(current); if (!p) goto fork_out;

rt_mutex_init_task(p);

#ifdef CONFIG_PROVE_LOCKING DEBUG_LOCKS_WARN_ON(!p->hardirqs_enabled); DEBUG_LOCKS_WARN_ON(!p->softirqs_enabled);

#endif

retval = -EAGAIN; if (atomic_read(&p->real_cred->user->processes) >= p->signal->rlim[RLIMIT_NPROC].rlim_cur) { if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RESOURCE) && p->real_cred->user != INIT_USER) goto bad_fork_free;

}

retval = copy_creds(p, clone_flags); if (retval < 0) goto bad_fork_free;

/*

*

If multiple threads are within copy_process(), then this check

*

triggers too late. This doesn't hurt, the check is only there

* to stop root fork bombs. */ retval = -EAGAIN; if (nr_threads >= max_threads) goto bad_fork_cleanup_count;

if (!try_module_get(task_thread_info(p)->exec_domain->module)) goto bad_fork_cleanup_count;

if (p->binfmt && !try_module_get(p->binfmt->module)) goto bad_fork_cleanup_put_domain;

p->did_exec = 0; delayacct_tsk_init(p); /* Must remain after dup_task_struct() */ copy_flags(clone_flags, p); INIT_LIST_HEAD(&p->children); INIT_LIST_HEAD(&p->sibling); #ifdef CONFIG_PREEMPT_RCU p->rcu_read_lock_nesting = 0; p->rcu_flipctr_idx = 0; #endif /* #ifdef CONFIG_PREEMPT_RCU */ p->vfork_done = NULL; spin_lock_init(&p->alloc_lock);

clear_tsk_thread_flag(p, TIF_SIGPENDING); init_sigpending(&p->pending);

p->utime = cputime_zero; p->stime = cputime_zero; p->gtime = cputime_zero; p->utimescaled = cputime_zero; p->stimescaled = cputime_zero; p->prev_utime = cputime_zero; p->prev_stime = cputime_zero;

p->default_timer_slack_ns = current->timer_slack_ns;

task_io_accounting_init(&p->ioac);

acct_clear_integrals(p);

posix_cpu_timers_init(p);

p->lock_depth = -1;

do_posix_clock_monotonic_gettime(&p->start_time);

/* -1 = no lock */

p->real_start_time = p->start_time; monotonic_to_bootbased(&p->real_start_time); p->io_context = NULL; p->audit_context = NULL; cgroup_fork(p); #ifdef CONFIG_NUMA p->mempolicy = mpol_dup(p->mempolicy); if (IS_ERR(p->mempolicy)) { retval = PTR_ERR(p->mempolicy); p->mempolicy = NULL; goto bad_fork_cleanup_cgroup;

}

mpol_fix_fork_child_flag(p);

#endif #ifdef CONFIG_TRACE_IRQFLAGS

#ifdef

p->irq_events = 0; ARCH_WANT_INTERRUPTS_ON_CTXSW p->hardirqs_enabled = 1;

#else

#endif

p->hardirq_enable_ip = 0; p->hardirq_enable_event = 0; p->hardirq_disable_ip = _THIS_IP_; p->hardirq_disable_event = 0; p->softirqs_enabled = 1; p->softirq_enable_ip = _THIS_IP_; p->softirq_enable_event = 0; p->softirq_disable_ip = 0; p->softirq_disable_event = 0; p->hardirq_context = 0; p->softirq_context = 0;

#endif #ifdef CONFIG_LOCKDEP p->lockdep_depth = 0; /* no locks held yet */ p->curr_chain_key = 0; p->lockdep_recursion = 0;

#endif

#ifdef CONFIG_DEBUG_MUTEXES p->blocked_on = NULL; /* not blocked yet */

#endif

if (unlikely(current->ptrace)) ptrace_fork(p, clone_flags);

/* Perform scheduler related setup. Assign this task to a CPU. */ sched_fork(p, clone_flags);

if ((retval = audit_alloc(p))) goto bad_fork_cleanup_policy; /* copy all the process information */ if ((retval = copy_semundo(clone_flags, p))) goto bad_fork_cleanup_audit; if ((retval = copy_files(clone_flags, p))) goto bad_fork_cleanup_semundo; if ((retval = copy_fs(clone_flags, p))) goto bad_fork_cleanup_files; if ((retval = copy_sighand(clone_flags, p))) goto bad_fork_cleanup_fs; if ((retval = copy_signal(clone_flags, p))) goto bad_fork_cleanup_sighand; if ((retval = copy_mm(clone_flags, p))) goto bad_fork_cleanup_signal; if ((retval = copy_namespaces(clone_flags, p))) goto bad_fork_cleanup_mm; if ((retval = copy_io(clone_flags, p))) goto bad_fork_cleanup_namespaces; retval = copy_thread(clone_flags, stack_start, stack_size, p, regs); if (retval) goto bad_fork_cleanup_io;

if (pid != &init_struct_pid) { retval = -ENOMEM; pid = alloc_pid(p->nsproxy->pid_ns); if (!pid) goto bad_fork_cleanup_io;

if (clone_flags & CLONE_NEWPID) { retval = pid_ns_prepare_proc(p->nsproxy->pid_ns); if (retval < 0) goto bad_fork_free_pid;

}

}

ftrace_graph_init_task(p);

p->pid = pid_nr(pid); p->tgid = p->pid; if (clone_flags & CLONE_THREAD) p->tgid = current->tgid;

if (current->nsproxy != p->nsproxy) { retval = ns_cgroup_clone(p, pid); if (retval) goto bad_fork_free_graph;

}

p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr :

NULL;

/*

*

Clear TID on mm_release()?

*/ p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr:

NULL; #ifdef CONFIG_FUTEX p->robust_list = NULL; #ifdef CONFIG_COMPAT p->compat_robust_list = NULL;

#endif

INIT_LIST_HEAD(&p->pi_state_list); p->pi_state_cache = NULL;

#endif

/*

*

sigaltstack should be cleared when sharing the same VM

*/ if ((clone_flags & (CLONE_VM|CLONE_VFORK)) == CLONE_VM) p->sas_ss_sp = p->sas_ss_size = 0;

/*

*

Syscall tracing should be turned off in the child regardless

*

of CLONE_PTRACE.

*/ clear_tsk_thread_flag(p, TIF_SYSCALL_TRACE); #ifdef TIF_SYSCALL_EMU clear_tsk_thread_flag(p, TIF_SYSCALL_EMU);

#endif

clear_all_latency_tracing(p);

/* ok, now we should be set up

p->exit_signal = (clone_flags & CLONE_THREAD) ? -1 : (clone_flags &

*/

CSIGNAL); p->pdeath_signal = 0; p->exit_state = 0;

/*

*

Ok, make it visible to the rest of the system.

*

We dont wake it up yet.

*/ p->group_leader = p; INIT_LIST_HEAD(&p->thread_group);

/* Now that the task is set up, run cgroup callbacks if

* necessary. We need to run them before the task is visible

* on the tasklist. */ cgroup_fork_callbacks(p); cgroup_callbacks_done = 1;

/* Need tasklist lock for parent etc handling! */

write_lock_irq(&tasklist_lock);

/*

*

The task hasn't been attached yet, so its cpus_allowed mask will

*

not be changed, nor will its assigned CPU.

*

*

The cpus_allowed mask of the parent may have changed after it was

*

copied first time - so re-copy it here, then check the child's CPU

*

to ensure it is on a valid CPU (and if not, just force it back to

*

parent's CPU). This avoids alot of nasty races.

*/ p->cpus_allowed = current->cpus_allowed; p->rt.nr_cpus_allowed = current->rt.nr_cpus_allowed; if (unlikely(!cpu_isset(task_cpu(p), p->cpus_allowed) ||

!cpu_online(task_cpu(p)))) set_task_cpu(p, smp_processor_id());

/* CLONE_PARENT re-uses the old parent */ if (clone_flags & (CLONE_PARENT|CLONE_THREAD)) { p->real_parent = current->real_parent; p->parent_exec_id = current->parent_exec_id; } else { p->real_parent = current; p->parent_exec_id = current->self_exec_id;

}

spin_lock(&current->sighand->siglock);

/*

* Process group and session signals need to be delivered to just the

* parent before the fork or both the parent and the child after the

* fork. Restart if a signal comes in before we add the new process to

* it's process group.

* A fatal signal pending means that current will exit, so the new

* thread can't slip out of an OOM kill (or normal SIGKILL).

*/ recalc_sigpending(); if (signal_pending(current)) { spin_unlock(&current->sighand->siglock); write_unlock_irq(&tasklist_lock); retval = -ERESTARTNOINTR; goto bad_fork_free_graph;

}

if (clone_flags & CLONE_THREAD) { p->group_leader = current->group_leader; list_add_tail_rcu(&p->thread_group, &p->group_leader->thread_group);

}

if (likely(p->pid)) { list_add_tail(&p->sibling, &p->real_parent->children); tracehook_finish_clone(p, clone_flags, trace);

if (thread_group_leader(p)) { if (clone_flags & CLONE_NEWPID) p->nsproxy->pid_ns->child_reaper = p;

p->signal->leader_pid = pid; tty_kref_put(p->signal->tty); p->signal->tty = tty_kref_get(current->signal->tty); attach_pid(p, PIDTYPE_PGID, task_pgrp(current)); attach_pid(p, PIDTYPE_SID, task_session(current)); list_add_tail_rcu(&p->tasks, &init_task.tasks); get_cpu_var(process_counts)++;

}

attach_pid(p, PIDTYPE_PID, pid);

nr_threads++;

}

total_forks++; spin_unlock(&current->sighand->siglock); write_unlock_irq(&tasklist_lock); proc_fork_connector(p); cgroup_post_fork(p); return p;

bad_fork_free_graph:

ftrace_graph_exit_task(p);

bad_fork_free_pid:

if (pid != &init_struct_pid) free_pid(pid); bad_fork_cleanup_io:

put_io_context(p->io_context);

bad_fork_cleanup_namespaces:

exit_task_namespaces(p);

bad_fork_cleanup_mm:

if (p->mm) mmput(p->mm); bad_fork_cleanup_signal:

cleanup_signal(p);

bad_fork_cleanup_sighand:

cleanup_sighand(p->sighand);

bad_fork_cleanup_fs:

exit_fs(p); /* blocking */ bad_fork_cleanup_files:

exit_files(p); /* blocking */ bad_fork_cleanup_semundo:

exit_sem(p);

bad_fork_cleanup_audit:

audit_free(p);

bad_fork_cleanup_policy:

#ifdef CONFIG_NUMA mpol_put(p->mempolicy); bad_fork_cleanup_cgroup:

#endif

cgroup_exit(p, cgroup_callbacks_done); delayacct_tsk_free(p); if (p->binfmt)

module_put(p->binfmt->module);

bad_fork_cleanup_put_domain:

module_put(task_thread_info(p)->exec_domain->module);

bad_fork_cleanup_count:

atomic_dec(&p->cred->user->processes);

put_cred(p->real_cred);

put_cred(p->cred);

bad_fork_free:

free_task(p);

fork_out:

return ERR_PTR(retval);

}

Комментарий

copy_process(), также как и do_fork(), начинает свою работу с проверки на сочетание установленных флагов. Опишем некоторые проверки:

если установлен флаг CLONE_THREAD, но не установлен флаг CLONE_SIGHAND, то возвращается ошибка, так как потоки группы должны разделять сигналы; если установлен флаг CLONE_SIGHAND, но не установлен флаг CLONE_VM, то возвращается ошибка, так как общие обработчики сигналов, подразумевают общее адресное пространство.

Далее вызывается функция dup_task_struct() (определена в файле kernel/fork.c), которая создает новый экземпляр структуры task_struct и копирует в него различные дескрипторы, относящиеся к текущему процессу. Затем в copy_process производится проверка лимитов и полномочий, производится проверка на "fork bomb" (http://en.wikipedia.org/wiki/Fork_bomb), выполняются вспомога- тельные действия, включающие инициализацию различных полей структуры task_struct. Потом происходит вызов функций, выполняющих копирование составляющих процесса: таблицы дескрипторов открытых файлов (copy_files), таблицы сигналов и обработчиков сигналов (copy_signal и copy_sighand), адресного пространства процесса (copy_mm) и структуры thread_info (copy_thread). Затем только что созданная задача назначается процессору из числа разрешенных для ее выполнения (cpus_allowed). После того как новый процесс унаследует приоритет родительского процесса, выполняется еще небольшое число вспомогательных действий и происходит возврат в do_fork().

Литература

Исходники ядра Linux 2.6.30;

Wolfgang Mauerer — Professional Linux Kernel Architecture;

Роберт Лав — Разработка ядра Linux;

http://www.ibm.com/developerworks/ru/library/l-linux-process- management/index.html — Анатомия управления процессами в Linux;

http://www.ibm.com/developerworks/ru/library/l-task-killable/ index.html - TASK_KILLABLE: Новое состояние процесса в Linux.

Оценить