PR16716 partial fix: Better types in 'syscall.{getpgid,reboot,setpgid}'.

* tapset/linux/syscalls.stp: Fix types in 'syscall.getpgid'.
* tapset/linux/syscalls2.stp: Fix types in 'syscall.reboot' and
  'syscall.setpgid'.
* tapset/linux/x86_64/syscalls.stp: Fix nesting in 'syscall.mmap2'.
* tapset/linux/x86_64/nd_syscalls.stp: Ditto.
* tapset/linux/aux_syscalls.stp (_reboot_magic_str): Convert to use
  _stp_lookup_str().
  (_reboot_flag_str): Ditto.
* runtime/linux/compat_unistd.h: Added mmap2 defines.
* testsuite/systemtap.syscall/pgid.c (main): Add more tests.
* testsuite/systemtap.syscall/reboot.c: New test case.

diff --git a/runtime/linux/compat_unistd.h b/runtime/linux/compat_unistd.h
index 297e3ec5a2ac3c083b097f6d0207f4d3adeb556c..ddfdb57a834f5dbe744aa4fc39429b5c58491cfc 100644 (file)
--- a/runtime/linux/compat_unistd.h
+++ b/runtime/linux/compat_unistd.h
@@ -45,6 +45,9 @@
 #ifndef __NR_ia32_mkdirat
 #define __NR_ia32_mkdirat 296
 #endif
+#ifndef __NR_ia32_mmap2
+#define __NR_ia32_mmap2 192
+#endif
 #ifndef __NR_ia32_open
 #define __NR_ia32_open 5
 #endif
@@ -145,6 +148,9 @@
 #ifndef __NR_accept4
 #define __NR_accept4 (__NR_syscall_max + 1)
 #endif
+#ifndef __NR_mmap2
+#define __NR_mmap2 (__NR_syscall_max + 1)
+#endif
 #ifndef __NR_recv
 #define __NR_recv (__NR_syscall_max + 1)
 #endif

diff --git a/tapset/linux/aux_syscalls.stp b/tapset/linux/aux_syscalls.stp
index e4a0a55b339385c5409ac74cfc5e1fae1ac612cb..8b256e1f8ce0d03ed3d30f597ac940235ed82c12 100644 (file)
--- a/tapset/linux/aux_syscalls.stp
+++ b/tapset/linux/aux_syscalls.stp
@@ -1333,7 +1333,7 @@ static const _stp_val_array const _stp_sched_policy_list[] = {
 };
 %}
 
-function _sched_policy_str:string(policy)
+function _sched_policy_str:string(policy:long)
 %{ /* pure */
        unsigned int policy = (unsigned int)STAP_ARG_policy;
 #ifdef SCHED_RESET_ON_FORK
@@ -1375,48 +1375,45 @@ function _shutdown_how_str:string(how)
 // be inlined into the function since these header file defines static
 // functions on some architectures.
 #include <linux/reboot.h>
+
+static const _stp_val_array const _stp_reboot_magic_list[] = {
+       V(LINUX_REBOOT_MAGIC1),
+       V(LINUX_REBOOT_MAGIC2),
+       V(LINUX_REBOOT_MAGIC2A),
+       V(LINUX_REBOOT_MAGIC2B),
+       V(LINUX_REBOOT_MAGIC2C),
+       {0, NULL}
+};
 %}
 
 function _reboot_magic_str:string(magic:long)
 %{ /* pure */
-       int magic = (int)STAP_ARG_magic;
-       switch (magic) {
-       case LINUX_REBOOT_MAGIC1:
-               strlcpy(STAP_RETVALUE, "LINUX_REBOOT_MAGIC1", MAXSTRINGLEN);
-               break;
-       case LINUX_REBOOT_MAGIC2:
-               strlcpy(STAP_RETVALUE, "LINUX_REBOOT_MAGIC2", MAXSTRINGLEN);
-               break;
-       case LINUX_REBOOT_MAGIC2A:
-               strlcpy(STAP_RETVALUE, "LINUX_REBOOT_MAGIC2A", MAXSTRINGLEN);
-               break;
-       case LINUX_REBOOT_MAGIC2B:
-               strlcpy(STAP_RETVALUE, "LINUX_REBOOT_MAGIC2B", MAXSTRINGLEN);
-               break;
-/*
-       LINUX_REBOOT_MAGIC2C is supported from kernel 2.6
-*/
-#ifdef LINUX_REBOOT_MAGIC2C
-       case LINUX_REBOOT_MAGIC2C:
-               strlcpy(STAP_RETVALUE, "LINUX_REBOOT_MAGIC2C", MAXSTRINGLEN);
-               break;
-#endif
-       default:
-               snprintf(STAP_RETVALUE, MAXSTRINGLEN, "UNKNOWN VALUE: %d", magic);
-       }
+       unsigned int magic = (unsigned int)STAP_ARG_magic;
+       _stp_lookup_str(_stp_reboot_magic_list, magic, STAP_RETVALUE,
+                       MAXSTRINGLEN);
 %}
 
