xref: /titanic_52/usr/src/uts/common/krtld/kobj.c (revision de710d24d2fae4468e64da999e1d952a247f142c)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 /*
26  * Copyright 2011 Bayard G. Bell <buffer.g.overflow@gmail.com>.
27  * All rights reserved. Use is subject to license terms.
28  */
29 
30 /*
31  * Kernel's linker/loader
32  */
33 
34 #include <sys/types.h>
35 #include <sys/param.h>
36 #include <sys/sysmacros.h>
37 #include <sys/systm.h>
38 #include <sys/user.h>
39 #include <sys/kmem.h>
40 #include <sys/reboot.h>
41 #include <sys/bootconf.h>
42 #include <sys/debug.h>
43 #include <sys/uio.h>
44 #include <sys/file.h>
45 #include <sys/vnode.h>
46 #include <sys/user.h>
47 #include <sys/mman.h>
48 #include <vm/as.h>
49 #include <vm/seg_kp.h>
50 #include <vm/seg_kmem.h>
51 #include <sys/elf.h>
52 #include <sys/elf_notes.h>
53 #include <sys/vmsystm.h>
54 #include <sys/kdi.h>
55 #include <sys/atomic.h>
56 #include <sys/kmdb.h>
57 
58 #include <sys/link.h>
59 #include <sys/kobj.h>
60 #include <sys/ksyms.h>
61 #include <sys/disp.h>
62 #include <sys/modctl.h>
63 #include <sys/varargs.h>
64 #include <sys/kstat.h>
65 #include <sys/kobj_impl.h>
66 #include <sys/fs/decomp.h>
67 #include <sys/callb.h>
68 #include <sys/cmn_err.h>
69 #include <sys/tnf_probe.h>
70 #include <sys/zmod.h>
71 
72 #include <krtld/reloc.h>
73 #include <krtld/kobj_kdi.h>
74 #include <sys/sha1.h>
75 #include <sys/crypto/elfsign.h>
76 
77 #if !defined(_OBP)
78 #include <sys/bootvfs.h>
79 #endif
80 
81 /*
82  * do_symbols() error codes
83  */
84 #define	DOSYM_UNDEF		-1	/* undefined symbol */
85 #define	DOSYM_UNSAFE		-2	/* MT-unsafe driver symbol */
86 
87 #if !defined(_OBP)
88 static void synthetic_bootaux(char *, val_t *);
89 #endif
90 
91 static struct module *load_exec(val_t *, char *);
92 static void load_linker(val_t *);
93 static struct modctl *add_primary(const char *filename, int);
94 static int bind_primary(val_t *, int);
95 static int load_primary(struct module *, int);
96 static int load_kmdb(val_t *);
97 static int get_progbits(struct module *, struct _buf *);
98 static int get_syms(struct module *, struct _buf *);
99 static int get_ctf(struct module *, struct _buf *);
100 static void get_signature(struct module *, struct _buf *);
101 static int do_common(struct module *);
102 static void add_dependent(struct module *, struct module *);
103 static int do_dependents(struct modctl *, char *, size_t);
104 static int do_symbols(struct module *, Elf64_Addr);
105 static void module_assign(struct modctl *, struct module *);
106 static void free_module_data(struct module *);
107 static char *depends_on(struct module *);
108 static char *getmodpath(const char *);
109 static char *basename(char *);
110 static void attr_val(val_t *);
111 static char *find_libmacro(char *);
112 static char *expand_libmacro(char *, char *, char *);
113 static int read_bootflags(void);
114 static int kobj_comp_setup(struct _buf *, struct compinfo *);
115 static int kobj_uncomp_blk(struct _buf *, caddr_t, uint_t);
116 static int kobj_read_blks(struct _buf *, caddr_t, uint_t, uint_t);
117 static int kobj_boot_open(char *, int);
118 static int kobj_boot_close(int);
119 static int kobj_boot_seek(int, off_t, off_t);
120 static int kobj_boot_read(int, caddr_t, size_t);
121 static int kobj_boot_fstat(int, struct bootstat *);
122 static int kobj_boot_compinfo(int, struct compinfo *);
123 
124 static Sym *lookup_one(struct module *, const char *);
125 static void sym_insert(struct module *, char *, symid_t);
126 static Sym *sym_lookup(struct module *, Sym *);
127 
128 static struct kobjopen_tctl *kobjopen_alloc(char *filename);
129 static void kobjopen_free(struct kobjopen_tctl *ltp);
130 static void kobjopen_thread(struct kobjopen_tctl *ltp);
131 static int kobj_is_compressed(intptr_t);
132 
133 extern int kcopy(const void *, void *, size_t);
134 extern int elf_mach_ok(Ehdr *);
135 extern int alloc_gottable(struct module *, caddr_t *, caddr_t *);
136 
137 #if !defined(_OBP)
138 extern int kobj_boot_mountroot(void);
139 #endif
140 
141 static void tnf_unsplice_probes(uint_t, struct modctl *);
142 extern tnf_probe_control_t *__tnf_probe_list_head;
143 extern tnf_tag_data_t *__tnf_tag_list_head;
144 
145 extern int modrootloaded;
146 extern int swaploaded;
147 extern int bop_io_quiesced;
148 extern int last_module_id;
149 
150 extern char stubs_base[];
151 extern char stubs_end[];
152 
153 #ifdef KOBJ_DEBUG
154 /*
155  * Values that can be or'd in to kobj_debug and their effects:
156  *
157  *	D_DEBUG		- misc. debugging information.
158  *	D_SYMBOLS	- list symbols and their values as they are entered
159  *			  into the hash table
160  *	D_RELOCATIONS	- display relocation processing information
161  *	D_LOADING	- display information about each module as it
162  *			  is loaded.
163  */
164 int kobj_debug = 0;
165 
166 #define	KOBJ_MARK(s)	if (kobj_debug & D_DEBUG)	\
167 	(_kobj_printf(ops, "%d", __LINE__), _kobj_printf(ops, ": %s\n", s))
168 #else
169 #define	KOBJ_MARK(s)	/* discard */
170 #endif
171 
172 #define	MODPATH_PROPNAME	"module-path"
173 
174 #ifdef MODDIR_SUFFIX
175 static char slash_moddir_suffix_slash[] = MODDIR_SUFFIX "/";
176 #else
177 #define	slash_moddir_suffix_slash	""
178 #endif
179 
180 #define	_moddebug	get_weakish_int(&moddebug)
181 #define	_modrootloaded	get_weakish_int(&modrootloaded)
182 #define	_swaploaded	get_weakish_int(&swaploaded)
183 #define	_ioquiesced	get_weakish_int(&bop_io_quiesced)
184 
185 #define	mod(X)		(struct module *)((X)->modl_modp->mod_mp)
186 
187 void	*romp;		/* rom vector (opaque to us) */
188 struct bootops *ops;	/* bootops vector */
189 void *dbvec;		/* debug vector */
190 
191 /*
192  * kobjopen thread control structure
193  */
194 struct kobjopen_tctl {
195 	ksema_t		sema;
196 	char		*name;		/* name of file */
197 	struct vnode	*vp;		/* vnode return from vn_open() */
198 	int		Errno;		/* error return from vnopen    */
199 };
200 
201 /*
202  * Structure for defining dynamically expandable library macros
203  */
204 
205 struct lib_macro_info {
206 	char	*lmi_list;		/* ptr to list of possible choices */
207 	char	*lmi_macroname;		/* pointer to macro name */
208 	ushort_t lmi_ba_index;		/* index into bootaux vector */
209 	ushort_t lmi_macrolen;		/* macro length */
210 } libmacros[] = {
211 	{ NULL, "CPU", BA_CPU, 0 },
212 	{ NULL, "MMU", BA_MMU, 0 }
213 };
214 
215 #define	NLIBMACROS	sizeof (libmacros) / sizeof (struct lib_macro_info)
216 
217 char *boot_cpu_compatible_list;			/* make $CPU available */
218 
219 char *kobj_module_path;				/* module search path */
220 vmem_t	*text_arena;				/* module text arena */
221 static vmem_t *data_arena;			/* module data & bss arena */
222 static vmem_t *ctf_arena;			/* CTF debug data arena */
223 static struct modctl *kobj_modules = NULL;	/* modules loaded */
224 int kobj_mmu_pagesize;				/* system pagesize */
225 static int lg_pagesize;				/* "large" pagesize */
226 static int kobj_last_module_id = 0;		/* id assignment */
227 static kmutex_t kobj_lock;			/* protects mach memory list */
228 
229 /*
230  * The following functions have been implemented by the kernel.
231  * However, many 3rd party drivers provide their own implementations
232  * of these functions.  When such drivers are loaded, messages
233  * indicating that these symbols have been multiply defined will be
234  * emitted to the console.  To avoid alarming customers for no good
235  * reason, we simply suppress such warnings for the following set of
236  * functions.
237  */
238 static char *suppress_sym_list[] =
239 {
240 	"strstr",
241 	"strncat",
242 	"strlcat",
243 	"strlcpy",
244 	"strspn",
245 	"memcpy",
246 	"memset",
247 	"memmove",
248 	"memcmp",
249 	"memchr",
250 	"__udivdi3",
251 	"__divdi3",
252 	"__umoddi3",
253 	"__moddi3",
254 	NULL		/* This entry must exist */
255 };
256 
257 /* indexed by KOBJ_NOTIFY_* */
258 static kobj_notify_list_t *kobj_notifiers[KOBJ_NOTIFY_MAX + 1];
259 
260 /*
261  * TNF probe management globals
262  */
263 tnf_probe_control_t	*__tnf_probe_list_head = NULL;
264 tnf_tag_data_t		*__tnf_tag_list_head = NULL;
265 int			tnf_changed_probe_list = 0;
266 
267 /*
268  * Prefix for statically defined tracing (SDT) DTrace probes.
269  */
270 const char		*sdt_prefix = "__dtrace_probe_";
271 
272 /*
273  * Beginning and end of the kernel's dynamic text/data segments.
274  */
275 static caddr_t _text;
276 static caddr_t _etext;
277 static caddr_t _data;
278 
279 /*
280  * The sparc linker doesn't create a memory location
281  * for a variable named _edata, so _edata can only be
282  * referred to, not modified.  krtld needs a static
283  * variable to modify it - within krtld, of course -
284  * outside of krtld, e_data is used in all kernels.
285  */
286 #if defined(__sparc)
287 static caddr_t _edata;
288 #else
289 extern caddr_t _edata;
290 #endif
291 
292 Addr dynseg = 0;	/* load address of "dynamic" segment */
293 size_t dynsize;		/* "dynamic" segment size */
294 
295 
296 int standalone = 1;			/* an unwholey kernel? */
297 int use_iflush;				/* iflush after relocations */
298 
299 /*
300  * _kobj_printf()
301  *
302  * Common printf function pointer. Can handle only one conversion
303  * specification in the format string. Some of the functions invoked
304  * through this function pointer cannot handle more that one conversion
305  * specification in the format string.
306  */
307 void (*_kobj_printf)(void *, const char *, ...);	/* printf routine */
308 
309 /*
310  * Standalone function pointers for use within krtld.
311  * Many platforms implement optimized platmod versions of
312  * utilities such as bcopy and any such are not yet available
313  * until the kernel is more completely stitched together.
314  * See kobj_impl.h
315  */
316 void (*kobj_bcopy)(const void *, void *, size_t);
317 void (*kobj_bzero)(void *, size_t);
318 size_t (*kobj_strlcat)(char *, const char *, size_t);
319 
320 static kobj_stat_t kobj_stat;
321 
322 #define	MINALIGN	8	/* at least a double-word */
323 
324 int
325 get_weakish_int(int *ip)
326 {
327 	if (standalone)
328 		return (0);
329 	return (ip == NULL ? 0 : *ip);
330 }
331 
332 static void *
333 get_weakish_pointer(void **ptrp)
334 {
335 	if (standalone)
336 		return (0);
337 	return (ptrp == NULL ? 0 : *ptrp);
338 }
339 
340 /*
341  * XXX fix dependencies on "kernel"; this should work
342  * for other standalone binaries as well.
343  *
344  * XXX Fix hashing code to use one pointer to
345  * hash entries.
346  *	|----------|
347  *	| nbuckets |
348  *	|----------|
349  *	| nchains  |
350  *	|----------|
351  *	| bucket[] |
352  *	|----------|
353  *	| chain[]  |
354  *	|----------|
355  */
356 
357 /*
358  * Load, bind and relocate all modules that
359  * form the primary kernel. At this point, our
360  * externals have not been relocated.
361  */
362 void
363 kobj_init(
364 	void *romvec,
365 	void *dvec,
366 	struct bootops *bootvec,
367 	val_t *bootaux)
368 {
369 	struct module *mp;
370 	struct modctl *modp;
371 	Addr entry;
372 	char filename[MAXPATHLEN];
373 
374 	/*
375 	 * Save these to pass on to
376 	 * the booted standalone.
377 	 */
378 	romp = romvec;
379 	dbvec = dvec;
380 
381 	ops = bootvec;
382 	kobj_setup_standalone_vectors();
383 
384 	KOBJ_MARK("Entered kobj_init()");
385 
386 	(void) BOP_GETPROP(ops, "whoami", filename);
387 
388 	/*
389 	 * We don't support standalone debuggers anymore.  The use of kadb
390 	 * will interfere with the later use of kmdb.  Let the user mend
391 	 * their ways now.  Users will reach this message if they still
392 	 * have the kadb binary on their system (perhaps they used an old
393 	 * bfu, or maybe they intentionally copied it there) and have
394 	 * specified its use in a way that eluded our checking in the boot
395 	 * program.
396 	 */
397 	if (dvec != NULL) {
398 		_kobj_printf(ops, "\nWARNING: Standalone debuggers such as "
399 		    "kadb are no longer supported\n\n");
400 		goto fail;
401 	}
402 
403 #if defined(_OBP)
404 	/*
405 	 * OBP allows us to read both the ramdisk and
406 	 * the underlying root fs when root is a disk.
407 	 * This can lower incidences of unbootable systems
408 	 * when the archive is out-of-date with the /etc
409 	 * state files.
410 	 */
411 	if (BOP_MOUNTROOT() != BOOT_SVC_OK) {
412 		_kobj_printf(ops, "can't mount boot fs\n");
413 		goto fail;
414 	}
415 #else
416 	{
417 		/* on x86, we always boot with a ramdisk */
418 		(void) kobj_boot_mountroot();
419 
420 		/*
421 		 * Now that the ramdisk is mounted, finish boot property
422 		 * initialization.
423 		 */
424 		boot_prop_finish();
425 	}
426 
427 #if !defined(_UNIX_KRTLD)
428 	/*
429 	 * 'unix' is linked together with 'krtld' into one executable and
430 	 * the early boot code does -not- hand us any of the dynamic metadata
431 	 * about the executable. In particular, it does not read in, map or
432 	 * otherwise look at the program headers. We fake all that up now.
433 	 *
434 	 * We do this early as DTrace static probes and tnf probes both call
435 	 * undefined references.  We have to process those relocations before
436 	 * calling any of them.
437 	 *
438 	 * OBP tells kobj_start() where the ELF image is in memory, so it
439 	 * synthesized bootaux before kobj_init() was called
440 	 */
441 	if (bootaux[BA_PHDR].ba_ptr == NULL)
442 		synthetic_bootaux(filename, bootaux);
443 
444 #endif	/* !_UNIX_KRTLD */
445 #endif	/* _OBP */
446 
447 	/*
448 	 * Save the interesting attribute-values
449 	 * (scanned by kobj_boot).
450 	 */
451 	attr_val(bootaux);
452 
453 	/*
454 	 * Set the module search path.
455 	 */
456 	kobj_module_path = getmodpath(filename);
457 
458 	boot_cpu_compatible_list = find_libmacro("CPU");
459 
460 	/*
461 	 * These two modules have actually been
462 	 * loaded by boot, but we finish the job
463 	 * by introducing them into the world of
464 	 * loadable modules.
465 	 */
466 
467 	mp = load_exec(bootaux, filename);
468 	load_linker(bootaux);
469 
470 	/*
471 	 * Load all the primary dependent modules.
472 	 */
473 	if (load_primary(mp, KOBJ_LM_PRIMARY) == -1)
474 		goto fail;
475 
476 	/*
477 	 * Glue it together.
478 	 */
479 	if (bind_primary(bootaux, KOBJ_LM_PRIMARY) == -1)
480 		goto fail;
481 
482 	entry = bootaux[BA_ENTRY].ba_val;
483 
484 	/*
485 	 * Get the boot flags
486 	 */
487 	bootflags(ops);
488 
489 	if (boothowto & RB_VERBOSE)
490 		kobj_lm_dump(KOBJ_LM_PRIMARY);
491 
492 	kobj_kdi_init();
493 
494 	if (boothowto & RB_KMDB) {
495 		if (load_kmdb(bootaux) < 0)
496 			goto fail;
497 	}
498 
499 	/*
500 	 * Post setup.
501 	 */
502 	s_text = _text;
503 	e_text = _etext;
504 	s_data = _data;
505 	e_data = _edata;
506 
507 	kobj_sync_instruction_memory(s_text, e_text - s_text);
508 
509 #ifdef	KOBJ_DEBUG
510 	if (kobj_debug & D_DEBUG)
511 		_kobj_printf(ops,
512 		    "krtld: transferring control to: 0x%p\n", entry);
513 #endif
514 
515 	/*
516 	 * Make sure the mod system knows about the modules already loaded.
517 	 */
518 	last_module_id = kobj_last_module_id;
519 	bcopy(kobj_modules, &modules, sizeof (modules));
520 	modp = &modules;
521 	do {
522 		if (modp->mod_next == kobj_modules)
523 			modp->mod_next = &modules;
524 		if (modp->mod_prev == kobj_modules)
525 			modp->mod_prev = &modules;
526 	} while ((modp = modp->mod_next) != &modules);
527 
528 	standalone = 0;
529 
530 #ifdef	KOBJ_DEBUG
531 	if (kobj_debug & D_DEBUG)
532 		_kobj_printf(ops,
533 		    "krtld: really transferring control to: 0x%p\n", entry);
534 #endif
535 
536 	/* restore printf/bcopy/bzero vectors before returning */
537 	kobj_restore_vectors();
538 
539 #if defined(_DBOOT)
540 	/*
541 	 * krtld was called from a dboot ELF section, the embedded
542 	 * dboot code contains the real entry via bootaux
543 	 */
544 	exitto((caddr_t)entry);
545 #else
546 	/*
547 	 * krtld was directly called from startup
548 	 */
549 	return;
550 #endif
551 
552 fail:
553 
554 	_kobj_printf(ops, "krtld: error during initial load/link phase\n");
555 
556 #if !defined(_UNIX_KRTLD)
557 	_kobj_printf(ops, "\n");
558 	_kobj_printf(ops, "krtld could neither locate nor resolve symbols"
559 	    " for:\n");
560 	_kobj_printf(ops, "    %s\n", filename);
561 	_kobj_printf(ops, "in the boot archive. Please verify that this"
562 	    " file\n");
563 	_kobj_printf(ops, "matches what is found in the boot archive.\n");
564 	_kobj_printf(ops, "You may need to boot using the Solaris failsafe to"
565 	    " fix this.\n");
566 	bop_panic("Unable to boot");
567 #endif
568 }
569 
570 #if !defined(_UNIX_KRTLD) && !defined(_OBP)
571 /*
572  * Synthesize additional metadata that describes the executable if
573  * krtld's caller didn't do it.
574  *
575  * (When the dynamic executable has an interpreter, the boot program
576  * does all this for us.  Where we don't have an interpreter, (or a
577  * even a boot program, perhaps) we have to do this for ourselves.)
578  */
579 static void
580 synthetic_bootaux(char *filename, val_t *bootaux)
581 {
582 	Ehdr ehdr;
583 	caddr_t phdrbase;
584 	struct _buf *file;
585 	int i, n;
586 
587 	/*
588 	 * Elf header
589 	 */
590 	KOBJ_MARK("synthetic_bootaux()");
591 	KOBJ_MARK(filename);
592 	file = kobj_open_file(filename);
593 	if (file == (struct _buf *)-1) {
594 		_kobj_printf(ops, "krtld: failed to open '%s'\n", filename);
595 		return;
596 	}
597 	KOBJ_MARK("reading program headers");
598 	if (kobj_read_file(file, (char *)&ehdr, sizeof (ehdr), 0) < 0) {
599 		_kobj_printf(ops, "krtld: %s: failed to read ehder\n",
600 		    filename);
601 		return;
602 	}
603 
604 	/*
605 	 * Program headers
606 	 */
607 	bootaux[BA_PHNUM].ba_val = ehdr.e_phnum;
608 	bootaux[BA_PHENT].ba_val = ehdr.e_phentsize;
609 	n = ehdr.e_phentsize * ehdr.e_phnum;
610 
611 	phdrbase = kobj_alloc(n, KM_WAIT | KM_TMP);
612 
613 	if (kobj_read_file(file, phdrbase, n, ehdr.e_phoff) < 0) {
614 		_kobj_printf(ops, "krtld: %s: failed to read phdrs\n",
615 		    filename);
616 		return;
617 	}
618 	bootaux[BA_PHDR].ba_ptr = phdrbase;
619 	kobj_close_file(file);
620 	KOBJ_MARK("closed file");
621 
622 	/*
623 	 * Find the dynamic section address
624 	 */
625 	for (i = 0; i < ehdr.e_phnum; i++) {
626 		Phdr *phdr = (Phdr *)(phdrbase + ehdr.e_phentsize * i);
627 
628 		if (phdr->p_type == PT_DYNAMIC) {
629 			bootaux[BA_DYNAMIC].ba_ptr = (void *)phdr->p_vaddr;
630 			break;
631 		}
632 	}
633 	KOBJ_MARK("synthetic_bootaux() done");
634 }
635 #endif	/* !_UNIX_KRTLD && !_OBP */
636 
637 /*
638  * Set up any global information derived
639  * from attribute/values in the boot or
640  * aux vector.
641  */
642 static void
643 attr_val(val_t *bootaux)
644 {
645 	Phdr *phdr;
646 	int phnum, phsize;
647 	int i;
648 
649 	KOBJ_MARK("attr_val()");
650 	kobj_mmu_pagesize = bootaux[BA_PAGESZ].ba_val;
651 	lg_pagesize = bootaux[BA_LPAGESZ].ba_val;
652 	use_iflush = bootaux[BA_IFLUSH].ba_val;
653 
654 	phdr = (Phdr *)bootaux[BA_PHDR].ba_ptr;
655 	phnum = bootaux[BA_PHNUM].ba_val;
656 	phsize = bootaux[BA_PHENT].ba_val;
657 	for (i = 0; i < phnum; i++) {
658 		phdr = (Phdr *)(bootaux[BA_PHDR].ba_val + i * phsize);
659 
660 		if (phdr->p_type != PT_LOAD) {
661 			continue;
662 		}
663 		/*
664 		 * Bounds of the various segments.
665 		 */
666 		if (!(phdr->p_flags & PF_X)) {
667 #if defined(_RELSEG)
668 			/*
669 			 * sparc kernel puts the dynamic info
670 			 * into a separate segment, which is
671 			 * free'd in bop_fini()
672 			 */
673 			ASSERT(phdr->p_vaddr != 0);
674 			dynseg = phdr->p_vaddr;
675 			dynsize = phdr->p_memsz;
676 #else
677 			ASSERT(phdr->p_vaddr == 0);
678 #endif
679 		} else {
680 			if (phdr->p_flags & PF_W) {
681 				_data = (caddr_t)phdr->p_vaddr;
682 				_edata = _data + phdr->p_memsz;
683 			} else {
684 				_text = (caddr_t)phdr->p_vaddr;
685 				_etext = _text + phdr->p_memsz;
686 			}
687 		}
688 	}
689 
690 	/* To do the kobj_alloc, _edata needs to be set. */
691 	for (i = 0; i < NLIBMACROS; i++) {
692 		if (bootaux[libmacros[i].lmi_ba_index].ba_ptr != NULL) {
693 			libmacros[i].lmi_list = kobj_alloc(
694 			    strlen(bootaux[libmacros[i].lmi_ba_index].ba_ptr) +
695 			    1, KM_WAIT);
696 			(void) strcpy(libmacros[i].lmi_list,
697 			    bootaux[libmacros[i].lmi_ba_index].ba_ptr);
698 		}
699 		libmacros[i].lmi_macrolen = strlen(libmacros[i].lmi_macroname);
700 	}
701 }
702 
703 /*
704  * Set up the booted executable.
705  */
706 static struct module *
707 load_exec(val_t *bootaux, char *filename)
708 {
709 	struct modctl *cp;
710 	struct module *mp;
711 	Dyn *dyn;
712 	Sym *sp;
713 	int i, lsize, osize, nsize, allocsize;
714 	char *libname, *tmp;
715 	char path[MAXPATHLEN];
716 
717 #ifdef KOBJ_DEBUG
718 	if (kobj_debug & D_DEBUG)
719 		_kobj_printf(ops, "module path '%s'\n", kobj_module_path);
720 #endif
721 
722 	KOBJ_MARK("add_primary");
723 	cp = add_primary(filename, KOBJ_LM_PRIMARY);
724 
725 	KOBJ_MARK("struct module");
726 	mp = kobj_zalloc(sizeof (struct module), KM_WAIT);
727 	cp->mod_mp = mp;
728 
729 	/*
730 	 * We don't have the following information
731 	 * since this module is an executable and not
732 	 * a relocatable .o.
733 	 */
734 	mp->symtbl_section = 0;
735 	mp->shdrs = NULL;
736 	mp->strhdr = NULL;
737 
738 	/*
739 	 * Since this module is the only exception,
740 	 * we cons up some section headers.
741 	 */
742 	KOBJ_MARK("symhdr");
743 	mp->symhdr = kobj_zalloc(sizeof (Shdr), KM_WAIT);
744 
745 	KOBJ_MARK("strhdr");
746 	mp->strhdr = kobj_zalloc(sizeof (Shdr), KM_WAIT);
747 
748 	mp->symhdr->sh_type = SHT_SYMTAB;
749 	mp->strhdr->sh_type = SHT_STRTAB;
750 	/*
751 	 * Scan the dynamic structure.
752 	 */
753 	for (dyn = (Dyn *) bootaux[BA_DYNAMIC].ba_ptr;
754 	    dyn->d_tag != DT_NULL; dyn++) {
755 		switch (dyn->d_tag) {
756 		case DT_SYMTAB:
757 			mp->symspace = mp->symtbl = (char *)dyn->d_un.d_ptr;
758 			mp->symhdr->sh_addr = dyn->d_un.d_ptr;
759 			break;
760 		case DT_HASH:
761 			mp->nsyms = *((uint_t *)dyn->d_un.d_ptr + 1);
762 			mp->hashsize = *(uint_t *)dyn->d_un.d_ptr;
763 			break;
764 		case DT_STRTAB:
765 			mp->strings = (char *)dyn->d_un.d_ptr;
766 			mp->strhdr->sh_addr = dyn->d_un.d_ptr;
767 			break;
768 		case DT_STRSZ:
769 			mp->strhdr->sh_size = dyn->d_un.d_val;
770 			break;
771 		case DT_SYMENT:
772 			mp->symhdr->sh_entsize = dyn->d_un.d_val;
773 			break;
774 		}
775 	}
776 
777 	/*
778 	 * Collapse any DT_NEEDED entries into one string.
779 	 */
780 	nsize = osize = 0;
781 	allocsize = MAXPATHLEN;
782 
783 	KOBJ_MARK("depends_on");
784 	mp->depends_on = kobj_alloc(allocsize, KM_WAIT);
785 
786 	for (dyn = (Dyn *) bootaux[BA_DYNAMIC].ba_ptr;
787 	    dyn->d_tag != DT_NULL; dyn++)
788 		if (dyn->d_tag == DT_NEEDED) {
789 			char *_lib;
790 
791 			libname = mp->strings + dyn->d_un.d_val;
792 			if (strchr(libname, '$') != NULL) {
793 				if ((_lib = expand_libmacro(libname,
794 				    path, path)) != NULL)
795 					libname = _lib;
796 				else
797 					_kobj_printf(ops, "krtld: "
798 					    "load_exec: fail to "
799 					    "expand %s\n", libname);
800 			}
801 			lsize = strlen(libname);
802 			nsize += lsize;
803 			if (nsize + 1 > allocsize) {
804 				KOBJ_MARK("grow depends_on");
805 				tmp = kobj_alloc(allocsize + MAXPATHLEN,
806 				    KM_WAIT);
807 				bcopy(mp->depends_on, tmp, osize);
808 				kobj_free(mp->depends_on, allocsize);
809 				mp->depends_on = tmp;
810 				allocsize += MAXPATHLEN;
811 			}
812 			bcopy(libname, mp->depends_on + osize, lsize);
813 			*(mp->depends_on + nsize) = ' '; /* separate */
814 			nsize++;
815 			osize = nsize;
816 		}
817 	if (nsize) {
818 		mp->depends_on[nsize - 1] = '\0'; /* terminate the string */
819 		/*
820 		 * alloc with exact size and copy whatever it got over
821 		 */
822 		KOBJ_MARK("realloc depends_on");
823 		tmp = kobj_alloc(nsize, KM_WAIT);
824 		bcopy(mp->depends_on, tmp, nsize);
825 		kobj_free(mp->depends_on, allocsize);
826 		mp->depends_on = tmp;
827 	} else {
828 		kobj_free(mp->depends_on, allocsize);
829 		mp->depends_on = NULL;
830 	}
831 
832 	mp->flags = KOBJ_EXEC|KOBJ_PRIM;	/* NOT a relocatable .o */
833 	mp->symhdr->sh_size = mp->nsyms * mp->symhdr->sh_entsize;
834 	/*
835 	 * We allocate our own table since we don't
836 	 * hash undefined references.
837 	 */
838 	KOBJ_MARK("chains");
839 	mp->chains = kobj_zalloc(mp->nsyms * sizeof (symid_t), KM_WAIT);
840 	KOBJ_MARK("buckets");
841 	mp->buckets = kobj_zalloc(mp->hashsize * sizeof (symid_t), KM_WAIT);
842 
843 	mp->text = _text;
844 	mp->data = _data;
845 
846 	mp->text_size = _etext - _text;
847 	mp->data_size = _edata - _data;
848 
849 	cp->mod_text = mp->text;
850 	cp->mod_text_size = mp->text_size;
851 
852 	mp->filename = cp->mod_filename;
853 
854 #ifdef	KOBJ_DEBUG
855 	if (kobj_debug & D_LOADING) {
856 		_kobj_printf(ops, "krtld: file=%s\n", mp->filename);
857 		_kobj_printf(ops, "\ttext: 0x%p", mp->text);
858 		_kobj_printf(ops, " size: 0x%x\n", mp->text_size);
859 		_kobj_printf(ops, "\tdata: 0x%p", mp->data);
860 		_kobj_printf(ops, " dsize: 0x%x\n", mp->data_size);
861 	}
862 #endif /* KOBJ_DEBUG */
863 
864 	/*
865 	 * Insert symbols into the hash table.
866 	 */
867 	for (i = 0; i < mp->nsyms; i++) {
868 		sp = (Sym *)(mp->symtbl + i * mp->symhdr->sh_entsize);
869 
870 		if (sp->st_name == 0 || sp->st_shndx == SHN_UNDEF)
871 			continue;
872 #if defined(__sparc)
873 		/*
874 		 * Register symbols are ignored in the kernel
875 		 */
876 		if (ELF_ST_TYPE(sp->st_info) == STT_SPARC_REGISTER)
877 			continue;
878 #endif	/* __sparc */
879 
880 		sym_insert(mp, mp->strings + sp->st_name, i);
881 	}
882 
883 	KOBJ_MARK("load_exec done");
884 	return (mp);
885 }
886 
887 /*
888  * Set up the linker module (if it's compiled in, LDNAME is NULL)
889  */
890 static void
891 load_linker(val_t *bootaux)
892 {
893 	struct module *kmp = (struct module *)kobj_modules->mod_mp;
894 	struct module *mp;
895 	struct modctl *cp;
896 	int i;
897 	Shdr *shp;
898 	Sym *sp;
899 	int shsize;
900 	char *dlname = (char *)bootaux[BA_LDNAME].ba_ptr;
901 
902 	/*
903 	 * On some architectures, krtld is compiled into the kernel.
904 	 */
905 	if (dlname == NULL)
906 		return;
907 
908 	cp = add_primary(dlname, KOBJ_LM_PRIMARY);
909 
910 	mp = kobj_zalloc(sizeof (struct module), KM_WAIT);
911 
912 	cp->mod_mp = mp;
913 	mp->hdr = *(Ehdr *)bootaux[BA_LDELF].ba_ptr;
914 	shsize = mp->hdr.e_shentsize * mp->hdr.e_shnum;
915 	mp->shdrs = kobj_alloc(shsize, KM_WAIT);
916 	bcopy(bootaux[BA_LDSHDR].ba_ptr, mp->shdrs, shsize);
917 
918 	for (i = 1; i < (int)mp->hdr.e_shnum; i++) {
919 		shp = (Shdr *)(mp->shdrs + (i * mp->hdr.e_shentsize));
920 
921 		if (shp->sh_flags & SHF_ALLOC) {
922 			if (shp->sh_flags & SHF_WRITE) {
923 				if (mp->data == NULL)
924 					mp->data = (char *)shp->sh_addr;
925 			} else if (mp->text == NULL) {
926 				mp->text = (char *)shp->sh_addr;
927 			}
928 		}
929 		if (shp->sh_type == SHT_SYMTAB) {
930 			mp->symtbl_section = i;
931 			mp->symhdr = shp;
932 			mp->symspace = mp->symtbl = (char *)shp->sh_addr;
933 		}
934 	}
935 	mp->nsyms = mp->symhdr->sh_size / mp->symhdr->sh_entsize;
936 	mp->flags = KOBJ_INTERP|KOBJ_PRIM;
937 	mp->strhdr = (Shdr *)
938 	    (mp->shdrs + mp->symhdr->sh_link * mp->hdr.e_shentsize);
939 	mp->strings = (char *)mp->strhdr->sh_addr;
940 	mp->hashsize = kobj_gethashsize(mp->nsyms);
941 
942 	mp->symsize = mp->symhdr->sh_size + mp->strhdr->sh_size + sizeof (int) +
943 	    (mp->hashsize + mp->nsyms) * sizeof (symid_t);
944 
945 	mp->chains = kobj_zalloc(mp->nsyms * sizeof (symid_t), KM_WAIT);
946 	mp->buckets = kobj_zalloc(mp->hashsize * sizeof (symid_t), KM_WAIT);
947 
948 	mp->bss = bootaux[BA_BSS].ba_val;
949 	mp->bss_align = 0;	/* pre-aligned during allocation */
950 	mp->bss_size = (uintptr_t)_edata - mp->bss;
951 	mp->text_size = _etext - mp->text;
952 	mp->data_size = _edata - mp->data;
953 	mp->filename = cp->mod_filename;
954 	cp->mod_text = mp->text;
955 	cp->mod_text_size = mp->text_size;
956 
957 	/*
958 	 * Now that we've figured out where the linker is,
959 	 * set the limits for the booted object.
960 	 */
961 	kmp->text_size = (size_t)(mp->text - kmp->text);
962 	kmp->data_size = (size_t)(mp->data - kmp->data);
963 	kobj_modules->mod_text_size = kmp->text_size;
964 
965 #ifdef	KOBJ_DEBUG
966 	if (kobj_debug & D_LOADING) {
967 		_kobj_printf(ops, "krtld: file=%s\n", mp->filename);
968 		_kobj_printf(ops, "\ttext:0x%p", mp->text);
969 		_kobj_printf(ops, " size: 0x%x\n", mp->text_size);
970 		_kobj_printf(ops, "\tdata:0x%p", mp->data);
971 		_kobj_printf(ops, " dsize: 0x%x\n", mp->data_size);
972 	}
973 #endif /* KOBJ_DEBUG */
974 
975 	/*
976 	 * Insert the symbols into the hash table.
977 	 */
978 	for (i = 0; i < mp->nsyms; i++) {
979 		sp = (Sym *)(mp->symtbl + i * mp->symhdr->sh_entsize);
980 
981 		if (sp->st_name == 0 || sp->st_shndx == SHN_UNDEF)
982 			continue;
983 		if (ELF_ST_BIND(sp->st_info) == STB_GLOBAL) {
984 			if (sp->st_shndx == SHN_COMMON)
985 				sp->st_shndx = SHN_ABS;
986 		}
987 		sym_insert(mp, mp->strings + sp->st_name, i);
988 	}
989 
990 }
991 
992 static kobj_notify_list_t **
993 kobj_notify_lookup(uint_t type)
994 {
995 	ASSERT(type != 0 && type < sizeof (kobj_notifiers) /
996 	    sizeof (kobj_notify_list_t *));
997 
998 	return (&kobj_notifiers[type]);
999 }
1000 
1001 int
1002 kobj_notify_add(kobj_notify_list_t *knp)
1003 {
1004 	kobj_notify_list_t **knl;
1005 
1006 	knl = kobj_notify_lookup(knp->kn_type);
1007 
1008 	knp->kn_next = NULL;
1009 	knp->kn_prev = NULL;
1010 
1011 	mutex_enter(&kobj_lock);
1012 
1013 	if (*knl != NULL) {
1014 		(*knl)->kn_prev = knp;
1015 		knp->kn_next = *knl;
1016 	}
1017 	(*knl) = knp;
1018 
1019 	mutex_exit(&kobj_lock);
1020 	return (0);
1021 }
1022 
1023 int
1024 kobj_notify_remove(kobj_notify_list_t *knp)
1025 {
1026 	kobj_notify_list_t **knl = kobj_notify_lookup(knp->kn_type);
1027 	kobj_notify_list_t *tknp;
1028 
1029 	mutex_enter(&kobj_lock);
1030 
1031 	/* LINTED */
1032 	if (tknp = knp->kn_next)
1033 		tknp->kn_prev = knp->kn_prev;
1034 
1035 	/* LINTED */
1036 	if (tknp = knp->kn_prev)
1037 		tknp->kn_next = knp->kn_next;
1038 	else
1039 		*knl = knp->kn_next;
1040 
1041 	mutex_exit(&kobj_lock);
1042 
1043 	return (0);
1044 }
1045 
1046 /*
1047  * Notify all interested callbacks of a specified change in module state.
1048  */
1049 static void
1050 kobj_notify(int type, struct modctl *modp)
1051 {
1052 	kobj_notify_list_t *knp;
1053 
1054 	if (modp->mod_loadflags & MOD_NONOTIFY || standalone)
1055 		return;
1056 
1057 	mutex_enter(&kobj_lock);
1058 
1059 	for (knp = *(kobj_notify_lookup(type)); knp != NULL; knp = knp->kn_next)
1060 		knp->kn_func(type, modp);
1061 
1062 	/*
1063 	 * KDI notification must be last (it has to allow for work done by the
1064 	 * other notification callbacks), so we call it manually.
1065 	 */
1066 	kobj_kdi_mod_notify(type, modp);
1067 
1068 	mutex_exit(&kobj_lock);
1069 }
1070 
1071 /*
1072  * Create the module path.
1073  */
1074 static char *
1075 getmodpath(const char *filename)
1076 {
1077 	char *path = kobj_zalloc(MAXPATHLEN, KM_WAIT);
1078 
1079 	/*
1080 	 * Platform code gets first crack, then add
1081 	 * the default components
1082 	 */
1083 	mach_modpath(path, filename);
1084 	if (*path != '\0')
1085 		(void) strcat(path, " ");
1086 	return (strcat(path, MOD_DEFPATH));
1087 }
1088 
1089 static struct modctl *
1090 add_primary(const char *filename, int lmid)
1091 {
1092 	struct modctl *cp;
1093 
1094 	cp = kobj_zalloc(sizeof (struct modctl), KM_WAIT);
1095 
1096 	cp->mod_filename = kobj_alloc(strlen(filename) + 1, KM_WAIT);
1097 
1098 	/*
1099 	 * For symbol lookup, we assemble our own
1100 	 * modctl list of the primary modules.
1101 	 */
1102 
1103 	(void) strcpy(cp->mod_filename, filename);
1104 	cp->mod_modname = basename(cp->mod_filename);
1105 
1106 	/* set values for modinfo assuming that the load will work */
1107 	cp->mod_prim = 1;
1108 	cp->mod_loaded = 1;
1109 	cp->mod_installed = 1;
1110 	cp->mod_loadcnt = 1;
1111 	cp->mod_loadflags = MOD_NOAUTOUNLOAD;
1112 
1113 	cp->mod_id = kobj_last_module_id++;
1114 
1115 	/*
1116 	 * Link the module in. We'll pass this info on
1117 	 * to the mod squad later.
1118 	 */
1119 	if (kobj_modules == NULL) {
1120 		kobj_modules = cp;
1121 		cp->mod_prev = cp->mod_next = cp;
1122 	} else {
1123 		cp->mod_prev = kobj_modules->mod_prev;
1124 		cp->mod_next = kobj_modules;
1125 		kobj_modules->mod_prev->mod_next = cp;
1126 		kobj_modules->mod_prev = cp;
1127 	}
1128 
1129 	kobj_lm_append(lmid, cp);
1130 
1131 	return (cp);
1132 }
1133 
1134 static int
1135 bind_primary(val_t *bootaux, int lmid)
1136 {
1137 	struct modctl_list *linkmap = kobj_lm_lookup(lmid);
1138 	struct modctl_list *lp;
1139 	struct module *mp;
1140 
1141 	/*
1142 	 * Do common symbols.
1143 	 */
1144 	for (lp = linkmap; lp; lp = lp->modl_next) {
1145 		mp = mod(lp);
1146 
1147 		/*
1148 		 * Don't do common section relocations for modules that
1149 		 * don't need it.
1150 		 */
1151 		if (mp->flags & (KOBJ_EXEC|KOBJ_INTERP))
1152 			continue;
1153 
1154 		if (do_common(mp) < 0)
1155 			return (-1);
1156 	}
1157 
1158 	/*
1159 	 * Resolve symbols.
1160 	 */
1161 	for (lp = linkmap; lp; lp = lp->modl_next) {
1162 		mp = mod(lp);
1163 
1164 		if (do_symbols(mp, 0) < 0)
1165 			return (-1);
1166 	}
1167 
1168 	/*
1169 	 * Do relocations.
1170 	 */
1171 	for (lp = linkmap; lp; lp = lp->modl_next) {
1172 		mp = mod(lp);
1173 
1174 		if (mp->flags & KOBJ_EXEC) {
1175 			Dyn *dyn;
1176 			Word relasz = 0, relaent = 0;
1177 			Word shtype;
1178 			char *rela = NULL;
1179 
1180 			for (dyn = (Dyn *)bootaux[BA_DYNAMIC].ba_ptr;
1181 			    dyn->d_tag != DT_NULL; dyn++) {
1182 				switch (dyn->d_tag) {
1183 				case DT_RELASZ:
1184 				case DT_RELSZ:
1185 					relasz = dyn->d_un.d_val;
1186 					break;
1187 				case DT_RELAENT:
1188 				case DT_RELENT:
1189 					relaent = dyn->d_un.d_val;
1190 					break;
1191 				case DT_RELA:
1192 					shtype = SHT_RELA;
1193 					rela = (char *)dyn->d_un.d_ptr;
1194 					break;
1195 				case DT_REL:
1196 					shtype = SHT_REL;
1197 					rela = (char *)dyn->d_un.d_ptr;
1198 					break;
1199 				}
1200 			}
1201 			if (relasz == 0 ||
1202 			    relaent == 0 || rela == NULL) {
1203 				_kobj_printf(ops, "krtld: bind_primary(): "
1204 				    "no relocation information found for "
1205 				    "module %s\n", mp->filename);
1206 				return (-1);
1207 			}
1208 #ifdef	KOBJ_DEBUG
1209 			if (kobj_debug & D_RELOCATIONS)
1210 				_kobj_printf(ops, "krtld: relocating: file=%s "
1211 				    "KOBJ_EXEC\n", mp->filename);
1212 #endif
1213 			if (do_relocate(mp, rela, shtype, relasz/relaent,
1214 			    relaent, (Addr)mp->text) < 0)
1215 				return (-1);
1216 		} else {
1217 			if (do_relocations(mp) < 0)
1218 				return (-1);
1219 		}
1220 
1221 		kobj_sync_instruction_memory(mp->text, mp->text_size);
1222 	}
1223 
1224 	for (lp = linkmap; lp; lp = lp->modl_next) {
1225 		mp = mod(lp);
1226 
1227 		/*
1228 		 * We need to re-read the full symbol table for the boot file,
1229 		 * since we couldn't use the full one before.  We also need to
1230 		 * load the CTF sections of both the boot file and the
1231 		 * interpreter (us).
1232 		 */
1233 		if (mp->flags & KOBJ_EXEC) {
1234 			struct _buf *file;
1235 			int n;
1236 
1237 			file = kobj_open_file(mp->filename);
1238 			if (file == (struct _buf *)-1)
1239 				return (-1);
1240 			if (kobj_read_file(file, (char *)&mp->hdr,
1241 			    sizeof (mp->hdr), 0) < 0)
1242 				return (-1);
1243 			n = mp->hdr.e_shentsize * mp->hdr.e_shnum;
1244 			mp->shdrs = kobj_alloc(n, KM_WAIT);
1245 			if (kobj_read_file(file, mp->shdrs, n,
1246 			    mp->hdr.e_shoff) < 0)
1247 				return (-1);
1248 			if (get_syms(mp, file) < 0)
1249 				return (-1);
1250 			if (get_ctf(mp, file) < 0)
1251 				return (-1);
1252 			kobj_close_file(file);
1253 			mp->flags |= KOBJ_RELOCATED;
1254 
1255 		} else if (mp->flags & KOBJ_INTERP) {
1256 			struct _buf *file;
1257 
1258 			/*
1259 			 * The interpreter path fragment in mp->filename
1260 			 * will already have the module directory suffix
1261 			 * in it (if appropriate).
1262 			 */
1263 			file = kobj_open_path(mp->filename, 1, 0);
1264 			if (file == (struct _buf *)-1)
1265 				return (-1);
1266 			if (get_ctf(mp, file) < 0)
1267 				return (-1);
1268 			kobj_close_file(file);
1269 			mp->flags |= KOBJ_RELOCATED;
1270 		}
1271 	}
1272 
1273 	return (0);
1274 }
1275 
1276 static struct modctl *
1277 mod_already_loaded(char *modname)
1278 {
1279 	struct modctl *mctl = kobj_modules;
1280 
1281 	do {
1282 		if (strcmp(modname, mctl->mod_filename) == 0)
1283 			return (mctl);
1284 		mctl = mctl->mod_next;
1285 
1286 	} while (mctl != kobj_modules);
1287 
1288 	return (NULL);
1289 }
1290 
1291 /*
1292  * Load all the primary dependent modules.
1293  */
1294 static int
1295 load_primary(struct module *mp, int lmid)
1296 {
1297 	struct modctl *cp;
1298 	struct module *dmp;
1299 	char *p, *q;
1300 	char modname[MODMAXNAMELEN];
1301 
1302 	if ((p = mp->depends_on) == NULL)
1303 		return (0);
1304 
1305 	/* CONSTANTCONDITION */
1306 	while (1) {
1307 		/*
1308 		 * Skip space.
1309 		 */
1310 		while (*p && (*p == ' ' || *p == '\t'))
1311 			p++;
1312 		/*
1313 		 * Get module name.
1314 		 */
1315 		q = modname;
1316 		while (*p && *p != ' ' && *p != '\t')
1317 			*q++ = *p++;
1318 
1319 		if (q == modname)
1320 			break;
1321 
1322 		*q = '\0';
1323 		/*
1324 		 * Check for dup dependencies.
1325 		 */
1326 		if (strcmp(modname, "dtracestubs") == 0 ||
1327 		    mod_already_loaded(modname) != NULL)
1328 			continue;
1329 
1330 		cp = add_primary(modname, lmid);
1331 		cp->mod_busy = 1;
1332 		/*
1333 		 * Load it.
1334 		 */
1335 		(void) kobj_load_module(cp, 1);
1336 		cp->mod_busy = 0;
1337 
1338 		if ((dmp = cp->mod_mp) == NULL) {
1339 			cp->mod_loaded = 0;
1340 			cp->mod_installed = 0;
1341 			cp->mod_loadcnt = 0;
1342 			return (-1);
1343 		}
1344 
1345 		add_dependent(mp, dmp);
1346 		dmp->flags |= KOBJ_PRIM;
1347 
1348 		/*
1349 		 * Recurse.
1350 		 */
1351 		if (load_primary(dmp, lmid) == -1) {
1352 			cp->mod_loaded = 0;
1353 			cp->mod_installed = 0;
1354 			cp->mod_loadcnt = 0;
1355 			return (-1);
1356 		}
1357 	}
1358 	return (0);
1359 }
1360 
1361 static int
1362 console_is_usb_serial(void)
1363 {
1364 	char *console;
1365 	int len, ret;
1366 
1367 	if ((len = BOP_GETPROPLEN(ops, "console")) == -1)
1368 		return (0);
1369 
1370 	console = kobj_zalloc(len, KM_WAIT|KM_TMP);
1371 	(void) BOP_GETPROP(ops, "console", console);
1372 	ret = (strcmp(console, "usb-serial") == 0);
1373 	kobj_free(console, len);
1374 
1375 	return (ret);
1376 }
1377 
1378 static int
1379 load_kmdb(val_t *bootaux)
1380 {
1381 	struct modctl *mctl;
1382 	struct module *mp;
1383 	Sym *sym;
1384 
1385 	if (console_is_usb_serial()) {
1386 		_kobj_printf(ops, "kmdb not loaded "
1387 		    "(unsupported on usb serial console)\n");
1388 		return (0);
1389 	}
1390 
1391 	_kobj_printf(ops, "Loading kmdb...\n");
1392 
1393 	if ((mctl = add_primary("misc/kmdbmod", KOBJ_LM_DEBUGGER)) == NULL)
1394 		return (-1);
1395 
1396 	mctl->mod_busy = 1;
1397 	(void) kobj_load_module(mctl, 1);
1398 	mctl->mod_busy = 0;
1399 
1400 	if ((mp = mctl->mod_mp) == NULL)
1401 		return (-1);
1402 
1403 	mp->flags |= KOBJ_PRIM;
1404 
1405 	if (load_primary(mp, KOBJ_LM_DEBUGGER) < 0)
1406 		return (-1);
1407 
1408 	if (boothowto & RB_VERBOSE)
1409 		kobj_lm_dump(KOBJ_LM_DEBUGGER);
1410 
1411 	if (bind_primary(bootaux, KOBJ_LM_DEBUGGER) < 0)
1412 		return (-1);
1413 
1414 	if ((sym = lookup_one(mctl->mod_mp, "kctl_boot_activate")) == NULL)
1415 		return (-1);
1416 
1417 #ifdef	KOBJ_DEBUG
1418 	if (kobj_debug & D_DEBUG) {
1419 		_kobj_printf(ops, "calling kctl_boot_activate() @ 0x%lx\n",
1420 		    sym->st_value);
1421 		_kobj_printf(ops, "\tops 0x%p\n", ops);
1422 		_kobj_printf(ops, "\tromp 0x%p\n", romp);
1423 	}
1424 #endif
1425 
1426 	if (((kctl_boot_activate_f *)sym->st_value)(ops, romp, 0,
1427 	    (const char **)kobj_kmdb_argv) < 0)
1428 		return (-1);
1429 
1430 	return (0);
1431 }
1432 
1433 /*
1434  * Return a string listing module dependencies.
1435  */
1436 static char *
1437 depends_on(struct module *mp)
1438 {
1439 	Sym *sp;
1440 	char *depstr, *q;
1441 
1442 	/*
1443 	 * The module doesn't have a depends_on value, so let's try it the
1444 	 * old-fashioned way - via "_depends_on"
1445 	 */
1446 	if ((sp = lookup_one(mp, "_depends_on")) == NULL)
1447 		return (NULL);
1448 
1449 	q = (char *)sp->st_value;
1450 
1451 #ifdef KOBJ_DEBUG
1452 	/*
1453 	 * _depends_on is a deprecated interface, so we warn about its use
1454 	 * irrespective of subsequent processing errors. How else are we going
1455 	 * to be able to deco this interface completely?
1456 	 * Changes initially limited to DEBUG because third-party modules
1457 	 * should be flagged to developers before general use base.
1458 	 */
1459 	_kobj_printf(ops,
1460 	    "Warning: %s uses deprecated _depends_on interface.\n",
1461 	    mp->filename);
1462 	_kobj_printf(ops, "Please notify module developer or vendor.\n");
1463 #endif
1464 
1465 	/*
1466 	 * Idiot checks. Make sure it's
1467 	 * in-bounds and NULL terminated.
1468 	 */
1469 	if (kobj_addrcheck(mp, q) || q[sp->st_size - 1] != '\0') {
1470 		_kobj_printf(ops, "Error processing dependency for %s\n",
1471 		    mp->filename);
1472 		return (NULL);
1473 	}
1474 
1475 	depstr = (char *)kobj_alloc(strlen(q) + 1, KM_WAIT);
1476 	(void) strcpy(depstr, q);
1477 
1478 	return (depstr);
1479 }
1480 
1481 void
1482 kobj_getmodinfo(void *xmp, struct modinfo *modinfo)
1483 {
1484 	struct module *mp;
1485 	mp = (struct module *)xmp;
1486 
1487 	modinfo->mi_base = mp->text;
1488 	modinfo->mi_size = mp->text_size + mp->data_size;
1489 }
1490 
1491 /*
1492  * kobj_export_ksyms() performs the following services:
1493  *
1494  * (1) Migrates the symbol table from boot/kobj memory to the ksyms arena.
1495  * (2) Removes unneeded symbols to save space.
1496  * (3) Reduces memory footprint by using VM_BESTFIT allocations.
1497  * (4) Makes the symbol table visible to /dev/ksyms.
1498  */
1499 static void
1500 kobj_export_ksyms(struct module *mp)
1501 {
1502 	Sym *esp = (Sym *)(mp->symtbl + mp->symhdr->sh_size);
1503 	Sym *sp, *osp;
1504 	char *name;
1505 	size_t namelen;
1506 	struct module *omp;
1507 	uint_t nsyms;
1508 	size_t symsize = mp->symhdr->sh_entsize;
1509 	size_t locals = 1;
1510 	size_t strsize;
1511 
1512 	/*
1513 	 * Make a copy of the original module structure.
1514 	 */
1515 	omp = kobj_alloc(sizeof (struct module), KM_WAIT);
1516 	bcopy(mp, omp, sizeof (struct module));
1517 
1518 	/*
1519 	 * Compute the sizes of the new symbol table sections.
1520 	 */
1521 	for (nsyms = strsize = 1, osp = (Sym *)omp->symtbl; osp < esp; osp++) {
1522 		if (osp->st_value == 0)
1523 			continue;
1524 		if (sym_lookup(omp, osp) == NULL)
1525 			continue;
1526 		name = omp->strings + osp->st_name;
1527 		namelen = strlen(name);
1528 		if (ELF_ST_BIND(osp->st_info) == STB_LOCAL)
1529 			locals++;
1530 		nsyms++;
1531 		strsize += namelen + 1;
1532 	}
1533 
1534 	mp->nsyms = nsyms;
1535 	mp->hashsize = kobj_gethashsize(mp->nsyms);
1536 
1537 	/*
1538 	 * ksyms_lock must be held as writer during any operation that
1539 	 * modifies ksyms_arena, including allocation from same, and
1540 	 * must not be dropped until the arena is vmem_walk()able.
1541 	 */
1542 	rw_enter(&ksyms_lock, RW_WRITER);
1543 
1544 	/*
1545 	 * Allocate space for the new section headers (symtab and strtab),
1546 	 * symbol table, buckets, chains, and strings.
1547 	 */
1548 	mp->symsize = (2 * sizeof (Shdr)) + (nsyms * symsize) +
1549 	    (mp->hashsize + mp->nsyms) * sizeof (symid_t) + strsize;
1550 
1551 	if (mp->flags & KOBJ_NOKSYMS) {
1552 		mp->symspace = kobj_alloc(mp->symsize, KM_WAIT);
1553 	} else {
1554 		mp->symspace = vmem_alloc(ksyms_arena, mp->symsize,
1555 		    VM_BESTFIT | VM_SLEEP);
1556 	}
1557 	bzero(mp->symspace, mp->symsize);
1558 
1559 	/*
1560 	 * Divvy up symspace.
1561 	 */
1562 	mp->shdrs = mp->symspace;
1563 	mp->symhdr = (Shdr *)mp->shdrs;
1564 	mp->strhdr = (Shdr *)(mp->symhdr + 1);
1565 	mp->symtbl = (char *)(mp->strhdr + 1);
1566 	mp->buckets = (symid_t *)(mp->symtbl + (nsyms * symsize));
1567 	mp->chains = (symid_t *)(mp->buckets + mp->hashsize);
1568 	mp->strings = (char *)(mp->chains + nsyms);
1569 
1570 	/*
1571 	 * Fill in the new section headers (symtab and strtab).
1572 	 */
1573 	mp->hdr.e_shnum = 2;
1574 	mp->symtbl_section = 0;
1575 
1576 	mp->symhdr->sh_type = SHT_SYMTAB;
1577 	mp->symhdr->sh_addr = (Addr)mp->symtbl;
1578 	mp->symhdr->sh_size = nsyms * symsize;
1579 	mp->symhdr->sh_link = 1;
1580 	mp->symhdr->sh_info = locals;
1581 	mp->symhdr->sh_addralign = sizeof (Addr);
1582 	mp->symhdr->sh_entsize = symsize;
1583 
1584 	mp->strhdr->sh_type = SHT_STRTAB;
1585 	mp->strhdr->sh_addr = (Addr)mp->strings;
1586 	mp->strhdr->sh_size = strsize;
1587 	mp->strhdr->sh_addralign = 1;
1588 
1589 	/*
1590 	 * Construct the new symbol table.
1591 	 */
1592 	for (nsyms = strsize = 1, osp = (Sym *)omp->symtbl; osp < esp; osp++) {
1593 		if (osp->st_value == 0)
1594 			continue;
1595 		if (sym_lookup(omp, osp) == NULL)
1596 			continue;
1597 		name = omp->strings + osp->st_name;
1598 		namelen = strlen(name);
1599 		sp = (Sym *)(mp->symtbl + symsize * nsyms);
1600 		bcopy(osp, sp, symsize);
1601 		bcopy(name, mp->strings + strsize, namelen);
1602 		sp->st_name = strsize;
1603 		sym_insert(mp, name, nsyms);
1604 		nsyms++;
1605 		strsize += namelen + 1;
1606 	}
1607 
1608 	rw_exit(&ksyms_lock);
1609 
1610 	/*
1611 	 * Free the old section headers -- we'll never need them again.
1612 	 */
1613 	if (!(mp->flags & KOBJ_PRIM)) {
1614 		uint_t	shn;
1615 		Shdr	*shp;
1616 
1617 		for (shn = 1; shn < omp->hdr.e_shnum; shn++) {
1618 			shp = (Shdr *)(omp->shdrs + shn * omp->hdr.e_shentsize);
1619 			switch (shp->sh_type) {
1620 			case SHT_RELA:
1621 			case SHT_REL:
1622 				if (shp->sh_addr != 0) {
1623 					kobj_free((void *)shp->sh_addr,
1624 					    shp->sh_size);
1625 				}
1626 				break;
1627 			}
1628 		}
1629 		kobj_free(omp->shdrs, omp->hdr.e_shentsize * omp->hdr.e_shnum);
1630 	}
1631 	/*
1632 	 * Discard the old symbol table and our copy of the module strucure.
1633 	 */
1634 	if (!(mp->flags & KOBJ_PRIM))
1635 		kobj_free(omp->symspace, omp->symsize);
1636 	kobj_free(omp, sizeof (struct module));
1637 }
1638 
1639 static void
1640 kobj_export_ctf(struct module *mp)
1641 {
1642 	char *data = mp->ctfdata;
1643 	size_t size = mp->ctfsize;
1644 
1645 	if (data != NULL) {
1646 		if (_moddebug & MODDEBUG_NOCTF) {
1647 			mp->ctfdata = NULL;
1648 			mp->ctfsize = 0;
1649 		} else {
1650 			mp->ctfdata = vmem_alloc(ctf_arena, size,
1651 			    VM_BESTFIT | VM_SLEEP);
1652 			bcopy(data, mp->ctfdata, size);
1653 		}
1654 
1655 		if (!(mp->flags & KOBJ_PRIM))
1656 			kobj_free(data, size);
1657 	}
1658 }
1659 
1660 void
1661 kobj_export_module(struct module *mp)
1662 {
1663 	kobj_export_ksyms(mp);
1664 	kobj_export_ctf(mp);
1665 
1666 	mp->flags |= KOBJ_EXPORTED;
1667 }
1668 
1669 static int
1670 process_dynamic(struct module *mp, char *dyndata, char *strdata)
1671 {
1672 	char *path = NULL, *depstr = NULL;
1673 	int allocsize = 0, osize = 0, nsize = 0;
1674 	char *libname, *tmp;
1675 	int lsize;
1676 	Dyn *dynp;
1677 
1678 	for (dynp = (Dyn *)dyndata; dynp && dynp->d_tag != DT_NULL; dynp++) {
1679 		switch (dynp->d_tag) {
1680 		case DT_NEEDED:
1681 			/*
1682 			 * Read the DT_NEEDED entries, expanding the macros they
1683 			 * contain (if any), and concatenating them into a
1684 			 * single space-separated dependency list.
1685 			 */
1686 			libname = (ulong_t)dynp->d_un.d_ptr + strdata;
1687 
1688 			if (strchr(libname, '$') != NULL) {
1689 				char *_lib;
1690 
1691 				if (path == NULL)
1692 					path = kobj_alloc(MAXPATHLEN, KM_WAIT);
1693 				if ((_lib = expand_libmacro(libname, path,
1694 				    path)) != NULL)
1695 					libname = _lib;
1696 				else {
1697 					_kobj_printf(ops, "krtld: "
1698 					    "process_dynamic: failed to expand "
1699 					    "%s\n", libname);
1700 				}
1701 			}
1702 
1703 			lsize = strlen(libname);
1704 			nsize += lsize;
1705 			if (nsize + 1 > allocsize) {
1706 				tmp = kobj_alloc(allocsize + MAXPATHLEN,
1707 				    KM_WAIT);
1708 				if (depstr != NULL) {
1709 					bcopy(depstr, tmp, osize);
1710 					kobj_free(depstr, allocsize);
1711 				}
1712 				depstr = tmp;
1713 				allocsize += MAXPATHLEN;
1714 			}
1715 			bcopy(libname, depstr + osize, lsize);
1716 			*(depstr + nsize) = ' '; /* separator */
1717 			nsize++;
1718 			osize = nsize;
1719 			break;
1720 
1721 		case DT_FLAGS_1:
1722 			if (dynp->d_un.d_val & DF_1_IGNMULDEF)
1723 				mp->flags |= KOBJ_IGNMULDEF;
1724 			if (dynp->d_un.d_val & DF_1_NOKSYMS)
1725 				mp->flags |= KOBJ_NOKSYMS;
1726 
1727 			break;
1728 		}
1729 	}
1730 
1731 	/*
1732 	 * finish up the depends string (if any)
1733 	 */
1734 	if (depstr != NULL) {
1735 		*(depstr + nsize - 1) = '\0'; /* overwrite separator w/term */
1736 		if (path != NULL)
1737 			kobj_free(path, MAXPATHLEN);
1738 
1739 		tmp = kobj_alloc(nsize, KM_WAIT);
1740 		bcopy(depstr, tmp, nsize);
1741 		kobj_free(depstr, allocsize);
1742 		depstr = tmp;
1743 
1744 		mp->depends_on = depstr;
1745 	}
1746 
1747 	return (0);
1748 }
1749 
1750 static int
1751 do_dynamic(struct module *mp, struct _buf *file)
1752 {
1753 	Shdr *dshp, *dstrp, *shp;
1754 	char *dyndata, *dstrdata;
1755 	int dshn, shn, rc;
1756 
1757 	/* find and validate the dynamic section (if any) */
1758 
1759 	for (dshp = NULL, shn = 1; shn < mp->hdr.e_shnum; shn++) {
1760 		shp = (Shdr *)(mp->shdrs + shn * mp->hdr.e_shentsize);
1761 		switch (shp->sh_type) {
1762 		case SHT_DYNAMIC:
1763 			if (dshp != NULL) {
1764 				_kobj_printf(ops, "krtld: get_dynamic: %s, ",
1765 				    mp->filename);
1766 				_kobj_printf(ops,
1767 				    "multiple dynamic sections\n");
1768 				return (-1);
1769 			} else {
1770 				dshp = shp;
1771 				dshn = shn;
1772 			}
1773 			break;
1774 		}
1775 	}
1776 
1777 	if (dshp == NULL)
1778 		return (0);
1779 
1780 	if (dshp->sh_link > mp->hdr.e_shnum) {
1781 		_kobj_printf(ops, "krtld: get_dynamic: %s, ", mp->filename);
1782 		_kobj_printf(ops, "no section for sh_link %d\n", dshp->sh_link);
1783 		return (-1);
1784 	}
1785 	dstrp = (Shdr *)(mp->shdrs + dshp->sh_link * mp->hdr.e_shentsize);
1786 
1787 	if (dstrp->sh_type != SHT_STRTAB) {
1788 		_kobj_printf(ops, "krtld: get_dynamic: %s, ", mp->filename);
1789 		_kobj_printf(ops, "sh_link not a string table for section %d\n",
1790 		    dshn);
1791 		return (-1);
1792 	}
1793 
1794 	/* read it from disk */
1795 
1796 	dyndata = kobj_alloc(dshp->sh_size, KM_WAIT|KM_TMP);
1797 	if (kobj_read_file(file, dyndata, dshp->sh_size, dshp->sh_offset) < 0) {
1798 		_kobj_printf(ops, "krtld: get_dynamic: %s, ", mp->filename);
1799 		_kobj_printf(ops, "error reading section %d\n", dshn);
1800 
1801 		kobj_free(dyndata, dshp->sh_size);
1802 		return (-1);
1803 	}
1804 
1805 	dstrdata = kobj_alloc(dstrp->sh_size, KM_WAIT|KM_TMP);
1806 	if (kobj_read_file(file, dstrdata, dstrp->sh_size,
1807 	    dstrp->sh_offset) < 0) {
1808 		_kobj_printf(ops, "krtld: get_dynamic: %s, ", mp->filename);
1809 		_kobj_printf(ops, "error reading section %d\n", dshp->sh_link);
1810 
1811 		kobj_free(dyndata, dshp->sh_size);
1812 		kobj_free(dstrdata, dstrp->sh_size);
1813 		return (-1);
1814 	}
1815 
1816 	/* pull the interesting pieces out */
1817 
1818 	rc = process_dynamic(mp, dyndata, dstrdata);
1819 
1820 	kobj_free(dyndata, dshp->sh_size);
1821 	kobj_free(dstrdata, dstrp->sh_size);
1822 
1823 	return (rc);
1824 }
1825 
1826 void
1827 kobj_set_ctf(struct module *mp, caddr_t data, size_t size)
1828 {
1829 	if (!standalone) {
1830 		if (mp->ctfdata != NULL) {
1831 			if (vmem_contains(ctf_arena, mp->ctfdata,
1832 			    mp->ctfsize)) {
1833 				vmem_free(ctf_arena, mp->ctfdata, mp->ctfsize);
1834 			} else {
1835 				kobj_free(mp->ctfdata, mp->ctfsize);
1836 			}
1837 		}
1838 	}
1839 
1840 	/*
1841 	 * The order is very important here.  We need to make sure that
1842 	 * consumers, at any given instant, see a consistent state.  We'd
1843 	 * rather they see no CTF data than the address of one buffer and the
1844 	 * size of another.
1845 	 */
1846 	mp->ctfdata = NULL;
1847 	membar_producer();
1848 	mp->ctfsize = size;
1849 	mp->ctfdata = data;
1850 	membar_producer();
1851 }
1852 
1853 int
1854 kobj_load_module(struct modctl *modp, int use_path)
1855 {
1856 	char *filename = modp->mod_filename;
1857 	char *modname = modp->mod_modname;
1858 	int i;
1859 	int n;
1860 	struct _buf *file;
1861 	struct module *mp = NULL;
1862 #ifdef MODDIR_SUFFIX
1863 	int no_suffixdir_drv = 0;
1864 #endif
1865 
1866 	mp = kobj_zalloc(sizeof (struct module), KM_WAIT);
1867 
1868 	/*
1869 	 * We need to prevent kmdb's symbols from leaking into /dev/ksyms.
1870 	 * kmdb contains a bunch of symbols with well-known names, symbols
1871 	 * which will mask the real versions, thus causing no end of trouble
1872 	 * for mdb.
1873 	 */
1874 	if (strcmp(modp->mod_modname, "kmdbmod") == 0)
1875 		mp->flags |= KOBJ_NOKSYMS;
1876 
1877 	file = kobj_open_path(filename, use_path, 1);
1878 	if (file == (struct _buf *)-1) {
1879 #ifdef MODDIR_SUFFIX
1880 		file = kobj_open_path(filename, use_path, 0);
1881 #endif
1882 		if (file == (struct _buf *)-1) {
1883 			kobj_free(mp, sizeof (*mp));
1884 			goto bad;
1885 		}
1886 #ifdef MODDIR_SUFFIX
1887 		/*
1888 		 * There is no driver module in the ISA specific (suffix)
1889 		 * subdirectory but there is a module in the parent directory.
1890 		 */
1891 		if (strncmp(filename, "drv/", 4) == 0) {
1892 			no_suffixdir_drv = 1;
1893 		}
1894 #endif
1895 	}
1896 
1897 	mp->filename = kobj_alloc(strlen(file->_name) + 1, KM_WAIT);
1898 	(void) strcpy(mp->filename, file->_name);
1899 
1900 	if (kobj_read_file(file, (char *)&mp->hdr, sizeof (mp->hdr), 0) < 0) {
1901 		_kobj_printf(ops, "kobj_load_module: %s read header failed\n",
1902 		    modname);
1903 		kobj_free(mp->filename, strlen(file->_name) + 1);
1904 		kobj_free(mp, sizeof (*mp));
1905 		goto bad;
1906 	}
1907 	for (i = 0; i < SELFMAG; i++) {
1908 		if (mp->hdr.e_ident[i] != ELFMAG[i]) {
1909 			if (_moddebug & MODDEBUG_ERRMSG)
1910 				_kobj_printf(ops, "%s not an elf module\n",
1911 				    modname);
1912 			kobj_free(mp->filename, strlen(file->_name) + 1);
1913 			kobj_free(mp, sizeof (*mp));
1914 			goto bad;
1915 		}
1916 	}
1917 	/*
1918 	 * It's ELF, but is it our ISA?  Interpreting the header
1919 	 * from a file for a byte-swapped ISA could cause a huge
1920 	 * and unsatisfiable value to be passed to kobj_alloc below
1921 	 * and therefore hang booting.
1922 	 */
1923 	if (!elf_mach_ok(&mp->hdr)) {
1924 		if (_moddebug & MODDEBUG_ERRMSG)
1925 			_kobj_printf(ops, "%s not an elf module for this ISA\n",
1926 			    modname);
1927 		kobj_free(mp->filename, strlen(file->_name) + 1);
1928 		kobj_free(mp, sizeof (*mp));
1929 #ifdef MODDIR_SUFFIX
1930 		/*
1931 		 * The driver mod is not in the ISA specific subdirectory
1932 		 * and the module in the parent directory is not our ISA.
1933 		 * If it is our ISA, for now we will silently succeed.
1934 		 */
1935 		if (no_suffixdir_drv == 1) {
1936 			cmn_err(CE_CONT, "?NOTICE: %s: 64-bit driver module"
1937 			    " not found\n", modname);
1938 		}
1939 #endif
1940 		goto bad;
1941 	}
1942 
1943 	/*
1944 	 * All modules, save for unix, should be relocatable (as opposed to
1945 	 * dynamic).  Dynamic modules come with PLTs and GOTs, which can't
1946 	 * currently be processed by krtld.
1947 	 */
1948 	if (mp->hdr.e_type != ET_REL) {
1949 		if (_moddebug & MODDEBUG_ERRMSG)
1950 			_kobj_printf(ops, "%s isn't a relocatable (ET_REL) "
1951 			    "module\n", modname);
1952 		kobj_free(mp->filename, strlen(file->_name) + 1);
1953 		kobj_free(mp, sizeof (*mp));
1954 		goto bad;
1955 	}
1956 
1957 	n = mp->hdr.e_shentsize * mp->hdr.e_shnum;
1958 	mp->shdrs = kobj_alloc(n, KM_WAIT);
1959 
1960 	if (kobj_read_file(file, mp->shdrs, n, mp->hdr.e_shoff) < 0) {
1961 		_kobj_printf(ops, "kobj_load_module: %s error reading "
1962 		    "section headers\n", modname);
1963 		kobj_free(mp->shdrs, n);
1964 		kobj_free(mp->filename, strlen(file->_name) + 1);
1965 		kobj_free(mp, sizeof (*mp));
1966 		goto bad;
1967 	}
1968 
1969 	kobj_notify(KOBJ_NOTIFY_MODLOADING, modp);
1970 	module_assign(modp, mp);
1971 
1972 	/* read in sections */
1973 	if (get_progbits(mp, file) < 0) {
1974 		_kobj_printf(ops, "%s error reading sections\n", modname);
1975 		goto bad;
1976 	}
1977 
1978 	if (do_dynamic(mp, file) < 0) {
1979 		_kobj_printf(ops, "%s error reading dynamic section\n",
1980 		    modname);
1981 		goto bad;
1982 	}
1983 
1984 	modp->mod_text = mp->text;
1985 	modp->mod_text_size = mp->text_size;
1986 
1987 	/* read in symbols; adjust values for each section's real address */
1988 	if (get_syms(mp, file) < 0) {
1989 		_kobj_printf(ops, "%s error reading symbols\n",
1990 		    modname);
1991 		goto bad;
1992 	}
1993 
1994 	/*
1995 	 * If we didn't dependency information from the dynamic section, look
1996 	 * for it the old-fashioned way.
1997 	 */
1998 	if (mp->depends_on == NULL)
1999 		mp->depends_on = depends_on(mp);
2000 
2001 	if (get_ctf(mp, file) < 0) {
2002 		_kobj_printf(ops, "%s debug information will not "
2003 		    "be available\n", modname);
2004 	}
2005 
2006 	/* primary kernel modules do not have a signature section */
2007 	if (!(mp->flags & KOBJ_PRIM))
2008 		get_signature(mp, file);
2009 
2010 #ifdef	KOBJ_DEBUG
2011 	if (kobj_debug & D_LOADING) {
2012 		_kobj_printf(ops, "krtld: file=%s\n", mp->filename);
2013 		_kobj_printf(ops, "\ttext:0x%p", mp->text);
2014 		_kobj_printf(ops, " size: 0x%x\n", mp->text_size);
2015 		_kobj_printf(ops, "\tdata:0x%p", mp->data);
2016 		_kobj_printf(ops, " dsize: 0x%x\n", mp->data_size);
2017 	}
2018 #endif /* KOBJ_DEBUG */
2019 
2020 	/*
2021 	 * For primary kernel modules, we defer
2022 	 * symbol resolution and relocation until
2023 	 * all primary objects have been loaded.
2024 	 */
2025 	if (!standalone) {
2026 		int ddrval, dcrval;
2027 		char *dependent_modname;
2028 		/* load all dependents */
2029 		dependent_modname = kobj_zalloc(MODMAXNAMELEN, KM_WAIT);
2030 		ddrval = do_dependents(modp, dependent_modname, MODMAXNAMELEN);
2031 
2032 		/*
2033 		 * resolve undefined and common symbols,
2034 		 * also allocates common space
2035 		 */
2036 		if ((dcrval = do_common(mp)) < 0) {
2037 			switch (dcrval) {
2038 			case DOSYM_UNSAFE:
2039 				_kobj_printf(ops, "WARNING: mod_load: "
2040 				    "MT-unsafe module '%s' rejected\n",
2041 				    modname);
2042 				break;
2043 			case DOSYM_UNDEF:
2044 				_kobj_printf(ops, "WARNING: mod_load: "
2045 				    "cannot load module '%s'\n",
2046 				    modname);
2047 				if (ddrval == -1) {
2048 					_kobj_printf(ops, "WARNING: %s: ",
2049 					    modname);
2050 					_kobj_printf(ops,
2051 					    "unable to resolve dependency, "
2052 					    "module '%s' not found\n",
2053 					    dependent_modname);
2054 				}
2055 				break;
2056 			}
2057 		}
2058 		kobj_free(dependent_modname, MODMAXNAMELEN);
2059 		if (dcrval < 0)
2060 			goto bad;
2061 
2062 		/* process relocation tables */
2063 		if (do_relocations(mp) < 0) {
2064 			_kobj_printf(ops, "%s error doing relocations\n",
2065 			    modname);
2066 			goto bad;
2067 		}
2068 
2069 		if (mp->destination) {
2070 			off_t	off = (uintptr_t)mp->destination & PAGEOFFSET;
2071 			caddr_t	base = (caddr_t)mp->destination - off;
2072 			size_t	size = P2ROUNDUP(mp->text_size + off, PAGESIZE);
2073 
2074 			hat_unload(kas.a_hat, base, size, HAT_UNLOAD_UNLOCK);
2075 			vmem_free(heap_arena, base, size);
2076 		}
2077 
2078 		/* sync_instruction_memory */
2079 		kobj_sync_instruction_memory(mp->text, mp->text_size);
2080 		kobj_export_module(mp);
2081 		kobj_notify(KOBJ_NOTIFY_MODLOADED, modp);
2082 	}
2083 	kobj_close_file(file);
2084 	return (0);
2085 bad:
2086 	if (file != (struct _buf *)-1)
2087 		kobj_close_file(file);
2088 	if (modp->mod_mp != NULL)
2089 		free_module_data(modp->mod_mp);
2090 
2091 	module_assign(modp, NULL);
2092 	return ((file == (struct _buf *)-1) ? ENOENT : EINVAL);
2093 }
2094 
2095 int
2096 kobj_load_primary_module(struct modctl *modp)
2097 {
2098 	struct modctl *dep;
2099 	struct module *mp;
2100 
2101 	if (kobj_load_module(modp, 0) != 0)
2102 		return (-1);
2103 
2104 	mp = modp->mod_mp;
2105 	mp->flags |= KOBJ_PRIM;
2106 
2107 	/* Bind new module to its dependents */
2108 	if (mp->depends_on != NULL && (dep =
2109 	    mod_already_loaded(mp->depends_on)) == NULL) {
2110 #ifdef	KOBJ_DEBUG
2111 		if (kobj_debug & D_DEBUG) {
2112 			_kobj_printf(ops, "krtld: failed to resolve deps "
2113 			    "for primary %s\n", modp->mod_modname);
2114 		}
2115 #endif
2116 		return (-1);
2117 	}
2118 
2119 	add_dependent(mp, dep->mod_mp);
2120 
2121 	/*
2122 	 * Relocate it.  This module may not be part of a link map, so we
2123 	 * can't use bind_primary.
2124 	 */
2125 	if (do_common(mp) < 0 || do_symbols(mp, 0) < 0 ||
2126 	    do_relocations(mp) < 0) {
2127 #ifdef	KOBJ_DEBUG
2128 		if (kobj_debug & D_DEBUG) {
2129 			_kobj_printf(ops, "krtld: failed to relocate "
2130 			    "primary %s\n", modp->mod_modname);
2131 		}
2132 #endif
2133 		return (-1);
2134 	}
2135 
2136 	return (0);
2137 }
2138 
2139 static void
2140 module_assign(struct modctl *cp, struct module *mp)
2141 {
2142 	if (standalone) {
2143 		cp->mod_mp = mp;
2144 		return;
2145 	}
2146 	mutex_enter(&mod_lock);
2147 	cp->mod_mp = mp;
2148 	cp->mod_gencount++;
2149 	mutex_exit(&mod_lock);
2150 }
2151 
2152 void
2153 kobj_unload_module(struct modctl *modp)
2154 {
2155 	struct module *mp = modp->mod_mp;
2156 
2157 	if ((_moddebug & MODDEBUG_KEEPTEXT) && mp) {
2158 		_kobj_printf(ops, "text for %s ", mp->filename);
2159 		_kobj_printf(ops, "was at %p\n", mp->text);
2160 		mp->text = NULL;	/* don't actually free it */
2161 	}
2162 
2163 	kobj_notify(KOBJ_NOTIFY_MODUNLOADING, modp);
2164 
2165 	/*
2166 	 * Null out mod_mp first, so consumers (debuggers) know not to look
2167 	 * at the module structure any more.
2168 	 */
2169 	mutex_enter(&mod_lock);
2170 	modp->mod_mp = NULL;
2171 	mutex_exit(&mod_lock);
2172 
2173 	kobj_notify(KOBJ_NOTIFY_MODUNLOADED, modp);
2174 	free_module_data(mp);
2175 }
2176 
2177 static void
2178 free_module_data(struct module *mp)
2179 {
2180 	struct module_list *lp, *tmp;
2181 	int ksyms_exported = 0;
2182 
2183 	lp = mp->head;
2184 	while (lp) {
2185 		tmp = lp;
2186 		lp = lp->next;
2187 		kobj_free((char *)tmp, sizeof (*tmp));
2188 	}
2189 
2190 	rw_enter(&ksyms_lock, RW_WRITER);
2191 	if (mp->symspace) {
2192 		if (vmem_contains(ksyms_arena, mp->symspace, mp->symsize)) {
2193 			vmem_free(ksyms_arena, mp->symspace, mp->symsize);
2194 			ksyms_exported = 1;
2195 		} else {
2196 			if (mp->flags & KOBJ_NOKSYMS)
2197 				ksyms_exported = 1;
2198 			kobj_free(mp->symspace, mp->symsize);
2199 		}
2200 	}
2201 	rw_exit(&ksyms_lock);
2202 
2203 	if (mp->ctfdata) {
2204 		if (vmem_contains(ctf_arena, mp->ctfdata, mp->ctfsize))
2205 			vmem_free(ctf_arena, mp->ctfdata, mp->ctfsize);
2206 		else
2207 			kobj_free(mp->ctfdata, mp->ctfsize);
2208 	}
2209 
2210 	if (mp->sigdata)
2211 		kobj_free(mp->sigdata, mp->sigsize);
2212 
2213 	/*
2214 	 * We did not get far enough into kobj_export_ksyms() to free allocated
2215 	 * buffers because we encounted error conditions. Free the buffers.
2216 	 */
2217 	if ((ksyms_exported == 0) && (mp->shdrs != NULL)) {
2218 		uint_t shn;
2219 		Shdr *shp;
2220 
2221 		for (shn = 1; shn < mp->hdr.e_shnum; shn++) {
2222 			shp = (Shdr *)(mp->shdrs + shn * mp->hdr.e_shentsize);
2223 			switch (shp->sh_type) {
2224 			case SHT_RELA:
2225 			case SHT_REL:
2226 				if (shp->sh_addr != 0)
2227 					kobj_free((void *)shp->sh_addr,
2228 					    shp->sh_size);
2229 				break;
2230 			}
2231 		}
2232 err_free_done:
2233 		if (!(mp->flags & KOBJ_PRIM)) {
2234 			kobj_free(mp->shdrs,
2235 			    mp->hdr.e_shentsize * mp->hdr.e_shnum);
2236 		}
2237 	}
2238 
2239 	if (mp->bss)
2240 		vmem_free(data_arena, (void *)mp->bss, mp->bss_size);
2241 
2242 	if (mp->fbt_tab)
2243 		kobj_texthole_free(mp->fbt_tab, mp->fbt_size);
2244 
2245 	if (mp->textwin_base)
2246 		kobj_textwin_free(mp);
2247 
2248 	if (mp->sdt_probes != NULL) {
2249 		sdt_probedesc_t *sdp = mp->sdt_probes, *next;
2250 
2251 		while (sdp != NULL) {
2252 			next = sdp->sdpd_next;
2253 			kobj_free(sdp->sdpd_name, strlen(sdp->sdpd_name) + 1);
2254 			kobj_free(sdp, sizeof (sdt_probedesc_t));
2255 			sdp = next;
2256 		}
2257 	}
2258 
2259 	if (mp->sdt_tab)
2260 		kobj_texthole_free(mp->sdt_tab, mp->sdt_size);
2261 	if (mp->text)
2262 		vmem_free(text_arena, mp->text, mp->text_size);
2263 	if (mp->data)
2264 		vmem_free(data_arena, mp->data, mp->data_size);
2265 	if (mp->depends_on)
2266 		kobj_free(mp->depends_on, strlen(mp->depends_on)+1);
2267 	if (mp->filename)
2268 		kobj_free(mp->filename, strlen(mp->filename)+1);
2269 
2270 	kobj_free((char *)mp, sizeof (*mp));
2271 }
2272 
2273 static int
2274 get_progbits(struct module *mp, struct _buf *file)
2275 {
2276 	struct proginfo *tp, *dp, *sdp;
2277 	Shdr *shp;
2278 	reloc_dest_t dest = NULL;
2279 	uintptr_t bits_ptr;
2280 	uintptr_t text = 0, data, textptr;
2281 	uint_t shn;
2282 	int err = -1;
2283 
2284 	tp = kobj_zalloc(sizeof (struct proginfo), KM_WAIT|KM_TMP);
2285 	dp = kobj_zalloc(sizeof (struct proginfo), KM_WAIT|KM_TMP);
2286 	sdp = kobj_zalloc(sizeof (struct proginfo), KM_WAIT|KM_TMP);
2287 	/*
2288 	 * loop through sections to find out how much space we need
2289 	 * for text, data, (also bss that is already assigned)
2290 	 */
2291 	if (get_progbits_size(mp, tp, dp, sdp) < 0)
2292 		goto done;
2293 
2294 	mp->text_size = tp->size;
2295 	mp->data_size = dp->size;
2296 
2297 	if (standalone) {
2298 		caddr_t limit = _data;
2299 
2300 		if (lg_pagesize && _text + lg_pagesize < limit)
2301 			limit = _text + lg_pagesize;
2302 
2303 		mp->text = kobj_segbrk(&_etext, mp->text_size,
2304 		    tp->align, limit);
2305 		/*
2306 		 * If we can't grow the text segment, try the
2307 		 * data segment before failing.
2308 		 */
2309 		if (mp->text == NULL) {
2310 			mp->text = kobj_segbrk(&_edata, mp->text_size,
2311 			    tp->align, 0);
2312 		}
2313 
2314 		mp->data = kobj_segbrk(&_edata, mp->data_size, dp->align, 0);
2315 
2316 		if (mp->text == NULL || mp->data == NULL)
2317 			goto done;
2318 
2319 	} else {
2320 		if (text_arena == NULL)
2321 			kobj_vmem_init(&text_arena, &data_arena);
2322 
2323 		/*
2324 		 * some architectures may want to load the module on a
2325 		 * page that is currently read only. It may not be
2326 		 * possible for those architectures to remap their page
2327 		 * on the fly. So we provide a facility for them to hang
2328 		 * a private hook where the memory they assign the module
2329 		 * is not the actual place where the module loads.
2330 		 *
2331 		 * In this case there are two addresses that deal with the
2332 		 * modload.
2333 		 * 1) the final destination of the module
2334 		 * 2) the address that is used to view the newly
2335 		 * loaded module until all the relocations relative to 1
2336 		 * above are completed.
2337 		 *
2338 		 * That is what dest is used for below.
2339 		 */
2340 		mp->text_size += tp->align;
2341 		mp->data_size += dp->align;
2342 
2343 		mp->text = kobj_text_alloc(text_arena, mp->text_size);
2344 
2345 		/*
2346 		 * a remap is taking place. Align the text ptr relative
2347 		 * to the secondary mapping. That is where the bits will
2348 		 * be read in.
2349 		 */
2350 		if (kvseg.s_base != NULL && !vmem_contains(heaptext_arena,
2351 		    mp->text, mp->text_size)) {
2352 			off_t	off = (uintptr_t)mp->text & PAGEOFFSET;
2353 			size_t	size = P2ROUNDUP(mp->text_size + off, PAGESIZE);
2354 			caddr_t	map = vmem_alloc(heap_arena, size, VM_SLEEP);
2355 			caddr_t orig = mp->text - off;
2356 			pgcnt_t pages = size / PAGESIZE;
2357 
2358 			dest = (reloc_dest_t)(map + off);
2359 			text = ALIGN((uintptr_t)dest, tp->align);
2360 
2361 			while (pages--) {
2362 				hat_devload(kas.a_hat, map, PAGESIZE,
2363 				    hat_getpfnum(kas.a_hat, orig),
2364 				    PROT_READ | PROT_WRITE | PROT_EXEC,
2365 				    HAT_LOAD_NOCONSIST | HAT_LOAD_LOCK);
2366 				map += PAGESIZE;
2367 				orig += PAGESIZE;
2368 			}
2369 			/*
2370 			 * Since we set up a non-cacheable mapping, we need
2371 			 * to flush any old entries in the cache that might
2372 			 * be left around from the read-only mapping.
2373 			 */
2374 			dcache_flushall();
2375 		}
2376 		if (mp->data_size)
2377 			mp->data = vmem_alloc(data_arena, mp->data_size,
2378 			    VM_SLEEP | VM_BESTFIT);
2379 	}
2380 	textptr = (uintptr_t)mp->text;
2381 	textptr = ALIGN(textptr, tp->align);
2382 	mp->destination = dest;
2383 
2384 	/*
2385 	 * This is the case where a remap is not being done.
2386 	 */
2387 	if (text == 0)
2388 		text = ALIGN((uintptr_t)mp->text, tp->align);
2389 	data = ALIGN((uintptr_t)mp->data, dp->align);
2390 
2391 	/* now loop though sections assigning addresses and loading the data */
2392 	for (shn = 1; shn < mp->hdr.e_shnum; shn++) {
2393 		shp = (Shdr *)(mp->shdrs + shn * mp->hdr.e_shentsize);
2394 		if (!(shp->sh_flags & SHF_ALLOC))
2395 			continue;
2396 
2397 		if ((shp->sh_flags & SHF_WRITE) == 0)
2398 			bits_ptr = text;
2399 		else
2400 			bits_ptr = data;
2401 
2402 		bits_ptr = ALIGN(bits_ptr, shp->sh_addralign);
2403 
2404 		if (shp->sh_type == SHT_NOBITS) {
2405 			/*
2406 			 * Zero bss.
2407 			 */
2408 			bzero((caddr_t)bits_ptr, shp->sh_size);
2409 			shp->sh_type = SHT_PROGBITS;
2410 		} else {
2411 			if (kobj_read_file(file, (char *)bits_ptr,
2412 			    shp->sh_size, shp->sh_offset) < 0)
2413 				goto done;
2414 		}
2415 
2416 		if (shp->sh_flags & SHF_WRITE) {
2417 			shp->sh_addr = bits_ptr;
2418 		} else {
2419 			textptr = ALIGN(textptr, shp->sh_addralign);
2420 			shp->sh_addr = textptr;
2421 			textptr += shp->sh_size;
2422 		}
2423 
2424 		bits_ptr += shp->sh_size;
2425 		if ((shp->sh_flags & SHF_WRITE) == 0)
2426 			text = bits_ptr;
2427 		else
2428 			data = bits_ptr;
2429 	}
2430 
2431 	err = 0;
2432 done:
2433 	/*
2434 	 * Free and mark as freed the section headers here so that
2435 	 * free_module_data() does not have to worry about this buffer.
2436 	 *
2437 	 * This buffer is freed here because one of the possible reasons
2438 	 * for error is a section with non-zero sh_addr and in that case
2439 	 * free_module_data() would have no way of recognizing that this
2440 	 * buffer was unallocated.
2441 	 */
2442 	if (err != 0) {
2443 		kobj_free(mp->shdrs, mp->hdr.e_shentsize * mp->hdr.e_shnum);
2444 		mp->shdrs = NULL;
2445 	}
2446 
2447 	(void) kobj_free(tp, sizeof (struct proginfo));
2448 	(void) kobj_free(dp, sizeof (struct proginfo));
2449 	(void) kobj_free(sdp, sizeof (struct proginfo));
2450 
2451 	return (err);
2452 }
2453 
2454 /*
2455  * Go through suppress_sym_list to see if "multiply defined"
2456  * warning of this symbol should be suppressed.  Return 1 if
2457  * warning should be suppressed, 0 otherwise.
2458  */
2459 static int
2460 kobj_suppress_warning(char *symname)
2461 {
2462 	int	i;
2463 
2464 	for (i = 0; suppress_sym_list[i] != NULL; i++) {
2465 		if (strcmp(suppress_sym_list[i], symname) == 0)
2466 			return (1);
2467 	}
2468 
2469 	return (0);
2470 }
2471 
2472 static int
2473 get_syms(struct module *mp, struct _buf *file)
2474 {
2475 	uint_t		shn;
2476 	Shdr	*shp;
2477 	uint_t		i;
2478 	Sym	*sp, *ksp;
2479 	char		*symname;
2480 	int		dosymtab = 0;
2481 
2482 	/*
2483 	 * Find the interesting sections.
2484 	 */
2485 	for (shn = 1; shn < mp->hdr.e_shnum; shn++) {
2486 		shp = (Shdr *)(mp->shdrs + shn * mp->hdr.e_shentsize);
2487 		switch (shp->sh_type) {
2488 		case SHT_SYMTAB:
2489 			mp->symtbl_section = shn;
2490 			mp->symhdr = shp;
2491 			dosymtab++;
2492 			break;
2493 
2494 		case SHT_RELA:
2495 		case SHT_REL:
2496 			/*
2497 			 * Already loaded.
2498 			 */
2499 			if (shp->sh_addr)
2500 				continue;
2501 
2502 			/* KM_TMP since kobj_free'd in do_relocations */
2503 			shp->sh_addr = (Addr)
2504 			    kobj_alloc(shp->sh_size, KM_WAIT|KM_TMP);
2505 
2506 			if (kobj_read_file(file, (char *)shp->sh_addr,
2507 			    shp->sh_size, shp->sh_offset) < 0) {
2508 				_kobj_printf(ops, "krtld: get_syms: %s, ",
2509 				    mp->filename);
2510 				_kobj_printf(ops, "error reading section %d\n",
2511 				    shn);
2512 				return (-1);
2513 			}
2514 			break;
2515 		}
2516 	}
2517 
2518 	/*
2519 	 * This is true for a stripped executable.  In the case of
2520 	 * 'unix' it can be stripped but it still contains the SHT_DYNSYM,
2521 	 * and since that symbol information is still present everything
2522 	 * is just fine.
2523 	 */
2524 	if (!dosymtab) {
2525 		if (mp->flags & KOBJ_EXEC)
2526 			return (0);
2527 		_kobj_printf(ops, "krtld: get_syms: %s ",
2528 		    mp->filename);
2529 		_kobj_printf(ops, "no SHT_SYMTAB symbol table found\n");
2530 		return (-1);
2531 	}
2532 
2533 	/*
2534 	 * get the associated string table header
2535 	 */
2536 	if ((mp->symhdr == 0) || (mp->symhdr->sh_link >= mp->hdr.e_shnum))
2537 		return (-1);
2538 	mp->strhdr = (Shdr *)
2539 	    (mp->shdrs + mp->symhdr->sh_link * mp->hdr.e_shentsize);
2540 
2541 	mp->nsyms = mp->symhdr->sh_size / mp->symhdr->sh_entsize;
2542 	mp->hashsize = kobj_gethashsize(mp->nsyms);
2543 
2544 	/*
2545 	 * Allocate space for the symbol table, buckets, chains, and strings.
2546 	 */
2547 	mp->symsize = mp->symhdr->sh_size +
2548 	    (mp->hashsize + mp->nsyms) * sizeof (symid_t) + mp->strhdr->sh_size;
2549 	mp->symspace = kobj_zalloc(mp->symsize, KM_WAIT|KM_SCRATCH);
2550 
2551 	mp->symtbl = mp->symspace;
2552 	mp->buckets = (symid_t *)(mp->symtbl + mp->symhdr->sh_size);
2553 	mp->chains = mp->buckets + mp->hashsize;
2554 	mp->strings = (char *)(mp->chains + mp->nsyms);
2555 
2556 	if (kobj_read_file(file, mp->symtbl,
2557 	    mp->symhdr->sh_size, mp->symhdr->sh_offset) < 0 ||
2558 	    kobj_read_file(file, mp->strings,
2559 	    mp->strhdr->sh_size, mp->strhdr->sh_offset) < 0)
2560 		return (-1);
2561 
2562 	/*
2563 	 * loop through the symbol table adjusting values to account
2564 	 * for where each section got loaded into memory.  Also
2565 	 * fill in the hash table.
2566 	 */
2567 	for (i = 1; i < mp->nsyms; i++) {
2568 		sp = (Sym *)(mp->symtbl + i * mp->symhdr->sh_entsize);
2569 		if (sp->st_shndx < SHN_LORESERVE) {
2570 			if (sp->st_shndx >= mp->hdr.e_shnum) {
2571 				_kobj_printf(ops, "%s bad shndx ",
2572 				    file->_name);
2573 				_kobj_printf(ops, "in symbol %d\n", i);
2574 				return (-1);
2575 			}
2576 			shp = (Shdr *)
2577 			    (mp->shdrs +
2578 			    sp->st_shndx * mp->hdr.e_shentsize);
2579 			if (!(mp->flags & KOBJ_EXEC))
2580 				sp->st_value += shp->sh_addr;
2581 		}
2582 
2583 		if (sp->st_name == 0 || sp->st_shndx == SHN_UNDEF)
2584 			continue;
2585 		if (sp->st_name >= mp->strhdr->sh_size)
2586 			return (-1);
2587 
2588 		symname = mp->strings + sp->st_name;
2589 
2590 		if (!(mp->flags & KOBJ_EXEC) &&
2591 		    ELF_ST_BIND(sp->st_info) == STB_GLOBAL) {
2592 			ksp = kobj_lookup_all(mp, symname, 0);
2593 
2594 			if (ksp && ELF_ST_BIND(ksp->st_info) == STB_GLOBAL &&
2595 			    !kobj_suppress_warning(symname) &&
2596 			    sp->st_shndx != SHN_UNDEF &&
2597 			    sp->st_shndx != SHN_COMMON &&
2598 			    ksp->st_shndx != SHN_UNDEF &&
2599 			    ksp->st_shndx != SHN_COMMON) {
2600 				/*
2601 				 * Unless this symbol is a stub, it's multiply
2602 				 * defined.  Multiply-defined symbols are
2603 				 * usually bad, but some objects (kmdb) have
2604 				 * a legitimate need to have their own
2605 				 * copies of common functions.
2606 				 */
2607 				if ((standalone ||
2608 				    ksp->st_value < (uintptr_t)stubs_base ||
2609 				    ksp->st_value >= (uintptr_t)stubs_end) &&
2610 				    !(mp->flags & KOBJ_IGNMULDEF)) {
2611 					_kobj_printf(ops,
2612 					    "%s symbol ", file->_name);
2613 					_kobj_printf(ops,
2614 					    "%s multiply defined\n", symname);
2615 				}
2616 			}
2617 		}
2618 
2619 		sym_insert(mp, symname, i);
2620 	}
2621 
2622 	return (0);
2623 }
2624 
2625 static int
2626 get_ctf(struct module *mp, struct _buf *file)
2627 {
2628 	char *shstrtab, *ctfdata;
2629 	size_t shstrlen;
2630 	Shdr *shp;
2631 	uint_t i;
2632 
2633 	if (_moddebug & MODDEBUG_NOCTF)
2634 		return (0); /* do not attempt to even load CTF data */
2635 
2636 	if (mp->hdr.e_shstrndx >= mp->hdr.e_shnum) {
2637 		_kobj_printf(ops, "krtld: get_ctf: %s, ",
2638 		    mp->filename);
2639 		_kobj_printf(ops, "corrupt e_shstrndx %u\n",
2640 		    mp->hdr.e_shstrndx);
2641 		return (-1);
2642 	}
2643 
2644 	shp = (Shdr *)(mp->shdrs + mp->hdr.e_shstrndx * mp->hdr.e_shentsize);
2645 	shstrlen = shp->sh_size;
2646 	shstrtab = kobj_alloc(shstrlen, KM_WAIT|KM_TMP);
2647 
2648 	if (kobj_read_file(file, shstrtab, shstrlen, shp->sh_offset) < 0) {
2649 		_kobj_printf(ops, "krtld: get_ctf: %s, ",
2650 		    mp->filename);
2651 		_kobj_printf(ops, "error reading section %u\n",
2652 		    mp->hdr.e_shstrndx);
2653 		kobj_free(shstrtab, shstrlen);
2654 		return (-1);
2655 	}
2656 
2657 	for (i = 0; i < mp->hdr.e_shnum; i++) {
2658 		shp = (Shdr *)(mp->shdrs + i * mp->hdr.e_shentsize);
2659 
2660 		if (shp->sh_size != 0 && shp->sh_name < shstrlen &&
2661 		    strcmp(shstrtab + shp->sh_name, ".SUNW_ctf") == 0) {
2662 			ctfdata = kobj_alloc(shp->sh_size, KM_WAIT|KM_SCRATCH);
2663 
2664 			if (kobj_read_file(file, ctfdata, shp->sh_size,
2665 			    shp->sh_offset) < 0) {
2666 				_kobj_printf(ops, "krtld: get_ctf: %s, error "
2667 				    "reading .SUNW_ctf data\n", mp->filename);
2668 				kobj_free(ctfdata, shp->sh_size);
2669 				kobj_free(shstrtab, shstrlen);
2670 				return (-1);
2671 			}
2672 
2673 			mp->ctfdata = ctfdata;
2674 			mp->ctfsize = shp->sh_size;
2675 			break;
2676 		}
2677 	}
2678 
2679 	kobj_free(shstrtab, shstrlen);
2680 	return (0);
2681 }
2682 
2683 #define	SHA1_DIGEST_LENGTH	20	/* SHA1 digest length in bytes */
2684 
2685 /*
2686  * Return the hash of the ELF sections that are memory resident.
2687  * i.e. text and data.  We skip a SHT_NOBITS section since it occupies
2688  * no space in the file. We use SHA1 here since libelfsign uses
2689  * it and both places need to use the same algorithm.
2690  */
2691 static void
2692 crypto_es_hash(struct module *mp, char *hash, char *shstrtab)
2693 {
2694 	uint_t shn;
2695 	Shdr *shp;
2696 	SHA1_CTX ctx;
2697 
2698 	SHA1Init(&ctx);
2699 
2700 	for (shn = 1; shn < mp->hdr.e_shnum; shn++) {
2701 		shp = (Shdr *)(mp->shdrs + shn * mp->hdr.e_shentsize);
2702 		if (!(shp->sh_flags & SHF_ALLOC) || shp->sh_size == 0)
2703 			continue;
2704 
2705 		/*
2706 		 * The check should ideally be shp->sh_type == SHT_NOBITS.
2707 		 * However, we can't do that check here as get_progbits()
2708 		 * resets the type.
2709 		 */
2710 		if (strcmp(shstrtab + shp->sh_name, ".bss") == 0)
2711 			continue;
2712 #ifdef	KOBJ_DEBUG
2713 		if (kobj_debug & D_DEBUG)
2714 			_kobj_printf(ops,
2715 			    "krtld: crypto_es_hash: updating hash with"
2716 			    " %s data size=%d\n", shstrtab + shp->sh_name,
2717 			    shp->sh_size);
2718 #endif
2719 		ASSERT(shp->sh_addr != NULL);
2720 		SHA1Update(&ctx, (const uint8_t *)shp->sh_addr, shp->sh_size);
2721 	}
2722 
2723 	SHA1Final((uchar_t *)hash, &ctx);
2724 }
2725 
2726 /*
2727  * Get the .SUNW_signature section for the module, it it exists.
2728  *
2729  * This section exists only for crypto modules. None of the
2730  * primary modules have this section currently.
2731  */
2732 static void
2733 get_signature(struct module *mp, struct _buf *file)
2734 {
2735 	char *shstrtab, *sigdata = NULL;
2736 	size_t shstrlen;
2737 	Shdr *shp;
2738 	uint_t i;
2739 
2740 	if (mp->hdr.e_shstrndx >= mp->hdr.e_shnum) {
2741 		_kobj_printf(ops, "krtld: get_signature: %s, ",
2742 		    mp->filename);
2743 		_kobj_printf(ops, "corrupt e_shstrndx %u\n",
2744 		    mp->hdr.e_shstrndx);
2745 		return;
2746 	}
2747 
2748 	shp = (Shdr *)(mp->shdrs + mp->hdr.e_shstrndx * mp->hdr.e_shentsize);
2749 	shstrlen = shp->sh_size;
2750 	shstrtab = kobj_alloc(shstrlen, KM_WAIT|KM_TMP);
2751 
2752 	if (kobj_read_file(file, shstrtab, shstrlen, shp->sh_offset) < 0) {
2753 		_kobj_printf(ops, "krtld: get_signature: %s, ",
2754 		    mp->filename);
2755 		_kobj_printf(ops, "error reading section %u\n",
2756 		    mp->hdr.e_shstrndx);
2757 		kobj_free(shstrtab, shstrlen);
2758 		return;
2759 	}
2760 
2761 	for (i = 0; i < mp->hdr.e_shnum; i++) {
2762 		shp = (Shdr *)(mp->shdrs + i * mp->hdr.e_shentsize);
2763 		if (shp->sh_size != 0 && shp->sh_name < shstrlen &&
2764 		    strcmp(shstrtab + shp->sh_name,
2765 		    ELF_SIGNATURE_SECTION) == 0) {
2766 			filesig_vers_t filesig_version;
2767 			size_t sigsize = shp->sh_size + SHA1_DIGEST_LENGTH;
2768 			sigdata = kobj_alloc(sigsize, KM_WAIT|KM_SCRATCH);
2769 
2770 			if (kobj_read_file(file, sigdata, shp->sh_size,
2771 			    shp->sh_offset) < 0) {
2772 				_kobj_printf(ops, "krtld: get_signature: %s,"
2773 				    " error reading .SUNW_signature data\n",
2774 				    mp->filename);
2775 				kobj_free(sigdata, sigsize);
2776 				kobj_free(shstrtab, shstrlen);
2777 				return;
2778 			}
2779 			filesig_version = ((struct filesignatures *)sigdata)->
2780 			    filesig_sig.filesig_version;
2781 			if (!(filesig_version == FILESIG_VERSION1 ||
2782 			    filesig_version == FILESIG_VERSION3)) {
2783 				/* skip versions we don't understand */
2784 				kobj_free(sigdata, sigsize);
2785 				kobj_free(shstrtab, shstrlen);
2786 				return;
2787 			}
2788 
2789 			mp->sigdata = sigdata;
2790 			mp->sigsize = sigsize;
2791 			break;
2792 		}
2793 	}
2794 
2795 	if (sigdata != NULL) {
2796 		crypto_es_hash(mp, sigdata + shp->sh_size, shstrtab);
2797 	}
2798 
2799 	kobj_free(shstrtab, shstrlen);
2800 }
2801 
2802 static void
2803 add_dependent(struct module *mp, struct module *dep)
2804 {
2805 	struct module_list *lp;
2806 
2807 	for (lp = mp->head; lp; lp = lp->next) {
2808 		if (lp->mp == dep)
2809 			return;	/* already on the list */
2810 	}
2811 
2812 	if (lp == NULL) {
2813 		lp = kobj_zalloc(sizeof (*lp), KM_WAIT);
2814 
2815 		lp->mp = dep;
2816 		lp->next = NULL;
2817 		if (mp->tail)
2818 			mp->tail->next = lp;
2819 		else
2820 			mp->head = lp;
2821 		mp->tail = lp;
2822 	}
2823 }
2824 
2825 static int
2826 do_dependents(struct modctl *modp, char *modname, size_t modnamelen)
2827 {
2828 	struct module *mp;
2829 	struct modctl *req;
2830 	char *d, *p, *q;
2831 	int c;
2832 	char *err_modname = NULL;
2833 
2834 	mp = modp->mod_mp;
2835 
2836 	if ((p = mp->depends_on) == NULL)
2837 		return (0);
2838 
2839 	for (;;) {
2840 		/*
2841 		 * Skip space.
2842 		 */
2843 		while (*p && (*p == ' ' || *p == '\t'))
2844 			p++;
2845 		/*
2846 		 * Get module name.
2847 		 */
2848 		d = p;
2849 		q = modname;
2850 		c = 0;
2851 		while (*p && *p != ' ' && *p != '\t') {
2852 			if (c < modnamelen - 1) {
2853 				*q++ = *p;
2854 				c++;
2855 			}
2856 			p++;
2857 		}
2858 
2859 		if (q == modname)
2860 			break;
2861 
2862 		if (c == modnamelen - 1) {
2863 			char *dep = kobj_alloc(p - d + 1, KM_WAIT|KM_TMP);
2864 
2865 			(void) strncpy(dep, d,  p - d + 1);
2866 			dep[p - d] = '\0';
2867 
2868 			_kobj_printf(ops, "%s: dependency ", modp->mod_modname);
2869 			_kobj_printf(ops, "'%s' too long ", dep);
2870 			_kobj_printf(ops, "(max %d chars)\n", modnamelen);
2871 
2872 			kobj_free(dep, p - d + 1);
2873 
2874 			return (-1);
2875 		}
2876 
2877 		*q = '\0';
2878 		if ((req = mod_load_requisite(modp, modname)) == NULL) {
2879 #ifndef	KOBJ_DEBUG
2880 			if (_moddebug & MODDEBUG_LOADMSG) {
2881 #endif	/* KOBJ_DEBUG */
2882 				_kobj_printf(ops,
2883 				    "%s: unable to resolve dependency, ",
2884 				    modp->mod_modname);
2885 				_kobj_printf(ops, "cannot load module '%s'\n",
2886 				    modname);
2887 #ifndef	KOBJ_DEBUG
2888 			}
2889 #endif	/* KOBJ_DEBUG */
2890 			if (err_modname == NULL) {
2891 				/*
2892 				 * This must be the same size as the modname
2893 				 * one.
2894 				 */
2895 				err_modname = kobj_zalloc(MODMAXNAMELEN,
2896 				    KM_WAIT);
2897 
2898 				/*
2899 				 * We can use strcpy() here without fearing
2900 				 * the NULL terminator because the size of
2901 				 * err_modname is the same as one of modname,
2902 				 * and it's filled with zeros.
2903 				 */
2904 				(void) strcpy(err_modname, modname);
2905 			}
2906 			continue;
2907 		}
2908 
2909 		add_dependent(mp, req->mod_mp);
2910 		mod_release_mod(req);
2911 
2912 	}
2913 
2914 	if (err_modname != NULL) {
2915 		/*
2916 		 * Copy the first module name where you detect an error to keep
2917 		 * its behavior the same as before.
2918 		 * This way keeps minimizing the memory use for error
2919 		 * modules, and this might be important at boot time because
2920 		 * the memory usage is a crucial factor for booting in most
2921 		 * cases. You can expect more verbose messages when using
2922 		 * a debug kernel or setting a bit in moddebug.
2923 		 */
2924 		bzero(modname, MODMAXNAMELEN);
2925 		(void) strcpy(modname, err_modname);
2926 		kobj_free(err_modname, MODMAXNAMELEN);
2927 		return (-1);
2928 	}
2929 
2930 	return (0);
2931 }
2932 
2933 static int
2934 do_common(struct module *mp)
2935 {
2936 	int err;
2937 
2938 	/*
2939 	 * first time through, assign all symbols defined in other
2940 	 * modules, and count up how much common space will be needed
2941 	 * (bss_size and bss_align)
2942 	 */
2943 	if ((err = do_symbols(mp, 0)) < 0)
2944 		return (err);
2945 	/*
2946 	 * increase bss_size by the maximum delta that could be
2947 	 * computed by the ALIGN below
2948 	 */
2949 	mp->bss_size += mp->bss_align;
2950 	if (mp->bss_size) {
2951 		if (standalone)
2952 			mp->bss = (uintptr_t)kobj_segbrk(&_edata, mp->bss_size,
2953 			    MINALIGN, 0);
2954 		else
2955 			mp->bss = (uintptr_t)vmem_alloc(data_arena,
2956 			    mp->bss_size, VM_SLEEP | VM_BESTFIT);
2957 		bzero((void *)mp->bss, mp->bss_size);
2958 		/* now assign addresses to all common symbols */
2959 		if ((err = do_symbols(mp, ALIGN(mp->bss, mp->bss_align))) < 0)
2960 			return (err);
2961 	}
2962 	return (0);
2963 }
2964 
2965 static int
2966 do_symbols(struct module *mp, Elf64_Addr bss_base)
2967 {
2968 	int bss_align;
2969 	uintptr_t bss_ptr;
2970 	int err;
2971 	int i;
2972 	Sym *sp, *sp1;
2973 	char *name;
2974 	int assign;
2975 	int resolved = 1;
2976 
2977 	/*
2978 	 * Nothing left to do (optimization).
2979 	 */
2980 	if (mp->flags & KOBJ_RESOLVED)
2981 		return (0);
2982 
2983 	assign = (bss_base) ? 1 : 0;
2984 	bss_ptr = bss_base;
2985 	bss_align = 0;
2986 	err = 0;
2987 
2988 	for (i = 1; i < mp->nsyms; i++) {
2989 		sp = (Sym *)(mp->symtbl + mp->symhdr->sh_entsize * i);
2990 		/*
2991 		 * we know that st_name is in bounds, since get_sections
2992 		 * has already checked all of the symbols
2993 		 */
2994 		name = mp->strings + sp->st_name;
2995 		if (sp->st_shndx != SHN_UNDEF && sp->st_shndx != SHN_COMMON)
2996 			continue;
2997 #if defined(__sparc)
2998 		/*
2999 		 * Register symbols are ignored in the kernel
3000 		 */
3001 		if (ELF_ST_TYPE(sp->st_info) == STT_SPARC_REGISTER) {
3002 			if (*name != '\0') {
3003 				_kobj_printf(ops, "%s: named REGISTER symbol ",
3004 				    mp->filename);
3005 				_kobj_printf(ops, "not supported '%s'\n",
3006 				    name);
3007 				err = DOSYM_UNDEF;
3008 			}
3009 			continue;
3010 		}
3011 #endif	/* __sparc */
3012 		/*
3013 		 * TLS symbols are ignored in the kernel
3014 		 */
3015 		if (ELF_ST_TYPE(sp->st_info) == STT_TLS) {
3016 			_kobj_printf(ops, "%s: TLS symbol ",
3017 			    mp->filename);
3018 			_kobj_printf(ops, "not supported '%s'\n",
3019 			    name);
3020 			err = DOSYM_UNDEF;
3021 			continue;
3022 		}
3023 
3024 		if (ELF_ST_BIND(sp->st_info) != STB_LOCAL) {
3025 			if ((sp1 = kobj_lookup_all(mp, name, 0)) != NULL) {
3026 				sp->st_shndx = SHN_ABS;
3027 				sp->st_value = sp1->st_value;
3028 				continue;
3029 			}
3030 		}
3031 
3032 		if (sp->st_shndx == SHN_UNDEF) {
3033 			resolved = 0;
3034 
3035 			if (strncmp(name, sdt_prefix, strlen(sdt_prefix)) == 0)
3036 				continue;
3037 
3038 			/*
3039 			 * If it's not a weak reference and it's
3040 			 * not a primary object, it's an error.
3041 			 * (Primary objects may take more than
3042 			 * one pass to resolve)
3043 			 */
3044 			if (!(mp->flags & KOBJ_PRIM) &&
3045 			    ELF_ST_BIND(sp->st_info) != STB_WEAK) {
3046 				_kobj_printf(ops, "%s: undefined symbol",
3047 				    mp->filename);
3048 				_kobj_printf(ops, " '%s'\n", name);
3049 				/*
3050 				 * Try to determine whether this symbol
3051 				 * represents a dependency on obsolete
3052 				 * unsafe driver support.  This is just
3053 				 * to make the warning more informative.
3054 				 */
3055 				if (strcmp(name, "sleep") == 0 ||
3056 				    strcmp(name, "unsleep") == 0 ||
3057 				    strcmp(name, "wakeup") == 0 ||
3058 				    strcmp(name, "bsd_compat_ioctl") == 0 ||
3059 				    strcmp(name, "unsafe_driver") == 0 ||
3060 				    strncmp(name, "spl", 3) == 0 ||
3061 				    strncmp(name, "i_ddi_spl", 9) == 0)
3062 					err = DOSYM_UNSAFE;
3063 				if (err == 0)
3064 					err = DOSYM_UNDEF;
3065 			}
3066 			continue;
3067 		}
3068 		/*
3069 		 * It's a common symbol - st_value is the
3070 		 * required alignment.
3071 		 */
3072 		if (sp->st_value > bss_align)
3073 			bss_align = sp->st_value;
3074 		bss_ptr = ALIGN(bss_ptr, sp->st_value);
3075 		if (assign) {
3076 			sp->st_shndx = SHN_ABS;
3077 			sp->st_value = bss_ptr;
3078 		}
3079 		bss_ptr += sp->st_size;
3080 	}
3081 	if (err)
3082 		return (err);
3083 	if (assign == 0 && mp->bss == NULL) {
3084 		mp->bss_align = bss_align;
3085 		mp->bss_size = bss_ptr;
3086 	} else if (resolved) {
3087 		mp->flags |= KOBJ_RESOLVED;
3088 	}
3089 
3090 	return (0);
3091 }
3092 
3093 uint_t
3094 kobj_hash_name(const char *p)
3095 {
3096 	uint_t g;
3097 	uint_t hval;
3098 
3099 	hval = 0;
3100 	while (*p) {
3101 		hval = (hval << 4) + *p++;
3102 		if ((g = (hval & 0xf0000000)) != 0)
3103 			hval ^= g >> 24;
3104 		hval &= ~g;
3105 	}
3106 	return (hval);
3107 }
3108 
3109 /* look for name in all modules */
3110 uintptr_t
3111 kobj_getsymvalue(char *name, int kernelonly)
3112 {
3113 	Sym		*sp;
3114 	struct modctl	*modp;
3115 	struct module	*mp;
3116 	uintptr_t	value = 0;
3117 
3118 	if ((sp = kobj_lookup_kernel(name)) != NULL)
3119 		return ((uintptr_t)sp->st_value);
3120 
3121 	if (kernelonly)
3122 		return (0);	/* didn't find it in the kernel so give up */
3123 
3124 	mutex_enter(&mod_lock);
3125 	modp = &modules;
3126 	do {
3127 		mp = (struct module *)modp->mod_mp;
3128 		if (mp && !(mp->flags & KOBJ_PRIM) && modp->mod_loaded &&
3129 		    (sp = lookup_one(mp, name))) {
3130 			value = (uintptr_t)sp->st_value;
3131 			break;
3132 		}
3133 	} while ((modp = modp->mod_next) != &modules);
3134 	mutex_exit(&mod_lock);
3135 	return (value);
3136 }
3137 
3138 /* look for a symbol near value. */
3139 char *
3140 kobj_getsymname(uintptr_t value, ulong_t *offset)
3141 {
3142 	char *name = NULL;
3143 	struct modctl *modp;
3144 
3145 	struct modctl_list *lp;
3146 	struct module *mp;
3147 
3148 	/*
3149 	 * Loop through the primary kernel modules.
3150 	 */
3151 	for (lp = kobj_lm_lookup(KOBJ_LM_PRIMARY); lp; lp = lp->modl_next) {
3152 		mp = mod(lp);
3153 
3154 		if ((name = kobj_searchsym(mp, value, offset)) != NULL)
3155 			return (name);
3156 	}
3157 
3158 	mutex_enter(&mod_lock);
3159 	modp = &modules;
3160 	do {
3161 		mp = (struct module *)modp->mod_mp;
3162 		if (mp && !(mp->flags & KOBJ_PRIM) && modp->mod_loaded &&
3163 		    (name = kobj_searchsym(mp, value, offset)))
3164 			break;
3165 	} while ((modp = modp->mod_next) != &modules);
3166 	mutex_exit(&mod_lock);
3167 	return (name);
3168 }
3169 
3170 /* return address of symbol and size */
3171 
3172 uintptr_t
3173 kobj_getelfsym(char *name, void *mp, int *size)
3174 {
3175 	Sym *sp;
3176 
3177 	if (mp == NULL)
3178 		sp = kobj_lookup_kernel(name);
3179 	else
3180 		sp = lookup_one(mp, name);
3181 
3182 	if (sp == NULL)
3183 		return (0);
3184 
3185 	*size = (int)sp->st_size;
3186 	return ((uintptr_t)sp->st_value);
3187 }
3188 
3189 uintptr_t
3190 kobj_lookup(struct module *mod, const char *name)
3191 {
3192 	Sym *sp;
3193 
3194 	sp = lookup_one(mod, name);
3195 
3196 	if (sp == NULL)
3197 		return (0);
3198 
3199 	return ((uintptr_t)sp->st_value);
3200 }
3201 
3202 char *
3203 kobj_searchsym(struct module *mp, uintptr_t value, ulong_t *offset)
3204 {
3205 	Sym *symtabptr;
3206 	char *strtabptr;
3207 	int symnum;
3208 	Sym *sym;
3209 	Sym *cursym;
3210 	uintptr_t curval;
3211 
3212 	*offset = (ulong_t)-1l;		/* assume not found */
3213 	cursym  = NULL;
3214 
3215 	if (kobj_addrcheck(mp, (void *)value) != 0)
3216 		return (NULL);		/* not in this module */
3217 
3218 	strtabptr  = mp->strings;
3219 	symtabptr  = (Sym *)mp->symtbl;
3220 
3221 	/*
3222 	 * Scan the module's symbol table for a symbol <= value
3223 	 */
3224 	for (symnum = 1, sym = symtabptr + 1;
3225 	    symnum < mp->nsyms; symnum++, sym = (Sym *)
3226 	    ((uintptr_t)sym + mp->symhdr->sh_entsize)) {
3227 		if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL) {
3228 			if (ELF_ST_BIND(sym->st_info) != STB_LOCAL)
3229 				continue;
3230 			if (ELF_ST_TYPE(sym->st_info) != STT_OBJECT &&
3231 			    ELF_ST_TYPE(sym->st_info) != STT_FUNC)
3232 				continue;
3233 		}
3234 
3235 		curval = (uintptr_t)sym->st_value;
3236 
3237 		if (curval > value)
3238 			continue;
3239 
3240 		/*
3241 		 * If one or both are functions...
3242 		 */
3243 		if (ELF_ST_TYPE(sym->st_info) == STT_FUNC || (cursym != NULL &&
3244 		    ELF_ST_TYPE(cursym->st_info) == STT_FUNC)) {
3245 			/* Ignore if the address is out of the bounds */
3246 			if (value - sym->st_value >= sym->st_size)
3247 				continue;
3248 
3249 			if (cursym != NULL &&
3250 			    ELF_ST_TYPE(cursym->st_info) == STT_FUNC) {
3251 				/* Prefer the function to the non-function */
3252 				if (ELF_ST_TYPE(sym->st_info) != STT_FUNC)
3253 					continue;
3254 
3255 				/* Prefer the larger of the two functions */
3256 				if (sym->st_size <= cursym->st_size)
3257 					continue;
3258 			}
3259 		} else if (value - curval >= *offset) {
3260 			continue;
3261 		}
3262 
3263 		*offset = (ulong_t)(value - curval);
3264 		cursym = sym;
3265 	}
3266 	if (cursym == NULL)
3267 		return (NULL);
3268 
3269 	return (strtabptr + cursym->st_name);
3270 }
3271 
3272 Sym *
3273 kobj_lookup_all(struct module *mp, char *name, int include_self)
3274 {
3275 	Sym *sp;
3276 	struct module_list *mlp;
3277 	struct modctl_list *clp;
3278 	struct module *mmp;
3279 
3280 	if (include_self && (sp = lookup_one(mp, name)) != NULL)
3281 		return (sp);
3282 
3283 	for (mlp = mp->head; mlp; mlp = mlp->next) {
3284 		if ((sp = lookup_one(mlp->mp, name)) != NULL &&
3285 		    ELF_ST_BIND(sp->st_info) != STB_LOCAL)
3286 			return (sp);
3287 	}
3288 
3289 	/*
3290 	 * Loop through the primary kernel modules.
3291 	 */
3292 	for (clp = kobj_lm_lookup(KOBJ_LM_PRIMARY); clp; clp = clp->modl_next) {
3293 		mmp = mod(clp);
3294 
3295 		if (mmp == NULL || mp == mmp)
3296 			continue;
3297 
3298 		if ((sp = lookup_one(mmp, name)) != NULL &&
3299 		    ELF_ST_BIND(sp->st_info) != STB_LOCAL)
3300 			return (sp);
3301 	}
3302 	return (NULL);
3303 }
3304 
3305 Sym *
3306 kobj_lookup_kernel(const char *name)
3307 {
3308 	struct modctl_list *lp;
3309 	struct module *mp;
3310 	Sym *sp;
3311 
3312 	/*
3313 	 * Loop through the primary kernel modules.
3314 	 */
3315 	for (lp = kobj_lm_lookup(KOBJ_LM_PRIMARY); lp; lp = lp->modl_next) {
3316 		mp = mod(lp);
3317 
3318 		if (mp == NULL)
3319 			continue;
3320 
3321 		if ((sp = lookup_one(mp, name)) != NULL)
3322 			return (sp);
3323 	}
3324 	return (NULL);
3325 }
3326 
3327 static Sym *
3328 lookup_one(struct module *mp, const char *name)
3329 {
3330 	symid_t *ip;
3331 	char *name1;
3332 	Sym *sp;
3333 
3334 	for (ip = &mp->buckets[kobj_hash_name(name) % mp->hashsize]; *ip;
3335 	    ip = &mp->chains[*ip]) {
3336 		sp = (Sym *)(mp->symtbl +
3337 		    mp->symhdr->sh_entsize * *ip);
3338 		name1 = mp->strings + sp->st_name;
3339 		if (strcmp(name, name1) == 0 &&
3340 		    ELF_ST_TYPE(sp->st_info) != STT_FILE &&
3341 		    sp->st_shndx != SHN_UNDEF &&
3342 		    sp->st_shndx != SHN_COMMON)
3343 			return (sp);
3344 	}
3345 	return (NULL);
3346 }
3347 
3348 /*
3349  * Lookup a given symbol pointer in the module's symbol hash.  If the symbol
3350  * is hashed, return the symbol pointer; otherwise return NULL.
3351  */
3352 static Sym *
3353 sym_lookup(struct module *mp, Sym *ksp)
3354 {
3355 	char *name = mp->strings + ksp->st_name;
3356 	symid_t *ip;
3357 	Sym *sp;
3358 
3359 	for (ip = &mp->buckets[kobj_hash_name(name) % mp->hashsize]; *ip;
3360 	    ip = &mp->chains[*ip]) {
3361 		sp = (Sym *)(mp->symtbl + mp->symhdr->sh_entsize * *ip);
3362 		if (sp == ksp)
3363 			return (ksp);
3364 	}
3365 	return (NULL);
3366 }
3367 
3368 static void
3369 sym_insert(struct module *mp, char *name, symid_t index)
3370 {
3371 	symid_t *ip;
3372 
3373 #ifdef KOBJ_DEBUG
3374 		if (kobj_debug & D_SYMBOLS) {
3375 			static struct module *lastmp = NULL;
3376 			Sym *sp;
3377 			if (lastmp != mp) {
3378 				_kobj_printf(ops,
3379 				    "krtld: symbol entry: file=%s\n",
3380 				    mp->filename);
3381 				_kobj_printf(ops,
3382 				    "krtld:\tsymndx\tvalue\t\t"
3383 				    "symbol name\n");
3384 				lastmp = mp;
3385 			}
3386 			sp = (Sym *)(mp->symtbl +
3387 			    index * mp->symhdr->sh_entsize);
3388 			_kobj_printf(ops, "krtld:\t[%3d]", index);
3389 			_kobj_printf(ops, "\t0x%lx", sp->st_value);
3390 			_kobj_printf(ops, "\t%s\n", name);
3391 		}
3392 
3393 #endif
3394 	for (ip = &mp->buckets[kobj_hash_name(name) % mp->hashsize]; *ip;
3395 	    ip = &mp->chains[*ip]) {
3396 		;
3397 	}
3398 	*ip = index;
3399 }
3400 
3401 struct modctl *
3402 kobj_boot_mod_lookup(const char *modname)
3403 {
3404 	struct modctl *mctl = kobj_modules;
3405 
3406 	do {
3407 		if (strcmp(modname, mctl->mod_modname) == 0)
3408 			return (mctl);
3409 	} while ((mctl = mctl->mod_next) != kobj_modules);
3410 
3411 	return (NULL);
3412 }
3413 
3414 /*
3415  * Determine if the module exists.
3416  */
3417 int
3418 kobj_path_exists(char *name, int use_path)
3419 {
3420 	struct _buf *file;
3421 
3422 	file = kobj_open_path(name, use_path, 1);
3423 #ifdef	MODDIR_SUFFIX
3424 	if (file == (struct _buf *)-1)
3425 		file = kobj_open_path(name, use_path, 0);
3426 #endif	/* MODDIR_SUFFIX */
3427 	if (file == (struct _buf *)-1)
3428 		return (0);
3429 	kobj_close_file(file);
3430 	return (1);
3431 }
3432 
3433 /*
3434  * fullname is dynamically allocated to be able to hold the
3435  * maximum size string that can be constructed from name.
3436  * path is exactly like the shell PATH variable.
3437  */
3438 struct _buf *
3439 kobj_open_path(char *name, int use_path, int use_moddir_suffix)
3440 {
3441 	char *p, *q;
3442 	char *pathp;
3443 	char *pathpsave;
3444 	char *fullname;
3445 	int maxpathlen;
3446 	struct _buf *file;
3447 
3448 #if !defined(MODDIR_SUFFIX)
3449 	use_moddir_suffix = B_FALSE;
3450 #endif
3451 
3452 	if (!use_path)
3453 		pathp = "";		/* use name as specified */
3454 	else
3455 		pathp = kobj_module_path;
3456 					/* use configured default path */
3457 
3458 	pathpsave = pathp;		/* keep this for error reporting */
3459 
3460 	/*
3461 	 * Allocate enough space for the largest possible fullname.
3462 	 * since path is of the form <directory> : <directory> : ...
3463 	 * we're potentially allocating a little more than we need to
3464 	 * but we'll allocate the exact amount when we find the right directory.
3465 	 * (The + 3 below is one for NULL terminator and one for the '/'
3466 	 * we might have to add at the beginning of path and one for
3467 	 * the '/' between path and name.)
3468 	 */
3469 	maxpathlen = strlen(pathp) + strlen(name) + 3;
3470 	/* sizeof includes null */
3471 	maxpathlen += sizeof (slash_moddir_suffix_slash) - 1;
3472 	fullname = kobj_zalloc(maxpathlen, KM_WAIT);
3473 
3474 	for (;;) {
3475 		p = fullname;
3476 		if (*pathp != '\0' && *pathp != '/')
3477 			*p++ = '/';	/* path must start with '/' */
3478 		while (*pathp && *pathp != ':' && *pathp != ' ')
3479 			*p++ = *pathp++;
3480 		if (p != fullname && p[-1] != '/')
3481 			*p++ = '/';
3482 		if (use_moddir_suffix) {
3483 			char *b = basename(name);
3484 			char *s;
3485 
3486 			/* copy everything up to the base name */
3487 			q = name;
3488 			while (q != b && *q)
3489 				*p++ = *q++;
3490 			s = slash_moddir_suffix_slash;
3491 			while (*s)
3492 				*p++ = *s++;
3493 			/* copy the rest */
3494 			while (*b)
3495 				*p++ = *b++;
3496 		} else {
3497 			q = name;
3498 			while (*q)
3499 				*p++ = *q++;
3500 		}
3501 		*p = 0;
3502 		if ((file = kobj_open_file(fullname)) != (struct _buf *)-1) {
3503 			kobj_free(fullname, maxpathlen);
3504 			return (file);
3505 		}
3506 		while (*pathp == ' ' || *pathp == ':')
3507 			pathp++;
3508 		if (*pathp == 0)
3509 			break;
3510 
3511 	}
3512 	kobj_free(fullname, maxpathlen);
3513 	if (_moddebug & MODDEBUG_ERRMSG) {
3514 		_kobj_printf(ops, "can't open %s,", name);
3515 		_kobj_printf(ops, " path is %s\n", pathpsave);
3516 	}
3517 	return ((struct _buf *)-1);
3518 }
3519 
3520 intptr_t
3521 kobj_open(char *filename)
3522 {
3523 	struct vnode *vp;
3524 	int fd;
3525 
3526 	if (_modrootloaded) {
3527 		struct kobjopen_tctl *ltp = kobjopen_alloc(filename);
3528 		int Errno;
3529 
3530 		/*
3531 		 * Hand off the open to a thread who has a
3532 		 * stack size capable handling the request.
3533 		 */
3534 		if (curthread != &t0) {
3535 			(void) thread_create(NULL, DEFAULTSTKSZ * 2,
3536 			    kobjopen_thread, ltp, 0, &p0, TS_RUN, maxclsyspri);
3537 			sema_p(&ltp->sema);
3538 			Errno = ltp->Errno;
3539 			vp = ltp->vp;
3540 		} else {
3541 			/*
3542 			 * 1098067: module creds should not be those of the
3543 			 * caller
3544 			 */
3545 			cred_t *saved_cred = curthread->t_cred;
3546 			curthread->t_cred = kcred;
3547 			Errno = vn_openat(filename, UIO_SYSSPACE, FREAD, 0, &vp,
3548 			    0, 0, rootdir, -1);
3549 			curthread->t_cred = saved_cred;
3550 		}
3551 		kobjopen_free(ltp);
3552 
3553 		if (Errno) {
3554 			if (_moddebug & MODDEBUG_ERRMSG) {
3555 				_kobj_printf(ops,
3556 				    "kobj_open: vn_open of %s fails, ",
3557 				    filename);
3558 				_kobj_printf(ops, "Errno = %d\n", Errno);
3559 			}
3560 			return (-1);
3561 		} else {
3562 			if (_moddebug & MODDEBUG_ERRMSG) {
3563 				_kobj_printf(ops, "kobj_open: '%s'", filename);
3564 				_kobj_printf(ops, " vp = %p\n", vp);
3565 			}
3566 			return ((intptr_t)vp);
3567 		}
3568 	} else {
3569 		fd = kobj_boot_open(filename, 0);
3570 
3571 		if (_moddebug & MODDEBUG_ERRMSG) {
3572 			if (fd < 0)
3573 				_kobj_printf(ops,
3574 				    "kobj_open: can't open %s\n", filename);
3575 			else {
3576 				_kobj_printf(ops, "kobj_open: '%s'", filename);
3577 				_kobj_printf(ops, " descr = 0x%x\n", fd);
3578 			}
3579 		}
3580 		return ((intptr_t)fd);
3581 	}
3582 }
3583 
3584 /*
3585  * Calls to kobj_open() are handled off to this routine as a separate thread.
3586  */
3587 static void
3588 kobjopen_thread(struct kobjopen_tctl *ltp)
3589 {
3590 	kmutex_t	cpr_lk;
3591 	callb_cpr_t	cpr_i;
3592 
3593 	mutex_init(&cpr_lk, NULL, MUTEX_DEFAULT, NULL);
3594 	CALLB_CPR_INIT(&cpr_i, &cpr_lk, callb_generic_cpr, "kobjopen");
3595 	ltp->Errno = vn_open(ltp->name, UIO_SYSSPACE, FREAD, 0, &(ltp->vp),
3596 	    0, 0);
3597 	sema_v(&ltp->sema);
3598 	mutex_enter(&cpr_lk);
3599 	CALLB_CPR_EXIT(&cpr_i);
3600 	mutex_destroy(&cpr_lk);
3601 	thread_exit();
3602 }
3603 
3604 /*
3605  * allocate and initialize a kobjopen thread structure
3606  */
3607 static struct kobjopen_tctl *
3608 kobjopen_alloc(char *filename)
3609 {
3610 	struct kobjopen_tctl *ltp = kmem_zalloc(sizeof (*ltp), KM_SLEEP);
3611 
3612 	ASSERT(filename != NULL);
3613 
3614 	ltp->name = kmem_alloc(strlen(filename) + 1, KM_SLEEP);
3615 	bcopy(filename, ltp->name, strlen(filename) + 1);
3616 	sema_init(&ltp->sema, 0, NULL, SEMA_DEFAULT, NULL);
3617 	return (ltp);
3618 }
3619 
3620 /*
3621  * free a kobjopen thread control structure
3622  */
3623 static void
3624 kobjopen_free(struct kobjopen_tctl *ltp)
3625 {
3626 	sema_destroy(&ltp->sema);
3627 	kmem_free(ltp->name, strlen(ltp->name) + 1);
3628 	kmem_free(ltp, sizeof (*ltp));
3629 }
3630 
3631 int
3632 kobj_read(intptr_t descr, char *buf, uint_t size, uint_t offset)
3633 {
3634 	int stat;
3635 	ssize_t resid;
3636 
3637 	if (_modrootloaded) {
3638 		if ((stat = vn_rdwr(UIO_READ, (struct vnode *)descr, buf, size,
3639 		    (offset_t)offset, UIO_SYSSPACE, 0, (rlim64_t)0, CRED(),
3640 		    &resid)) != 0) {
3641 			_kobj_printf(ops,
3642 			    "vn_rdwr failed with error 0x%x\n", stat);
3643 			return (-1);
3644 		}
3645 		return (size - resid);
3646 	} else {
3647 		int count = 0;
3648 
3649 		if (kobj_boot_seek((int)descr, (off_t)0, offset) != 0) {
3650 			_kobj_printf(ops,
3651 			    "kobj_read: seek 0x%x failed\n", offset);
3652 			return (-1);
3653 		}
3654 
3655 		count = kobj_boot_read((int)descr, buf, size);
3656 		if (count < size) {
3657 			if (_moddebug & MODDEBUG_ERRMSG) {
3658 				_kobj_printf(ops,
3659 				    "kobj_read: req %d bytes, ", size);
3660 				_kobj_printf(ops, "got %d\n", count);
3661 			}
3662 		}
3663 		return (count);
3664 	}
3665 }
3666 
3667 void
3668 kobj_close(intptr_t descr)
3669 {
3670 	if (_moddebug & MODDEBUG_ERRMSG)
3671 		_kobj_printf(ops, "kobj_close: 0x%lx\n", descr);
3672 
3673 	if (_modrootloaded) {
3674 		struct vnode *vp = (struct vnode *)descr;
3675 		(void) VOP_CLOSE(vp, FREAD, 1, (offset_t)0, CRED(), NULL);
3676 		VN_RELE(vp);
3677 	} else
3678 		(void) kobj_boot_close((int)descr);
3679 }
3680 
3681 int
3682 kobj_fstat(intptr_t descr, struct bootstat *buf)
3683 {
3684 	if (buf == NULL)
3685 		return (-1);
3686 
3687 	if (_modrootloaded) {
3688 		vattr_t vattr;
3689 		struct vnode *vp = (struct vnode *)descr;
3690 		if (VOP_GETATTR(vp, &vattr, 0, kcred, NULL) != 0)
3691 			return (-1);
3692 
3693 		/*
3694 		 * The vattr and bootstat structures are similar, but not
3695 		 * identical.  We do our best to fill in the bootstat structure
3696 		 * from the contents of vattr (transfering only the ones that
3697 		 * are obvious.
3698 		 */
3699 
3700 		buf->st_mode = (uint32_t)vattr.va_mode;
3701 		buf->st_nlink = (uint32_t)vattr.va_nlink;
3702 		buf->st_uid = (int32_t)vattr.va_uid;
3703 		buf->st_gid = (int32_t)vattr.va_gid;
3704 		buf->st_rdev = (uint64_t)vattr.va_rdev;
3705 		buf->st_size = (uint64_t)vattr.va_size;
3706 		buf->st_atim.tv_sec = (int64_t)vattr.va_atime.tv_sec;
3707 		buf->st_atim.tv_nsec = (int64_t)vattr.va_atime.tv_nsec;
3708 		buf->st_mtim.tv_sec = (int64_t)vattr.va_mtime.tv_sec;
3709 		buf->st_mtim.tv_nsec = (int64_t)vattr.va_mtime.tv_nsec;
3710 		buf->st_ctim.tv_sec = (int64_t)vattr.va_ctime.tv_sec;
3711 		buf->st_ctim.tv_nsec = (int64_t)vattr.va_ctime.tv_nsec;
3712 		buf->st_blksize = (int32_t)vattr.va_blksize;
3713 		buf->st_blocks = (int64_t)vattr.va_nblocks;
3714 
3715 		return (0);
3716 	}
3717 
3718 	return (kobj_boot_fstat((int)descr, buf));
3719 }
3720 
3721 
3722 struct _buf *
3723 kobj_open_file(char *name)
3724 {
3725 	struct _buf *file;
3726 	struct compinfo cbuf;
3727 	intptr_t fd;
3728 
3729 	if ((fd = kobj_open(name)) == -1) {
3730 		return ((struct _buf *)-1);
3731 	}
3732 
3733 	file = kobj_zalloc(sizeof (struct _buf), KM_WAIT|KM_TMP);
3734 	file->_fd = fd;
3735 	file->_name = kobj_alloc(strlen(name)+1, KM_WAIT|KM_TMP);
3736 	file->_cnt = file->_size = file->_off = 0;
3737 	file->_ln = 1;
3738 	file->_ptr = file->_base;
3739 	(void) strcpy(file->_name, name);
3740 
3741 	/*
3742 	 * Before root is mounted, we must check
3743 	 * for a compressed file and do our own
3744 	 * buffering.
3745 	 */
3746 	if (_modrootloaded) {
3747 		file->_base = kobj_zalloc(MAXBSIZE, KM_WAIT);
3748 		file->_bsize = MAXBSIZE;
3749 
3750 		/* Check if the file is compressed */
3751 		file->_iscmp = kobj_is_compressed(fd);
3752 	} else {
3753 		if (kobj_boot_compinfo(fd, &cbuf) != 0) {
3754 			kobj_close_file(file);
3755 			return ((struct _buf *)-1);
3756 		}
3757 		file->_iscmp = cbuf.iscmp;
3758 		if (file->_iscmp) {
3759 			if (kobj_comp_setup(file, &cbuf) != 0) {
3760 				kobj_close_file(file);
3761 				return ((struct _buf *)-1);
3762 			}
3763 		} else {
3764 			file->_base = kobj_zalloc(cbuf.blksize, KM_WAIT|KM_TMP);
3765 			file->_bsize = cbuf.blksize;
3766 		}
3767 	}
3768 	return (file);
3769 }
3770 
3771 static int
3772 kobj_comp_setup(struct _buf *file, struct compinfo *cip)
3773 {
3774 	struct comphdr *hdr;
3775 
3776 	/*
3777 	 * read the compressed image into memory,
3778 	 * so we can deompress from there
3779 	 */
3780 	file->_dsize = cip->fsize;
3781 	file->_dbuf = kobj_alloc(cip->fsize, KM_WAIT|KM_TMP);
3782 	if (kobj_read(file->_fd, file->_dbuf, cip->fsize, 0) != cip->fsize) {
3783 		kobj_free(file->_dbuf, cip->fsize);
3784 		return (-1);
3785 	}
3786 
3787 	hdr = kobj_comphdr(file);
3788 	if (hdr->ch_magic != CH_MAGIC_ZLIB || hdr->ch_version != CH_VERSION ||
3789 	    hdr->ch_algorithm != CH_ALG_ZLIB || hdr->ch_fsize == 0 ||
3790 	    !ISP2(hdr->ch_blksize)) {
3791 		kobj_free(file->_dbuf, cip->fsize);
3792 		return (-1);
3793 	}
3794 	file->_base = kobj_alloc(hdr->ch_blksize, KM_WAIT|KM_TMP);
3795 	file->_bsize = hdr->ch_blksize;
3796 	return (0);
3797 }
3798 
3799 void
3800 kobj_close_file(struct _buf *file)
3801 {
3802 	kobj_close(file->_fd);
3803 	if (file->_base != NULL)
3804 		kobj_free(file->_base, file->_bsize);
3805 	if (file->_dbuf != NULL)
3806 		kobj_free(file->_dbuf, file->_dsize);
3807 	kobj_free(file->_name, strlen(file->_name)+1);
3808 	kobj_free(file, sizeof (struct _buf));
3809 }
3810 
3811 int
3812 kobj_read_file(struct _buf *file, char *buf, uint_t size, uint_t off)
3813 {
3814 	int b_size, c_size;
3815 	int b_off;	/* Offset into buffer for start of bcopy */
3816 	int count = 0;
3817 	int page_addr;
3818 
3819 	if (_moddebug & MODDEBUG_ERRMSG) {
3820 		_kobj_printf(ops, "kobj_read_file: size=%x,", size);
3821 		_kobj_printf(ops, " offset=%x at", off);
3822 		_kobj_printf(ops, " buf=%x\n", buf);
3823 	}
3824 
3825 	/*
3826 	 * Handle compressed (gzip for now) file here. First get the
3827 	 * compressed size, then read the image into memory and finally
3828 	 * call zlib to decompress the image at the supplied memory buffer.
3829 	 */
3830 	if (file->_iscmp == CH_MAGIC_GZIP) {
3831 		ulong_t dlen;
3832 		vattr_t vattr;
3833 		struct vnode *vp = (struct vnode *)file->_fd;
3834 		ssize_t resid;
3835 		int err = 0;
3836 
3837 		if (VOP_GETATTR(vp, &vattr, 0, kcred, NULL) != 0)
3838 			return (-1);
3839 
3840 		file->_dbuf = kobj_alloc(vattr.va_size, KM_WAIT|KM_TMP);
3841 		file->_dsize = vattr.va_size;
3842 
3843 		/* Read the compressed file into memory */
3844 		if ((err = vn_rdwr(UIO_READ, vp, file->_dbuf, vattr.va_size,
3845 		    (offset_t)(0), UIO_SYSSPACE, 0, (rlim64_t)0, CRED(),
3846 		    &resid)) != 0) {
3847 
3848 			_kobj_printf(ops, "kobj_read_file :vn_rdwr() failed, "
3849 			    "error code 0x%x\n", err);
3850 			return (-1);
3851 		}
3852 
3853 		dlen = size;
3854 
3855 		/* Decompress the image at the supplied memory buffer */
3856 		if ((err = z_uncompress(buf, &dlen, file->_dbuf,
3857 		    vattr.va_size)) != Z_OK) {
3858 			_kobj_printf(ops, "kobj_read_file: z_uncompress "
3859 			    "failed, error code : 0x%x\n", err);
3860 			return (-1);
3861 		}
3862 
3863 		if (dlen != size) {
3864 			_kobj_printf(ops, "kobj_read_file: z_uncompress "
3865 			    "failed to uncompress (size returned 0x%x , "
3866 			    "expected size: 0x%x)\n", dlen, size);
3867 			return (-1);
3868 		}
3869 
3870 		return (0);
3871 	}
3872 
3873 	while (size) {
3874 		page_addr = F_PAGE(file, off);
3875 		b_size = file->_size;
3876 		/*
3877 		 * If we have the filesystem page the caller's referring to
3878 		 * and we have something in the buffer,
3879 		 * satisfy as much of the request from the buffer as we can.
3880 		 */
3881 		if (page_addr == file->_off && b_size > 0) {
3882 			b_off = B_OFFSET(file, off);
3883 			c_size = b_size - b_off;
3884 			/*
3885 			 * If there's nothing to copy, we're at EOF.
3886 			 */
3887 			if (c_size <= 0)
3888 				break;
3889 			if (c_size > size)
3890 				c_size = size;
3891 			if (buf) {
3892 				if (_moddebug & MODDEBUG_ERRMSG)
3893 					_kobj_printf(ops, "copying %x bytes\n",
3894 					    c_size);
3895 				bcopy(file->_base+b_off, buf, c_size);
3896 				size -= c_size;
3897 				off += c_size;
3898 				buf += c_size;
3899 				count += c_size;
3900 			} else {
3901 				_kobj_printf(ops, "kobj_read: system error");
3902 				count = -1;
3903 				break;
3904 			}
3905 		} else {
3906 			/*
3907 			 * If the caller's offset is page aligned and
3908 			 * the caller want's at least a filesystem page and
3909 			 * the caller provided a buffer,
3910 			 * read directly into the caller's buffer.
3911 			 */
3912 			if (page_addr == off &&
3913 			    (c_size = F_BLKS(file, size)) && buf) {
3914 				c_size = kobj_read_blks(file, buf, c_size,
3915 				    page_addr);
3916 				if (c_size < 0) {
3917 					count = -1;
3918 					break;
3919 				}
3920 				count += c_size;
3921 				if (c_size != F_BLKS(file, size))
3922 					break;
3923 				size -= c_size;
3924 				off += c_size;
3925 				buf += c_size;
3926 			/*
3927 			 * Otherwise, read into our buffer and copy next time
3928 			 * around the loop.
3929 			 */
3930 			} else {
3931 				file->_off = page_addr;
3932 				c_size = kobj_read_blks(file, file->_base,
3933 				    file->_bsize, page_addr);
3934 				file->_ptr = file->_base;
3935 				file->_cnt = c_size;
3936 				file->_size = c_size;
3937 				/*
3938 				 * If a _filbuf call or nothing read, break.
3939 				 */
3940 				if (buf == NULL || c_size <= 0) {
3941 					count = c_size;
3942 					break;
3943 				}
3944 			}
3945 			if (_moddebug & MODDEBUG_ERRMSG)
3946 				_kobj_printf(ops, "read %x bytes\n", c_size);
3947 		}
3948 	}
3949 	if (_moddebug & MODDEBUG_ERRMSG)
3950 		_kobj_printf(ops, "count = %x\n", count);
3951 
3952 	return (count);
3953 }
3954 
3955 static int
3956 kobj_read_blks(struct _buf *file, char *buf, uint_t size, uint_t off)
3957 {
3958 	int ret;
3959 
3960 	ASSERT(B_OFFSET(file, size) == 0 && B_OFFSET(file, off) == 0);
3961 	if (file->_iscmp) {
3962 		uint_t blks;
3963 		int nret;
3964 
3965 		ret = 0;
3966 		for (blks = size / file->_bsize; blks != 0; blks--) {
3967 			nret = kobj_uncomp_blk(file, buf, off);
3968 			if (nret == -1)
3969 				return (-1);
3970 			buf += nret;
3971 			off += nret;
3972 			ret += nret;
3973 			if (nret < file->_bsize)
3974 				break;
3975 		}
3976 	} else
3977 		ret = kobj_read(file->_fd, buf, size, off);
3978 	return (ret);
3979 }
3980 
3981 static int
3982 kobj_uncomp_blk(struct _buf *file, char *buf, uint_t off)
3983 {
3984 	struct comphdr *hdr = kobj_comphdr(file);
3985 	ulong_t dlen, slen;
3986 	caddr_t src;
3987 	int i;
3988 
3989 	dlen = file->_bsize;
3990 	i = off / file->_bsize;
3991 	src = file->_dbuf + hdr->ch_blkmap[i];
3992 	if (i == hdr->ch_fsize / file->_bsize)
3993 		slen = file->_dsize - hdr->ch_blkmap[i];
3994 	else
3995 		slen = hdr->ch_blkmap[i + 1] - hdr->ch_blkmap[i];
3996 	if (z_uncompress(buf, &dlen, src, slen) != Z_OK)
3997 		return (-1);
3998 	return (dlen);
3999 }
4000 
4001 int
4002 kobj_filbuf(struct _buf *f)
4003 {
4004 	if (kobj_read_file(f, NULL, f->_bsize, f->_off + f->_size) > 0)
4005 		return (kobj_getc(f));
4006 	return (-1);
4007 }
4008 
4009 void
4010 kobj_free(void *address, size_t size)
4011 {
4012 	if (standalone)
4013 		return;
4014 
4015 	kmem_free(address, size);
4016 	kobj_stat.nfree_calls++;
4017 	kobj_stat.nfree += size;
4018 }
4019 
4020 void *
4021 kobj_zalloc(size_t size, int flag)
4022 {
4023 	void *v;
4024 
4025 	if ((v = kobj_alloc(size, flag)) != 0) {
4026 		bzero(v, size);
4027 	}
4028 
4029 	return (v);
4030 }
4031 
4032 void *
4033 kobj_alloc(size_t size, int flag)
4034 {
4035 	/*
4036 	 * If we are running standalone in the
4037 	 * linker, we ask boot for memory.
4038 	 * Either it's temporary memory that we lose
4039 	 * once boot is mapped out or we allocate it
4040 	 * permanently using the dynamic data segment.
4041 	 */
4042 	if (standalone) {
4043 #if defined(_OBP)
4044 		if (flag & (KM_TMP | KM_SCRATCH))
4045 			return (bop_temp_alloc(size, MINALIGN));
4046 #else
4047 		if (flag & (KM_TMP | KM_SCRATCH))
4048 			return (BOP_ALLOC(ops, 0, size, MINALIGN));
4049 #endif
4050 		return (kobj_segbrk(&_edata, size, MINALIGN, 0));
4051 	}
4052 
4053 	kobj_stat.nalloc_calls++;
4054 	kobj_stat.nalloc += size;
4055 
4056 	return (kmem_alloc(size, (flag & KM_NOWAIT) ? KM_NOSLEEP : KM_SLEEP));
4057 }
4058 
4059 /*
4060  * Allow the "mod" system to sync up with the work
4061  * already done by kobj during the initial loading
4062  * of the kernel.  This also gives us a chance
4063  * to reallocate memory that belongs to boot.
4064  */
4065 void
4066 kobj_sync(void)
4067 {
4068 	struct modctl_list *lp, **lpp;
4069 
4070 	/*
4071 	 * The module path can be set in /etc/system via 'moddir' commands
4072 	 */
4073 	if (default_path != NULL)
4074 		kobj_module_path = default_path;
4075 	else
4076 		default_path = kobj_module_path;
4077 
4078 	ksyms_arena = vmem_create("ksyms", NULL, 0, sizeof (uint64_t),
4079 	    segkmem_alloc, segkmem_free, heap_arena, 0, VM_SLEEP);
4080 
4081 	ctf_arena = vmem_create("ctf", NULL, 0, sizeof (uint_t),
4082 	    segkmem_alloc, segkmem_free, heap_arena, 0, VM_SLEEP);
4083 
4084 	/*
4085 	 * Move symbol tables from boot memory to ksyms_arena.
4086 	 */
4087 	for (lpp = kobj_linkmaps; *lpp != NULL; lpp++) {
4088 		for (lp = *lpp; lp != NULL; lp = lp->modl_next)
4089 			kobj_export_module(mod(lp));
4090 	}
4091 }
4092 
4093 caddr_t
4094 kobj_segbrk(caddr_t *spp, size_t size, size_t align, caddr_t limit)
4095 {
4096 	uintptr_t va, pva;
4097 	size_t alloc_pgsz = kobj_mmu_pagesize;
4098 	size_t alloc_align = BO_NO_ALIGN;
4099 	size_t alloc_size;
4100 
4101 	/*
4102 	 * If we are using "large" mappings for the kernel,
4103 	 * request aligned memory from boot using the
4104 	 * "large" pagesize.
4105 	 */
4106 	if (lg_pagesize) {
4107 		alloc_align = lg_pagesize;
4108 		alloc_pgsz = lg_pagesize;
4109 	}
4110 
4111 #if defined(__sparc)
4112 	/* account for redzone */
4113 	if (limit)
4114 		limit -= alloc_pgsz;
4115 #endif	/* __sparc */
4116 
4117 	va = ALIGN((uintptr_t)*spp, align);
4118 	pva = P2ROUNDUP((uintptr_t)*spp, alloc_pgsz);
4119 	/*
4120 	 * Need more pages?
4121 	 */
4122 	if (va + size > pva) {
4123 		uintptr_t npva;
4124 
4125 		alloc_size = P2ROUNDUP(size - (pva - va), alloc_pgsz);
4126 		/*
4127 		 * Check for overlapping segments.
4128 		 */
4129 		if (limit && limit <= *spp + alloc_size) {
4130 			return ((caddr_t)0);
4131 		}
4132 
4133 		npva = (uintptr_t)BOP_ALLOC(ops, (caddr_t)pva,
4134 		    alloc_size, alloc_align);
4135 
4136 		if (npva == NULL) {
4137 			_kobj_printf(ops, "BOP_ALLOC failed, 0x%lx bytes",
4138 			    alloc_size);
4139 			_kobj_printf(ops, " aligned %lx", alloc_align);
4140 			_kobj_printf(ops, " at 0x%lx\n", pva);
4141 			return (NULL);
4142 		}
4143 	}
4144 	*spp = (caddr_t)(va + size);
4145 
4146 	return ((caddr_t)va);
4147 }
4148 
4149 /*
4150  * Calculate the number of output hash buckets.
4151  * We use the next prime larger than n / 4,
4152  * so the average hash chain is about 4 entries.
4153  * More buckets would just be a waste of memory.
4154  */
4155 uint_t
4156 kobj_gethashsize(uint_t n)
4157 {
4158 	int f;
4159 	int hsize = MAX(n / 4, 2);
4160 
4161 	for (f = 2; f * f <= hsize; f++)
4162 		if (hsize % f == 0)
4163 			hsize += f = 1;
4164 
4165 	return (hsize);
4166 }
4167 
4168 /*
4169  * Get the file size.
4170  *
4171  * Before root is mounted, files are compressed in the boot_archive ramdisk
4172  * (in the memory). kobj_fstat would return the compressed file size.
4173  * In order to get the uncompressed file size, read the file to the end and
4174  * count its size.
4175  */
4176 int
4177 kobj_get_filesize(struct _buf *file, uint64_t *size)
4178 {
4179 	int err = 0;
4180 	ssize_t resid;
4181 	uint32_t buf;
4182 
4183 	if (_modrootloaded) {
4184 		struct bootstat bst;
4185 
4186 		if (kobj_fstat(file->_fd, &bst) != 0)
4187 			return (EIO);
4188 		*size = bst.st_size;
4189 
4190 		if (file->_iscmp == CH_MAGIC_GZIP) {
4191 			/*
4192 			 * Read the last 4 bytes of the compressed (gzip)
4193 			 * image to get the size of its uncompressed
4194 			 * version.
4195 			 */
4196 			if ((err = vn_rdwr(UIO_READ, (struct vnode *)file->_fd,
4197 			    (char *)(&buf), 4, (offset_t)(*size - 4),
4198 			    UIO_SYSSPACE, 0, (rlim64_t)0, CRED(), &resid))
4199 			    != 0) {
4200 				_kobj_printf(ops, "kobj_get_filesize: "
4201 				    "vn_rdwr() failed with error 0x%x\n", err);
4202 				return (-1);
4203 			}
4204 
4205 			*size =  (uint64_t)buf;
4206 		}
4207 	} else {
4208 
4209 #if defined(_OBP)
4210 		struct bootstat bsb;
4211 
4212 		if (file->_iscmp) {
4213 			struct comphdr *hdr = kobj_comphdr(file);
4214 
4215 			*size = hdr->ch_fsize;
4216 		} else if (kobj_boot_fstat(file->_fd, &bsb) != 0)
4217 			return (EIO);
4218 		else
4219 			*size = bsb.st_size;
4220 #else
4221 		char *buf;
4222 		int count;
4223 		uint64_t offset = 0;
4224 
4225 		buf = kmem_alloc(MAXBSIZE, KM_SLEEP);
4226 		do {
4227 			count = kobj_read_file(file, buf, MAXBSIZE, offset);
4228 			if (count < 0) {
4229 				kmem_free(buf, MAXBSIZE);
4230 				return (EIO);
4231 			}
4232 			offset += count;
4233 		} while (count == MAXBSIZE);
4234 		kmem_free(buf, MAXBSIZE);
4235 
4236 		*size = offset;
4237 #endif
4238 	}
4239 
4240 	return (0);
4241 }
4242 
4243 static char *
4244 basename(char *s)
4245 {
4246 	char *p, *q;
4247 
4248 	q = NULL;
4249 	p = s;
4250 	do {
4251 		if (*p == '/')
4252 			q = p;
4253 	} while (*p++);
4254 	return (q ? q + 1 : s);
4255 }
4256 
4257 void
4258 kobj_stat_get(kobj_stat_t *kp)
4259 {
4260 	*kp = kobj_stat;
4261 }
4262 
4263 int
4264 kobj_getpagesize()
4265 {
4266 	return (lg_pagesize);
4267 }
4268 
4269 void
4270 kobj_textwin_alloc(struct module *mp)
4271 {
4272 	ASSERT(MUTEX_HELD(&mod_lock));
4273 
4274 	if (mp->textwin != NULL)
4275 		return;
4276 
4277 	/*
4278 	 * If the text is not contained in the heap, then it is not contained
4279 	 * by a writable mapping.  (Specifically, it's on the nucleus page.)
4280 	 * We allocate a read/write mapping for this module's text to allow
4281 	 * the text to be patched without calling hot_patch_kernel_text()
4282 	 * (which is quite slow).
4283 	 */
4284 	if (!vmem_contains(heaptext_arena, mp->text, mp->text_size)) {
4285 		uintptr_t text = (uintptr_t)mp->text;
4286 		uintptr_t size = (uintptr_t)mp->text_size;
4287 		uintptr_t i;
4288 		caddr_t va;
4289 		size_t sz = ((text + size + PAGESIZE - 1) & PAGEMASK) -
4290 		    (text & PAGEMASK);
4291 
4292 		va = mp->textwin_base = vmem_alloc(heap_arena, sz, VM_SLEEP);
4293 
4294 		for (i = text & PAGEMASK; i < text + size; i += PAGESIZE) {
4295 			hat_devload(kas.a_hat, va, PAGESIZE,
4296 			    hat_getpfnum(kas.a_hat, (caddr_t)i),
4297 			    PROT_READ | PROT_WRITE,
4298 			    HAT_LOAD_LOCK | HAT_LOAD_NOCONSIST);
4299 			va += PAGESIZE;
4300 		}
4301 
4302 		mp->textwin = mp->textwin_base + (text & PAGEOFFSET);
4303 	} else {
4304 		mp->textwin = mp->text;
4305 	}
4306 }
4307 
4308 void
4309 kobj_textwin_free(struct module *mp)
4310 {
4311 	uintptr_t text = (uintptr_t)mp->text;
4312 	uintptr_t tsize = (uintptr_t)mp->text_size;
4313 	size_t size = (((text + tsize + PAGESIZE - 1) & PAGEMASK) -
4314 	    (text & PAGEMASK));
4315 
4316 	mp->textwin = NULL;
4317 
4318 	if (mp->textwin_base == NULL)
4319 		return;
4320 
4321 	hat_unload(kas.a_hat, mp->textwin_base, size, HAT_UNLOAD_UNLOCK);
4322 	vmem_free(heap_arena, mp->textwin_base, size);
4323 	mp->textwin_base = NULL;
4324 }
4325 
4326 static char *
4327 find_libmacro(char *name)
4328 {
4329 	int lmi;
4330 
4331 	for (lmi = 0; lmi < NLIBMACROS; lmi++) {
4332 		if (strcmp(name, libmacros[lmi].lmi_macroname) == 0)
4333 			return (libmacros[lmi].lmi_list);
4334 	}
4335 	return (NULL);
4336 }
4337 
4338 /*
4339  * Check for $MACRO in tail (string to expand) and expand it in path at pathend
4340  * returns path if successful, else NULL
4341  * Support multiple $MACROs expansion and the first valid path will be returned
4342  * Caller's responsibility to provide enough space in path to expand
4343  */
4344 char *
4345 expand_libmacro(char *tail, char *path, char *pathend)
4346 {
4347 	char c, *p, *p1, *p2, *path2, *endp;
4348 	int diff, lmi, macrolen, valid_macro, more_macro;
4349 	struct _buf *file;
4350 
4351 	/*
4352 	 * check for $MACROS between nulls or slashes
4353 	 */
4354 	p = strchr(tail, '$');
4355 	if (p == NULL)
4356 		return (NULL);
4357 	for (lmi = 0; lmi < NLIBMACROS; lmi++) {
4358 		macrolen = libmacros[lmi].lmi_macrolen;
4359 		if (strncmp(p + 1, libmacros[lmi].lmi_macroname, macrolen) == 0)
4360 			break;
4361 	}
4362 
4363 	valid_macro = 0;
4364 	if (lmi < NLIBMACROS) {
4365 		/*
4366 		 * The following checks are used to restrict expansion of
4367 		 * macros to those that form a full directory/file name
4368 		 * and to keep the behavior same as before.  If this
4369 		 * restriction is removed or no longer valid in the future,
4370 		 * the checks below can be deleted.
4371 		 */
4372 		if ((p == tail) || (*(p - 1) == '/')) {
4373 			c = *(p + macrolen + 1);
4374 			if (c == '/' || c == '\0')
4375 				valid_macro = 1;
4376 		}
4377 	}
4378 
4379 	if (!valid_macro) {
4380 		p2 = strchr(p, '/');
4381 		/*
4382 		 * if no more macro to expand, then just copy whatever left
4383 		 * and check whether it exists
4384 		 */
4385 		if (p2 == NULL || strchr(p2, '$') == NULL) {
4386 			(void) strcpy(pathend, tail);
4387 			if ((file = kobj_open_path(path, 1, 1)) !=
4388 			    (struct _buf *)-1) {
4389 				kobj_close_file(file);
4390 				return (path);
4391 			} else
4392 				return (NULL);
4393 		} else {
4394 			/*
4395 			 * copy all chars before '/' and call expand_libmacro()
4396 			 * again
4397 			 */
4398 			diff = p2 - tail;
4399 			bcopy(tail, pathend, diff);
4400 			pathend += diff;
4401 			*(pathend) = '\0';
4402 			return (expand_libmacro(p2, path, pathend));
4403 		}
4404 	}
4405 
4406 	more_macro = 0;
4407 	if (c != '\0') {
4408 		endp = p + macrolen + 1;
4409 		if (strchr(endp, '$') != NULL)
4410 			more_macro = 1;
4411 	} else
4412 		endp = NULL;
4413 
4414 	/*
4415 	 * copy lmi_list and split it into components.
4416 	 * then put the part of tail before $MACRO into path
4417 	 * at pathend
4418 	 */
4419 	diff = p - tail;
4420 	if (diff > 0)
4421 		bcopy(tail, pathend, diff);
4422 	path2 = pathend + diff;
4423 	p1 = libmacros[lmi].lmi_list;
4424 	while (p1 && (*p1 != '\0')) {
4425 		p2 = strchr(p1, ':');
4426 		if (p2) {
4427 			diff = p2 - p1;
4428 			bcopy(p1, path2, diff);
4429 			*(path2 + diff) = '\0';
4430 		} else {
4431 			diff = strlen(p1);
4432 			bcopy(p1, path2, diff + 1);
4433 		}
4434 		/* copy endp only if there isn't any more macro to expand */
4435 		if (!more_macro && (endp != NULL))
4436 			(void) strcat(path2, endp);
4437 		file = kobj_open_path(path, 1, 1);
4438 		if (file != (struct _buf *)-1) {
4439 			kobj_close_file(file);
4440 			/*
4441 			 * if more macros to expand then call expand_libmacro(),
4442 			 * else return path which has the whole path
4443 			 */
4444 			if (!more_macro || (expand_libmacro(endp, path,
4445 			    path2 + diff) != NULL)) {
4446 				return (path);
4447 			}
4448 		}
4449 		if (p2)
4450 			p1 = ++p2;
4451 		else
4452 			return (NULL);
4453 	}
4454 	return (NULL);
4455 }
4456 
4457 static void
4458 tnf_add_notifyunload(kobj_notify_f *fp)
4459 {
4460 	kobj_notify_list_t *entry;
4461 
4462 	entry = kobj_alloc(sizeof (kobj_notify_list_t), KM_WAIT);
4463 	entry->kn_type = KOBJ_NOTIFY_MODUNLOADING;
4464 	entry->kn_func = fp;
4465 	(void) kobj_notify_add(entry);
4466 }
4467 
4468 /* ARGSUSED */
4469 static void
4470 tnf_unsplice_probes(uint_t what, struct modctl *mod)
4471 {
4472 	tnf_probe_control_t **p;
4473 	tnf_tag_data_t **q;
4474 	struct module *mp = mod->mod_mp;
4475 
4476 	if (!(mp->flags & KOBJ_TNF_PROBE))
4477 		return;
4478 
4479 	for (p = &__tnf_probe_list_head; *p; )
4480 		if (kobj_addrcheck(mp, (char *)*p) == 0)
4481 			*p = (*p)->next;
4482 		else
4483 			p = &(*p)->next;
4484 
4485 	for (q = &__tnf_tag_list_head; *q; )
4486 		if (kobj_addrcheck(mp, (char *)*q) == 0)
4487 			*q = (tnf_tag_data_t *)(*q)->tag_version;
4488 		else
4489 			q = (tnf_tag_data_t **)&(*q)->tag_version;
4490 
4491 	tnf_changed_probe_list = 1;
4492 }
4493 
4494 int
4495 tnf_splice_probes(int boot_load, tnf_probe_control_t *plist,
4496     tnf_tag_data_t *tlist)
4497 {
4498 	int result = 0;
4499 	static int add_notify = 1;
4500 
4501 	if (plist) {
4502 		tnf_probe_control_t *pl;
4503 
4504 		for (pl = plist; pl->next; )
4505 			pl = pl->next;
4506 
4507 		if (!boot_load)
4508 			mutex_enter(&mod_lock);
4509 		tnf_changed_probe_list = 1;
4510 		pl->next = __tnf_probe_list_head;
4511 		__tnf_probe_list_head = plist;
4512 		if (!boot_load)
4513 			mutex_exit(&mod_lock);
4514 		result = 1;
4515 	}
4516 
4517 	if (tlist) {
4518 		tnf_tag_data_t *tl;
4519 
4520 		for (tl = tlist; tl->tag_version; )
4521 			tl = (tnf_tag_data_t *)tl->tag_version;
4522 
4523 		if (!boot_load)
4524 			mutex_enter(&mod_lock);
4525 		tl->tag_version = (tnf_tag_version_t *)__tnf_tag_list_head;
4526 		__tnf_tag_list_head = tlist;
4527 		if (!boot_load)
4528 			mutex_exit(&mod_lock);
4529 		result = 1;
4530 	}
4531 	if (!boot_load && result && add_notify) {
4532 		tnf_add_notifyunload(tnf_unsplice_probes);
4533 		add_notify = 0;
4534 	}
4535 	return (result);
4536 }
4537 
4538 char *kobj_file_buf;
4539 int kobj_file_bufsize;
4540 
4541 /*
4542  * This code is for the purpose of manually recording which files
4543  * needs to go into the boot archive on any given system.
4544  *
4545  * To enable the code, set kobj_file_bufsize in /etc/system
4546  * and reboot the system, then use mdb to look at kobj_file_buf.
4547  */
4548 static void
4549 kobj_record_file(char *filename)
4550 {
4551 	static char *buf;
4552 	static int size = 0;
4553 	int n;
4554 
4555 	if (kobj_file_bufsize == 0)	/* don't bother */
4556 		return;
4557 
4558 	if (kobj_file_buf == NULL) {	/* allocate buffer */
4559 		size = kobj_file_bufsize;
4560 		buf = kobj_file_buf = kobj_alloc(size, KM_WAIT|KM_TMP);
4561 	}
4562 
4563 	n = snprintf(buf, size, "%s\n", filename);
4564 	if (n > size)
4565 		n = size;
4566 	size -= n;
4567 	buf += n;
4568 }
4569 
4570 static int
4571 kobj_boot_fstat(int fd, struct bootstat *stp)
4572 {
4573 #if defined(_OBP)
4574 	if (!standalone && _ioquiesced)
4575 		return (-1);
4576 	return (BOP_FSTAT(ops, fd, stp));
4577 #else
4578 	return (BRD_FSTAT(bfs_ops, fd, stp));
4579 #endif
4580 }
4581 
4582 static int
4583 kobj_boot_open(char *filename, int flags)
4584 {
4585 #if defined(_OBP)
4586 
4587 	/*
4588 	 * If io via bootops is quiesced, it means boot is no longer
4589 	 * available to us.  We make it look as if we can't open the
4590 	 * named file - which is reasonably accurate.
4591 	 */
4592 	if (!standalone && _ioquiesced)
4593 		return (-1);
4594 
4595 	kobj_record_file(filename);
4596 	return (BOP_OPEN(filename, flags));
4597 #else /* x86 */
4598 	kobj_record_file(filename);
4599 	return (BRD_OPEN(bfs_ops, filename, flags));
4600 #endif
4601 }
4602 
4603 static int
4604 kobj_boot_close(int fd)
4605 {
4606 #if defined(_OBP)
4607 	if (!standalone && _ioquiesced)
4608 		return (-1);
4609 
4610 	return (BOP_CLOSE(fd));
4611 #else /* x86 */
4612 	return (BRD_CLOSE(bfs_ops, fd));
4613 #endif
4614 }
4615 
4616 /*ARGSUSED*/
4617 static int
4618 kobj_boot_seek(int fd, off_t hi, off_t lo)
4619 {
4620 #if defined(_OBP)
4621 	return (BOP_SEEK(fd, lo) == -1 ? -1 : 0);
4622 #else
4623 	return (BRD_SEEK(bfs_ops, fd, lo, SEEK_SET));
4624 #endif
4625 }
4626 
4627 static int
4628 kobj_boot_read(int fd, caddr_t buf, size_t size)
4629 {
4630 #if defined(_OBP)
4631 	return (BOP_READ(fd, buf, size));
4632 #else
4633 	return (BRD_READ(bfs_ops, fd, buf, size));
4634 #endif
4635 }
4636 
4637 static int
4638 kobj_boot_compinfo(int fd, struct compinfo *cb)
4639 {
4640 	return (boot_compinfo(fd, cb));
4641 }
4642 
4643 /*
4644  * Check if the file is compressed (for now we handle only gzip).
4645  * It returns CH_MAGIC_GZIP if the file is compressed and 0 otherwise.
4646  */
4647 static int
4648 kobj_is_compressed(intptr_t fd)
4649 {
4650 	struct vnode *vp = (struct vnode *)fd;
4651 	ssize_t resid;
4652 	uint16_t magic_buf;
4653 	int err = 0;
4654 
4655 	if ((err = vn_rdwr(UIO_READ, vp, (caddr_t)((intptr_t)&magic_buf),
4656 	    sizeof (magic_buf), (offset_t)(0),
4657 	    UIO_SYSSPACE, 0, (rlim64_t)0, CRED(), &resid)) != 0) {
4658 
4659 		_kobj_printf(ops, "kobj_is_compressed: vn_rdwr() failed, "
4660 		    "error code 0x%x\n", err);
4661 		return (0);
4662 	}
4663 
4664 	if (magic_buf == CH_MAGIC_GZIP)
4665 		return (CH_MAGIC_GZIP);
4666 
4667 	return (0);
4668 }
4669