!829 Move sigchain’s sigmask from sigprocmask to pthread_sigmask

Merge pull request !829 from dhy308/release_sigchain_0225

libc-test/src/functionalext/common/sigchain_util.h

@@ -28,7 +28,7 @@
             EXPECT_FALSE(fun, true);             \
         }                                                 \
     }                                                     \
-    result = sigprocmask(SIG_BLOCK, &set, NULL);          \
+    result = pthread_sigmask(SIG_BLOCK, &set, NULL);          \
     if (result != 0) {                                    \
         EXPECT_FALSE(fun, true);                 \
     }                                                     \
@@ -38,16 +38,11 @@
 #define SIGCHIAN_TEST_SIGNAL_NUM_2 2
 #define SIGCHIAN_TEST_SIGNAL_NUM_3 3
 #define SIGCHIAN_TEST_SIGNAL_NUM_4 4
-#define SIGCHIAN_TEST_SIGNAL_NUM_5 5
-#define SIGCHIAN_TEST_SIGNAL_NUM_6 6
-#define SIGCHIAN_TEST_SIGNAL_NUM_8 8
-#define SIGCHIAN_TEST_SIGNAL_NUM_9 9
-#define SIGCHIAN_TEST_SIGNAL_NUM_11 11
-#define SIGCHIAN_TEST_SIGNAL_NUM_13 13
-#define SIGCHIAN_TEST_SIGNAL_NUM_14 14
 
 #define SIGCHAIN_SIGNAL_37 37
 #define SIGCHAIN_SIGNAL_43 43
+#define SIGCHAIN_SIGNAL_45 45
+#define SIGCHAIN_SIGNAL_56 56
 #define SIGCHAIN_SIGNAL_64 64
 
 extern bool get_sigchain_mask_enable();
\ No newline at end of file

libc-test/src/functionalext/sigchain/sigchain_add_special_handler.c

@@ -24,52 +24,52 @@ static int g_count = 0;
 /**
  * @brief the special handler
  */
-static bool sigchain_special_sigabrt_handler1(int signo, siginfo_t *siginfo, void *ucontext_raw)
+static bool sigchain_special_sigint_handler1(int signo, siginfo_t *siginfo, void *ucontext_raw)
 {
     g_count++;
-    EXPECT_EQ("sigchain_add_special_handler_001", signo, SIGABRT);
+    EXPECT_EQ("sigchain_add_special_handler_001", signo, SIGINT);
     return false;
 }
 
 /**
  * @brief the special handler
  */
-static bool sigchain_special_sigabrt_handler2(int signo, siginfo_t *siginfo, void *ucontext_raw)
+static bool sigchain_special_sigint_handler2(int signo, siginfo_t *siginfo, void *ucontext_raw)
 {
     g_count++;
-    EXPECT_EQ("sigchain_add_special_handler_001", signo, SIGABRT);
+    EXPECT_EQ("sigchain_add_special_handler_001", signo, SIGINT);
     return true;
 }
 
 /**
  * @tc.name      : sigchain_add_special_handler_001
- * @tc.desc      : The signal are not registered with the kernel, call add_special_signal_handler to  add
+ * @tc.desc      : The signal is not registered with the kernel, call add_special_signal_handler to  add
  *                 two special handlers
  * @tc.level     : Level 0
  */
 static void sigchain_add_special_handler_001()
 {
-    struct signal_chain_action sigabrt = {
-        .sca_sigaction = sigchain_special_sigabrt_handler1,
+    struct signal_chain_action sigint = {
+        .sca_sigaction = sigchain_special_sigint_handler1,
         .sca_mask = {},
         .sca_flags = 0,
     };
-    add_special_signal_handler(SIGABRT, &sigabrt);
+    add_special_signal_handler(SIGINT, &sigint);
 
-    struct signal_chain_action sigabrt1 = {
-        .sca_sigaction = sigchain_special_sigabrt_handler2,
+    struct signal_chain_action sigint1 = {
+        .sca_sigaction = sigchain_special_sigint_handler2,
         .sca_mask = {},
         .sca_flags = SIGCHAIN_ALLOW_NORETURN,
     };
-    add_special_signal_handler(SIGABRT, &sigabrt1);
+    add_special_signal_handler(SIGINT, &sigint1);
 
     if (get_sigchain_mask_enable()) {
         sigset_t set = {0};
-        int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGABRT};
+        int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGINT};
         SIGCHAIN_TEST_SET_MASK(set, "sigchain_add_special_handler_001", signo, SIGCHIAN_TEST_SIGNAL_NUM_1);
     }
 
-    raise(SIGABRT);
+    raise(SIGINT);
     EXPECT_EQ("sigchain_add_special_handler_001", g_count, SIGCHIAN_TEST_SIGNAL_NUM_2);
 }
 
@@ -104,12 +104,13 @@ static void signal_sighup_handler(int signo)
 
 /**
  * @tc.name      : sigchain_add_special_handler_002
- * @tc.desc      : The signal are registered with the kernel(Using signal), call
+ * @tc.desc      : The signal is registered with the kernel(Using signal), call
  *                 add_special_signal_handler to add two special handlers
  * @tc.level     : Level 0
  */
 static void sigchain_add_special_handler_002()
 {
+    g_count = 0;
     signal(SIGHUP, signal_sighup_handler);
 
     struct signal_chain_action sighup = {
@@ -132,72 +133,73 @@ static void sigchain_add_special_handler_002()
         SIGCHAIN_TEST_SET_MASK(set, "sigchain_add_special_handler_002", signo, SIGCHIAN_TEST_SIGNAL_NUM_1);
     }
     raise(SIGHUP);
-    EXPECT_EQ("sigchain_add_special_handler_002", g_count, SIGCHIAN_TEST_SIGNAL_NUM_5);
+    EXPECT_EQ("sigchain_add_special_handler_002", g_count, SIGCHIAN_TEST_SIGNAL_NUM_3);
 }
 
 /**
  * @brief the special handler
  */
-static bool sigchain_special_sigsegv_handler1(int signo, siginfo_t *siginfo, void *ucontext_raw)
+static bool sigchain_special_sigusr2_handler1(int signo, siginfo_t *siginfo, void *ucontext_raw)
 {
     g_count++;
-    EXPECT_EQ("sigchain_add_special_handler_003", signo, SIGSEGV);
+    EXPECT_EQ("sigchain_add_special_handler_003", signo, SIGUSR2);
     return false;
 }
 
 /**
  * @brief the special handler
  */
-static bool sigchain_special_sigsegv_handler2(int signo, siginfo_t *siginfo, void *ucontext_raw)
+static bool sigchain_special_sigusr2_handler2(int signo, siginfo_t *siginfo, void *ucontext_raw)
 {
     g_count++;
-    EXPECT_EQ("sigchain_add_special_handler_003", signo, SIGSEGV);
+    EXPECT_EQ("sigchain_add_special_handler_003", signo, SIGUSR2);
     return false;
 }
 
 /**
  * @brief the signal handler
  */
