1 /*
2 * Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl>
3 * Copyright (c) 1993 Branko Lankester <branko@hacktic.nl>
4 * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com>
5 * Copyright (c) 1996-1999 Wichert Akkerman <wichert@cistron.nl>
6 * Copyright (c) 1999-2017 The strace developers.
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. The name of the author may not be used to endorse or promote products
18 * derived from this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
21 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
24 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include "defs.h"
33 #include <stdarg.h>
34
35 const char *
xlookup(const struct xlat * xlat,const uint64_t val)36 xlookup(const struct xlat *xlat, const uint64_t val)
37 {
38 for (; xlat->str != NULL; xlat++)
39 if (xlat->val == val)
40 return xlat->str;
41 return NULL;
42 }
43
44 static int
xlat_bsearch_compare(const void * a,const void * b)45 xlat_bsearch_compare(const void *a, const void *b)
46 {
47 const uint64_t val1 = *(const uint64_t *) a;
48 const uint64_t val2 = ((const struct xlat *) b)->val;
49 return (val1 > val2) ? 1 : (val1 < val2) ? -1 : 0;
50 }
51
52 const char *
xlat_search(const struct xlat * xlat,const size_t nmemb,const uint64_t val)53 xlat_search(const struct xlat *xlat, const size_t nmemb, const uint64_t val)
54 {
55 const struct xlat *e =
56 bsearch((const void *) &val,
57 xlat, nmemb, sizeof(*xlat), xlat_bsearch_compare);
58
59 return e ? e->str : NULL;
60 }
61
62 /**
63 * Print entry in struct xlat table, if there.
64 *
65 * @param val Value to search a literal representation for.
66 * @param dflt String (abbreviated in comment syntax) which should be emitted
67 * if no appropriate xlat value has been found.
68 * @param xlat (And the following arguments) Pointers to arrays of xlat values.
69 * The last argument should be NULL.
70 * @return 1 if appropriate xlat value has been found, 0 otherwise.
71 */
72 int
printxvals(const uint64_t val,const char * dflt,const struct xlat * xlat,...)73 printxvals(const uint64_t val, const char *dflt, const struct xlat *xlat, ...)
74 {
75 va_list args;
76
77 va_start(args, xlat);
78 for (; xlat; xlat = va_arg(args, const struct xlat *)) {
79 const char *str = xlookup(xlat, val);
80
81 if (str) {
82 tprints(str);
83 va_end(args);
84 return 1;
85 }
86 }
87 /* No hits -- print raw # instead. */
88 tprintf("%#" PRIx64, val);
89 tprints_comment(dflt);
90
91 va_end(args);
92
93 return 0;
94 }
95
96 /**
97 * Print entry in sorted struct xlat table, if it is there.
98 *
99 * @param xlat Pointer to an array of xlat values (not terminated with
100 * XLAT_END).
101 * @param xlat_size Number of xlat elements present in array (usually ARRAY_SIZE
102 * if array is declared in the unit's scope and not
103 * terminated with XLAT_END).
104 * @param val Value to search literal representation for.
105 * @param dflt String (abbreviated in comment syntax) which should be
106 * emitted if no appropriate xlat value has been found.
107 * @return 1 if appropriate xlat value has been found, 0
108 * otherwise.
109 */
110 int
printxval_searchn(const struct xlat * xlat,size_t xlat_size,uint64_t val,const char * dflt)111 printxval_searchn(const struct xlat *xlat, size_t xlat_size, uint64_t val,
112 const char *dflt)
113 {
114 const char *s = xlat_search(xlat, xlat_size, val);
115
116 if (s) {
117 tprints(s);
118 return 1;
119 }
120
121 tprintf("%#" PRIx64, val);
122 tprints_comment(dflt);
123
124 return 0;
125 }
126
127 /*
128 * Interpret `xlat' as an array of flags
129 * print the entries whose bits are on in `flags'
130 */
131 void
addflags(const struct xlat * xlat,uint64_t flags)132 addflags(const struct xlat *xlat, uint64_t flags)
133 {
134 for (; xlat->str; xlat++) {
135 if (xlat->val && (flags & xlat->val) == xlat->val) {
136 tprintf("|%s", xlat->str);
137 flags &= ~xlat->val;
138 }
139 }
140 if (flags) {
141 tprintf("|%#" PRIx64, flags);
142 }
143 }
144
145 /*
146 * Interpret `xlat' as an array of flags.
147 * Print to static string the entries whose bits are on in `flags'
148 * Return static string.
149 */
150 const char *
sprintflags(const char * prefix,const struct xlat * xlat,uint64_t flags)151 sprintflags(const char *prefix, const struct xlat *xlat, uint64_t flags)
152 {
153 static char outstr[1024];
154 char *outptr;
155 int found = 0;
156
157 outptr = stpcpy(outstr, prefix);
158
159 if (flags == 0 && xlat->val == 0 && xlat->str) {
160 strcpy(outptr, xlat->str);
161 return outstr;
162 }
163
164 for (; xlat->str; xlat++) {
165 if (xlat->val && (flags & xlat->val) == xlat->val) {
166 if (found)
167 *outptr++ = '|';
168 outptr = stpcpy(outptr, xlat->str);
169 found = 1;
170 flags &= ~xlat->val;
171 if (!flags)
172 break;
173 }
174 }
175 if (flags) {
176 if (found)
177 *outptr++ = '|';
178 outptr += sprintf(outptr, "%#" PRIx64, flags);
179 }
180
181 return outstr;
182 }
183
184 int
printflags_ex(uint64_t flags,const char * dflt,const struct xlat * xlat,...)185 printflags_ex(uint64_t flags, const char *dflt, const struct xlat *xlat, ...)
186 {
187 unsigned int n = 0;
188 va_list args;
189
190 va_start(args, xlat);
191 for (; xlat; xlat = va_arg(args, const struct xlat *)) {
192 for (; (flags || !n) && xlat->str; ++xlat) {
193 if ((flags == xlat->val) ||
194 (xlat->val && (flags & xlat->val) == xlat->val)) {
195 tprintf("%s%s", (n++ ? "|" : ""), xlat->str);
196 flags &= ~xlat->val;
197 }
198 if (!flags)
199 break;
200 }
201 }
202 va_end(args);
203
204 if (n) {
205 if (flags) {
206 tprintf("|%#" PRIx64, flags);
207 n++;
208 }
209 } else {
210 if (flags) {
211 tprintf("%#" PRIx64, flags);
212 tprints_comment(dflt);
213 } else {
214 if (dflt)
215 tprints("0");
216 }
217 }
218
219 return n;
220 }
221