Linux中信號和rt_signal系統調用有什么區別？

Question

我開發了一個處理SIGILL信號的庫。 因為我想避免libc依賴，並直接使用Linux系統調用。 我注意到我的庫掛在一些Linux系統上，經過大量調試后我發現使用rt_sigaction syscall而不是sigaction解決了這個問題。 但是，我沒有找到兩個系統調用之間差異的描述。 SO上有人知道底層細節嗎？

更新：我使用信號處理程序來檢測某些ARM指令擴展的CPU支持，例如XScale指令MIATT 。 這是指令探測功能：

static uint32_t probe_xscale() {
    register uint32_t retValue asm("r0") = 0;
    asm volatile (
        // Equivalent of the following code:
        //  ".arch xscale\n"
        //  "MIATT acc0, r0, r0;"
        // If the next line raises SIGILL,  the signal handle will change r0 to 1 and skip the instruction (4 bytes)
        "MCR P0, 0x1, r0, c15, c0, 0;"
        : "+r" (retValue)
        :
        :
    );
    return retValue;
}

在SIGILL處理程序中，我將PC寄存器前進4個字節（此指令的大小），並更改其中一個寄存器以指示SIGILL處理程序已被調用。 這是信號處理程序代碼。

static void probe_signal_handler(int, siginfo_t *, void* ptr) {
    ucontext_t* ctx = (ucontext_t*)ptr;
    ctx->uc_mcontext.arm_pc += 4;
    ctx->uc_mcontext.arm_r0 = 1;
}

以下是我如何進行探測（如果指令未導致SIGILL，則函數返回0，如果調用SIGILL處理程序，則返回1，如果sigaction syscall失敗，則返回2）：

static uint32_t probeInstruction(uint32_t (*ProbeFunction)()) {
    struct sigaction oldSigillAction;
    struct sigaction probeSigillAction;
    memset(&probeSigillAction, 0, sizeof(probeSigillAction));
    probeSigillAction.sa_sigaction = &probe_signal_handler;
    // Needs Linux >= 2.2
    probeSigillAction.sa_flags = SA_ONSTACK | SA_RESTART | SA_SIGINFO;
    int sigactionResult = _syscall_sigaction(SIGILL, &probeSigillAction, &oldSigillAction);
    if (sigactionResult == 0) {
        const uint32_t probeResult = ProbeFunction();
        _syscall_sigaction(SIGILL, &oldSigillAction, NULL);
        return probeResult;
    } else {
        return 2;
    }
}

這是我的sigaction syscall存根函數的實現：

static int _syscall_sigaction(int signum, const struct sigaction *new_action, struct sigaction *old_action) __attribute__((noinline));
static int _syscall_sigaction(int signalNumberParameter, const struct sigaction *newActionParameter, struct sigaction *oldActionParameter) {
    register int result asm ("r0");
    register int signalNumber asm ("r0") = signalNumberParameter;
    register const struct sigaction *newAction asm ("r1") = newActionParameter;
    register struct sigaction *oldAction asm ("r2") = oldActionParameter;
    register int syscallNumber asm ("r7") = __NR_rt_sigaction;
    asm volatile (
        "swi $0;"
        : "=r" (result)
        : "r" (signalNumber), "r" (newAction), "r" (oldAction), "r" (syscallNumber)
        :
    );
    return result;
}

我在Android SDK（qemu）和運行Ubuntu的Pandaboard的模擬器中測試了這段代碼。 在模擬器中，代碼運行良好（在模擬ARM9和Cortex-A8 CPU時），但在Pandaboard上，如果我使用__NR_sigaction，它會掛起MIATT指令：似乎在信號處理程序之后代碼不會跳過4個字節，而是運行同樣的指示。

Answer 1

我沒有明確的答案，但我仍會努力做出貢獻：

查看內核源代碼：

 300SYSCALL_DEFINE3(sigaction, int, sig, const struct sigaction __user *, act,
 301        struct sigaction __user *, oact)
 302{
 303        struct k_sigaction new_ka, old_ka;
 304        int ret;
 305        int err = 0;
 306
 307        if (act) {
 308                old_sigset_t mask;
 309
 310                if (!access_ok(VERIFY_READ, act, sizeof(*act)))
 311                        return -EFAULT;
 312                err |= __get_user(new_ka.sa.sa_handler, &act->sa_handler);
 313                err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 314                err |= __get_user(mask, &act->sa_mask.sig[0]);
 315                if (err)
 316                        return -EFAULT;
 317
 318                siginitset(&new_ka.sa.sa_mask, mask);
 319        }
 320
 321        ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 322
 323        if (!ret && oact) {
 324                if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
 325                        return -EFAULT;
 326                err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 327                err |= __put_user(old_ka.sa.sa_handler, &oact->sa_handler);
 328                err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
 329                err |= __put_user(0, &oact->sa_mask.sig[1]);
 330                err |= __put_user(0, &oact->sa_mask.sig[2]);
 331                err |= __put_user(0, &oact->sa_mask.sig[3]);
 332                if (err)
 333                        return -EFAULT;
 334        }
 335
 336        return ret;
 337}
 338#endif

與

2955SYSCALL_DEFINE4(rt_sigaction, int, sig,
2956                const struct sigaction __user *, act,
2957                struct sigaction __user *, oact,
2958                size_t, sigsetsize)
2959{
2960        struct k_sigaction new_sa, old_sa;
2961        int ret = -EINVAL;
2962
2963        /* XXX: Don't preclude handling different sized sigset_t's.  */
2964        if (sigsetsize != sizeof(sigset_t))
2965                goto out;
2966
2967        if (act) {
2968                if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2969                        return -EFAULT;
2970        }
2971
2972        ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2973
2974        if (!ret && oact) {
2975                if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2976                        return -EFAULT;
2977        }
2978out:
2979        return ret;
2980}

我看到的不同之處在於rt_sigaction復制了整個sigaction結構，而sigaction正在獲取並改變內聯內存（使用get / set用戶函數）......我不確定，但可能需要更多時間來訪問直接使用用戶空間內存而不是使用臨時副本。

Answer 2

從man sigaction （ 鏈接 ）我引用：

最初的Linux系統調用名為sigaction（）。 但是，通過在Linux 2.2中添加實時信號，該系統調用支持的固定大小的32位sigset_t類型不再適合用途。 因此，添加了一個新的系統調用rt_sigaction（）來支持放大的sigset_t類型。 新系統調用采用第四個參數size_t sigsetsize，它指定act.sa_mask和oldact.sa_mask中信號集的字節大小。