Convert parsers of flock structures to new mpers infrastructure

* fetch_struct_flock.c: New file.
* Makefile.am (strace_SOURCES): Add it.
* fcntl.c (print_struct_flock64): New function.
(printflock64): Use fetch_struct_flock64 and print_struct_flock64.
(printflock): Use fetch_struct_flock and print_struct_flock64.

diff --git a/Makefile.am b/Makefile.am
index 55379b739321c7e85ea414a49839bee6489846fd..81f0b6d80016ea1b1055b355ff7859d0221fcb35 100644 (file)
--- a/Makefile.am
+++ b/Makefile.am
@@ -62,6 +62,7 @@ strace_SOURCES =      \
        fchownat.c      \
        fcntl.c         \
        fetch_seccomp_fprog.c \
+       fetch_struct_flock.c \
        file.c          \
        file_handle.c   \
        flock.c         \

diff --git a/fcntl.c b/fcntl.c
index 3ca78c99e36c35acfeab6698104f8cd39aa24fd2..a864682db1c8678d827aa321a6029ffe584fd498 100644 (file)
--- a/fcntl.c
+++ b/fcntl.c
@@ -39,73 +39,35 @@
 #include "xlat/notifyflags.h"
 
 static void
-printflock64(struct tcb *tcp, long addr, int getlk)
+print_struct_flock64(const struct_kernel_flock64 *fl, const int getlk)
+{
+       tprints("{l_type=");
+       printxval(lockfcmds, fl->l_type, "F_???");
+       tprints(", l_whence=");
+       printxval(whence_codes, fl->l_whence, "SEEK_???");
+       tprintf(", l_start=%Ld, l_len=%Ld",
+               (long long) fl->l_start, (long long) fl->l_len);
+       if (getlk)
+               tprintf(", l_pid=%lu", (unsigned long) fl->l_pid);
+       tprints("}");
+}
+
+static void
+printflock64(struct tcb *tcp, const long addr, const int getlk)
 {
        struct_kernel_flock64 fl;
 
-       if (umove_or_printaddr(tcp, addr, &fl))
-               return;
-       tprints("{type=");
-       printxval(lockfcmds, fl.l_type, "F_???");
-       tprints(", whence=");
-       printxval(whence_codes, fl.l_whence, "SEEK_???");
-       tprintf(", start=%lld, len=%lld", (long long) fl.l_start, (long long) fl.l_len);
-       if (getlk)
-               tprintf(", pid=%lu}", (unsigned long) fl.l_pid);
-       else
-               tprints("}");
+       if (fetch_struct_flock64(tcp, addr, &fl))
+               print_struct_flock64(&fl, getlk);
 }
 
 static void
-printflock(struct tcb *tcp, long addr, int getlk)
+printflock(struct tcb *tcp, const long addr, const int getlk)
 {
-       struct_kernel_flock fl;
+       struct_kernel_flock64 fl;
 
-#if SUPPORTED_PERSONALITIES > 1
-       if (
-# if SIZEOF_OFF_T > SIZEOF_LONG
-           current_personality != DEFAULT_PERSONALITY &&
-# endif
-           current_wordsize != sizeof(fl.l_start)) {
-               if (current_wordsize == 4) {
-                       /* 32-bit x86 app on x86_64 and similar cases */
-                       struct {
-                               short int l_type;
-                               short int l_whence;
-                               int32_t l_start; /* off_t */
-                               int32_t l_len; /* off_t */
-                               int32_t l_pid; /* pid_t */
-                       } fl32;
-                       if (umove_or_printaddr(tcp, addr, &fl32))
-                               return;
-                       fl.l_type = fl32.l_type;
-                       fl.l_whence = fl32.l_whence;
-                       fl.l_start = fl32.l_start;
-                       fl.l_len = fl32.l_len;
-                       fl.l_pid = fl32.l_pid;
-               } else {
-                       /* let people know we have a problem here */
-                       tprintf("<decode error: unsupported wordsize %d>",
-                               current_wordsize);
-                       return;
-               }
-       } else
-#endif
-       if (umove_or_printaddr(tcp, addr, &fl))
-               return;
-       tprints("{type=");
-       printxval(lockfcmds, fl.l_type, "F_???");
-       tprints(", whence=");
-       printxval(whence_codes, fl.l_whence, "SEEK_???");
-#if SIZEOF_OFF_T > SIZEOF_LONG
-       tprintf(", start=%lld, len=%lld", fl.l_start, fl.l_len);
-#else
-       tprintf(", start=%ld, len=%ld", fl.l_start, fl.l_len);
-#endif
-       if (getlk)
-               tprintf(", pid=%lu}", (unsigned long) fl.l_pid);
-       else
-               tprints("}");
+       if (fetch_struct_flock(tcp, addr, &fl))
+               print_struct_flock64(&fl, getlk);
 }
 
 static void

