Use ptr_to_kulong instead of explicit casts of pointers to kernel_ureg_t

Direct casts to kernel_ureg_t will not work after the change
of kernel_ureg_t from unsigned long to kernel_ulong_t.

* defs.h (ptr_to_kulong): New macro.
* block.c (print_blkpg_req): Use it instead of explicit casts
to kernel_ureg_t.
* btrfs.c (btrfs_ioctl): Likewise.
* evdev.c (ff_effect_ioctl): Likewise.
* mmsghdr.c (dumpiov_in_mmsghdr): Likewise.
* msghdr.c (print_struct_msghdr, dumpiov_in_msghdr): Likewise.
* mtd.c (decode_mtd_oob_buf): Likewise.
* printsiginfo.c (printsigval, print_si_info): Likewise.
* scsi.c (print_sg_io_v3_req, print_sg_io_v3_res): Likewise.
* sigaltstack.c (print_stack_t): Likewise.
* sock.c (decode_ifconf): Likewise.
* sysctl.c (SYS_FUNC(sysctl)): Likewise.
* util.c (dumpiov_upto): Likewise.
* v4l2.c (print_v4l2_framebuffer, print_v4l2_ext_control,
print_v4l2_ext_controls): Likewise.

diff --git a/block.c b/block.c
index d6b6a793c7237add5ac59e3012b31dd8199df5e3..b885839cfdfcd883ade79aafabba790024098d93 100644 (file)
--- a/block.c
+++ b/block.c
@@ -129,7 +129,7 @@ print_blkpg_req(struct tcb *tcp, const struct_blkpg_ioctl_arg *blkpg)
        tprintf(", flags=%d, datalen=%d, data=",
                blkpg->flags, blkpg->datalen);
 
