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 == ' ')
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(<p->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(<p->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(<p->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(<p->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 (hdr->ch_blksize & (hdr->ch_blksize - 1)) != 0) {
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 }