diff --git a/fetch_struct_flock.c b/fetch_struct_flock.c
new file mode 100644 (file)
index 0000000..cd195e2
--- /dev/null
+++ b/fetch_struct_flock.c
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2015 Dmitry V. Levin <ldv@altlinux.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "defs.h"
+
+#include DEF_MPERS_TYPE(struct_flock)
+#include DEF_MPERS_TYPE(struct_flock64)
+
+#include "flock.h"
+typedef struct_kernel_flock struct_flock;
+typedef struct_kernel_flock64 struct_flock64;
+
+#include MPERS_DEFS
+
+#define SIZEOF_MEMBER(type, member) \
+       sizeof(((type *) NULL)->member)
+
+#define FLOCK_MEMBERS_EQ(type, member) \
+       (SIZEOF_MEMBER(struct_kernel_flock64, member) == SIZEOF_MEMBER(type, member) \
+        && offsetof(struct_kernel_flock64, member) == offsetof(type, member))
+
+#define FLOCK_STRUCTS_EQ(type) \
+       (sizeof(struct_kernel_flock64) == sizeof(type) \
+        && FLOCK_MEMBERS_EQ(type, l_type) \
+        && FLOCK_MEMBERS_EQ(type, l_whence) \
+        && FLOCK_MEMBERS_EQ(type, l_start) \
+        && FLOCK_MEMBERS_EQ(type, l_len) \
+        && FLOCK_MEMBERS_EQ(type, l_pid))
+
+MPERS_PRINTER_DECL(bool, fetch_struct_flock)(struct tcb *tcp, const long addr, void *p)
+{
+       struct_kernel_flock64 *pfl = p;
+       struct_flock mfl;
+
+       if (FLOCK_STRUCTS_EQ(struct_flock))
+               return !umove_or_printaddr(tcp, addr, pfl);
+
+       if (umove_or_printaddr(tcp, addr, &mfl))
+               return false;
+
+       pfl->l_type = mfl.l_type;
+       pfl->l_whence = mfl.l_whence;
+       pfl->l_start = mfl.l_start;
+       pfl->l_len = mfl.l_len;
+       pfl->l_pid = mfl.l_pid;
+       return true;
+}
+
+MPERS_PRINTER_DECL(bool, fetch_struct_flock64)(struct tcb *tcp, const long addr, void *p)
+{
+       struct_kernel_flock64 *pfl = p;
+       struct_flock64 mfl;
+
+       if (FLOCK_STRUCTS_EQ(struct_flock64))
+               return !umove_or_printaddr(tcp, addr, pfl);
+
+       if (umove_or_printaddr(tcp, addr, &mfl))
+               return false;
+
+       pfl->l_type = mfl.l_type;
+       pfl->l_whence = mfl.l_whence;
+       pfl->l_start = mfl.l_start;
+       pfl->l_len = mfl.l_len;
+       pfl->l_pid = mfl.l_pid;
+       return true;
+}