-       if (!umove_or_printaddr(tcp, (kernel_ureg_t) blkpg->data, &p)) {
+       if (!umove_or_printaddr(tcp, ptr_to_kulong(blkpg->data), &p)) {
                tprintf("{start=%" PRId64 ", length=%" PRId64
                        ", pno=%d, devname=",
                        p.start, p.length, p.pno);

diff --git a/btrfs.c b/btrfs.c
index 01340a4ad3da11db7179a53ccfddd7b4492697c8..87bb3d827c75b33ff994055e207d94e10e4ac03b 100644 (file)
--- a/btrfs.c
+++ b/btrfs.c
@@ -1217,7 +1217,7 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl,
                        tprints("...");
                else {
                        uint64_t record;
-                       print_array(tcp, (kernel_ureg_t) args.clone_sources,
+                       print_array(tcp, ptr_to_kulong(args.clone_sources),
                                    args.clone_sources_count,
                                    &record, sizeof(record),
                                    umoven_or_printaddr,
@@ -1321,7 +1321,7 @@ MPERS_PRINTER_DECL(int, btrfs_ioctl,
                                        (uint64_t) args.size);
 
                                btrfs_print_qgroup_inherit(tcp,
-                                       (kernel_ureg_t) args.qgroup_inherit);
+                                       ptr_to_kulong(args.qgroup_inherit));
                        }
                        tprints(", name=");
                        print_quoted_string(args.name, sizeof(args.name),

diff --git a/defs.h b/defs.h
index 9a1aee71f4efa9348aa9c6268d86865dc3174095..2b31350875732707b032fd5cd83d7117484b3256 100644 (file)
--- a/defs.h
+++ b/defs.h
@@ -884,6 +884,11 @@ extern unsigned current_klongsize;
 # define widen_to_ulong(v) ((unsigned long)(v))
 #endif
 
+/*
+ * Cast a pointer or a pointer-sized integer to kernel_ureg_t.
+ */
+#define ptr_to_kulong(v) ((kernel_ureg_t) (unsigned long) (v))
+
 /*
  * Zero-extend a signed integer type to unsigned long long.
  */

diff --git a/evdev.c b/evdev.c
index 42abcb32b69fcd3cf92c22e759bf2fd1f4455bb1..94842ba3d3131bb57566178cfae417a73c529265 100644 (file)
--- a/evdev.c
+++ b/evdev.c
@@ -135,7 +135,7 @@ ff_effect_ioctl(struct tcb *const tcp, const kernel_ureg_t arg)
                        decode_envelope(&ffe.u.periodic.envelope);
                        tprintf(", custom_len=%u, custom_data=",
                                ffe.u.periodic.custom_len);
-                       printaddr((kernel_ureg_t) ffe.u.periodic.custom_data);
+                       printaddr(ptr_to_kulong(ffe.u.periodic.custom_data));
                        tprints("}");
                        break;
                case FF_RUMBLE:

diff --git a/mmsghdr.c b/mmsghdr.c
index a21a3003c1bb902c8a59ac53d7ee393497ca03e7..94fee4070171957b49d6bea04ce5cc853d0ca47e 100644 (file)
--- a/mmsghdr.c
+++ b/mmsghdr.c
@@ -162,7 +162,8 @@ dumpiov_in_mmsghdr(struct tcb *const tcp, kernel_ureg_t addr)
                tprintf(" = %lu buffers in vector %u\n",
                        (kernel_ureg_t) mmsg.msg_hdr.msg_iovlen, i);
                dumpiov_upto(tcp, mmsg.msg_hdr.msg_iovlen,
-                       (kernel_ureg_t) mmsg.msg_hdr.msg_iov, mmsg.msg_len);
+                            ptr_to_kulong(mmsg.msg_hdr.msg_iov),
+                            mmsg.msg_len);
        }
 }
 

diff --git a/msghdr.c b/msghdr.c
index cdd037cd4adb5579527b670514dadc2c634ebb59..7a830b9523b04b2c831e85102bb59e95bf3a111d 100644 (file)
--- a/msghdr.c
+++ b/msghdr.c
@@ -342,7 +342,7 @@ print_struct_msghdr(struct tcb *tcp, const struct msghdr *msg,
 
        tprints("{msg_name=");
        const int family =
-               decode_sockaddr(tcp, (kernel_ureg_t) msg->msg_name, msg_namelen);
+               decode_sockaddr(tcp, ptr_to_kulong(msg->msg_name), msg_namelen);
        const enum iov_decode decode =
                (family == AF_NETLINK) ? IOV_DECODE_NETLINK : IOV_DECODE_STR;
 
@@ -354,10 +354,10 @@ print_struct_msghdr(struct tcb *tcp, const struct msghdr *msg,
        tprints(", msg_iov=");
 
        tprint_iov_upto(tcp, msg->msg_iovlen,
-                       (kernel_ureg_t) msg->msg_iov, decode, data_size);
+                       ptr_to_kulong(msg->msg_iov), decode, data_size);
        tprintf(", msg_iovlen=%lu", (kernel_ureg_t) msg->msg_iovlen);
 
-       decode_msg_control(tcp, (kernel_ureg_t) msg->msg_control,
+       decode_msg_control(tcp, ptr_to_kulong(msg->msg_control),
                           msg->msg_controllen);
        tprintf(", msg_controllen=%lu", (kernel_ureg_t) msg->msg_controllen);
 
@@ -400,7 +400,7 @@ dumpiov_in_msghdr(struct tcb *const tcp, const kernel_ureg_t addr,
 
        if (fetch_struct_msghdr(tcp, addr, &msg)) {
                dumpiov_upto(tcp, msg.msg_iovlen,
-                            (kernel_ureg_t) msg.msg_iov, data_size);
+                            ptr_to_kulong(msg.msg_iov), data_size);
        }
 }
 

diff --git a/mtd.c b/mtd.c
index d6abf4b17d99bf2f73479065ec3d4d47c10b5a44..8c049b2ecfe030b6992a2dbb8b55180021d60d56 100644 (file)
--- a/mtd.c
+++ b/mtd.c
@@ -84,7 +84,7 @@ decode_mtd_oob_buf(struct tcb *const tcp, const kernel_ureg_t addr)
                return;
 
        tprintf("{start=%#x, length=%#x, ptr=", mbuf.start, mbuf.length);
-       printaddr((kernel_ureg_t) mbuf.ptr);
+       printaddr(ptr_to_kulong(mbuf.ptr));
        tprints("}");
 }
 

diff --git a/printsiginfo.c b/printsiginfo.c
index d991e8fbf314f91af49c6fb04554bb141aa8c0ad..70e392bcf6012314cc9f2ac0a9cc6f6bf62113f0 100644 (file)
--- a/printsiginfo.c
+++ b/printsiginfo.c
@@ -77,7 +77,7 @@ static void
 printsigval(const siginfo_t *sip)
 {
        tprintf(", si_value={int=%d, ptr=", sip->si_int);
-       printaddr((kernel_ureg_t) sip->si_ptr);
+       printaddr(ptr_to_kulong(sip->si_ptr));
        tprints("}");
 }
 
@@ -178,7 +178,7 @@ print_si_info(const siginfo_t *sip)
                case SIGILL: case SIGFPE:
                case SIGSEGV: case SIGBUS:
                        tprints(", si_addr=");
-                       printaddr((kernel_ureg_t) sip->si_addr);
+                       printaddr(ptr_to_kulong(sip->si_addr));
                        break;
                case SIGPOLL:
                        switch (sip->si_code) {
@@ -194,7 +194,7 @@ print_si_info(const siginfo_t *sip)
                                syscall_name((unsigned) sip->si_syscall);
 
                        tprints(", si_call_addr=");
-                       printaddr((kernel_ureg_t) sip->si_call_addr);
+                       printaddr(ptr_to_kulong(sip->si_call_addr));
                        tprints(", si_syscall=");
                        if (scname)
                                tprintf("__NR_%s", scname);

diff --git a/scsi.c b/scsi.c
index db59323d9318280c4ffcd3b8becffef750f51b80..71fd2e2c6b2b580a78f9b35a391fb189573ae0f5 100644 (file)
--- a/scsi.c
+++ b/scsi.c
@@ -73,7 +73,7 @@ print_sg_io_v3_req(struct tcb *const tcp, const kernel_ureg_t arg)
        printxval(sg_io_dxfer_direction, sg_io.dxfer_direction,
                  "SG_DXFER_???");
        tprintf(", cmd[%u]=", sg_io.cmd_len);
-       print_sg_io_buffer(tcp, (kernel_ureg_t) sg_io.cmdp, sg_io.cmd_len);
+       print_sg_io_buffer(tcp, ptr_to_kulong(sg_io.cmdp), sg_io.cmd_len);
        tprintf(", mx_sb_len=%d", sg_io.mx_sb_len);
        tprintf(", iovec_count=%d", sg_io.iovec_count);
        tprintf(", dxfer_len=%u", sg_io.dxfer_len);
@@ -85,11 +85,11 @@ print_sg_io_v3_req(struct tcb *const tcp, const kernel_ureg_t arg)
                tprintf(", data[%u]=", sg_io.dxfer_len);
                if (sg_io.iovec_count)
                        tprint_iov_upto(tcp, sg_io.iovec_count,
-                                       (kernel_ureg_t) sg_io.dxferp,
+                                       ptr_to_kulong(sg_io.dxferp),
                                        IOV_DECODE_STR,
                                        sg_io.dxfer_len);
                else
-                       print_sg_io_buffer(tcp, (kernel_ureg_t) sg_io.dxferp,
+                       print_sg_io_buffer(tcp, ptr_to_kulong(sg_io.dxferp),
                                           sg_io.dxfer_len);
        }
        return 1;
@@ -114,17 +114,17 @@ print_sg_io_v3_res(struct tcb *const tcp, const kernel_ureg_t arg)
                tprintf(", data[%u]=", din_len);
                if (sg_io.iovec_count)
                        tprint_iov_upto(tcp, sg_io.iovec_count,
-                                       (kernel_ureg_t) sg_io.dxferp,
+                                       ptr_to_kulong(sg_io.dxferp),
                                        syserror(tcp) ? IOV_DECODE_ADDR :
                                        IOV_DECODE_STR, din_len);
                else
-                       print_sg_io_buffer(tcp, (kernel_ureg_t) sg_io.dxferp,
+                       print_sg_io_buffer(tcp, ptr_to_kulong(sg_io.dxferp),
                                           din_len);
        }
        tprintf(", status=%02x", sg_io.status);
        tprintf(", masked_status=%02x", sg_io.masked_status);
        tprintf(", sb[%u]=", sg_io.sb_len_wr);
-       print_sg_io_buffer(tcp, (kernel_ureg_t) sg_io.sbp, sg_io.sb_len_wr);
+       print_sg_io_buffer(tcp, ptr_to_kulong(sg_io.sbp), sg_io.sb_len_wr);
        tprintf(", host_status=%#x", sg_io.host_status);
        tprintf(", driver_status=%#x", sg_io.driver_status);
        tprintf(", resid=%d", sg_io.resid);

diff --git a/sigaltstack.c b/sigaltstack.c
index 0cb0ba7a4113e517bca26b0af89455418b4b465c..1265990f053897781e452dad2cb4c84d5c6ed341 100644 (file)
--- a/sigaltstack.c
+++ b/sigaltstack.c
@@ -49,7 +49,7 @@ print_stack_t(struct tcb *const tcp, const kernel_ureg_t addr)
                return;
 
        tprints("{ss_sp=");
-       printaddr((kernel_ureg_t) ss.ss_sp);
+       printaddr(ptr_to_kulong(ss.ss_sp));
        tprints(", ss_flags=");
        printflags(sigaltstack_flags, ss.ss_flags, "SS_???");
        tprintf(", ss_size=%lu}", (kernel_ureg_t) ss.ss_size);

diff --git a/sock.c b/sock.c
index b7336f436a182b783bb2bd4fb30955f9a20ab056..1af989413d30c2e722ec9606ebaa47cbd48d9412 100644 (file)
--- a/sock.c
+++ b/sock.c
@@ -171,7 +171,7 @@ decode_ifconf(struct tcb *const tcp, const kernel_ureg_t addr)
 
        struct ifreq ifra[nifra > max_strlen ? max_strlen : nifra];
        tprints(", ");
-       if (umove_or_printaddr(tcp, (kernel_ureg_t) ifc.ifc_buf, &ifra)) {
+       if (umove_or_printaddr(tcp, ptr_to_kulong(ifc.ifc_buf), &ifra)) {
                tprints("}");
                return RVAL_DECODED | 1;
        }

diff --git a/sysctl.c b/sysctl.c
index 94779572a112331f75990728738550b92c796127..38436931c7ce944fbd73158ede1d3812a269f4b5 100644 (file)
--- a/sysctl.c
+++ b/sysctl.c
@@ -167,13 +167,13 @@ SYS_FUNC(sysctl)
                size_t oldlen = 0;
                if (info.oldval == NULL) {
                        tprints("NULL");
-               } else if (umove(tcp, (kernel_ureg_t) info.oldlenp, &oldlen) >= 0
+               } else if (umove(tcp, ptr_to_kulong(info.oldlenp), &oldlen) >= 0
                           && info.nlen >= 2
                           && ((name[0] == CTL_KERN
                                && (name[1] == KERN_OSRELEASE
                                    || name[1] == KERN_OSTYPE
                                        )))) {
-                       printpath(tcp, (kernel_ureg_t) info.oldval);
+                       printpath(tcp, ptr_to_kulong(info.oldval));
                } else {
                        tprintf("%p", info.oldval);
                }
@@ -183,7 +183,7 @@ SYS_FUNC(sysctl)
                else if (syserror(tcp))
                        tprintf("%p", info.newval);
                else
-                       printpath(tcp, (kernel_ureg_t) info.newval);
+                       printpath(tcp, ptr_to_kulong(info.newval));
                tprintf(", %lu", (unsigned long)info.newlen);
        }
 

diff --git a/util.c b/util.c
index d5366c43d4414dac5922f61e87d8439ea1e5c8d1..ed95d0f205cb4e1bc4f9398b5cbde4e12e0895b7 100644 (file)
--- a/util.c
+++ b/util.c
@@ -933,7 +933,7 @@ dumpiov_upto(struct tcb *const tcp, const int len, const kernel_ureg_t addr,
 #else
        struct iovec *iov;
 #define sizeof_iov sizeof(*iov)
-#define iov_iov_base(i) iov[i].iov_base
+#define iov_iov_base(i) ptr_to_kulong(iov[i].iov_base)
 #define iov_iov_len(i) iov[i].iov_len
 #endif
        int i;
@@ -957,7 +957,7 @@ dumpiov_upto(struct tcb *const tcp, const int len, const kernel_ureg_t addr,
                        /* include the buffer number to make it easy to
                         * match up the trace with the source */
                        tprintf(" * %lu bytes in buffer %d\n", iov_len, i);
-                       dumpstr(tcp, (kernel_ureg_t) iov_iov_base(i), iov_len);
+                       dumpstr(tcp, iov_iov_base(i), iov_len);
                }
        }
        free(iov);

diff --git a/v4l2.c b/v4l2.c
index e746a1ed263bb02ecec875206177f442339407df..628ac3ad1201bea45a0b2e182363e81f2b7bafe5 100644 (file)
--- a/v4l2.c
+++ b/v4l2.c
@@ -388,7 +388,7 @@ print_v4l2_framebuffer(struct tcb *const tcp, const kernel_ureg_t arg)
        if (!umove_or_printaddr(tcp, arg, &b)) {
                tprintf("{capability=%#x, flags=%#x, base=",
                        b.capability, b.flags);
-               printaddr((kernel_ureg_t) b.base);
+               printaddr(ptr_to_kulong(b.base));
                tprints("}");
        }
 
@@ -668,7 +668,7 @@ print_v4l2_ext_control(struct tcb *tcp, void *elem_buf, size_t elem_size, void *
        tprintf(", size=%u", p->size);
        if (p->size > 0) {
                tprints(", string=");
-               printstrn(tcp, (kernel_ureg_t) p->string, p->size);
+               printstrn(tcp, ptr_to_kulong(p->string), p->size);
        } else
 # endif
        tprintf(", value=%d, value64=%" PRId64, p->value, (int64_t) p->value64);
@@ -710,7 +710,7 @@ print_v4l2_ext_controls(struct tcb *const tcp, const kernel_ureg_t arg,
 
        tprints("controls=");
        struct_v4l2_ext_control ctrl;
-       bool fail = !print_array(tcp, (kernel_ureg_t) c.controls, c.count,
+       bool fail = !print_array(tcp, ptr_to_kulong(c.controls), c.count,
                                 &ctrl, sizeof(ctrl),
                                 umoven_or_printaddr_ignore_syserror,
                                 print_v4l2_ext_control, 0);