rpms/valgrind/devel valgrind-3.1.1-syscall-updates-from-trunk.patch, NONE, 1.1 valgrind-3.1.1-syscall-updates.patch, NONE, 1.1 valgrind.spec, 1.29, 1.30

fedora-cvs-commits at redhat.com fedora-cvs-commits at redhat.com
Wed Apr 12 15:25:28 UTC 2006


Author: jakub

Update of /cvs/dist/rpms/valgrind/devel
In directory cvs.devel.redhat.com:/tmp/cvs-serv9592

Modified Files:
	valgrind.spec 
Added Files:
	valgrind-3.1.1-syscall-updates-from-trunk.patch 
	valgrind-3.1.1-syscall-updates.patch 
Log Message:
3.1.1-2


valgrind-3.1.1-syscall-updates-from-trunk.patch:
 priv_syswrap-generic.h |    1 
 priv_syswrap-linux.h   |   16 +++
 syswrap-amd64-linux.c  |   20 +++
 syswrap-generic.c      |   76 +++++---------
 syswrap-linux.c        |  256 +++++++++++++++++++++++++++++++++++++++++++++++++
 syswrap-ppc32-linux.c  |   23 +++-
 syswrap-x86-linux.c    |   59 ++++++++++-
 7 files changed, 396 insertions(+), 55 deletions(-)

--- NEW FILE valgrind-3.1.1-syscall-updates-from-trunk.patch ---
--- valgrind-3.1.1/coregrind/m_syswrap/syswrap-ppc32-linux.c.jj	2006-02-22 08:47:05.000000000 -0500
+++ valgrind-3.1.1/coregrind/m_syswrap/syswrap-ppc32-linux.c	2006-04-12 10:23:34.000000000 -0400
@@ -392,6 +392,7 @@ DECL_TEMPLATE(ppc32_linux, sys_clone);
 DECL_TEMPLATE(ppc32_linux, sys_sigreturn);
 DECL_TEMPLATE(ppc32_linux, sys_rt_sigreturn);
 DECL_TEMPLATE(ppc32_linux, sys_sigaction);
+DECL_TEMPLATE(ppc32_linux, sys_sigsuspend);
 
 PRE(sys_socketcall)
 {
@@ -1424,6 +1425,20 @@ POST(sys_sigaction)
       POST_MEM_WRITE( ARG3, sizeof(struct vki_old_sigaction));
 }
 
+PRE(sys_sigsuspend)
+{
+   /* The C library interface to sigsuspend just takes a pointer to
+      a signal mask but this system call only takes the first word of
+      the signal mask as an argument so only 32 signals are supported.
+     
+      In fact glibc normally uses rt_sigsuspend if it is available as
+      that takes a pointer to the signal mask so supports more signals.
+    */
+   *flags |= SfMayBlock;
+   PRINT("sys_sigsuspend ( %d )", ARG1 );
+   PRE_REG_READ1(int, "sigsuspend", vki_old_sigset_t, mask);
+}
+
 
 #undef PRE
 #undef POST