-function _reboot_flag_str(flag) {
-   if(flag==0x01234567) return "LINUX_REBOOT_CMD_RESTART"
-   if(flag==0xCDEF0123) return "LINUX_REBOOT_CMD_HALT"
-   if(flag==0x4321FEDC) return "LINUX_REBOOT_CMD_POWER_OFF"
-   if(flag==0xA1B2C3D4) return "LINUX_REBOOT_CMD_RESTART2"
-   if(flag==0x89ABCDEF) return "LINUX_REBOOT_CMD_CAD_ON"
-   if(flag==0x00000000) return "LINUX_REBOOT_CMD_CAD_OFF"
-   if(flag==0xD000FCE2) return "LINUX_REBOOT_CMD_SW_SUSPEND"
-   if(flag==0x45584543) return "LINUX_REBOOT_CMD_KEXEC"
-   return sprintf("UNKNOWN VALUE: %d", flag)
-}
+%{
+#include <linux/reboot.h>
+static const _stp_val_array const _stp_reboot_flag_list[] = {
+       V(LINUX_REBOOT_CMD_RESTART),
+       V(LINUX_REBOOT_CMD_HALT),
+       V(LINUX_REBOOT_CMD_CAD_ON),
+       V(LINUX_REBOOT_CMD_CAD_OFF),
+       V(LINUX_REBOOT_CMD_POWER_OFF),
+       V(LINUX_REBOOT_CMD_RESTART2),
+       V(LINUX_REBOOT_CMD_SW_SUSPEND),
+       V(LINUX_REBOOT_CMD_KEXEC),
+       {0, NULL}
+};     
+%}
+
+function _reboot_flag_str:string(flag:long)
+%{  /* pure */
+       unsigned int flag = (unsigned int)STAP_ARG_flag;
+       _stp_lookup_str(_stp_reboot_flag_list, flag, STAP_RETVALUE,
+                       MAXSTRINGLEN);
+%}
 
 function _waitid_which_str(flag) {
    if(flag==0) return "P_ALL"

diff --git a/tapset/linux/syscalls.stp b/tapset/linux/syscalls.stp
index 60e306ba39b50c7010771a603a9cf44f959aea0a..6103b13b562f3f83ea03f7d35252cb17eb0474fb 100644 (file)
--- a/tapset/linux/syscalls.stp
+++ b/tapset/linux/syscalls.stp
@@ -1775,8 +1775,8 @@ probe syscall.getpgid = kernel.function("sys_getpgid").call
 {
        @__syscall_compat_gate(%{ __NR_getpgid %}, %{ __NR_compat_getpgid %})
        name = "getpgid"
-       pid = $pid
-       argstr = sprintf("%d", $pid)
+       pid = __int32($pid)
+       argstr = sprintf("%d", __int32($pid))
 }
 probe syscall.getpgid.return = kernel.function("sys_getpgid").return
 {

diff --git a/tapset/linux/syscalls2.stp b/tapset/linux/syscalls2.stp
index 8cc829620d059152bb583419e9c39102d974b7db..5073c9465b74f6dfc213e43f79429d7e220cd3a1 100644 (file)
--- a/tapset/linux/syscalls2.stp
+++ b/tapset/linux/syscalls2.stp
@@ -937,12 +937,12 @@ probe syscall.readv.return = kernel.function("compat_sys_readv").return ?,
 probe syscall.reboot = kernel.function("sys_reboot").call
 {
        name = "reboot"
-       magic = $magic1
-       magic_str = _reboot_magic_str($magic1)
-       magic2 = $magic2
-       magic2_str =_reboot_magic_str($magic2)
-       flag = $cmd
-       flag_str =  _reboot_flag_str($cmd)
+       magic = __int32($magic1)
+       magic_str = _reboot_magic_str(__int32($magic1))
+       magic2 = __int32($magic2)
+       magic2_str =_reboot_magic_str(__int32($magic2))
+       flag = __uint32($cmd)
+       flag_str =  _reboot_flag_str(__uint32($cmd))
        arg_uaddr = $arg
        argstr = sprintf("%s, %s, %s, %p", magic_str, magic2_str,
                flag_str, $arg)
@@ -2419,9 +2419,9 @@ probe syscall.set_mempolicy.return = kernel.function("compat_sys_set_mempolicy")
 probe syscall.setpgid = kernel.function("sys_setpgid").call
 {
        name = "setpgid"
-       pid = $pid
-       pgid = $pgid
-       argstr = sprintf("%d, %d", $pid, $pgid)
+       pid = __int32($pid)
+       pgid = __int32($pgid)
+       argstr = sprintf("%d, %d", __int32($pid), __int32($pgid))
 }
 probe syscall.setpgid.return = kernel.function("sys_setpgid").return
 {

diff --git a/tapset/linux/x86_64/nd_syscalls.stp b/tapset/linux/x86_64/nd_syscalls.stp
index 3a713248e55c0f478e793e664d5a0299e4c024e9..d7c8634cc81acd5847e3f4b5c1a557ef7452f4c8 100644 (file)
--- a/tapset/linux/x86_64/nd_syscalls.stp
+++ b/tapset/linux/x86_64/nd_syscalls.stp
@@ -148,6 +148,7 @@ probe nd_syscall.mmap32.return = kprobe.function("sys32_mmap").return
 #
 probe nd_syscall.mmap2 = __nd_syscall.mmap2 ?, __nd_syscall.mmap_pgoff ?
 {
+       @__syscall_compat_gate(%{ __NR_mmap2 %}, %{ __NR_ia32_mmap2 %})
        name = "mmap2"
 }
 probe __nd_syscall.mmap2 = kprobe.function("sys32_mmap2")
@@ -175,6 +176,7 @@ probe __nd_syscall.mmap_pgoff = kprobe.function("sys_mmap_pgoff")
 probe nd_syscall.mmap2.return = kprobe.function("sys32_mmap2").return ?,
        kprobe.function("sys_mmap_pgoff").return ?
 {
+       @__syscall_compat_gate(%{ __NR_mmap2 %}, %{ __NR_ia32_mmap2 %})
        name = "mmap2"
        retstr = returnstr(2)
 }

diff --git a/tapset/linux/x86_64/syscalls.stp b/tapset/linux/x86_64/syscalls.stp
index 96922938dc0d4dbb84f35b16a258aa385fcece8a..72b832c6ac41a82135f81022eb0acf35d06afd57 100644 (file)
--- a/tapset/linux/x86_64/syscalls.stp
+++ b/tapset/linux/x86_64/syscalls.stp
@@ -147,6 +147,7 @@ probe syscall.mmap32.return = kernel.function("sys32_mmap").return
 # The function is removed since 2.6.33
 probe syscall.mmap2 = __syscall.mmap2 ?, __syscall.mmap_pgoff ?
 {
+       @__syscall_compat_gate(%{ __NR_mmap2 %}, %{ __NR_ia32_mmap2 %})
        name = "mmap2"
         start = $addr
         length = $len
@@ -171,6 +172,7 @@ probe __syscall.mmap_pgoff = kernel.function("sys_mmap_pgoff")
 probe syscall.mmap2.return = kernel.function("sys_mmap2").return ?,
        kernel.function("sys_mmap_pgoff").return ?
 {
+       @__syscall_compat_gate(%{ __NR_mmap2 %}, %{ __NR_ia32_mmap2 %})
        name = "mmap2"
        retstr = return_str(2, $return)
 }

diff --git a/testsuite/systemtap.syscall/pgid.c b/testsuite/systemtap.syscall/pgid.c
index bdae295f4a41f1441f473b78042ccf453377190e..f33bdf9b9b16e1cbe4fd15bdb4f729e32edcf93d 100644 (file)
--- a/testsuite/systemtap.syscall/pgid.c
+++ b/testsuite/systemtap.syscall/pgid.c
@@ -6,6 +6,7 @@
 int main()
 {
     pid_t pgid;
+    pid_t pid = getpid();
 
     pgid = getpgrp();
     // On some platforms (like RHEL5 ia64), getpgrp() is implemented
@@ -15,9 +16,18 @@ int main()
     pgid = getpgid(0);
     //staptest// getpgid (0) = NNNN
 
+    (void)getpgid(-1);
+    //staptest// getpgid (-1) = -NNNN (ESRCH)
+
     setpgid(0, 0);
     //staptest// setpgid (0, 0) = 0
 
+    setpgid(pid, -1);
+    //staptest// setpgid (NNNN, -1) = -NNNN (EINVAL)
+
+    setpgid(-1, pgid);
+    //staptest// setpgid (-1, NNNN) = -NNNN (ESRCH)
+
     pgid = getpgrp();
     //staptest// [[[[getpgrp ()!!!!getpgid (0)]]]] = NNNN
 

diff --git a/testsuite/systemtap.syscall/reboot.c b/testsuite/systemtap.syscall/reboot.c
new file mode 100644 (file)
index 0000000..95cfcae
--- /dev/null
+++ b/testsuite/systemtap.syscall/reboot.c
@@ -0,0 +1,20 @@
+/* COVERAGE: reboot */
+
+#include <unistd.h>
+#include <sys/reboot.h>
+#include <linux/reboot.h>
+
+int main()
+{
+    // Since we may or may not be run as root, these commands could
+    // succeed or fail. So, ignore most of the return values.
+
+    reboot(RB_ENABLE_CAD);
+    //staptest// reboot (LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_CAD_ON, XXXX)
+
+    reboot(RB_DISABLE_CAD);
+    //staptest// reboot (LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_CAD_OFF, XXXX)
+
+    reboot(-1);
+    //staptest// reboot (LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, 0xffffffff, XXXX)
+}