granicus.if.org Git - strace/blob - print_timeval.c

   1 /*
   2  * Copyright (c) 2015-2017 Dmitry V. Levin <ldv@altlinux.org>
   3  * Copyright (c) 2016-2019 The strace developers.
   4  * All rights reserved.
   5  *
   6  * SPDX-License-Identifier: LGPL-2.1-or-later
   7  */
   8
   9 #include "defs.h"
  10
  11 #include DEF_MPERS_TYPE(timeval_t)
  12
  13 typedef struct timeval timeval_t;
  14
  15 #include MPERS_DEFS
  16
  17 #include "xstring.h"
  18
  19 static const char timeval_fmt[]  = "{tv_sec=%lld, tv_usec=%llu}";
  20
  21 static void
  22 print_timeval_t(const timeval_t *t)
  23 {
  24         tprintf(timeval_fmt, (long long) t->tv_sec,
  25                 zero_extend_signed_to_ull(t->tv_usec));
  26 }
  27
  28 static void
  29 print_timeval_t_utime(const timeval_t *t)
  30 {
  31         print_timeval_t(t);
  32         tprints_comment(sprinttime_usec(t->tv_sec,
  33                 zero_extend_signed_to_ull(t->tv_usec)));
  34 }
  35
  36 MPERS_PRINTER_DECL(void, print_struct_timeval, const void *arg)
  37 {
  38         print_timeval_t(arg);
  39 }
  40
  41 MPERS_PRINTER_DECL(bool, print_struct_timeval_data_size,
  42                    const void *arg, const size_t size)
  43 {
  44         if (size < sizeof(timeval_t)) {
  45                 tprints("?");
  46                 return false;
  47         }
  48
  49         print_timeval_t(arg);
  50         return true;
  51 }
  52
  53 MPERS_PRINTER_DECL(int, print_timeval,
  54                    struct tcb *const tcp, const kernel_ulong_t addr)
  55 {
  56         timeval_t t;
  57
  58         if (umove_or_printaddr(tcp, addr, &t))
  59                 return -1;
  60
  61         print_timeval_t(&t);
  62         return 0;
  63 }
  64
  65 MPERS_PRINTER_DECL(int, print_timeval_utimes,
  66                    struct tcb *const tcp, const kernel_ulong_t addr)
  67 {
  68         timeval_t t[2];
  69
  70         if (umove_or_printaddr(tcp, addr, &t))
  71                 return -1;
  72
  73         tprints("[");
  74         print_timeval_t_utime(&t[0]);
  75         tprints(", ");
  76         print_timeval_t_utime(&t[1]);
  77         tprints("]");
  78         return 0;
  79 }
  80
  81 MPERS_PRINTER_DECL(const char *, sprint_timeval,
  82                    struct tcb *const tcp, const kernel_ulong_t addr)
  83 {
  84         timeval_t t;
  85         static char buf[sizeof(timeval_fmt) + 3 * sizeof(t)];
  86
  87         if (!addr) {
  88                 strcpy(buf, "NULL");
  89         } else if (!verbose(tcp) || (exiting(tcp) && syserror(tcp)) ||
  90                    umove(tcp, addr, &t)) {
  91                 xsprintf(buf, "%#" PRI_klx, addr);
  92         } else {
  93                 xsprintf(buf, timeval_fmt,
  94                          (long long) t.tv_sec,
  95                          zero_extend_signed_to_ull(t.tv_usec));
  96         }
  97
  98         return buf;
  99 }
 100
 101 MPERS_PRINTER_DECL(int, print_itimerval,
 102                    struct tcb *const tcp, const kernel_ulong_t addr)
 103 {
 104         timeval_t t[2];
 105
 106         if (umove_or_printaddr(tcp, addr, &t))
 107                 return -1;
 108
 109         tprints("{it_interval=");
 110         print_timeval_t(&t[0]);
 111         tprints(", it_value=");
 112         print_timeval_t(&t[1]);
 113         tprints("}");
 114         return 0;
 115 }
 116
 117 #ifdef ALPHA
 118
 119 void
 120 print_timeval32_t(const timeval32_t *t)
 121 {
 122         tprintf(timeval_fmt, (long long) t->tv_sec,
 123                 zero_extend_signed_to_ull(t->tv_usec));
 124 }
 125
 126 static void
 127 print_timeval32_t_utime(const timeval32_t *t)
 128 {
 129         print_timeval32_t(t);
 130         tprints_comment(sprinttime_usec(t->tv_sec,
 131                 zero_extend_signed_to_ull(t->tv_usec)));
 132 }
 133
 134 int
 135 print_timeval32(struct tcb *const tcp, const kernel_ulong_t addr)
 136 {
 137         timeval32_t t;
 138
 139         if (umove_or_printaddr(tcp, addr, &t))
 140                 return -1;
 141
 142         print_timeval32_t(&t);
 143         return 0;
 144 }
 145
 146 int
 147 print_timeval32_utimes(struct tcb *const tcp, const kernel_ulong_t addr)
 148 {
 149         timeval32_t t[2];
 150
 151         if (umove_or_printaddr(tcp, addr, &t))
 152                 return -1;
 153
 154         tprints("[");
 155         print_timeval32_t_utime(&t[0]);
 156         tprints(", ");
 157         print_timeval32_t_utime(&t[1]);
 158         tprints("]");
 159         return 0;
 160 }
 161
 162 int
 163 print_itimerval32(struct tcb *const tcp, const kernel_ulong_t addr)
 164 {
 165         timeval32_t t[2];
 166
 167         if (umove_or_printaddr(tcp, addr, &t))
 168                 return -1;
 169
 170         tprints("{it_interval=");
 171         print_timeval32_t(&t[0]);
 172         tprints(", it_value=");
 173         print_timeval32_t(&t[1]);
 174         tprints("}");
 175         return 0;
 176 }
 177
 178 const char *
 179 sprint_timeval32(struct tcb *const tcp, const kernel_ulong_t addr)
 180 {
 181         timeval32_t t;
 182         static char buf[sizeof(timeval_fmt) + 3 * sizeof(t)];
 183
 184         if (!addr) {
 185                 strcpy(buf, "NULL");
 186         } else if (!verbose(tcp) || (exiting(tcp) && syserror(tcp)) ||
 187                    umove(tcp, addr, &t)) {
 188                 xsprintf(buf, "%#" PRI_klx, addr);
 189         } else {
 190                 xsprintf(buf, timeval_fmt,
 191                          (long long) t.tv_sec,
 192                          zero_extend_signed_to_ull(t.tv_usec));
 193         }
 194
 195         return buf;
 196 }
 197
 198 #endif /* ALPHA */