深入理解Unix信号机制


阅读数: 次   
× 文章目录
  1. 1. 前言
  2. 2. 什么是信号
    1. 2.1. 信号的定义
    2. 2.2. 信号集
    3. 2.3. 信号传递控制
  3. 3. 信号处理
  4. 4. 实现一个CrashHandler
    1. 4.1. 异常的捕获
    2. 4.2. 信号的捕获
    3. 4.3. Bugly的实现
  5. 5. 参考资料

前言

最近为了复现一个1%概率左右的跨平台层的崩溃，在MSDK的TestApp中集成了一个CrashHandler来进行压力测试。借着解决问题的机会深入学习一下Unix的信号机制。并在本文讲述了如何实现一个CrashHandlerDemo。

什么是信号

信号的定义

在上一次讲Socket编程提到SIGPIPE时简单了解了一下signal函数，我们知道可以向进程注册一个指定的信号处理函数，以使进程在收到指定函数时触发该函数。那么信号到底是什么呢，UNIX环境高级编程中定义：信号是软件中断，提供了一种处理异步事件的方法。为什么说是软件的中断，因为信号触发的软件层进程执行的中断。即进程在执行时，收到信号时中断程序的运行执行中断处理函数（如果没有忽略该信号），然后再返回程序继续运行。为什么说是处理异步事件，因为信号是随机出现，进程是无法确定什么时候接收到信号，只能告诉内核在出现该信号时该如何处理，进程不会阻塞以等待信号，而是正常执行，直到信号发送过来。

所以可以理解信号就是一种进程通信手段用于通知进程发生了某个事件。举一个例子，在iOS13上不加蓝牙权限描述时打开App请求蓝牙权限就会崩溃，查看crash log可以看到：

1
2
3
4
5
xception Type:  EXC_CRASH (SIGKILL)
Exception Codes: 0x0000000000000000, 0x0000000000000000
Exception Note:  EXC_CORPSE_NOTIFY
Termination Reason: TCC, This app has crashed because it attempted to access privacy-sensitive data without a usage description. The app's Info.plist must contain an NSBluetoothAlwaysUsageDescription key with a string value explaining to the user how the app uses this data.
Triggered by Thread:  1

可以看到崩溃的类型SIGKILL其实就当前进程在请求蓝牙权限时由于没有描述文件，内核发送一个SIGKILL信号给当前进程。

信号集

Unix系统中利用sigset_t（信号集）来表示多个信号，在darwin系统中由于信号只有31种，因此采用一个uint32_t来表示sigset_t，说白了就是利用其不同的bit位来判断是否包含这个值的信号，系统也提供了一下几个函数进行信号集的处理：

1
2
3
4
5
6
//sigemptyset用于清空信号集，这个宏命令就可以看到实现的原理了哈，很值得学习
#define	sigemptyset(set)	(*(set) = 0, 0)
int	sigemptyset(sigset_t *);
//sigfillset用于把信号集每一位都置为1，实现是按位取反
#define	sigfillset(set)		(*(set) = ~(sigset_t)0, 0)
int	sigfillset(sigset_t *);

这里值得学习的一点是C语言的逗号运算符，(*(set) = 0, 0)第一个0是把指针指向uint32_t置为0，第二个0表示的是返回值。这种语法糖还是蛮有趣的。

还有以下几个函数来进行信号集的增删改查:

1
2
3
4
5
6
7
8
9
10
11
12
//sigismember用于判断set中是否包含某个信号
#define	sigaddset(set, signo)	(*(set) |= __sigbits(signo), 0)
#define	sigdelset(set, signo)	(*(set) &= ~__sigbits(signo), 0)
#define	sigismember(set, signo)	((*(set) & __sigbits(signo)) != 0)

__header_always_inline int
__sigbits(int __signo)
{
    return __signo > __DARWIN_NSIG ? 0 : (1 << (__signo - 1));
}
//因为Darwin系统中现在只有31个信号！所以在上面做了保护
#define __DARWIN_NSIG   32      /* counting 0; could be 33 (mask is 1-32) */

其实都是一些位域运算的封装，在系统源码中包括Runtime的源码中随处可见位运算的使用，作为源码必定需要足够高的性能，采用位域运算可以大大减少内存占用和处理效率。

信号传递控制

可以利用sigprocmask控制进程信号屏蔽集：

