518 lines
14 KiB
C
518 lines
14 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>
|
|
|
|
static inline enum xlat_style
|
|
get_xlat_style(enum xlat_style style)
|
|
{
|
|
if (xlat_verbose(style) == XLAT_STYLE_DEFAULT)
|
|
return style | xlat_verbosity;
|
|
|
|
return style;
|
|
}
|
|
|
|
static inline const char *
|
|
sprint_xlat_val(uint64_t val, enum xlat_style style)
|
|
{
|
|
static char buf[sizeof(val) * 3];
|
|
|
|
switch (xlat_format(style)) {
|
|
case XLAT_STYLE_FMT_D:
|
|
xsprintf(buf, "%" PRId64, val);
|
|
break;
|
|
|
|
case XLAT_STYLE_FMT_U:
|
|
xsprintf(buf, "%" PRIu64, val);
|
|
break;
|
|
|
|
case XLAT_STYLE_FMT_X:
|
|
xsprintf(buf, "%#" PRIx64, val);
|
|
break;
|
|
}
|
|
|
|
return buf;
|
|
}
|
|
|
|
static inline void
|
|
print_xlat_val(uint64_t val, enum xlat_style style)
|
|
{
|
|
tprints(sprint_xlat_val(val, style));
|
|
}
|
|
|
|
const char *
|
|
xlookup(const struct xlat *xlat, const uint64_t val)
|
|
{
|
|
static const struct xlat *pos;
|
|
|
|
if (xlat)
|
|
pos = xlat;
|
|
|
|
for (; pos->str != NULL; pos++)
|
|
if (pos->val == val)
|
|
return pos->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)
|
|
{
|
|
static const struct xlat *pos;
|
|
static size_t memb_left;
|
|
|
|
if (xlat) {
|
|
pos = xlat;
|
|
memb_left = nmemb;
|
|
}
|
|
|
|
const struct xlat *e =
|
|
bsearch((const void *) &val,
|
|
pos, memb_left, sizeof(*pos), xlat_bsearch_compare);
|
|
|
|
if (e) {
|
|
memb_left -= e - pos;
|
|
return e->str;
|
|
} else {
|
|
return 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, ...)
|
|
{
|
|
static const struct xlat *last;
|
|
|
|
style = get_xlat_style(style);
|
|
|
|
if (xlat_verbose(style) == XLAT_STYLE_RAW) {
|
|
print_xlat_val(val, style);
|
|
return 0;
|
|
}
|
|
|
|
const char *str = NULL;
|
|
va_list args;
|
|
|
|
va_start(args, xlat);
|
|
|
|
if (!xlat)
|
|
xlat = last;
|
|
|
|
for (; xlat; xlat = va_arg(args, const struct xlat *)) {
|
|
last = xlat;
|
|
|
|
str = xlookup(xlat, val);
|
|
|
|
if (str) {
|
|
if (xlat_verbose(style) == XLAT_STYLE_VERBOSE) {
|
|
print_xlat_val(val, style);
|
|
tprints_comment(str);
|
|
} else {
|
|
tprints(str);
|
|
}
|
|
|
|
goto printxvals_ex_end;
|
|
}
|
|
}
|
|
|
|
/* No hits -- print raw # instead. */
|
|
print_xlat_val(val, style);
|
|
tprints_comment(dflt);
|
|
|
|
printxvals_ex_end:
|
|
va_end(args);
|
|
|
|
return !!str;
|
|
}
|
|
|
|
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)
|
|
{
|
|
style = get_xlat_style(style);
|
|
|
|
if (xlat_verbose(style) == XLAT_STYLE_RAW)
|
|
return xsnprintf(buf, size, "%s", sprint_xlat_val(val, style));
|
|
|
|
const char *const str = xlookup(x, val);
|
|
|
|
if (str) {
|
|
if (xlat_verbose(style) == XLAT_STYLE_VERBOSE)
|
|
return xsnprintf(buf, size, "%s /* %s */",
|
|
sprint_xlat_val(val, style), str);
|
|
else
|
|
return xsnprintf(buf, size, "%s", str);
|
|
}
|
|
if (dflt)
|
|
return xsnprintf(buf, size, "%s /* %s */",
|
|
sprint_xlat_val(val, style), dflt);
|
|
|
|
return xsnprintf(buf, size, "%s", sprint_xlat_val(val, style));
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
* @param fn Search function.
|
|
* @return 1 if appropriate xlat value has been found, 0
|
|
* otherwise.
|
|
*/
|
|
static int
|
|
printxval_sized(const struct xlat *xlat, size_t xlat_size, uint64_t val,
|
|
const char *dflt, enum xlat_style style,
|
|
const char *(* fn)(const struct xlat *, size_t, uint64_t))
|
|
{
|
|
style = get_xlat_style(style);
|
|
|
|
if (xlat_verbose(style) == XLAT_STYLE_RAW) {
|
|
print_xlat_val(val, style);
|
|
return 0;
|
|
}
|
|
|
|
const char *s = fn(xlat, xlat_size, val);
|
|
|
|
if (s) {
|
|
if (xlat_verbose(style) == XLAT_STYLE_VERBOSE) {
|
|
print_xlat_val(val, style);
|
|
tprints_comment(s);
|
|
} else {
|
|
tprints(s);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
print_xlat_val(val, style);
|
|
tprints_comment(dflt);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
printxval_searchn_ex(const struct xlat *xlat, size_t xlat_size, uint64_t val,
|
|
const char *dflt, enum xlat_style style)
|
|
{
|
|
return printxval_sized(xlat, xlat_size, val, dflt, style,
|
|
xlat_search);
|
|
}
|
|
|
|
const char *
|
|
xlat_idx(const struct xlat *xlat, size_t nmemb, uint64_t val)
|
|
{
|
|
static const struct xlat *pos;
|
|
static size_t memb_left;
|
|
|
|
if (xlat) {
|
|
pos = xlat;
|
|
memb_left = nmemb;
|
|
}
|
|
|
|
if (val >= memb_left)
|
|
return NULL;
|
|
|
|
if (val != pos[val].val) {
|
|
error_func_msg("Unexpected xlat value %" PRIu64
|
|
" at index %" PRIu64,
|
|
pos[val].val, val);
|
|
return NULL;
|
|
}
|
|
|
|
return pos[val].str;
|
|
}
|
|
|
|
int
|
|
printxval_indexn_ex(const struct xlat *xlat, size_t xlat_size, uint64_t val,
|
|
const char *dflt, enum xlat_style style)
|
|
{
|
|
return printxval_sized(xlat, xlat_size, val, dflt, style, xlat_idx);
|
|
}
|
|
|
|
/*
|
|
* 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);
|
|
style = get_xlat_style(style);
|
|
|
|
if (xlat_verbose(style) == XLAT_STYLE_RAW) {
|
|
if (!flags)
|
|
return NULL;
|
|
|
|
outptr = xappendstr(outstr, outptr, "%s",
|
|
sprint_xlat_val(flags, style));
|
|
|
|
return outstr;
|
|
}
|
|
|
|
if (flags == 0 && xlat->val == 0 && xlat->str) {
|
|
if (xlat_verbose(style) == XLAT_STYLE_VERBOSE) {
|
|
outptr = xappendstr(outstr, outptr, "0 /* %s */",
|
|
xlat->str);
|
|
} else {
|
|
strcpy(outptr, xlat->str);
|
|
}
|
|
|
|
return outstr;
|
|
}
|
|
|
|
if (xlat_verbose(style) == XLAT_STYLE_VERBOSE && flags)
|
|
outptr = xappendstr(outstr, outptr, "%s",
|
|
sprint_xlat_val(flags, style));
|
|
|
|
for (; flags && xlat->str; xlat++) {
|
|
if (xlat->val && (flags & xlat->val) == xlat->val) {
|
|
if (found)
|
|
*outptr++ = '|';
|
|
else if (xlat_verbose(style) == XLAT_STYLE_VERBOSE)
|
|
outptr = stpcpy(outptr, " /* ");
|
|
|
|
outptr = stpcpy(outptr, xlat->str);
|
|
found = 1;
|
|
flags &= ~xlat->val;
|
|
}
|
|
}
|
|
|
|
if (flags) {
|
|
if (found)
|
|
*outptr++ = '|';
|
|
if (found || xlat_verbose(style) != XLAT_STYLE_VERBOSE)
|
|
outptr = xappendstr(outstr, outptr, "%s",
|
|
sprint_xlat_val(flags, style));
|
|
} else {
|
|
if (!found)
|
|
return NULL;
|
|
}
|
|
|
|
if (found && xlat_verbose(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, ...)
|
|
{
|
|
style = get_xlat_style(style);
|
|
|
|
if (xlat_verbose(style) == XLAT_STYLE_RAW) {
|
|
if (flags || dflt) {
|
|
print_xlat_val(flags, style);
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
const char *init_sep = "";
|
|
unsigned int n = 0;
|
|
va_list args;
|
|
|
|
if (xlat_verbose(style) == XLAT_STYLE_VERBOSE) {
|
|
init_sep = " /* ";
|
|
if (flags)
|
|
print_xlat_val(flags, style);
|
|
}
|
|
|
|
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 (xlat_verbose(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) {
|
|
tprints("|");
|
|
print_xlat_val(flags, style);
|
|
n++;
|
|
}
|
|
|
|
if (xlat_verbose(style) == XLAT_STYLE_VERBOSE)
|
|
tprints(" */");
|
|
} else {
|
|
if (flags) {
|
|
if (xlat_verbose(style) != XLAT_STYLE_VERBOSE)
|
|
print_xlat_val(flags, style);
|
|
tprints_comment(dflt);
|
|
} else {
|
|
if (dflt)
|
|
tprints("0");
|
|
}
|
|
}
|
|
|
|
return n;
|
|
}
|
|
|
|
void
|
|
print_xlat_ex(const uint64_t val, const char *str, enum xlat_style style)
|
|
{
|
|
bool default_str = style & PXF_DEFAULT_STR;
|
|
style = get_xlat_style(style);
|
|
|
|
switch (xlat_verbose(style)) {
|
|
case XLAT_STYLE_ABBREV:
|
|
if (str) {
|
|
if (default_str) {
|
|
print_xlat_val(val, style);
|
|
tprints_comment(str);
|
|
} else {
|
|
tprints(str);
|
|
}
|
|
break;
|
|
}
|
|
ATTRIBUTE_FALLTHROUGH;
|
|
|
|
case XLAT_STYLE_RAW:
|
|
print_xlat_val(val, style);
|
|
break;
|
|
|
|
default:
|
|
error_func_msg("Unexpected style value of %#x", style);
|
|
ATTRIBUTE_FALLTHROUGH;
|
|
|
|
case XLAT_STYLE_VERBOSE:
|
|
print_xlat_val(val, style);
|
|
tprints_comment(str);
|
|
}
|
|
}
|
|
|
|
void
|
|
printxval_dispatch_ex(const struct xlat *xlat, size_t xlat_size, uint64_t val,
|
|
const char *dflt, enum xlat_type xt,
|
|
enum xlat_style style)
|
|
{
|
|
switch (xt) {
|
|
case XT_NORMAL:
|
|
printxvals_ex(val, dflt, style, xlat, NULL);
|
|
break;
|
|
|
|
case XT_SORTED:
|
|
printxval_searchn_ex(xlat, xlat_size, val, dflt, style);
|
|
break;
|
|
|
|
case XT_INDEXED:
|
|
printxval_indexn_ex(xlat, xlat_size, val, dflt, style);
|
|
break;
|
|
}
|
|
}
|