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 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 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 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 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 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 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 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 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