-static void signal_sigsegv_sigaction(int signo)
+static void signal_sigusr2_sigaction(int signo)
 {
     g_count++;
-    EXPECT_EQ("sigchain_add_special_handler_003", signo, SIGSEGV);
+    EXPECT_EQ("sigchain_add_special_handler_003", signo, SIGUSR2);
 }
 
 /**
  * @tc.name      : sigchain_add_special_handler_003
- * @tc.desc      : the signal that are registered with the kernel(Using sigaction), call
+ * @tc.desc      : The signal is registered with the kernel(Using sigaction), call
  *                 add_special_signal_handler to add two special handlers
  * @tc.level     : Level 0
  */
 static void sigchain_add_special_handler_003()
 {
+    g_count = 0;
     struct sigaction sigac = {
-        .sa_handler = signal_sigsegv_sigaction,
+        .sa_handler = signal_sigusr2_sigaction,
     };
-    sigaction(SIGSEGV, &sigac, NULL);
+    sigaction(SIGUSR2, &sigac, NULL);
 
-    struct signal_chain_action sigsegv = {
-        .sca_sigaction = sigchain_special_sigsegv_handler1,
+    struct signal_chain_action sigusr2 = {
+        .sca_sigaction = sigchain_special_sigusr2_handler1,
         .sca_mask = {},
         .sca_flags = 0,
     };
-    add_special_signal_handler(SIGSEGV, &sigsegv);
+    add_special_signal_handler(SIGUSR2, &sigusr2);
 
-    struct signal_chain_action sigsegv2 = {
-        .sca_sigaction = sigchain_special_sigsegv_handler2,
+    struct signal_chain_action sigusr21 = {
+        .sca_sigaction = sigchain_special_sigusr2_handler2,
         .sca_mask = {},
         .sca_flags = 0,
     };
-    add_special_signal_handler(SIGSEGV, &sigsegv2);
+    add_special_signal_handler(SIGUSR2, &sigusr21);
 
     if (get_sigchain_mask_enable()) {
         sigset_t set = {0};
-        int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGSEGV};
+        int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGUSR2};
         SIGCHAIN_TEST_SET_MASK(set, "sigchain_add_special_handler_003", signo, SIGCHIAN_TEST_SIGNAL_NUM_1);
     }
-    raise(SIGSEGV);
-    EXPECT_EQ("sigchain_add_special_handler_003", g_count, SIGCHIAN_TEST_SIGNAL_NUM_8);
+    raise(SIGUSR2);
+    EXPECT_EQ("sigchain_add_special_handler_003", g_count, SIGCHIAN_TEST_SIGNAL_NUM_3);
 }
 
 /**
@@ -218,6 +220,7 @@ static bool sigchain_special_sigterm_handler(int signo, siginfo_t *siginfo, void
  */
 static void sigchain_add_special_handler_004()
 {
+    g_count = 0;
     struct signal_chain_action sigterm = {
         .sca_sigaction = sigchain_special_sigterm_handler,
         .sca_mask = {},
@@ -232,7 +235,7 @@ static void sigchain_add_special_handler_004()
     }
 
     raise(SIGTERM);
-    EXPECT_EQ("sigchain_add_special_handler_004", g_count, SIGCHIAN_TEST_SIGNAL_NUM_9);
+    EXPECT_EQ("sigchain_add_special_handler_004", g_count, SIGCHIAN_TEST_SIGNAL_NUM_1);
 }
 
 /**
@@ -262,6 +265,7 @@ static void signal_64_handler(int signo)
  */
 static void sigchain_add_special_handler_005()
 {
+    g_count = 0;
     signal(SIGCHAIN_SIGNAL_64, signal_64_handler);
 
     struct signal_chain_action sighup = {
@@ -277,7 +281,7 @@ static void sigchain_add_special_handler_005()
         SIGCHAIN_TEST_SET_MASK(set, "sigchain_add_special_handler_005", signo, SIGCHIAN_TEST_SIGNAL_NUM_1);
     }
     raise(SIGCHAIN_SIGNAL_64);
-    EXPECT_EQ("sigchain_add_special_handler_005", g_count, SIGCHIAN_TEST_SIGNAL_NUM_11);
+    EXPECT_EQ("sigchain_add_special_handler_005", g_count, SIGCHIAN_TEST_SIGNAL_NUM_2);
 }
 
 /**
@@ -307,6 +311,7 @@ static void signal_37_sigaction(int signo)
  */
 static void sigchain_add_special_handler_006()
 {
+    g_count = 0;
     struct sigaction sigac = {
         .sa_handler = signal_37_sigaction,
     };
@@ -326,7 +331,7 @@ static void sigchain_add_special_handler_006()
     }
 
     raise(SIGCHAIN_SIGNAL_37);
-    EXPECT_EQ("sigchain_add_special_handler_006", g_count, SIGCHIAN_TEST_SIGNAL_NUM_13);
+    EXPECT_EQ("sigchain_add_special_handler_006", g_count, SIGCHIAN_TEST_SIGNAL_NUM_2);
 }
 
 /**
@@ -345,7 +350,7 @@ static bool sigchain_special_43_handler(int signo, siginfo_t *siginfo, void *uco
 static void signal_43_sigaction(int signo)
 {
     g_count++;
-    EXPECT_FALSE("sigchain_intercept_sigprocmask_003", true);
+    EXPECT_FALSE("sigchain_add_special_handler_007", true);
 }
 
 /**
@@ -356,6 +361,7 @@ static void signal_43_sigaction(int signo)
  */
 static void sigchain_add_special_handler_007()
 {
+    g_count = 0;
     struct sigaction sigac = {
         .sa_handler = signal_43_sigaction,
     };
@@ -375,7 +381,126 @@ static void sigchain_add_special_handler_007()
     }
 
     raise(SIGCHAIN_SIGNAL_43);
-    EXPECT_EQ("sigchain_add_special_handler_007", g_count, SIGCHIAN_TEST_SIGNAL_NUM_14);
+    EXPECT_EQ("sigchain_add_special_handler_007", g_count, SIGCHIAN_TEST_SIGNAL_NUM_1);
+}
+
+
+/**
+ * @brief the special handler
+ */
+static bool sigchain_special_45_handler(int signo, siginfo_t *siginfo, void *ucontext_raw)
+{
+    g_count++;
+    EXPECT_EQ("sigchain_add_special_handler_008", signo, SIGCHAIN_SIGNAL_45);
+    return false;
+}
+
+/**
+ * @brief the signal handler
+ */
+static void signal_45_sigaction(int signo)
+{
+    g_count++;
+    EXPECT_EQ("sigchain_add_special_handler_008", signo, SIGCHAIN_SIGNAL_45);
+}
+
+/**
+ * @tc.name      : sigchain_add_special_handler_008
+ * @tc.desc      : There is no special handler, add the special at the last of the chains
+ * @tc.level     : Level 0
+ */
+static void sigchain_add_special_handler_008()
+{
+    g_count = 0;
+    struct sigaction sigac = {
+        .sa_handler = signal_45_sigaction,
+    };
+    sigaction(SIGCHAIN_SIGNAL_45, &sigac, NULL);
+
+    struct signal_chain_action sig45 = {
+        .sca_sigaction = sigchain_special_45_handler,
+        .sca_mask = {},
+        .sca_flags = 0,
+    };
+    add_special_handler_at_last(SIGCHAIN_SIGNAL_45, &sig45);
+
+    if (get_sigchain_mask_enable()) {
+        sigset_t set = {0};
+        int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGCHAIN_SIGNAL_45};
+        SIGCHAIN_TEST_SET_MASK(set, "sigchain_add_special_handler_008", signo, SIGCHIAN_TEST_SIGNAL_NUM_1);
+    }
+
+    raise(SIGCHAIN_SIGNAL_45);
+    EXPECT_EQ("sigchain_add_special_handler_008", g_count, SIGCHIAN_TEST_SIGNAL_NUM_2);
+}
+
+
+/**
+ * @brief the special handler
+ */
+static bool sigchain_special_56_handler1(int signo, siginfo_t *siginfo, void *ucontext_raw)
+{
+    g_count++;
+    EXPECT_EQ("sigchain_add_special_handler_009", signo, SIGCHAIN_SIGNAL_56);
+    EXPECT_EQ("sigchain_add_special_handler_009", g_count, SIGCHIAN_TEST_SIGNAL_NUM_2);
+    return false;
+}
+
+/**
+ * @brief the special handler
+ */
+static bool sigchain_special_56_handler2(int signo, siginfo_t *siginfo, void *ucontext_raw)
+{
+    g_count++;
+    EXPECT_EQ("sigchain_add_special_handler_009", signo, SIGCHAIN_SIGNAL_56);
+    EXPECT_EQ("sigchain_add_special_handler_009", g_count, SIGCHIAN_TEST_SIGNAL_NUM_1);
+    return false;
+}
+
+/**
+ * @brief the signal handler
+ */
+static void signal_56_sigaction(int signo)
+{
+    g_count++;
+    EXPECT_EQ("sigchain_add_special_handler_009", signo, SIGCHAIN_SIGNAL_56);
+}
+
+/**
+ * @tc.name      : sigchain_add_special_handler_009
+ * @tc.desc      : There are one special handler, add the special at the last of the chains
+ * @tc.level     : Level 0
+ */
+static void sigchain_add_special_handler_009()
+{
+    g_count = 0;
+    struct sigaction sigac = {
+        .sa_handler = signal_56_sigaction,
+    };
+    sigaction(SIGCHAIN_SIGNAL_56, &sigac, NULL);
+
+    struct signal_chain_action sig56 = {
+        .sca_sigaction = sigchain_special_56_handler2,
+        .sca_mask = {},
+        .sca_flags = 0,
+    };
+    add_special_signal_handler(SIGCHAIN_SIGNAL_56, &sig56);
+
+    struct signal_chain_action sig561 = {
+        .sca_sigaction = sigchain_special_56_handler1,
+        .sca_mask = {},
+        .sca_flags = 0,
+    };
+    add_special_handler_at_last(SIGCHAIN_SIGNAL_56, &sig561);
+
+    if (get_sigchain_mask_enable()) {
+        sigset_t set = {0};
+        int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGCHAIN_SIGNAL_56};
+        SIGCHAIN_TEST_SET_MASK(set, "sigchain_add_special_handler_009", signo, SIGCHIAN_TEST_SIGNAL_NUM_1);
+    }
+
+    raise(SIGCHAIN_SIGNAL_56);
+    EXPECT_EQ("sigchain_add_special_handler_009", g_count, SIGCHIAN_TEST_SIGNAL_NUM_3);
 }
 
 int main(void)
@@ -387,5 +512,7 @@ int main(void)
     sigchain_add_special_handler_005();
     sigchain_add_special_handler_006();
     sigchain_add_special_handler_007();
+    sigchain_add_special_handler_008();
+    sigchain_add_special_handler_009();
     return t_status;
 }
\ No newline at end of file

libc-test/src/functionalext/sigchain/sigchain_handler_call_order.c

