Debian Codegraph @

libdrgn/error.c

raw
1 // Copyright (c) Meta Platforms, Inc. and affiliates.
2 // SPDX-License-Identifier: LGPL-2.1-or-later
3
4 #include <elfutils/libdw.h>
5 #include <errno.h>
6 #include <inttypes.h>
7 #include <libelf.h>
8 #include <stdarg.h>
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include <string.h>
12
13 #include "drgn_internal.h"
14 #include "error.h"
15 #include "string_builder.h"
16 #include "util.h"
17
18 LIBDRGN_PUBLIC struct drgn_error drgn_enomem = {
19 .code = DRGN_ERROR_NO_MEMORY,
20 .message = "cannot allocate memory",
21 };
22
23 LIBDRGN_PUBLIC struct drgn_error drgn_not_found = {
24 .code = DRGN_ERROR_LOOKUP,
25 .message = "not found",
26 };
27
28 struct drgn_error drgn_stop = {
29 .code = DRGN_ERROR_STOP,
30 .message = "stop iteration",
31 };
32
33 struct drgn_error drgn_error_object_absent = {
34 .code = DRGN_ERROR_OBJECT_ABSENT,
35 .message = "object absent",
36 };
37
38 static struct drgn_error *drgn_error_create_nodup(enum drgn_error_code code,
39 char *message)
40 {
41 struct drgn_error *err;
42
43 err = malloc(sizeof(*err));
44 if (!err) {
45 free(message);
46 return &drgn_enomem;
47 }
48
49 err->code = code;
50 err->needs_destroy = true;
51 err->errnum = 0;
52 err->path = NULL;
53 err->address = 0;
54 err->message = message;
55 return err;
56 }
57
58 LIBDRGN_PUBLIC struct drgn_error *drgn_error_create(enum drgn_error_code code,
59 const char *message)
60 {
61 char *message_copy;
62
63 message_copy = strdup(message);
64 if (!message_copy)
65 return &drgn_enomem;
66 return drgn_error_create_nodup(code, message_copy);
67 }
68
69 LIBDRGN_PUBLIC struct drgn_error *
70 drgn_error_format_os(const char *message, int errnum, const char *path_format,
71 ...)
72 {
73 struct drgn_error *err;
74 va_list ap;
75 int ret;
76
77 err = malloc(sizeof(*err));
78 if (!err)
79 return &drgn_enomem;
80
81 err->code = DRGN_ERROR_OS;
82 err->needs_destroy = true;
83 err->errnum = errnum;
84 if (path_format) {
85 va_start(ap, path_format);
86 ret = vasprintf(&err->path, path_format, ap);
87 va_end(ap);
88 if (ret == -1) {
89 free(err);
90 return &drgn_enomem;
91 }
92 } else {
93 err->path = NULL;
94 }
95 err->address = 0;
96 err->message = strdup(message);
97 if (!err->message) {
98 free(err->path);
99 free(err);
100 return &drgn_enomem;
101 }
102 return err;
103 }
104
105 LIBDRGN_PUBLIC struct drgn_error *drgn_error_create_os(const char *message,
106 int errnum,
107 const char *path)
108 {
109 if (path)
110 return drgn_error_format_os(message, errnum, "%s", path);
111 else
112 return drgn_error_format_os(message, errnum, NULL);
113 }
114
115 LIBDRGN_PUBLIC struct drgn_error *drgn_error_format(enum drgn_error_code code,
116 const char *format, ...)
117 {
118 char *message;
119 va_list ap;
120 int ret;
121
122 va_start(ap, format);
123 ret = vasprintf(&message, format, ap);
124 va_end(ap);
125 if (ret == -1)
126 return &drgn_enomem;
127 return drgn_error_create_nodup(code, message);
128 }
129
130 LIBDRGN_PUBLIC struct drgn_error *drgn_error_create_fault(const char *message,
131 uint64_t address)
132 {
133 struct drgn_error *err;
134
135 err = drgn_error_create(DRGN_ERROR_FAULT, message);
136 if (err != &drgn_enomem)
137 err->address = address;
138 return err;
139 }
140
141 LIBDRGN_PUBLIC struct drgn_error *
142 drgn_error_format_fault(uint64_t address, const char *format, ...)
143 {
144 struct drgn_error *err;
145 va_list ap;
146 char *message;
147 int ret;
148
149 va_start(ap, format);
150 ret = vasprintf(&message, format, ap);
151 va_end(ap);
152 if (ret == -1)
153 return &drgn_enomem;
154 err = drgn_error_create_nodup(DRGN_ERROR_FAULT, message);
155 if (err != &drgn_enomem)
156 err->address = address;
157 return err;
158 }
159
160 LIBDRGN_PUBLIC struct drgn_error *drgn_error_copy(struct drgn_error *src)
161 {
162 if (!src->needs_destroy)
163 return src;
164 struct drgn_error *dst = malloc(sizeof(*dst));
165 if (!dst)
166 return &drgn_enomem;
167 dst->code = src->code;
168 dst->needs_destroy = true;
169 dst->errnum = src->errnum;
170 if (src->path) {
171 dst->path = strdup(src->path);
172 if (!dst->path) {
173 free(dst);
174 return &drgn_enomem;
175 }
176 } else {
177 dst->path = NULL;
178 }
179 dst->address = src->address;
180 if (src->message) {
181 dst->message = strdup(src->message);
182 if (!dst->message) {
183 free(dst->path);
184 free(dst);
185 return &drgn_enomem;
186 }
187 } else {
188 dst->message = NULL;
189 }
190 return dst;
191 }
192
193 #define emit_error(err) ( \
194 err->code == DRGN_ERROR_OS ? \
195 /* This is easier than dealing with strerror_r(). */ \
196 (errno = err->errnum, \
197 err->path ? \
198 emit_error_format("%s: %s: %m", err->message, err->path) : \
199 emit_error_format("%s: %m", err->message)) \
200 : err->code == DRGN_ERROR_FAULT ? \
201 emit_error_format("%s: 0x%" PRIx64, err->message, err->address) \
202 : \
203 emit_error_string(err->message) \
204 )
205
206 bool string_builder_append_error(struct string_builder *sb,
207 struct drgn_error *err)
208 {
209 #define emit_error_format(...) string_builder_appendf(sb, __VA_ARGS__)
210 #define emit_error_string(s) string_builder_append(sb, s)
211 return emit_error(err);
212 #undef emit_error_string
213 #undef emit_error_format
214 }
215
216 LIBDRGN_PUBLIC char *drgn_error_string(struct drgn_error *err)
217 {
218 char *tmp;
219 #define emit_error_format(...) (asprintf(&tmp, __VA_ARGS__) < 0 ? NULL : tmp)
220 #define emit_error_string(s) strdup(s)
221 return emit_error(err);
222 #undef emit_error_string
223 #undef emit_error_format
224 }
225
226 LIBDRGN_PUBLIC int drgn_error_fwrite(FILE *file, struct drgn_error *err)
227 {
228 #define emit_error_format(format, ...) fprintf(file, format "\n", __VA_ARGS__)
229 #define emit_error_string(s) fprintf(file, "%s\n", s)
230 return emit_error(err);
231 #undef emit_error_string
232 #undef emit_error_format
233 }
234
235 LIBDRGN_PUBLIC int drgn_error_dwrite(int fd, struct drgn_error *err)
236 {
237 #define emit_error_format(format, ...) dprintf(fd, format "\n", __VA_ARGS__)
238 #define emit_error_string(s) dprintf(fd, "%s\n", s)
239 return emit_error(err);
240 #undef emit_error_string
241 #undef emit_error_format
242 }
243
244 #undef emit_error
245
246 LIBDRGN_PUBLIC void drgn_error_destroy(struct drgn_error *err)
247 {
248 if (err && err->needs_destroy) {
249 free(err->path);
250 free(err->message);
251 free(err);
252 }
253 }
254
255 struct drgn_error *drgn_error_libelf(void)
256 {
257 return drgn_error_format(DRGN_ERROR_OTHER, "libelf error: %s",
258 elf_errmsg(-1));
259 }
260
261 struct drgn_error *drgn_error_libdw(void)
262 {
263 return drgn_error_format(DRGN_ERROR_OTHER, "libdw error: %s",
264 dwarf_errmsg(-1));
265 }