strace/xlat.c
Eugene Syromyatnikov e8c3f34edd Introduce xlat verbosity styles
* defs.h (printxvals_ex): Rename from printxvals, add style argument.
(enum xlat_style): New enumeration.
(printxvals): New macro, a wrapper for printxvals_ex.
(printxval_searchn_ex): Rename from printxval_searchn, add style
argument.
(printxval_searchn): New macro, a wrapper for printxval_searchn_ex.
(printxval_search_ex): New macro, a wrapper for printxval_searchn_ex.
(sprintxval_ex): Rename from sprintxval, add style argument.
(sprintxval): New macro, a wrapper for sprintxval_ex.
(printflags_ex): Add style argument.
(sprintflags_ex): Rename from sprintflags, add style argument.
(sprintflags): New macro, a wrapper for sprintflags_ex.
(printflags64): Pass XLAT_STYLE_ABBREV as a style in printflags_ex call.
* netlink.c (decode_nlmsg_flags): Pass XLAT_STYLE_ABBREV as a style in
printflags_ex call.
* xlat.c (printxvals_ex): Rename from printxvals, add style argument,
handle it.
(sprintxval_ex): Rename from sprintxval, add style argument, handle it.
(printxval_searchn_ex): Rename from printxval_searchn, add style
argument, handle it.
(sprintflags_ex): Rename from sprintflags, add style argument,
handle it.
(printflags_ex): Add style argument, handle it.

Co-Authored-by: Dmitry V. Levin <ldv@altlinux.org>
References: https://github.com/strace/strace/issues/27
2018-04-13 00:25:13 +02:00

343 lines
10 KiB
C

