xref: /titanic_41/usr/src/cmd/sgs/rtld/mdbmod/common/rtld.c (revision b533f56bf95137d3de6666bd923e15ec373ea611)
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) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
24  */
25 
26 #include <msg.h>
27 #include <_rtld.h>
28 #include <conv.h>
29 #include <sys/mdb_modapi.h>
30 #include <sys/param.h>
31 #include <stdlib.h>
32 
33 /*
34  * Data structure for walkers.
35  */
36 typedef struct {
37 	uint_t	w_flags;
38 } W_desc;
39 
40 /*
41  * Flags values for dcmds
42  */
43 
44 #define	RTLD_FLG_VERBOSE	0x0001		/* verbose output */
45 
46 static const mdb_bitmask_t rtflags_bits[] = {
47 	{ MSG_ORIG(MSG_FLG_ISMAIN), FLG_RT_ISMAIN, FLG_RT_ISMAIN},
48 	{ MSG_ORIG(MSG_FLG_IMGALLOC), FLG_RT_IMGALLOC, FLG_RT_IMGALLOC},
49 	{ MSG_ORIG(MSG_FLG_RELOCED), FLG_RT_RELOCED, FLG_RT_RELOCED},
50 	{ MSG_ORIG(MSG_FLG_SETGROUP), FLG_RT_SETGROUP, FLG_RT_SETGROUP},
51 	{ MSG_ORIG(MSG_FLG_CAP), FLG_RT_CAP, FLG_RT_CAP},
52 	{ MSG_ORIG(MSG_FLG_OBJECT), FLG_RT_OBJECT, FLG_RT_OBJECT},
53 	{ MSG_ORIG(MSG_FLG_NEWLOAD), FLG_RT_NEWLOAD, FLG_RT_NEWLOAD},
54 	{ MSG_ORIG(MSG_FLG_NODUMP), FLG_RT_NODUMP, FLG_RT_NODUMP},
55 	{ MSG_ORIG(MSG_FLG_DELETE), FLG_RT_DELETE, FLG_RT_DELETE},
56 	{ MSG_ORIG(MSG_FLG_ANALYZED), FLG_RT_ANALYZED, FLG_RT_ANALYZED},
57 	{ MSG_ORIG(MSG_FLG_INITDONE), FLG_RT_INITDONE, FLG_RT_INITDONE},
58 	{ MSG_ORIG(MSG_FLG_TRANS), FLG_RT_TRANS, FLG_RT_TRANS},
59 	{ MSG_ORIG(MSG_FLG_FIXED), FLG_RT_FIXED, FLG_RT_FIXED},
60 	{ MSG_ORIG(MSG_FLG_PRELOAD), FLG_RT_PRELOAD, FLG_RT_PRELOAD},
61 	{ MSG_ORIG(MSG_FLG_ALTER), FLG_RT_ALTER, FLG_RT_ALTER},
62 	{ MSG_ORIG(MSG_FLG_LOADFLTR), FLG_RT_LOADFLTR, FLG_RT_LOADFLTR},
63 	{ MSG_ORIG(MSG_FLG_AUDIT), FLG_RT_AUDIT, FLG_RT_AUDIT},
64 	{ MSG_ORIG(MSG_FLG_MODESET), FLG_RT_MODESET, FLG_RT_MODESET},
65 	{ MSG_ORIG(MSG_FLG_ANALZING), FLG_RT_ANALZING, FLG_RT_ANALZING},
66 	{ MSG_ORIG(MSG_FLG_INITFRST), FLG_RT_INITFRST, FLG_RT_INITFRST},
67 	{ MSG_ORIG(MSG_FLG_NOOPEN), FLG_RT_NOOPEN, FLG_RT_NOOPEN},
68 	{ MSG_ORIG(MSG_FLG_FINICLCT), FLG_RT_FINICLCT, FLG_RT_FINICLCT},
69 	{ MSG_ORIG(MSG_FLG_INITCALL), FLG_RT_INITCALL, FLG_RT_INITCALL},
70 	{ MSG_ORIG(MSG_FLG_OBJINTPO), FLG_RT_OBJINTPO, FLG_RT_OBJINTPO},
71 	{ MSG_ORIG(MSG_FLG_SYMINTPO), FLG_RT_SYMINTPO, FLG_RT_SYMINTPO},
72 	{ MSG_ORIG(MSG_FLG_MOVE), FLG_RT_MOVE, FLG_RT_MOVE},
73 	{ MSG_ORIG(MSG_FLG_RELOCING), FLG_RT_RELOCING, FLG_RT_RELOCING},
74 	{ MSG_ORIG(MSG_FLG_REGSYMS), FLG_RT_REGSYMS, FLG_RT_REGSYMS},
75 	{ MSG_ORIG(MSG_FLG_INITCLCT), FLG_RT_INITCLCT, FLG_RT_INITCLCT},
76 	{ MSG_ORIG(MSG_FLG_PUBHDL), FLG_RT_PUBHDL, FLG_RT_PUBHDL},
77 	{ MSG_ORIG(MSG_FLG_PRIHDL), FLG_RT_PRIHDL, FLG_RT_PRIHDL},
78 	{ NULL, 0, 0}
79 };
80 
81 static const mdb_bitmask_t rtflags1_bits[] = {
82 	{ MSG_ORIG(MSG_FL1_COPYTOOK), FL1_RT_COPYTOOK, FL1_RT_COPYTOOK},
83 	{ MSG_ORIG(MSG_FL1_ALTCHECK), FL1_RT_ALTCHECK, FL1_RT_ALTCHECK},
84 	{ MSG_ORIG(MSG_FL1_ALTCAP), FL1_RT_ALTCAP, FL1_RT_ALTCAP},
85 	{ MSG_ORIG(MSG_FL1_CONFSET), FL1_RT_CONFSET, FL1_RT_CONFSET },
86 	{ MSG_ORIG(MSG_FL1_NODEFLIB), FL1_RT_NODEFLIB, FL1_RT_NODEFLIB },
87 	{ MSG_ORIG(MSG_FL1_ENDFILTE), FL1_RT_ENDFILTE, FL1_RT_ENDFILTE },
88 	{ MSG_ORIG(MSG_FL1_DISPREL), FL1_RT_DISPREL, FL1_RT_DISPREL },
89 	{ MSG_ORIG(MSG_FL1_DTFLAGS), FL1_RT_DTFLAGS, FL1_RT_DTFLAGS},
90 	{ MSG_ORIG(MSG_FL1_LDDSTUB), FL1_RT_LDDSTUB, FL1_RT_LDDSTUB},
91 	{ MSG_ORIG(MSG_FL1_NOINIFIN), FL1_RT_NOINIFIN, FL1_RT_NOINIFIN },
92 	{ MSG_ORIG(MSG_FL1_USED), FL1_RT_USED, FL1_RT_USED },
93 	{ MSG_ORIG(MSG_FL1_SYMBOLIC), FL1_RT_SYMBOLIC, FL1_RT_SYMBOLIC },
94 	{ MSG_ORIG(MSG_FL1_OBJSFLTR), FL1_RT_OBJSFLTR, FL1_RT_OBJSFLTR },
95 	{ MSG_ORIG(MSG_FL1_OBJAFLTR), FL1_RT_OBJAFLTR, FL1_RT_OBJAFLTR },
96 	{ MSG_ORIG(MSG_FL1_SYMSFLTR), FL1_RT_SYMSFLTR, FL1_RT_SYMSFLTR },
97 	{ MSG_ORIG(MSG_FL1_SYMAFLTR), FL1_RT_SYMAFLTR, FL1_RT_SYMAFLTR },
98 	{ MSG_ORIG(MSG_FL1_TLSADD), FL1_RT_TLSADD, FL1_RT_TLSADD },
99 	{ MSG_ORIG(MSG_FL1_TLSSTAT), FL1_RT_TLSSTAT, FL1_RT_TLSSTAT },
100 	{ MSG_ORIG(MSG_FL1_DIRECT), FL1_RT_DIRECT, FL1_RT_DIRECT},
101 	{ MSG_ORIG(MSG_FL1_GLOBAUD), FL1_RT_GLOBAUD, FL1_RT_GLOBAUD},
102 	{ MSG_ORIG(MSG_FL1_DEPAUD), FL1_RT_DEPAUD, FL1_RT_DEPAUD},
103 	{ NULL, 0, 0}
104 };
105 
106 static const mdb_bitmask_t rtaflags_bits[] = {
107 	{ MSG_ORIG(MSG_LTFL_AUD_PREINIT), LML_TFLG_AUD_PREINIT,
108 	    LML_TFLG_AUD_PREINIT },
109 	{ MSG_ORIG(MSG_LTFL_AUD_OBJSEARCH), LML_TFLG_AUD_OBJSEARCH,
110 	    LML_TFLG_AUD_OBJSEARCH },
111 	{ MSG_ORIG(MSG_LTFL_AUD_OBJOPEN), LML_TFLG_AUD_OBJOPEN,
112 	    LML_TFLG_AUD_OBJOPEN },
113 	{ MSG_ORIG(MSG_LTFL_AUD_OBJFILTER), LML_TFLG_AUD_OBJFILTER,
114 	    LML_TFLG_AUD_OBJFILTER },
115 	{ MSG_ORIG(MSG_LTFL_AUD_OBJCLOSE), LML_TFLG_AUD_OBJCLOSE,
116 	    LML_TFLG_AUD_OBJCLOSE },
117 	{ MSG_ORIG(MSG_LTFL_AUD_SYMBIND), LML_TFLG_AUD_SYMBIND,
118 	    LML_TFLG_AUD_SYMBIND },
119 	{ MSG_ORIG(MSG_LTFL_AUD_PLTENTER), LML_TFLG_AUD_PLTENTER,
120 	    LML_TFLG_AUD_PLTENTER },
121 	{ MSG_ORIG(MSG_LTFL_AUD_PLTEXIT), LML_TFLG_AUD_PLTEXIT,
122 	    LML_TFLG_AUD_PLTEXIT },
123 	{ MSG_ORIG(MSG_LTFL_AUD_ACTIVITY), LML_TFLG_AUD_ACTIVITY,
124 	    LML_TFLG_AUD_ACTIVITY },
125 	{ NULL, 0, 0}
126 };
127 
128 static const mdb_bitmask_t rtmode_bits[] = {
129 	{ MSG_ORIG(MSG_MODE_LAZY), RTLD_LAZY, RTLD_LAZY },
130 	{ MSG_ORIG(MSG_MODE_NOW), RTLD_NOW, RTLD_NOW },
131 	{ MSG_ORIG(MSG_MODE_NOLOAD), RTLD_NOLOAD, RTLD_NOLOAD },
132 	{ MSG_ORIG(MSG_MODE_GLOBAL), RTLD_GLOBAL, RTLD_GLOBAL },
133 	{ MSG_ORIG(MSG_MODE_PARENT), RTLD_PARENT, RTLD_PARENT },
134 	{ MSG_ORIG(MSG_MODE_GROUP), RTLD_GROUP, RTLD_GROUP },
135 	{ MSG_ORIG(MSG_MODE_WORLD), RTLD_WORLD, RTLD_WORLD },
136 	{ MSG_ORIG(MSG_MODE_NODELETE), RTLD_NODELETE, RTLD_NODELETE },
137 	{ MSG_ORIG(MSG_MODE_FIRST), RTLD_FIRST, RTLD_FIRST },
138 	{ MSG_ORIG(MSG_MODE_CONFGEN), RTLD_CONFGEN, RTLD_CONFGEN },
139 	{ NULL, 0, 0}
140 };
141 
142 static const mdb_bitmask_t bndflags_bits[] = {
143 	{ MSG_ORIG(MSG_BFL_NEEDED), BND_NEEDED, BND_NEEDED },
144 	{ MSG_ORIG(MSG_BFL_REFER), BND_REFER, BND_REFER },
145 	{ MSG_ORIG(MSG_BFL_FILTER), BND_FILTER, BND_FILTER },
146 	{ NULL, 0, 0}
147 };
148 
149 static const mdb_bitmask_t grhflags_bits[] = {
150 	{ MSG_ORIG(MSG_GPH_PUBLIC), GPH_PUBLIC, GPH_PUBLIC },
151 	{ MSG_ORIG(MSG_GPH_PRIVATE), GPH_PRIVATE, GPH_PRIVATE },
152 	{ MSG_ORIG(MSG_GPH_ZERO), GPH_ZERO, GPH_ZERO },
153 	{ MSG_ORIG(MSG_GPH_LDSO), GPH_LDSO, GPH_LDSO },
154 	{ MSG_ORIG(MSG_GPH_FIRST), GPH_FIRST, GPH_FIRST },
155 	{ MSG_ORIG(MSG_GPH_FILTEE), GPH_FILTEE, GPH_FILTEE },
156 	{ MSG_ORIG(MSG_GPH_INITIAL), GPH_INITIAL, GPH_INITIAL },
157 	{ NULL, 0, 0}
158 };
159 
160 static const mdb_bitmask_t grdflags_bits[] = {
161 	{ MSG_ORIG(MSG_GPD_DLSYM), GPD_DLSYM, GPD_DLSYM },
162 	{ MSG_ORIG(MSG_GPD_RELOC), GPD_RELOC, GPD_RELOC },
163 	{ MSG_ORIG(MSG_GPD_ADDEPS), GPD_ADDEPS, GPD_ADDEPS },
164 	{ MSG_ORIG(MSG_GPD_PARENT), GPD_PARENT, GPD_PARENT },
165 	{ MSG_ORIG(MSG_GPD_FILTER), GPD_FILTER, GPD_FILTER },
166 	{ MSG_ORIG(MSG_GPD_REMOVE), GPD_REMOVE, GPD_REMOVE },
167 	{ NULL, 0, 0}
168 };
169 
170 static const mdb_bitmask_t lmc_bits[] = {
171 	{ MSG_ORIG(MSG_LMC_ANALYZING), LMC_FLG_ANALYZING, LMC_FLG_ANALYZING},
172 	{ MSG_ORIG(MSG_LMC_RELOCATING), LMC_FLG_RELOCATING, LMC_FLG_RELOCATING},
173 	{ MSG_ORIG(MSG_LMC_REANALYZE), LMC_FLG_REANALYZE, LMC_FLG_REANALYZE},
174 	{ NULL, 0, 0}
175 };
176 
177 /*
178  * Obtain a string - typically a link-map name.
179  */
180 static char *
String(uintptr_t addr,const char * name)181 String(uintptr_t addr, const char *name)
182 {
183 	static char	str[MAXPATHLEN];
184 
185 	if (addr) {
186 		if (mdb_readstr(str, MAXPATHLEN, addr) == -1) {
187 			mdb_warn(MSG_ORIG(MSG_ERR_READ), name, addr);
188 			return (0);
189 		}
190 		return (str);
191 	}
192 	return ((char *)MSG_ORIG(MSG_STR_EMPTY));
193 }
194 
195 /*
196  * Obtain a link-map name.
197  */
198 static char *
Rtmap_Name(uintptr_t addr)199 Rtmap_Name(uintptr_t addr)
200 {
201 	Rt_map	rtmap;
202 
203 	if (addr) {
204 		if (mdb_vread(&rtmap, sizeof (Rt_map), addr) == -1) {
205 			mdb_warn(MSG_ORIG(MSG_ERR_READ),
206 			    MSG_ORIG(MSG_RTMAP_STR), addr);
207 			return (0);
208 		}
209 		return (String((uintptr_t)NAME(&rtmap),
210 		    MSG_ORIG(MSG_STR_NAME)));
211 	}
212 	return ((char *)MSG_ORIG(MSG_STR_EMPTY));
213 }
214 
215 void
dcmd_Bind_help(void)216 dcmd_Bind_help(void)
217 {
218 	mdb_printf(MSG_ORIG(MSG_BND_HELP));
219 }
220 
221 static int
222 /* ARGSUSED2 */
dcmd_Bind(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)223 dcmd_Bind(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
224 {
225 	Bnd_desc	bnd;
226 	char		*str;
227 
228 	/*
229 	 * Insure we have a valid address.
230 	 */
231 	if ((flags & DCMD_ADDRSPEC) == 0) {
232 		mdb_warn(MSG_ORIG(MSG_ERR_NAS), MSG_ORIG(MSG_BND_STR));
233 		return (DCMD_USAGE);
234 	}
235 
236 	/*
237 	 * Obtain the binding descriptor.
238 	 */
239 	if (mdb_vread(&bnd, sizeof (Bnd_desc), addr) == -1) {
240 		mdb_warn(MSG_ORIG(MSG_ERR_READ), MSG_ORIG(MSG_BND_STR), addr);
241 		return (DCMD_ERR);
242 	}
243 	mdb_printf(MSG_ORIG(MSG_BND_TITLE), addr);
244 
245 	/*
246 	 * Establish the identity of the caller.
247 	 */
248 	if ((str = Rtmap_Name((uintptr_t)bnd.b_caller)) == 0)
249 		return (DCMD_ERR);
250 	mdb_printf(MSG_ORIG(MSG_BND_LINE1), bnd.b_caller, str);
251 
252 	/*
253 	 * Establish the identity of the dependency.
254 	 */
255 	if ((str = Rtmap_Name((uintptr_t)bnd.b_depend)) == 0)
256 		return (DCMD_ERR);
257 	mdb_printf(MSG_ORIG(MSG_BND_LINE2), bnd.b_depend, str);
258 
259 	/*
260 	 * Display any flags.
261 	 */
262 	mdb_printf(MSG_ORIG(MSG_BND_LINE3), bnd.b_flags, bnd.b_flags,
263 	    bndflags_bits);
264 
265 	return (DCMD_OK);
266 }
267 
268 static void
dcmd_Depends_help(void)269 dcmd_Depends_help(void)
270 {
271 	mdb_printf(MSG_ORIG(MSG_DEPENDS_HELP));
272 }
273 
274 static int
Depends(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv,uint_t flg,const char * msg)275 Depends(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv,
276     uint_t flg, const char *msg)
277 {
278 	APlist		apl;
279 	uintptr_t	datap, nitems;
280 	Bnd_desc	*bdp;
281 
282 	/*
283 	 * Obtain the APlist and determine its number of elements and those
284 	 * that are in use.
285 	 */
286 	if (mdb_vread(&apl, sizeof (APlist), addr) == -1) {
287 		mdb_warn(MSG_ORIG(MSG_ERR_READ), MSG_ORIG(MSG_STR_APLIST),
288 		    addr);
289 		return (DCMD_ERR);
290 	}
291 
292 	mdb_printf(msg, addr, (size_t)apl.apl_nitems,
293 	    (size_t)apl.apl_arritems);
294 
295 	if (((flg & RTLD_FLG_VERBOSE) == 0) || (apl.apl_nitems == 0))
296 		return (DCMD_OK);
297 
298 	/*
299 	 * Under verbose mode print the name of each dependency.  An APlist can
300 	 * have a variable number of data items, so read each individual entry.
301 	 */
302 	datap = APLIST_OFF_DATA + (uintptr_t)addr;
303 	if (mdb_vread(&bdp, sizeof (Bnd_desc *), datap) == -1) {
304 		mdb_warn(MSG_ORIG(MSG_ERR_READ),
305 		    MSG_ORIG(MSG_BNDDESC_STR), datap);
306 		return (DCMD_ERR);
307 	}
308 
309 	(void) mdb_inc_indent(4);
310 	mdb_printf(MSG_ORIG(MSG_STR_DASHES));
311 
312 	if (dcmd_Bind((uintptr_t)bdp, flags, argc, argv) == DCMD_ERR) {
313 		(void) mdb_dec_indent(4);
314 		return (DCMD_ERR);
315 	}
316 
317 	for (nitems = 1; nitems < apl.apl_nitems; nitems++) {
318 		datap += sizeof (void *);
319 		if (mdb_vread(&bdp, sizeof (Bnd_desc *), datap) == -1) {
320 			mdb_warn(MSG_ORIG(MSG_ERR_READ),
321 			    MSG_ORIG(MSG_BNDDESC_STR), datap);
322 			return (DCMD_ERR);
323 		}
324 
325 		mdb_printf(MSG_ORIG(MSG_STR_DASHES));
326 		if (dcmd_Bind((uintptr_t)bdp, flags, argc, argv) == DCMD_ERR) {
327 			(void) mdb_dec_indent(4);
328 			return (DCMD_ERR);
329 		}
330 	}
331 	(void) mdb_dec_indent(4);
332 	return (DCMD_OK);
333 }
334 
335 static int
dcmd_Depends(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)336 dcmd_Depends(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
337 {
338 	Rt_map		rtmap;
339 	char		*str;
340 	uint_t		flg = 0;
341 
342 	/*
343 	 * Insure we have a valid address, and provide for a -v option.
344 	 */
345 	if ((flags & DCMD_ADDRSPEC) == 0) {
346 		mdb_warn(MSG_ORIG(MSG_ERR_NAS), MSG_ORIG(MSG_DEPENDS_STR));
347 		return (DCMD_USAGE);
348 	}
349 	if (mdb_getopts(argc, argv, 'v', MDB_OPT_SETBITS, RTLD_FLG_VERBOSE,
350 	    &flg, NULL) != argc)
351 		return (DCMD_USAGE);
352 
353 	/*
354 	 * Read the Rt_map contents.
355 	 */
356 	if (mdb_vread(&rtmap, sizeof (Rt_map), addr) == -1) {
357 		mdb_warn(MSG_ORIG(MSG_ERR_READ), MSG_ORIG(MSG_RTMAP_STR), addr);
358 		return (DCMD_ERR);
359 	}
360 	if ((str = String((uintptr_t)NAME(&rtmap),
361 	    MSG_ORIG(MSG_STR_NAME))) == 0)
362 		return (DCMD_ERR);
363 
364 	mdb_printf(MSG_ORIG(MSG_DEPENDS_LINE1), str);
365 	mdb_printf(MSG_ORIG(MSG_STR_DASHES));
366 
367 	if (DEPENDS(&rtmap) == NULL)
368 		return (DCMD_OK);
369 
370 	return (Depends((uintptr_t)DEPENDS(&rtmap), flags, argc, argv, flg,
371 	    MSG_ORIG(MSG_DEPENDS_LINE2)));
372 }
373 
374 static void
dcmd_Callers_help(void)375 dcmd_Callers_help(void)
376 {
377 	mdb_printf(MSG_ORIG(MSG_CALLERS_HELP));
378 }
379 
380 static int
dcmd_Callers(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)381 dcmd_Callers(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
382 {
383 	Rt_map		rtmap;
384 	char		*str;
385 	uint_t		flg = 0;
386 
387 	/*
388 	 * Insure we have a valid address, and provide for a -v option.
389 	 */
390 	if ((flags & DCMD_ADDRSPEC) == 0) {
391 		mdb_warn(MSG_ORIG(MSG_ERR_NAS), MSG_ORIG(MSG_DEPENDS_STR));
392 		return (DCMD_USAGE);
393 	}
394 	if (mdb_getopts(argc, argv, 'v', MDB_OPT_SETBITS, RTLD_FLG_VERBOSE,
395 	    &flg, NULL) != argc)
396 		return (DCMD_USAGE);
397 
398 	/*
399 	 * Read the Rt_map contents.
400 	 */
401 	if (mdb_vread(&rtmap, sizeof (Rt_map), addr) == -1) {
402 		mdb_warn(MSG_ORIG(MSG_ERR_READ), MSG_ORIG(MSG_RTMAP_STR), addr);
403 		return (DCMD_ERR);
404 	}
405 	if ((str = String((uintptr_t)NAME(&rtmap),
406 	    MSG_ORIG(MSG_STR_NAME))) == 0)
407 		return (DCMD_ERR);
408 
409 	mdb_printf(MSG_ORIG(MSG_CALLERS_LINE1), str);
410 	mdb_printf(MSG_ORIG(MSG_STR_DASHES));
411 
412 	if (CALLERS(&rtmap) == NULL)
413 		return (DCMD_OK);
414 
415 	return (Depends((uintptr_t)CALLERS(&rtmap), flags, argc, argv, flg,
416 	    MSG_ORIG(MSG_CALLERS_LINE2)));
417 }
418 
419 void
dcmd_rtmap_help(void)420 dcmd_rtmap_help(void)
421 {
422 	mdb_printf(MSG_ORIG(MSG_RTMAP_HELP));
423 }
424 
425 static int
426 /* ARGSUSED2 */
dcmd_rtmap(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)427 dcmd_rtmap(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
428 {
429 	Rt_map		rtmap;
430 	char		*str;
431 
432 	if ((flags & DCMD_ADDRSPEC) == 0) {
433 		mdb_warn(MSG_ORIG(MSG_ERR_NAS), MSG_ORIG(MSG_RTMAP_STR));
434 		return (DCMD_USAGE);
435 	}
436 
437 	if (mdb_vread(&rtmap, sizeof (Rt_map), addr) == -1) {
438 		mdb_warn(MSG_ORIG(MSG_ERR_READ), MSG_ORIG(MSG_RTMAP_STR), addr);
439 		return (DCMD_ERR);
440 	}
441 
442 	mdb_printf(MSG_ORIG(MSG_RTMAP_TITLE), addr);
443 	mdb_printf(MSG_ORIG(MSG_STR_DASHES));
444 
445 	/*
446 	 * Determine the objects name.  NAME() is the name by which the object
447 	 * has been opened, typically from adding a search path to a file name.
448 	 * PATHNAME() is the fully resolve name, which is displayed by the proc
449 	 * tools and debuggers.  If the two names differ, print the PATHNAME().
450 	 */
451 	if ((str = String((uintptr_t)NAME(&rtmap),
452 	    MSG_ORIG(MSG_STR_NAME))) == 0)
453 		return (DCMD_ERR);
454 	mdb_printf(MSG_ORIG(MSG_RTMAP_LINE1), str);
455 	if (NAME(&rtmap) != PATHNAME(&rtmap)) {
456 		if ((str = String((uintptr_t)PATHNAME(&rtmap),
457 		    MSG_ORIG(MSG_STR_PATHNAME))) == 0)
458 			return (DCMD_ERR);
459 		mdb_printf(MSG_ORIG(MSG_RTMAP_LINE2), str);
460 	}
461 
462 	mdb_printf(MSG_ORIG(MSG_RTMAP_LINE3), ADDR(&rtmap), DYN(&rtmap));
463 	mdb_printf(MSG_ORIG(MSG_RTMAP_LINE4), NEXT(&rtmap), PREV(&rtmap));
464 	mdb_printf(MSG_ORIG(MSG_RTMAP_LINE5), rtmap.rt_fct, TLSMODID(&rtmap));
465 	mdb_printf(MSG_ORIG(MSG_RTMAP_LINE6), INIT(&rtmap), FINI(&rtmap));
466 	mdb_printf(MSG_ORIG(MSG_RTMAP_LINE7), GROUPS(&rtmap), HANDLES(&rtmap));
467 	mdb_printf(MSG_ORIG(MSG_RTMAP_LINE8), DEPENDS(&rtmap), CALLERS(&rtmap));
468 
469 	if ((str = String((uintptr_t)REFNAME(&rtmap),
470 	    MSG_ORIG(MSG_STR_REFNAME))) == 0)
471 		return (DCMD_ERR);
472 	mdb_printf(MSG_ORIG(MSG_RTMAP_LINE9), DYNINFO(&rtmap), str);
473 
474 	if ((str = String((uintptr_t)RPATH(&rtmap),
475 	    MSG_ORIG(MSG_STR_RPATH))) == 0)
476 		return (DCMD_ERR);
477 	mdb_printf(MSG_ORIG(MSG_RTMAP_LINE10), RLIST(&rtmap), str);
478 
479 	mdb_printf(MSG_ORIG(MSG_RTMAP_LINE11), LIST(&rtmap), LIST(&rtmap));
480 	mdb_printf(MSG_ORIG(MSG_RTMAP_LINE12), FLAGS(&rtmap));
481 	mdb_printf(MSG_ORIG(MSG_RTMAP_LINE20), FLAGS(&rtmap), rtflags_bits);
482 	mdb_printf(MSG_ORIG(MSG_RTMAP_LINE13), FLAGS1(&rtmap));
483 	mdb_printf(MSG_ORIG(MSG_RTMAP_LINE20), FLAGS1(&rtmap), rtflags1_bits);
484 	if (AFLAGS(&rtmap)) {
485 		mdb_printf(MSG_ORIG(MSG_RTMAP_LINE14), AFLAGS(&rtmap));
486 		mdb_printf(MSG_ORIG(MSG_RTMAP_LINE20), AFLAGS(&rtmap),
487 		    rtaflags_bits);
488 	}
489 	mdb_printf(MSG_ORIG(MSG_RTMAP_LINE15), MODE(&rtmap));
490 	mdb_printf(MSG_ORIG(MSG_RTMAP_LINE20), MODE(&rtmap), rtmode_bits);
491 
492 	return (DCMD_OK);
493 }
494 
495 static int
rtmap_format(uintptr_t addr,const void * data,void * private)496 rtmap_format(uintptr_t addr, const void *data, void *private)
497 {
498 	const Rt_map	*lmp = (const Rt_map *)data;
499 	W_desc		*wdp = (W_desc *)private;
500 	char		*str;
501 
502 	if (wdp && (wdp->w_flags & RTLD_FLG_VERBOSE)) {
503 		mdb_printf(MSG_ORIG(MSG_STR_DASHES));
504 		(void) mdb_call_dcmd(
505 		    MSG_ORIG(MSG_RTMAP_STR), addr, DCMD_ADDRSPEC, NULL, NULL);
506 		return (0);
507 	}
508 
509 	if ((str = String((uintptr_t)NAME(lmp),
510 	    MSG_ORIG(MSG_STR_NAME))) == 0)
511 		return (DCMD_ERR);
512 
513 	mdb_printf(MSG_ORIG(MSG_FMT_RT), CNTL(lmp), addr, ADDR(lmp), str);
514 	return (0);
515 }
516 
517 void
dcmd_Rtmaps_help(void)518 dcmd_Rtmaps_help(void)
519 {
520 	mdb_printf(MSG_ORIG(MSG_RTMAPS_HELP));
521 }
522 
523 static int
dcmd_Rtmaps(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)524 dcmd_Rtmaps(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
525 {
526 	uint_t		flg = 0;
527 	GElf_Sym	gsym;
528 	APlist		*aplp, apl;
529 	uintptr_t	datap, nitems;
530 	const char	*str;
531 	W_desc		wdesc;
532 
533 	/*
534 	 * '-v' - Verbose output of rtmap
535 	 */
536 	if (mdb_getopts(argc, argv, 'v', MDB_OPT_SETBITS, RTLD_FLG_VERBOSE,
537 	    &flg, NULL) != argc)
538 		return (DCMD_USAGE);
539 
540 	/*
541 	 * If an address was provided use it.
542 	 */
543 	if (flags & DCMD_ADDRSPEC) {
544 		if (((flags & DCMD_LOOPFIRST) || !(flags & DCMD_LOOP)) &&
545 		    !(flg & RTLD_FLG_VERBOSE)) {
546 			mdb_printf(MSG_ORIG(MSG_RTMAPS_TITLE0));
547 			mdb_printf(MSG_ORIG(MSG_STR_DASHES));
548 		}
549 
550 		wdesc.w_flags = flg;
551 		if (mdb_pwalk(MSG_ORIG(MSG_RTMAPS_STR), rtmap_format,
552 		    (void *)&wdesc, addr) == -1)
553 			return (DCMD_ERR);
554 		return (DCMD_OK);
555 	}
556 
557 	/*
558 	 * Otherwise traverse the dynlm_list and display each link-map.
559 	 */
560 	if (mdb_lookup_by_obj(MSG_ORIG(MSG_STR_LDSO1),
561 	    MSG_ORIG(MSG_STR_DYNLMLIST), &gsym) == -1) {
562 		mdb_warn(MSG_ORIG(MSG_ERR_SYMFAILED), MSG_ORIG(MSG_STR_LDSO1),
563 		    MSG_ORIG(MSG_STR_DYNLMLIST));
564 		return (DCMD_ERR);
565 	}
566 	if (mdb_vread(&aplp, sizeof (APlist *),
567 	    (uintptr_t)gsym.st_value) == -1) {
568 		mdb_warn(MSG_ORIG(MSG_ERR_READ), MSG_ORIG(MSG_STR_APLIST),
569 		    gsym.st_value);
570 		return (DCMD_ERR);
571 	}
572 
573 	if (aplp == NULL) {
574 		mdb_printf(MSG_ORIG(MSG_LMLIST_TITLE0),
575 		    MSG_ORIG(MSG_STR_DYNLMLIST));
576 		return (DCMD_OK);
577 	}
578 
579 	if (mdb_vread(&apl, sizeof (APlist), (uintptr_t)aplp) == -1) {
580 		mdb_warn(MSG_ORIG(MSG_ERR_READ), MSG_ORIG(MSG_STR_APLIST),
581 		    aplp);
582 	}
583 	mdb_printf(MSG_ORIG(MSG_LMLIST_TITLE1), MSG_ORIG(MSG_STR_DYNLMLIST),
584 	    aplp, (size_t)apl.apl_nitems, (size_t)apl.apl_arritems);
585 	mdb_printf(MSG_ORIG(MSG_STR_DASHES));
586 
587 	flags |= (DCMD_LOOP | DCMD_LOOPFIRST);
588 	for (datap = (uintptr_t)aplp + APLIST_OFF_DATA, nitems = 0;
589 	    nitems < apl.apl_nitems; nitems++, datap += sizeof (void *)) {
590 		Lm_list	*lml, lm;
591 
592 		if (mdb_vread(&lml, sizeof (Lm_list *), datap) == -1) {
593 			mdb_warn(MSG_ORIG(MSG_ERR_READ),
594 			    MSG_ORIG(MSG_LMLIST_STR), datap);
595 			return (DCMD_ERR);
596 		}
597 		if (mdb_vread(&lm, sizeof (Lm_list), (uintptr_t)lml) == -1) {
598 			mdb_warn(MSG_ORIG(MSG_ERR_READ),
599 			    MSG_ORIG(MSG_LMLIST_STR), lml);
600 			return (DCMD_ERR);
601 		}
602 
603 		(void) mdb_inc_indent(2);
604 		if (lm.lm_flags & LML_FLG_BASELM)
605 			str = MSG_ORIG(MSG_LMLIST_BASE);
606 		else if (lm.lm_flags & LML_FLG_RTLDLM)
607 			str = MSG_ORIG(MSG_LMLIST_LDSO);
608 		else
609 			str = MSG_ORIG(MSG_LMLIST_NEWLM);
610 
611 		if ((flags & DCMD_LOOP) && ((flags & DCMD_LOOPFIRST) == 0))
612 			mdb_printf(MSG_ORIG(MSG_STR_DASHES));
613 
614 		mdb_printf(MSG_ORIG(MSG_LMLIST_TITLE2), datap, str);
615 		mdb_printf(MSG_ORIG(MSG_STR_DASHES));
616 
617 		(void) mdb_inc_indent(2);
618 
619 		if (((flags & DCMD_LOOPFIRST) || !(flags & DCMD_LOOP)) &&
620 		    !(flg & RTLD_FLG_VERBOSE)) {
621 			mdb_printf(MSG_ORIG(MSG_RTMAPS_TITLE0));
622 			mdb_printf(MSG_ORIG(MSG_STR_DASHES));
623 		}
624 
625 		wdesc.w_flags = flg;
626 		if (mdb_pwalk(MSG_ORIG(MSG_RTMAPS_STR), rtmap_format,
627 		    (void *)&wdesc, (uintptr_t)lm.lm_head) == -1) {
628 			(void) mdb_dec_indent(4);
629 			return (DCMD_ERR);
630 		}
631 		(void) mdb_dec_indent(4);
632 		flags &= ~DCMD_LOOPFIRST;
633 	}
634 	return (DCMD_OK);
635 }
636 
637 void
dcmd_Setenv_help(void)638 dcmd_Setenv_help(void)
639 {
640 	mdb_printf(MSG_ORIG(MSG_SETENV_HELP));
641 }
642 
643 /*
644  * As of s10, mdb provides its own setenv command.  This command allows the
645  * environment of the process being controlled to be changed at any time.
646  * Prior to this, ld.so.1 provided it's own, more primitive implementation.
647  * This allowed for changing mdb's environment only, which if it was changed
648  * before the application ws executed, would be copied to the applications
649  * environment.  Thus, we could start mdb, set an LD_ variable within its
650  * environment (which it's own ld.so.1 had already finished processing), and
651  * have this setting be inherited by the application.
652  */
653 static int
654 /* ARGSUSED */
dcmd_Setenv(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)655 dcmd_Setenv(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
656 {
657 	char	*str;
658 
659 	if (mdb_call_dcmd(MSG_ORIG(MSG_STR_SETENV), addr, flags, argc,
660 	    argv) == 0)
661 		return (DCMD_OK);
662 
663 	if (((flags & DCMD_ADDRSPEC) != 0) || (argc == 0) || (argc > 1) ||
664 	    (argv->a_type != MDB_TYPE_STRING))
665 		return (DCMD_USAGE);
666 
667 	str = mdb_alloc((strlen(argv->a_un.a_str) + 1), UM_NOSLEEP);
668 	if (str == NULL)
669 		return (DCMD_ERR);
670 
671 	(void) strcpy(str, argv->a_un.a_str);
672 	(void) putenv(str);
673 	return (DCMD_OK);
674 }
675 
676 /*
677  * Walk Rt_map lists
678  */
679 static int
walk_rtmap_init(mdb_walk_state_t * wsp)680 walk_rtmap_init(mdb_walk_state_t *wsp)
681 {
682 	if (wsp->walk_addr == NULL) {
683 		mdb_warn(MSG_ORIG(MSG_ERR_NAS), MSG_ORIG(MSG_RTMAP_STR));
684 		return (WALK_ERR);
685 	}
686 	return (WALK_NEXT);
687 }
688 
689 static int
walk_rtmap_step(mdb_walk_state_t * wsp)690 walk_rtmap_step(mdb_walk_state_t *wsp)
691 {
692 	int	status;
693 	Rt_map	lmp;
694 
695 	if (wsp->walk_addr == NULL)
696 		return (WALK_DONE);
697 	if (mdb_vread(&lmp, sizeof (Rt_map), wsp->walk_addr) == -1) {
698 		mdb_warn(MSG_ORIG(MSG_ERR_READ),
699 		    MSG_ORIG(MSG_RTMAP_STR), wsp->walk_addr);
700 		return (WALK_DONE);
701 	}
702 
703 	status = wsp->walk_callback(wsp->walk_addr, &lmp, wsp->walk_cbdata);
704 	wsp->walk_addr = (uintptr_t)(NEXT(&lmp));
705 	return (status);
706 }
707 
708 static const mdb_bitmask_t lml_flags_bit[] = {
709 	{ MSG_ORIG(MSG_LFL_BASELM), LML_FLG_BASELM, LML_FLG_BASELM },
710 	{ MSG_ORIG(MSG_LFL_RTLDLM), LML_FLG_RTLDLM, LML_FLG_RTLDLM },
711 	{ MSG_ORIG(MSG_LFL_PLTREL), LML_FLG_PLTREL, LML_FLG_PLTREL },
712 	{ MSG_ORIG(MSG_LFL_HOLDLOCK), LML_FLG_HOLDLOCK, LML_FLG_HOLDLOCK },
713 	{ MSG_ORIG(MSG_LFL_ENVIRON), LML_FLG_ENVIRON, LML_FLG_ENVIRON },
714 	{ MSG_ORIG(MSG_LFL_INTRPOSE), LML_FLG_INTRPOSE, LML_FLG_INTRPOSE },
715 	{ MSG_ORIG(MSG_LFL_LOCAUDIT), LML_FLG_LOCAUDIT, LML_FLG_LOCAUDIT },
716 	{ MSG_ORIG(MSG_LFL_LOADAVAIL), LML_FLG_LOADAVAIL, LML_FLG_LOADAVAIL },
717 	{ MSG_ORIG(MSG_LFL_IGNRELERR), LML_FLG_IGNRELERR, LML_FLG_IGNRELERR },
718 	{ MSG_ORIG(MSG_LFL_STARTREL), LML_FLG_STARTREL, LML_FLG_STARTREL },
719 	{ MSG_ORIG(MSG_LFL_ATEXIT), LML_FLG_ATEXIT, LML_FLG_ATEXIT },
720 	{ MSG_ORIG(MSG_LFL_OBJADDED), LML_FLG_OBJADDED, LML_FLG_OBJADDED },
721 	{ MSG_ORIG(MSG_LFL_OBJDELETED), LML_FLG_OBJDELETED,
722 	    LML_FLG_OBJDELETED },
723 	{ MSG_ORIG(MSG_LFL_OBJREEVAL), LML_FLG_OBJREEVAL, LML_FLG_OBJREEVAL },
724 	{ MSG_ORIG(MSG_LFL_INTRPOSETSORT), LML_FLG_INTRPOSETSORT,
725 	    LML_FLG_INTRPOSETSORT },
726 	{ MSG_ORIG(MSG_LFL_AUDITNOTIFY), LML_FLG_AUDITNOTIFY,
727 	    LML_FLG_AUDITNOTIFY },
728 	{ MSG_ORIG(MSG_LFL_GROUPSEXIST), LML_FLG_GROUPSEXIST,
729 	    LML_FLG_GROUPSEXIST },
730 
731 	{ MSG_ORIG(MSG_LFL_TRC_LDDSTUB), LML_FLG_TRC_LDDSTUB,
732 	    LML_FLG_TRC_LDDSTUB },
733 	{ MSG_ORIG(MSG_LFL_TRC_ENABLE), LML_FLG_TRC_ENABLE,
734 	    LML_FLG_TRC_ENABLE },
735 	{ MSG_ORIG(MSG_LFL_TRC_WARN), LML_FLG_TRC_WARN, LML_FLG_TRC_WARN },
736 	{ MSG_ORIG(MSG_LFL_TRC_VERBOSE), LML_FLG_TRC_VERBOSE,
737 	    LML_FLG_TRC_VERBOSE },
738 	{ MSG_ORIG(MSG_LFL_TRC_SEARCH), LML_FLG_TRC_SEARCH,
739 	    LML_FLG_TRC_SEARCH },
740 	{ MSG_ORIG(MSG_LFL_TRC_UNREF), LML_FLG_TRC_UNREF, LML_FLG_TRC_UNREF },
741 	{ MSG_ORIG(MSG_LFL_TRC_UNUSED), LML_FLG_TRC_UNUSED,
742 	    LML_FLG_TRC_UNUSED },
743 	{ MSG_ORIG(MSG_LFL_TRC_INIT), LML_FLG_TRC_INIT, LML_FLG_TRC_INIT },
744 	{ MSG_ORIG(MSG_LFL_TRC_NOUNRESWEAK), LML_FLG_TRC_NOUNRESWEAK,
745 	    LML_FLG_TRC_NOUNRESWEAK },
746 	{ MSG_ORIG(MSG_LFL_TRC_NOPAREXT), LML_FLG_TRC_NOPAREXT,
747 	    LML_FLG_TRC_NOPAREXT },
748 	{ NULL, 0, 0}
749 };
750 
751 static const mdb_bitmask_t lml_tflags_bit[] = {
752 	{ MSG_ORIG(MSG_LTFL_NOLAZYLD), LML_TFLG_NOLAZYLD, LML_TFLG_NOLAZYLD },
753 	{ MSG_ORIG(MSG_LTFL_NODIRECT), LML_TFLG_NODIRECT, LML_TFLG_NODIRECT },
754 	{ MSG_ORIG(MSG_LTFL_NOAUDIT), LML_TFLG_NOAUDIT, LML_TFLG_NOAUDIT },
755 	{ MSG_ORIG(MSG_LTFL_LOADFLTR), LML_TFLG_LOADFLTR, LML_TFLG_LOADFLTR },
756 
757 	{ MSG_ORIG(MSG_LTFL_AUD_PREINIT), LML_TFLG_AUD_PREINIT,
758 	    LML_TFLG_AUD_PREINIT },
759 	{ MSG_ORIG(MSG_LTFL_AUD_OBJSEARCH), LML_TFLG_AUD_OBJSEARCH,
760 	    LML_TFLG_AUD_OBJSEARCH },
761 	{ MSG_ORIG(MSG_LTFL_AUD_OBJOPEN), LML_TFLG_AUD_OBJOPEN,
762 	    LML_TFLG_AUD_OBJOPEN },
763 	{ MSG_ORIG(MSG_LTFL_AUD_OBJFILTER), LML_TFLG_AUD_OBJFILTER,
764 	    LML_TFLG_AUD_OBJFILTER },
765 	{ MSG_ORIG(MSG_LTFL_AUD_OBJCLOSE), LML_TFLG_AUD_OBJCLOSE,
766 	    LML_TFLG_AUD_OBJCLOSE },
767 	{ MSG_ORIG(MSG_LTFL_AUD_SYMBIND), LML_TFLG_AUD_SYMBIND,
768 	    LML_TFLG_AUD_SYMBIND },
769 	{ MSG_ORIG(MSG_LTFL_AUD_PLTENTER), LML_TFLG_AUD_PLTENTER,
770 	    LML_TFLG_AUD_PLTENTER },
771 	{ MSG_ORIG(MSG_LTFL_AUD_PLTEXIT), LML_TFLG_AUD_PLTEXIT,
772 	    LML_TFLG_AUD_PLTEXIT },
773 	{ MSG_ORIG(MSG_LTFL_AUD_ACTIVITY), LML_TFLG_AUD_ACTIVITY,
774 	    LML_TFLG_AUD_ACTIVITY },
775 	{ NULL, 0, 0}
776 };
777 
778 void
dcmd_Lm_list_help(void)779 dcmd_Lm_list_help(void)
780 {
781 	mdb_printf(MSG_ORIG(MSG_LMLIST_HELP));
782 }
783 
784 static int
785 /* ARGSUSED1 */
_dcmd_Lm_list(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)786 _dcmd_Lm_list(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
787 {
788 	Lm_list		lml;
789 	const char	*str;
790 	uint_t		flg = 0;
791 
792 	if (mdb_getopts(argc, argv, 'v', MDB_OPT_SETBITS, RTLD_FLG_VERBOSE,
793 	    &flg, NULL) != argc)
794 		return (DCMD_USAGE);
795 
796 	if (mdb_vread(&lml, sizeof (lml), addr) == -1) {
797 		mdb_warn(MSG_ORIG(MSG_ERR_READ), MSG_ORIG(MSG_LMLIST_STR),
798 		    addr);
799 		return (DCMD_ERR);
800 	}
801 
802 	if (lml.lm_flags & LML_FLG_BASELM)
803 		str = MSG_ORIG(MSG_LMLIST_BASE);
804 	else if (lml.lm_flags & LML_FLG_RTLDLM)
805 		str = MSG_ORIG(MSG_LMLIST_LDSO);
806 	else
807 		str = MSG_ORIG(MSG_LMLIST_NEWLM);
808 
809 	if ((flags & DCMD_LOOP) && ((flags & DCMD_LOOPFIRST) == 0))
810 		mdb_printf(MSG_ORIG(MSG_STR_DASHES));
811 
812 	mdb_printf(MSG_ORIG(MSG_LMLIST_TITLE2), addr, str);
813 	mdb_printf(MSG_ORIG(MSG_STR_DASHES));
814 
815 	if (lml.lm_lists) {
816 		Alist		al;
817 		Lm_cntl		lmc;
818 		uintptr_t	datap;
819 
820 		addr = (uintptr_t)lml.lm_lists;
821 		if (mdb_vread(&al, sizeof (Alist), addr) == -1) {
822 			mdb_warn(MSG_ORIG(MSG_ERR_READ),
823 			    MSG_ORIG(MSG_STR_ALIST), addr);
824 			return (DCMD_ERR);
825 		}
826 
827 		/*
828 		 * Determine whether the Alist has been populated.  Note, the
829 		 * implementation first reserves an alist entry, and initializes
830 		 * this element when the first link-map is processed.  Thus,
831 		 * there's a window when nitems is updated, but before the next
832 		 * element has been initialized.
833 		 */
834 		if (al.al_nitems && (flg & RTLD_FLG_VERBOSE)) {
835 			datap = ALIST_OFF_DATA + (uintptr_t)addr;
836 
837 			if (mdb_vread(&lmc, sizeof (Lm_cntl),
838 			    datap) == -1) {
839 				mdb_warn(MSG_ORIG(MSG_ERR_READ),
840 				    MSG_ORIG(MSG_LMLIST_STR), datap);
841 				return (DCMD_ERR);
842 			}
843 		}
844 
845 		mdb_printf(MSG_ORIG(MSG_LMLIST_LINE0), addr,
846 		    (size_t)al.al_nitems, (size_t)al.al_arritems);
847 		(void) mdb_inc_indent(2);
848 		mdb_printf(MSG_ORIG(MSG_STR_DASHES));
849 
850 		if (al.al_nitems && (flg & RTLD_FLG_VERBOSE)) {
851 			uintptr_t	nitems;
852 
853 			(void) mdb_inc_indent(2);
854 			mdb_printf(MSG_ORIG(MSG_LMC_LINE1), datap);
855 			mdb_printf(MSG_ORIG(MSG_LMC_LINE2), lmc.lc_head,
856 			    lmc.lc_tail);
857 			mdb_printf(MSG_ORIG(MSG_LMC_LINE3), lmc.lc_flags,
858 			    lmc.lc_now);
859 			mdb_printf(MSG_ORIG(MSG_LMC_LINE4), lmc.lc_flags,
860 			    lmc_bits);
861 			mdb_printf(MSG_ORIG(MSG_STR_DASHES));
862 			mdb_printf(MSG_ORIG(MSG_RTMAPS_TITLE0));
863 			mdb_printf(MSG_ORIG(MSG_STR_DASHES));
864 
865 			if (lmc.lc_head) {
866 				if (mdb_pwalk(MSG_ORIG(MSG_RTMAPS_STR),
867 				    rtmap_format, (void *)0,
868 				    (uintptr_t)lmc.lc_head) == -1) {
869 					(void) mdb_dec_indent(4);
870 					return (DCMD_ERR);
871 				}
872 			} else
873 				mdb_printf(MSG_ORIG(MSG_FMT_RT), 0, 0, 0,
874 				    MSG_ORIG(MSG_STR_EMPTY));
875 
876 			mdb_printf(MSG_ORIG(MSG_STR_DASHES));
877 
878 			for (nitems = 1; nitems < al.al_nitems; nitems++) {
879 				datap += al.al_size;
880 				if (mdb_vread(&lmc, sizeof (Lm_cntl),
881 				    datap) == -1) {
882 					mdb_warn(MSG_ORIG(MSG_ERR_READ),
883 					    MSG_ORIG(MSG_LMLIST_STR), datap);
884 					(void) mdb_dec_indent(4);
885 					return (DCMD_ERR);
886 				}
887 
888 				mdb_printf(MSG_ORIG(MSG_STR_DASHES));
889 				mdb_printf(MSG_ORIG(MSG_LMC_LINE1), datap);
890 				mdb_printf(MSG_ORIG(MSG_LMC_LINE2),
891 				    lmc.lc_head, lmc.lc_tail);
892 				mdb_printf(MSG_ORIG(MSG_LMC_LINE3),
893 				    lmc.lc_flags, lmc.lc_now);
894 				mdb_printf(MSG_ORIG(MSG_LMC_LINE4),
895 				    lmc.lc_flags, lmc_bits);
896 				mdb_printf(MSG_ORIG(MSG_STR_DASHES));
897 				mdb_printf(MSG_ORIG(MSG_RTMAPS_TITLE0));
898 				mdb_printf(MSG_ORIG(MSG_STR_DASHES));
899 
900 				if (lmc.lc_head) {
901 					if (mdb_pwalk(MSG_ORIG(MSG_RTMAPS_STR),
902 					    rtmap_format, (void *)0,
903 					    (uintptr_t)lmc.lc_head) == -1) {
904 						(void) mdb_dec_indent(4);
905 						return (DCMD_ERR);
906 					}
907 				} else
908 					mdb_printf(MSG_ORIG(MSG_FMT_RT), 0, 0,
909 					    0, MSG_ORIG(MSG_STR_EMPTY));
910 
911 				mdb_printf(MSG_ORIG(MSG_STR_DASHES));
912 			}
913 			(void) mdb_dec_indent(2);
914 		}
915 		(void) mdb_dec_indent(2);
916 	}
917 
918 	mdb_printf(MSG_ORIG(MSG_LMLIST_LINE1), lml.lm_head, lml.lm_tail);
919 	mdb_printf(MSG_ORIG(MSG_LMLIST_LINE2), lml.lm_alp, lml.lm_rti);
920 	mdb_printf(MSG_ORIG(MSG_LMLIST_LINE3), lml.lm_handle, lml.lm_obj,
921 	    lml.lm_init, lml.lm_lazy);
922 
923 	mdb_printf(MSG_ORIG(MSG_LMLIST_LINE4), lml.lm_flags);
924 	if (lml.lm_flags)
925 		mdb_printf(MSG_ORIG(MSG_LMLIST_LINE6), lml.lm_flags,
926 		    lml_flags_bit);
927 
928 	mdb_printf(MSG_ORIG(MSG_LMLIST_LINE5), lml.lm_tflags);
929 	if (lml.lm_tflags)
930 		mdb_printf(MSG_ORIG(MSG_LMLIST_LINE6), lml.lm_tflags,
931 		    lml_tflags_bit);
932 
933 	return (DCMD_OK);
934 }
935 
936 static int
937 /* ARGSUSED2 */
dcmd_Lm_list(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)938 dcmd_Lm_list(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
939 {
940 	GElf_Sym	gsym;
941 	APlist		*aplp, apl;
942 	uintptr_t	datap, nitems;
943 
944 	/*
945 	 * If an address was provided us it.
946 	 */
947 	if (flags & DCMD_ADDRSPEC)
948 		return (_dcmd_Lm_list(addr, flags, argc, argv));
949 
950 	/*
951 	 * Otherwise traverse the dynlm_list and display each link-map list.
952 	 */
953 	if (mdb_lookup_by_obj(MSG_ORIG(MSG_STR_LDSO1),
954 	    MSG_ORIG(MSG_STR_DYNLMLIST), &gsym) == -1) {
955 		mdb_warn(MSG_ORIG(MSG_ERR_SYMFAILED), MSG_ORIG(MSG_STR_LDSO1),
956 		    MSG_ORIG(MSG_STR_DYNLMLIST));
957 		return (DCMD_ERR);
958 	}
959 	if (mdb_vread(&aplp, sizeof (APlist *),
960 	    (uintptr_t)gsym.st_value) == -1) {
961 		mdb_warn(MSG_ORIG(MSG_ERR_READ), MSG_ORIG(MSG_STR_APLIST),
962 		    gsym.st_value);
963 		return (DCMD_ERR);
964 	}
965 	if (aplp == NULL) {
966 		mdb_printf(MSG_ORIG(MSG_LMLIST_TITLE0),
967 		    MSG_ORIG(MSG_STR_DYNLMLIST));
968 		return (DCMD_OK);
969 	}
970 
971 	if (mdb_vread(&apl, sizeof (APlist), (uintptr_t)aplp) == -1) {
972 		mdb_warn(MSG_ORIG(MSG_ERR_READ), MSG_ORIG(MSG_STR_APLIST),
973 		    aplp);
974 		return (DCMD_ERR);
975 	}
976 
977 	mdb_printf(MSG_ORIG(MSG_LMLIST_TITLE1), MSG_ORIG(MSG_STR_DYNLMLIST),
978 	    aplp, (size_t)apl.apl_nitems, (size_t)apl.apl_arritems);
979 	mdb_printf(MSG_ORIG(MSG_STR_DASHES));
980 
981 	flags |= (DCMD_LOOP | DCMD_LOOPFIRST);
982 	for (datap = (uintptr_t)aplp + APLIST_OFF_DATA, nitems = 0;
983 	    nitems < apl.apl_nitems; nitems++, datap += sizeof (void *)) {
984 		Lm_list	*lml;
985 
986 		if (mdb_vread(&lml, sizeof (Lm_list *), datap) == -1) {
987 			mdb_warn(MSG_ORIG(MSG_ERR_READ),
988 			    MSG_ORIG(MSG_LMLIST_STR), datap);
989 			return (DCMD_ERR);
990 		}
991 
992 		(void) mdb_inc_indent(2);
993 		if (_dcmd_Lm_list((uintptr_t)lml, flags, argc,
994 		    argv) == DCMD_ERR) {
995 			(void) mdb_dec_indent(2);
996 			return (DCMD_ERR);
997 		}
998 		(void) mdb_dec_indent(2);
999 		flags &= ~DCMD_LOOPFIRST;
1000 	}
1001 	return (DCMD_OK);
1002 }
1003 
1004 void
dcmd_GrpDesc_help(void)1005 dcmd_GrpDesc_help(void)
1006 {
1007 	mdb_printf(MSG_ORIG(MSG_GRPDESC_HELP));
1008 }
1009 
1010 static int
1011 /* ARGSUSED2 */
dcmd_GrpDesc(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1012 dcmd_GrpDesc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1013 {
1014 	Grp_desc	gd;
1015 	char		*str;
1016 
1017 	/*
1018 	 * Insure we have a valid address.
1019 	 */
1020 	if ((flags & DCMD_ADDRSPEC) == 0) {
1021 		mdb_warn(MSG_ORIG(MSG_ERR_NAS), MSG_ORIG(MSG_GRPDESC_STR));
1022 		return (DCMD_USAGE);
1023 	}
1024 
1025 	mdb_printf(MSG_ORIG(MSG_GRPDESC_LINE1), addr);
1026 	if (mdb_vread(&gd, sizeof (Grp_desc), addr) == -1) {
1027 		mdb_warn(MSG_ORIG(MSG_ERR_READ), MSG_ORIG(MSG_GRPDESC_STR),
1028 		    addr);
1029 		return (DCMD_ERR);
1030 	}
1031 
1032 	if ((str = Rtmap_Name((uintptr_t)gd.gd_depend)) == 0)
1033 		return (DCMD_ERR);
1034 
1035 	mdb_printf(MSG_ORIG(MSG_GRPDESC_LINE2), gd.gd_depend, str);
1036 	mdb_printf(MSG_ORIG(MSG_GRPDESC_LINE3), gd.gd_flags, gd.gd_flags,
1037 	    grdflags_bits);
1038 
1039 	return (DCMD_OK);
1040 }
1041 
1042 void
dcmd_GrpHdl_help(void)1043 dcmd_GrpHdl_help(void)
1044 {
1045 	mdb_printf(MSG_ORIG(MSG_GRPHDL_HELP));
1046 }
1047 
1048 static int
1049 /* ARGSUSED2 */
dcmd_GrpHdl(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1050 dcmd_GrpHdl(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1051 {
1052 	Grp_hdl		gh;
1053 	Alist		al;
1054 	uintptr_t	datap, listidx;
1055 	char		*str;
1056 	uint_t		flg = 0;
1057 
1058 	/*
1059 	 * Insure we have a valid address, and provide for a -v option.
1060 	 */
1061 	if ((flags & DCMD_ADDRSPEC) == 0) {
1062 		mdb_warn(MSG_ORIG(MSG_ERR_NAS), MSG_ORIG(MSG_GRPHDL_STR));
1063 		return (DCMD_USAGE);
1064 	}
1065 	if (mdb_getopts(argc, argv, 'v', MDB_OPT_SETBITS, RTLD_FLG_VERBOSE,
1066 	    &flg, NULL) != argc)
1067 		return (DCMD_USAGE);
1068 
1069 	mdb_printf(MSG_ORIG(MSG_GRPHDL_LINE1), addr);
1070 	mdb_printf(MSG_ORIG(MSG_STR_DASHES));
1071 
1072 	if (mdb_vread(&gh, sizeof (Grp_hdl), addr) == -1) {
1073 		mdb_warn(MSG_ORIG(MSG_ERR_READ), MSG_ORIG(MSG_GRPHDL_STR),
1074 		    addr);
1075 		return (DCMD_ERR);
1076 	}
1077 
1078 	/*
1079 	 * Determine the handles owner.  Note that an orphaned handle may no
1080 	 * longer contain its originating owner.
1081 	 */
1082 	if (gh.gh_ownlmp) {
1083 		if ((str = Rtmap_Name((uintptr_t)gh.gh_ownlmp)) == 0)
1084 			return (DCMD_ERR);
1085 	} else
1086 		str = (char *)MSG_ORIG(MSG_STR_ORPHANED);
1087 
1088 	mdb_printf(MSG_ORIG(MSG_GRPHDL_LINE2), str);
1089 	mdb_printf(MSG_ORIG(MSG_GRPHDL_LINE3), gh.gh_flags, gh.gh_flags,
1090 	    grhflags_bits);
1091 
1092 	if (gh.gh_depends == 0) {
1093 		mdb_printf(MSG_ORIG(MSG_GRPHDL_LINE4), gh.gh_refcnt);
1094 		return (DCMD_OK);
1095 	}
1096 
1097 	addr = (uintptr_t)gh.gh_depends;
1098 	if (mdb_vread(&al, sizeof (Alist), addr) == -1) {
1099 		mdb_warn(MSG_ORIG(MSG_ERR_READ), MSG_ORIG(MSG_STR_ALIST), addr);
1100 		return (DCMD_ERR);
1101 	}
1102 
1103 	mdb_printf(MSG_ORIG(MSG_GRPHDL_LINE5), gh.gh_refcnt, addr,
1104 	    (size_t)al.al_nitems, (size_t)al.al_arritems);
1105 
1106 	if (((flg & RTLD_FLG_VERBOSE) == 0) || (al.al_nitems == 0))
1107 		return (DCMD_OK);
1108 
1109 	(void) mdb_inc_indent(4);
1110 	mdb_printf(MSG_ORIG(MSG_STR_DASHES));
1111 
1112 	/*
1113 	 * Under verbose mode print the name of each dependency.  An Alist can
1114 	 * have a variable number of data items, so read each individual entry.
1115 	 */
1116 	datap = ALIST_OFF_DATA + (uintptr_t)addr;
1117 	if (dcmd_GrpDesc(datap, flags, argc, argv) == DCMD_ERR) {
1118 		(void) mdb_dec_indent(4);
1119 		return (DCMD_ERR);
1120 	}
1121 
1122 	for (listidx = 1; listidx < al.al_nitems; listidx++) {
1123 		datap += al.al_size;
1124 		mdb_printf(MSG_ORIG(MSG_STR_DASHES));
1125 		if (dcmd_GrpDesc(datap, flags, argc, argv) == DCMD_ERR) {
1126 			(void) mdb_dec_indent(4);
1127 			return (DCMD_ERR);
1128 		}
1129 	}
1130 
1131 	(void) mdb_dec_indent(4);
1132 	return (DCMD_OK);
1133 }
1134 
1135 static void
dcmd_Handles_help(void)1136 dcmd_Handles_help(void)
1137 {
1138 	mdb_printf(MSG_ORIG(MSG_HANDLES_HELP));
1139 }
1140 
1141 static int
dcmd_Handles(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1142 dcmd_Handles(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1143 {
1144 	Rt_map		rtmap;
1145 	char		*str;
1146 	uint_t		flg = 0;
1147 	APlist		apl;
1148 	uintptr_t	datap, nitems;
1149 	Grp_hdl		*ghp;
1150 
1151 	/*
1152 	 * Insure we have a valid address, and provide for a -v option.
1153 	 */
1154 	if ((flags & DCMD_ADDRSPEC) == 0) {
1155 		mdb_warn(MSG_ORIG(MSG_ERR_NAS), MSG_ORIG(MSG_HANDLES_STR));
1156 		return (DCMD_USAGE);
1157 	}
1158 	if (mdb_getopts(argc, argv, 'v', MDB_OPT_SETBITS, RTLD_FLG_VERBOSE,
1159 	    &flg, NULL) != argc)
1160 		return (DCMD_USAGE);
1161 
1162 	/*
1163 	 * Read the Rt_map contents.
1164 	 */
1165 	if (mdb_vread(&rtmap, sizeof (Rt_map), addr) == -1) {
1166 		mdb_warn(MSG_ORIG(MSG_ERR_READ), MSG_ORIG(MSG_RTMAP_STR), addr);
1167 		return (DCMD_ERR);
1168 	}
1169 	if ((str = String((uintptr_t)NAME(&rtmap),
1170 	    MSG_ORIG(MSG_STR_NAME))) == 0)
1171 		return (DCMD_ERR);
1172 
1173 	mdb_printf(MSG_ORIG(MSG_HANDLES_LINE1), str);
1174 	mdb_printf(MSG_ORIG(MSG_STR_DASHES));
1175 
1176 	if (HANDLES(&rtmap) == 0)
1177 		return (DCMD_OK);
1178 
1179 	addr = (uintptr_t)HANDLES(&rtmap);
1180 	if (mdb_vread(&apl, sizeof (APlist), addr) == -1) {
1181 		mdb_warn(MSG_ORIG(MSG_ERR_READ), MSG_ORIG(MSG_STR_APLIST),
1182 		    addr);
1183 		return (DCMD_ERR);
1184 	}
1185 
1186 	mdb_printf(MSG_ORIG(MSG_HANDLES_LINE2), addr, (size_t)apl.apl_nitems,
1187 	    (size_t)apl.apl_arritems);
1188 
1189 	if (((flg & RTLD_FLG_VERBOSE) == 0) || (apl.apl_nitems == 0))
1190 		return (DCMD_OK);
1191 
1192 	/*
1193 	 * Under verbose mode print the name of each dependency.  An APlist can
1194 	 * have a variable number of data items, so read each individual entry.
1195 	 */
1196 	datap = addr + APLIST_OFF_DATA;
1197 	if (mdb_vread(&ghp, sizeof (Grp_hdl *), datap) == -1) {
1198 		mdb_warn(MSG_ORIG(MSG_ERR_READ),
1199 		    MSG_ORIG(MSG_GRPHDL_STR), datap);
1200 		return (DCMD_ERR);
1201 	}
1202 
1203 	(void) mdb_inc_indent(4);
1204 	mdb_printf(MSG_ORIG(MSG_STR_DASHES));
1205 
1206 	if (dcmd_GrpHdl((uintptr_t)ghp, flags, argc, argv) == DCMD_ERR) {
1207 		(void) mdb_dec_indent(4);
1208 		return (DCMD_ERR);
1209 	}
1210 
1211 	nitems = 1;
1212 	for (nitems = 1; nitems < apl.apl_nitems; nitems++) {
1213 		datap += sizeof (void *);
1214 		if (mdb_vread(&ghp, sizeof (Grp_hdl *), datap) == -1) {
1215 			mdb_warn(MSG_ORIG(MSG_ERR_READ),
1216 			    MSG_ORIG(MSG_GRPHDL_STR), datap);
1217 			return (DCMD_ERR);
1218 		}
1219 
1220 		mdb_printf(MSG_ORIG(MSG_STR_DASHES));
1221 		if (dcmd_GrpHdl((uintptr_t)ghp, flags, argc,
1222 		    argv) == DCMD_ERR) {
1223 			(void) mdb_dec_indent(4);
1224 			return (DCMD_ERR);
1225 		}
1226 	}
1227 	(void) mdb_dec_indent(4);
1228 	return (DCMD_OK);
1229 }
1230 
1231 static void
dcmd_Groups_help(void)1232 dcmd_Groups_help(void)
1233 {
1234 	mdb_printf(MSG_ORIG(MSG_GROUPS_HELP));
1235 }
1236 
1237 
1238 static int
dcmd_Groups(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1239 dcmd_Groups(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1240 {
1241 	Rt_map		rtmap;
1242 	char		*str;
1243 	APlist		apl;
1244 	uint_t		flg = 0;
1245 	uintptr_t	datap, nitems;
1246 	Grp_hdl		*ghp;
1247 
1248 	/*
1249 	 * Insure we have a valid address, and provide for a -v option.
1250 	 */
1251 	if ((flags & DCMD_ADDRSPEC) == 0) {
1252 		mdb_warn(MSG_ORIG(MSG_ERR_NAS), MSG_ORIG(MSG_GROUPS_STR));
1253 		return (DCMD_USAGE);
1254 	}
1255 	if (mdb_getopts(argc, argv, 'v', MDB_OPT_SETBITS, RTLD_FLG_VERBOSE,
1256 	    &flg, NULL) != argc)
1257 		return (DCMD_USAGE);
1258 
1259 	/*
1260 	 * Read the Rt_map contents.
1261 	 */
1262 	if (mdb_vread(&rtmap, sizeof (Rt_map), addr) == -1) {
1263 		mdb_warn(MSG_ORIG(MSG_ERR_READ), MSG_ORIG(MSG_RTMAP_STR), addr);
1264 		return (DCMD_ERR);
1265 	}
1266 	if ((str = String((uintptr_t)NAME(&rtmap),
1267 	    MSG_ORIG(MSG_STR_NAME))) == 0)
1268 		return (DCMD_ERR);
1269 
1270 	mdb_printf(MSG_ORIG(MSG_GROUPS_LINE1), str);
1271 	mdb_printf(MSG_ORIG(MSG_STR_DASHES));
1272 
1273 	if (GROUPS(&rtmap) == 0)
1274 		return (DCMD_OK);
1275 
1276 	addr = (uintptr_t)GROUPS(&rtmap);
1277 	if (mdb_vread(&apl, sizeof (APlist), addr) == -1) {
1278 		mdb_warn(MSG_ORIG(MSG_ERR_READ), MSG_ORIG(MSG_STR_APLIST),
1279 		    addr);
1280 		return (DCMD_ERR);
1281 	}
1282 
1283 	mdb_printf(MSG_ORIG(MSG_GROUPS_LINE2), addr, (size_t)apl.apl_nitems,
1284 	    (size_t)apl.apl_arritems);
1285 
1286 	if (((flg & RTLD_FLG_VERBOSE) == 0) || (apl.apl_nitems == 0))
1287 		return (DCMD_OK);
1288 
1289 	/*
1290 	 * Under verbose mode print the name of each dependency.  An APlist can
1291 	 * have a variable number of data items, so read each individual entry.
1292 	 */
1293 	datap = addr + APLIST_OFF_DATA;
1294 	if (mdb_vread(&ghp, sizeof (Grp_hdl *), datap) == -1) {
1295 		mdb_warn(MSG_ORIG(MSG_ERR_READ),
1296 		    MSG_ORIG(MSG_GRPHDL_STR), datap);
1297 		return (DCMD_ERR);
1298 	}
1299 
1300 	(void) mdb_inc_indent(4);
1301 	mdb_printf(MSG_ORIG(MSG_STR_DASHES));
1302 
1303 	if (dcmd_GrpHdl((uintptr_t)ghp, flags, argc, argv) == DCMD_ERR) {
1304 		(void) mdb_dec_indent(4);
1305 		return (DCMD_ERR);
1306 	}
1307 
1308 	for (nitems = 1; nitems < apl.apl_nitems; nitems++) {
1309 		datap += sizeof (void *);
1310 		if (mdb_vread(&ghp, sizeof (Grp_hdl *), datap) == -1) {
1311 			mdb_warn(MSG_ORIG(MSG_ERR_READ),
1312 			    MSG_ORIG(MSG_GRPHDL_STR), datap);
1313 			return (DCMD_ERR);
1314 		}
1315 
1316 		mdb_printf(MSG_ORIG(MSG_STR_DASHES));
1317 		if (dcmd_GrpHdl((uintptr_t)ghp, flags, argc,
1318 		    argv) == DCMD_ERR) {
1319 			(void) mdb_dec_indent(4);
1320 			return (DCMD_ERR);
1321 		}
1322 	}
1323 	(void) mdb_dec_indent(4);
1324 	return (DCMD_OK);
1325 }
1326 static void
dcmd_ElfDyn_help(void)1327 dcmd_ElfDyn_help(void)
1328 {
1329 	mdb_printf(MSG_ORIG(MSG_ELFDYN_HELP));
1330 }
1331 
1332 static int
1333 /* ARGSUSED2 */
dcmd_ElfDyn(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1334 dcmd_ElfDyn(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1335 {
1336 	Dyn		dyn;
1337 	const char	*dynstr;
1338 	Conv_inv_buf_t	inv_buf;
1339 
1340 	if ((flags & DCMD_ADDRSPEC) == 0)
1341 		return (DCMD_USAGE);
1342 	if (mdb_vread(&dyn, sizeof (dyn), addr) == -1) {
1343 		mdb_warn(MSG_ORIG(MSG_ERR_READ), MSG_ORIG(MSG_ELFDYN_STR),
1344 		    addr);
1345 		return (DCMD_ERR);
1346 	}
1347 
1348 	mdb_printf(MSG_ORIG(MSG_ELFDYN_TITLE), addr);
1349 	dynstr = conv_dyn_tag(dyn.d_tag, ELFOSABI_SOLARIS, M_MACH, 0, &inv_buf);
1350 	mdb_printf(MSG_ORIG(MSG_ELFDYN_LINE1), addr, dynstr, dyn.d_un.d_ptr);
1351 
1352 	mdb_set_dot(addr + sizeof (Dyn));
1353 
1354 	return (DCMD_OK);
1355 }
1356 
1357 static void
dcmd_ElfEhdr_help(void)1358 dcmd_ElfEhdr_help(void)
1359 {
1360 	mdb_printf(MSG_ORIG(MSG_EHDR_HELP));
1361 }
1362 
1363 static int
1364 /* ARGSUSED2 */
dcmd_ElfEhdr(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1365 dcmd_ElfEhdr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1366 {
1367 	Ehdr			ehdr;
1368 	Byte			*byte;
1369 	const char		*flgs;
1370 	Conv_inv_buf_t		inv_buf1, inv_buf2;
1371 	Conv_ehdr_flags_buf_t	ehdr_flags_buf;
1372 
1373 
1374 	if ((flags & DCMD_ADDRSPEC) == 0)
1375 		return (DCMD_USAGE);
1376 
1377 	if (mdb_vread(&ehdr, sizeof (ehdr), addr) == -1) {
1378 		mdb_warn(MSG_ORIG(MSG_ERR_READ), MSG_ORIG(MSG_EHDR_STR),
1379 		    addr);
1380 		return (DCMD_ERR);
1381 	}
1382 
1383 	mdb_printf(MSG_ORIG(MSG_EHDR_TITLE), addr);
1384 	byte = &ehdr.e_ident[0];
1385 	mdb_printf(MSG_ORIG(MSG_EHDR_LINE1), byte[EI_MAG0],
1386 	    (byte[EI_MAG1] ? byte[EI_MAG1] : '0'),
1387 	    (byte[EI_MAG2] ? byte[EI_MAG2] : '0'),
1388 	    (byte[EI_MAG3] ? byte[EI_MAG3] : '0'));
1389 	mdb_printf(MSG_ORIG(MSG_EHDR_LINE2),
1390 	    conv_ehdr_class(ehdr.e_ident[EI_CLASS], 0, &inv_buf1),
1391 	    conv_ehdr_data(ehdr.e_ident[EI_DATA], 0, &inv_buf2));
1392 
1393 	mdb_printf(MSG_ORIG(MSG_EHDR_LINE3),
1394 	    conv_ehdr_mach(ehdr.e_machine, 0, &inv_buf1),
1395 	    conv_ehdr_vers(ehdr.e_version, 0, &inv_buf2));
1396 	mdb_printf(MSG_ORIG(MSG_EHDR_LINE4),
1397 	    conv_ehdr_type(ehdr.e_ident[EI_OSABI], ehdr.e_type, 0, &inv_buf1));
1398 
1399 	/*
1400 	 * Line up the flags differently depending on whether we
1401 	 * received a numeric (e.g. "0x200") or text representation
1402 	 * (e.g. "[ EF_SPARC_SUN_US1 ]").
1403 	 */
1404 	flgs = conv_ehdr_flags(ehdr.e_machine, ehdr.e_flags,
1405 	    0, &ehdr_flags_buf);
1406 	if (flgs[0] == '[')
1407 		mdb_printf(MSG_ORIG(MSG_EHDR_LINE5), flgs);
1408 	else
1409 		mdb_printf(MSG_ORIG(MSG_EHDR_LINE6), flgs);
1410 
1411 	mdb_printf(MSG_ORIG(MSG_EHDR_LINE7), ehdr.e_entry, ehdr.e_ehsize,
1412 	    ehdr.e_shstrndx);
1413 	mdb_printf(MSG_ORIG(MSG_EHDR_LINE8), ehdr.e_shoff, ehdr.e_shentsize,
1414 	    ehdr.e_shnum);
1415 	mdb_printf(MSG_ORIG(MSG_EHDR_LINE9), ehdr.e_phoff, ehdr.e_phentsize,
1416 	    ehdr.e_phnum);
1417 
1418 	mdb_set_dot(addr + sizeof (Ehdr));
1419 
1420 	return (DCMD_OK);
1421 }
1422 
1423 static void
dcmd_ElfPhdr_help(void)1424 dcmd_ElfPhdr_help(void)
1425 {
1426 	mdb_printf(MSG_ORIG(MSG_EPHDR_HELP));
1427 }
1428 
1429 static int
1430 /* ARGSUSED2 */
dcmd_ElfPhdr(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1431 dcmd_ElfPhdr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1432 {
1433 	Phdr			phdr;
1434 	Conv_inv_buf_t		inv_buf;
1435 	Conv_phdr_flags_buf_t	phdr_flags_buf;
1436 
1437 	if ((flags & DCMD_ADDRSPEC) == 0)
1438 		return (DCMD_USAGE);
1439 
1440 	if (mdb_vread(&phdr, sizeof (phdr), addr) == -1) {
1441 		mdb_warn(MSG_ORIG(MSG_ERR_READ), MSG_ORIG(MSG_EPHDR_STR),
1442 		    addr);
1443 		return (DCMD_ERR);
1444 	}
1445 
1446 	mdb_printf(MSG_ORIG(MSG_EPHDR_TITLE), addr);
1447 	mdb_printf(MSG_ORIG(MSG_EPHDR_LINE1), phdr.p_vaddr,
1448 	    conv_phdr_flags(ELFOSABI_SOLARIS, phdr.p_flags, 0,
1449 	    &phdr_flags_buf));
1450 	mdb_printf(MSG_ORIG(MSG_EPHDR_LINE2), phdr.p_paddr,
1451 	    conv_phdr_type(ELFOSABI_SOLARIS, M_MACH, phdr.p_type, 0, &inv_buf));
1452 	mdb_printf(MSG_ORIG(MSG_EPHDR_LINE3), phdr.p_filesz, phdr.p_memsz);
1453 	mdb_printf(MSG_ORIG(MSG_EPHDR_LINE4), phdr.p_offset, phdr.p_align);
1454 
1455 	mdb_set_dot(addr + sizeof (Phdr));
1456 
1457 	return (DCMD_OK);
1458 }
1459 
1460 
1461 static const mdb_dcmd_t dcmds[] = {
1462 	{ MSG_ORIG(MSG_BND_STR), MSG_ORIG(MSG_USG_ADDREQ_V),
1463 		MSG_ORIG(MSG_BND_DCD),
1464 		dcmd_Bind, dcmd_Bind_help},
1465 	{ MSG_ORIG(MSG_DEPENDS_STR), MSG_ORIG(MSG_USG_ADDREQ_V),
1466 		MSG_ORIG(MSG_DEPENDS_DCD),
1467 		dcmd_Depends, dcmd_Depends_help},
1468 	{ MSG_ORIG(MSG_CALLERS_STR), MSG_ORIG(MSG_USG_ADDREQ_V),
1469 		MSG_ORIG(MSG_CALLERS_DCD),
1470 		dcmd_Callers, dcmd_Callers_help},
1471 	{ MSG_ORIG(MSG_GRPHDL_STR), MSG_ORIG(MSG_USG_ADDREQ_V),
1472 		MSG_ORIG(MSG_GRPHDL_DCD),
1473 		dcmd_GrpHdl, dcmd_GrpHdl_help},
1474 	{ MSG_ORIG(MSG_GRPDESC_STR), MSG_ORIG(MSG_USG_ADDREQ_V),
1475 		MSG_ORIG(MSG_GRPDESC_DCD),
1476 		dcmd_GrpDesc, dcmd_GrpDesc_help},
1477 	{ MSG_ORIG(MSG_HANDLES_STR), MSG_ORIG(MSG_USG_ADDREQ_V),
1478 		MSG_ORIG(MSG_HANDLES_DCD),
1479 		dcmd_Handles, dcmd_Handles_help},
1480 	{ MSG_ORIG(MSG_GROUPS_STR), MSG_ORIG(MSG_USG_ADDREQ_V),
1481 		MSG_ORIG(MSG_GROUPS_DCD),
1482 		dcmd_Groups, dcmd_Groups_help},
1483 	{ MSG_ORIG(MSG_ELFDYN_STR), MSG_ORIG(MSG_USG_ADDREQ),
1484 		MSG_ORIG(MSG_ELFDYN_DCD),
1485 		dcmd_ElfDyn, dcmd_ElfDyn_help},
1486 	{ MSG_ORIG(MSG_EHDR_STR), MSG_ORIG(MSG_USG_ADDREQ),
1487 		MSG_ORIG(MSG_EHDR_DCD),
1488 		dcmd_ElfEhdr, dcmd_ElfEhdr_help},
1489 	{ MSG_ORIG(MSG_EPHDR_STR), MSG_ORIG(MSG_USG_ADDREQ),
1490 		MSG_ORIG(MSG_EPHDR_DCD),
1491 		dcmd_ElfPhdr, dcmd_ElfPhdr_help},
1492 	{ MSG_ORIG(MSG_LMLIST_STR), MSG_ORIG(MSG_USG_ADDREQ_V),
1493 		MSG_ORIG(MSG_LMLIST_DCD),
1494 		dcmd_Lm_list, dcmd_Lm_list_help},
1495 	{ MSG_ORIG(MSG_RTMAPS_STR), MSG_ORIG(MSG_USG_ADDOPT_V),
1496 		MSG_ORIG(MSG_RTMAPS_DCD),
1497 		dcmd_Rtmaps, dcmd_Rtmaps_help},
1498 	{ MSG_ORIG(MSG_RTMAP_STR), MSG_ORIG(MSG_USG_ADDREQ),
1499 		MSG_ORIG(MSG_RTMAP_DCD),
1500 		dcmd_rtmap, dcmd_rtmap_help},
1501 	{ MSG_ORIG(MSG_SETENV_STR), MSG_ORIG(MSG_USG_SETENV),
1502 		MSG_ORIG(MSG_SETENV_DCD),
1503 		dcmd_Setenv, dcmd_Setenv_help},
1504 	{ NULL }
1505 };
1506 
1507 static const mdb_walker_t walkers[] = {
1508 	{ MSG_ORIG(MSG_RTMAPS_STR), MSG_ORIG(MSG_WWD_RTMAP),
1509 		walk_rtmap_init, walk_rtmap_step, NULL, NULL },
1510 	{ NULL }
1511 };
1512 
1513 static const mdb_modinfo_t modinfo = {
1514 	MDB_API_VERSION, dcmds, walkers
1515 };
1516 
1517 const	mdb_modinfo_t *
_mdb_init(void)1518 _mdb_init(void)
1519 {
1520 	return (&modinfo);
1521 }
1522