signal.c: use printaddr and umove_or_printaddr

* signal.c (print_sigset_addr_len, decode_old_sigaction):
Use printaddr and umove_or_printaddr.
(sys_signal): Use printaddr.
(sys_sigprocmask, sys_sigpending, sys_rt_sigprocmask,
sys_rt_sigpending): Remove redundant checks for syserror.
(decode_new_sigaction): Use umove_or_printaddr.

diff --git a/signal.c b/signal.c
index c9e7518f92f28efacac3c17962a74593f356846b..3b82cf3bb7216235ca65a013834c3e110fdb6a5e 100644 (file)
--- a/signal.c
+++ b/signal.c
@@ -227,16 +227,11 @@ print_sigset_addr_len(struct tcb *tcp, long addr, long len)
 {
        char mask[NSIG / 8];
 
-       if (!addr) {
-               tprints("NULL");
-               return;
-       }
        /* Here len is usually equals NSIG / 8 or current_wordsize.
         * But we code this defensively:
         */
        if (len < 0) {
- bad:
-               tprintf("%#lx", addr);
+               printaddr(addr);
                return;
        }
        if (len >= NSIG / 8)
@@ -244,8 +239,8 @@ print_sigset_addr_len(struct tcb *tcp, long addr, long len)
        else
                len = (len + 3) & ~3;
 
-       if (umoven(tcp, addr, len, mask) < 0)
-               goto bad;
+       if (umoven_or_printaddr(tcp, addr, len, mask))
+               return;
        tprints(sprintsigmask_n("", mask, len));
 }
 
@@ -294,39 +289,25 @@ static void
 decode_old_sigaction(struct tcb *tcp, long addr)
 {
        struct old_sigaction sa;
-       int r;
-
-       if (!addr) {
-               tprints("NULL");
-               return;
-       }
-       if (!verbose(tcp) || (exiting(tcp) && syserror(tcp))) {
-               tprintf("%#lx", addr);
-               return;
-       }
 
 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
        if (current_wordsize != sizeof(sa.__sa_handler) && current_wordsize == 4) {
                struct old_sigaction32 sa32;
-               r = umove(tcp, addr, &sa32);
-               if (r >= 0) {
-                       memset(&sa, 0, sizeof(sa));
-                       sa.__sa_handler = (void*)(uintptr_t)sa32.__sa_handler;
-                       sa.sa_flags = sa32.sa_flags;
+
+               if (umove_or_printaddr(tcp, addr, &sa32))
+                       return;
+
+               memset(&sa, 0, sizeof(sa));
+               sa.__sa_handler = (void*)(uintptr_t)sa32.__sa_handler;
+               sa.sa_flags = sa32.sa_flags;
 #if HAVE_SA_RESTORER && defined SA_RESTORER
-                       sa.sa_restorer = (void*)(uintptr_t)sa32.sa_restorer;
+               sa.sa_restorer = (void*)(uintptr_t)sa32.sa_restorer;
 #endif
-                       sa.sa_mask = sa32.sa_mask;
-               }
+               sa.sa_mask = sa32.sa_mask;
        } else
 #endif
-       {
-               r = umove(tcp, addr, &sa);
-       }
-       if (r < 0) {
-               tprints("{...}");
+       if (umove_or_printaddr(tcp, addr, &sa))
                return;
-       }
 
        /* Architectures using function pointers, like
         * hppa, may need to manipulate the function pointer
@@ -336,14 +317,16 @@ decode_old_sigaction(struct tcb *tcp, long addr)
         * be manipulated by strace. In order to prevent the
         * compiler from generating code to manipulate
         * __sa_handler we cast the function pointers to long. */
+       tprints("{");
        if ((long)sa.__sa_handler == (long)SIG_ERR)
-               tprints("{SIG_ERR, ");
+               tprints("SIG_ERR");
        else if ((long)sa.__sa_handler == (long)SIG_DFL)
-               tprints("{SIG_DFL, ");
+               tprints("SIG_DFL");
        else if ((long)sa.__sa_handler == (long)SIG_IGN)
-               tprints("{SIG_IGN, ");
+               tprints("SIG_IGN");
        else
-               tprintf("{%#lx, ", (long) sa.__sa_handler);
+               printaddr((long) sa.__sa_handler);
+       tprints(", ");
 #ifdef MIPS
        tprintsigmask_addr("", sa.sa_mask);
 #else
@@ -386,7 +369,7 @@ SYS_FUNC(signal)
                        tprints("SIG_IGN");
                        break;
                default:
-                       tprintf("%#lx", tcp->u_arg[1]);
+                       printaddr(tcp->u_arg[1]);
                }
                return 0;
        }