/*
* Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl>
* Copyright (c) 1993 Branko Lankester <branko@hacktic.nl>
* Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com>
* Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl>
* Copyright (c) 1999-2018 The strace developers.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "defs.h"
#include "xstring.h"
#include <stdarg.h>
const char *
xlookup(const struct xlat *xlat, const uint64_t val)
{
for (; xlat->str != NULL; xlat++)
if (xlat->val == val)
return xlat->str;
return NULL;
}
static int
xlat_bsearch_compare(const void *a, const void *b)
{
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 uint64_t val)
{
const struct xlat *e =
bsearch((const void *) &val,
xlat, nmemb, sizeof(*xlat), xlat_bsearch_compare);
return e ? e->str : NULL;
}
/**
* Print entry in struct xlat table, if there.
*
* @param val Value to search a literal representation for.
* @param dflt String (abbreviated in comment syntax) which should be emitted
* if no appropriate xlat value has been found.
* @param style Style in which xlat value should be printed.
* @param xlat (And the following arguments) Pointers to arrays of xlat values.
* The last argument should be NULL.
* @return 1 if appropriate xlat value has been found, 0 otherwise.
*/
int
printxvals_ex(const uint64_t val, const char *dflt, enum xlat_style style,
const struct xlat *xlat, ...)
{
if (style == XLAT_STYLE_RAW) {
tprintf("%#" PRIx64, val);
return 0;
}
va_list args;
va_start(args, xlat);
for (; xlat; xlat = va_arg(args, const struct xlat *)) {
const char *str = xlookup(xlat, val);
if (str) {
if (style == XLAT_STYLE_VERBOSE) {
tprintf("%#" PRIx64, val);
tprints_comment(str);
} else {
tprints(str);
}
va_end(args);
return 1;
}
}
/* No hits -- print raw # instead. */
tprintf("%#" PRIx64, val);
tprints_comment(dflt);
va_end(args);
return 0;
}
int
sprintxval_ex(char *const buf, const size_t size, const struct xlat *const x,
const unsigned int val, const char *const dflt,
enum xlat_style style)
{
if (style == XLAT_STYLE_RAW)
return xsnprintf(buf, size, "%#x", val);
const char *const str = xlookup(x, val);
if (str) {
if (style == XLAT_STYLE_VERBOSE)
return xsnprintf(buf, size, "%#x /* %s */", val, str);
else
return xsnprintf(buf, size, "%s", str);
}
if (dflt)
return xsnprintf(buf, size, "%#x /* %s */", val, dflt);
return xsnprintf(buf, size, "%#x", val);
}
/**
* Print entry in sorted struct xlat table, if it is there.
*
* @param xlat Pointer to an array of xlat values (not terminated with
* XLAT_END).
* @param xlat_size Number of xlat elements present in array (usually ARRAY_SIZE
* if array is declared in the unit's scope and not
* terminated with XLAT_END).
* @param val Value to search literal representation for.
* @param dflt String (abbreviated in comment syntax) which should be
* emitted if no appropriate xlat value has been found.
* @param style Style in which xlat value should be printed.
* @return 1 if appropriate xlat value has been found, 0
* otherwise.
*/
int
printxval_searchn_ex(const struct xlat *xlat, size_t xlat_size, uint64_t val,
const char *dflt, enum xlat_style style)
{
if (style == XLAT_STYLE_RAW) {
tprintf("%#" PRIx64, val);
return 0;
}
const char *s = xlat_search(xlat, xlat_size, val);
if (s) {
if (style == XLAT_STYLE_VERBOSE) {
tprintf("%#" PRIx64, val);
tprints_comment(s);
} else {
tprints(s);
}
return 1;
}
tprintf("%#" PRIx64, val);
tprints_comment(dflt);
return 0;
}
/*
* Interpret `xlat' as an array of flags.
* Print to static string the entries whose bits are on in `flags'
* Return static string. If 0 is provided as flags, and there is no flag that
* has the value of 0 (it should be the first in xlat table), return NULL.
*
* Expected output:
* +------------+------------+---------+------------+
* | flags != 0 | xlat found | style | output |
* +------------+------------+---------+------------+
* | false | (any) | raw | <none> |
* | true | (any) | raw | VAL |
* +------------+------------+---------+------------+
* | false | false | abbrev | <none> |
* | true | false | abbrev | VAL |
* | (any) | true | abbrev | XLAT |
* +------------+------------+---------+------------+
* | false | false | verbose | <none> |
* | true | false | verbose | VAL |
* | (any) | true | verbose | VAL (XLAT) |
* +------------+------------+---------+------------+
*/
const char *
sprintflags_ex(const char *prefix, const struct xlat *xlat, uint64_t flags,
enum xlat_style style)
{
static char outstr[1024];
char *outptr;
int found = 0;
outptr = stpcpy(outstr, prefix);
if (style == XLAT_STYLE_RAW) {
if (!flags)
return NULL;
outptr = xappendstr(outstr, outptr, "%#" PRIx64, flags);
return outstr;
}
if (flags == 0 && xlat->val == 0 && xlat->str) {
if (style == XLAT_STYLE_VERBOSE) {
outptr = xappendstr(outstr, outptr, "0 /* %s */",
xlat->str);
} else {
strcpy(outptr, xlat->str);
}
return outstr;
}
if (style == XLAT_STYLE_VERBOSE && flags)
outptr = xappendstr(outstr, outptr, "%#" PRIx64, flags);
for (; flags && xlat->str; xlat++) {
if (xlat->val && (flags & xlat->val) == xlat->val) {
if (found)
*outptr++ = '|';
else if (style == XLAT_STYLE_VERBOSE)
outptr = stpcpy(outptr, " /* ");
outptr = stpcpy(outptr, xlat->str);
found = 1;
flags &= ~xlat->val;
}
}
if (flags) {
if (found)
*outptr++ = '|';
if (found || style != XLAT_STYLE_VERBOSE)
outptr = xappendstr(outstr, outptr, "%#" PRIx64, flags);
} else {
if (!found)
return NULL;
}
if (found && style == XLAT_STYLE_VERBOSE)
outptr = stpcpy(outptr, " */");
return outstr;
}
/**
* Print flags from multiple xlat tables.
*
* Expected output:
* +------------+--------------+------------+---------+------------+
* | flags != 0 | dflt != NULL | xlat found | style | output |
* +------------+--------------+------------+---------+------------+
* | false | false | (any) | raw | <none> |
* | false | true | (any) | raw | VAL |
* | true | (any) | (any) | raw | VAL |
* +------------+--------------+------------+---------+------------+
* | false | false | false | abbrev | <none> |
* | false | true | false | abbrev | VAL |
* | true | false | false | abbrev | VAL |
* | true | true | false | abbrev | VAL (DFLT) |
* | (any) | (any) | true | abbrev | XLAT |
* +------------+--------------+------------+---------+------------+
* | false | false | false | verbose | <none> |
* | false | true | false | verbose | VAL |
* | true | false | false | verbose | VAL |
* | true | true | false | verbose | VAL (DFLT) |
* | (any) | (any) | true | verbose | VAL (XLAT) |
* +------------+--------------+------------+---------+------------+
*/
int
printflags_ex(uint64_t flags, const char *dflt, enum xlat_style style,
const struct xlat *xlat, ...)
{
if (style == XLAT_STYLE_RAW) {
if (flags || dflt) {
tprintf("%#" PRIx64, flags);
return 1;
}
return 0;
}
const char *init_sep = "";
unsigned int n = 0;
va_list args;
if (style == XLAT_STYLE_VERBOSE) {
init_sep = " /* ";
if (flags)
tprintf("%#" PRIx64, flags);
}
va_start(args, xlat);
for (; xlat; xlat = va_arg(args, const struct xlat *)) {
for (; (flags || !n) && xlat->str; ++xlat) {
if ((flags == xlat->val) ||
(xlat->val && (flags & xlat->val) == xlat->val)) {
if (style == XLAT_STYLE_VERBOSE && !flags)
tprints("0");
tprintf("%s%s",
(n++ ? "|" : init_sep), xlat->str);
flags &= ~xlat->val;
}
if (!flags)
break;
}
}
va_end(args);
if (n) {
if (flags) {
tprintf("|%#" PRIx64, flags);
n++;
}
if (style == XLAT_STYLE_VERBOSE)
tprints(" */");
} else {
if (flags) {
if (style != XLAT_STYLE_VERBOSE)
tprintf("%#" PRIx64, flags);
tprints_comment(dflt);
} else {
if (dflt)
tprints("0");
}
}
return n;
}