ptp.c: enhance ptp ioctl parser

* ptp.c: Include <linux/ioctl.h> instead of <sys/ioctl.h>.
Update for RVAL_DECODED.
(ptp_ioctl): Use umove_or_printaddr.

diff --git a/ptp.c b/ptp.c
index dbd35834880442a501104d8d4f1a9a207f9b56d9..f6cc1ab5dfafe08c35602179efc0a95c96e0e69f 100644 (file)
--- a/ptp.c
+++ b/ptp.c
@@ -1,98 +1,110 @@
 #include "defs.h"
-#include <sys/ioctl.h>
+#include <linux/ioctl.h>
 #include <linux/ptp_clock.h>
 
 #include "xlat/ptp_flags_options.h"
 
 int
-ptp_ioctl(struct tcb *tcp, const unsigned int code, long arg)
+ptp_ioctl(struct tcb *tcp, const unsigned int code, const long arg)
 {
        if (!verbose(tcp))
-               return 0;
+               return RVAL_DECODED;
 
        switch (code) {
-               case PTP_CLOCK_GETCAPS: /* decode on exit */
-               {
-                       struct ptp_clock_caps caps;
+       case PTP_EXTTS_REQUEST: {
+               struct ptp_extts_request extts;
 
-                       if (entering(tcp) || syserror(tcp) ||
-                           umove(tcp, arg, &caps) < 0)
-                               return 0;
+               tprints(", ");
+               if (umove_or_printaddr(tcp, arg, &extts))
+                       break;
 
-                       tprintf(", {max_adj=%d, n_alarm=%d, n_ext_ts=%d, n_per_out=%d, pps=%d}",
-                               caps.max_adj, caps.n_alarm, caps.n_ext_ts,
-                               caps.n_per_out, caps.pps);
-                       return 1;
-               }
+               tprintf("{index=%d, flags=", extts.index);
+               printflags(ptp_flags_options, extts.flags, "PTP_???");
+               tprints("}");
+               break;
+       }
 
-               case PTP_EXTTS_REQUEST: /* decode on enter */
-               {
-                       struct ptp_extts_request extts;
+       case PTP_PEROUT_REQUEST: {
+               struct ptp_perout_request perout;
 
-                       if (exiting(tcp))
-                               return 1;
-                       if (umove(tcp, arg, &extts) < 0) {
-                               tprintf(", %#lx", arg);
-                               return 0;
-                       }
-                       tprintf(", {index=%d, flags=", extts.index);
-                       printflags(ptp_flags_options, extts.flags, "PTP_???");
-                       tprints("}");
-                       return 1;
-               }
+               tprints(", ");
+               if (umove_or_printaddr(tcp, arg, &perout))
+                       break;
 
-               case PTP_PEROUT_REQUEST: /* decode on enter */
-               {
-                       struct ptp_perout_request perout;
+               tprintf("{start={%" PRId64 ", %" PRIu32 "}"
+                          ", period={%" PRId64 ", %" PRIu32 "}"
+                          ", index=%d, flags=",
+                       (int64_t)perout.start.sec, perout.start.nsec,
+                       (int64_t)perout.period.sec, perout.period.nsec,
+                       perout.index);
+               printflags(ptp_flags_options, perout.flags, "PTP_???");
+               tprints("}");
+               break;
+       }
 
-                       if (exiting(tcp))
-                               return 1;
-                       if (umove(tcp, arg, &perout) < 0) {
-                               tprintf(", %#lx", arg);
-                               return 0;
-                       }
+       case PTP_ENABLE_PPS:
+               tprintf(", %ld", arg);
+               break;
 
-                       tprintf(", {start={%" PRId64 ", %" PRIu32 "}"
-                                  ", period={%" PRId64 ", %" PRIu32 "}"
-                                  ", index=%d, flags=",
-                               (int64_t)perout.start.sec, perout.start.nsec,
-                               (int64_t)perout.period.sec, perout.period.nsec,
-                               perout.index);
-                       printflags(ptp_flags_options, perout.flags, "PTP_???");
-                       tprints("}");
-                       return 1;
-               }
+       case PTP_SYS_OFFSET: {
+               struct ptp_sys_offset sysoff;
+
+               if (entering(tcp)) {
+                       tprints(", ");
+                       if (umove_or_printaddr(tcp, arg, &sysoff))
+                               break;
 
-               case PTP_ENABLE_PPS: /* decode on enter */
-                       if (entering(tcp))
-                               tprintf(", %ld", arg);
+                       tprintf("{n_samples=%u", sysoff.n_samples);
                        return 1;
+               } else {
+                       unsigned int n_samples, i;
 
-               case PTP_SYS_OFFSET: /* decode on exit */
-               {
-                       struct ptp_sys_offset sysoff;
-                       unsigned int i;
+                       if (syserror(tcp)) {
+                               tprints("}");
+                               break;
+                       }
 
-                       if (entering(tcp) || umove(tcp, arg, &sysoff) < 0)
-                               return 0;
+                       tprints(", ");
+                       if (umove(tcp, arg, &sysoff) < 0) {
+                               tprints("???}");
+                               break;
+                       }
 
-                       tprintf(", {n_samples=%u, ts={", sysoff.n_samples);
-                       if (syserror(tcp)) {
-                               tprints("...}}");
-                               return 1;
+                       tprints("ts=[");
+                       n_samples = sysoff.n_samples > PTP_MAX_SAMPLES ?
+                               PTP_MAX_SAMPLES : sysoff.n_samples;
+                       for (i = 0; i < 2 * n_samples + 1; ++i) {
+                               if (i > 0)
+                                       tprints(", ");
+                               tprintf("{%" PRId64 ", %" PRIu32 "}",
+                                       (int64_t)sysoff.ts[i].sec,
+                                       sysoff.ts[i].nsec);
                        }
                        if (sysoff.n_samples > PTP_MAX_SAMPLES)
-                               sysoff.n_samples = PTP_MAX_SAMPLES;
-                       tprintf("{%" PRId64 ", %" PRIu32 "}",
-                               (int64_t)sysoff.ts[0].sec, sysoff.ts[0].nsec);
-                       for (i = 1; i < 2*sysoff.n_samples+1; ++i)
-                               tprintf(", {%" PRId64 ", %" PRIu32 "}",
-                                       (int64_t)sysoff.ts[i].sec, sysoff.ts[i].nsec);
-                       tprints("}}");
-                       return 1;
+                               tprints(", ...");
+                       tprints("]}");
+                       break;
                }
+       }
+       case PTP_CLOCK_GETCAPS: {
+               struct ptp_clock_caps caps;
 
-               default: /* decode on exit */
+               if (entering(tcp))
                        return 0;
+
+               tprints(", ");
+               if (umove_or_printaddr(tcp, arg, &caps))
+                       break;
+
+               tprintf("{max_adj=%d, n_alarm=%d, n_ext_ts=%d, n_per_out=%d, pps=%d}",
+                       caps.max_adj, caps.n_alarm, caps.n_ext_ts,
+                       caps.n_per_out, caps.pps);
+               break;
        }
+
+       default:
+               return RVAL_DECODED;
+       }
+
+       return RVAL_DECODED | 1;
 }