1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 #include <stdio.h>
27 #include <dlfcn.h>
28 #include <libelf.h>
29 #include <link.h>
30 #include <debug.h>
31 #include "msg.h"
32 #include "_libld.h"
33
34 /*
35 * Table which defines the default functions to be called by the library
36 * SUPPORT (-S <libname>). These functions can be redefined by the
37 * ld_support_loadso() routine.
38 */
39 static Support_list support[LDS_NUM] = {
40 {MSG_ORIG(MSG_SUP_VERSION), NULL}, /* LDS_VERSION */
41 {MSG_ORIG(MSG_SUP_INPUT_DONE), NULL}, /* LDS_INPUT_DONE */
42 #if defined(_ELF64)
43 {MSG_ORIG(MSG_SUP_START_64), NULL}, /* LDS_START */
44 {MSG_ORIG(MSG_SUP_ATEXIT_64), NULL}, /* LDS_ATEXIT */
45 {MSG_ORIG(MSG_SUP_OPEN_64), NULL}, /* LDS_OPEN */
46 {MSG_ORIG(MSG_SUP_FILE_64), NULL}, /* LDS_FILE */
47 {MSG_ORIG(MSG_SUP_INSEC_64), NULL}, /* LDS_INSEC */
48 {MSG_ORIG(MSG_SUP_SEC_64), NULL} /* LDS_SEC */
49 #else /* Elf32 */
50 {MSG_ORIG(MSG_SUP_START), NULL}, /* LDS_START */
51 {MSG_ORIG(MSG_SUP_ATEXIT), NULL}, /* LDS_ATEXIT */
52 {MSG_ORIG(MSG_SUP_OPEN), NULL}, /* LDS_OPEN */
53 {MSG_ORIG(MSG_SUP_FILE), NULL}, /* LDS_FILE */
54 {MSG_ORIG(MSG_SUP_INSEC), NULL}, /* LDS_INSEC */
55 {MSG_ORIG(MSG_SUP_SEC), NULL} /* LDS_SEC */
56 #endif
57 };
58
59 /*
60 * Loads in a support shared object specified using the SGS_SUPPORT environment
61 * variable or the -S ld option, and determines which interface functions are
62 * provided by that object.
63 */
64 uintptr_t
ld_sup_loadso(Ofl_desc * ofl,const char * obj)65 ld_sup_loadso(Ofl_desc *ofl, const char *obj)
66 {
67 void *handle, (*fptr)();
68 uint_t interface, version = LD_SUP_VERSION1;
69
70 /*
71 * Load the required support library. If we are unable to load it fail
72 * with a fatal error.
73 */
74 if ((handle = dlopen(obj, (RTLD_LAZY | RTLD_FIRST))) == NULL) {
75 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SUP_NOLOAD),
76 obj, dlerror());
77 return (S_ERROR);
78 }
79
80 for (interface = 0; interface < LDS_NUM; interface++) {
81 Func_list fl;
82
83 if ((fptr = (void (*)())dlsym(handle,
84 support[interface].sup_name)) == NULL)
85 continue;
86
87 DBG_CALL(Dbg_support_load(ofl->ofl_lml, obj,
88 support[interface].sup_name));
89
90 if (interface == LDS_VERSION) {
91 DBG_CALL(Dbg_support_action(ofl->ofl_lml, obj,
92 support[LDS_VERSION].sup_name, LDS_VERSION, 0));
93
94 version = ((uint_t(*)())fptr)(LD_SUP_VCURRENT);
95
96 /*
97 * If version is LD_SUP_VNONE, unload the support
98 * library and act as if it was never requested.
99 * This provides the support library with a mechanism
100 * for opting out of the process.
101 *
102 * Note that this depends on LDS_VERSION being the
103 * first item in support[]. If this were not true,
104 * then other functions from the library might be
105 * entered into the function lists, and unloading
106 * the object would cause corruption.
107 */
108 assert(LDS_VERSION == 0);
109 if (version == LD_SUP_VNONE) {
110 DBG_CALL(Dbg_support_vnone(ofl->ofl_lml,
111 obj));
112 (void) dlclose(handle);
113 return (1);
114 }
115
116 /*
117 * If the support library has a version higher
118 * than we support, we are unable to accept it.
119 */
120 if (version > LD_SUP_VCURRENT) {
121 ld_eprintf(ofl, ERR_FATAL,
122 MSG_INTL(MSG_SUP_BADVERSION), obj,
123 LD_SUP_VCURRENT, version);
124 (void) dlclose(handle);
125 return (S_ERROR);
126 }
127 }
128
129 fl.fl_obj = obj;
130 fl.fl_fptr = fptr;
131 fl.fl_version = version;
132 if (alist_append(&support[interface].sup_funcs, &fl,
133 sizeof (Func_list), AL_CNT_SUPPORT) == NULL)
134 return (S_ERROR);
135 }
136 return (1);
137 }
138
139 /*
140 * Wrapper routines for the ld support library calls.
141 */
142 void
ld_sup_start(Ofl_desc * ofl,const Half etype,const char * caller)143 ld_sup_start(Ofl_desc *ofl, const Half etype, const char *caller)
144 {
145 Func_list *flp;
146 Aliste idx;
147
148 for (ALIST_TRAVERSE(support[LDS_START].sup_funcs, idx, flp)) {
149 DBG_CALL(Dbg_support_action(ofl->ofl_lml, flp->fl_obj,
150 support[LDS_START].sup_name, LDS_START, ofl->ofl_name));
151 (*flp->fl_fptr)(ofl->ofl_name, etype, caller);
152 }
153 }
154
155 void
ld_sup_atexit(Ofl_desc * ofl,int ecode)156 ld_sup_atexit(Ofl_desc *ofl, int ecode)
157 {
158 Func_list *flp;
159 Aliste idx;
160
161 for (ALIST_TRAVERSE(support[LDS_ATEXIT].sup_funcs, idx, flp)) {
162 DBG_CALL(Dbg_support_action(ofl->ofl_lml, flp->fl_obj,
163 support[LDS_ATEXIT].sup_name, LDS_ATEXIT, 0));
164 (*flp->fl_fptr)(ecode);
165 }
166 }
167
168 void
ld_sup_open(Ofl_desc * ofl,const char ** opath,const char ** ofile,int * ofd,int flags,Elf ** oelf,Elf * ref,size_t off,const Elf_Kind ekind)169 ld_sup_open(Ofl_desc *ofl, const char **opath, const char **ofile, int *ofd,
170 int flags, Elf **oelf, Elf *ref, size_t off, const Elf_Kind ekind)
171 {
172 Func_list *flp;
173 Aliste idx;
174
175 for (ALIST_TRAVERSE(support[LDS_OPEN].sup_funcs, idx, flp)) {
176 const char *npath = *opath;
177 const char *nfile = *ofile;
178 Elf *nelf = *oelf;
179 int nfd = *ofd;
180 int _flags = 0;
181
182 /*
183 * This interface was introduced in VERSION3. Only call this
184 * function for libraries reporting support for version 3 or
185 * above.
186 */
187 if (flp->fl_version < LD_SUP_VERSION3)
188 continue;
189
190 if (!(flags & FLG_IF_CMDLINE))
191 _flags |= LD_SUP_DERIVED;
192 if (!(flags & FLG_IF_NEEDED))
193 _flags |= LD_SUP_INHERITED;
194 if (flags & FLG_IF_EXTRACT)
195 _flags |= LD_SUP_EXTRACTED;
196
197 /*
198 * If the present object is an extracted archive member, make
199 * sure the archive offset is reset so that the caller can
200 * obtain an ELF descriptor to the same member (an elf_begin()
201 * moves the offset to the next member).
202 */
203 if (flags & FLG_IF_EXTRACT)
204 (void) elf_rand(ref, off);
205
206 DBG_CALL(Dbg_support_action(ofl->ofl_lml, flp->fl_obj,
207 support[LDS_OPEN].sup_name, LDS_OPEN, *opath));
208 (*flp->fl_fptr)(&npath, &nfile, &nfd, _flags, &nelf, ref, off,
209 ekind);
210
211 /*
212 * If the file descriptor, ELF descriptor, or file names have
213 * been modified, then diagnose the differences and return the
214 * new data. As a basic test, make sure the support library
215 * hasn't nulled out data ld(1) will try and dereference.
216 */
217 if ((npath != *opath) || (nfd != *ofd) || (nelf != *oelf)) {
218 DBG_CALL(Dbg_file_modified(ofl->ofl_lml, flp->fl_obj,
219 *opath, npath, *ofd, nfd, *oelf, nelf));
220 if (npath)
221 *opath = npath;
222 if (nfile)
223 *ofile = nfile;
224 *ofd = nfd;
225 *oelf = nelf;
226 }
227 }
228 }
229
230 void
ld_sup_file(Ofl_desc * ofl,const char * ifile,const Elf_Kind ekind,int flags,Elf * elf)231 ld_sup_file(Ofl_desc *ofl, const char *ifile, const Elf_Kind ekind, int flags,
232 Elf *elf)
233 {
234 Func_list *flp;
235 Aliste idx;
236
237 for (ALIST_TRAVERSE(support[LDS_FILE].sup_funcs, idx, flp)) {
238 int _flags = 0;
239
240 if (!(flags & FLG_IF_CMDLINE))
241 _flags |= LD_SUP_DERIVED;
242 if (!(flags & FLG_IF_NEEDED))
243 _flags |= LD_SUP_INHERITED;
244 if (flags & FLG_IF_EXTRACT)
245 _flags |= LD_SUP_EXTRACTED;
246
247 DBG_CALL(Dbg_support_action(ofl->ofl_lml, flp->fl_obj,
248 support[LDS_FILE].sup_name, LDS_FILE, ifile));
249 (*flp->fl_fptr)(ifile, ekind, _flags, elf);
250 }
251 }
252
253 uintptr_t
ld_sup_input_section(Ofl_desc * ofl,Ifl_desc * ifl,const char * sname,Shdr ** oshdr,Word ndx,Elf_Scn * scn,Elf * elf)254 ld_sup_input_section(Ofl_desc *ofl, Ifl_desc *ifl, const char *sname,
255 Shdr **oshdr, Word ndx, Elf_Scn *scn, Elf *elf)
256 {
257 Func_list *flp;
258 Aliste idx;
259 uint_t flags = 0;
260 Elf_Data *data = NULL;
261
262 for (ALIST_TRAVERSE(support[LDS_INSEC].sup_funcs, idx, flp)) {
263 Shdr *nshdr = *oshdr;
264
265 /*
266 * This interface was introduced in VERSION2. Only call this
267 * function for libraries reporting support for version 2 or
268 * above.
269 */
270 if (flp->fl_version < LD_SUP_VERSION2)
271 continue;
272
273 if ((data == NULL) &&
274 ((data = elf_getdata(scn, NULL)) == NULL)) {
275 ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_GETDATA),
276 ifl->ifl_name);
277 return (S_ERROR);
278 }
279
280 DBG_CALL(Dbg_support_action(ofl->ofl_lml, flp->fl_obj,
281 support[LDS_INSEC].sup_name, LDS_INSEC, sname));
282 (*flp->fl_fptr)(sname, &nshdr, ndx, data, elf, &flags);
283
284 /*
285 * If the section header has been re-allocated (known to occur
286 * with libCCexcept.so), then diagnose the section header
287 * difference and return the new section header.
288 */
289 if (nshdr != *oshdr) {
290 Ehdr *ehdr = ifl->ifl_ehdr;
291
292 DBG_CALL(Dbg_shdr_modified(ofl->ofl_lml, flp->fl_obj,
293 ehdr->e_ident[EI_OSABI], ehdr->e_machine, ndx,
294 *oshdr, nshdr, sname));
295 *oshdr = nshdr;
296 }
297 }
298 return (0);
299 }
300
301 void
ld_sup_section(Ofl_desc * ofl,const char * scn,Shdr * shdr,Word ndx,Elf_Data * data,Elf * elf)302 ld_sup_section(Ofl_desc *ofl, const char *scn, Shdr *shdr, Word ndx,
303 Elf_Data *data, Elf *elf)
304 {
305 Func_list *flp;
306 Aliste idx;
307
308 for (ALIST_TRAVERSE(support[LDS_SEC].sup_funcs, idx, flp)) {
309 DBG_CALL(Dbg_support_action(ofl->ofl_lml, flp->fl_obj,
310 support[LDS_SEC].sup_name, LDS_SEC, scn));
311 (*flp->fl_fptr)(scn, shdr, ndx, data, elf);
312 }
313 }
314
315 void
ld_sup_input_done(Ofl_desc * ofl)316 ld_sup_input_done(Ofl_desc *ofl)
317 {
318 Func_list *flp;
319 Aliste idx;
320 uint_t flags = 0;
321
322 for (ALIST_TRAVERSE(support[LDS_INPUT_DONE].sup_funcs, idx, flp)) {
323 /*
324 * This interface was introduced in VERSION2. Only call this
325 * function for libraries reporting support for version 2 or
326 * above.
327 */
328 if (flp->fl_version < LD_SUP_VERSION2)
329 continue;
330
331 DBG_CALL(Dbg_support_action(ofl->ofl_lml, flp->fl_obj,
332 support[LDS_INPUT_DONE].sup_name, LDS_INPUT_DONE, 0));
333 (*flp->fl_fptr)(&flags);
334 }
335 }
336