Как работает ptrace в Linux?

20

Системный вызов ptrace позволяет родительскому процессу проверять вложенный дочерний процесс. Например, в Linux strace (который реализован с помощью системного вызова ptrace ) может проверять системные вызовы, вызванные дочерним процессом.

Когда присоединенный дочерний процесс вызывает системный вызов, родительский процесс ptracing может быть уведомлен. Но как именно это происходит? Я хочу знать технические детали этого механизма.

Заранее спасибо.

    
задан daehee 29.05.2014 в 09:59
источник
  • man7.org/linux/man-pages/man2/ptrace.2.html полезен –  tristan 29.05.2014 в 10:07
  • @tristan: Насколько я понимаю, OP хочет знать о механизмах, которые позволяют это произойти, а не об использовании. –  Blagovest Buyukliev 29.05.2014 в 10:09
  • @ Благовест Буюклиев: Благодарю вас. это именно то, что я хочу. Я знаю, как использовать ptrace. Я не знаю его внутреннего принципа –  daehee 29.05.2014 в 10:23

1 ответ

29

When the attached child process invokes a system call, the ptracing parent process can be notified. But how exactly does that happen?

Родительский процесс вызывает ptrace с PTRACE_ATTACH , а его дочерний процесс вызывает ptrace с параметром PTRACE_TRACEME . Эта пара соединит два процесса, заполнив некоторые поля внутри их task_struct ( kernel / ptrace.c: sys_ptrace , ребенок будет иметь флаг PT_PTRACED в поле ptrace struct task_struct и pid процесса ptracer в качестве родителя и в списке ptrace_entry - __ptrace_link ; родитель запишет pid ребенка в список ptraced ).

Затем strace вызовет ptrace с флагом PTRACE_SYSCALL , чтобы зарегистрировать себя в качестве отладчика syscall, установив thread_flag TIF_SYSCALL_TRACE в struct thread_info дочернего процесса (что-то вроде set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); ). arch/x86/include/asm/thread_info.h :

 67 /*
 68  * thread information flags
 69  * - these are process state flags that various assembly files
 70  *   may need to access   ...*/

 75 #define TIF_SYSCALL_TRACE       0       /* syscall trace active */
 99 #define _TIF_SYSCALL_TRACE      (1 << TIF_SYSCALL_TRACE)

При каждом входе или выходе системного вызова код записи системного вызова для конкретной архитектуры будет проверять этот _TIF_SYSCALL_TRACE flag (непосредственно в реализации syscall на ассемблере, например x86 arch/x86/kernel/entry_32.S : jnz syscall_trace_entry в ENTRY(system_call) и аналогичный код в syscall_exit_work ), и если он установлен, ptracer будет уведомлен с помощью сигнала (SIGTRAP), а потомок будет временно остановлен. Обычно это делается в syscall_trace_enter и syscall_trace_leave :

1457 long syscall_trace_enter(struct pt_regs *regs)

1483         if ((ret || test_thread_flag(TIF_SYSCALL_TRACE)) &&
1484             tracehook_report_syscall_entry(regs))
1485                 ret = -1L;

1507 void syscall_trace_leave(struct pt_regs *regs)

1531         if (step || test_thread_flag(TIF_SYSCALL_TRACE))
1532                 tracehook_report_syscall_exit(regs, step);

