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
------------------------------------------------------------------------------
Find and fix application performance issues faster with Applications Manager
Applications Manager provides deep performance insights into multiple tiers of
your business applications. It resolves application problems quickly and
reduces your MTTR. Get your free trial!
https://ad.doubleclick.net/ddm/clk/302982198;130105516;z
_______________________________________________
Strace-devel mailing list
Strace-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/strace-devel
