?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dmake: do not set MAKEFLAGS=k
[unleashed/tickless.git] / usr / src / cmd / sgs / rtld / mdbmod / common / rtld.c
blob3d37745c75ebc6765b1450798aca27cbdc432c3a
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 *
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 *
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
216 dcmd_Bind_help(void)
217 {
218 mdb_printf(MSG_ORIG(MSG_BND_HELP));
219 }
220
221 static int
222 /* ARGSUSED2 */
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
269 dcmd_Depends_help(void)
270 {
271 mdb_printf(MSG_ORIG(MSG_DEPENDS_HELP));
272 }
273
274 static int
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
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
375 dcmd_Callers_help(void)
376 {
377 mdb_printf(MSG_ORIG(MSG_CALLERS_HELP));
378 }
379
380 static int
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
420 dcmd_rtmap_help(void)
421 {
422 mdb_printf(MSG_ORIG(MSG_RTMAP_HELP));
423 }
424
425 static int
426 /* ARGSUSED2 */
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
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, 0, 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
518 dcmd_Rtmaps_help(void)
519 {
520 mdb_printf(MSG_ORIG(MSG_RTMAPS_HELP));
521 }
522
523 static int
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
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 */
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
680 walk_rtmap_init(mdb_walk_state_t *wsp)
681 {
682 if (wsp->walk_addr == (uintptr_t)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
690 walk_rtmap_step(mdb_walk_state_t *wsp)
691 {
692 int status;
693 Rt_map lmp;
694
695 if (wsp->walk_addr == (uintptr_t)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
779 dcmd_Lm_list_help(void)
780 {
781 mdb_printf(MSG_ORIG(MSG_LMLIST_HELP));
782 }
783
784 static int
785 /* ARGSUSED1 */
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, NULL,
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, NULL,
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 */
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
1005 dcmd_GrpDesc_help(void)
1006 {
1007 mdb_printf(MSG_ORIG(MSG_GRPDESC_HELP));
1008 }
1009
1010 static int
1011 /* ARGSUSED2 */
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
1043 dcmd_GrpHdl_help(void)
1044 {
1045 mdb_printf(MSG_ORIG(MSG_GRPHDL_HELP));
1046 }
1047
1048 static int
1049 /* ARGSUSED2 */
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
1136 dcmd_Handles_help(void)
1137 {
1138 mdb_printf(MSG_ORIG(MSG_HANDLES_HELP));
1139 }
1140
1141 static int
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
1232 dcmd_Groups_help(void)
1233 {
1234 mdb_printf(MSG_ORIG(MSG_GROUPS_HELP));
1235 }
1236
1237
1238 static int
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
1327 dcmd_ElfDyn_help(void)
1328 {
1329 mdb_printf(MSG_ORIG(MSG_ELFDYN_HELP));
1330 }
1331
1332 static int
1333 /* ARGSUSED2 */
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
1358 dcmd_ElfEhdr_help(void)
1359 {
1360 mdb_printf(MSG_ORIG(MSG_EHDR_HELP));
1361 }
1362
1363 static int
1364 /* ARGSUSED2 */
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
1424 dcmd_ElfPhdr_help(void)
1425 {
1426 mdb_printf(MSG_ORIG(MSG_EPHDR_HELP));
1427 }
1428
1429 static int
1430 /* ARGSUSED2 */
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 *
1518 _mdb_init(void)
1519 {
1520 return (&modinfo);
1521 }
unleashed repo fork