83572320f4cbb1c37e28481b3c0ee29cfd62a719
2 Copyright (C) 2019-2022 Free Software Foundation, Inc.
4 This file is part of libctf.
6 libctf is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 This program is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14 See the GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; see the file COPYING. If not see
18 <http://www.gnu.org/licenses/>. */
24 #include <sys/types.h>
30 #define ENOTSUP ENOSYS
33 int _libctf_version
= CTF_VERSION
; /* Library client version. */
34 int _libctf_debug
= 0; /* Debugging messages enabled. */
36 /* Private, read-only mmap from a file, with fallback to copying.
38 No handling of page-offset issues at all: the caller must allow for that. */
40 _libctf_malloc_
void *
41 ctf_mmap (size_t length
, size_t offset
, int fd
)
46 data
= mmap (NULL
, length
, PROT_READ
, MAP_PRIVATE
, fd
, offset
);
47 if (data
== MAP_FAILED
)
50 if ((data
= malloc (length
)) != NULL
)
52 if (ctf_pread (fd
, data
, length
, offset
) <= 0)
63 ctf_munmap (void *buf
, size_t length _libctf_unused_
)
66 (void) munmap (buf
, length
);
73 ctf_pread (int fd
, void *buf
, ssize_t count
, off_t offset
)
77 char *data
= (char *) buf
;
83 if (((len
= pread (fd
, data
, count
, offset
)) < 0) &&
90 if (len
== 0) /* EOF. */
101 if ((orig_off
= lseek (fd
, 0, SEEK_CUR
)) < 0)
103 if ((lseek (fd
, offset
, SEEK_SET
)) < 0)
109 if (((len
= read (fd
, data
, count
)) < 0) &&
116 if (len
== 0) /* EOF. */
122 if ((lseek (fd
, orig_off
, SEEK_SET
)) < 0)
123 return -1; /* offset is smashed. */
129 /* Set the CTF library client version to the specified version. If version is
130 zero, we just return the default library version number. */
132 ctf_version (int version
)
142 /* Dynamic version switching is not presently supported. */
143 if (version
!= CTF_VERSION
)
148 ctf_dprintf ("ctf_version: client using version %d\n", version
);
149 _libctf_version
= version
;
152 return _libctf_version
;
156 libctf_init_debug (void)
161 _libctf_debug
= getenv ("LIBCTF_DEBUG") != NULL
;
166 void ctf_setdebug (int debug
)
168 /* Ensure that libctf_init_debug() has been called, so that we don't get our
169 debugging-on-or-off smashed by the next call. */
172 _libctf_debug
= debug
;
173 ctf_dprintf ("CTF debugging set to %i\n", debug
);
176 int ctf_getdebug (void)
178 return _libctf_debug
;
181 _libctf_printflike_ (1, 2)
182 void ctf_dprintf (const char *format
, ...)
184 if (_libctf_unlikely_ (_libctf_debug
))
188 va_start (alist
, format
);
190 (void) fputs ("libctf DEBUG: ", stderr
);
191 (void) vfprintf (stderr
, format
, alist
);
196 /* This needs more attention to thread-safety later on. */
197 static ctf_list_t open_errors
;
199 /* Errors and warnings. Report the warning or error to the list in FP (or the
200 open errors list if NULL): if ERR is nonzero it is the errno to report to the
201 debug stream instead of that recorded on fp. */
202 _libctf_printflike_ (4, 5)
204 ctf_err_warn (ctf_dict_t
*fp
, int is_warning
, int err
,
205 const char *format
, ...)
208 ctf_err_warning_t
*cew
;
210 /* Don't bother reporting errors here: we can't do much about them if they
211 happen. If we're so short of memory that a tiny malloc doesn't work, a
212 vfprintf isn't going to work either and the caller will have to rely on the
213 ENOMEM return they'll be getting in short order anyway. */
215 if ((cew
= malloc (sizeof (ctf_err_warning_t
))) == NULL
)
218 cew
->cew_is_warning
= is_warning
;
219 va_start (alist
, format
);
220 if (vasprintf (&cew
->cew_text
, format
, alist
) < 0)
228 /* Include the error code only if there is one; if this is not a warning,
229 only use the error code if it was explicitly passed and is nonzero.
230 (Warnings may not have a meaningful error code, since the warning may not
231 lead to unwinding up to the user.) */
232 if ((!is_warning
&& (err
!= 0 || (fp
&& ctf_errno (fp
) != 0)))
233 || (is_warning
&& err
!= 0))
234 ctf_dprintf ("%s: %s (%s)\n", is_warning
? _("error") : _("warning"),
235 cew
->cew_text
, err
!= 0 ? ctf_errmsg (err
)
236 : ctf_errmsg (ctf_errno (fp
)));
238 ctf_dprintf ("%s: %s\n", is_warning
? _("error") : _("warning"),
242 ctf_list_append (&fp
->ctf_errs_warnings
, cew
);
244 ctf_list_append (&open_errors
, cew
);
247 /* Move all the errors/warnings from an fp into the open_errors. */
249 ctf_err_warn_to_open (ctf_dict_t
*fp
)
251 ctf_list_splice (&open_errors
, &fp
->ctf_errs_warnings
);
254 /* Error-warning reporting: an 'iterator' that returns errors and warnings from
255 the error/warning list, in order of emission. Errors and warnings are popped
256 after return: the caller must free the returned error-text pointer.
258 An fp of NULL returns CTF-open-time errors from the open_errors variable
261 The treatment of errors from this function itself is somewhat unusual: it
262 will often be called on an error path, so we don't want to overwrite the
263 ctf_errno unless we have no choice. So, like ctf_bufopen et al, this
264 function takes an errp pointer where errors are reported. The pointer is
265 optional: if not set, errors are reported via the fp (if non-NULL). Calls
266 with neither fp nor errp set are mildly problematic because there is no clear
267 way to report end-of-iteration: you just have to assume that a NULL return
268 means the end, and not an iterator error. */
271 ctf_errwarning_next (ctf_dict_t
*fp
, ctf_next_t
**it
, int *is_warning
,
277 ctf_err_warning_t
*cew
;
280 errlist
= &fp
->ctf_errs_warnings
;
282 errlist
= &open_errors
;
286 if ((i
= ctf_next_create ()) == NULL
)
291 ctf_set_errno (fp
, ENOMEM
);
296 i
->ctn_iter_fun
= (void (*) (void)) ctf_errwarning_next
;
300 if ((void (*) (void)) ctf_errwarning_next
!= i
->ctn_iter_fun
)
303 *errp
= ECTF_NEXT_WRONGFUN
;
305 ctf_set_errno (fp
, ECTF_NEXT_WRONGFUN
);
309 if (fp
!= i
->cu
.ctn_fp
)
312 *errp
= ECTF_NEXT_WRONGFP
;
314 ctf_set_errno (fp
, ECTF_NEXT_WRONGFP
);
318 cew
= ctf_list_next (errlist
);
322 ctf_next_destroy (i
);
325 *errp
= ECTF_NEXT_END
;
327 ctf_set_errno (fp
, ECTF_NEXT_END
);
332 *is_warning
= cew
->cew_is_warning
;
334 ctf_list_delete (errlist
, cew
);
340 ctf_assert_fail_internal (ctf_dict_t
*fp
, const char *file
, size_t line
,
343 ctf_err_warn (fp
, 0, ECTF_INTERNAL
, _("%s: %lu: libctf assertion failed: %s"),
344 file
, (long unsigned int) line
, exprstr
);
345 ctf_set_errno (fp
, ECTF_INTERNAL
);