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
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
|
/* Template for error handling for runtime dynamic linker.
Copyright (C) 1995-2019 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
/* The following macro needs to be defined before including this
skeleton file:
DL_ERROR_BOOTSTRAP
If 1, do not use TLS and implement _dl_signal_cerror and
_dl_receive_error. If 0, TLS is used, and the variants with
error callbacks are not provided. */
#include <libintl.h>
#include <setjmp.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <ldsodefs.h>
#include <stdio.h>
/* This structure communicates state between _dl_catch_error and
_dl_signal_error. */
struct catch
{
struct dl_exception *exception; /* The exception data is stored there. */
volatile int *errcode; /* Return value of _dl_signal_error. */
jmp_buf env; /* longjmp here on error. */
};
/* Multiple threads at once can use the `_dl_catch_error' function. The
calls can come from `_dl_map_object_deps', `_dlerror_run', or from
any of the libc functionality which loads dynamic objects (NSS, iconv).
Therefore we have to be prepared to save the state in thread-local
memory. */
#if !DL_ERROR_BOOTSTRAP
static __thread struct catch *catch_hook attribute_tls_model_ie;
#else
/* The version of this code in ld.so cannot use thread-local variables
and is used during bootstrap only. */
static struct catch *catch_hook;
#endif
#if DL_ERROR_BOOTSTRAP
/* This points to a function which is called when an continuable error is
received. Unlike the handling of `catch' this function may return.
The arguments will be the `errstring' and `objname'.
Since this functionality is not used in normal programs (only in ld.so)
we do not care about multi-threaded programs here. We keep this as a
global variable. */
static receiver_fct receiver;
#endif /* DL_ERROR_BOOTSTRAP */
/* Lossage while resolving the program's own symbols is always fatal. */
static void
__attribute__ ((noreturn))
fatal_error (int errcode, const char *objname, const char *occasion,
const char *errstring)
{
char buffer[1024];
_dl_fatal_printf ("%s: %s: %s%s%s%s%s\n",
RTLD_PROGNAME,
occasion ?: N_("error while loading shared libraries"),
objname, *objname ? ": " : "",
errstring, errcode ? ": " : "",
(errcode
? __strerror_r (errcode, buffer, sizeof buffer)
: ""));
}
void
_dl_signal_exception (int errcode, struct dl_exception *exception,
const char *occasion)
{
struct catch *lcatch = catch_hook;
if (lcatch != NULL)
{
*lcatch->exception = *exception;
*lcatch->errcode = errcode;
/* We do not restore the signal mask because none was saved. */
__longjmp (lcatch->env[0].__jmpbuf, 1);
}
else
fatal_error (errcode, exception->objname, occasion, exception->errstring);
}
libc_hidden_def (_dl_signal_exception)
void
_dl_signal_error (int errcode, const char *objname, const char *occation,
const char *errstring)
{
struct catch *lcatch = catch_hook;
if (! errstring)
errstring = N_("DYNAMIC LINKER BUG!!!");
if (lcatch != NULL)
{
_dl_exception_create (lcatch->exception, objname, errstring);
*lcatch->errcode = errcode;
/* We do not restore the signal mask because none was saved. */
__longjmp (lcatch->env[0].__jmpbuf, 1);
}
else
fatal_error (errcode, objname, occation, errstring);
}
libc_hidden_def (_dl_signal_error)
#if DL_ERROR_BOOTSTRAP
void
_dl_signal_cexception (int errcode, struct dl_exception *exception,
const char *occasion)
{
if (__builtin_expect (GLRO(dl_debug_mask)
& ~(DL_DEBUG_STATISTICS|DL_DEBUG_PRELINK), 0))
_dl_debug_printf ("%s: error: %s: %s (%s)\n",
exception->objname, occasion,
exception->errstring, receiver ? "continued" : "fatal");
if (receiver)
{
/* We are inside _dl_receive_error. Call the user supplied
handler and resume the work. The receiver will still be
installed. */
(*receiver) (errcode, exception->objname, exception->errstring);
}
else
_dl_signal_exception (errcode, exception, occasion);
}
void
_dl_signal_cerror (int errcode, const char *objname, const char *occation,
const char *errstring)
{
if (__builtin_expect (GLRO(dl_debug_mask)
& ~(DL_DEBUG_STATISTICS|DL_DEBUG_PRELINK), 0))
_dl_debug_printf ("%s: error: %s: %s (%s)\n", objname, occation,
errstring, receiver ? "continued" : "fatal");
if (receiver)
{
/* We are inside _dl_receive_error. Call the user supplied
handler and resume the work. The receiver will still be
installed. */
(*receiver) (errcode, objname, errstring);
}
else
_dl_signal_error (errcode, objname, occation, errstring);
}
#endif /* DL_ERROR_BOOTSTRAP */
int
_dl_catch_exception (struct dl_exception *exception,
void (*operate) (void *), void *args)
{
/* We need not handle `receiver' since setting a `catch' is handled
before it. */
/* Only this needs to be marked volatile, because it is the only local
variable that gets changed between the setjmp invocation and the
longjmp call. All others are just set here (before setjmp) and read
in _dl_signal_error (before longjmp). */
volatile int errcode;
struct catch c;
/* Don't use an initializer since we don't need to clear C.env. */
c.exception = exception;
c.errcode = &errcode;
struct catch *const old = catch_hook;
catch_hook = &c;
/* Do not save the signal mask. */
if (__builtin_expect (__sigsetjmp (c.env, 0), 0) == 0)
{
(*operate) (args);
catch_hook = old;
*exception = (struct dl_exception) { NULL };
return 0;
}
/* We get here only if we longjmp'd out of OPERATE.
_dl_signal_exception has already stored values into
*EXCEPTION. */
catch_hook = old;
return errcode;
}
libc_hidden_def (_dl_catch_exception)
int
_dl_catch_error (const char **objname, const char **errstring,
bool *mallocedp, void (*operate) (void *), void *args)
{
struct dl_exception exception;
int errorcode = _dl_catch_exception (&exception, operate, args);
*objname = exception.objname;
*errstring = exception.errstring;
*mallocedp = exception.message_buffer == exception.errstring;
return errorcode;
}
libc_hidden_def (_dl_catch_error)
#if DL_ERROR_BOOTSTRAP
void
_dl_receive_error (receiver_fct fct, void (*operate) (void *), void *args)
{
struct catch *old_catch = catch_hook;
receiver_fct old_receiver = receiver;
/* Set the new values. */
catch_hook = NULL;
receiver = fct;
(*operate) (args);
catch_hook = old_catch;
receiver = old_receiver;
}
#endif /* DL_ERROR_BOOTSTRAP */
|