1
2
3
4
5
6
7
//改变或检测信号屏蔽字,how描述如何处理。old_set用于检测当前进程的信号屏蔽字
//传入SIG_BLOCK表示将new_set指向的信号集<b>添加到</b>当前进程的信号屏蔽字，即阻塞这些信号
//传入SIG_UNBLOCK表示将new_set指向的信号集从当前进程的信号屏蔽字中移除，即释放这些信号
//传入SIG_SETMASK表示将new_set指向的信号集<b>作为</b>当前进程的信号屏蔽字（注意与SIG_BLOCK的区别）
//new_set传入的新的信号集
//old_set获取已存在的阻塞的信号集
int	sigprocmask(int how, const sigset_t * new_set, sigset_t * old_set);

被sigprocmsk阻塞的信号，无论发生多少次都会保存下来，可以通过old_set获取。但是设置为SIG_UNBLOCK时就会释放这些阻塞的信号。由于sigset_t只能通过每个bit保存一种信号的状态，所以无论接收到信号多少次，再次方法只会被传递一次。

sigprocmask一般只用于单线程的进程，因为它直接修改的进程的公共信号屏蔽集，所以对于多线程中使用需要在使用前进行声明和初始化，以保证数据的安全。

当系统阻塞了一些信号时，这些信号在触发之后就变成了未决的信号, 如何获取当前进程中未决的信号集呢，可以通过sigpending，我们用以下例子来实践一下信号的控制与未决信号的捕获：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
sigset_t new_set, old_set, pending_set;
    sigemptyset(&new_set);
    sigemptyset(&old_set);
    sigemptyset(&pending_set);
    //屏蔽这3个信号
    sigaddset(&new_set, SIGINT);
    sigaddset(&new_set, SIGQUIT);
    sigaddset(&new_set, SIGABRT);
    //阻塞new_set信号集
    sigprocmask(SIG_BLOCK, &new_set, &old_set);
    printf("new set is %8.8d, old set is:%8.8d\n", new_set, old_set);
    sigpending(&pending_set);
    printf("Pending set is %8.8d.\n", pending_set);
	  //Kill函数即像指定的进程发送信号，并且kill -l可以查看到信号集合
    kill(getpid(), SIGINT);
    sigpending(&pending_set);
    printf("Pending set is %8.8d.\n", pending_set);
    kill(getpid(), SIGQUIT);
    sigpending(&pending_set);
    printf("Pending set is %8.8d.\n", pending_set);
    kill(getpid(), SIGABRT);
    sigpending(&pending_set);
    printf("Pending set is %8.8d.\n", pending_set);
    //释放信号
//    sigprocmask( SIG_UNBLOCK, &new_set, &old_set );
    if (sigismember(&pending_set, SIGINT)) {
        printf("SIGINT was came.\n");
    }
    if (sigismember(&pending_set, SIGQUIT)) {
        printf("SIGQUIT was came.\n");
    }
    if (sigismember(&pending_set, SIGABRT)) {
        printf("SIGABRT was came.\n");
    }
    NSLog(@"code run here");

运行之后结果如下:

1
2
3
4
5
6
7
8
new set is 00000038, old set is:00000000
Pending set is 00000000.
Pending set is 00000000.
Pending set is 00000004.
Pending set is 00000036.
SIGQUIT was came.
SIGABRT was came.
2020-12-29 23:51:00.548057+0800 TestSignal[86096:15391848] code run here

sigpending成功捕获了未决的信号，如果我们把代码中注释的sigprocmask释放掉(SIG_UNBLOCK)会怎么样呢:

1
2
3
4
5
new set is 00000038, old set is:00000000
Pending set is 00000000.
Pending set is 00000002.
Pending set is 00000006.
Pending set is 00000038.

程序运行到这里直接崩溃了，因为阻塞的信号被释放了，进程收到了SIGINT信号，并且进程被干掉了所以后面就没有执行了。通过查看奔溃的frame可以看到，崩在了sigpromask之后，那么看一下它到底做了什么：

image-20200118192925723

要看懂这一段代码我们需要找到systemcall.h，路径为： 

1
/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/usr/include/sys

