1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
/* Simple subrs.
Copyright (C) 2019-2020 Free Software Foundation, Inc.
This file is part of libctf.
libctf is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; see the file COPYING. If not see
<http://www.gnu.org/licenses/>. */
#include <ctf-impl.h>
#ifdef HAVE_MMAP
#include <sys/mman.h>
#endif
#include <sys/types.h>
#include <stdarg.h>
#include <string.h>
#include <unistd.h>
int _libctf_version = CTF_VERSION; /* Library client version. */
int _libctf_debug = 0; /* Debugging messages enabled. */
/* Private, read-only mmap from a file, with fallback to copying.
No handling of page-offset issues at all: the caller must allow for that. */
_libctf_malloc_ void *
ctf_mmap (size_t length, size_t offset, int fd)
{
void *data;
#ifdef HAVE_MMAP
data = mmap (NULL, length, PROT_READ, MAP_PRIVATE, fd, offset);
if (data == MAP_FAILED)
data = NULL;
#else
if ((data = malloc (length)) != NULL)
{
if (ctf_pread (fd, data, length, offset) <= 0)
{
free (data);
data = NULL;
}
}
#endif
return data;
}
void
ctf_munmap (void *buf, size_t length _libctf_unused_)
{
#ifdef HAVE_MMAP
(void) munmap (buf, length);
#else
free (buf);
#endif
}
ssize_t
ctf_pread (int fd, void *buf, ssize_t count, off_t offset)
{
ssize_t len;
size_t acc = 0;
char *data = (char *) buf;
#ifdef HAVE_PREAD
while (count > 0)
{
errno = 0;
if (((len = pread (fd, data, count, offset)) < 0) &&
errno != EINTR)
return len;
if (errno == EINTR)
continue;
acc += len;
if (len == 0) /* EOF. */
return acc;
count -= len;
offset += len;
data += len;
}
return acc;
#else
off_t orig_off;
if ((orig_off = lseek (fd, 0, SEEK_CUR)) < 0)
return -1;
if ((lseek (fd, offset, SEEK_SET)) < 0)
return -1;
while (count > 0)
{
errno = 0;
if (((len = read (fd, data, count)) < 0) &&
errno != EINTR)
return len;
if (errno == EINTR)
continue;
acc += len;
if (len == 0) /* EOF. */
break;
count -= len;
data += len;
}
if ((lseek (fd, orig_off, SEEK_SET)) < 0)
return -1; /* offset is smashed. */
#endif
return acc;
}
const char *
ctf_strerror (int err)
{
return (const char *) (strerror (err));
}
/* Set the CTF library client version to the specified version. If version is
zero, we just return the default library version number. */
int
ctf_version (int version)
{
if (version < 0)
{
errno = EINVAL;
return -1;
}
if (version > 0)
{
/* Dynamic version switching is not presently supported. */
if (version != CTF_VERSION)
{
errno = ENOTSUP;
return -1;
}
ctf_dprintf ("ctf_version: client using version %d\n", version);
_libctf_version = version;
}
return _libctf_version;
}
void
libctf_init_debug (void)
{
static int inited;
if (!inited)
{
_libctf_debug = getenv ("LIBCTF_DEBUG") != NULL;
inited = 1;
}
}
void ctf_setdebug (int debug)
{
/* Ensure that libctf_init_debug() has been called, so that we don't get our
debugging-on-or-off smashed by the next call. */
libctf_init_debug();
_libctf_debug = debug;
ctf_dprintf ("CTF debugging set to %i\n", debug);
}
int ctf_getdebug (void)
{
return _libctf_debug;
}
_libctf_printflike_ (1, 2)
void ctf_dprintf (const char *format, ...)
{
if (_libctf_unlikely_ (_libctf_debug))
{
va_list alist;
va_start (alist, format);
fflush (stdout);
(void) fputs ("libctf DEBUG: ", stderr);
(void) vfprintf (stderr, format, alist);
va_end (alist);
}
}
|