@@ -1461,7 +1476,7 @@ const SyscallTableEntry ML_(syscall_tabl
    GENX_(__NR_execve,            sys_execve),            // 11
    GENX_(__NR_chdir,             sys_chdir),             // 12
    GENXY(__NR_time,              sys_time),              // 13
-//..    GENX_(__NR_mknod,             sys_mknod),             // 14
+   GENX_(__NR_mknod,             sys_mknod),             // 14
 //.. 
    GENX_(__NR_chmod,             sys_chmod),             // 15
 //..    LINX_(__NR_lchown,            sys_lchown16),          // 16 ## P
@@ -1531,7 +1546,7 @@ const SyscallTableEntry ML_(syscall_tabl
 //.. 
 //..    LINX_(__NR_setreuid,          sys_setreuid16),        // 70
 //..    LINX_(__NR_setregid,          sys_setregid16),        // 71
-//..    GENX_(__NR_sigsuspend,        sys_sigsuspend),        // 72
+   PLAX_(__NR_sigsuspend,        sys_sigsuspend),        // 72
 //..    LINXY(__NR_sigpending,        sys_sigpending),        // 73
 //..    //   (__NR_sethostname,       sys_sethostname),       // 74 */*
 //.. 
@@ -1563,7 +1578,7 @@ const SyscallTableEntry ML_(syscall_tabl
    GENX_(__NR_getpriority,       sys_getpriority),       // 96
    GENX_(__NR_setpriority,       sys_setpriority),       // 97
 //..    GENX_(__NR_profil,            sys_ni_syscall),        // 98
-//..    GENXY(__NR_statfs,            sys_statfs),            // 99
+   GENXY(__NR_statfs,            sys_statfs),            // 99
 //.. 
 //..    GENXY(__NR_fstatfs,           sys_fstatfs),           // 100
 //..    LINX_(__NR_ioperm,            sys_ioperm),            // 101
@@ -1606,7 +1621,7 @@ const SyscallTableEntry ML_(syscall_tabl
 //..    GENX_(__NR_get_kernel_syms,   sys_ni_syscall),        // 130
 //..    LINX_(__NR_quotactl,          sys_quotactl),          // 131
    GENX_(__NR_getpgid,           sys_getpgid),           // 132
-//..    GENX_(__NR_fchdir,            sys_fchdir),            // 133
+   GENX_(__NR_fchdir,            sys_fchdir),            // 133
 //..    //   (__NR_bdflush,           sys_bdflush),           // 134 */Linux
 //.. 
 //..    //   (__NR_sysfs,             sys_sysfs),             // 135 SVr4
--- valgrind-3.1.1/coregrind/m_syswrap/priv_syswrap-generic.h.jj	2006-02-20 10:16:37.000000000 -0500
+++ valgrind-3.1.1/coregrind/m_syswrap/priv_syswrap-generic.h	2006-04-12 10:23:34.000000000 -0400
@@ -170,7 +170,6 @@ DECL_TEMPLATE(generic, sys_newfstat);   
 
 // For the remainder, not really sure yet
 DECL_TEMPLATE(generic, sys_ptrace);                // (x86?) (almost-P)
-DECL_TEMPLATE(generic, sys_sigsuspend);            // POSIX, but L (proto varies across archs)
 DECL_TEMPLATE(generic, sys_setrlimit);             // SVr4, 4.3BSD
 DECL_TEMPLATE(generic, sys_ioctl);                 // x86? (various)
 DECL_TEMPLATE(generic, sys_old_getrlimit);         // SVr4, 4.3BSD L?
--- valgrind-3.1.1/coregrind/m_syswrap/priv_syswrap-linux.h.jj	2006-02-20 10:16:37.000000000 -0500
+++ valgrind-3.1.1/coregrind/m_syswrap/priv_syswrap-linux.h	2006-04-12 10:22:08.000000000 -0400
@@ -74,6 +74,8 @@ DECL_TEMPLATE(linux, sys_prctl);
 DECL_TEMPLATE(linux, sys_sendfile);
 DECL_TEMPLATE(linux, sys_sendfile64);
 DECL_TEMPLATE(linux, sys_futex);
+DECL_TEMPLATE(linux, sys_pselect6);
+DECL_TEMPLATE(linux, sys_ppoll);
 
 DECL_TEMPLATE(linux, sys_epoll_create);
 DECL_TEMPLATE(linux, sys_epoll_ctl);
@@ -122,6 +124,20 @@ DECL_TEMPLATE(linux, sys_timer_delete);
 DECL_TEMPLATE(linux, sys_capget);
 DECL_TEMPLATE(linux, sys_capset);
 
+DECL_TEMPLATE(linux, sys_openat);
+DECL_TEMPLATE(linux, sys_mkdirat);
+DECL_TEMPLATE(linux, sys_mknodat);
+DECL_TEMPLATE(linux, sys_fchownat);
+DECL_TEMPLATE(linux, sys_futimesat);
+DECL_TEMPLATE(linux, sys_newfstatat);
+DECL_TEMPLATE(linux, sys_unlinkat);
+DECL_TEMPLATE(linux, sys_renameat);
+DECL_TEMPLATE(linux, sys_linkat);
+DECL_TEMPLATE(linux, sys_symlinkat);
+DECL_TEMPLATE(linux, sys_readlinkat);
+DECL_TEMPLATE(linux, sys_fchmodat);
+DECL_TEMPLATE(linux, sys_faccessat);
+
 // These ones have 32-bit generic equivalents, but the 16-bit versions (they
 // use 16-bit gid_t and uid_t types) seem to be Linux-specific.
 DECL_TEMPLATE(linux, sys_getuid16);
--- valgrind-3.1.1/coregrind/m_syswrap/syswrap-amd64-linux.c.jj	2006-02-22 08:47:05.000000000 -0500
+++ valgrind-3.1.1/coregrind/m_syswrap/syswrap-amd64-linux.c	2006-04-12 10:22:08.000000000 -0400
@@ -1271,6 +1271,26 @@ const SyscallTableEntry ML_(syscall_tabl
    LINX_(__NR_inotify_add_watch, sys_inotify_add_watch), // 254
 
    LINX_(__NR_inotify_rm_watch,	 sys_inotify_rm_watch), // 255
+//   LINX_(__NR_migrate_pages,	 sys_migrate_pages),    // 256
+   LINXY(__NR_openat,		 sys_openat),           // 257
+   LINX_(__NR_mkdirat,		 sys_mkdirat),          // 258
+   LINX_(__NR_mknodat,		 sys_mknodat),          // 259
+
+   LINX_(__NR_fchownat,		 sys_fchownat),         // 260
+   LINX_(__NR_futimesat,	 sys_futimesat),        // 261
+   LINXY(__NR_newfstatat,	 sys_newfstatat),       // 262
+   LINX_(__NR_unlinkat,		 sys_unlinkat),         // 263
+   LINX_(__NR_renameat,		 sys_renameat),         // 264
+
+   LINX_(__NR_linkat,		 sys_linkat),           // 265
+   LINX_(__NR_symlinkat,	 sys_symlinkat),        // 266
+   LINX_(__NR_readlinkat,	 sys_readlinkat),       // 267
+   LINX_(__NR_fchmodat,		 sys_fchmodat),         // 268
+   LINX_(__NR_faccessat,	 sys_faccessat),        // 269
+
+//   LINX_(__NR_pselect6,		 sys_ni_syscall),       // 270
+//   LINXY(__NR_ppoll,		 sys_ni_syscall),       // 271
+//   LINX_(__NR_unshare,		 sys_unshare),          // 272
 };
 
 const UInt ML_(syscall_table_size) = 
--- valgrind-3.1.1/coregrind/m_syswrap/syswrap-generic.c.jj	2006-02-22 08:47:05.000000000 -0500
+++ valgrind-3.1.1/coregrind/m_syswrap/syswrap-generic.c	2006-04-12 10:23:34.000000000 -0400
@@ -752,7 +752,7 @@ void msghdr_foreachfield ( 
    foreach_func ( tid, True, "(msg)", (Addr)&msg->msg_iovlen, sizeof( msg->msg_iovlen ) );
    foreach_func ( tid, True, "(msg)", (Addr)&msg->msg_control, sizeof( msg->msg_control ) );
    foreach_func ( tid, True, "(msg)", (Addr)&msg->msg_controllen, sizeof( msg->msg_controllen ) );
-   foreach_func ( tid, True, "(msg)", (Addr)&msg->msg_flags, sizeof( msg->msg_flags ) );
+   foreach_func ( tid, False, "(msg)", (Addr)&msg->msg_flags, sizeof( msg->msg_flags ) );
 
    if ( msg->msg_name )
       foreach_func ( tid, False,
@@ -769,7 +769,7 @@ void msghdr_foreachfield ( 
 
       for ( i = 0; i < msg->msg_iovlen; ++i, ++iov )
          foreach_func ( tid, False,
-                        "(msg.msg_iov[i]", 
+                        "(msg.msg_iov[i])", 
                         (Addr)iov->iov_base, iov->iov_len );
    }
 
@@ -2237,7 +2237,7 @@ POST(sys_pread64)
 
 PRE(sys_mknod)
 {
-   PRINT("sys_mknod ( %p, 0x%x, 0x%x )", ARG1, ARG2, ARG3 );
+   PRINT("sys_mknod ( %p(%s), 0x%x, 0x%x )", ARG1, ARG1, ARG2, ARG3 );
    PRE_REG_READ3(long, "mknod",
                  const char *, pathname, int, mode, unsigned, dev);
    PRE_MEM_RASCIIZ( "mknod(pathname)", ARG1 );
@@ -2581,21 +2581,21 @@ PRE(sys_brk)
 
 PRE(sys_chdir)
 {
-   PRINT("sys_chdir ( %p )", ARG1);
+   PRINT("sys_chdir ( %p(%s) )", ARG1,ARG1);
    PRE_REG_READ1(long, "chdir", const char *, path);
    PRE_MEM_RASCIIZ( "chdir(path)", ARG1 );
 }
 
 PRE(sys_chmod)
 {
-   PRINT("sys_chmod ( %p, %d )", ARG1,ARG2);
+   PRINT("sys_chmod ( %p(%s), %d )", ARG1,ARG1,ARG2);
    PRE_REG_READ2(long, "chmod", const char *, path, vki_mode_t, mode);
    PRE_MEM_RASCIIZ( "chmod(path)", ARG1 );
 }
 
 PRE(sys_chown)
 {
-   PRINT("sys_chown ( %p, 0x%x, 0x%x )", ARG1,ARG2,ARG3);
+   PRINT("sys_chown ( %p(%s), 0x%x, 0x%x )", ARG1,ARG1,ARG2,ARG3);
    PRE_REG_READ3(long, "chown",
                  const char *, path, vki_uid_t, owner, vki_gid_t, group);
    PRE_MEM_RASCIIZ( "chown(path)", ARG1 );
@@ -2603,7 +2603,7 @@ PRE(sys_chown)
 
 PRE(sys_lchown)
 {
-   PRINT("sys_lchown ( %p, 0x%x, 0x%x )", ARG1,ARG2,ARG3);
+   PRINT("sys_lchown ( %p(%s), 0x%x, 0x%x )", ARG1,ARG1,ARG2,ARG3);
    PRE_REG_READ3(long, "lchown",
                  const char *, path, vki_uid_t, owner, vki_gid_t, group);
    PRE_MEM_RASCIIZ( "lchown(path)", ARG1 );
@@ -4587,7 +4587,7 @@ PRE(sys_kill)
 PRE(sys_link)
 {
    *flags |= SfMayBlock;
-   PRINT("sys_link ( %p, %p)", ARG1, ARG2);
+   PRINT("sys_link ( %p(%s), %p(%s) )", ARG1,ARG1,ARG2,ARG2);
    PRE_REG_READ2(long, "link", const char *, oldpath, const char *, newpath);
    PRE_MEM_RASCIIZ( "link(oldpath)", ARG1);
    PRE_MEM_RASCIIZ( "link(newpath)", ARG2);
@@ -4612,7 +4612,7 @@ POST(sys_newlstat)
 PRE(sys_mkdir)
 {
    *flags |= SfMayBlock;
-   PRINT("sys_mkdir ( %p, %d )", ARG1,ARG2);
+   PRINT("sys_mkdir ( %p(%s), %d )", ARG1,ARG1,ARG2);
    PRE_REG_READ2(long, "mkdir", const char *, pathname, int, mode);
    PRE_MEM_RASCIIZ( "mkdir(pathname)", ARG1 );
 }
@@ -4865,7 +4865,6 @@ POST(sys_creat)
    }
 }
 
-// XXX: x86-specific, due to pollfd struct
 PRE(sys_poll)
 {
    /* struct pollfd {
@@ -4880,16 +4879,16 @@ PRE(sys_poll)
    *flags |= SfMayBlock;
    PRINT("sys_poll ( %p, %d, %d )\n", ARG1,ARG2,ARG3);
    PRE_REG_READ3(long, "poll",
-                 struct pollfd *, ufds, unsigned int, nfds, long, timeout);
-                     
+                 struct vki_pollfd *, ufds, unsigned int, nfds, long, timeout);
+
    for (i = 0; i < ARG2; i++) {
-      // 'fd' and 'events' field are inputs;  'revents' is output.
-      // XXX: this is x86 specific -- the pollfd struct varies across
-      // different architectures.
-      PRE_MEM_READ( "poll(ufds)",
-                    (Addr)(&ufds[i]), sizeof(int) + sizeof(short) );
-      PRE_MEM_WRITE( "poll(ufds)", (Addr)(&ufds[i].revents), sizeof(short) );
-   }  
+      PRE_MEM_READ( "poll(ufds.fd)",
+                    (Addr)(&ufds[i].fd), sizeof(ufds[i].fd) );
+      PRE_MEM_READ( "poll(ufds.events)",
+                    (Addr)(&ufds[i].events), sizeof(ufds[i].events) );
+      PRE_MEM_WRITE( "poll(ufd.reventss)",
+                     (Addr)(&ufds[i].revents), sizeof(ufds[i].revents) );
+   }
 }
 
 POST(sys_poll)
@@ -4897,9 +4896,8 @@ POST(sys_poll)
    if (RES > 0) {
       UInt i;
       struct vki_pollfd* ufds = (struct vki_pollfd *)ARG1;
-      // XXX: again, this is x86-specific
       for (i = 0; i < ARG2; i++)
-	 POST_MEM_WRITE( (Addr)(&ufds[i].revents), sizeof(Short) );
+	 POST_MEM_WRITE( (Addr)(&ufds[i].revents), sizeof(ufds[i].revents) );
    }
 }
 
@@ -4908,7 +4906,7 @@ PRE(sys_readlink)
    HChar name[25];
    Word  saved = SYSNO;
 
-   PRINT("sys_readlink ( %p, %p, %llu )", ARG1,ARG2,(ULong)ARG3);
+   PRINT("sys_readlink ( %p(%s), %p, %llu )", ARG1,ARG1,ARG2,(ULong)ARG3);
    PRE_REG_READ3(long, "readlink",
                  const char *, path, char *, buf, int, bufsiz);
    PRE_MEM_RASCIIZ( "readlink(path)", ARG1 );
@@ -4979,7 +4977,7 @@ POST(sys_readv)
 
 PRE(sys_rename)
 {
-   PRINT("sys_rename ( %p, %p )", ARG1, ARG2 );
+   PRINT("sys_rename ( %p(%s), %p(%s) )", ARG1,ARG1,ARG2,ARG2);
    PRE_REG_READ2(long, "rename", const char *, oldpath, const char *, newpath);
    PRE_MEM_RASCIIZ( "rename(oldpath)", ARG1 );
    PRE_MEM_RASCIIZ( "rename(newpath)", ARG2 );
@@ -4988,7 +4986,7 @@ PRE(sys_rename)
 PRE(sys_rmdir)
 {
    *flags |= SfMayBlock;
-   PRINT("sys_rmdir ( %p )", ARG1);
+   PRINT("sys_rmdir ( %p(%s) )", ARG1,ARG1);
    PRE_REG_READ1(long, "rmdir", const char *, pathname);
    PRE_MEM_RASCIIZ( "rmdir(pathname)", ARG1 );
 }
@@ -4999,7 +4997,7 @@ PRE(sys_select)
    PRINT("sys_select ( %d, %p, %p, %p, %p )", ARG1,ARG2,ARG3,ARG4,ARG5);
    PRE_REG_READ5(long, "select",
                  int, n, vki_fd_set *, readfds, vki_fd_set *, writefds,
-                 vki_fd_set *, exceptfds, struct timeval *, timeout);
+                 vki_fd_set *, exceptfds, struct vki_timeval *, timeout);
    // XXX: this possibly understates how much memory is read.
    if (ARG2 != 0)
       PRE_MEM_READ( "select(readfds)",   
@@ -5113,7 +5111,7 @@ POST(sys_newstat)
 
 PRE(sys_statfs)
 {
-   PRINT("sys_statfs ( %p, %p )",ARG1,ARG2);
+   PRINT("sys_statfs ( %p(%s), %p )",ARG1,ARG1,ARG2);
    PRE_REG_READ2(long, "statfs", const char *, path, struct statfs *, buf);
    PRE_MEM_RASCIIZ( "statfs(path)", ARG1 );
    PRE_MEM_WRITE( "statfs(buf)", ARG2, sizeof(struct vki_statfs) );
@@ -5125,7 +5123,7 @@ POST(sys_statfs)
 
 PRE(sys_statfs64)
 {
-   PRINT("sys_statfs64 ( %p, %llu, %p )",ARG1,(ULong)ARG2,ARG3);
+   PRINT("sys_statfs64 ( %p(%s), %llu, %p )",ARG1,ARG1,(ULong)ARG2,ARG3);
    PRE_REG_READ3(long, "statfs64",
                  const char *, path, vki_size_t, size, struct statfs64 *, buf);
    PRE_MEM_RASCIIZ( "statfs64(path)", ARG1 );
@@ -5139,7 +5137,7 @@ POST(sys_statfs64)
 PRE(sys_symlink)
 {
    *flags |= SfMayBlock;
-   PRINT("sys_symlink ( %p, %p )",ARG1,ARG2);
+   PRINT("sys_symlink ( %p(%s), %p(%s) )",ARG1,ARG1,ARG2,ARG2);
    PRE_REG_READ2(long, "symlink", const char *, oldpath, const char *, newpath);
    PRE_MEM_RASCIIZ( "symlink(oldpath)", ARG1 );
    PRE_MEM_RASCIIZ( "symlink(newpath)", ARG2 );
@@ -5271,7 +5269,7 @@ PRE(sys_writev)
 
 PRE(sys_utimes)
 {
-   PRINT("sys_utimes ( %p, %p )", ARG1,ARG2);
+   PRINT("sys_utimes ( %p(%s), %p )", ARG1,ARG1,ARG2);
    PRE_REG_READ2(long, "utimes", char *, filename, struct timeval *, tvp);
    PRE_MEM_RASCIIZ( "utimes(filename)", ARG1 );
    if (ARG2 != 0)
@@ -5280,7 +5278,7 @@ PRE(sys_utimes)
 
 PRE(sys_acct)
 {
-   PRINT("sys_acct ( %p )", ARG1);
+   PRINT("sys_acct ( %p(%s) )", ARG1,ARG1);
    PRE_REG_READ1(long, "acct", const char *, filename);
    PRE_MEM_RASCIIZ( "acct(filename)", ARG1 );
 }
@@ -5292,24 +5290,6 @@ PRE(sys_pause)
    PRE_REG_READ0(long, "pause");
 }
 
-//zz // XXX: x86-specific
-//zz PRE(sys_sigsuspend, SfMayBlock)
-//zz {
-//zz    /* The C library interface to sigsuspend just takes a pointer to
-//zz       a signal mask but this system call has three arguments - the first
-//zz       two don't appear to be used by the kernel and are always passed as
-//zz       zero by glibc and the third is the first word of the signal mask
-//zz       so only 32 signals are supported.
-//zz      
-//zz       In fact glibc normally uses rt_sigsuspend if it is available as
-//zz       that takes a pointer to the signal mask so supports more signals.
-//zz     */
-//zz    PRINT("sys_sigsuspend ( %d, %d, %d )", ARG1,ARG2,ARG3 );
-//zz    PRE_REG_READ3(int, "sigsuspend",
-//zz                  int, history0, int, history1,
-//zz                  vki_old_sigset_t, mask);
-//zz }
-
 // XXX: x86-specific
 PRE(sys_sigaltstack)
 {
--- valgrind-3.1.1/coregrind/m_syswrap/syswrap-linux.c.jj	2006-02-22 08:47:05.000000000 -0500
+++ valgrind-3.1.1/coregrind/m_syswrap/syswrap-linux.c	2006-04-12 10:22:08.000000000 -0400
@@ -33,6 +33,7 @@
 #include "pub_core_aspacemgr.h"
 #include "pub_core_debuginfo.h"    // VG_(di_notify_*)
 #include "pub_core_transtab.h"     // VG_(discard_translations)
+#include "pub_core_clientstate.h"
 #include "pub_core_debuglog.h"
 #include "pub_core_libcbase.h"
 #include "pub_core_libcassert.h"
@@ -793,6 +794,66 @@ POST(sys_futex)
    }
 }
 
+PRE(sys_pselect6)
+{
+   *flags |= SfMayBlock;
+   PRINT("sys_pselect6 ( %d, %p, %p, %p, %p, %p )", ARG1,ARG2,ARG3,ARG4,ARG5,ARG6);
+   PRE_REG_READ6(long, "pselect6",
+                 int, n, vki_fd_set *, readfds, vki_fd_set *, writefds,
+                 vki_fd_set *, exceptfds, struct vki_timeval *, timeout,
+                 void *, sig);
+   // XXX: this possibly understates how much memory is read.
+   if (ARG2 != 0)
+      PRE_MEM_READ( "pselect6(readfds)",   
+		     ARG2, ARG1/8 /* __FD_SETSIZE/8 */ );
+   if (ARG3 != 0)
+      PRE_MEM_READ( "pselect6(writefds)",  
+		     ARG3, ARG1/8 /* __FD_SETSIZE/8 */ );
+   if (ARG4 != 0)
+      PRE_MEM_READ( "pselect6(exceptfds)", 
+		     ARG4, ARG1/8 /* __FD_SETSIZE/8 */ );
+   if (ARG5 != 0)
+      PRE_MEM_READ( "pselect6(timeout)", ARG5, sizeof(struct vki_timeval) );
+   if (ARG6 != 0)
+      PRE_MEM_READ( "pselect6(sig)", ARG6, sizeof(void *)+sizeof(vki_size_t) );
+}
+
+PRE(sys_ppoll)
+{
+   UInt i;
+   struct vki_pollfd* ufds = (struct vki_pollfd *)ARG1;
+   *flags |= SfMayBlock;
+   PRINT("sys_ppoll ( %p, %d, %p, %p, %llu )\n", ARG1,ARG2,ARG3,ARG4,ARG5);
+   PRE_REG_READ5(long, "ppoll",
+                 struct vki_pollfd *, ufds, unsigned int, nfds,
+                 struct vki_timespec *, tsp, vki_sigset_t *, sigmask,
+                 vki_size_t, sigsetsize);
+
+   for (i = 0; i < ARG2; i++) {
+      PRE_MEM_READ( "ppoll(ufds.fd)",
+                    (Addr)(&ufds[i].fd), sizeof(ufds[i].fd) );
+      PRE_MEM_READ( "ppoll(ufds.events)",
+                    (Addr)(&ufds[i].events), sizeof(ufds[i].events) );
+      PRE_MEM_WRITE( "ppoll(ufd.reventss)",
+                     (Addr)(&ufds[i].revents), sizeof(ufds[i].revents) );
+   }
+
+   if (ARG3)
+      PRE_MEM_READ( "ppoll(tsp)", ARG3, sizeof(struct vki_timespec) );
+   if (ARG4)
+      PRE_MEM_READ( "ppoll(sigmask)", ARG4, sizeof(vki_sigset_t) );
+}
+
+POST(sys_ppoll)
+{
+   if (RES > 0) {
+      UInt i;
+      struct vki_pollfd* ufds = (struct vki_pollfd *)ARG1;
+      for (i = 0; i < ARG2; i++)
+	 POST_MEM_WRITE( (Addr)(&ufds[i].revents), sizeof(ufds[i].revents) );
+   }
+}
+
 
 /* ---------------------------------------------------------------------
    epoll_* wrappers
@@ -2210,6 +2271,201 @@ ML_(linux_POST_sys_msgctl) ( ThreadId ti
    }
 }
 
+/* ---------------------------------------------------------------------
+   *at wrappers
+   ------------------------------------------------------------------ */
+
+PRE(sys_openat)
+{
+   HChar  name[30];
+   SysRes sres;
+
+   if (ARG3 & VKI_O_CREAT) {
+      // 4-arg version
+      PRINT("sys_openat ( %d, %p(%s), %d, %d )",ARG1,ARG2,ARG2,ARG3,ARG4);
+      PRE_REG_READ4(long, "openat",
+                    int, dfd, const char *, filename, int, flags, int, mode);
+   } else {
+      // 3-arg version
+      PRINT("sys_openat ( %d, %p(%s), %d )",ARG1,ARG2,ARG2,ARG3);
+      PRE_REG_READ3(long, "openat",
+                    int, dfd, const char *, filename, int, flags);
+   }
+
+   if (!ML_(fd_allowed)(ARG1, "openat", tid, False))
+      SET_STATUS_Failure( VKI_EBADF );
+   else
+      PRE_MEM_RASCIIZ( "openat(filename)", ARG2 );
+
+   /* Handle the case where the open is of /proc/self/cmdline or
+      /proc/<pid>/cmdline, and just give it a copy of the fd for the
+      fake file we cooked up at startup (in m_main).  Also, seek the
+      cloned fd back to the start. */
+
+   VG_(sprintf)(name, "/proc/%d/cmdline", VG_(getpid)());
+   if (ML_(safe_to_deref)( (void*)ARG2, 1 )
+       && (VG_(strcmp)((Char *)ARG2, name) == 0 
+           || VG_(strcmp)((Char *)ARG2, "/proc/self/cmdline") == 0)) {
+      sres = VG_(dup)( VG_(cl_cmdline_fd) );
+      SET_STATUS_from_SysRes( sres );
+      if (!sres.isError) {
+         OffT off = VG_(lseek)( sres.val, 0, VKI_SEEK_SET );
+         if (off < 0)
+            SET_STATUS_Failure( VKI_EMFILE );
+      }
+      return;
+   }
+
+   /* Otherwise handle normally */
+   *flags |= SfMayBlock;
+}
+
+POST(sys_openat)
+{
+   vg_assert(SUCCESS);
+   if (!ML_(fd_allowed)(RES, "openat", tid, True)) {
+      VG_(close)(RES);
+      SET_STATUS_Failure( VKI_EMFILE );
+   } else {
+      if (VG_(clo_track_fds))
+         ML_(record_fd_open_with_given_name)(tid, RES, (Char*)ARG2);
+   }
+}
+
+PRE(sys_mkdirat)
+{
+   *flags |= SfMayBlock;
+   PRINT("sys_mkdirat ( %d, %p(%s), %d )", ARG1,ARG2,ARG2,ARG3);
+   PRE_REG_READ3(long, "mkdirat",
+                 int, dfd, const char *, pathname, int, mode);
+   PRE_MEM_RASCIIZ( "mkdirat(pathname)", ARG2 );
+}
+
+PRE(sys_mknodat)
+{
+   PRINT("sys_mknodat ( %d, %p(%s), 0x%x, 0x%x )", ARG1,ARG2,ARG2,ARG3,ARG4 );
+   PRE_REG_READ4(long, "mknodat",
+                 int, dfd, const char *, pathname, int, mode, unsigned, dev);
+   PRE_MEM_RASCIIZ( "mknodat(pathname)", ARG2 );
+}
+
+PRE(sys_fchownat)
+{
+   PRINT("sys_fchownat ( %d, %p(%s), 0x%x, 0x%x )", ARG1,ARG2,ARG2,ARG3,ARG4);
+   PRE_REG_READ4(long, "fchownat",
+                 int, dfd, const char *, path,
+                 vki_uid_t, owner, vki_gid_t, group);
+   PRE_MEM_RASCIIZ( "fchownat(path)", ARG2 );
+}
+
+PRE(sys_futimesat)
+{
+   PRINT("sys_futimesat ( %d, %p(%s), %p )", ARG1,ARG2,ARG2,ARG3);
+   PRE_REG_READ3(long, "futimesat",
+                 int, dfd, char *, filename, struct timeval *, tvp);
+   PRE_MEM_RASCIIZ( "futimesat(filename)", ARG2 );
+   if (ARG3 != 0)
+      PRE_MEM_READ( "futimesat(tvp)", ARG3, sizeof(struct vki_timeval) );
+}
+
+PRE(sys_newfstatat)
+{
+   PRINT("sys_newfstatat ( %d, %p(%s), %p )", ARG1,ARG2,ARG2,ARG3);
+   PRE_REG_READ3(long, "fstatat",
+                 int, dfd, char *, file_name, struct stat *, buf);
+   PRE_MEM_RASCIIZ( "fstatat(file_name)", ARG2 );
+   PRE_MEM_WRITE( "fstatat(buf)", ARG3, sizeof(struct vki_stat) );
+}
+
+POST(sys_newfstatat)
+{
+   POST_MEM_WRITE( ARG3, sizeof(struct vki_stat) );
+}
+
+PRE(sys_unlinkat)
+{
+   *flags |= SfMayBlock;
+   PRINT("sys_unlinkat ( %d, %p(%s) )", ARG1,ARG2,ARG2);
+   PRE_REG_READ2(long, "unlinkat", int, dfd, const char *, pathname);
+   PRE_MEM_RASCIIZ( "unlinkat(pathname)", ARG2 );
+}
+
+PRE(sys_renameat)
+{
+   PRINT("sys_renameat ( %d, %p(%s), %p(%s) )", ARG1,ARG2,ARG2,ARG3,ARG3);
+   PRE_REG_READ3(long, "renameat",
+                 int, dfd, const char *, oldpath, const char *, newpath);
+   PRE_MEM_RASCIIZ( "renameat(oldpath)", ARG2 );
+   PRE_MEM_RASCIIZ( "renameat(newpath)", ARG3 );
+}
+
+PRE(sys_linkat)
+{
+   *flags |= SfMayBlock;
+   PRINT("sys_linkat ( %d, %p(%s), %p(%s) )", ARG1,ARG2,ARG2,ARG3,ARG3);
+   PRE_REG_READ3(long, "linkat",
+                 int, dfd, const char *, oldpath, const char *, newpath);
+   PRE_MEM_RASCIIZ( "linkat(oldpath)", ARG2);
+   PRE_MEM_RASCIIZ( "linkat(newpath)", ARG3);
+}
+
+PRE(sys_symlinkat)
+{
+   *flags |= SfMayBlock;
+   PRINT("sys_symlinkat ( %d, %p(%s), %p(%s) )",ARG1,ARG2,ARG2,ARG3,ARG3);
+   PRE_REG_READ3(long, "symlinkat",
+                 int, dfd, const char *, oldpath, const char *, newpath);
+   PRE_MEM_RASCIIZ( "symlinkat(oldpath)", ARG2 );
+   PRE_MEM_RASCIIZ( "symlinkat(newpath)", ARG3 );
+}
+
+PRE(sys_readlinkat)
+{
+   HChar name[25];
+   Word  saved = SYSNO;
+
+   PRINT("sys_readlinkat ( %d, %p(%s), %p, %llu )", ARG1,ARG2,ARG2,ARG3,(ULong)ARG4);
+   PRE_REG_READ4(long, "readlinkat",
+                 int, dfd, const char *, path, char *, buf, int, bufsiz);
+   PRE_MEM_RASCIIZ( "readlinkat(path)", ARG2 );
+   PRE_MEM_WRITE( "readlinkat(buf)", ARG3,ARG4 );
+
+   /*
+    * Handle the case where readlinkat is looking at /proc/self/exe or
+    * /proc/<pid>/exe.
+    */
+   VG_(sprintf)(name, "/proc/%d/exe", VG_(getpid)());
+   if (ML_(safe_to_deref)((void*)ARG2, 1)
+       && (VG_(strcmp)((Char *)ARG2, name) == 0 
+           || VG_(strcmp)((Char *)ARG2, "/proc/self/exe") == 0)) {
+      VG_(sprintf)(name, "/proc/self/fd/%d", VG_(cl_exec_fd));
+      SET_STATUS_from_SysRes( VG_(do_syscall4)(saved, ARG1, (UWord)name, 
+                                                      ARG3, ARG4));
+   } else {
+      /* Normal case */
+      SET_STATUS_from_SysRes( VG_(do_syscall4)(saved, ARG1, ARG2, ARG3, ARG4));
+   }
+
+   if (SUCCESS && RES > 0)
+      POST_MEM_WRITE( ARG3, RES );
+}
+
+PRE(sys_fchmodat)
+{
+   PRINT("sys_fchmodat ( %d, %p(%s), %d )", ARG1,ARG2,ARG2,ARG3);
+   PRE_REG_READ3(long, "fchmodat",
+                 int, dfd, const char *, path, vki_mode_t, mode);
+   PRE_MEM_RASCIIZ( "fchmodat(path)", ARG2 );
+}
+
+PRE(sys_faccessat)
+{
+   PRINT("sys_faccessat ( %d, %p(%s), %d )", ARG1,ARG2,ARG2,ARG3);
+   PRE_REG_READ3(long, "faccessat",
+                 int, dfd, const char *, pathname, int, mode);
+   PRE_MEM_RASCIIZ( "faccessat(pathname)", ARG2 );
+}
+
 #undef PRE
 #undef POST
 
--- valgrind-3.1.1/coregrind/m_syswrap/syswrap-x86-linux.c.jj	2006-02-22 08:47:05.000000000 -0500
+++ valgrind-3.1.1/coregrind/m_syswrap/syswrap-x86-linux.c	2006-04-12 10:23:34.000000000 -0400
@@ -758,6 +758,7 @@ static void setup_child ( /*OUT*/ Thread
    magic. */
 DECL_TEMPLATE(x86_linux, sys_socketcall);
 DECL_TEMPLATE(x86_linux, sys_stat64);
+DECL_TEMPLATE(x86_linux, sys_fstatat64);
 DECL_TEMPLATE(x86_linux, sys_fstat64);
 DECL_TEMPLATE(x86_linux, sys_lstat64);
 DECL_TEMPLATE(x86_linux, sys_clone);
@@ -771,6 +772,7 @@ DECL_TEMPLATE(x86_linux, sys_set_thread_
 DECL_TEMPLATE(x86_linux, sys_get_thread_area);
 DECL_TEMPLATE(x86_linux, sys_ptrace);
 DECL_TEMPLATE(x86_linux, sys_sigaction);
+DECL_TEMPLATE(x86_linux, sys_sigsuspend);
 DECL_TEMPLATE(x86_linux, old_select);
 DECL_TEMPLATE(x86_linux, sys_vm86old);
 DECL_TEMPLATE(x86_linux, sys_vm86);
@@ -1332,7 +1334,7 @@ POST(sys_lstat64)
 
 PRE(sys_stat64)
 {
-   PRINT("sys_stat64 ( %p, %p )",ARG1,ARG2);
+   PRINT("sys_stat64 ( %p(%s), %p )",ARG1,ARG2,ARG2);
    PRE_REG_READ2(long, "stat64", char *, file_name, struct stat64 *, buf);
    PRE_MEM_RASCIIZ( "stat64(file_name)", ARG1 );
    PRE_MEM_WRITE( "stat64(buf)", ARG2, sizeof(struct vki_stat64) );
@@ -1343,6 +1345,20 @@ POST(sys_stat64)
    POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) );
 }
 
+PRE(sys_fstatat64)
+{
+   PRINT("sys_fstatat64 ( %d, %p(%s), %p )",ARG1,ARG2,ARG2,ARG3);
+   PRE_REG_READ3(long, "fstatat64",
+                 int, dfd, char *, file_name, struct stat64 *, buf);
+   PRE_MEM_RASCIIZ( "fstatat64(file_name)", ARG2 );
+   PRE_MEM_WRITE( "fstatat64(buf)", ARG3, sizeof(struct vki_stat64) );
+}
+
+POST(sys_fstatat64)
+{
+   POST_MEM_WRITE( ARG3, sizeof(struct vki_stat64) );
+}
+
 PRE(sys_fstat64)
 {
    PRINT("sys_fstat64 ( %d, %p )",ARG1,ARG2);
@@ -1679,6 +1695,24 @@ POST(sys_sigaction)
       POST_MEM_WRITE( ARG3, sizeof(struct vki_old_sigaction));
 }
 
+PRE(sys_sigsuspend)
+{
+   /* The C library interface to sigsuspend just takes a pointer to
+      a signal mask but this system call has three arguments - the first
+      two don't appear to be used by the kernel and are always passed as
+      zero by glibc and the third is the first word of the signal mask
+      so only 32 signals are supported.
+     
+      In fact glibc normally uses rt_sigsuspend if it is available as
+      that takes a pointer to the signal mask so supports more signals.
+    */
+   *flags |= SfMayBlock;
+   PRINT("sys_sigsuspend ( %d, %d, %d )", ARG1,ARG2,ARG3 );
+   PRE_REG_READ3(int, "sigsuspend",
+                 int, history0, int, history1,
+                 vki_old_sigset_t, mask);
+}
+
 PRE(sys_vm86old)
 {
    PRINT("sys_vm86old ( %p )", ARG1);
@@ -1848,7 +1882,7 @@ const SyscallTableEntry ML_(syscall_tabl
 //zz 
    LINX_(__NR_setreuid,          sys_setreuid16),     // 70
    LINX_(__NR_setregid,          sys_setregid16),     // 71
-//zz    GENX_(__NR_sigsuspend,        sys_sigsuspend),     // 72
+   PLAX_(__NR_sigsuspend,        sys_sigsuspend),     // 72
    LINXY(__NR_sigpending,        sys_sigpending),     // 73
 //zz    //   (__NR_sethostname,       sys_sethostname),    // 74 */*
 //zz 
@@ -2117,6 +2151,27 @@ const SyscallTableEntry ML_(syscall_tabl
    LINX_(__NR_inotify_init,	 sys_inotify_init),   // 291
    LINX_(__NR_inotify_add_watch, sys_inotify_add_watch), // 292
    LINX_(__NR_inotify_rm_watch,	 sys_inotify_rm_watch), // 293
+//   LINX_(__NR_migrate_pages,	 sys_migrate_pages),    // 294
+
+   LINXY(__NR_openat,		 sys_openat),           // 295
+   LINX_(__NR_mkdirat,		 sys_mkdirat),          // 296
+   LINX_(__NR_mknodat,		 sys_mknodat),          // 297
+   LINX_(__NR_fchownat,		 sys_fchownat),         // 298
+   LINX_(__NR_futimesat,	 sys_futimesat),        // 299
+
+   PLAXY(__NR_fstatat64,	 sys_fstatat64),        // 300
+   LINX_(__NR_unlinkat,		 sys_unlinkat),         // 301
+   LINX_(__NR_renameat,		 sys_renameat),         // 302
+   LINX_(__NR_linkat,		 sys_linkat),           // 303
+   LINX_(__NR_symlinkat,	 sys_symlinkat),        // 304
+
+   LINX_(__NR_readlinkat,	 sys_readlinkat),       // 305
+   LINX_(__NR_fchmodat,		 sys_fchmodat),         // 306
+   LINX_(__NR_faccessat,	 sys_faccessat),        // 307
+   LINX_(__NR_pselect6,		 sys_pselect6),         // 308
+   LINXY(__NR_ppoll,		 sys_ppoll),            // 309
+
+//   LINX_(__NR_unshare,		 sys_unshare),          // 310
 };
 
 const UInt ML_(syscall_table_size) = 

valgrind-3.1.1-syscall-updates.patch:
 syswrap-amd64-linux.c |    4 -
 syswrap-ppc32-linux.c |  132 +++++++++++++++++++++++++-------------------------
 2 files changed, 68 insertions(+), 68 deletions(-)

--- NEW FILE valgrind-3.1.1-syscall-updates.patch ---
--- valgrind-3.1.1/coregrind/m_syswrap/syswrap-ppc32-linux.c.jj	2006-04-12 10:23:34.000000000 -0400
+++ valgrind-3.1.1/coregrind/m_syswrap/syswrap-ppc32-linux.c	2006-04-12 11:15:39.000000000 -0400
@@ -1479,16 +1479,16 @@ const SyscallTableEntry ML_(syscall_tabl
    GENX_(__NR_mknod,             sys_mknod),             // 14
 //.. 
    GENX_(__NR_chmod,             sys_chmod),             // 15
-//..    LINX_(__NR_lchown,            sys_lchown16),          // 16 ## P
+   GENX_(__NR_lchown,            sys_lchown),          // 16 ## P
 //..    GENX_(__NR_break,             sys_ni_syscall),        // 17
 //..    //   (__NR_oldstat,           sys_stat),              // 18 (obsolete)
    LINX_(__NR_lseek,             sys_lseek),             // 19
 //.. 
    GENX_(__NR_getpid,            sys_getpid),            // 20
-//..    LINX_(__NR_mount,             sys_mount),             // 21
-//..    LINX_(__NR_umount,            sys_oldumount),         // 22
-   LINX_(__NR_setuid,            sys_setuid16),          // 23 ## P
-   LINX_(__NR_getuid,            sys_getuid16),          // 24 ## P
+   LINX_(__NR_mount,             sys_mount),             // 21
+   LINX_(__NR_umount,            sys_oldumount),         // 22
+   GENX_(__NR_setuid,            sys_setuid),            // 23 ## P
+   GENX_(__NR_getuid,            sys_getuid),            // 24 ## P
 //.. 
 //..    //   (__NR_stime,             sys_stime),             // 25 * (SVr4,SVID,X/OPEN)
 //..    PLAXY(__NR_ptrace,            sys_ptrace),            // 26
@@ -1515,14 +1515,14 @@ const SyscallTableEntry ML_(syscall_tabl
 //..    GENX_(__NR_prof,              sys_ni_syscall),        // 44
 //.. 
    GENX_(__NR_brk,               sys_brk),               // 45
-   LINX_(__NR_setgid,            sys_setgid16),          // 46
-   LINX_(__NR_getgid,            sys_getgid16),          // 47
+   GENX_(__NR_setgid,            sys_setgid),            // 46
+   GENX_(__NR_getgid,            sys_getgid),            // 47
 //..    //   (__NR_signal,            sys_signal),            // 48 */* (ANSI C)
-   LINX_(__NR_geteuid,           sys_geteuid16),         // 49
+   GENX_(__NR_geteuid,           sys_geteuid),           // 49
 
-   LINX_(__NR_getegid,           sys_getegid16),         // 50
+   GENX_(__NR_getegid,           sys_getegid),           // 50
 //..    GENX_(__NR_acct,              sys_acct),              // 51
-//..    LINX_(__NR_umount2,           sys_umount),            // 52
+   LINX_(__NR_umount2,           sys_umount),            // 52
 //..    GENX_(__NR_lock,              sys_ni_syscall),        // 53
    GENXY(__NR_ioctl,             sys_ioctl),             // 54
 //.. 
@@ -1533,7 +1533,7 @@ const SyscallTableEntry ML_(syscall_tabl
 //..    //   (__NR_oldolduname,       sys_olduname),          // 59 Linux -- obsolete
 
    GENX_(__NR_umask,             sys_umask),             // 60
-//..    GENX_(__NR_chroot,            sys_chroot),            // 61
+   GENX_(__NR_chroot,            sys_chroot),            // 61
 //..    //   (__NR_ustat,             sys_ustat)              // 62 SVr4 -- deprecated
    GENXY(__NR_dup2,              sys_dup2),              // 63
    GENX_(__NR_getppid,           sys_getppid),           // 64
@@ -1544,10 +1544,10 @@ const SyscallTableEntry ML_(syscall_tabl
 //..    //   (__NR_sgetmask,          sys_sgetmask),          // 68 */* (ANSI C)
 //..    //   (__NR_ssetmask,          sys_ssetmask),          // 69 */* (ANSI C)
 //.. 
-//..    LINX_(__NR_setreuid,          sys_setreuid16),        // 70
-//..    LINX_(__NR_setregid,          sys_setregid16),        // 71
+   GENX_(__NR_setreuid,          sys_setreuid),          // 70
+   GENX_(__NR_setregid,          sys_setregid),          // 71
    PLAX_(__NR_sigsuspend,        sys_sigsuspend),        // 72
-//..    LINXY(__NR_sigpending,        sys_sigpending),        // 73
+   LINXY(__NR_sigpending,        sys_sigpending),        // 73
 //..    //   (__NR_sethostname,       sys_sethostname),       // 74 */*
 //.. 
    GENX_(__NR_setrlimit,         sys_setrlimit),              // 75
@@ -1556,8 +1556,8 @@ const SyscallTableEntry ML_(syscall_tabl
    GENXY(__NR_gettimeofday,      sys_gettimeofday),           // 78
 //..    GENX_(__NR_settimeofday,      sys_settimeofday),      // 79
 //.. 
-   LINXY(__NR_getgroups,         sys_getgroups16),       // 80
-//..    LINX_(__NR_setgroups,         sys_setgroups16),       // 81
+   GENXY(__NR_getgroups,         sys_getgroups),         // 80
+   GENX_(__NR_setgroups,         sys_setgroups),         // 81
 //..    PLAX_(__NR_select,            old_select),            // 82
    GENX_(__NR_symlink,           sys_symlink),           // 83
 //..    //   (__NR_oldlstat,          sys_lstat),             // 84 -- obsolete
@@ -1570,17 +1570,17 @@ const SyscallTableEntry ML_(syscall_tabl
 
    PLAX_(__NR_mmap,              sys_mmap),                   // 90
    GENXY(__NR_munmap,            sys_munmap),                 // 91
-//..    GENX_(__NR_truncate,          sys_truncate),          // 92
+   GENX_(__NR_truncate,          sys_truncate),          // 92
    GENX_(__NR_ftruncate,         sys_ftruncate),         // 93
    GENX_(__NR_fchmod,            sys_fchmod),            // 94
 
-   LINX_(__NR_fchown,            sys_fchown16),          // 95
+   GENX_(__NR_fchown,            sys_fchown),            // 95
    GENX_(__NR_getpriority,       sys_getpriority),       // 96
    GENX_(__NR_setpriority,       sys_setpriority),       // 97
 //..    GENX_(__NR_profil,            sys_ni_syscall),        // 98
    GENXY(__NR_statfs,            sys_statfs),            // 99
 //.. 
-//..    GENXY(__NR_fstatfs,           sys_fstatfs),           // 100
+   GENXY(__NR_fstatfs,           sys_fstatfs),           // 100
 //..    LINX_(__NR_ioperm,            sys_ioperm),            // 101
    PLAXY(__NR_socketcall,        sys_socketcall),        // 102
 //..    LINXY(__NR_syslog,            sys_syslog),            // 103
@@ -1625,27 +1625,27 @@ const SyscallTableEntry ML_(syscall_tabl
 //..    //   (__NR_bdflush,           sys_bdflush),           // 134 */Linux
 //.. 
 //..    //   (__NR_sysfs,             sys_sysfs),             // 135 SVr4
-//..    LINX_(__NR_personality,       sys_personality),       // 136
+   LINX_(__NR_personality,       sys_personality),       // 136
 //..    GENX_(__NR_afs_syscall,       sys_ni_syscall),        // 137
-   LINX_(__NR_setfsuid,          sys_setfsuid16),        // 138
-   LINX_(__NR_setfsgid,          sys_setfsgid16),        // 139
+   LINX_(__NR_setfsuid,          sys_setfsuid),          // 138
+   LINX_(__NR_setfsgid,          sys_setfsgid),          // 139
 
    LINXY(__NR__llseek,           sys_llseek),            // 140
    GENXY(__NR_getdents,          sys_getdents),          // 141
    GENX_(__NR__newselect,        sys_select),            // 142
    GENX_(__NR_flock,             sys_flock),             // 143
-//..    GENX_(__NR_msync,             sys_msync),             // 144
+   GENX_(__NR_msync,             sys_msync),             // 144
 //.. 
    GENXY(__NR_readv,             sys_readv),             // 145
    GENX_(__NR_writev,            sys_writev),            // 146
-//..    GENX_(__NR_getsid,            sys_getsid),            // 147
+   GENX_(__NR_getsid,            sys_getsid),            // 147
    GENX_(__NR_fdatasync,         sys_fdatasync),         // 148
    LINXY(__NR__sysctl,           sys_sysctl),            // 149
 //.. 
-//..    GENX_(__NR_mlock,             sys_mlock),             // 150
-//..    GENX_(__NR_munlock,           sys_munlock),           // 151
-//..    GENX_(__NR_mlockall,          sys_mlockall),          // 152
-//..    LINX_(__NR_munlockall,        sys_munlockall),        // 153
+   GENX_(__NR_mlock,             sys_mlock),             // 150
+   GENX_(__NR_munlock,           sys_munlock),           // 151
+   GENX_(__NR_mlockall,          sys_mlockall),          // 152
+   LINX_(__NR_munlockall,        sys_munlockall),        // 153
 //..    LINXY(__NR_sched_setparam,    sys_sched_setparam),    // 154
 //.. 
    LINXY(__NR_sched_getparam,         sys_sched_getparam),        // 155
@@ -1658,35 +1658,35 @@ const SyscallTableEntry ML_(syscall_tabl
 //..    //LINX?(__NR_sched_rr_get_interval,  sys_sched_rr_get_interval), // 161 */*
    GENXY(__NR_nanosleep,         sys_nanosleep),         // 162
    GENX_(__NR_mremap,            sys_mremap),            // 163
-   LINX_(__NR_setresuid,         sys_setresuid16),       // 164
+   LINX_(__NR_setresuid,         sys_setresuid),         // 164
 
-   LINXY(__NR_getresuid,         sys_getresuid16),       // 165
+   LINXY(__NR_getresuid,         sys_getresuid),         // 165
 
 //..    GENX_(__NR_query_module,      sys_ni_syscall),        // 166
    GENXY(__NR_poll,              sys_poll),              // 167
 //..    //   (__NR_nfsservctl,        sys_nfsservctl),        // 168 */Linux
 //.. 
-//..    LINX_(__NR_setresgid,         sys_setresgid16),       // 169
-   LINXY(__NR_getresgid,         sys_getresgid16),       // 170
+   LINX_(__NR_setresgid,         sys_setresgid),         // 169
+   LINXY(__NR_getresgid,         sys_getresgid),         // 170
    LINX_(__NR_prctl,             sys_prctl),             // 171
    PLAX_(__NR_rt_sigreturn,      sys_rt_sigreturn),      // 172
    LINXY(__NR_rt_sigaction,      sys_rt_sigaction),      // 173
 
    LINXY(__NR_rt_sigprocmask,    sys_rt_sigprocmask),    // 174
-//..    LINXY(__NR_rt_sigpending,     sys_rt_sigpending),     // 175
+   LINXY(__NR_rt_sigpending,     sys_rt_sigpending),     // 175
    LINXY(__NR_rt_sigtimedwait,   sys_rt_sigtimedwait),   // 176
-//..    LINXY(__NR_rt_sigqueueinfo,   sys_rt_sigqueueinfo),   // 177
+   LINXY(__NR_rt_sigqueueinfo,   sys_rt_sigqueueinfo),   // 177
    LINX_(__NR_rt_sigsuspend,     sys_rt_sigsuspend),     // 178
 
    GENXY(__NR_pread64,           sys_pread64),           // 179
    GENX_(__NR_pwrite64,          sys_pwrite64),          // 180
-   LINX_(__NR_chown,             sys_chown16),           // 181
+   GENX_(__NR_chown,             sys_chown),             // 181
    GENXY(__NR_getcwd,            sys_getcwd),            // 182
 //..    LINXY(__NR_capget,            sys_capget),            // 183
 //.. 
 //..    LINX_(__NR_capset,            sys_capset),            // 184
    GENXY(__NR_sigaltstack,       sys_sigaltstack),       // 185
-//..    LINXY(__NR_sendfile,          sys_sendfile),          // 186
+   LINXY(__NR_sendfile,          sys_sendfile),          // 186
 //..    GENXY(__NR_getpmsg,           sys_getpmsg),           // 187
 //..    GENX_(__NR_putpmsg,           sys_putpmsg),           // 188
 
@@ -1695,7 +1695,7 @@ const SyscallTableEntry ML_(syscall_tabl
    GENXY(__NR_ugetrlimit,        sys_getrlimit),         // 190
 //__NR_readahead      // 191 ppc/Linux only?
    PLAX_(__NR_mmap2,             sys_mmap2),             // 192
-//..    GENX_(__NR_truncate64,        sys_truncate64),        // 193
+   GENX_(__NR_truncate64,        sys_truncate64),        // 193
    GENX_(__NR_ftruncate64,       sys_ftruncate64),       // 194
 //..    
 
@@ -1719,57 +1719,57 @@ const SyscallTableEntry ML_(syscall_tabl
 //..    LINX_(__NR_lsetxattr,         sys_lsetxattr),         // 210
 //..    LINX_(__NR_fsetxattr,         sys_fsetxattr),         // 211
    LINXY(__NR_getxattr,          sys_getxattr),          // 212
-//..    LINXY(__NR_lgetxattr,         sys_lgetxattr),         // 213
-//..    LINXY(__NR_fgetxattr,         sys_fgetxattr),         // 214
-//..    LINXY(__NR_listxattr,         sys_listxattr),         // 215
-//..    LINXY(__NR_llistxattr,        sys_llistxattr),        // 216
-//..    LINXY(__NR_flistxattr,        sys_flistxattr),        // 217
-//..    LINX_(__NR_removexattr,       sys_removexattr),       // 218
-//..    LINX_(__NR_lremovexattr,      sys_lremovexattr),      // 219
-//..    LINX_(__NR_fremovexattr,      sys_fremovexattr),      // 220
+   LINXY(__NR_lgetxattr,         sys_lgetxattr),         // 213
+   LINXY(__NR_fgetxattr,         sys_fgetxattr),         // 214
+   LINXY(__NR_listxattr,         sys_listxattr),         // 215
+   LINXY(__NR_llistxattr,        sys_llistxattr),        // 216
+   LINXY(__NR_flistxattr,        sys_flistxattr),        // 217
+   LINX_(__NR_removexattr,       sys_removexattr),       // 218
+   LINX_(__NR_lremovexattr,      sys_lremovexattr),      // 219
+   LINX_(__NR_fremovexattr,      sys_fremovexattr),      // 220
 
    LINXY(__NR_futex,             sys_futex),                  // 221
-//..    LINX_(__NR_sched_setaffinity, sys_sched_setaffinity), // 222
-//..    LINXY(__NR_sched_getaffinity, sys_sched_getaffinity), // 223
+   LINX_(__NR_sched_setaffinity, sys_sched_setaffinity), // 222
+   LINXY(__NR_sched_getaffinity, sys_sched_getaffinity), // 223
 /* 224 currently unused */
 
 // __NR_tuxcall                                               // 225
 
-//..    LINXY(__NR_sendfile64,        sys_sendfile64),        // 226
+   LINXY(__NR_sendfile64,        sys_sendfile64),        // 226
 //.. 
-//..    LINX_(__NR_io_setup,          sys_io_setup),          // 227
-//..    LINX_(__NR_io_destroy,        sys_io_destroy),        // 228
-//..    LINXY(__NR_io_getevents,      sys_io_getevents),      // 229
-//..    LINX_(__NR_io_submit,         sys_io_submit),         // 230
-//..    LINXY(__NR_io_cancel,         sys_io_cancel),         // 231
+   LINX_(__NR_io_setup,          sys_io_setup),          // 227
+   LINX_(__NR_io_destroy,        sys_io_destroy),        // 228
+   LINXY(__NR_io_getevents,      sys_io_getevents),      // 229
+   LINX_(__NR_io_submit,         sys_io_submit),         // 230
+   LINXY(__NR_io_cancel,         sys_io_cancel),         // 231
 //.. 
    LINX_(__NR_set_tid_address,   sys_set_tid_address),   // 232
 
 //..    LINX_(__NR_fadvise64,         sys_fadvise64),         // 233 */(Linux?)
    LINX_(__NR_exit_group,        sys_exit_group),        // 234
 //..    GENXY(__NR_lookup_dcookie,    sys_lookup_dcookie),    // 235
-//..    LINXY(__NR_epoll_create,      sys_epoll_create),      // 236
-//..    LINX_(__NR_epoll_ctl,         sys_epoll_ctl),         // 237
-//..    LINXY(__NR_epoll_wait,        sys_epoll_wait),        // 238
+   LINXY(__NR_epoll_create,      sys_epoll_create),      // 236
+   LINX_(__NR_epoll_ctl,         sys_epoll_ctl),         // 237
+   LINXY(__NR_epoll_wait,        sys_epoll_wait),        // 238
 
 //..    //   (__NR_remap_file_pages,  sys_remap_file_pages),  // 239 */Linux
-//..    LINXY(__NR_timer_create,      sys_timer_create),      // 240
-//..    LINXY(__NR_timer_settime,     sys_timer_settime),     // 241
-//..    LINXY(__NR_timer_gettime,     sys_timer_gettime),     // 242
-//..    LINX_(__NR_timer_getoverrun,  sys_timer_getoverrun),  // 243
-//..    LINX_(__NR_timer_delete,      sys_timer_delete),      // 244
-//..    LINX_(__NR_clock_settime,     sys_clock_settime),     // 245
+   LINXY(__NR_timer_create,      sys_timer_create),      // 240
+   LINXY(__NR_timer_settime,     sys_timer_settime),     // 241
+   LINXY(__NR_timer_gettime,     sys_timer_gettime),     // 242
+   LINX_(__NR_timer_getoverrun,  sys_timer_getoverrun),  // 243
+   LINX_(__NR_timer_delete,      sys_timer_delete),      // 244
+   LINX_(__NR_clock_settime,     sys_clock_settime),     // 245
    LINXY(__NR_clock_gettime,     sys_clock_gettime),     // 246
    LINXY(__NR_clock_getres,      sys_clock_getres),      // 247
-//..    LINXY(__NR_clock_nanosleep,   sys_clock_nanosleep),   // 248
+   LINXY(__NR_clock_nanosleep,   sys_clock_nanosleep),   // 248
 
 // __NR_swapcontext                                           // 249
 
    LINXY(__NR_tgkill,            sys_tgkill),            // 250 */Linux
 //..    GENX_(__NR_utimes,            sys_utimes),            // 251
-//..    GENXY(__NR_statfs64,          sys_statfs64),          // 252
-//..    GENXY(__NR_fstatfs64,         sys_fstatfs64),         // 253
-//..    LINX_(__NR_fadvise64_64,      sys_fadvise64_64),      // 254 */(Linux?)
+   GENXY(__NR_statfs64,          sys_statfs64),          // 252
+   GENXY(__NR_fstatfs64,         sys_fstatfs64),         // 253
+   LINX_(__NR_fadvise64_64,      sys_fadvise64_64),      // 254 */(Linux?)
 
 // __NR_rtas                                                  // 255
 
--- valgrind-3.1.1/coregrind/m_syswrap/syswrap-amd64-linux.c.jj	2006-04-12 10:22:08.000000000 -0400
+++ valgrind-3.1.1/coregrind/m_syswrap/syswrap-amd64-linux.c	2006-04-12 11:21:55.000000000 -0400
@@ -1012,7 +1012,7 @@ const SyscallTableEntry ML_(syscall_tabl
    GENXY(__NR_setitimer,         sys_setitimer),      // 38 
    GENX_(__NR_getpid,            sys_getpid),         // 39 
 
-   //   (__NR_sendfile,          sys_sendfile64),     // 40 
+   LINXY(__NR_sendfile,          sys_sendfile),       // 40 
    PLAXY(__NR_socket,            sys_socket),         // 41 
    PLAX_(__NR_connect,           sys_connect),        // 42
    PLAXY(__NR_accept,            sys_accept),         // 43 
@@ -1163,7 +1163,7 @@ const SyscallTableEntry ML_(syscall_tabl
    GENX_(__NR_settimeofday,      sys_settimeofday),   // 164 
 
    LINX_(__NR_mount,             sys_mount),          // 165
-   //   (__NR_umount2,           sys_umount),         // 166 
+   LINX_(__NR_umount2,           sys_umount),         // 166 
    //   (__NR_swapon,            sys_swapon),         // 167 
    //   (__NR_swapoff,           sys_swapoff),        // 168 
    //   (__NR_reboot,            sys_reboot),         // 169 


Index: valgrind.spec
===================================================================
RCS file: /cvs/dist/rpms/valgrind/devel/valgrind.spec,v
retrieving revision 1.29
retrieving revision 1.30
diff -u -r1.29 -r1.30
--- valgrind.spec	3 Apr 2006 16:55:06 -0000	1.29
+++ valgrind.spec	12 Apr 2006 15:25:26 -0000	1.30
@@ -1,13 +1,15 @@
 Summary: Tool for finding memory management bugs in programs
 Name: valgrind
 Version: 3.1.1
-Release: 1
+Release: 2
 Epoch: 1
 Source0: http://www.valgrind.org/downloads/valgrind-%{version}.tar.bz2
 Patch1: valgrind-3.1.1-valgrind_h.patch
 Patch2: valgrind-3.1.1-amd64-speedup.patch
 Patch3: valgrind-3.1.1-cfa-val-expr.patch
 Patch4: valgrind-3.1.1-glibc24.patch
+Patch5: valgrind-3.1.1-syscall-updates-from-trunk.patch
+Patch6: valgrind-3.1.1-syscall-updates.patch
 License: GPL
 URL: http://www.valgrind.org/
 Group: Development/Debuggers
@@ -34,6 +36,8 @@
 %patch2 -p1
 %patch3 -p1
 %patch4 -p1
+%patch5 -p1
+%patch6 -p1
 
 %build
 %ifarch x86_64
@@ -111,6 +115,9 @@
 %{_mandir}/man1/valgrind*
 
 %changelog
+* Wed Apr 12 2006 Jakub Jelinek <jakub at redhat.com> 3.1.1-2
+- handle many syscalls that were unhandled before, especially on ppc
+
 * Mon Apr  3 2006 Jakub Jelinek <jakub at redhat.com> 3.1.1-1
 - upgrade to 3.1.1
   - many bugfixes




More information about the fedora-cvs-commits mailing list