@@ -29,9 +29,9 @@ static bool sigchain_special_handler(int signo, siginfo_t *siginfo, void *uconte
 {
     EXPECT_EQ("sigchain_handler_call_order_001", signo, SIGHUP);
     sigset_t set = {0};
-    int signal[SIGCHIAN_TEST_SIGNAL_NUM_2] = {SIGHUP, SIGSEGV};
-    SIGCHAIN_TEST_SET_MASK(set, "sigchain_intercept_sigprocmask_001", signal, SIGCHIAN_TEST_SIGNAL_NUM_2);
-    raise(SIGSEGV);
+    int signal[SIGCHIAN_TEST_SIGNAL_NUM_2] = {SIGHUP, SIGUSR2};
+    SIGCHAIN_TEST_SET_MASK(set, "sigchain_handler_call_order_001", signal, SIGCHIAN_TEST_SIGNAL_NUM_2);
+    raise(SIGUSR2);
     g_count++;
     return false;
 }
@@ -41,7 +41,7 @@ static bool sigchain_special_handler(int signo, siginfo_t *siginfo, void *uconte
  */
 static bool sigchain_special_handler1(int signo, siginfo_t *siginfo, void *ucontext_raw)
 {
-    EXPECT_EQ("sigchain_handler_call_order_001", signo, SIGSEGV);
+    EXPECT_EQ("sigchain_handler_call_order_001", signo, SIGUSR2);
     EXPECT_EQ("sigchain_handler_call_order_001", g_count, SIGCHIAN_TEST_SIGNAL_NUM_1);
     g_count++;
     return false;
@@ -58,13 +58,13 @@ static void signal_handler(int signo)
 /**
  * @tc.name      : sigchain_handler_call_order_001
  * @tc.desc      : The signals are registered with the special handler, and mask and rasie the signal
- *                 at the special handler. Test the influence of sigchain on sigprocmask.
+ *                 at the special handler. Test the influence of sigchain on pthread_sigmask.
  * @tc.level     : Level 0
  */
 static void sigchain_handler_call_order_001()
 {
     signal(SIGHUP, signal_handler);
-    signal(SIGSEGV, signal_handler);
+    signal(SIGUSR2, signal_handler);
 
     struct signal_chain_action sighup = {
         .sca_sigaction = sigchain_special_handler,
@@ -73,12 +73,12 @@ static void sigchain_handler_call_order_001()
     };
     add_special_signal_handler(SIGHUP, &sighup);
 
-    struct signal_chain_action sigsegv = {
+    struct signal_chain_action sigusr2 = {
         .sca_sigaction = sigchain_special_handler1,
         .sca_mask = {},
         .sca_flags = 0,
     };
-    add_special_signal_handler(SIGSEGV, &sigsegv);
+    add_special_signal_handler(SIGUSR2, &sigusr2);
 
     raise(SIGHUP);
     EXPECT_EQ("sigchain_handler_call_order_001", g_count, SIGCHIAN_TEST_SIGNAL_NUM_4);
@@ -89,7 +89,7 @@ static void sigchain_handler_call_order_001()
  */
 static bool sigchain_special_handler3(int signo, siginfo_t *siginfo, void *ucontext_raw)
 {
-    EXPECT_EQ("sigchain_handler_call_order_002", signo, SIGSYS);
+    EXPECT_EQ("sigchain_handler_call_order_002", signo, SIGPWR);
     g_count++;
     return false;
 }
@@ -99,8 +99,8 @@ static bool sigchain_special_handler3(int signo, siginfo_t *siginfo, void *ucont
  */
 static void signal_handler3(int signo)
 {
-    EXPECT_EQ("sigchain_handler_call_order_002", signo, SIGSYS);
-    EXPECT_EQ("sigchain_handler_call_order_002", g_count, SIGCHIAN_TEST_SIGNAL_NUM_5);
+    EXPECT_EQ("sigchain_handler_call_order_002", signo, SIGPWR);
+    EXPECT_EQ("sigchain_handler_call_order_002", g_count, SIGCHIAN_TEST_SIGNAL_NUM_1);
     g_count++;
     return;
 }
@@ -113,17 +113,18 @@ static void signal_handler3(int signo)
  */
 static void sigchain_handler_call_order_002()
 {
-    signal(SIGSYS, signal_handler3);
+    g_count = 0;
+    signal(SIGPWR, signal_handler3);
 
     struct signal_chain_action sigsegv = {
         .sca_sigaction = sigchain_special_handler3,
         .sca_mask = {},
         .sca_flags = 0,
     };
-    add_special_signal_handler(SIGSYS, &sigsegv);
+    add_special_signal_handler(SIGPWR, &sigsegv);
 
-    raise(SIGSYS);
-    EXPECT_EQ("sigchain_handler_call_order_002", g_count, SIGCHIAN_TEST_SIGNAL_NUM_6);
+    raise(SIGPWR);
+    EXPECT_EQ("sigchain_handler_call_order_002", g_count, SIGCHIAN_TEST_SIGNAL_NUM_2);
 }
 
 int main(void)

libc-test/src/functionalext/sigchain/sigchain_intercept_sigprocmask.c → libc-test/src/functionalext/sigchain/sigchain_intercept_pthread_sigmask.c

@@ -29,7 +29,7 @@ static int g_count = 0;
 static bool sigchain_special_handler2(int signo, siginfo_t *siginfo, void *ucontext_raw)
 {
     g_count++;
-    EXPECT_EQ("sigchain_intercept_sigprocmask_001", signo, SIGSEGV);
+    EXPECT_EQ("sigchain_intercept_pthread_sigmask_001", signo, SIGUSR2);
     return false;
 }
 
@@ -39,37 +39,37 @@ static bool sigchain_special_handler2(int signo, siginfo_t *siginfo, void *ucont
 static void signal_handler2(int signo)
 {
     g_count++;
-    EXPECT_EQ("sigchain_intercept_sigprocmask_001", signo, SIGSEGV);
+    EXPECT_EQ("sigchain_intercept_pthread_sigmask_001", signo, SIGUSR2);
 }
 
 /**
- * @tc.name      : sigchain_intercept_sigprocmask_001
- * @tc.desc      : The signals are registered with the special handler, test the influence of sigchain
- *                 on sigprocmask.
+ * @tc.name      : sigchain_intercept_pthread_sigmask_001
+ * @tc.desc      : The signal is registered with the special handler, test the influence of sigchain
+ *                 on pthread_sigmask.
  * @tc.level     : Level 0
  */
-static void sigchain_intercept_sigprocmask_001()
+static void sigchain_intercept_pthread_sigmask_001()
 {
     struct sigaction siga2 = {
         .sa_handler = signal_handler2,
     };
-    sigaction(SIGSEGV, &siga2, NULL);
+    sigaction(SIGUSR2, &siga2, NULL);
 
-    struct signal_chain_action sigsegv = {
+    struct signal_chain_action sigusr2 = {
         .sca_sigaction = sigchain_special_handler2,
         .sca_mask = {},
         .sca_flags = 0,
     };
-    add_special_signal_handler(SIGSEGV, &sigsegv);
+    add_special_signal_handler(SIGUSR2, &sigusr2);
 
     sigset_t set = {0};
-    int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGSEGV};
-    SIGCHAIN_TEST_SET_MASK(set, "sigchain_intercept_sigprocmask_001", signo, SIGCHIAN_TEST_SIGNAL_NUM_1);
-    raise(SIGSEGV);
+    int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGUSR2};
+    SIGCHAIN_TEST_SET_MASK(set, "sigchain_intercept_pthread_sigmask_001", signo, SIGCHIAN_TEST_SIGNAL_NUM_1);
+    raise(SIGUSR2);
     if (get_sigchain_mask_enable()) {
-        EXPECT_EQ("sigchain_intercept_sigprocmask_001", g_count, SIGCHIAN_TEST_SIGNAL_NUM_2);
+        EXPECT_EQ("sigchain_intercept_pthread_sigmask_001", g_count, SIGCHIAN_TEST_SIGNAL_NUM_2);
     } else {
-        EXPECT_EQ("sigchain_intercept_sigprocmask_001", g_count, 0);
+        EXPECT_EQ("sigchain_intercept_pthread_sigmask_001", g_count, 0);
     }
 }
 
@@ -79,7 +79,7 @@ static void sigchain_intercept_sigprocmask_001()
 static bool sigchain_special_handler3(int signo, siginfo_t *siginfo, void *ucontext_raw)
 {
     g_count++;
-    EXPECT_FALSE("sigchain_intercept_sigprocmask_002", true);
+    EXPECT_FALSE("sigchain_intercept_pthread_sigmask_002", true);
     return false;
 }
 
@@ -89,61 +89,62 @@ static bool sigchain_special_handler3(int signo, siginfo_t *siginfo, void *ucont
 static void signal_handler3(int signo)
 {
     g_count++;
-    EXPECT_EQ("sigchain_intercept_sigprocmask_002", signo, SIGSYS);
+    EXPECT_EQ("sigchain_intercept_pthread_sigmask_002", signo, SIGPWR);
 }
 
 /**
- * @tc.name      : sigchain_intercept_sigprocmask_002
+ * @tc.name      : sigchain_intercept_pthread_sigmask_002
  * @tc.desc      : The signals are registered with the special handler, and remove the special handler.
- *                 Test the influence of sigchain on sigprocmask.
+ *                 Test the influence of sigchain on pthread_sigmask.
  * @tc.level     : Level 0
  */
-static void sigchain_intercept_sigprocmask_002()
+static void sigchain_intercept_pthread_sigmask_002()
 {
+    g_count = 0;
     struct sigaction siga2 = {
         .sa_handler = signal_handler3,
     };
-    sigaction(SIGSYS, &siga2, NULL);
+    sigaction(SIGPWR, &siga2, NULL);
 
     struct signal_chain_action sigsegv = {
         .sca_sigaction = sigchain_special_handler3,
         .sca_mask = {},
         .sca_flags = 0,
     };
-    add_special_signal_handler(SIGSYS, &sigsegv);
+    add_special_signal_handler(SIGPWR, &sigsegv);
 
     sigset_t set = {0};
-    int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGSYS};
-    SIGCHAIN_TEST_SET_MASK(set, "sigchain_intercept_sigprocmask_002", signo, SIGCHIAN_TEST_SIGNAL_NUM_1);
+    int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGPWR};
+    SIGCHAIN_TEST_SET_MASK(set, "sigchain_intercept_pthread_sigmask_002", signo, SIGCHIAN_TEST_SIGNAL_NUM_1);
 
-    remove_special_signal_handler(SIGSYS, sigchain_special_handler3);
+    remove_special_signal_handler(SIGPWR, sigchain_special_handler3);
 
-    raise(SIGSYS);
+    raise(SIGPWR);
     if (get_sigchain_mask_enable()) {
-        EXPECT_EQ("sigchain_intercept_sigprocmask_002", g_count, SIGCHIAN_TEST_SIGNAL_NUM_3);
+        EXPECT_EQ("sigchain_intercept_pthread_sigmask_002", g_count, SIGCHIAN_TEST_SIGNAL_NUM_1);
     } else {
-        EXPECT_EQ("sigchain_intercept_sigprocmask_002", g_count, 0);
-    }  
+        EXPECT_EQ("sigchain_intercept_pthread_sigmask_002", g_count, 0);
+    }
 }
 
-
 /**
  * @brief the signal handler
  */
 static void signal_handler1(int signo)
 {
     g_count++;
-    EXPECT_FALSE("sigchain_intercept_sigprocmask_001", true);
+    EXPECT_FALSE("sigchain_intercept_pthread_sigmask_001", true);
 }
 
 /**
- * @tc.name      : sigchain_intercept_sigprocmask_003
+ * @tc.name      : sigchain_intercept_pthread_sigmask_003
  * @tc.desc      : The signals are not registered with the special handler, test the influence of sigchain
- *                 on sigprocmask.
+ *                 on pthread_sigmask.
  * @tc.level     : Level 0
  */
-static void sigchain_intercept_sigprocmask_003()
+static void sigchain_intercept_pthread_sigmask_003()
 {
+    g_count = 0;
     struct sigaction siga1 = {
         .sa_handler = signal_handler1,
     };
@@ -151,32 +152,29 @@ static void sigchain_intercept_sigprocmask_003()
 
     sigset_t set = {0};
     int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGHUP};
-    SIGCHAIN_TEST_SET_MASK(set, "sigchain_intercept_sigprocmask_003", signo, SIGCHIAN_TEST_SIGNAL_NUM_1);
+    SIGCHAIN_TEST_SET_MASK(set, "sigchain_intercept_pthread_sigmask_003", signo, SIGCHIAN_TEST_SIGNAL_NUM_1);
     raise(SIGHUP);
-    if (get_sigchain_mask_enable()) {
-        EXPECT_EQ("sigchain_intercept_sigprocmask_003", g_count, SIGCHIAN_TEST_SIGNAL_NUM_3);
-    } else {
-        EXPECT_EQ("sigchain_intercept_sigprocmask_003", g_count, 0);
-    }
+    EXPECT_EQ("sigchain_intercept_pthread_sigmask_003", g_count, 0);
 }
 
 /**
- * @tc.name      : sigchain_intercept_sigprocmask_004
- * @tc.desc      : The new set is null, call sigprocmask.
+ * @tc.name      : sigchain_intercept_pthread_sigmask_004
+ * @tc.desc      : The new set is null, call pthread_sigmask.
  * @tc.level     : Level 0
  */
-static void sigchain_intercept_sigprocmask_004()
+static void sigchain_intercept_pthread_sigmask_004()
 {
-    int result = sigprocmask(SIG_BLOCK, NULL, NULL);
-    if (result != 0) {                                    
-        EXPECT_FALSE("sigchain_intercept_sigprocmask_004", true);
-    }   
+    int result = pthread_sigmask(SIG_BLOCK, NULL, NULL);
+    if (result != 0) {
+        EXPECT_FALSE("sigchain_intercept_pthread_sigmask_004", true);
+    }
 }
+
 int main(void)
 {
-    sigchain_intercept_sigprocmask_001();
-    sigchain_intercept_sigprocmask_002();
-    sigchain_intercept_sigprocmask_003();
-    sigchain_intercept_sigprocmask_004();
+    sigchain_intercept_pthread_sigmask_001();
+    sigchain_intercept_pthread_sigmask_002();
+    sigchain_intercept_pthread_sigmask_003();
+    sigchain_intercept_pthread_sigmask_004();
     return t_status;
 }
\ No newline at end of file

libc-test/src/functionalext/sigchain/sigchain_intercept_sigaction.c

@@ -33,7 +33,7 @@ static void signal_handler1(int signo)
 
 /**
  * @tc.name      : sigchain_intercept_sigaction_001
- * @tc.desc      : The signals are not registered with the special handler, test the influence of sigchain
+ * @tc.desc      : The signal is not registered with the special handler, test the influence of sigchain
  *                 on sigaction.
  * @tc.level     : Level 0
  */
@@ -41,6 +41,7 @@ static void sigchain_intercept_sigaction_001()
 {
     struct sigaction siga1 = {
         .sa_handler = signal_handler1,
+        .sa_flags = SA_RESTART,
     };
     sigaction(SIGHUP, &siga1, NULL);
 
@@ -54,7 +55,7 @@ static void sigchain_intercept_sigaction_001()
 static bool sigchain_special_handler2(int signo, siginfo_t *siginfo, void *ucontext_raw)
 {
     g_count++;
-    EXPECT_EQ("sigchain_intercept_sigaction_002", signo, SIGSEGV);
+    EXPECT_EQ("sigchain_intercept_sigaction_002", signo, SIGUSR2);
     return false;
 }
 
@@ -64,37 +65,39 @@ static bool sigchain_special_handler2(int signo, siginfo_t *siginfo, void *ucont
 static void signal_handler2(int signo)
 {
     g_count++;
-    EXPECT_EQ("sigchain_intercept_sigaction_002", signo, SIGSEGV);
+    EXPECT_EQ("sigchain_intercept_sigaction_002", signo, SIGUSR2);
 }
 
 
 /**
  * @tc.name      : sigchain_intercept_sigaction_002
- * @tc.desc      : The signals are registered with the special handler, test the influence of sigchain on sigaction.
+ * @tc.desc      : The signals is registered with the special handler, test the influence of sigchain on sigaction.
  * @tc.level     : Level 0
  */
 static void sigchain_intercept_sigaction_002()
 {
-    struct signal_chain_action sigsegv = {
+    g_count = 0;
+    struct signal_chain_action sigusr2 = {
         .sca_sigaction = sigchain_special_handler2,
         .sca_mask = {},
         .sca_flags = 0,
     };
-    add_special_signal_handler(SIGSEGV, &sigsegv);
+    add_special_signal_handler(SIGUSR2, &sigusr2);
 
     struct sigaction siga2 = {
         .sa_handler = signal_handler2,
+        .sa_flags = SA_RESTART,
     };
-    sigaction(SIGSEGV, &siga2, NULL);
+    sigaction(SIGUSR2, &siga2, NULL);
 
     if (get_sigchain_mask_enable()) {
         sigset_t set = {0};
-        int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGSEGV};
+        int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGUSR2};
         SIGCHAIN_TEST_SET_MASK(set, "sigchain_intercept_sigaction_002", signo, SIGCHIAN_TEST_SIGNAL_NUM_1);
     }
 
-    raise(SIGSEGV);
-    EXPECT_EQ("sigchain_intercept_sigaction_002", g_count, SIGCHIAN_TEST_SIGNAL_NUM_3);
+    raise(SIGUSR2);
+    EXPECT_EQ("sigchain_intercept_sigaction_002", g_count, SIGCHIAN_TEST_SIGNAL_NUM_2);
 }
 
 /**
@@ -118,12 +121,13 @@ static void signal_handler3(int signo)
 
 /**
  * @tc.name      : sigchain_intercept_sigaction_003
- * @tc.desc      : the signals are registered with the special handler, and remove the special handler. Test
+ * @tc.desc      : the signal is registered with the special handler, and remove the special handler. Test
  *                 the influence of sigchain on sigaction.
  * @tc.level     : Level 0
  */
 static void sigchain_intercept_sigaction_003()
 {
+    g_count = 0;
     struct signal_chain_action sigurg = {
         .sca_sigaction = sigchain_special_handler3,
         .sca_mask = {},
@@ -133,19 +137,21 @@ static void sigchain_intercept_sigaction_003()
 
     struct sigaction siga2 = {
         .sa_handler = signal_handler3,
+        .sa_flags = SA_RESTART,
     };
     sigaction(SIGURG, &siga2, NULL);
 
     if (get_sigchain_mask_enable()) {
         sigset_t set = {0};
         int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGURG};
-        SIGCHAIN_TEST_SET_MASK(set, "sigchain_intercept_sigaction_002", signo, SIGCHIAN_TEST_SIGNAL_NUM_1);
+        SIGCHAIN_TEST_SET_MASK(set, "sigchain_intercept_sigaction_003", signo, SIGCHIAN_TEST_SIGNAL_NUM_1);
     }
 
     remove_special_signal_handler(SIGURG, sigchain_special_handler3);
     raise(SIGURG);
-    EXPECT_EQ("sigchain_intercept_sigaction_003", g_count, SIGCHIAN_TEST_SIGNAL_NUM_4);
+    EXPECT_EQ("sigchain_intercept_sigaction_003", g_count, SIGCHIAN_TEST_SIGNAL_NUM_1);
 }
+
 int main(void)
 {
     sigchain_intercept_sigaction_001();

libc-test/src/functionalext/sigchain/sigchain_intercept_signal.c

@@ -33,7 +33,7 @@ static void signal_handler1(int signo)
 
 /**
  * @tc.name      : sigchain_add_special_handler_025
- * @tc.desc      : The signals are not registered with the special handler, test the influence of sigchain on signal
+ * @tc.desc      : The signal is not registered with the special handler, test the influence of sigchain on signal
  * @tc.level     : Level 0
  */
 static void sigchain_intercept_signal_001()
@@ -49,7 +49,7 @@ static void sigchain_intercept_signal_001()
 static bool sigchain_special_handler1(int signo, siginfo_t *siginfo, void *ucontext_raw)
 {
     g_count++;
-    EXPECT_EQ("sigchain_intercept_signal_002", signo, SIGSEGV);
+    EXPECT_EQ("sigchain_intercept_signal_002", signo, SIGUSR2);
     return false;
 }
 
@@ -59,32 +59,33 @@ static bool sigchain_special_handler1(int signo, siginfo_t *siginfo, void *ucont
 static void signal_handler2(int signo)
 {
     g_count++;
-    EXPECT_EQ("sigchain_intercept_signal_002", signo, SIGSEGV);
+    EXPECT_EQ("sigchain_intercept_signal_002", signo, SIGUSR2);
 }
 
 /**
  * @tc.name      : sigchain_intercept_signal_002
- * @tc.desc      : The signals are registered with the special handler, test the influence of sigchain on signal
+ * @tc.desc      : The signal is registered with the special handler, test the influence of sigchain on signal
  * @tc.level     : Level 0
  */
 static void sigchain_intercept_signal_002()
 {
-    struct signal_chain_action sigsegv = {
+    g_count = 0;
+    struct signal_chain_action sigusr2 = {
         .sca_sigaction = sigchain_special_handler1,
         .sca_mask = {},
         .sca_flags = 0,
     };
-    add_special_signal_handler(SIGSEGV, &sigsegv);
+    add_special_signal_handler(SIGUSR2, &sigusr2);
 
-    signal(SIGSEGV, signal_handler2);
+    signal(SIGUSR2, signal_handler2);
 
     if (get_sigchain_mask_enable()) {
         sigset_t set = {0};
-        int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGSEGV};
+        int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGUSR2};
         SIGCHAIN_TEST_SET_MASK(set, "sigchain_intercept_signal_002", signo, SIGCHIAN_TEST_SIGNAL_NUM_1);
     }
-    raise(SIGSEGV);
-    EXPECT_EQ("sigchain_intercept_signal_002", g_count, SIGCHIAN_TEST_SIGNAL_NUM_3);
+    raise(SIGUSR2);
+    EXPECT_EQ("sigchain_intercept_signal_002", g_count, SIGCHIAN_TEST_SIGNAL_NUM_2);
 }
 
 /**
@@ -109,12 +110,13 @@ static void signal_handler3(int signo)
 
 /**
  * @tc.name      : sigchain_intercept_signal_003
- * @tc.desc      : The signals are registered with the special handler, and remove the special handler.
+ * @tc.desc      : The signal is registered with the special handler, and remove the special handler.
  *                 Test the influence of sigchain on signal
  * @tc.level     : Level 0
  */
 static void sigchain_intercept_signal_003()
 {
+    g_count = 0;
     struct signal_chain_action sigurg = {
         .sca_sigaction = sigchain_special_handler3,
         .sca_mask = {},
@@ -126,13 +128,8 @@ static void sigchain_intercept_signal_003()
 
     remove_special_signal_handler(SIGURG, sigchain_special_handler3);
 
-    if (get_sigchain_mask_enable()) {
-        sigset_t set = {0};
-        int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGURG};
-        SIGCHAIN_TEST_SET_MASK(set, "sigchain_intercept_sigaction_002", signo, SIGCHIAN_TEST_SIGNAL_NUM_1);
-    }
     raise(SIGURG);
-    EXPECT_EQ("sigchain_intercept_signal_003", g_count, SIGCHIAN_TEST_SIGNAL_NUM_4);
+    EXPECT_EQ("sigchain_intercept_signal_003", g_count, SIGCHIAN_TEST_SIGNAL_NUM_1);
 }
 int main(void)
 {

libc-test/src/functionalext/sigchain/sigchain_rm_special_handler.c

@@ -43,35 +43,35 @@ static bool sigchain_special_sigabrt_handler2(int signo, siginfo_t *siginfo, voi
 
 /**
  * @tc.name      : sigchain_rm_special_handler_001
- * @tc.desc      : The signal are not registered with the kernel, call remove_special_signal_handler to remove
+ * @tc.desc      : The signal is not registered with the kernel, call remove_special_signal_handler to remove
  *                 two special handlers
  * @tc.level     : Level 0
  */
 static void sigchain_rm_special_handler_001()
 {
-    struct signal_chain_action sigabrt = {
+    struct signal_chain_action sigcont = {
         .sca_sigaction = sigchain_special_sigabrt_handler1,
         .sca_mask = {},
         .sca_flags = 0,
     };
-    add_special_signal_handler(SIGABRT, &sigabrt);
+    add_special_signal_handler(SIGCONT, &sigcont);
 
-    struct signal_chain_action sigabrt1 = {
+    struct signal_chain_action sigcont1 = {
         .sca_sigaction = sigchain_special_sigabrt_handler2,
         .sca_mask = {},
         .sca_flags = SIGCHAIN_ALLOW_NORETURN,
     };
-    add_special_signal_handler(SIGABRT, &sigabrt1);
+    add_special_signal_handler(SIGCONT, &sigcont1);
 
     if (get_sigchain_mask_enable()) {
         sigset_t set = {0};
-        int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGABRT};
+        int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGCONT};
         SIGCHAIN_TEST_SET_MASK(set, "sigchain_rm_special_handler_001", signo, SIGCHIAN_TEST_SIGNAL_NUM_1);
     }
-    remove_special_signal_handler(SIGABRT, sigchain_special_sigabrt_handler1);
-    remove_special_signal_handler(SIGABRT, sigchain_special_sigabrt_handler2);
+    remove_special_signal_handler(SIGCONT, sigchain_special_sigabrt_handler1);
+    remove_special_signal_handler(SIGCONT, sigchain_special_sigabrt_handler2);
 
-    raise(SIGABRT);
+    raise(SIGCONT);
     EXPECT_EQ("sigchain_rm_special_handler_001", g_count, 0);
 }
 
@@ -106,12 +106,13 @@ static void signal_sighup_handler(int signo)
 
 /**
  * @tc.name      : sigchain_rm_special_handler_002
- * @tc.desc      : The signal are registered with the kernel(Using signal), call
+ * @tc.desc      : The signal is registered with the kernel(Using signal), call
  *                 remove_special_signal_handler to remove two special handlers
  * @tc.level     : Level 0
  */
 static void sigchain_rm_special_handler_002()
 {
+    g_count = 0;
     signal(SIGHUP, signal_sighup_handler);
 
     struct signal_chain_action sighup = {
@@ -143,7 +144,7 @@ static void sigchain_rm_special_handler_002()
 /**
  * @brief the special handler
  */
-static bool sigchain_special_sigsegv_handler1(int signo, siginfo_t *siginfo, void *ucontext_raw)
+static bool sigchain_special_sigusr2_handler1(int signo, siginfo_t *siginfo, void *ucontext_raw)
 {
     g_count++;
     EXPECT_FALSE("sigchain_rm_special_handler_003", true);
@@ -153,7 +154,7 @@ static bool sigchain_special_sigsegv_handler1(int signo, siginfo_t *siginfo, voi
 /**
  * @brief the special handler
  */
-static bool sigchain_special_sigsegv_handler2(int signo, siginfo_t *siginfo, void *ucontext_raw)
+static bool sigchain_special_sigusr2_handler2(int signo, siginfo_t *siginfo, void *ucontext_raw)
 {
     g_count++;
     EXPECT_FALSE("sigchain_rm_special_handler_003", true);
@@ -163,49 +164,50 @@ static bool sigchain_special_sigsegv_handler2(int signo, siginfo_t *siginfo, voi
 /**
  * @brief the signal handler
  */
-static void signal_sigsegv_sigaction(int signo)
+static void signal_sigusr2_sigaction(int signo)
 {
     g_count++;
-    EXPECT_EQ("sigchain_rm_special_handler_003", signo, SIGSEGV);
+    EXPECT_EQ("sigchain_rm_special_handler_003", signo, SIGUSR2);
 }
 
 /**
  * @tc.name      : sigchain_rm_special_handler_003
- * @tc.desc      : the signal that are registered with the kernel(Using sigaction), call
+ * @tc.desc      : The signal is registered with the kernel(Using sigaction), call
  *                 remove_special_signal_handler to remove two special handlers
  * @tc.level     : Level 0
  */
 static void sigchain_rm_special_handler_003()
 {
+    g_count = 0;
     struct sigaction sigac = {
-        .sa_handler = signal_sigsegv_sigaction,
+        .sa_handler = signal_sigusr2_sigaction,
     };
-    sigaction(SIGSEGV, &sigac, NULL);
+    sigaction(SIGUSR2, &sigac, NULL);
 
-    struct signal_chain_action sigsegv = {
-        .sca_sigaction = sigchain_special_sigsegv_handler1,
+    struct signal_chain_action sigusr2 = {
+        .sca_sigaction = sigchain_special_sigusr2_handler1,
         .sca_mask = {},
         .sca_flags = 0,
     };
-    add_special_signal_handler(SIGSEGV, &sigsegv);
+    add_special_signal_handler(SIGUSR2, &sigusr2);
 
-    struct signal_chain_action sigsegv2 = {
-        .sca_sigaction = sigchain_special_sigsegv_handler2,
+    struct signal_chain_action sigusr21 = {
+        .sca_sigaction = sigchain_special_sigusr2_handler2,
         .sca_mask = {},
         .sca_flags = 0,
     };
-    add_special_signal_handler(SIGSEGV, &sigsegv2);
+    add_special_signal_handler(SIGUSR2, &sigusr21);
 
     if (get_sigchain_mask_enable()) {
         sigset_t set = {0};
-        int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGSEGV};
+        int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGUSR2};
         SIGCHAIN_TEST_SET_MASK(set, "sigchain_rm_special_handler_003", signo, SIGCHIAN_TEST_SIGNAL_NUM_1);
     }
 
-    remove_special_signal_handler(SIGSEGV, sigchain_special_sigsegv_handler1);
-    remove_special_signal_handler(SIGSEGV, sigchain_special_sigsegv_handler2);
-    raise(SIGSEGV);
-    EXPECT_EQ("sigchain_rm_special_handler_003", g_count, SIGCHIAN_TEST_SIGNAL_NUM_2);
+    remove_special_signal_handler(SIGUSR2, sigchain_special_sigusr2_handler1);
+    remove_special_signal_handler(SIGUSR2, sigchain_special_sigusr2_handler2);
+    raise(SIGUSR2);
+    EXPECT_EQ("sigchain_rm_special_handler_003", g_count, SIGCHIAN_TEST_SIGNAL_NUM_1);
 }
 
 /**
@@ -220,29 +222,30 @@ static bool sigchain_special_sigterm_handler(int signo, siginfo_t *siginfo, void
 
 /**
  * @tc.name      : sigchain_rm_special_handler_004
- * @tc.desc      : the signal is not registered with the kernel, call remove_special_signal_handler to remove
+ * @tc.desc      : The signal is not registered with the kernel, call remove_special_signal_handler to remove
  *                 a special handler.
  * @tc.level     : Level 0
  */
 static void sigchain_rm_special_handler_004()
 {
-    struct signal_chain_action sigsegv = {
+    g_count = 0;
+    struct signal_chain_action sigcont = {
         .sca_sigaction = sigchain_special_sigterm_handler,
         .sca_mask = {},
         .sca_flags = 0,
     };
-    add_special_signal_handler(SIGTERM, &sigsegv);
+    add_special_signal_handler(SIGCONT, &sigcont);
 
 
     if (get_sigchain_mask_enable()) {
         sigset_t set = {0};
-        int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGTERM};
+        int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGCONT};
         SIGCHAIN_TEST_SET_MASK(set, "sigchain_rm_special_handler_004", signo, SIGCHIAN_TEST_SIGNAL_NUM_1);
     }
-    remove_special_signal_handler(SIGTERM, sigchain_special_sigterm_handler);
+    remove_special_signal_handler(SIGCONT, sigchain_special_sigterm_handler);
 
-    raise(SIGTERM);
-    EXPECT_EQ("sigchain_rm_special_handler_004", g_count, SIGCHIAN_TEST_SIGNAL_NUM_2);
+    raise(SIGCONT);
+    EXPECT_EQ("sigchain_rm_special_handler_004", g_count, 0);
 }
 
 /**
@@ -266,15 +269,15 @@ static void signal_64_handler(int signo)
 
 /**
  * @tc.name      : sigchain_rm_special_handler_005
- * @tc.desc      : the signal is registered with the kernel(Using signal), call remove_special_signal_handler to remove
+ * @tc.desc      : The signal is registered with the kernel(Using signal), call remove_special_signal_handler to remove
  *                 a special handler.
  * @tc.level     : Level 0
  */
 static void sigchain_rm_special_handler_005()
 {
+    g_count = 0;
     signal(SIGCHAIN_SIGNAL_64, signal_64_handler);
 
-
     struct signal_chain_action sighup = {
         .sca_sigaction = sigchain_special_64_handler,
         .sca_mask = {},
@@ -290,7 +293,7 @@ static void sigchain_rm_special_handler_005()
     remove_special_signal_handler(SIGCHAIN_SIGNAL_64, sigchain_special_64_handler);
 
     raise(SIGCHAIN_SIGNAL_64);
-    EXPECT_EQ("sigchain_rm_special_handler_005", g_count, SIGCHIAN_TEST_SIGNAL_NUM_3);
+    EXPECT_EQ("sigchain_rm_special_handler_005", g_count, SIGCHIAN_TEST_SIGNAL_NUM_1);
 }
 
 /**
@@ -314,12 +317,13 @@ static void signal_37_sigaction(int signo)
 
 /**
  * @tc.name      : sigchain_rm_special_handler_006
- * @tc.desc      : the signal is registered with the kernel(Using sigaction), call remove_special_signal_handler
+ * @tc.desc      : The signal is registered with the kernel(Using sigaction), call remove_special_signal_handler
  *                 to remove a special handler.
  * @tc.level     : Level 0
  */
 static void sigchain_rm_special_handler_006()
 {
+    g_count = 0;
     struct sigaction sigac = {
         .sa_handler = signal_37_sigaction,
     };
@@ -340,7 +344,72 @@ static void sigchain_rm_special_handler_006()
     remove_special_signal_handler(SIGCHAIN_SIGNAL_37, sigchain_special_37_handler);
 
     raise(SIGCHAIN_SIGNAL_37);
-    EXPECT_EQ("sigchain_rm_special_handler_006", g_count, SIGCHIAN_TEST_SIGNAL_NUM_4);
+    EXPECT_EQ("sigchain_rm_special_handler_006", g_count, SIGCHIAN_TEST_SIGNAL_NUM_1);
+}
+
+/**
+ * @brief the special handler
+ */
+static bool sigchain_special_quit_handler(int signo, siginfo_t *siginfo, void *ucontext_raw)
+{
+    g_count++;
+    EXPECT_FALSE("sigchain_rm_all_special_handler_007", true);
+    return false;
+}
+
+static bool sigchain_special_quit_handler1(int signo, siginfo_t *siginfo, void *ucontext_raw)
+{
+    g_count++;
+    EXPECT_FALSE("sigchain_rm_all_special_handler_007", true);
+    return false;
+}
+
+/**
+ * @brief the signal handler
+ */
+static void signal_quit_sigaction(int signo)
+{
+    g_count++;
+    EXPECT_EQ("sigchain_rm_all_special_handler_007", signo, SIGQUIT);
+}
+
+/**
+ * @tc.name      : sigchain_rm_all_special_handler_007
+ * @tc.desc      : The signal is registered with the kernel(Using sigaction), call remove_special_signal_handler
+ *                 to remove a special handler.
+ * @tc.level     : Level 0
+ */
+static void sigchain_rm_all_special_handler_007()
+{
+    g_count = 0;
+    struct sigaction sigac = {
+        .sa_handler = signal_quit_sigaction,
+    };
+    sigaction(SIGQUIT, &sigac, NULL);
+
+    struct signal_chain_action sigquit = {
+        .sca_sigaction = sigchain_special_quit_handler,
+        .sca_mask = {},
+        .sca_flags = 0,
+    };
+    add_special_signal_handler(SIGQUIT, &sigquit);
+
+    struct signal_chain_action sigquit1 = {
+        .sca_sigaction = sigchain_special_quit_handler1,
+        .sca_mask = {},
+        .sca_flags = 0,
+    };
+    add_special_signal_handler(SIGQUIT, &sigquit1);
+
+    if (get_sigchain_mask_enable()) {
+        sigset_t set = {0};
+        int signo[SIGCHIAN_TEST_SIGNAL_NUM_1] = {SIGQUIT};
+        SIGCHAIN_TEST_SET_MASK(set, "sigchain_rm_all_special_handler_007", signo, SIGCHIAN_TEST_SIGNAL_NUM_1);
+    }
+    remove_all_special_handler(SIGQUIT);
+
+    raise(SIGQUIT);
+    EXPECT_EQ("sigchain_rm_all_special_handler_007", g_count, SIGCHIAN_TEST_SIGNAL_NUM_1);
 }
 
 int main(void)
@@ -351,5 +420,6 @@ int main(void)
     sigchain_rm_special_handler_004();
     sigchain_rm_special_handler_005();
     sigchain_rm_special_handler_006();
+    sigchain_rm_all_special_handler_007();
     return t_status;
 }
\ No newline at end of file

libc-test/src/functionalext/sigchain/test_src_functionalext_sigchain.gni

@@ -15,6 +15,6 @@ functionalext_sigchain_list = [
   "sigchain_rm_special_handler",
   "sigchain_intercept_sigaction",
   "sigchain_intercept_signal",
-  "sigchain_intercept_sigprocmask",
+  "sigchain_intercept_pthread_sigmask",
   "sigchain_handler_call_order",
 ]

libc.map.txt

@@ -309,6 +309,7 @@
     acoshl;
     acosl;
     addmntent;
+    add_special_handler_at_last;
     add_special_signal_handler;
     adjtime;
     adjtimex;
@@ -1487,6 +1488,7 @@
     remainderl;
     remap_file_pages;
     remove;
+    remove_all_special_handler;
     remove_special_signal_handler;
     removexattr;
     remque;

musl_src.gni

@@ -2122,6 +2122,7 @@ musl_src_porting_file = [
   "src/thread/pthread_rwlock_clockwrlock.c",
   "src/thread/pthread_rwlock_timedwrlock_monotonic_np.c",
   "src/thread/pthread_rwlock_timedwrlock.c",
+  "src/thread/pthread_sigmask.c",
   "src/trace/trace_marker.c",
   "src/ldso/dlclose.c",
   "src/ldso/dlerror.c",
@@ -2142,7 +2143,7 @@ musl_src_porting_file = [
   "src/sched/sched_cpualloc.c",
   "src/signal/signal.c",
   "src/signal/sigaction.c",
-  "src/signal/sigprocmask.c",
+  "src/signal/siginterrupt.c",
   "include/langinfo.h",
   "include/locale.h",
   "src/hilog/hilog_adapter.c",

porting/linux/user/include/sigchain.h

@@ -38,8 +38,12 @@ struct signal_chain_action {
 
 /* Mark the signal to the sigchain, add the special handler to the sigchain. */
 void add_special_signal_handler(int signo, struct signal_chain_action* sa);
-/* Remove the special the handler form the sigchain. */
+/* Add the special handler at the last of sigchain chains */
+void add_special_handler_at_last(int signo, struct signal_chain_action* sa);
+/* Remove the special the handler from the sigchain. */
 void remove_special_signal_handler(int signo, bool (*fn)(int, siginfo_t*, void*));
+/* Remove all special the handler from the sigchain */
+void remove_all_special_handler(int signo);
 
 #ifdef __cplusplus
 }

porting/linux/user/src/sigchain/sigchain.c

@@ -20,6 +20,8 @@
 #include <threads.h>
 #include <hilog_adapter.h>
 #include <stdlib.h>
+#include <errno.h>
+#include "syscall.h"
 
 extern int __libc_sigaction(int sig, const struct sigaction *restrict sa,
                             struct sigaction *restrict old);
@@ -73,12 +75,11 @@ static void create_pthread_key(void)
     SIGCHAIN_PRINT_INFO("%{public}s create the thread key!", __func__);
     int rc = pthread_key_create(&g_sigchain_key, NULL);
     if (rc != 0) {
-        SIGCHAIN_PRINT_ERROR("%{public}s failed to create sigchain pthread key, rc:%{public}d",
+        SIGCHAIN_PRINT_FATAL("%{public}s failed to create sigchain pthread key, rc:%{public}d",
                 __func__,  rc);
     }
 }
 
-
 /**
   * @brief Get the key of the signal thread.
   * @retval int32_t, the value of the sigchain key.
@@ -110,12 +111,34 @@ static void set_handling_signal(bool value)
                         (void *)((uintptr_t)(value)));
 }
 
+/**
+  * @brief Set the mask of the system. Its prototype comes from pthread_sigmask.
+  * @param[in] how, the value of the mask operation .
+  * @param[in] set, the new value of the sigset.
+  * @param[in] old, the old value of the sigset.
+  */
+static int sigchain_sigmask(int how, const sigset_t *restrict set, sigset_t *restrict old)
+{
+    int ret;
+    if (set && (unsigned)how - SIG_BLOCK > 2U) return EINVAL;
+    ret = -__syscall(SYS_rt_sigprocmask, how, set, old, _NSIG/8);
+    if (!ret && old) {
+        if (sizeof old->__bits[0] == 8) {
+            old->__bits[0] &= ~0x380000000ULL;
+        } else {
+            old->__bits[0] &= ~0x80000000UL;
+            old->__bits[1] &= ~0x3UL;
+        }
+    }
+    return ret;
+}
+
 /**
   * @brief Judge whether the signal is marked
   * @param[in] signo, the value of the signal.
   * @retval true if the signal is marked, or false.
   */
-bool ismarked(int signo)
+static bool ismarked(int signo)
 {
     return sig_chains[signo - 1].marked;
 }
@@ -135,13 +158,13 @@ static void signal_chain_handler(int signo, siginfo_t* siginfo, void* ucontext_r
     if (!get_handling_signal()) {
         for (int i = 0; i < SIGNAL_CHAIN_SPECIAL_ACTION_MAX; i++) {
             if (sig_chains[signo - 1].sca_special_actions[i].sca_sigaction == NULL) {
-                break;
+                continue;
             }
             /* The special handler might not return. */
             bool noreturn = (sig_chains[signo - 1].sca_special_actions[i].sca_flags &
                              SIGCHAIN_ALLOW_NORETURN);
             sigset_t previous_mask;
-            pthread_sigmask(SIG_SETMASK, &sig_chains[signo - 1].sca_special_actions[i].sca_mask,
+            sigchain_sigmask(SIG_SETMASK, &sig_chains[signo - 1].sca_special_actions[i].sca_mask,
                             &previous_mask);
 
             bool previous_value =  get_handling_signal();
@@ -155,7 +178,7 @@ static void signal_chain_handler(int signo, siginfo_t* siginfo, void* ucontext_r
                 return;
             }
 
-            pthread_sigmask(SIG_SETMASK, &previous_mask, NULL);
+            sigchain_sigmask(SIG_SETMASK, &previous_mask, NULL);
             set_handling_signal(previous_value);
         }
     }
@@ -170,7 +193,7 @@ static void signal_chain_handler(int signo, siginfo_t* siginfo, void* ucontext_r
         sigaddset(&mask, signo);
     }
 
-    pthread_sigmask(SIG_SETMASK, &mask, NULL);
+    sigchain_sigmask(SIG_SETMASK, &mask, NULL);
 
     if ((sa_flags & SA_SIGINFO)) {
         sig_chains[signo - 1].sig_action.sa_sigaction(signo, siginfo, ucontext_raw);
@@ -178,7 +201,7 @@ static void signal_chain_handler(int signo, siginfo_t* siginfo, void* ucontext_r
         if (sig_chains[signo - 1].sig_action.sa_handler == SIG_IGN) {
             return;
         } else if (sig_chains[signo - 1].sig_action.sa_handler == SIG_DFL) {
-            SIGCHAIN_PRINT_INFO("%{public}s exiting due to SIG_DFL handler for signal: %{public}d",
+            SIGCHAIN_PRINT_FATAL("%{public}s exiting due to SIG_DFL handler for signal: %{public}d",
                     __func__, signo);
         } else {
             sig_chains[signo - 1].sig_action.sa_handler(signo);
@@ -204,6 +227,18 @@ static void sigchain_register(int signo)
     __libc_sigaction(signo, &signal_action, &sig_chains[signo - 1].sig_action);
 }
 
+/**
+  * @brief Unregister the signal from sigchain, register the signal's user handler with the kernel if needed
+  * @param[in] signo, the value of the signal.
+  * @retval void
+  */
+static void unregister_sigchain(int signo)
+{
+    SIGCHAIN_PRINT_INFO("%{public}s signo: %{public}d", __func__, signo);
+    __libc_sigaction(signo, &sig_chains[signo - 1].sig_action, NULL);
+    sig_chains[signo - 1].marked = false;
+}
+
 /**
   * @brief Mark the signal to the sigchain.
   * @param[in] signo, the value of the signal.
@@ -247,7 +282,7 @@ static struct sigaction getaction(int signo)
   * @param[in] sa, the action with special handler.
   * @retval void
   */
-void add_special_handler(int signo, struct signal_chain_action* sa)
+static void add_special_handler(int signo, struct signal_chain_action* sa)
 {
     SIGCHAIN_PRINT_INFO("%{public}s signo: %{public}d", __func__, signo);
     for (int i = 0; i < SIGNAL_CHAIN_SPECIAL_ACTION_MAX; i++) {
@@ -267,17 +302,22 @@ void add_special_handler(int signo, struct signal_chain_action* sa)
   * @param[in] fn, the special handler of the signal.
   * @retval void
   */
-void rm_special_handler(int signo, bool (*fn)(int, siginfo_t*, void*))
+static void rm_special_handler(int signo, bool (*fn)(int, siginfo_t*, void*))
 {
     SIGCHAIN_PRINT_INFO("%{public}s signo: %{public}d", __func__, signo);
     int len = SIGNAL_CHAIN_SPECIAL_ACTION_MAX;
     for (int i = 0; i < len; i++) {
         if (sig_chains[signo - 1].sca_special_actions[i].sca_sigaction == fn) {
-            for (int j = i; j < len - 1; ++j) {
-                sig_chains[signo - 1].sca_special_actions[j] = 
-                        sig_chains[signo - 1].sca_special_actions[j + 1];
+            sig_chains[signo - 1].sca_special_actions[i].sca_sigaction = NULL;
+            int count = 0;
+            for (int k = 0; k < len; k++) {
+                if (sig_chains[signo - 1].sca_special_actions[k].sca_sigaction == NULL) {
+                    count++;
+                }
+            }
+            if (count == len) {
+                unregister_sigchain(signo);
             }
-            sig_chains[signo - 1].sca_special_actions[len - 1].sca_sigaction = NULL;
             return;
         }
     }
@@ -319,8 +359,56 @@ void remove_special_signal_handler(int signo, bool (*fn)(int, siginfo_t*, void*)
         SIGCHAIN_PRINT_FATAL("%{public}s Invalid signal %{public}d", __func__, signo);
         return;
     }
-    // remove the special handler from the sigchain.
-    rm_special_handler(signo, fn);
+
+    if (ismarked(signo)) {
+        // remove the special handler from the sigchain.
+        rm_special_handler(signo, fn);
+    }
+}
+
+/**
+  * @brief This is an external interface, remove all special handler from the sigchain.
+  * @param[in] signo, the value of the signal.
+  * @retval void
+  */
+void remove_all_special_handler(int signo)
+{
+    SIGCHAIN_PRINT_INFO("%{public}s signo: %{public}d", __func__, signo);
+    if (signo <= 0 || signo >= _NSIG) {
+        SIGCHAIN_PRINT_FATAL("%{public}s Invalid signal %{public}d", __func__, signo);
+        return;
+    }
+
+    if (ismarked(signo)) {
+        // remove all special handler from the sigchain.
+        for (int i = 0; i < SIGNAL_CHAIN_SPECIAL_ACTION_MAX; i++) {
+            sig_chains[signo - 1].sca_special_actions[i].sca_sigaction = NULL;
+        }
+        unregister_sigchain(signo);
+    }
+}
+
+/**
+  * @brief This is an external interface, add the special handler at the last of sigchain chains.
+  * @param[in] signo, the value of the signal.
+  * @param[in] sa, the action with special handler.
+  * @retval void
+  */
+void add_special_handler_at_last(int signo, struct signal_chain_action* sa)
+{
+    SIGCHAIN_PRINT_INFO("%{public}s signo: %{public}d", __func__, signo);
+    if (signo <= 0 || signo >= _NSIG) {
+        SIGCHAIN_PRINT_FATAL("%{public}s Invalid signal %{public}d", __func__, signo);
+        return;
+    }
+
+    if (sig_chains[signo - 1].sca_special_actions[SIGNAL_CHAIN_SPECIAL_ACTION_MAX - 1].sca_sigaction == NULL) {
+        sig_chains[signo - 1].sca_special_actions[SIGNAL_CHAIN_SPECIAL_ACTION_MAX - 1] = *sa;
+        mark_signal_to_sigchain(signo);
+        return;
+    }
+
+    SIGCHAIN_PRINT_FATAL("Add too many the special handlers at last!");
 }
 
 /**
@@ -355,15 +443,15 @@ bool intercept_sigaction(int signo, const struct sigaction *restrict sa,
 }
 
 /**
-  * @brief Intercept the sigprocmask.
+  * @brief Intercept the pthread_sigmask.
   * @param[in] how, the value of the mask operation .
   * @param[out] set, the value of the sigset.
   * @retval void.
   */
-void intercept_sigprocmask(int how, sigset_t *restrict set)
+void intercept_pthread_sigmask(int how, sigset_t *restrict set)
 {
     SIGCHAIN_PRINT_DEBUG("%{public}s how: %{public}d", __func__, how);
-    // Forward directly to the pthread_sigmask When this sigchain is handling a signal.
+    // Forward directly to the system mask When this sigchain is handling a signal.
     if (get_handling_signal()) {
         return;
     }

porting/linux/user/src/signal/sigaction.c

+/*
+ * Copyright (c) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #include <signal.h>
 #include <errno.h>
 #include <string.h>
@@ -85,10 +100,11 @@ int __sigaction(int sig, const struct sigaction *restrict sa, struct sigaction *
 		errno = EINVAL;
 		return -1;
 	}
+	/* sigchain intercepts sigaction */
 	if (intercept_sigaction(sig, sa, old)) {
 		return 0;
 	}
-	
+
 	return __libc_sigaction(sig, sa, old);
 }
 

porting/linux/user/src/signal/siginterrupt.c

+/*
+ * Copyright (c) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <signal.h>
+#include <errno.h>
+
+extern int __libc_sigaction(int sig, const struct sigaction *restrict sa, struct sigaction *restrict old);
+
+int siginterrupt(int sig, int flag)
+{
+	if (sig-32U < 3 || sig-1U >= _NSIG-1) {
+		errno = EINVAL;
+		return -1;
+	}
+	struct sigaction sa;
+
+	__libc_sigaction(sig, 0, &sa);
+	if (flag) sa.sa_flags &= ~SA_RESTART;
+	else sa.sa_flags |= SA_RESTART;
+
+	return __libc_sigaction(sig, &sa, 0);
+}

porting/linux/user/src/signal/sigprocmask.c

-#include <signal.h>
-#include <errno.h>
-#include <sigchain.h>
-#include <stddef.h>
-#include <hilog_adapter.h>
-#include <string.h>
-#ifdef OHOS_ENABLE_PARAMETER
-#include "sys_param.h"
-#endif
-
-extern void intercept_sigprocmask(int how, sigset_t *restrict set);
-static const char *param_name = "musl.sigchain.procmask";
-
-bool get_sigchain_mask_enable()
-{
-#ifdef OHOS_ENABLE_PARAMETER
-    static CachedHandle sigchain_procmask_handle = NULL;
-    if (sigchain_procmask_handle == NULL) {
-        sigchain_procmask_handle = CachedParameterCreate(param_name, "false");
-    }
-    char *param_value = CachedParameterGet(sigchain_procmask_handle);
-    if (param_value != NULL) {
-        if (strcmp(param_value, "true") == 0) {
-            return true;
-        }
-    }
-#endif
-    return false;
-}
-
-int sigprocmask(int how, const sigset_t *restrict set, sigset_t *restrict old)
-{
-	int r = 0;
-	if (set && get_sigchain_mask_enable()) {
-		sigset_t tmpset = *set;
-		intercept_sigprocmask(how, &tmpset);
-		const sigset_t *new_set_ptr = &tmpset;
-		r = pthread_sigmask(how, new_set_ptr, old);
-	} else {
-		r = pthread_sigmask(how, set, old);
-	}
-	if (!r) return r;
-	errno = r;
-	return -1;
-}

porting/linux/user/src/thread/pthread_sigmask.c

+/*
+ * Copyright (c) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <signal.h>
+#include <errno.h>
+#include <sigchain.h>
+#include <stddef.h>
+#include <hilog_adapter.h>
+#include <string.h>
+#include "syscall.h"
+#ifdef OHOS_ENABLE_PARAMETER
+#include "sys_param.h"
+#endif
+
+extern void intercept_pthread_sigmask(int how, sigset_t *restrict set);
+static const char *param_name = "musl.sigchain.procmask";
+
+/**
+  * @brief Get whether sigchain mask is enabled
+  * @retval True if the sigchain mask is enable, or false.
+  */
+bool get_sigchain_mask_enable()
+{
+#ifdef OHOS_ENABLE_PARAMETER
+	static CachedHandle sigchain_procmask_handle = NULL;
+	if (sigchain_procmask_handle == NULL) {
+		sigchain_procmask_handle = CachedParameterCreate(param_name, "false");
+	}
+	char *param_value = CachedParameterGet(sigchain_procmask_handle);
+	if (param_value != NULL) {
+		if (strcmp(param_value, "true") == 0) {
+			return true;
+		}
+	}
+#endif
+	return false;
+}
+
+int pthread_sigmask(int how, const sigset_t *restrict set, sigset_t *restrict old)
+{
+	int ret;
+	if (set && (unsigned)how - SIG_BLOCK > 2U) return EINVAL;
+	/* sigchain intercepts pthread_sigmask */
+	if (set && get_sigchain_mask_enable()) {
+		sigset_t tmpset = *set;
+		intercept_pthread_sigmask(how, &tmpset);
+		const sigset_t *new_set_ptr = &tmpset;
+		ret = -__syscall(SYS_rt_sigprocmask, how, new_set_ptr, old, _NSIG/8);
+	} else {
+		ret = -__syscall(SYS_rt_sigprocmask, how, set, old, _NSIG/8);
+	}
+
+	if (!ret && old) {
+		if (sizeof old->__bits[0] == 8) {
+			old->__bits[0] &= ~0x380000000ULL;
+		} else {
+			old->__bits[0] &= ~0x80000000UL;
+			old->__bits[1] &= ~0x3UL;
+		}
+	}
+	return ret;
+}