@@ -457,10 +440,7 @@ SYS_FUNC(sigprocmask)
                tprints(", ");
        }
        else {
-               if (syserror(tcp))
-                       tprintf("%#lx", tcp->u_arg[2]);
-               else
-                       print_sigset_addr_len(tcp, tcp->u_arg[2], current_wordsize);
+               print_sigset_addr_len(tcp, tcp->u_arg[2], current_wordsize);
        }
 # endif /* !ALPHA */
        return 0;
@@ -493,12 +473,8 @@ SYS_FUNC(tgkill)
 
 SYS_FUNC(sigpending)
 {
-       if (exiting(tcp)) {
-               if (syserror(tcp))
-                       tprintf("%#lx", tcp->u_arg[0]);
-               else
-                       print_sigset_addr_len(tcp, tcp->u_arg[0], current_wordsize);
-       }
+       if (exiting(tcp))
+               print_sigset_addr_len(tcp, tcp->u_arg[0], current_wordsize);
        return 0;
 }
 
@@ -512,10 +488,7 @@ SYS_FUNC(rt_sigprocmask)
                tprints(", ");
        }
        else {
-               if (syserror(tcp))
-                       tprintf("%#lx", tcp->u_arg[2]);
-               else
-                       print_sigset_addr_len(tcp, tcp->u_arg[2], tcp->u_arg[3]);
+               print_sigset_addr_len(tcp, tcp->u_arg[2], tcp->u_arg[3]);
                tprintf(", %lu", tcp->u_arg[3]);
        }
        return 0;
@@ -553,46 +526,34 @@ static void
 decode_new_sigaction(struct tcb *tcp, long addr)
 {
        struct new_sigaction sa;
-       int r;
 
-       if (!addr) {
-               tprints("NULL");
-               return;
-       }
-       if (!verbose(tcp) || (exiting(tcp) && syserror(tcp))) {
-               tprintf("%#lx", addr);
-               return;
-       }
 #if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
        if (current_wordsize != sizeof(sa.sa_flags) && current_wordsize == 4) {
                struct new_sigaction32 sa32;
-               r = umove(tcp, addr, &sa32);
-               if (r >= 0) {
-                       memset(&sa, 0, sizeof(sa));
-                       sa.__sa_handler = (void*)(unsigned long)sa32.__sa_handler;
-                       sa.sa_flags     = sa32.sa_flags;
+
+               if (umove_or_printaddr(tcp, addr, &sa32))
+                       return;
+
+               memset(&sa, 0, sizeof(sa));
+               sa.__sa_handler = (void*)(unsigned long)sa32.__sa_handler;
+               sa.sa_flags     = sa32.sa_flags;
 #if HAVE_SA_RESTORER && defined SA_RESTORER
-                       sa.sa_restorer  = (void*)(unsigned long)sa32.sa_restorer;
+               sa.sa_restorer  = (void*)(unsigned long)sa32.sa_restorer;
 #endif
-                       /* Kernel treats sa_mask as an array of longs.
-                        * For 32-bit process, "long" is uint32_t, thus, for example,
-                        * 32th bit in sa_mask will end up as bit 0 in sa_mask[1].
-                        * But for (64-bit) kernel, 32th bit in sa_mask is
-                        * 32th bit in 0th (64-bit) long!
-                        * For little-endian, it's the same.
-                        * For big-endian, we swap 32-bit words.
-                        */
-                       sa.sa_mask[0] = sa32.sa_mask[0] + ((long)(sa32.sa_mask[1]) << 32);
-               }
+               /* Kernel treats sa_mask as an array of longs.
+                * For 32-bit process, "long" is uint32_t, thus, for example,
+                * 32th bit in sa_mask will end up as bit 0 in sa_mask[1].
+                * But for (64-bit) kernel, 32th bit in sa_mask is
+                * 32th bit in 0th (64-bit) long!
+                * For little-endian, it's the same.
+                * For big-endian, we swap 32-bit words.
+                */
+               sa.sa_mask[0] = sa32.sa_mask[0] + ((long)(sa32.sa_mask[1]) << 32);
        } else
 #endif
-       {
-               r = umove(tcp, addr, &sa);
-       }
-       if (r < 0) {
-               tprints("{...}");
+       if (umove_or_printaddr(tcp, addr, &sa))
                return;
-       }
+
        /* Architectures using function pointers, like
         * hppa, may need to manipulate the function pointer
         * to compute the result of a comparison. However,
@@ -656,10 +617,7 @@ SYS_FUNC(rt_sigpending)
                 * This allows non-rt sigpending() syscall
                 * to reuse rt_sigpending() code in kernel.
                 */
-               if (syserror(tcp))
-                       tprintf("%#lx", tcp->u_arg[0]);
-               else
-                       print_sigset_addr_len(tcp, tcp->u_arg[0], tcp->u_arg[1]);
+               print_sigset_addr_len(tcp, tcp->u_arg[0], tcp->u_arg[1]);
                tprintf(", %lu", tcp->u_arg[1]);
        }
        return 0;