内核对tkill的处理

左手的ㄟ右手 2023-09-24 08:09 101阅读 0赞

一、问题的引出

在多线程用户态程序中，为了更加准确详细的从一个线程观察另一个线程的行为，可能有时候需要让目标线程暂时安静下来，从而便于观测和监控。关于这个行为，首先想到的当然就是向一个线程发送一个SIGSTOP信号(注意，不是向进程，就是通过内核的tkill系统调用，或者说pthread\_kill)，从而让线程处于STOP状态，之后再通过SIGCONT让线程继续运行，这样是最为简单而环保的方法。但是事实测试的时候会发现这个信号即使是只发给内核的单个线程，也会造成整个线程组中所有线程被停止，这就是一个比较奇怪的现象了。

二、内核对tkill的处理

linux-2.6.37.1\\kernel\\signal.c

SYSCALL\_DEFINE2(tkill, pid\_t, pid, int, sig)

if (pid <=0)

return -EINVAL;

return do\_tkill(0, pid, sig);

-->>>do\_tkill--->>>do\_send\_sig\_info(sig, info, p, false)---->>>send\_signal--->>>\_\_send\_signal

pending=group ? &t->signal->shared\_pending : &t->pending;

从代码上看，tkill发出的信号是发送给了线程私有的pending信号队列，所以直到这里看来，它依然是应该只有目标线程会接受这个信号。

三、停止线程组代码实现

do\_signal--->>>get\_signal\_to\_deliver

signr=tracehook\_get\_signal(current, regs, info, return\_ka);

if (unlikely(signr < 0))

goto relock;

if (unlikely(signr !=0))

ka=return\_ka;

else \{

if (unlikely(signal->group\_stop\_count > 0) &&

do\_signal\_stop(0))结合后面的说明，如果说线程正处在一个线程组停止状态并且还有未处于stop状态的线程，则执行do\_signal\_stop自行停止调度。

goto relock;

signr=dequeue\_signal(current, &current->blocked,

info);

if (!signr)

break;

if (signr !=SIGKILL) \{

signr=ptrace\_signal(signr, info,

regs, cookie);

if (!signr)

continue;

………………

内核定义的停止信号

\#define SIG\_KERNEL\_STOP\_MASK (\\

rt\_sigmask(SIGSTOP) | rt\_sigmask(SIGTSTP) | \\

rt\_sigmask(SIGTTIN) | rt\_sigmask(SIGTTOU) )

if (sig\_kernel\_stop(signr)) \{所以SIGSTOP信号将会走入该流程。

if (signr !=SIGSTOP) \{这里也说明了很多TTY操作，如SIGTTIN等也会对线程组产生影响。

spin\_unlock\_irq(&sighand->siglock);

if (is\_current\_pgrp\_orphaned())

goto relock;

spin\_lock\_irq(&sighand->siglock);

if (likely(do\_signal\_stop(info->si\_signo))) \{

goto relock;

continue;

下面是do\_signal\_stop的代码，这个是对于这个特征的核心代码

static int do\_signal\_stop(int signr)

struct signal\_struct \*sig=current->signal;

int notify;

if (!sig->group\_stop\_count) \{如果说gropu\_stop\_Count为零，则说明线程组STOP还没有启动，所以在下面的指令中要把这个值设置为需要被STOP的线程的数目。

struct task\_struct \*t;

if (!likely(sig->flags & SIGNAL\_STOP\_DEQUEUED) ||

unlikely(signal\_group\_exit(sig)))

return 0;

sig->group\_exit\_code=signr;

sig->group\_stop\_count=1;

for (t=next\_thread(current); t !=current; t=next\_thread(t))

if (!(t->flags & PF\_EXITING) &&

!task\_is\_stopped\_or\_traced(t)) \{

sig->group\_stop\_count++;便利线程组中所有线程，对每一个尚未被处理的线程在group\_stop\_count中加一。

signal\_wake\_up(t, 0);

notify=sig->group\_stop\_count==1 ? CLD\_STOPPED : 0;

notify=tracehook\_notify\_jctl(notify, CLD\_STOPPED);

if (sig->group\_stop\_count) \{

if (!--sig->group\_stop\_count)这个线程组全部完成了STOP。

sig->flags=SIGNAL\_STOP\_STOPPED;

current->exit\_code=sig->group\_exit\_code;

\_\_set\_current\_state(TASK\_STOPPED);所有执行这个函数的线程都被设置为了TASK\_STOPPED状态，接下来执行schedule函数之后该线程将会被从运行队列中移除，次数受该函数开始if中设置的group\_stop\_count值决定。。

spin\_unlock\_irq(&current->sighand->siglock);

if (notify) \{

read\_lock(&tasklist\_lock);

do\_notify\_parent\_cldstop(current, notify);

read\_unlock(&tasklist\_lock);

do \{从这里该线程将会切换出去，让出调度权，

schedule();

\} while (try\_to\_freeze());

tracehook\_finish\_jctl();

current->exit\_code=0;

return 1;

四、调试器如何做到对单个线程的SIGSTOP

由于调试器和被调试任务之间有一种内核可以感知到的调试关系，也就是被调试任务的PT\_PTRACED的标志位被置位，所以当一个线程收到信号并且要处理的时候，内核会首先给调试器一个机会

get\_signal\_to\_deliver---->>ptrace\_stop--->>do\_notify\_parent\_cldstop

if ((current->ptrace & PT\_PTRACED) && signr !=SIGKILL) \{

ptrace\_signal\_deliver(regs, cookie);

ptrace\_stop(signr, signr, info);如果调试器在这个函数之后取消掉信号，也就是让exit\_code清零，则下面的continue将会忽略这个信号。

signr=current->exit\_code;

if (signr==0)

continue;

所以在没有启动线程组暂停之前，调试器优先获得控制权，所以调试器可以判断出是自己发送的信号，在进行必要的操作之后，通过ptrace系统调用再取消这个信号，从而让线程组退出夭折。linux-2.6.21\\arch\\i386\\kernel\\ptrace.c

long arch\_ptrace(struct task\_struct \*child, long request, long addr, long data)

case PTRACE\_SYSEMU:

case PTRACE\_SYSCALL:

case PTRACE\_CONT:

ret=-EIO;

if (!valid\_signal(data))

break;

if (request==PTRACE\_SYSEMU) \{

set\_tsk\_thread\_flag(child, TIF\_SYSCALL\_EMU);

clear\_tsk\_thread\_flag(child, TIF\_SYSCALL\_TRACE);

\} else if (request==PTRACE\_SYSCALL) \{

set\_tsk\_thread\_flag(child, TIF\_SYSCALL\_TRACE);

clear\_tsk\_thread\_flag(child, TIF\_SYSCALL\_EMU);

\} else \{

clear\_tsk\_thread\_flag(child, TIF\_SYSCALL\_EMU);

clear\_tsk\_thread\_flag(child, TIF\_SYSCALL\_TRACE);

child->exit\_code=data;调试器可以通过PTRACE\_CONT清除这个信号。

clear\_singlestep(child);

wake\_up\_process(child);

ret=0;

break;

内核对tkill的处理

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关内核对tkill的处理

相关 Java——对数据的处理

相关 WKWebView对Cookie的处理

相关【内核开发】字符串的处理

相关 httpclient对cookie的处理

相关对HTTP body的处理

相关 linux 内核驱动中对文件的读写

相关 Linux内核驱动——并发和竞争的处理

相关 NSURLProtocol对WKWebView的处理

相关如何对Linux内核参数进行优化？