Some ioctls have flags fields that are 64-bit. A 32-bit val means
these flags will never be matched or printed.
* util.c:
(xlookup) Use uint64_t for val.
(xlat_search) Likewise.
(printxvals) Likewise.
(addflags64) New function.
(printflags64) New function.
(sprintflags64) New function.
(addflags) Use unsigned int for val and convert to wrapper for *64.
(printflags) Likewise.
(sprintflags) Likewise.
* defs.h: (struct xlat) Use uint_64 for val.
---
defs.h | 17 ++++++++++-------
util.c | 46 ++++++++++++++++++++++++++++++++--------------
2 files changed, 42 insertions(+), 21 deletions(-)
diff --git a/defs.h b/defs.h
index f095ff6..ead12dd 100644
--- a/defs.h
+++ b/defs.h
@@ -361,7 +361,7 @@ typedef uint8_t qualbits_t;
#define filtered(tcp) ((tcp)->flags & TCB_FILTERED)
struct xlat {
- unsigned int val;
+ uint64_t val;
const char *str;
};
#define XLAT(x) { x, #x }
@@ -526,8 +526,8 @@ extern void pathtrace_select(const char *);
extern int pathtrace_match(struct tcb *);
extern int getfdpath(struct tcb *, int, char *, unsigned);
-extern const char *xlookup(const struct xlat *, const unsigned int);
-extern const char *xlat_search(const struct xlat *, const size_t, const
unsigned int);
+extern const char *xlookup(const struct xlat *, const uint64_t);
+extern const char *xlat_search(const struct xlat *, const size_t, const
uint64_t);
extern unsigned long get_pagesize(void);
extern int string_to_uint(const char *str);
@@ -554,15 +554,18 @@ extern int printllval(struct tcb *, const char *, int)
ATTRIBUTE_FORMAT((printf, 2, 0));
extern void printaddr(long);
-extern void printxvals(const unsigned int, const char *, const struct xlat *,
...);
+extern void printxvals(const uint64_t, const char *, const struct xlat *, ...);
#define printxval(xlat, val, dflt) printxvals(val, dflt, xlat, NULL)
extern int printargs(struct tcb *);
extern int printargs_u(struct tcb *);
extern int printargs_d(struct tcb *);
-extern void addflags(const struct xlat *, int);
-extern int printflags(const struct xlat *, int, const char *);
-extern const char *sprintflags(const char *, const struct xlat *, int);
+extern void addflags(const struct xlat *, unsigned int);
+extern void addflags64(const struct xlat *, uint64_t);
+extern int printflags(const struct xlat *, unsigned int, const char *);
+extern int printflags64(const struct xlat *, uint64_t, const char *);
+extern const char *sprintflags(const char *, const struct xlat *, unsigned
int);
+extern const char *sprintflags64(const char *, const struct xlat *, uint64_t);
extern const char *sprintmode(int);
extern const char *sprinttime(time_t);
extern void dumpiov_in_msghdr(struct tcb *, long, unsigned long);
diff --git a/util.c b/util.c
index 1e5aecc..3968cf0 100644
--- a/util.c
+++ b/util.c
@@ -121,7 +121,7 @@ tv_mul(struct timeval *tv, const struct timeval *a, int n)
}
const char *
-xlookup(const struct xlat *xlat, const unsigned int val)
+xlookup(const struct xlat *xlat, const uint64_t val)
{
for (; xlat->str != NULL; xlat++)
if (xlat->val == val)
@@ -132,16 +132,16 @@ xlookup(const struct xlat *xlat, const unsigned int val)
static int
xlat_bsearch_compare(const void *a, const void *b)
{
- const unsigned int val1 = (const unsigned long) a;
- const unsigned int val2 = ((const struct xlat *) b)->val;
+ const uint64_t val1 = *(const uint64_t *) a;
+ const uint64_t val2 = ((const struct xlat *) b)->val;
return (val1 > val2) ? 1 : (val1 < val2) ? -1 : 0;
}
const char *
-xlat_search(const struct xlat *xlat, const size_t nmemb, const unsigned int
val)
+xlat_search(const struct xlat *xlat, const size_t nmemb, const uint64_t val)
{
const struct xlat *e =
- bsearch((const void*) (const unsigned long) val,
+ bsearch((const void*) &val,
xlat, nmemb, sizeof(*xlat), xlat_bsearch_compare);
return e ? e->str : NULL;
@@ -208,7 +208,7 @@ next_set_bit(const void *bit_array, unsigned cur_bit,
unsigned size_bits)
* Print entry in struct xlat table, if there.
*/
void
-printxvals(const unsigned int val, const char *dflt, const struct xlat *xlat,
...)
+printxvals(const uint64_t val, const char *dflt, const struct xlat *xlat, ...)
{
va_list args;
@@ -223,7 +223,7 @@ printxvals(const unsigned int val, const char *dflt, const
struct xlat *xlat, ..
}
}
/* No hits -- print raw # instead. */
- tprintf("%#x /* %s */", val, dflt);
+ tprintf("%#" PRIx64 " /* %s */", val, dflt);
va_end(args);
}
@@ -303,7 +303,7 @@ printllval(struct tcb *tcp, const char *format, int arg_no)
* return # of flags printed.
*/
void
-addflags(const struct xlat *xlat, int flags)
+addflags64(const struct xlat *xlat, uint64_t flags)
{
for (; xlat->str; xlat++) {
if (xlat->val && (flags & xlat->val) == xlat->val) {
@@ -312,17 +312,23 @@ addflags(const struct xlat *xlat, int flags)
}
}
if (flags) {
- tprintf("|%#x", flags);
+ tprintf("|%#" PRIx64, flags);
}
}
+void
+addflags(const struct xlat *xlat, unsigned int flags)
+{
+ return addflags64(xlat, flags);
+}
+
/*
* Interpret `xlat' as an array of flags.
* Print to static string the entries whose bits are on in `flags'
* Return static string.
*/
const char *
-sprintflags(const char *prefix, const struct xlat *xlat, int flags)
+sprintflags64(const char *prefix, const struct xlat *xlat, uint64_t flags)
{
static char outstr[1024];
char *outptr;
@@ -349,14 +355,20 @@ sprintflags(const char *prefix, const struct xlat *xlat,
int flags)
if (flags) {
if (found)
*outptr++ = '|';
- outptr += sprintf(outptr, "%#x", flags);
+ outptr += sprintf(outptr, "%#" PRIx64, flags);
}
return outstr;
}
+const char *
+sprintflags(const char *prefix, const struct xlat *xlat, unsigned int flags)
+{
+ return sprintflags64(prefix, xlat, flags);
+}
+
int
-printflags(const struct xlat *xlat, int flags, const char *dflt)
+printflags64(const struct xlat *xlat, uint64_t flags, const char *dflt)
{
int n;
const char *sep;
@@ -378,12 +390,12 @@ printflags(const struct xlat *xlat, int flags, const char
*dflt)
if (n) {
if (flags) {
- tprintf("%s%#x", sep, flags);
+ tprintf("%s%#" PRIx64, sep, flags);
n++;
}
} else {
if (flags) {
- tprintf("%#x", flags);
+ tprintf("%#" PRIx64, flags);
if (dflt)
tprintf(" /* %s */", dflt);
} else {
@@ -395,6 +407,12 @@ printflags(const struct xlat *xlat, int flags, const char
*dflt)
return n;
}
+int
+printflags(const struct xlat *xlat, unsigned int flags, const char *dflt)
+{
+ return printflags64(xlat, flags, dflt);
+}
+
void
printaddr(const long addr)
{
--
2.7.1
------------------------------------------------------------------------------
Transform Data into Opportunity.
Accelerate data analysis in your applications with
Intel Data Analytics Acceleration Library.
Click to learn more.
http://pubads.g.doubleclick.net/gampad/clk?id=278785471&iu=/4140
_______________________________________________
Strace-devel mailing list
Strace-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/strace-devel
