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 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #pragma ident "%Z%%M% %I% %E% SMI" 27 28 29 #include <stdlib.h> 30 #include <stdio.h> 31 #include <string.h> 32 #include <proc_service.h> 33 #include <link.h> 34 #include <rtld_db.h> 35 #include <rtld.h> 36 #include <_rtld_db.h> 37 #include <msg.h> 38 #include <sys/param.h> 39 40 /* 41 * Mutex to protect global data 42 */ 43 mutex_t glob_mutex = DEFAULTMUTEX; 44 int rtld_db_version = RD_VERSION1; 45 int rtld_db_logging = 0; 46 char rtld_db_helper_path[MAXPATHLEN]; 47 48 49 void 50 rd_log(const int on_off) 51 { 52 (void) mutex_lock(&glob_mutex); 53 rtld_db_logging = on_off; 54 (void) mutex_unlock(&glob_mutex); 55 LOG(ps_plog(MSG_ORIG(MSG_DB_LOGENABLE))); 56 } 57 58 /* 59 * Versioning Notes. 60 * 61 * The following have been added as the versions of librtld_db 62 * have grown: 63 * 64 * RD_VERSION1: 65 * o baseline version 66 * 67 * RD_VERSION2: 68 * o added support for the use of the AT_SUN_LDBASE auxvector 69 * to find the initialial debugging (r_debug) structures 70 * in ld.so.1 71 * o added the rl_dynamic field to rd_loadobj_t 72 * o added the RD_FLG_MEM_OBJECT to be used with the 73 * rl_dynamic->rl_flags field. 74 * 75 * RD_VERSION3: 76 * o added the following fields/flags to the rd_plt_info_t 77 * type: 78 * pi_baddr - bound address of PLT (if bound) 79 * pi_flags - flag field 80 * RD_FLG_PI_PLTBOUND (flag for pi_flags) 81 * if set - the PLT is bound and pi_baddr 82 * is filled in with the destination of the PLT. 83 * 84 * RD_VERSION4: 85 * o added the following field to the rd_loadobj_t structure: 86 * rl_tlsmodid - module ID for TLS references 87 */ 88 rd_err_e 89 rd_init(int version) 90 { 91 if ((version < RD_VERSION1) || 92 (version > RD_VERSION)) 93 return (RD_NOCAPAB); 94 rtld_db_version = version; 95 LOG(ps_plog(MSG_ORIG(MSG_DB_RDINIT), rtld_db_version)); 96 97 return (RD_OK); 98 } 99 100 rd_err_e 101 rd_ctl(int cmd, void *arg) 102 { 103 if (cmd != RD_CTL_SET_HELPPATH || arg == NULL || 104 strlen((char *)arg) >= MAXPATHLEN) 105 return (RD_ERR); 106 107 (void) strcpy(rtld_db_helper_path, (char *)arg); 108 109 return (RD_OK); 110 } 111 112 rd_err_e 113 rd_get_dyns(rd_agent_t *rap, psaddr_t addr, void **dynpp, size_t *dynpp_sz) 114 { 115 if (rap->rd_helper.rh_ops != NULL) 116 return (rap->rd_helper.rh_ops->rho_get_dyns( 117 rap->rd_helper.rh_data, addr, dynpp, dynpp_sz)); 118 119 #ifdef _LP64 120 if (rap->rd_dmodel == PR_MODEL_LP64) 121 return (_rd_get_dyns64(rap, 122 addr, (Elf64_Dyn **)dynpp, dynpp_sz)); 123 else 124 #endif 125 return (_rd_get_dyns32(rap, 126 addr, (Dyn **)dynpp, dynpp_sz)); 127 } 128 129 rd_err_e 130 rd_reset(struct rd_agent *rap) 131 { 132 rd_err_e err; 133 134 RDAGLOCK(rap); 135 136 rap->rd_flags = 0; 137 138 #ifdef _LP64 139 /* 140 * Determine if client is 32-bit or 64-bit. 141 */ 142 if (ps_pdmodel(rap->rd_psp, &rap->rd_dmodel) != PS_OK) { 143 LOG(ps_plog(MSG_ORIG(MSG_DB_DMLOOKFAIL))); 144 RDAGUNLOCK(rap); 145 return (RD_DBERR); 146 } 147 148 if (rap->rd_dmodel == PR_MODEL_LP64) 149 err = _rd_reset64(rap); 150 else 151 #endif 152 err = _rd_reset32(rap); 153 154 RDAGUNLOCK(rap); 155 return (err); 156 } 157 158 159 rd_agent_t * 160 rd_new(struct ps_prochandle *php) 161 { 162 rd_agent_t *rap; 163 164 LOG(ps_plog(MSG_ORIG(MSG_DB_RDNEW), php)); 165 if ((rap = (rd_agent_t *)calloc(sizeof (rd_agent_t), 1)) == NULL) 166 return (0); 167 168 rap->rd_psp = php; 169 (void) mutex_init(&rap->rd_mutex, USYNC_THREAD, 0); 170 if (rd_reset(rap) != RD_OK) { 171 if (rap->rd_helper.rh_dlhandle != NULL) { 172 rap->rd_helper.rh_ops->rho_fini(rap->rd_helper.rh_data); 173 (void) dlclose(rap->rd_helper.rh_dlhandle); 174 } 175 free(rap); 176 LOG(ps_plog(MSG_ORIG(MSG_DB_RESETFAIL))); 177 return ((rd_agent_t *)0); 178 } 179 180 return (rap); 181 } 182 183 184 void 185 rd_delete(rd_agent_t *rap) 186 { 187 LOG(ps_plog(MSG_ORIG(MSG_DB_RDDELETE), rap)); 188 if (rap->rd_helper.rh_dlhandle != NULL) { 189 rap->rd_helper.rh_ops->rho_fini(rap->rd_helper.rh_data); 190 (void) dlclose(rap->rd_helper.rh_dlhandle); 191 } 192 free(rap); 193 } 194 195 196 rd_err_e 197 rd_loadobj_iter(rd_agent_t *rap, rl_iter_f *cb, void *client_data) 198 { 199 rd_err_e err; 200 201 RDAGLOCK(rap); 202 203 #ifdef _LP64 204 if (rap->rd_dmodel == PR_MODEL_LP64) 205 err = _rd_loadobj_iter64(rap, cb, client_data); 206 else 207 #endif 208 err = _rd_loadobj_iter32(rap, cb, client_data); 209 210 RDAGUNLOCK(rap); 211 return (err); 212 } 213 214 215 rd_err_e 216 rd_plt_resolution(rd_agent_t *rap, psaddr_t pc, lwpid_t lwpid, 217 psaddr_t pltbase, rd_plt_info_t *rpi) 218 { 219 rd_err_e err; 220 RDAGLOCK(rap); 221 #ifdef _LP64 222 if (rap->rd_dmodel == PR_MODEL_LP64) 223 err = plt64_resolution(rap, pc, lwpid, pltbase, 224 rpi); 225 else 226 #endif 227 err = plt32_resolution(rap, pc, lwpid, pltbase, 228 rpi); 229 RDAGUNLOCK(rap); 230 return (err); 231 } 232 233 rd_err_e 234 rd_event_addr(rd_agent_t *rap, rd_event_e num, rd_notify_t *np) 235 { 236 rd_err_e rc = RD_OK; 237 238 RDAGLOCK(rap); 239 switch (num) { 240 case RD_NONE: 241 break; 242 case RD_PREINIT: 243 np->type = RD_NOTIFY_BPT; 244 np->u.bptaddr = rap->rd_preinit; 245 break; 246 case RD_POSTINIT: 247 np->type = RD_NOTIFY_BPT; 248 np->u.bptaddr = rap->rd_postinit; 249 break; 250 case RD_DLACTIVITY: 251 np->type = RD_NOTIFY_BPT; 252 np->u.bptaddr = rap->rd_dlact; 253 break; 254 default: 255 LOG(ps_plog(MSG_ORIG(MSG_DB_UNEXPEVENT), num)); 256 rc = RD_ERR; 257 break; 258 } 259 if (rc == RD_OK) { 260 LOG(ps_plog(MSG_ORIG(MSG_DB_RDEVENTADDR), num, 261 EC_ADDR(np->u.bptaddr))); 262 } 263 264 RDAGUNLOCK(rap); 265 return (rc); 266 } 267 268 269 /* ARGSUSED 0 */ 270 rd_err_e 271 rd_event_enable(rd_agent_t *rap, int onoff) 272 { 273 rd_err_e err; 274 275 RDAGLOCK(rap); 276 277 #ifdef _LP64 278 if (rap->rd_dmodel == PR_MODEL_LP64) 279 err = _rd_event_enable64(rap, onoff); 280 else 281 #endif 282 err = _rd_event_enable32(rap, onoff); 283 284 RDAGUNLOCK(rap); 285 return (err); 286 } 287 288 289 rd_err_e 290 rd_event_getmsg(rd_agent_t *rap, rd_event_msg_t *emsg) 291 { 292 rd_err_e err; 293 294 RDAGLOCK(rap); 295 296 #ifdef _LP64 297 if (rap->rd_dmodel == PR_MODEL_LP64) 298 err = _rd_event_getmsg64(rap, emsg); 299 else 300 #endif 301 err = _rd_event_getmsg32(rap, emsg); 302 303 RDAGUNLOCK(rap); 304 return (err); 305 } 306 307 308 rd_err_e 309 rd_binder_exit_addr(struct rd_agent *rap, const char *bname, psaddr_t *beaddr) 310 { 311 ps_sym_t sym; 312 313 if (rap->rd_tbinder) { 314 *beaddr = rap->rd_tbinder; 315 return (RD_OK); 316 } 317 if (ps_pglobal_sym(rap->rd_psp, PS_OBJ_LDSO, bname, &sym) != PS_OK) { 318 LOG(ps_plog(MSG_ORIG(MSG_DB_UNFNDSYM), 319 bname)); 320 return (RD_ERR); 321 } 322 323 rap->rd_tbinder = *beaddr = sym.st_value + sym.st_size - M_BIND_ADJ; 324 325 return (RD_OK); 326 } 327 328 329 rd_err_e 330 rd_objpad_enable(struct rd_agent *rap, size_t padsize) 331 { 332 rd_err_e err; 333 334 RDAGLOCK(rap); 335 336 #ifdef _LP64 337 if (rap->rd_dmodel == PR_MODEL_LP64) 338 err = _rd_objpad_enable64(rap, padsize); 339 else 340 #endif 341 err = _rd_objpad_enable32(rap, padsize); 342 343 RDAGUNLOCK(rap); 344 return (err); 345 } 346 347 348 char * 349 rd_errstr(rd_err_e rderr) 350 { 351 /* 352 * Convert an 'rd_err_e' to a string 353 */ 354 switch (rderr) { 355 case RD_OK: 356 return ((char *)MSG_ORIG(MSG_ER_OK)); 357 case RD_ERR: 358 return ((char *)MSG_ORIG(MSG_ER_ERR)); 359 case RD_DBERR: 360 return ((char *)MSG_ORIG(MSG_ER_DBERR)); 361 case RD_NOCAPAB: 362 return ((char *)MSG_ORIG(MSG_ER_NOCAPAB)); 363 case RD_NODYNAM: 364 return ((char *)MSG_ORIG(MSG_ER_NODYNAM)); 365 case RD_NOBASE: 366 return ((char *)MSG_ORIG(MSG_ER_NOBASE)); 367 case RD_NOMAPS: 368 return ((char *)MSG_ORIG(MSG_ER_NOMAPS)); 369 default: 370 return ((char *)MSG_ORIG(MSG_ER_DEFAULT)); 371 } 372 } 373