xref: /titanic_51/usr/src/cmd/sgs/liblddbg/common/files.c (revision 40e7ce05bde825a43b0db32ded62db8cc5b6ec9c)
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 2009 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #include	<sys/auxv.h>
28 #include	<string.h>
29 #include	<unistd.h>
30 #include	<fcntl.h>
31 #include	<limits.h>
32 #include	<stdio.h>
33 #include	<libld.h>
34 #include	<rtld.h>
35 #include	<conv.h>
36 #include	"msg.h"
37 #include	"_debug.h"
38 
39 void
40 Dbg_file_analyze(Rt_map *lmp)
41 {
42 	Conv_dl_mode_buf_t	dl_mode_buf;
43 	Lm_list			*lml = LIST(lmp);
44 
45 	if (DBG_NOTCLASS(DBG_C_FILES))
46 		return;
47 
48 	Dbg_util_nl(lml, DBG_NL_STD);
49 	dbg_print(lml, MSG_INTL(MSG_FIL_ANALYZE), NAME(lmp),
50 	    conv_dl_mode(MODE(lmp), 1, &dl_mode_buf));
51 }
52 
53 void
54 Dbg_file_mmapobj(Lm_list *lml, const char *name, mmapobj_result_t *ompp,
55     uint_t onum)
56 {
57 	mmapobj_result_t	*mpp;
58 	uint_t			mnum;
59 
60 	if (DBG_NOTCLASS(DBG_C_FILES))
61 		return;
62 	if (DBG_NOTDETAIL())
63 		return;
64 
65 	Dbg_util_nl(lml, DBG_NL_STD);
66 	dbg_print(lml, MSG_INTL(MSG_FIL_MMAPOBJ), name, onum);
67 
68 	for (mnum = 0, mpp = ompp; mnum < onum; mnum++, mpp++) {
69 		const char	*str;
70 		uint_t		type = MR_GET_TYPE(mpp->mr_flags);
71 
72 		if (type == MR_PADDING)
73 			str = MSG_ORIG(MSG_MR_PADDING);
74 		else if (type == MR_HDR_ELF)
75 			str = MSG_ORIG(MSG_MR_HDR_ELF);
76 		else if (type == MR_HDR_AOUT)
77 			str = MSG_ORIG(MSG_MR_HDR_AOUT);
78 		else
79 			str = MSG_ORIG(MSG_STR_EMPTY);
80 
81 		dbg_print(lml, MSG_INTL(MSG_FIL_MMAPOBJ_1), mnum,
82 		    EC_NATPTR(mpp->mr_addr), EC_OFF(mpp->mr_fsize), str);
83 		dbg_print(lml, MSG_INTL(MSG_FIL_MMAPOBJ_2),
84 		    EC_OFF(mpp->mr_offset), EC_OFF(mpp->mr_msize));
85 	}
86 	Dbg_util_nl(lml, DBG_NL_STD);
87 }
88 
89 void
90 Dbg_file_aout(Lm_list *lml, const char *name, Addr addr, size_t size,
91     const char *lmid, Aliste lmco)
92 {
93 	if (DBG_NOTCLASS(DBG_C_FILES))
94 		return;
95 
96 	dbg_print(lml, MSG_INTL(MSG_FIL_AOUT), name);
97 	dbg_print(lml, MSG_INTL(MSG_FIL_DATA_AS), EC_ADDR(addr), EC_OFF(size));
98 	dbg_print(lml, MSG_INTL(MSG_FIL_DATA_LL), lmid, EC_XWORD(lmco));
99 }
100 
101 void
102 Dbg_file_elf(Lm_list *lml, const char *name, Addr addr, size_t size,
103     const char *lmid, Aliste lmco)
104 {
105 	const char	*str;
106 
107 	if (DBG_NOTCLASS(DBG_C_FILES))
108 		return;
109 
110 	if (addr == 0)
111 		str = MSG_INTL(MSG_STR_TEMPORARY);
112 	else
113 		str = MSG_ORIG(MSG_STR_EMPTY);
114 
115 	dbg_print(lml, MSG_INTL(MSG_FIL_ELF), name, str);
116 	dbg_print(lml, MSG_INTL(MSG_FIL_DATA_AS), EC_ADDR(addr), EC_OFF(size));
117 	dbg_print(lml, MSG_INTL(MSG_FIL_DATA_LL), lmid, EC_XWORD(lmco));
118 }
119 
120 void
121 Dbg_file_ldso(Rt_map *lmp, char **envp, auxv_t *auxv, const char *lmid,
122     Aliste lmco)
123 {
124 	Lm_list	*lml = LIST(lmp);
125 
126 	if (DBG_NOTCLASS(DBG_C_FILES))
127 		return;
128 
129 	Dbg_util_nl(lml, DBG_NL_STD);
130 	dbg_print(lml, MSG_INTL(MSG_FIL_LDSO), PATHNAME(lmp));
131 	dbg_print(lml, MSG_INTL(MSG_FIL_DATA_AS), EC_ADDR(ADDR(lmp)),
132 	    EC_OFF(MSIZE(lmp)));
133 	dbg_print(lml, MSG_INTL(MSG_FIL_DATA_EA), EC_NATPTR(envp),
134 	    EC_NATPTR(auxv));
135 	dbg_print(lml, MSG_INTL(MSG_FIL_DATA_LL), lmid, EC_XWORD(lmco));
136 	Dbg_util_nl(lml, DBG_NL_STD);
137 }
138 
139 
140 void
141 Dbg_file_prot(Rt_map *lmp, int prot)
142 {
143 	Lm_list	*lml = LIST(lmp);
144 
145 	if (DBG_NOTCLASS(DBG_C_FILES))
146 		return;
147 
148 	Dbg_util_nl(lml, DBG_NL_STD);
149 	dbg_print(lml, MSG_INTL(MSG_FIL_PROT), NAME(lmp), (prot ? '+' : '-'));
150 }
151 
152 void
153 Dbg_file_delete(Rt_map *lmp)
154 {
155 	Lm_list	*lml = LIST(lmp);
156 
157 	if (DBG_NOTCLASS(DBG_C_FILES))
158 		return;
159 
160 	Dbg_util_nl(lml, DBG_NL_STD);
161 	dbg_print(lml, MSG_INTL(MSG_FIL_DELETE), NAME(lmp));
162 }
163 
164 static int	hdl_title = 0;
165 static Msg	hdl_str = 0;
166 
167 void
168 Dbg_file_hdl_title(int type)
169 {
170 	static const Msg titles[] = {
171 		MSG_FIL_HDL_CREATE,	/* MSG_INTL(MSG_FIL_HDL_CREATE) */
172 		MSG_FIL_HDL_ADD,	/* MSG_INTL(MSG_FIL_HDL_ADD) */
173 		MSG_FIL_HDL_DELETE,	/* MSG_INTL(MSG_FIL_HDL_DELETE) */
174 		MSG_FIL_HDL_ORPHAN,	/* MSG_INTL(MSG_FIL_HDL_ORPHAN) */
175 		MSG_FIL_HDL_REINST,	/* MSG_INTL(MSG_FIL_HDL_REINST) */
176 	};
177 
178 	if (DBG_NOTCLASS(DBG_C_FILES))
179 		return;
180 	if (DBG_NOTDETAIL())
181 		return;
182 
183 	/*
184 	 * Establish a binding title for later use in Dbg_file_hdl_action.
185 	 */
186 	if (type <= DBG_HDL_REINST) {
187 		hdl_str = titles[type];
188 		hdl_title = 1;
189 	} else {
190 		hdl_str = 0;
191 		hdl_title = 0;
192 	}
193 }
194 
195 void
196 Dbg_file_hdl_collect(Grp_hdl *ghp, const char *name)
197 {
198 	Conv_grphdl_flags_buf_t	grphdl_flags_buf;
199 	Lm_list		*lml = ghp->gh_ownlml;
200 	const char	*str;
201 
202 	if (DBG_NOTCLASS(DBG_C_FILES))
203 		return;
204 	if (DBG_NOTDETAIL())
205 		return;
206 
207 	if (ghp->gh_ownlmp)
208 		str = NAME(ghp->gh_ownlmp);
209 	else
210 		str = MSG_INTL(MSG_STR_ORPHAN);
211 
212 	if (hdl_title) {
213 		hdl_title = 0;
214 		Dbg_util_nl(lml, DBG_NL_STD);
215 	}
216 	if (name)
217 		dbg_print(lml, MSG_INTL(MSG_FIL_HDL_RETAIN), str, name);
218 	else
219 		dbg_print(lml, MSG_INTL(MSG_FIL_HDL_COLLECT), str,
220 		    conv_grphdl_flags(ghp->gh_flags, &grphdl_flags_buf));
221 }
222 
223 void
224 Dbg_file_hdl_action(Grp_hdl *ghp, Rt_map *lmp, int type, uint_t flags)
225 {
226 	Conv_grpdesc_flags_buf_t grpdesc_flags_buf;
227 	const char	*mode, *group;
228 	Lm_list		*lml = LIST(lmp);
229 	Msg		str;
230 
231 	static const Msg fmt[] = {
232 		MSG_FIL_DEP_ADD,	/* MSG_INTL(MSG_FIL_DEP_ADD) */
233 		MSG_FIL_DEP_UPDATE,	/* MSG_INTL(MSG_FIL_DEP_UPDATE) */
234 		MSG_FIL_DEP_DELETE,	/* MSG_INTL(MSG_FIL_DEP_DELETE) */
235 		MSG_FIL_DEP_REMOVE,	/* MSG_INTL(MSG_FIL_DEP_REMOVE) */
236 		MSG_FIL_DEP_REMAIN,	/* MSG_INTL(MSG_FIL_DEP_REMAIN) */
237 		MSG_FIL_DEP_ORPHAN,	/* MSG_INTL(MSG_FIL_DEP_ORPHAN) */
238 		MSG_FIL_DEP_REINST,	/* MSG_INTL(MSG_FIL_DEP_REINST) */
239 	};
240 	if (DBG_NOTCLASS(DBG_C_FILES))
241 		return;
242 	if (DBG_NOTDETAIL())
243 		return;
244 
245 	if (hdl_title) {
246 		Dbg_util_nl(lml, DBG_NL_STD);
247 		if (hdl_str) {
248 			const char	*name;
249 
250 			/*
251 			 * Protect ourselves in case this handle has no
252 			 * originating owner.
253 			 */
254 			if (ghp->gh_ownlmp)
255 				name = NAME(ghp->gh_ownlmp);
256 			else
257 				name = MSG_INTL(MSG_STR_UNKNOWN);
258 
259 			dbg_print(lml, MSG_INTL(hdl_str), name, EC_NATPTR(ghp));
260 		}
261 		hdl_title = 0;
262 	}
263 
264 	/*
265 	 * Establish a binding descriptor format string.
266 	 */
267 	if (type > DBG_DEP_REINST)
268 		return;
269 
270 	str = fmt[type];
271 
272 	if (((type == DBG_DEP_ADD) || (type == DBG_DEP_UPDATE)) && flags)
273 		group = conv_grpdesc_flags(flags, &grpdesc_flags_buf);
274 	else
275 		group = MSG_ORIG(MSG_STR_EMPTY);
276 
277 	if ((MODE(lmp) & (RTLD_GLOBAL | RTLD_NODELETE)) ==
278 	    (RTLD_GLOBAL | RTLD_NODELETE))
279 		mode = MSG_ORIG(MSG_MODE_GLOBNODEL);
280 	else if (MODE(lmp) & RTLD_GLOBAL)
281 		mode = MSG_ORIG(MSG_MODE_GLOB);
282 	else if (MODE(lmp) & RTLD_NODELETE)
283 		mode = MSG_ORIG(MSG_MODE_NODEL);
284 	else
285 		mode = MSG_ORIG(MSG_STR_EMPTY);
286 
287 	dbg_print(lml, MSG_INTL(str), NAME(lmp), mode, group);
288 }
289 
290 void
291 Dbg_file_bind_entry(Lm_list *lml, Bnd_desc *bdp)
292 {
293 	Conv_bnd_type_buf_t bnd_type_buf;
294 
295 	if (DBG_NOTCLASS(DBG_C_FILES))
296 		return;
297 	if (DBG_NOTDETAIL())
298 		return;
299 
300 	/*
301 	 * Print the dependency together with the modes of the binding.
302 	 */
303 	Dbg_util_nl(lml, DBG_NL_STD);
304 	dbg_print(lml, MSG_INTL(MSG_FIL_BND_ADD), NAME(bdp->b_caller));
305 	dbg_print(lml, MSG_INTL(MSG_FIL_BND_FILE), NAME(bdp->b_depend),
306 	    conv_bnd_type(bdp->b_flags, &bnd_type_buf));
307 }
308 
309 void
310 Dbg_file_bindings(Rt_map *lmp, int flag)
311 {
312 	Conv_bnd_obj_buf_t	bnd_obj_buf;
313 	Conv_bnd_type_buf_t	bnd_type_buf;
314 	const char	*str;
315 	Rt_map		*tlmp;
316 	Lm_list		*lml = LIST(lmp);
317 	int		next = 0;
318 
319 	if (DBG_NOTCLASS(DBG_C_INIT))
320 		return;
321 	if (DBG_NOTDETAIL())
322 		return;
323 
324 	if (flag & RT_SORT_REV)
325 		str = MSG_ORIG(MSG_SCN_INIT);
326 	else
327 		str = MSG_ORIG(MSG_SCN_FINI);
328 
329 	Dbg_util_nl(lml, DBG_NL_STD);
330 	dbg_print(lml, MSG_INTL(MSG_FIL_DEP_TITLE), str,
331 	    conv_bnd_obj(lml->lm_flags, &bnd_obj_buf));
332 
333 	/* LINTED */
334 	for (tlmp = lmp; tlmp; tlmp = (Rt_map *)NEXT(tlmp)) {
335 		Bnd_desc	*bdp;
336 		Aliste		idx;
337 
338 		/*
339 		 * For .init processing, only collect objects that have been
340 		 * relocated and haven't already been collected.
341 		 * For .fini processing, only collect objects that have had
342 		 * their .init collected, and haven't already been .fini
343 		 * collected.
344 		 */
345 		if (flag & RT_SORT_REV) {
346 			if ((FLAGS(tlmp) & (FLG_RT_RELOCED |
347 			    FLG_RT_INITCLCT)) != FLG_RT_RELOCED)
348 				continue;
349 
350 		} else {
351 			if ((flag & RT_SORT_DELETE) &&
352 			    ((FLAGS(tlmp) & FLG_RT_DELETE) == 0))
353 				continue;
354 			if (((FLAGS(tlmp) &
355 			    (FLG_RT_INITCLCT | FLG_RT_FINICLCT)) ==
356 			    FLG_RT_INITCLCT) == 0)
357 				continue;
358 		}
359 
360 		if (next++)
361 			Dbg_util_nl(lml, DBG_NL_STD);
362 
363 		if (DEPENDS(tlmp) == NULL)
364 			dbg_print(lml, MSG_INTL(MSG_FIL_DEP_NONE), NAME(tlmp));
365 		else {
366 			dbg_print(lml, MSG_INTL(MSG_FIL_DEP_ENT), NAME(tlmp));
367 
368 			for (APLIST_TRAVERSE(DEPENDS(tlmp), idx, bdp)) {
369 				dbg_print(lml, MSG_INTL(MSG_FIL_BND_FILE),
370 				    NAME(bdp->b_depend),
371 				    conv_bnd_type(bdp->b_flags,
372 				    &bnd_type_buf));
373 			}
374 		}
375 	}
376 	Dbg_util_nl(lml, DBG_NL_STD);
377 }
378 
379 void
380 Dbg_file_dlopen(Rt_map *clmp, const char *name, int *in_nfavl, int mode)
381 {
382 	Conv_dl_mode_buf_t	dl_mode_buf;
383 	Lm_list			*lml = LIST(clmp);
384 	const char		*retry;
385 
386 	if (DBG_NOTCLASS(DBG_C_FILES))
387 		return;
388 
389 	/*
390 	 * The core functionality of dlopen() can be called twice.  The first
391 	 * attempt can be affected by path names that exist in the "not-found"
392 	 * AVL tree.  Should a "not-found" path name be found, a second attempt
393 	 * is made to locate the required file (in_nfavl is NULL).  This fall-
394 	 * back provides for file system changes while a process executes.
395 	 */
396 	if (in_nfavl)
397 		retry = MSG_ORIG(MSG_STR_EMPTY);
398 	else
399 		retry = MSG_INTL(MSG_STR_RETRY);
400 
401 	Dbg_util_nl(lml, DBG_NL_STD);
402 	dbg_print(lml, MSG_INTL(MSG_FIL_DLOPEN), name, NAME(clmp), retry,
403 	    conv_dl_mode(mode, 0, &dl_mode_buf));
404 }
405 
406 void
407 Dbg_file_dlclose(Lm_list *lml, const char *name, int flag)
408 {
409 	const char	*str;
410 
411 	if (DBG_NOTCLASS(DBG_C_FILES))
412 		return;
413 
414 	if (flag == DBG_DLCLOSE_IGNORE)
415 		str = MSG_INTL(MSG_STR_IGNORE);
416 	else
417 		str = MSG_ORIG(MSG_STR_EMPTY);
418 
419 	Dbg_util_nl(lml, DBG_NL_STD);
420 	dbg_print(lml, MSG_INTL(MSG_FIL_DLCLOSE), name, str);
421 }
422 
423 void
424 Dbg_file_dldump(Rt_map *lmp, const char *path, int flags)
425 {
426 	Conv_dl_flag_buf_t	dl_flag_buf;
427 	Lm_list			*lml = LIST(lmp);
428 
429 	if (DBG_NOTCLASS(DBG_C_FILES))
430 		return;
431 
432 	Dbg_util_nl(lml, DBG_NL_STD);
433 	dbg_print(lml, MSG_INTL(MSG_FIL_DLDUMP), NAME(lmp), path,
434 	    conv_dl_flag(flags, 0, &dl_flag_buf));
435 }
436 
437 void
438 Dbg_file_lazyload(Rt_map *clmp, const char *fname, const char *sname)
439 {
440 	Lm_list	*lml = LIST(clmp);
441 
442 	if (DBG_NOTCLASS(DBG_C_FILES))
443 		return;
444 
445 	Dbg_util_nl(lml, DBG_NL_STD);
446 	dbg_print(lml, MSG_INTL(MSG_FIL_LAZYLOAD), fname, NAME(clmp),
447 	    Dbg_demangle_name(sname));
448 }
449 
450 void
451 Dbg_file_preload(Lm_list *lml, const char *name)
452 {
453 	if (DBG_NOTCLASS(DBG_C_FILES))
454 		return;
455 
456 	Dbg_util_nl(lml, DBG_NL_STD);
457 	dbg_print(lml, MSG_INTL(MSG_FIL_PRELOAD), name);
458 }
459 
460 void
461 Dbg_file_needed(Rt_map *lmp, const char *name)
462 {
463 	Lm_list	*lml = LIST(lmp);
464 
465 	if (DBG_NOTCLASS(DBG_C_FILES))
466 		return;
467 
468 	Dbg_util_nl(lml, DBG_NL_STD);
469 	dbg_print(lml, MSG_INTL(MSG_FIL_NEEDED), name, NAME(lmp));
470 }
471 
472 void
473 Dbg_file_filter(Lm_list *lml, const char *filter, const char *filtee,
474     int config)
475 {
476 	if (DBG_NOTCLASS(DBG_C_FILES))
477 		return;
478 
479 	Dbg_util_nl(lml, DBG_NL_STD);
480 	if (config)
481 		dbg_print(lml, MSG_INTL(MSG_FIL_FILTER_1), filter, filtee);
482 	else
483 		dbg_print(lml, MSG_INTL(MSG_FIL_FILTER_2), filter, filtee);
484 }
485 
486 void
487 Dbg_file_filtee(Lm_list *lml, const char *filter, const char *filtee, int audit)
488 {
489 	if (audit) {
490 		if (DBG_NOTCLASS(DBG_C_AUDITING | DBG_C_FILES))
491 			return;
492 
493 		Dbg_util_nl(lml, DBG_NL_STD);
494 		dbg_print(lml, MSG_INTL(MSG_FIL_FILTEE_3), filtee);
495 	} else {
496 		if (DBG_NOTCLASS(DBG_C_FILES))
497 			return;
498 
499 		Dbg_util_nl(lml, DBG_NL_STD);
500 		if (filter)
501 			dbg_print(lml, MSG_INTL(MSG_FIL_FILTEE_1), filtee,
502 			    filter);
503 		else
504 			dbg_print(lml, MSG_INTL(MSG_FIL_FILTEE_2), filtee);
505 	}
506 }
507 
508 void
509 Dbg_file_fixname(Lm_list *lml, const char *oname, const char *nname)
510 {
511 	if (DBG_NOTCLASS(DBG_C_FILES))
512 		return;
513 
514 	Dbg_util_nl(lml, DBG_NL_STD);
515 	dbg_print(lml, MSG_INTL(MSG_FIL_FIXNAME), oname, nname);
516 }
517 
518 void
519 Dbg_file_output(Ofl_desc *ofl)
520 {
521 	const char	*prefix = MSG_ORIG(MSG_PTH_OBJECT);
522 	char		*oname, *nname, *ofile;
523 	int		fd;
524 
525 	if (DBG_NOTCLASS(DBG_C_FILES))
526 		return;
527 	if (DBG_NOTDETAIL())
528 		return;
529 
530 	/*
531 	 * Obtain the present input object filename for concatenation to the
532 	 * prefix name.
533 	 */
534 	oname = (char *)ofl->ofl_name;
535 	if ((ofile = strrchr(oname, '/')) == NULL)
536 		ofile = oname;
537 	else
538 		ofile++;
539 
540 	/*
541 	 * Concatenate the prefix with the object filename, open the file and
542 	 * write out the present Elf memory image.  As this is debugging we
543 	 * ignore all errors.
544 	 */
545 	if ((nname = malloc(strlen(prefix) + strlen(ofile) + 1)) != 0) {
546 		(void) strcpy(nname, prefix);
547 		(void) strcat(nname, ofile);
548 		if ((fd = open(nname, O_RDWR | O_CREAT | O_TRUNC,
549 		    0666)) != -1) {
550 			(void) write(fd, ofl->ofl_nehdr, ofl->ofl_size);
551 			(void) close(fd);
552 		}
553 		free(nname);
554 	}
555 }
556 
557 void
558 Dbg_file_config_dis(Lm_list *lml, const char *config, int features)
559 {
560 	Conv_config_feat_buf_t	config_feat_buf;
561 	const char		*str;
562 
563 	switch (features & ~CONF_FEATMSK) {
564 	case DBG_CONF_IGNORE:
565 		str = MSG_INTL(MSG_FIL_CONFIG_ERR_1);
566 		break;
567 	case DBG_CONF_VERSION:
568 		str = MSG_INTL(MSG_FIL_CONFIG_ERR_2);
569 		break;
570 	case DBG_CONF_PRCFAIL:
571 		str = MSG_INTL(MSG_FIL_CONFIG_ERR_3);
572 		break;
573 	case DBG_CONF_CORRUPT:
574 		str = MSG_INTL(MSG_FIL_CONFIG_ERR_4);
575 		break;
576 	case DBG_CONF_ABIMISMATCH:
577 		str = MSG_INTL(MSG_FIL_CONFIG_ERR_5);
578 		break;
579 	default:
580 		str = conv_config_feat(features, &config_feat_buf);
581 		break;
582 	}
583 
584 	Dbg_util_nl(lml, DBG_NL_FRC);
585 	dbg_print(lml, MSG_INTL(MSG_FIL_CONFIG_ERR), config, str);
586 	Dbg_util_nl(lml, DBG_NL_FRC);
587 }
588 
589 void
590 Dbg_file_config_obj(Lm_list *lml, const char *dir, const char *file,
591     const char *config)
592 {
593 	char	*name, _name[PATH_MAX];
594 
595 	if (DBG_NOTCLASS(DBG_C_FILES))
596 		return;
597 
598 	if (file) {
599 		(void) snprintf(_name, PATH_MAX, MSG_ORIG(MSG_FMT_PATH),
600 		    dir, file);
601 		name = _name;
602 	} else
603 		name = (char *)dir;
604 
605 	dbg_print(lml, MSG_INTL(MSG_FIL_CONFIG), name, config);
606 }
607 
608 void
609 Dbg_file_del_rescan(Lm_list *lml)
610 {
611 	if (DBG_NOTCLASS(DBG_C_FILES))
612 		return;
613 
614 	Dbg_util_nl(lml, DBG_NL_STD);
615 	dbg_print(lml, MSG_INTL(MSG_FIL_DEL_RESCAN));
616 }
617 
618 void
619 Dbg_file_mode_promote(Rt_map *lmp, int mode)
620 {
621 	Conv_dl_mode_buf_t	dl_mode_buf;
622 	Lm_list			*lml = LIST(lmp);
623 
624 	if (DBG_NOTCLASS(DBG_C_FILES))
625 		return;
626 
627 	Dbg_util_nl(lml, DBG_NL_STD);
628 	dbg_print(lml, MSG_INTL(MSG_FIL_PROMOTE), NAME(lmp),
629 	    conv_dl_mode(mode, 0, &dl_mode_buf));
630 	Dbg_util_nl(lml, DBG_NL_STD);
631 }
632 
633 void
634 Dbg_file_cntl(Lm_list *lml, Aliste flmco, Aliste tlmco)
635 {
636 	Lm_cntl	*lmc;
637 	Aliste	off;
638 
639 	if (DBG_NOTCLASS(DBG_C_FILES))
640 		return;
641 	if (DBG_NOTDETAIL())
642 		return;
643 
644 	Dbg_util_nl(lml, DBG_NL_STD);
645 	dbg_print(lml, MSG_INTL(MSG_CNTL_TITLE), EC_XWORD(flmco),
646 	    EC_XWORD(tlmco));
647 
648 	for (ALIST_TRAVERSE_BY_OFFSET(lml->lm_lists, off, lmc)) {
649 		Rt_map	*lmp;
650 
651 		/* LINTED */
652 		for (lmp = lmc->lc_head; lmp; lmp = (Rt_map *)NEXT(lmp))
653 			dbg_print(lml, MSG_ORIG(MSG_CNTL_ENTRY), EC_XWORD(off),
654 			    NAME(lmp));
655 	}
656 	Dbg_util_nl(lml, DBG_NL_STD);
657 }
658 
659 /*
660  * Report archive rescan operation.
661  *	argv_start_ndx, argv_end_ndx - Index range of command line arguments
662  *		from which archives are to be reprocessed.
663  */
664 void
665 Dbg_file_ar_rescan(Lm_list *lml, int argv_start_ndx, int argv_end_ndx)
666 {
667 	if (DBG_NOTCLASS(DBG_C_FILES))
668 		return;
669 
670 	Dbg_util_nl(lml, DBG_NL_STD);
671 	dbg_print(lml, MSG_INTL(MSG_FIL_AR_RESCAN),
672 	    argv_start_ndx, argv_end_ndx);
673 	Dbg_util_nl(lml, DBG_NL_STD);
674 }
675 
676 void
677 Dbg_file_ar(Lm_list *lml, const char *name, int again)
678 {
679 	const char	*str;
680 
681 	if (DBG_NOTCLASS(DBG_C_FILES))
682 		return;
683 
684 	if (again)
685 		str = MSG_INTL(MSG_STR_AGAIN);
686 	else
687 		str = MSG_ORIG(MSG_STR_EMPTY);
688 
689 	Dbg_util_nl(lml, DBG_NL_STD);
690 	dbg_print(lml, MSG_INTL(MSG_FIL_ARCHIVE), name, str);
691 }
692 
693 void
694 Dbg_file_generic(Lm_list *lml, Ifl_desc *ifl)
695 {
696 	Conv_inv_buf_t inv_buf;
697 
698 	if (DBG_NOTCLASS(DBG_C_FILES))
699 		return;
700 
701 	Dbg_util_nl(lml, DBG_NL_STD);
702 	dbg_print(lml, MSG_INTL(MSG_FIL_BASIC), ifl->ifl_name,
703 	    conv_ehdr_type(ifl->ifl_ehdr->e_ident[EI_OSABI],
704 	    ifl->ifl_ehdr->e_type, 0, &inv_buf));
705 }
706 
707 static const Msg
708 reject[] = {
709 	MSG_STR_EMPTY,
710 	MSG_REJ_MACH,		/* MSG_INTL(MSG_REJ_MACH) */
711 	MSG_REJ_CLASS,		/* MSG_INTL(MSG_REJ_CLASS) */
712 	MSG_REJ_DATA,		/* MSG_INTL(MSG_REJ_DATA) */
713 	MSG_REJ_TYPE,		/* MSG_INTL(MSG_REJ_TYPE) */
714 	MSG_REJ_BADFLAG,	/* MSG_INTL(MSG_REJ_BADFLAG) */
715 	MSG_REJ_MISFLAG,	/* MSG_INTL(MSG_REJ_MISFLAG) */
716 	MSG_REJ_VERSION,	/* MSG_INTL(MSG_REJ_VERSION) */
717 	MSG_REJ_HAL,		/* MSG_INTL(MSG_REJ_HAL) */
718 	MSG_REJ_US3,		/* MSG_INTL(MSG_REJ_US3) */
719 	MSG_REJ_STR,		/* MSG_INTL(MSG_REJ_STR) */
720 	MSG_REJ_UNKFILE,	/* MSG_INTL(MSG_REJ_UNKFILE) */
721 	MSG_REJ_HWCAP_1,	/* MSG_INTL(MSG_REJ_HWCAP_1) */
722 };
723 
724 void
725 Dbg_file_rejected(Lm_list *lml, Rej_desc *rej, Half mach)
726 {
727 	Conv_reject_desc_buf_t rej_buf;
728 
729 	if (DBG_NOTCLASS(DBG_C_FILES))
730 		return;
731 
732 	Dbg_util_nl(lml, DBG_NL_STD);
733 	dbg_print(lml, MSG_INTL(reject[rej->rej_type]), rej->rej_name ?
734 	    rej->rej_name : MSG_INTL(MSG_STR_UNKNOWN),
735 	    conv_reject_desc(rej, &rej_buf, mach));
736 	Dbg_util_nl(lml, DBG_NL_STD);
737 }
738 
739 void
740 Dbg_file_reuse(Lm_list *lml, const char *nname, const char *oname)
741 {
742 	if (DBG_NOTCLASS(DBG_C_FILES))
743 		return;
744 
745 	dbg_print(lml, MSG_INTL(MSG_FIL_REUSE), nname, oname);
746 }
747 
748 void
749 Dbg_file_skip(Lm_list *lml, const char *oname, const char *nname)
750 {
751 	if (DBG_NOTCLASS(DBG_C_FILES))
752 		return;
753 
754 	if (oname && strcmp(nname, oname))
755 		dbg_print(lml, MSG_INTL(MSG_FIL_SKIP_1), nname, oname);
756 	else
757 		dbg_print(lml, MSG_INTL(MSG_FIL_SKIP_2), nname);
758 }
759 
760 void
761 Dbg_file_modified(Lm_list *lml, const char *obj, const char *oname,
762     const char *nname, int ofd, int nfd, Elf *oelf, Elf *nelf)
763 {
764 	const char	*str;
765 
766 	if (DBG_NOTCLASS(DBG_C_FILES | DBG_C_SUPPORT))
767 		return;
768 	if (DBG_NOTDETAIL())
769 		return;
770 
771 	Dbg_util_nl(lml, DBG_NL_STD);
772 	dbg_print(lml, MSG_INTL(MSG_FIL_MODIFIED), oname, obj);
773 
774 	if (nname != oname)
775 		dbg_print(lml, MSG_INTL(MSG_FIL_NAMECHANGE), nname);
776 	if (nfd != ofd) {
777 		if (nfd == -1)
778 			str = MSG_INTL(MSG_FIL_IGNORE);
779 		else
780 			str = MSG_ORIG(MSG_STR_EMPTY);
781 		dbg_print(lml, MSG_INTL(MSG_FIL_FDCHANGE), ofd, nfd, str);
782 	}
783 	if (nelf != oelf) {
784 		if (nelf == 0)
785 			str = MSG_INTL(MSG_FIL_IGNORE);
786 		else
787 			str = MSG_ORIG(MSG_STR_EMPTY);
788 		dbg_print(lml, MSG_INTL(MSG_FIL_ELFCHANGE), EC_NATPTR(oelf),
789 		    EC_NATPTR(nelf), str);
790 	}
791 	Dbg_util_nl(lml, DBG_NL_STD);
792 }
793 
794 void
795 Dbg_file_cleanup(Lm_list *lml, const char *name, Aliste lmco)
796 {
797 	if (DBG_NOTCLASS(DBG_C_FILES))
798 		return;
799 
800 	Dbg_util_nl(lml, DBG_NL_STD);
801 	dbg_print(lml, MSG_INTL(MSG_FIL_CLEANUP), name, EC_XWORD(lmco));
802 }
803