systemcall.h列举了所有系统调用的参数表，可以看到所有的系统调用接口全部用了一个数字来表示，根据苹果的注释可以知道该文件是由xnu源码中的systemcalls.master生成的。因此我们下载一下xnu内核源码。利用cat工具打开systemcalls.master文件可以看到，这里只截取部分需要的信息如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
cat /Users/joey.cao/Desktop/Learning/LLVM/darwin-xnu-master/bsd/kern/syscalls.master
;	derived from: FreeBSD @(#)syscalls.master	8.2 (Berkeley) 1/13/94
//简要的看了眼makesyscalls.sh，它解析这个.master配置文件生成了一下代码
;System call name/number master file.
; This is file processed by .../xnu/bsd/kern/makesyscalls.sh and creates:
;	.../xnu/bsd/kern/init_sysent.c
;	.../xnu/bsd/kern/syscalls.c
;	.../xnu/bsd/sys/syscall.h
;	.../xnu/bsd/sys/sysproto.h
;	.../xnu/bsd/security/audit_syscalls.c
  
  //这个文件定义了系统调用参数与函数原型的映射表，每一个调用对应一个函数模型
 1	AUE_EXIT	ALL	{ void exit(int rval) NO_SYSCALL_STUB; }
...
48	AUE_SIGPROCMASK	ALL	{ int sigprocmask(int how, user_addr_t mask, user_addr_t omask); }

所以我们分析下上图sigpromask的堆栈，首先把0x2000030赋值给eax寄存器。由于BSD层在Mach层之上，mach层占用了前0x2000000。所以BSD层的系统调用需要从逻辑地址0x2000000开始。所以这里实际表明调用的系统调用参数为48（注意这里是16进制），即正好就是SYS_sigpromask，它的函数原型如下:

1
2
#define	SYS_sigprocmask    48
48	AUE_SIGPROCMASK	ALL	{ int sigprocmask(int how, user_addr_t mask, user_addr_t omask); }

此时把参数rcx寄存器的值传入r10寄存器，作为调用函数的syscall的入参。然后可以看到是一个jae判断函数，判断的是0x7fff51b5a2a0下面jmp的返回值，我们查看0x7fff51b5a2a0这段函数地址，到底做了什么：

1
2
3
(lldb) image lookup --address 0x7fff51b54457
      Address: libsystem_kernel.dylib[0x00007fff51b54457] (libsystem_kernel.dylib.__TEXT.__text + 1095)
      Summary: libsystem_kernel.dylib`cerror_nocancel

正如注解所示，这里jmp的是cerror_nocancel。在xnu源码的errno.c中可以找到：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//可以看到errno保存在一个全局变量里，所以永远只会保存最新的一次systemcall的结果
int errno;

int * __error(void)
{
	void *ptr = _os_tsd_get_direct(__TSD_ERRNO);
	if (ptr != NULL) {
		return (int*)ptr;
	}
	return &errno;
}
__attribute__((noinline)) cerror_return_t cerror_nocancel(int err)
{
	errno = err;
	int *tsderrno = (int*)_os_tsd_get_direct(__TSD_ERRNO);
	if (tsderrno) {
		*tsderrno = err;
	}
	return -1;
}

可以看到，这里cerror_nocancel把传入信号值并通过转换获取到对应的错误码并赋给了errno。这也就是为什么当系统出现错误时可以实时的通过errno获取，然后由于错误进程终止。

信号处理

在早期的POSIX系统中提供了不可靠的信号机制，而为了向后兼容需要这些旧的信号语义的程序，提供了signal函数，但是正如之前分析过的signal的实现来看，有一个非常大的问题就是signal函数只能传递一个函数指针，那么如果有多个地方调用了signal函数只有最后一次传入的函数指针才会被保存:

1
void(*signal(int, void (*)(int)))(int);

不过在4.4BSD之后，以及MACOS和FreeBSD上其实现遵循了sigaction的函数定义，在苹果的main page上也可以找到相应的描述，这个是可靠的，因此可以认为在我们开发使用时signal函数对信号捕获是可靠的。sigaction方法提供了设置和检测信号的能力，并且能获取对信号已经设置的action，因此可以保全其它用户对信号捕获的处理：

1
2
3
4
//signo表示需要检测或者修改的信号
//new_action表示要设置新的信号action
//old_action如果不为空，则会获取已经存在的针对signo的处理action
int	sigaction(int signo, const struct sigaction * new_action, struct sigaction * old_action);

sigaction的定义也是很复杂的，它不仅内部有一个__sigaction_u来保持信号处理函数指针，还利用sa_mask来设置屏蔽字，sa_flags来设置需要捕获的信号：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
struct  sigaction {
  //可以看到这里signalHandler是一个union做到了向前兼容旧的signal
	union __sigaction_u __sigaction_u;  /* signal handler */
	sigset_t sa_mask;               /* signal mask to apply */
	int     sa_flags;               /* see signal options below */
};
/* Signal vector template for Kernel user boundary */
struct  __sigaction {
	union __sigaction_u __sigaction_u;  /* signal handler */
	void    (*sa_tramp)(void *, int, int, siginfo_t *, void *);
	sigset_t sa_mask;               /* signal mask to apply */
	int     sa_flags;               /* see signal options below */
};
typedef struct __siginfo {
	int     si_signo;               /* signal number */
	int     si_errno;               /* errno association */
	int     si_code;                /* signal code */
	pid_t   si_pid;                 /* sending process */
	uid_t   si_uid;                 /* sender's ruid */
	int     si_status;              /* exit value */
	void    *si_addr;               /* faulting instruction */
	union sigval si_value;          /* signal value */
	long    si_band;                /* band event for SIGPOLL */
	unsigned long   __pad[7];       /* Reserved for Future Use */
} siginfo_t;

可以看到__sigaction_u是一个union，其实就是为了兼容旧的signal的处理函数：

1
2
3
4
5
6
/* union for signal handlers */
union __sigaction_u {
	void    (*__sa_handler)(int);
	void    (*__sa_sigaction)(int, struct __siginfo *,
	    void *);
};

在支持sigaction的系统中，sigaction兼容signal函数，具体的实现可以参考UNIX环境搞基编程这本书，一句话说就是把上面union里的__sa_handler指向对应的signalHandler。由于这里仅仅只是一个union两种处理函数是不能共存的，所以切记不要冲突了。

实现一个CrashHandler

异常的捕获

异常也是一种常见的处理机制，例如OC中的NSException，不仅在系统代码会产生异常，开发者也可以在出错时主动产生异常来获取到错误信息。异常触发实质上是调用NSAssertionHandler:

1
- (void)handleFailureInMethod:(SEL)selector object:(id)object file:(NSString *)fileName lineNumber:(NSInteger)line description:(nullable NSString *)format,... NS_FORMAT_FUNCTION(5,6);

对于异常的捕获很简单，系统已经封装的很完美了，只需要调用NSSetUncaughtExceptionHandler传入一个按下面模板的函数指针即可：

1
typedef void NSUncaughtExceptionHandler(NSException *exception);

特别注意的是，有可能在你注册handler之前已经有人注册了，所以需要先调用NSGetUncaughtExceptionHandler来判断是否已经有注册了，如果有则保存下来，等exception触发时再通知到先前注册的handler。如果每一个新注册的人都能这样进行异常的传递，那么所有的exception handler才能都被触发。

1
2
3
4
if (NSGetUncaughtExceptionHandler()) {
    preExceptionHandler = NSGetUncaughtExceptionHandler();
}
NSSetUncaughtExceptionHandler(ExceptionHandler);

信号的捕获

信号控制已经了解的足够充分了，但是在进行信号捕获时仍然需要注意一些细节。例如保存上一次的sa_sigaction，虽然sa_action已经做到了向前兼容sa_handler，但是想做的够保险，还是需要根据sa_flag来判断，以及自己在注册sa_action时注意更新sa_flag。

还有一点需要注意的是应该为每个signal保存不同的sa_sigaction或sa_handler，因为你也不知道之前调用者对不同的signal采用了不同的处理，或者多个用户各自监听了不同的信号。所以最保险的方法就是存储下每个signal对应的处理函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
   for (NSNumber *signalValue in needCatchedSignals) {
        int signo = signalValue.intValue;
        //首先获取old_action
        struct sigaction old_action;
        bzero(&old_action, sizeof(sigaction));
        //获取旧的action
        int ret = sigaction(signo, NULL, &old_action);
        if (ret < 0) {
            printf("sigaction old action failed: %s\n", strerror(errno));
        }
#if DEBUGLOG
        printf("old_action sa_mask: %8.8d\n", old_action.sa_mask);
        printf("old_action sa_flags: %8.8d\n", old_action.sa_flags);
#endif
        //如果已经有注册的sigaction
        if (old_action.sa_flags & SA_SIGINFO) {
            //把已有的处理函数指针保存下来
            preSignalActions[signo] = old_action.sa_sigaction;
        }
        //注意sa_handler和sa_sigaction是不能共存的
        else if (old_action.sa_handler) {
            preSignalHandlers[signo] = old_action.sa_handler;
        }
        //注册新的action
        struct sigaction new_action;
        bzero(&new_action, sizeof(sigaction));
        sigemptyset(&new_action.sa_mask);
        new_action.sa_sigaction = SignalAction;
        //设置SA_SIGINFO标记位
        new_action.sa_flags = SA_NODEFER | SA_SIGINFO;
        ret = sigaction(SIGALRM, &new_action, NULL);
        if (ret < 0) {
            printf("sigaction new action failed: %s\n", strerror(errno));
        }
    }

虽然已经做了很多考虑，但是仍然不能确保其它用户是否规范的使用signal，只能自求多福吧。。。

Bugly的实现

Bugly是腾讯出的一款用于统计用户崩溃等功能的第三方SDK，可以捕获到非常全的崩溃信息，尤其是崩溃日志非常详细，此次我们主要为了追踪一个已知但是偶现的bug所以还不需要那么齐全的堆栈。不过查看下Bugly的实现总是好的，首先查看下符号，大致就能推测出一些功能的实现逻辑，对于Signal进行了捕获处理:

1
2
3
4
5
6
7
8
9
//可以知道有一个BLYCrashSignalHandler的OC类
0000000000083fd0 (__DATA,__objc_data) external _OBJC_CLASS_$_BLYCrashSignalHandler
0000000000083ff8 (__DATA,__objc_data) external _OBJC_METACLASS_$_BLYCrashSignalHandler
...
0000000000085d78 (__DATA,__bss) non-external _g_BLYSignalHandlerInstalled
0000000000085d80 (__DATA,__bss) non-external _g_BLYSignalStack
//果然也保存了了已有的Signalhandlers
0000000000085d98 (__DATA,__bss) non-external _g_BLYPreviousSignalHandlers
0000000000085da0 (__DATA,__bss) non-external _gSignalHandlerForward

对于exception也进行了捕获处理:

1
2
3
4
5
6
7
8
9
10
//封装了一个exception类
0000000000084340 (__DATA,__objc_data) external _OBJC_CLASS_$_BLYCrashUserException
0000000000084368 (__DATA,__objc_data) external _OBJC_METACLASS_$_BLYCrashUserException
  //也有一个OC的BLYCrashUncaughtExceptionHandler类
0000000000084390 (__DATA,__objc_data) external _OBJC_CLASS_$_BLYCrashUserExceptionHandler
00000000000843b8 (__DATA,__objc_data) external _OBJC_METACLASS_$_BLYCrashUserExceptionHandler
0000000000084070 (__DATA,__objc_data) external _OBJC_CLASS_$_BLYCrashUncaughtExceptionHandler
//保存上一次的excptionHandler并传递
0000000000085dc0 (__DATA,__bss) non-external _g_BLYPreviousUncaughtExceptionHandler
0000000000085dc8 (__DATA,__bss) non-external _gUncaughtExceptionHandlerForward

为了进一步确认它的实现，我们使用了一个非常好用的逆向工具Hopper DIsassembler。只关注一些实现例如上一次的action的通知的逻辑:

image-20200119104256813

先分析一下这一段代码，把_g_BLYPreviousSignalHandlers保存到rax寄存器，通过其它的代码可以看到Bugly的是在UIVIewController分类+ (void)load的时候就开始注册捕获信号了，这是一个非常早的时机。此时把信号对应的处理函数保存到了_g_BLYPreviousSignalHandlers这个静态数组中，然后r12这里是以信号值rcx按4字节对齐来偏移寻找到信号对应的处理函数。然后调用该函数，并把三个参数传入。可以看到思路和我们基本是一样的。

参考资料

UNIX环境高级编程（https://item.jd.com/12720738.html）

https://en.wikipedia.org/wiki/Signal_(IPC)

进入内核态究竟是什么意思？ - 灵剑的回答 - 知乎 https://www.zhihu.com/question/306127044/answer/555327651

https://www.cnblogs.com/bakari/p/5520860.html

https://github.com/apple/darwin-xnu

https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/syscall.2.html

https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/sigaction.2.html

https://bugly.qq.com/v2/

https://www.hopperapp.com

扫一扫，分享到微信

微信分享二维码
# 若是after-footer.ejs，在最后添加

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

越来越胖了。。。