1 /*
2 * Copyright (C) 2014 Ondrej Oprala <ooprala@redhat.com>
3 * Copyright (C) 2014 Karel Zak <kzak@redhat.com>
4 *
5 * This file may be distributed under the terms of the
6 * GNU Lesser General Public License.
7 */
8 #ifndef UTIL_LINUX_DEBUG_H
9 #define UTIL_LINUX_DEBUG_H
10
11
12 /*
13 * util-linux debug macros
14 *
15 * The debug stuff is based on <name>_debug_mask that controls what outputs is
16 * expected. The mask is usually initialized by <NAME>_DEBUG= env.variable
17 *
18 * After successful initialization the flag <PREFIX>_DEBUG_INIT is always set
19 * to the mask (this flag is required). The <PREFIX> is usually library API
20 * prefix (e.g. MNT_) or program name (e.g. CFDISK_)
21 *
22 * In the code is possible to use
23 *
24 * DBG(FOO, ul_debug("this is output for foo"));
25 *
26 * where for the FOO has to be defined <PREFIX>_DEBUG_FOO.
27 *
28 * It's possible to initialize the mask by comma delimited strings with
29 * subsystem names (e.g. "LIBMOUNT_DEBUG=options,tab"). In this case is
30 * necessary to define mask names array. This functionality is optional.
31 *
32 * It's strongly recommended to use UL_* macros to define/declare/use
33 * the debug stuff.
34 *
35 * See disk-utils/cfdisk.c: cfdisk_init_debug() for programs debug
36 * or libmount/src/init.c: mnt_init_debug() for library debug
37 *
38 */
39
40 #include <stdarg.h>
41 #include <string.h>
42
43 struct ul_debug_maskname {
44 const char *name;
45 int mask;
46 const char *help;
47 };
48 #define UL_DEBUG_EMPTY_MASKNAMES {{ NULL, 0, NULL }}
49 #define UL_DEBUG_DEFINE_MASKNAMES(m) static const struct ul_debug_maskname m ## _masknames[]
50 #define UL_DEBUG_MASKNAMES(m) m ## _masknames
51
52 #define UL_DEBUG_MASK(m) m ## _debug_mask
53 #define UL_DEBUG_DEFINE_MASK(m) int UL_DEBUG_MASK(m)
54 #define UL_DEBUG_DECLARE_MASK(m) extern UL_DEBUG_DEFINE_MASK(m)
55
56 /*
57 * Internal mask flags (above 0xffffff)
58 */
59 #define __UL_DEBUG_FL_NOADDR (1 << 24) /* Don't print object address */
60
61
62 /* l - library name, p - flag prefix, m - flag postfix, x - function */
63 #define __UL_DBG(l, p, m, x) \
64 do { \
65 if ((p ## m) & l ## _debug_mask) { \
66 fprintf(stderr, "%d: %s: %8s: ", getpid(), # l, # m); \
67 x; \
68 } \
69 } while (0)
70
71 #define __UL_DBG_CALL(l, p, m, x) \
72 do { \
73 if ((p ## m) & l ## _debug_mask) { \
74 x; \
75 } \
76 } while (0)
77
78 #define __UL_DBG_FLUSH(l, p) \
79 do { \
80 if (l ## _debug_mask && \
81 l ## _debug_mask != p ## INIT) { \
82 fflush(stderr); \
83 } \
84 } while (0)
85
86 #define __UL_INIT_DEBUG_FROM_STRING(lib, pref, mask, str) \
87 do { \
88 if (lib ## _debug_mask & pref ## INIT) \
89 ; \
90 else if (!mask && str) { \
91 lib ## _debug_mask = ul_debug_parse_mask(lib ## _masknames, str); \
92 } else \
93 lib ## _debug_mask = mask; \
94 if (lib ## _debug_mask) { \
95 if (getuid() != geteuid() || getgid() != getegid()) { \
96 lib ## _debug_mask |= __UL_DEBUG_FL_NOADDR; \
97 fprintf(stderr, "%d: %s: don't print memory addresses (SUID executable).\n", getpid(), # lib); \
98 } \
99 } \
100 lib ## _debug_mask |= pref ## INIT; \
101 } while (0)
102
103
104 #define __UL_INIT_DEBUG_FROM_ENV(lib, pref, mask, env) \
105 do { \
106 const char *envstr = mask ? NULL : getenv(# env); \
107 __UL_INIT_DEBUG_FROM_STRING(lib, pref, mask, envstr); \
108 } while (0)
109
110
111
112 static inline void __attribute__ ((__format__ (__printf__, 1, 2)))
ul_debug(const char * mesg,...)113 ul_debug(const char *mesg, ...)
114 {
115 va_list ap;
116 va_start(ap, mesg);
117 vfprintf(stderr, mesg, ap);
118 va_end(ap);
119 fputc('\n', stderr);
120 }
121
ul_debug_parse_mask(const struct ul_debug_maskname flagnames[],const char * mask)122 static inline int ul_debug_parse_mask(
123 const struct ul_debug_maskname flagnames[],
124 const char *mask)
125 {
126 int res;
127 char *ptr;
128
129 /* let's check for a numeric mask first */
130 res = strtoul(mask, &ptr, 0);
131
132 /* perhaps it's a comma-separated string? */
133 if (ptr && *ptr && flagnames && flagnames[0].name) {
134 char *msbuf, *ms, *name;
135 res = 0;
136
137 ms = msbuf = strdup(mask);
138 if (!ms)
139 return res;
140
141 while ((name = strtok_r(ms, ",", &ptr))) {
142 const struct ul_debug_maskname *d;
143 ms = ptr;
144
145 for (d = flagnames; d && d->name; d++) {
146 if (strcmp(name, d->name) == 0) {
147 res |= d->mask;
148 break;
149 }
150 }
151 /* nothing else we can do by OR-ing the mask */
152 if (res == 0xffff)
153 break;
154 }
155 free(msbuf);
156 } else if (ptr && strcmp(ptr, "all") == 0)
157 res = 0xffff;
158
159 return res;
160 }
161
ul_debug_print_masks(const char * env,const struct ul_debug_maskname flagnames[])162 static inline void ul_debug_print_masks(
163 const char *env,
164 const struct ul_debug_maskname flagnames[])
165 {
166 const struct ul_debug_maskname *d;
167
168 if (!flagnames)
169 return;
170
171 fprintf(stderr, "Available \"%s=<name>[,...]|<mask>\" debug masks:\n",
172 env);
173 for (d = flagnames; d && d->name; d++) {
174 if (!d->help)
175 continue;
176 fprintf(stderr, " %-8s [0x%04x] : %s\n",
177 d->name, d->mask, d->help);
178 }
179 }
180
181 #endif /* UTIL_LINUX_DEBUG_H */
182