tracehook_report_syscall_* являются фактическими работниками здесь, они будут называть ptrace_report_syscall . include/linux/tracehook.h :

 80 /**
 81  * tracehook_report_syscall_entry - task is about to attempt a system call
 82  * @regs:               user register state of current task
 83  *
 84  * This will be called if %TIF_SYSCALL_TRACE has been set, when the
 85  * current task has just entered the kernel for a system call.
 86  * Full user register state is available here.  Changing the values
 87  * in @regs can affect the system call number and arguments to be tried.
 88  * It is safe to block here, preventing the system call from beginning.
 89  *
 90  * Returns zero normally, or nonzero if the calling arch code should abort
 91  * the system call.  That must prevent normal entry so no system call is
 92  * made.  If @task ever returns to user mode after this, its register state
 93  * is unspecified, but should be something harmless like an %ENOSYS error
 94  * return.  It should preserve enough information so that syscall_rollback()
 95  * can work (see asm-generic/syscall.h).
 96  *
 97  * Called without locks, just after entering kernel mode.
 98  */
 99 static inline __must_check int tracehook_report_syscall_entry(
100         struct pt_regs *regs)
101 {
102         return ptrace_report_syscall(regs);
103 }
104 
105 /**
106  * tracehook_report_syscall_exit - task has just finished a system call
107  * @regs:               user register state of current task
108  * @step:               nonzero if simulating single-step or block-step
109  *
110  * This will be called if %TIF_SYSCALL_TRACE has been set, when the
111  * current task has just finished an attempted system call.  Full
112  * user register state is available here.  It is safe to block here,
113  * preventing signals from being processed.
114  *
115  * If @step is nonzero, this report is also in lieu of the normal
116  * trap that would follow the system call instruction because
117  * user_enable_block_step() or user_enable_single_step() was used.
118  * In this case, %TIF_SYSCALL_TRACE might not be set.
119  *
120  * Called without locks, just before checking for pending signals.
121  */
122 static inline void tracehook_report_syscall_exit(struct pt_regs *regs, int step)
123 {
...
130 
131         ptrace_report_syscall(regs);
132 }

И ptrace_report_syscall генерирует SIGTRAP для отладчика или связать через ptrace_notify / ptrace_do_notify :

 55 /*
 56  * ptrace report for syscall entry and exit looks identical.
 57  */
 58 static inline int ptrace_report_syscall(struct pt_regs *regs)
 59 {
 60         int ptrace = current->ptrace;
 61 
 62         if (!(ptrace & PT_PTRACED))
 63                 return 0;
 64 
 65         ptrace_notify(SIGTRAP | ((ptrace & PT_TRACESYSGOOD) ? 0x80 : 0));
 66 
 67         /*
 68          * this isn't the same as continuing with a signal, but it will do
 69          * for normal use.  strace only continues with a signal if the
 70          * stopping signal is not SIGTRAP.  -brl
 71          */
 72         if (current->exit_code) {
 73                 send_sig(current->exit_code, current, 1);
 74                 current->exit_code = 0;
 75         }
 76 
 77         return fatal_signal_pending(current);
 78 }

ptrace_notify реализован в kernel/signal.c , это останавливает ребенка и передает sig_info в ptracer:

1961 static void ptrace_do_notify(int signr, int exit_code, int why)
1962 {
1963         siginfo_t info;
1964 
1965         memset(&info, 0, sizeof info);
1966         info.si_signo = signr;
1967         info.si_code = exit_code;
1968         info.si_pid = task_pid_vnr(current);
1969         info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
1970 
1971         /* Let the debugger run.  */
1972         ptrace_stop(exit_code, why, 1, &info);
1973 }
1974 
1975 void ptrace_notify(int exit_code)
1976 {
1977         BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1978         if (unlikely(current->task_works))
1979                 task_work_run();
1980 
1981         spin_lock_irq(&current->sighand->siglock);
1982         ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED);
1983         spin_unlock_irq(&current->sighand->siglock);
1984 }

ptrace_stop находится в том же файле signal.c , строка 1839 для 3.13.

    
ответ дан osgx 29.05.2014 в 10:34
  • awesome :) это точный ответ, который я хотел! –  daehee 29.05.2014 в 11:00
  • Каково значение current-> exit_code? Для чего его используют? В настоящее время я просматриваю сценарий, когда сигналы запускаются, а ptrace привязан к процессу. Также что делает ptrace_stop ()? Я вижу, что он устанавливает и очищает exit_code, в результате сигнал не доставляется. Пожалуйста, дайте мне знать, если вы хотите опубликовать отдельный запрос. На самом деле нужна ваша помощь. Спасибо. –  mk.. 09.07.2014 в 06:41
  • Ptrace_stop здесь: lxr.free-electrons.com/source/kernel/signal.c?v=3.13#L1828 он просто изменяет состояние тока на TASK_TRACED (рассматривается как T в ps и top), а также отправляет подготовленный сигнал к parent / ptracer. Насколько я понимаю, поле exit_code struct task_struct (include sched.h) используется для временного сохранения сигнала, чтобы позволить ptracer изменять или отменять сигнал. –  osgx 09.07.2014 в 11:14