1 0 stevel /* 2 0 stevel * CDDL HEADER START 3 0 stevel * 4 0 stevel * The contents of this file are subject to the terms of the 5 1544 eschrock * Common Development and Distribution License (the "License"). 6 1544 eschrock * You may not use this file except in compliance with the License. 7 0 stevel * 8 0 stevel * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 0 stevel * or http://www.opensolaris.org/os/licensing. 10 0 stevel * See the License for the specific language governing permissions 11 0 stevel * and limitations under the License. 12 0 stevel * 13 0 stevel * When distributing Covered Code, include this CDDL HEADER in each 14 0 stevel * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 0 stevel * If applicable, add the following below this CDDL HEADER, with the 16 0 stevel * fields enclosed by brackets "[]" replaced with your own identifying 17 0 stevel * information: Portions Copyright [yyyy] [name of copyright owner] 18 0 stevel * 19 0 stevel * CDDL HEADER END 20 0 stevel */ 21 0 stevel /* 22 10047 Pramod * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 0 stevel * Use is subject to license terms. 24 0 stevel */ 25 0 stevel 26 0 stevel /* 27 0 stevel * Kernel's linker/loader 28 0 stevel */ 29 0 stevel 30 0 stevel #include <sys/types.h> 31 0 stevel #include <sys/param.h> 32 0 stevel #include <sys/sysmacros.h> 33 0 stevel #include <sys/systm.h> 34 0 stevel #include <sys/user.h> 35 0 stevel #include <sys/kmem.h> 36 0 stevel #include <sys/reboot.h> 37 0 stevel #include <sys/bootconf.h> 38 0 stevel #include <sys/debug.h> 39 0 stevel #include <sys/uio.h> 40 0 stevel #include <sys/file.h> 41 0 stevel #include <sys/vnode.h> 42 0 stevel #include <sys/user.h> 43 0 stevel #include <sys/mman.h> 44 0 stevel #include <vm/as.h> 45 0 stevel #include <vm/seg_kp.h> 46 0 stevel #include <vm/seg_kmem.h> 47 0 stevel #include <sys/elf.h> 48 0 stevel #include <sys/elf_notes.h> 49 0 stevel #include <sys/vmsystm.h> 50 0 stevel #include <sys/kdi.h> 51 0 stevel #include <sys/atomic.h> 52 0 stevel #include <sys/kmdb.h> 53 0 stevel 54 0 stevel #include <sys/link.h> 55 0 stevel #include <sys/kobj.h> 56 0 stevel #include <sys/ksyms.h> 57 0 stevel #include <sys/disp.h> 58 0 stevel #include <sys/modctl.h> 59 0 stevel #include <sys/varargs.h> 60 0 stevel #include <sys/kstat.h> 61 0 stevel #include <sys/kobj_impl.h> 62 5648 setje #include <sys/fs/decomp.h> 63 0 stevel #include <sys/callb.h> 64 0 stevel #include <sys/cmn_err.h> 65 0 stevel #include <sys/tnf_probe.h> 66 5648 setje #include <sys/zmod.h> 67 5648 setje 68 5648 setje #include <krtld/reloc.h> 69 5648 setje #include <krtld/kobj_kdi.h> 70 0 stevel #include <sys/sha1.h> 71 0 stevel #include <sys/crypto/elfsign.h> 72 0 stevel 73 5648 setje #if !defined(_OBP) 74 0 stevel #include <sys/bootvfs.h> 75 0 stevel #endif 76 0 stevel 77 0 stevel /* 78 0 stevel * do_symbols() error codes 79 0 stevel */ 80 0 stevel #define DOSYM_UNDEF -1 /* undefined symbol */ 81 0 stevel #define DOSYM_UNSAFE -2 /* MT-unsafe driver symbol */ 82 0 stevel 83 5648 setje #if !defined(_OBP) 84 3446 mrj static void synthetic_bootaux(char *, val_t *); 85 5648 setje #endif 86 5648 setje 87 3446 mrj static struct module *load_exec(val_t *, char *); 88 0 stevel static void load_linker(val_t *); 89 3446 mrj static struct modctl *add_primary(const char *filename, int); 90 0 stevel static int bind_primary(val_t *, int); 91 0 stevel static int load_primary(struct module *, int); 92 0 stevel static int load_kmdb(val_t *); 93 0 stevel static int get_progbits(struct module *, struct _buf *); 94 0 stevel static int get_syms(struct module *, struct _buf *); 95 0 stevel static int get_ctf(struct module *, struct _buf *); 96 0 stevel static void get_signature(struct module *, struct _buf *); 97 0 stevel static int do_common(struct module *); 98 0 stevel static void add_dependent(struct module *, struct module *); 99 0 stevel static int do_dependents(struct modctl *, char *, size_t); 100 0 stevel static int do_symbols(struct module *, Elf64_Addr); 101 0 stevel static void module_assign(struct modctl *, struct module *); 102 0 stevel static void free_module_data(struct module *); 103 0 stevel static char *depends_on(struct module *); 104 3446 mrj static char *getmodpath(const char *); 105 0 stevel static char *basename(char *); 106 0 stevel static void attr_val(val_t *); 107 0 stevel static char *find_libmacro(char *); 108 0 stevel static char *expand_libmacro(char *, char *, char *); 109 0 stevel static int read_bootflags(void); 110 5648 setje static int kobj_comp_setup(struct _buf *, struct compinfo *); 111 5648 setje static int kobj_uncomp_blk(struct _buf *, caddr_t, uint_t); 112 5648 setje static int kobj_read_blks(struct _buf *, caddr_t, uint_t, uint_t); 113 0 stevel static int kobj_boot_open(char *, int); 114 0 stevel static int kobj_boot_close(int); 115 0 stevel static int kobj_boot_seek(int, off_t, off_t); 116 0 stevel static int kobj_boot_read(int, caddr_t, size_t); 117 1544 eschrock static int kobj_boot_fstat(int, struct bootstat *); 118 5648 setje static int kobj_boot_compinfo(int, struct compinfo *); 119 0 stevel 120 0 stevel static Sym *lookup_one(struct module *, const char *); 121 0 stevel static void sym_insert(struct module *, char *, symid_t); 122 0 stevel static Sym *sym_lookup(struct module *, Sym *); 123 0 stevel 124 0 stevel static struct kobjopen_tctl *kobjopen_alloc(char *filename); 125 0 stevel static void kobjopen_free(struct kobjopen_tctl *ltp); 126 0 stevel static void kobjopen_thread(struct kobjopen_tctl *ltp); 127 7858 Krishnendu static int kobj_is_compressed(intptr_t); 128 0 stevel 129 0 stevel extern int kcopy(const void *, void *, size_t); 130 0 stevel extern int elf_mach_ok(Ehdr *); 131 0 stevel extern int alloc_gottable(struct module *, caddr_t *, caddr_t *); 132 0 stevel 133 5648 setje #if !defined(_OBP) 134 5648 setje extern int kobj_boot_mountroot(void); 135 5648 setje #endif 136 5648 setje 137 5648 setje static void tnf_unsplice_probes(uint_t, struct modctl *); 138 5648 setje extern tnf_probe_control_t *__tnf_probe_list_head; 139 5648 setje extern tnf_tag_data_t *__tnf_tag_list_head; 140 0 stevel 141 0 stevel extern int modrootloaded; 142 0 stevel extern int swaploaded; 143 0 stevel extern int bop_io_quiesced; 144 0 stevel extern int last_module_id; 145 5648 setje 146 5648 setje extern char stubs_base[]; 147 5648 setje extern char stubs_end[]; 148 0 stevel 149 0 stevel #ifdef KOBJ_DEBUG 150 0 stevel /* 151 0 stevel * Values that can be or'd in to kobj_debug and their effects: 152 0 stevel * 153 0 stevel * D_DEBUG - misc. debugging information. 154 0 stevel * D_SYMBOLS - list symbols and their values as they are entered 155 0 stevel * into the hash table 156 0 stevel * D_RELOCATIONS - display relocation processing information 157 0 stevel * D_LOADING - display information about each module as it 158 0 stevel * is loaded. 159 0 stevel */ 160 0 stevel int kobj_debug = 0; 161 3446 mrj 162 3446 mrj #define KOBJ_MARK(s) if (kobj_debug & D_DEBUG) \ 163 3446 mrj (_kobj_printf(ops, "%d", __LINE__), _kobj_printf(ops, ": %s\n", s)) 164 3446 mrj #else 165 3446 mrj #define KOBJ_MARK(s) /* discard */ 166 0 stevel #endif 167 0 stevel 168 0 stevel #define MODPATH_PROPNAME "module-path" 169 0 stevel 170 0 stevel #ifdef MODDIR_SUFFIX 171 0 stevel static char slash_moddir_suffix_slash[] = MODDIR_SUFFIX "/"; 172 0 stevel #else 173 0 stevel #define slash_moddir_suffix_slash "" 174 0 stevel #endif 175 0 stevel 176 0 stevel #define _moddebug get_weakish_int(&moddebug) 177 0 stevel #define _modrootloaded get_weakish_int(&modrootloaded) 178 0 stevel #define _swaploaded get_weakish_int(&swaploaded) 179 0 stevel #define _ioquiesced get_weakish_int(&bop_io_quiesced) 180 0 stevel 181 0 stevel #define mod(X) (struct module *)((X)->modl_modp->mod_mp) 182 0 stevel 183 0 stevel void *romp; /* rom vector (opaque to us) */ 184 0 stevel struct bootops *ops; /* bootops vector */ 185 0 stevel void *dbvec; /* debug vector */ 186 0 stevel 187 0 stevel /* 188 0 stevel * kobjopen thread control structure 189 0 stevel */ 190 0 stevel struct kobjopen_tctl { 191 0 stevel ksema_t sema; 192 0 stevel char *name; /* name of file */ 193 0 stevel struct vnode *vp; /* vnode return from vn_open() */ 194 0 stevel int Errno; /* error return from vnopen */ 195 0 stevel }; 196 0 stevel 197 0 stevel /* 198 0 stevel * Structure for defining dynamically expandable library macros 199 0 stevel */ 200 0 stevel 201 0 stevel struct lib_macro_info { 202 0 stevel char *lmi_list; /* ptr to list of possible choices */ 203 0 stevel char *lmi_macroname; /* pointer to macro name */ 204 0 stevel ushort_t lmi_ba_index; /* index into bootaux vector */ 205 0 stevel ushort_t lmi_macrolen; /* macro length */ 206 0 stevel } libmacros[] = { 207 0 stevel { NULL, "CPU", BA_CPU, 0 }, 208 0 stevel { NULL, "MMU", BA_MMU, 0 } 209 0 stevel }; 210 0 stevel 211 0 stevel #define NLIBMACROS sizeof (libmacros) / sizeof (struct lib_macro_info) 212 0 stevel 213 0 stevel char *boot_cpu_compatible_list; /* make $CPU available */ 214 0 stevel 215 3446 mrj char *kobj_module_path; /* module search path */ 216 0 stevel vmem_t *text_arena; /* module text arena */ 217 0 stevel static vmem_t *data_arena; /* module data & bss arena */ 218 0 stevel static vmem_t *ctf_arena; /* CTF debug data arena */ 219 0 stevel static struct modctl *kobj_modules = NULL; /* modules loaded */ 220 0 stevel int kobj_mmu_pagesize; /* system pagesize */ 221 0 stevel static int lg_pagesize; /* "large" pagesize */ 222 0 stevel static int kobj_last_module_id = 0; /* id assignment */ 223 0 stevel static kmutex_t kobj_lock; /* protects mach memory list */ 224 0 stevel 225 0 stevel /* 226 0 stevel * The following functions have been implemented by the kernel. 227 0 stevel * However, many 3rd party drivers provide their own implementations 228 0 stevel * of these functions. When such drivers are loaded, messages 229 5331 amw * indicating that these symbols have been multiply defined will be 230 0 stevel * emitted to the console. To avoid alarming customers for no good 231 0 stevel * reason, we simply suppress such warnings for the following set of 232 0 stevel * functions. 233 0 stevel */ 234 0 stevel static char *suppress_sym_list[] = 235 0 stevel { 236 0 stevel "strstr", 237 0 stevel "strncat", 238 0 stevel "strlcat", 239 0 stevel "strlcpy", 240 0 stevel "strspn", 241 0 stevel "memcpy", 242 0 stevel "memset", 243 0 stevel "memmove", 244 0 stevel "memcmp", 245 0 stevel "memchr", 246 0 stevel "__udivdi3", 247 0 stevel "__divdi3", 248 0 stevel "__umoddi3", 249 0 stevel "__moddi3", 250 0 stevel NULL /* This entry must exist */ 251 0 stevel }; 252 0 stevel 253 0 stevel /* indexed by KOBJ_NOTIFY_* */ 254 0 stevel static kobj_notify_list_t *kobj_notifiers[KOBJ_NOTIFY_MAX + 1]; 255 0 stevel 256 0 stevel /* 257 0 stevel * TNF probe management globals 258 0 stevel */ 259 0 stevel tnf_probe_control_t *__tnf_probe_list_head = NULL; 260 0 stevel tnf_tag_data_t *__tnf_tag_list_head = NULL; 261 0 stevel int tnf_changed_probe_list = 0; 262 0 stevel 263 0 stevel /* 264 0 stevel * Prefix for statically defined tracing (SDT) DTrace probes. 265 0 stevel */ 266 0 stevel const char *sdt_prefix = "__dtrace_probe_"; 267 0 stevel 268 0 stevel /* 269 3446 mrj * Beginning and end of the kernel's dynamic text/data segments. 270 0 stevel */ 271 0 stevel static caddr_t _text; 272 0 stevel static caddr_t _etext; 273 3446 mrj static caddr_t _data; 274 3446 mrj 275 3446 mrj /* 276 5648 setje * The sparc linker doesn't create a memory location 277 5648 setje * for a variable named _edata, so _edata can only be 278 5648 setje * referred to, not modified. krtld needs a static 279 5648 setje * variable to modify it - within krtld, of course - 280 5648 setje * outside of krtld, e_data is used in all kernels. 281 5648 setje */ 282 5648 setje #if defined(__sparc) 283 5648 setje static caddr_t _edata; 284 5648 setje #else 285 5648 setje extern caddr_t _edata; 286 5648 setje #endif 287 5648 setje 288 5648 setje Addr dynseg = 0; /* load address of "dynamic" segment */ 289 5648 setje size_t dynsize; /* "dynamic" segment size */ 290 5648 setje 291 0 stevel 292 0 stevel int standalone = 1; /* an unwholey kernel? */ 293 0 stevel int use_iflush; /* iflush after relocations */ 294 0 stevel 295 0 stevel /* 296 0 stevel * _kobj_printf() 297 0 stevel * 298 0 stevel * Common printf function pointer. Can handle only one conversion 299 0 stevel * specification in the format string. Some of the functions invoked 300 0 stevel * through this function pointer cannot handle more that one conversion 301 0 stevel * specification in the format string. 302 0 stevel */ 303 0 stevel void (*_kobj_printf)(void *, const char *, ...); /* printf routine */ 304 5648 setje 305 5648 setje /* 306 5648 setje * Standalone function pointers for use within krtld. 307 5648 setje * Many platforms implement optimized platmod versions of 308 5648 setje * utilities such as bcopy and any such are not yet available 309 5648 setje * until the kernel is more completely stitched together. 310 5648 setje * See kobj_impl.h 311 5648 setje */ 312 5648 setje void (*kobj_bcopy)(const void *, void *, size_t); 313 5648 setje void (*kobj_bzero)(void *, size_t); 314 5648 setje size_t (*kobj_strlcat)(char *, const char *, size_t); 315 0 stevel 316 0 stevel static kobj_stat_t kobj_stat; 317 0 stevel 318 0 stevel #define MINALIGN 8 /* at least a double-word */ 319 0 stevel 320 0 stevel int 321 0 stevel get_weakish_int(int *ip) 322 0 stevel { 323 0 stevel if (standalone) 324 0 stevel return (0); 325 0 stevel return (ip == NULL ? 0 : *ip); 326 0 stevel } 327 0 stevel 328 0 stevel static void * 329 0 stevel get_weakish_pointer(void **ptrp) 330 0 stevel { 331 0 stevel if (standalone) 332 0 stevel return (0); 333 0 stevel return (ptrp == NULL ? 0 : *ptrp); 334 0 stevel } 335 0 stevel 336 0 stevel /* 337 0 stevel * XXX fix dependencies on "kernel"; this should work 338 0 stevel * for other standalone binaries as well. 339 0 stevel * 340 0 stevel * XXX Fix hashing code to use one pointer to 341 0 stevel * hash entries. 342 0 stevel * |----------| 343 0 stevel * | nbuckets | 344 0 stevel * |----------| 345 0 stevel * | nchains | 346 0 stevel * |----------| 347 0 stevel * | bucket[] | 348 0 stevel * |----------| 349 0 stevel * | chain[] | 350 0 stevel * |----------| 351 0 stevel */ 352 0 stevel 353 0 stevel /* 354 0 stevel * Load, bind and relocate all modules that 355 0 stevel * form the primary kernel. At this point, our 356 0 stevel * externals have not been relocated. 357 0 stevel */ 358 0 stevel void 359 0 stevel kobj_init( 360 0 stevel void *romvec, 361 0 stevel void *dvec, 362 0 stevel struct bootops *bootvec, 363 0 stevel val_t *bootaux) 364 0 stevel { 365 0 stevel struct module *mp; 366 0 stevel struct modctl *modp; 367 0 stevel Addr entry; 368 3446 mrj char filename[MAXPATHLEN]; 369 0 stevel 370 0 stevel /* 371 0 stevel * Save these to pass on to 372 0 stevel * the booted standalone. 373 0 stevel */ 374 0 stevel romp = romvec; 375 0 stevel dbvec = dvec; 376 0 stevel 377 0 stevel ops = bootvec; 378 5648 setje kobj_setup_standalone_vectors(); 379 5648 setje 380 3446 mrj KOBJ_MARK("Entered kobj_init()"); 381 3446 mrj 382 3446 mrj (void) BOP_GETPROP(ops, "whoami", filename); 383 0 stevel 384 0 stevel /* 385 0 stevel * We don't support standalone debuggers anymore. The use of kadb 386 0 stevel * will interfere with the later use of kmdb. Let the user mend 387 0 stevel * their ways now. Users will reach this message if they still 388 0 stevel * have the kadb binary on their system (perhaps they used an old 389 0 stevel * bfu, or maybe they intentionally copied it there) and have 390 0 stevel * specified its use in a way that eluded our checking in the boot 391 0 stevel * program. 392 0 stevel */ 393 0 stevel if (dvec != NULL) { 394 0 stevel _kobj_printf(ops, "\nWARNING: Standalone debuggers such as " 395 0 stevel "kadb are no longer supported\n\n"); 396 0 stevel goto fail; 397 0 stevel } 398 0 stevel 399 5648 setje #if defined(_OBP) 400 5648 setje /* 401 5648 setje * OBP allows us to read both the ramdisk and 402 5648 setje * the underlying root fs when root is a disk. 403 5648 setje * This can lower incidences of unbootable systems 404 5648 setje * when the archive is out-of-date with the /etc 405 5648 setje * state files. 406 5648 setje */ 407 5648 setje if (BOP_MOUNTROOT() != BOOT_SVC_OK) { 408 5648 setje _kobj_printf(ops, "can't mount boot fs\n"); 409 5648 setje goto fail; 410 5648 setje } 411 5648 setje #else 412 0 stevel { 413 0 stevel /* on x86, we always boot with a ramdisk */ 414 0 stevel (void) kobj_boot_mountroot(); 415 3446 mrj 416 3446 mrj /* 417 3446 mrj * Now that the ramdisk is mounted, finish boot property 418 3446 mrj * initialization. 419 3446 mrj */ 420 3446 mrj boot_prop_finish(); 421 3446 mrj } 422 3446 mrj 423 3446 mrj #if !defined(_UNIX_KRTLD) 424 3446 mrj /* 425 5648 setje * 'unix' is linked together with 'krtld' into one executable and 426 3446 mrj * the early boot code does -not- hand us any of the dynamic metadata 427 3446 mrj * about the executable. In particular, it does not read in, map or 428 3446 mrj * otherwise look at the program headers. We fake all that up now. 429 3446 mrj * 430 3446 mrj * We do this early as DTrace static probes and tnf probes both call 431 3446 mrj * undefined references. We have to process those relocations before 432 3446 mrj * calling any of them. 433 5648 setje * 434 5648 setje * OBP tells kobj_start() where the ELF image is in memory, so it 435 5648 setje * synthesized bootaux before kobj_init() was called 436 3446 mrj */ 437 3446 mrj if (bootaux[BA_PHDR].ba_ptr == NULL) 438 3446 mrj synthetic_bootaux(filename, bootaux); 439 5648 setje 440 5648 setje #endif /* !_UNIX_KRTLD */ 441 5648 setje #endif /* _OBP */ 442 3446 mrj 443 3446 mrj /* 444 3446 mrj * Save the interesting attribute-values 445 3446 mrj * (scanned by kobj_boot). 446 3446 mrj */ 447 3446 mrj attr_val(bootaux); 448 0 stevel 449 0 stevel /* 450 0 stevel * Set the module search path. 451 0 stevel */ 452 3446 mrj kobj_module_path = getmodpath(filename); 453 0 stevel 454 0 stevel boot_cpu_compatible_list = find_libmacro("CPU"); 455 0 stevel 456 0 stevel /* 457 0 stevel * These two modules have actually been 458 0 stevel * loaded by boot, but we finish the job 459 0 stevel * by introducing them into the world of 460 0 stevel * loadable modules. 461 0 stevel */ 462 0 stevel 463 3446 mrj mp = load_exec(bootaux, filename); 464 0 stevel load_linker(bootaux); 465 0 stevel 466 0 stevel /* 467 0 stevel * Load all the primary dependent modules. 468 0 stevel */ 469 0 stevel if (load_primary(mp, KOBJ_LM_PRIMARY) == -1) 470 0 stevel goto fail; 471 0 stevel 472 0 stevel /* 473 0 stevel * Glue it together. 474 0 stevel */ 475 0 stevel if (bind_primary(bootaux, KOBJ_LM_PRIMARY) == -1) 476 0 stevel goto fail; 477 0 stevel 478 0 stevel entry = bootaux[BA_ENTRY].ba_val; 479 0 stevel 480 0 stevel /* 481 0 stevel * Get the boot flags 482 0 stevel */ 483 0 stevel bootflags(ops); 484 0 stevel 485 0 stevel if (boothowto & RB_VERBOSE) 486 0 stevel kobj_lm_dump(KOBJ_LM_PRIMARY); 487 0 stevel 488 0 stevel kobj_kdi_init(); 489 0 stevel 490 0 stevel if (boothowto & RB_KMDB) { 491 0 stevel if (load_kmdb(bootaux) < 0) 492 0 stevel goto fail; 493 0 stevel } 494 0 stevel 495 0 stevel /* 496 0 stevel * Post setup. 497 0 stevel */ 498 0 stevel s_text = _text; 499 0 stevel e_text = _etext; 500 0 stevel s_data = _data; 501 0 stevel e_data = _edata; 502 0 stevel 503 0 stevel kobj_sync_instruction_memory(s_text, e_text - s_text); 504 0 stevel 505 0 stevel #ifdef KOBJ_DEBUG 506 0 stevel if (kobj_debug & D_DEBUG) 507 0 stevel _kobj_printf(ops, 508 0 stevel "krtld: transferring control to: 0x%p\n", entry); 509 0 stevel #endif 510 0 stevel 511 0 stevel /* 512 0 stevel * Make sure the mod system knows about the modules already loaded. 513 0 stevel */ 514 0 stevel last_module_id = kobj_last_module_id; 515 0 stevel bcopy(kobj_modules, &modules, sizeof (modules)); 516 0 stevel modp = &modules; 517 0 stevel do { 518 0 stevel if (modp->mod_next == kobj_modules) 519 0 stevel modp->mod_next = &modules; 520 0 stevel if (modp->mod_prev == kobj_modules) 521 0 stevel modp->mod_prev = &modules; 522 0 stevel } while ((modp = modp->mod_next) != &modules); 523 0 stevel 524 0 stevel standalone = 0; 525 0 stevel 526 5648 setje #ifdef KOBJ_DEBUG 527 5648 setje if (kobj_debug & D_DEBUG) 528 5648 setje _kobj_printf(ops, 529 5648 setje "krtld: really transferring control to: 0x%p\n", entry); 530 5648 setje #endif 531 5648 setje 532 5648 setje /* restore printf/bcopy/bzero vectors before returning */ 533 5648 setje kobj_restore_vectors(); 534 5648 setje 535 5648 setje #if defined(_DBOOT) 536 5648 setje /* 537 5648 setje * krtld was called from a dboot ELF section, the embedded 538 5648 setje * dboot code contains the real entry via bootaux 539 5648 setje */ 540 0 stevel exitto((caddr_t)entry); 541 5648 setje #else 542 5648 setje /* 543 5648 setje * krtld was directly called from startup 544 5648 setje */ 545 5648 setje return; 546 5648 setje #endif 547 5648 setje 548 0 stevel fail: 549 0 stevel 550 0 stevel _kobj_printf(ops, "krtld: error during initial load/link phase\n"); 551 4159 josephb 552 4159 josephb #if !defined(_UNIX_KRTLD) 553 4159 josephb _kobj_printf(ops, "\n"); 554 4159 josephb _kobj_printf(ops, "krtld could neither locate nor resolve symbols" 555 4159 josephb " for:\n"); 556 4159 josephb _kobj_printf(ops, " %s\n", filename); 557 4159 josephb _kobj_printf(ops, "in the boot archive. Please verify that this" 558 4159 josephb " file\n"); 559 4159 josephb _kobj_printf(ops, "matches what is found in the boot archive.\n"); 560 4159 josephb _kobj_printf(ops, "You may need to boot using the Solaris failsafe to" 561 4159 josephb " fix this.\n"); 562 4159 josephb bop_panic("Unable to boot"); 563 4159 josephb #endif 564 0 stevel } 565 0 stevel 566 5648 setje #if !defined(_UNIX_KRTLD) && !defined(_OBP) 567 5648 setje /* 568 5648 setje * Synthesize additional metadata that describes the executable if 569 5648 setje * krtld's caller didn't do it. 570 3446 mrj * 571 3446 mrj * (When the dynamic executable has an interpreter, the boot program 572 3446 mrj * does all this for us. Where we don't have an interpreter, (or a 573 3446 mrj * even a boot program, perhaps) we have to do this for ourselves.) 574 3446 mrj */ 575 3446 mrj static void 576 3446 mrj synthetic_bootaux(char *filename, val_t *bootaux) 577 3446 mrj { 578 3446 mrj Ehdr ehdr; 579 3446 mrj caddr_t phdrbase; 580 3446 mrj struct _buf *file; 581 3446 mrj int i, n; 582 3446 mrj 583 3446 mrj /* 584 3446 mrj * Elf header 585 3446 mrj */ 586 3446 mrj KOBJ_MARK("synthetic_bootaux()"); 587 3446 mrj KOBJ_MARK(filename); 588 3446 mrj file = kobj_open_file(filename); 589 3446 mrj if (file == (struct _buf *)-1) { 590 3446 mrj _kobj_printf(ops, "krtld: failed to open '%s'\n", filename); 591 3446 mrj return; 592 3446 mrj } 593 3446 mrj KOBJ_MARK("reading program headers"); 594 3446 mrj if (kobj_read_file(file, (char *)&ehdr, sizeof (ehdr), 0) < 0) { 595 3446 mrj _kobj_printf(ops, "krtld: %s: failed to read ehder\n", 596 3446 mrj filename); 597 3446 mrj return; 598 3446 mrj } 599 3446 mrj 600 3446 mrj /* 601 3446 mrj * Program headers 602 3446 mrj */ 603 3446 mrj bootaux[BA_PHNUM].ba_val = ehdr.e_phnum; 604 3446 mrj bootaux[BA_PHENT].ba_val = ehdr.e_phentsize; 605 3446 mrj n = ehdr.e_phentsize * ehdr.e_phnum; 606 3446 mrj 607 3446 mrj phdrbase = kobj_alloc(n, KM_WAIT | KM_TMP); 608 3446 mrj 609 3446 mrj if (kobj_read_file(file, phdrbase, n, ehdr.e_phoff) < 0) { 610 3446 mrj _kobj_printf(ops, "krtld: %s: failed to read phdrs\n", 611 3446 mrj filename); 612 3446 mrj return; 613 3446 mrj } 614 3446 mrj bootaux[BA_PHDR].ba_ptr = phdrbase; 615 3446 mrj kobj_close_file(file); 616 3446 mrj KOBJ_MARK("closed file"); 617 3446 mrj 618 3446 mrj /* 619 3446 mrj * Find the dynamic section address 620 3446 mrj */ 621 3446 mrj for (i = 0; i < ehdr.e_phnum; i++) { 622 3446 mrj Phdr *phdr = (Phdr *)(phdrbase + ehdr.e_phentsize * i); 623 3446 mrj 624 3446 mrj if (phdr->p_type == PT_DYNAMIC) { 625 3446 mrj bootaux[BA_DYNAMIC].ba_ptr = (void *)phdr->p_vaddr; 626 3446 mrj break; 627 3446 mrj } 628 3446 mrj } 629 3446 mrj KOBJ_MARK("synthetic_bootaux() done"); 630 3446 mrj } 631 5648 setje #endif /* !_UNIX_KRTLD && !_OBP */ 632 3446 mrj 633 0 stevel /* 634 0 stevel * Set up any global information derived 635 0 stevel * from attribute/values in the boot or 636 0 stevel * aux vector. 637 0 stevel */ 638 0 stevel static void 639 0 stevel attr_val(val_t *bootaux) 640 0 stevel { 641 0 stevel Phdr *phdr; 642 0 stevel int phnum, phsize; 643 0 stevel int i; 644 0 stevel 645 3446 mrj KOBJ_MARK("attr_val()"); 646 0 stevel kobj_mmu_pagesize = bootaux[BA_PAGESZ].ba_val; 647 0 stevel lg_pagesize = bootaux[BA_LPAGESZ].ba_val; 648 0 stevel use_iflush = bootaux[BA_IFLUSH].ba_val; 649 0 stevel 650 0 stevel phdr = (Phdr *)bootaux[BA_PHDR].ba_ptr; 651 0 stevel phnum = bootaux[BA_PHNUM].ba_val; 652 0 stevel phsize = bootaux[BA_PHENT].ba_val; 653 0 stevel for (i = 0; i < phnum; i++) { 654 0 stevel phdr = (Phdr *)(bootaux[BA_PHDR].ba_val + i * phsize); 655 0 stevel 656 5648 setje if (phdr->p_type != PT_LOAD) { 657 5648 setje continue; 658 5648 setje } 659 0 stevel /* 660 0 stevel * Bounds of the various segments. 661 0 stevel */ 662 0 stevel if (!(phdr->p_flags & PF_X)) { 663 5648 setje #if defined(_RELSEG) 664 5648 setje /* 665 5648 setje * sparc kernel puts the dynamic info 666 5648 setje * into a separate segment, which is 667 5648 setje * free'd in bop_fini() 668 5648 setje */ 669 5648 setje ASSERT(phdr->p_vaddr != 0); 670 0 stevel dynseg = phdr->p_vaddr; 671 5648 setje dynsize = phdr->p_memsz; 672 3446 mrj #else 673 3446 mrj ASSERT(phdr->p_vaddr == 0); 674 3446 mrj #endif 675 0 stevel } else { 676 0 stevel if (phdr->p_flags & PF_W) { 677 3446 mrj _data = (caddr_t)phdr->p_vaddr; 678 3446 mrj _edata = _data + phdr->p_memsz; 679 0 stevel } else { 680 0 stevel _text = (caddr_t)phdr->p_vaddr; 681 0 stevel _etext = _text + phdr->p_memsz; 682 0 stevel } 683 0 stevel } 684 0 stevel } 685 0 stevel 686 0 stevel /* To do the kobj_alloc, _edata needs to be set. */ 687 0 stevel for (i = 0; i < NLIBMACROS; i++) { 688 0 stevel if (bootaux[libmacros[i].lmi_ba_index].ba_ptr != NULL) { 689 0 stevel libmacros[i].lmi_list = kobj_alloc( 690 0 stevel strlen(bootaux[libmacros[i].lmi_ba_index].ba_ptr) + 691 0 stevel 1, KM_WAIT); 692 0 stevel (void) strcpy(libmacros[i].lmi_list, 693 3912 lling bootaux[libmacros[i].lmi_ba_index].ba_ptr); 694 0 stevel } 695 0 stevel libmacros[i].lmi_macrolen = strlen(libmacros[i].lmi_macroname); 696 0 stevel } 697 0 stevel } 698 0 stevel 699 0 stevel /* 700 0 stevel * Set up the booted executable. 701 0 stevel */ 702 0 stevel static struct module * 703 3446 mrj load_exec(val_t *bootaux, char *filename) 704 3446 mrj { 705 0 stevel struct modctl *cp; 706 0 stevel struct module *mp; 707 0 stevel Dyn *dyn; 708 0 stevel Sym *sp; 709 0 stevel int i, lsize, osize, nsize, allocsize; 710 0 stevel char *libname, *tmp; 711 5648 setje char path[MAXPATHLEN]; 712 3446 mrj 713 3446 mrj #ifdef KOBJ_DEBUG 714 3446 mrj if (kobj_debug & D_DEBUG) 715 3446 mrj _kobj_printf(ops, "module path '%s'\n", kobj_module_path); 716 3446 mrj #endif 717 3446 mrj 718 3446 mrj KOBJ_MARK("add_primary"); 719 0 stevel cp = add_primary(filename, KOBJ_LM_PRIMARY); 720 0 stevel 721 3446 mrj KOBJ_MARK("struct module"); 722 0 stevel mp = kobj_zalloc(sizeof (struct module), KM_WAIT); 723 0 stevel cp->mod_mp = mp; 724 0 stevel 725 0 stevel /* 726 0 stevel * We don't have the following information 727 0 stevel * since this module is an executable and not 728 0 stevel * a relocatable .o. 729 0 stevel */ 730 0 stevel mp->symtbl_section = 0; 731 0 stevel mp->shdrs = NULL; 732 0 stevel mp->strhdr = NULL; 733 0 stevel 734 0 stevel /* 735 0 stevel * Since this module is the only exception, 736 0 stevel * we cons up some section headers. 737 0 stevel */ 738 3446 mrj KOBJ_MARK("symhdr"); 739 0 stevel mp->symhdr = kobj_zalloc(sizeof (Shdr), KM_WAIT); 740 3446 mrj 741 3446 mrj KOBJ_MARK("strhdr"); 742 0 stevel mp->strhdr = kobj_zalloc(sizeof (Shdr), KM_WAIT); 743 0 stevel 744 0 stevel mp->symhdr->sh_type = SHT_SYMTAB; 745 0 stevel mp->strhdr->sh_type = SHT_STRTAB; 746 0 stevel /* 747 0 stevel * Scan the dynamic structure. 748 0 stevel */ 749 0 stevel for (dyn = (Dyn *) bootaux[BA_DYNAMIC].ba_ptr; 750 0 stevel dyn->d_tag != DT_NULL; dyn++) { 751 0 stevel switch (dyn->d_tag) { 752 0 stevel case DT_SYMTAB: 753 0 stevel mp->symspace = mp->symtbl = (char *)dyn->d_un.d_ptr; 754 0 stevel mp->symhdr->sh_addr = dyn->d_un.d_ptr; 755 0 stevel break; 756 0 stevel case DT_HASH: 757 0 stevel mp->nsyms = *((uint_t *)dyn->d_un.d_ptr + 1); 758 0 stevel mp->hashsize = *(uint_t *)dyn->d_un.d_ptr; 759 0 stevel break; 760 0 stevel case DT_STRTAB: 761 0 stevel mp->strings = (char *)dyn->d_un.d_ptr; 762 0 stevel mp->strhdr->sh_addr = dyn->d_un.d_ptr; 763 0 stevel break; 764 0 stevel case DT_STRSZ: 765 0 stevel mp->strhdr->sh_size = dyn->d_un.d_val; 766 0 stevel break; 767 0 stevel case DT_SYMENT: 768 0 stevel mp->symhdr->sh_entsize = dyn->d_un.d_val; 769 0 stevel break; 770 0 stevel } 771 0 stevel } 772 0 stevel 773 0 stevel /* 774 0 stevel * Collapse any DT_NEEDED entries into one string. 775 0 stevel */ 776 0 stevel nsize = osize = 0; 777 0 stevel allocsize = MAXPATHLEN; 778 0 stevel 779 3446 mrj KOBJ_MARK("depends_on"); 780 0 stevel mp->depends_on = kobj_alloc(allocsize, KM_WAIT); 781 0 stevel 782 0 stevel for (dyn = (Dyn *) bootaux[BA_DYNAMIC].ba_ptr; 783 0 stevel dyn->d_tag != DT_NULL; dyn++) 784 0 stevel if (dyn->d_tag == DT_NEEDED) { 785 0 stevel char *_lib; 786 0 stevel 787 0 stevel libname = mp->strings + dyn->d_un.d_val; 788 0 stevel if (strchr(libname, '$') != NULL) { 789 0 stevel if ((_lib = expand_libmacro(libname, 790 5648 setje path, path)) != NULL) 791 0 stevel libname = _lib; 792 0 stevel else 793 0 stevel _kobj_printf(ops, "krtld: " 794 0 stevel "load_exec: fail to " 795 0 stevel "expand %s\n", libname); 796 0 stevel } 797 0 stevel lsize = strlen(libname); 798 0 stevel nsize += lsize; 799 0 stevel if (nsize + 1 > allocsize) { 800 3446 mrj KOBJ_MARK("grow depends_on"); 801 0 stevel tmp = kobj_alloc(allocsize + MAXPATHLEN, 802 0 stevel KM_WAIT); 803 0 stevel bcopy(mp->depends_on, tmp, osize); 804 0 stevel kobj_free(mp->depends_on, allocsize); 805 0 stevel mp->depends_on = tmp; 806 0 stevel allocsize += MAXPATHLEN; 807 0 stevel } 808 0 stevel bcopy(libname, mp->depends_on + osize, lsize); 809 5331 amw *(mp->depends_on + nsize) = ' '; /* separate */ 810 0 stevel nsize++; 811 0 stevel osize = nsize; 812 0 stevel } 813 0 stevel if (nsize) { 814 0 stevel mp->depends_on[nsize - 1] = '\0'; /* terminate the string */ 815 0 stevel /* 816 0 stevel * alloc with exact size and copy whatever it got over 817 0 stevel */ 818 3446 mrj KOBJ_MARK("realloc depends_on"); 819 0 stevel tmp = kobj_alloc(nsize, KM_WAIT); 820 0 stevel bcopy(mp->depends_on, tmp, nsize); 821 0 stevel kobj_free(mp->depends_on, allocsize); 822 0 stevel mp->depends_on = tmp; 823 0 stevel } else { 824 0 stevel kobj_free(mp->depends_on, allocsize); 825 0 stevel mp->depends_on = NULL; 826 0 stevel } 827 0 stevel 828 0 stevel mp->flags = KOBJ_EXEC|KOBJ_PRIM; /* NOT a relocatable .o */ 829 0 stevel mp->symhdr->sh_size = mp->nsyms * mp->symhdr->sh_entsize; 830 0 stevel /* 831 0 stevel * We allocate our own table since we don't 832 0 stevel * hash undefined references. 833 0 stevel */ 834 3446 mrj KOBJ_MARK("chains"); 835 0 stevel mp->chains = kobj_zalloc(mp->nsyms * sizeof (symid_t), KM_WAIT); 836 3446 mrj KOBJ_MARK("buckets"); 837 0 stevel mp->buckets = kobj_zalloc(mp->hashsize * sizeof (symid_t), KM_WAIT); 838 0 stevel 839 0 stevel mp->text = _text; 840 0 stevel mp->data = _data; 841 3446 mrj 842 3446 mrj mp->text_size = _etext - _text; 843 3446 mrj mp->data_size = _edata - _data; 844 3446 mrj 845 0 stevel cp->mod_text = mp->text; 846 0 stevel cp->mod_text_size = mp->text_size; 847 0 stevel 848 0 stevel mp->filename = cp->mod_filename; 849 0 stevel 850 0 stevel #ifdef KOBJ_DEBUG 851 0 stevel if (kobj_debug & D_LOADING) { 852 0 stevel _kobj_printf(ops, "krtld: file=%s\n", mp->filename); 853 0 stevel _kobj_printf(ops, "\ttext: 0x%p", mp->text); 854 0 stevel _kobj_printf(ops, " size: 0x%x\n", mp->text_size); 855 0 stevel _kobj_printf(ops, "\tdata: 0x%p", mp->data); 856 0 stevel _kobj_printf(ops, " dsize: 0x%x\n", mp->data_size); 857 0 stevel } 858 0 stevel #endif /* KOBJ_DEBUG */ 859 0 stevel 860 0 stevel /* 861 0 stevel * Insert symbols into the hash table. 862 0 stevel */ 863 0 stevel for (i = 0; i < mp->nsyms; i++) { 864 0 stevel sp = (Sym *)(mp->symtbl + i * mp->symhdr->sh_entsize); 865 0 stevel 866 0 stevel if (sp->st_name == 0 || sp->st_shndx == SHN_UNDEF) 867 0 stevel continue; 868 5648 setje #if defined(__sparc) 869 0 stevel /* 870 0 stevel * Register symbols are ignored in the kernel 871 0 stevel */ 872 0 stevel if (ELF_ST_TYPE(sp->st_info) == STT_SPARC_REGISTER) 873 0 stevel continue; 874 0 stevel #endif /* __sparc */ 875 0 stevel 876 0 stevel sym_insert(mp, mp->strings + sp->st_name, i); 877 0 stevel } 878 0 stevel 879 3446 mrj KOBJ_MARK("load_exec done"); 880 0 stevel return (mp); 881 0 stevel } 882 0 stevel 883 0 stevel /* 884 3446 mrj * Set up the linker module (if it's compiled in, LDNAME is NULL) 885 0 stevel */ 886 0 stevel static void 887 0 stevel load_linker(val_t *bootaux) 888 0 stevel { 889 0 stevel struct module *kmp = (struct module *)kobj_modules->mod_mp; 890 0 stevel struct module *mp; 891 0 stevel struct modctl *cp; 892 0 stevel int i; 893 0 stevel Shdr *shp; 894 0 stevel Sym *sp; 895 0 stevel int shsize; 896 0 stevel char *dlname = (char *)bootaux[BA_LDNAME].ba_ptr; 897 3446 mrj 898 3446 mrj /* 899 3446 mrj * On some architectures, krtld is compiled into the kernel. 900 3446 mrj */ 901 3446 mrj if (dlname == NULL) 902 3446 mrj return; 903 0 stevel 904 0 stevel cp = add_primary(dlname, KOBJ_LM_PRIMARY); 905 0 stevel 906 0 stevel mp = kobj_zalloc(sizeof (struct module), KM_WAIT); 907 0 stevel 908 0 stevel cp->mod_mp = mp; 909 0 stevel mp->hdr = *(Ehdr *)bootaux[BA_LDELF].ba_ptr; 910 0 stevel shsize = mp->hdr.e_shentsize * mp->hdr.e_shnum; 911 0 stevel mp->shdrs = kobj_alloc(shsize, KM_WAIT); 912 0 stevel bcopy(bootaux[BA_LDSHDR].ba_ptr, mp->shdrs, shsize); 913 0 stevel 914 0 stevel for (i = 1; i < (int)mp->hdr.e_shnum; i++) { 915 0 stevel shp = (Shdr *)(mp->shdrs + (i * mp->hdr.e_shentsize)); 916 0 stevel 917 0 stevel if (shp->sh_flags & SHF_ALLOC) { 918 0 stevel if (shp->sh_flags & SHF_WRITE) { 919 0 stevel if (mp->data == NULL) 920 0 stevel mp->data = (char *)shp->sh_addr; 921 0 stevel } else if (mp->text == NULL) { 922 0 stevel mp->text = (char *)shp->sh_addr; 923 0 stevel } 924 0 stevel } 925 0 stevel if (shp->sh_type == SHT_SYMTAB) { 926 0 stevel mp->symtbl_section = i; 927 0 stevel mp->symhdr = shp; 928 0 stevel mp->symspace = mp->symtbl = (char *)shp->sh_addr; 929 0 stevel } 930 0 stevel } 931 0 stevel mp->nsyms = mp->symhdr->sh_size / mp->symhdr->sh_entsize; 932 0 stevel mp->flags = KOBJ_INTERP|KOBJ_PRIM; 933 0 stevel mp->strhdr = (Shdr *) 934 3912 lling (mp->shdrs + mp->symhdr->sh_link * mp->hdr.e_shentsize); 935 0 stevel mp->strings = (char *)mp->strhdr->sh_addr; 936 0 stevel mp->hashsize = kobj_gethashsize(mp->nsyms); 937 0 stevel 938 0 stevel mp->symsize = mp->symhdr->sh_size + mp->strhdr->sh_size + sizeof (int) + 939 3912 lling (mp->hashsize + mp->nsyms) * sizeof (symid_t); 940 0 stevel 941 0 stevel mp->chains = kobj_zalloc(mp->nsyms * sizeof (symid_t), KM_WAIT); 942 0 stevel mp->buckets = kobj_zalloc(mp->hashsize * sizeof (symid_t), KM_WAIT); 943 0 stevel 944 0 stevel mp->bss = bootaux[BA_BSS].ba_val; 945 0 stevel mp->bss_align = 0; /* pre-aligned during allocation */ 946 0 stevel mp->bss_size = (uintptr_t)_edata - mp->bss; 947 0 stevel mp->text_size = _etext - mp->text; 948 0 stevel mp->data_size = _edata - mp->data; 949 0 stevel mp->filename = cp->mod_filename; 950 0 stevel cp->mod_text = mp->text; 951 0 stevel cp->mod_text_size = mp->text_size; 952 0 stevel 953 0 stevel /* 954 0 stevel * Now that we've figured out where the linker is, 955 0 stevel * set the limits for the booted object. 956 0 stevel */ 957 0 stevel kmp->text_size = (size_t)(mp->text - kmp->text); 958 0 stevel kmp->data_size = (size_t)(mp->data - kmp->data); 959 0 stevel kobj_modules->mod_text_size = kmp->text_size; 960 0 stevel 961 0 stevel #ifdef KOBJ_DEBUG 962 0 stevel if (kobj_debug & D_LOADING) { 963 0 stevel _kobj_printf(ops, "krtld: file=%s\n", mp->filename); 964 0 stevel _kobj_printf(ops, "\ttext:0x%p", mp->text); 965 0 stevel _kobj_printf(ops, " size: 0x%x\n", mp->text_size); 966 0 stevel _kobj_printf(ops, "\tdata:0x%p", mp->data); 967 0 stevel _kobj_printf(ops, " dsize: 0x%x\n", mp->data_size); 968 0 stevel } 969 0 stevel #endif /* KOBJ_DEBUG */ 970 0 stevel 971 0 stevel /* 972 0 stevel * Insert the symbols into the hash table. 973 0 stevel */ 974 0 stevel for (i = 0; i < mp->nsyms; i++) { 975 0 stevel sp = (Sym *)(mp->symtbl + i * mp->symhdr->sh_entsize); 976 0 stevel 977 0 stevel if (sp->st_name == 0 || sp->st_shndx == SHN_UNDEF) 978 0 stevel continue; 979 0 stevel if (ELF_ST_BIND(sp->st_info) == STB_GLOBAL) { 980 0 stevel if (sp->st_shndx == SHN_COMMON) 981 0 stevel sp->st_shndx = SHN_ABS; 982 0 stevel } 983 0 stevel sym_insert(mp, mp->strings + sp->st_name, i); 984 0 stevel } 985 0 stevel 986 0 stevel } 987 0 stevel 988 0 stevel static kobj_notify_list_t ** 989 0 stevel kobj_notify_lookup(uint_t type) 990 0 stevel { 991 0 stevel ASSERT(type != 0 && type < sizeof (kobj_notifiers) / 992 0 stevel sizeof (kobj_notify_list_t *)); 993 0 stevel 994 0 stevel return (&kobj_notifiers[type]); 995 0 stevel } 996 0 stevel 997 0 stevel int 998 0 stevel kobj_notify_add(kobj_notify_list_t *knp) 999 0 stevel { 1000 0 stevel kobj_notify_list_t **knl; 1001 0 stevel 1002 0 stevel knl = kobj_notify_lookup(knp->kn_type); 1003 0 stevel 1004 0 stevel knp->kn_next = NULL; 1005 0 stevel knp->kn_prev = NULL; 1006 0 stevel 1007 0 stevel mutex_enter(&kobj_lock); 1008 0 stevel 1009 0 stevel if (*knl != NULL) { 1010 0 stevel (*knl)->kn_prev = knp; 1011 0 stevel knp->kn_next = *knl; 1012 0 stevel } 1013 0 stevel (*knl) = knp; 1014 0 stevel 1015 0 stevel mutex_exit(&kobj_lock); 1016 0 stevel return (0); 1017 0 stevel } 1018 0 stevel 1019 0 stevel int 1020 0 stevel kobj_notify_remove(kobj_notify_list_t *knp) 1021 0 stevel { 1022 0 stevel kobj_notify_list_t **knl = kobj_notify_lookup(knp->kn_type); 1023 0 stevel kobj_notify_list_t *tknp; 1024 0 stevel 1025 0 stevel mutex_enter(&kobj_lock); 1026 0 stevel 1027 0 stevel /* LINTED */ 1028 0 stevel if (tknp = knp->kn_next) 1029 0 stevel tknp->kn_prev = knp->kn_prev; 1030 0 stevel 1031 0 stevel /* LINTED */ 1032 0 stevel if (tknp = knp->kn_prev) 1033 0 stevel tknp->kn_next = knp->kn_next; 1034 0 stevel else 1035 0 stevel *knl = knp->kn_next; 1036 0 stevel 1037 0 stevel mutex_exit(&kobj_lock); 1038 0 stevel 1039 0 stevel return (0); 1040 0 stevel } 1041 0 stevel 1042 0 stevel /* 1043 0 stevel * Notify all interested callbacks of a specified change in module state. 1044 0 stevel */ 1045 0 stevel static void 1046 0 stevel kobj_notify(int type, struct modctl *modp) 1047 0 stevel { 1048 0 stevel kobj_notify_list_t *knp; 1049 0 stevel 1050 0 stevel if (modp->mod_loadflags & MOD_NONOTIFY || standalone) 1051 0 stevel return; 1052 0 stevel 1053 0 stevel mutex_enter(&kobj_lock); 1054 0 stevel 1055 0 stevel for (knp = *(kobj_notify_lookup(type)); knp != NULL; knp = knp->kn_next) 1056 0 stevel knp->kn_func(type, modp); 1057 0 stevel 1058 0 stevel /* 1059 0 stevel * KDI notification must be last (it has to allow for work done by the 1060 0 stevel * other notification callbacks), so we call it manually. 1061 0 stevel */ 1062 0 stevel kobj_kdi_mod_notify(type, modp); 1063 0 stevel 1064 0 stevel mutex_exit(&kobj_lock); 1065 0 stevel } 1066 0 stevel 1067 0 stevel /* 1068 5648 setje * Create the module path. 1069 5648 setje */ 1070 0 stevel static char * 1071 3446 mrj getmodpath(const char *filename) 1072 0 stevel { 1073 5648 setje char *path = kobj_zalloc(MAXPATHLEN, KM_WAIT); 1074 5648 setje 1075 5648 setje /* 1076 5648 setje * Platform code gets first crack, then add 1077 5648 setje * the default components 1078 5648 setje */ 1079 5648 setje mach_modpath(path, filename); 1080 5648 setje if (*path != '\0') 1081 5648 setje (void) strcat(path, " "); 1082 3446 mrj return (strcat(path, MOD_DEFPATH)); 1083 0 stevel } 1084 0 stevel 1085 0 stevel static struct modctl * 1086 3446 mrj add_primary(const char *filename, int lmid) 1087 0 stevel { 1088 0 stevel struct modctl *cp; 1089 0 stevel 1090 0 stevel cp = kobj_zalloc(sizeof (struct modctl), KM_WAIT); 1091 0 stevel 1092 0 stevel cp->mod_filename = kobj_alloc(strlen(filename) + 1, KM_WAIT); 1093 0 stevel 1094 0 stevel /* 1095 0 stevel * For symbol lookup, we assemble our own 1096 0 stevel * modctl list of the primary modules. 1097 0 stevel */ 1098 0 stevel 1099 0 stevel (void) strcpy(cp->mod_filename, filename); 1100 0 stevel cp->mod_modname = basename(cp->mod_filename); 1101 0 stevel 1102 0 stevel /* set values for modinfo assuming that the load will work */ 1103 0 stevel cp->mod_prim = 1; 1104 0 stevel cp->mod_loaded = 1; 1105 0 stevel cp->mod_installed = 1; 1106 0 stevel cp->mod_loadcnt = 1; 1107 0 stevel cp->mod_loadflags = MOD_NOAUTOUNLOAD; 1108 0 stevel 1109 0 stevel cp->mod_id = kobj_last_module_id++; 1110 0 stevel 1111 0 stevel /* 1112 0 stevel * Link the module in. We'll pass this info on 1113 0 stevel * to the mod squad later. 1114 0 stevel */ 1115 0 stevel if (kobj_modules == NULL) { 1116 0 stevel kobj_modules = cp; 1117 0 stevel cp->mod_prev = cp->mod_next = cp; 1118 0 stevel } else { 1119 0 stevel cp->mod_prev = kobj_modules->mod_prev; 1120 0 stevel cp->mod_next = kobj_modules; 1121 0 stevel kobj_modules->mod_prev->mod_next = cp; 1122 0 stevel kobj_modules->mod_prev = cp; 1123 0 stevel } 1124 0 stevel 1125 0 stevel kobj_lm_append(lmid, cp); 1126 0 stevel 1127 0 stevel return (cp); 1128 0 stevel } 1129 0 stevel 1130 0 stevel static int 1131 0 stevel bind_primary(val_t *bootaux, int lmid) 1132 0 stevel { 1133 0 stevel struct modctl_list *linkmap = kobj_lm_lookup(lmid); 1134 0 stevel struct modctl_list *lp; 1135 0 stevel struct module *mp; 1136 0 stevel 1137 0 stevel /* 1138 0 stevel * Do common symbols. 1139 0 stevel */ 1140 0 stevel for (lp = linkmap; lp; lp = lp->modl_next) { 1141 0 stevel mp = mod(lp); 1142 0 stevel 1143 0 stevel /* 1144 0 stevel * Don't do common section relocations for modules that 1145 0 stevel * don't need it. 1146 0 stevel */ 1147 0 stevel if (mp->flags & (KOBJ_EXEC|KOBJ_INTERP)) 1148 0 stevel continue; 1149 0 stevel 1150 0 stevel if (do_common(mp) < 0) 1151 0 stevel return (-1); 1152 0 stevel } 1153 0 stevel 1154 0 stevel /* 1155 0 stevel * Resolve symbols. 1156 0 stevel */ 1157 0 stevel for (lp = linkmap; lp; lp = lp->modl_next) { 1158 0 stevel mp = mod(lp); 1159 0 stevel 1160 0 stevel if (do_symbols(mp, 0) < 0) 1161 0 stevel return (-1); 1162 0 stevel } 1163 0 stevel 1164 0 stevel /* 1165 0 stevel * Do relocations. 1166 0 stevel */ 1167 0 stevel for (lp = linkmap; lp; lp = lp->modl_next) { 1168 0 stevel mp = mod(lp); 1169 0 stevel 1170 0 stevel if (mp->flags & KOBJ_EXEC) { 1171 3446 mrj Dyn *dyn; 1172 3446 mrj Word relasz = 0, relaent = 0; 1173 3446 mrj Word shtype; 1174 3446 mrj char *rela = NULL; 1175 0 stevel 1176 0 stevel for (dyn = (Dyn *)bootaux[BA_DYNAMIC].ba_ptr; 1177 0 stevel dyn->d_tag != DT_NULL; dyn++) { 1178 0 stevel switch (dyn->d_tag) { 1179 0 stevel case DT_RELASZ: 1180 0 stevel case DT_RELSZ: 1181 0 stevel relasz = dyn->d_un.d_val; 1182 0 stevel break; 1183 0 stevel case DT_RELAENT: 1184 0 stevel case DT_RELENT: 1185 0 stevel relaent = dyn->d_un.d_val; 1186 0 stevel break; 1187 0 stevel case DT_RELA: 1188 0 stevel shtype = SHT_RELA; 1189 5648 setje rela = (char *)dyn->d_un.d_ptr; 1190 0 stevel break; 1191 0 stevel case DT_REL: 1192 0 stevel shtype = SHT_REL; 1193 5648 setje rela = (char *)dyn->d_un.d_ptr; 1194 0 stevel break; 1195 0 stevel } 1196 0 stevel } 1197 0 stevel if (relasz == 0 || 1198 0 stevel relaent == 0 || rela == NULL) { 1199 0 stevel _kobj_printf(ops, "krtld: bind_primary(): " 1200 0 stevel "no relocation information found for " 1201 0 stevel "module %s\n", mp->filename); 1202 0 stevel return (-1); 1203 0 stevel } 1204 0 stevel #ifdef KOBJ_DEBUG 1205 0 stevel if (kobj_debug & D_RELOCATIONS) 1206 0 stevel _kobj_printf(ops, "krtld: relocating: file=%s " 1207 0 stevel "KOBJ_EXEC\n", mp->filename); 1208 0 stevel #endif 1209 0 stevel if (do_relocate(mp, rela, shtype, relasz/relaent, 1210 0 stevel relaent, (Addr)mp->text) < 0) 1211 0 stevel return (-1); 1212 0 stevel } else { 1213 0 stevel if (do_relocations(mp) < 0) 1214 0 stevel return (-1); 1215 0 stevel } 1216 0 stevel 1217 0 stevel kobj_sync_instruction_memory(mp->text, mp->text_size); 1218 0 stevel } 1219 0 stevel 1220 0 stevel for (lp = linkmap; lp; lp = lp->modl_next) { 1221 0 stevel mp = mod(lp); 1222 0 stevel 1223 0 stevel /* 1224 0 stevel * We need to re-read the full symbol table for the boot file, 1225 0 stevel * since we couldn't use the full one before. We also need to 1226 0 stevel * load the CTF sections of both the boot file and the 1227 0 stevel * interpreter (us). 1228 0 stevel */ 1229 0 stevel if (mp->flags & KOBJ_EXEC) { 1230 0 stevel struct _buf *file; 1231 0 stevel int n; 1232 0 stevel 1233 0 stevel file = kobj_open_file(mp->filename); 1234 0 stevel if (file == (struct _buf *)-1) 1235 0 stevel return (-1); 1236 0 stevel if (kobj_read_file(file, (char *)&mp->hdr, 1237 0 stevel sizeof (mp->hdr), 0) < 0) 1238 0 stevel return (-1); 1239 0 stevel n = mp->hdr.e_shentsize * mp->hdr.e_shnum; 1240 0 stevel mp->shdrs = kobj_alloc(n, KM_WAIT); 1241 0 stevel if (kobj_read_file(file, mp->shdrs, n, 1242 0 stevel mp->hdr.e_shoff) < 0) 1243 0 stevel return (-1); 1244 0 stevel if (get_syms(mp, file) < 0) 1245 0 stevel return (-1); 1246 0 stevel if (get_ctf(mp, file) < 0) 1247 0 stevel return (-1); 1248 0 stevel kobj_close_file(file); 1249 0 stevel mp->flags |= KOBJ_RELOCATED; 1250 0 stevel 1251 0 stevel } else if (mp->flags & KOBJ_INTERP) { 1252 0 stevel struct _buf *file; 1253 0 stevel 1254 0 stevel /* 1255 0 stevel * The interpreter path fragment in mp->filename 1256 0 stevel * will already have the module directory suffix 1257 0 stevel * in it (if appropriate). 1258 0 stevel */ 1259 0 stevel file = kobj_open_path(mp->filename, 1, 0); 1260 0 stevel if (file == (struct _buf *)-1) 1261 0 stevel return (-1); 1262 0 stevel if (get_ctf(mp, file) < 0) 1263 0 stevel return (-1); 1264 0 stevel kobj_close_file(file); 1265 0 stevel mp->flags |= KOBJ_RELOCATED; 1266 0 stevel } 1267 0 stevel } 1268 0 stevel 1269 0 stevel return (0); 1270 0 stevel } 1271 0 stevel 1272 0 stevel static struct modctl * 1273 0 stevel mod_already_loaded(char *modname) 1274 0 stevel { 1275 0 stevel struct modctl *mctl = kobj_modules; 1276 0 stevel 1277 0 stevel do { 1278 0 stevel if (strcmp(modname, mctl->mod_filename) == 0) 1279 0 stevel return (mctl); 1280 0 stevel mctl = mctl->mod_next; 1281 0 stevel 1282 0 stevel } while (mctl != kobj_modules); 1283 0 stevel 1284 0 stevel return (NULL); 1285 0 stevel } 1286 0 stevel 1287 0 stevel /* 1288 0 stevel * Load all the primary dependent modules. 1289 0 stevel */ 1290 0 stevel static int 1291 0 stevel load_primary(struct module *mp, int lmid) 1292 0 stevel { 1293 0 stevel struct modctl *cp; 1294 0 stevel struct module *dmp; 1295 0 stevel char *p, *q; 1296 0 stevel char modname[MODMAXNAMELEN]; 1297 0 stevel 1298 0 stevel if ((p = mp->depends_on) == NULL) 1299 0 stevel return (0); 1300 0 stevel 1301 0 stevel /* CONSTANTCONDITION */ 1302 0 stevel while (1) { 1303 0 stevel /* 1304 0 stevel * Skip space. 1305 0 stevel */ 1306 0 stevel while (*p && (*p == ' ' || *p == '\t')) 1307 0 stevel p++; 1308 0 stevel /* 1309 0 stevel * Get module name. 1310 0 stevel */ 1311 0 stevel q = modname; 1312 0 stevel while (*p && *p != ' ' && *p != '\t') 1313 0 stevel *q++ = *p++; 1314 0 stevel 1315 0 stevel if (q == modname) 1316 0 stevel break; 1317 0 stevel 1318 0 stevel *q = '\0'; 1319 0 stevel /* 1320 0 stevel * Check for dup dependencies. 1321 0 stevel */ 1322 0 stevel if (strcmp(modname, "dtracestubs") == 0 || 1323 0 stevel mod_already_loaded(modname) != NULL) 1324 0 stevel continue; 1325 0 stevel 1326 0 stevel cp = add_primary(modname, lmid); 1327 0 stevel cp->mod_busy = 1; 1328 0 stevel /* 1329 0 stevel * Load it. 1330 0 stevel */ 1331 0 stevel (void) kobj_load_module(cp, 1); 1332 0 stevel cp->mod_busy = 0; 1333 0 stevel 1334 0 stevel if ((dmp = cp->mod_mp) == NULL) { 1335 0 stevel cp->mod_loaded = 0; 1336 0 stevel cp->mod_installed = 0; 1337 0 stevel cp->mod_loadcnt = 0; 1338 0 stevel return (-1); 1339 0 stevel } 1340 0 stevel 1341 0 stevel add_dependent(mp, dmp); 1342 0 stevel dmp->flags |= KOBJ_PRIM; 1343 0 stevel 1344 0 stevel /* 1345 0 stevel * Recurse. 1346 0 stevel */ 1347 0 stevel if (load_primary(dmp, lmid) == -1) { 1348 0 stevel cp->mod_loaded = 0; 1349 0 stevel cp->mod_installed = 0; 1350 0 stevel cp->mod_loadcnt = 0; 1351 0 stevel return (-1); 1352 0 stevel } 1353 0 stevel } 1354 0 stevel return (0); 1355 0 stevel } 1356 0 stevel 1357 0 stevel static int 1358 2191 szhou console_is_usb_serial(void) 1359 2191 szhou { 1360 2191 szhou char *console; 1361 2191 szhou int len, ret; 1362 2191 szhou 1363 2191 szhou if ((len = BOP_GETPROPLEN(ops, "console")) == -1) 1364 2191 szhou return (0); 1365 2191 szhou 1366 2191 szhou console = kobj_zalloc(len, KM_WAIT|KM_TMP); 1367 2191 szhou (void) BOP_GETPROP(ops, "console", console); 1368 2191 szhou ret = (strcmp(console, "usb-serial") == 0); 1369 2191 szhou kobj_free(console, len); 1370 2191 szhou 1371 2191 szhou return (ret); 1372 2191 szhou } 1373 2191 szhou 1374 2191 szhou static int 1375 0 stevel load_kmdb(val_t *bootaux) 1376 0 stevel { 1377 0 stevel struct modctl *mctl; 1378 0 stevel struct module *mp; 1379 0 stevel Sym *sym; 1380 2191 szhou 1381 2191 szhou if (console_is_usb_serial()) { 1382 2191 szhou _kobj_printf(ops, "kmdb not loaded " 1383 2191 szhou "(unsupported on usb serial console)\n"); 1384 2191 szhou return (0); 1385 2191 szhou } 1386 0 stevel 1387 0 stevel _kobj_printf(ops, "Loading kmdb...\n"); 1388 0 stevel 1389 0 stevel if ((mctl = add_primary("misc/kmdbmod", KOBJ_LM_DEBUGGER)) == NULL) 1390 0 stevel return (-1); 1391 0 stevel 1392 0 stevel mctl->mod_busy = 1; 1393 0 stevel (void) kobj_load_module(mctl, 1); 1394 0 stevel mctl->mod_busy = 0; 1395 0 stevel 1396 0 stevel if ((mp = mctl->mod_mp) == NULL) 1397 0 stevel return (-1); 1398 0 stevel 1399 0 stevel mp->flags |= KOBJ_PRIM; 1400 0 stevel 1401 0 stevel if (load_primary(mp, KOBJ_LM_DEBUGGER) < 0) 1402 0 stevel return (-1); 1403 0 stevel 1404 0 stevel if (boothowto & RB_VERBOSE) 1405 0 stevel kobj_lm_dump(KOBJ_LM_DEBUGGER); 1406 0 stevel 1407 0 stevel if (bind_primary(bootaux, KOBJ_LM_DEBUGGER) < 0) 1408 0 stevel return (-1); 1409 0 stevel 1410 0 stevel if ((sym = lookup_one(mctl->mod_mp, "kctl_boot_activate")) == NULL) 1411 0 stevel return (-1); 1412 3446 mrj 1413 3446 mrj #ifdef KOBJ_DEBUG 1414 3446 mrj if (kobj_debug & D_DEBUG) { 1415 3446 mrj _kobj_printf(ops, "calling kctl_boot_activate() @ 0x%lx\n", 1416 3446 mrj sym->st_value); 1417 3446 mrj _kobj_printf(ops, "\tops 0x%p\n", ops); 1418 3446 mrj _kobj_printf(ops, "\tromp 0x%p\n", romp); 1419 3446 mrj } 1420 3446 mrj #endif 1421 0 stevel 1422 0 stevel if (((kctl_boot_activate_f *)sym->st_value)(ops, romp, 0, 1423 0 stevel (const char **)kobj_kmdb_argv) < 0) 1424 0 stevel return (-1); 1425 0 stevel 1426 0 stevel return (0); 1427 0 stevel } 1428 0 stevel 1429 0 stevel /* 1430 0 stevel * Return a string listing module dependencies. 1431 0 stevel */ 1432 0 stevel static char * 1433 0 stevel depends_on(struct module *mp) 1434 0 stevel { 1435 0 stevel Sym *sp; 1436 0 stevel char *depstr, *q; 1437 0 stevel 1438 0 stevel /* 1439 0 stevel * The module doesn't have a depends_on value, so let's try it the 1440 0 stevel * old-fashioned way - via "_depends_on" 1441 0 stevel */ 1442 0 stevel if ((sp = lookup_one(mp, "_depends_on")) == NULL) 1443 0 stevel return (NULL); 1444 0 stevel 1445 0 stevel q = (char *)sp->st_value; 1446 0 stevel 1447 0 stevel /* 1448 0 stevel * Idiot checks. Make sure it's 1449 0 stevel * in-bounds and NULL terminated. 1450 0 stevel */ 1451 0 stevel if (kobj_addrcheck(mp, q) || q[sp->st_size - 1] != '\0') { 1452 0 stevel _kobj_printf(ops, "Error processing dependency for %s\n", 1453 0 stevel mp->filename); 1454 0 stevel return (NULL); 1455 0 stevel } 1456 0 stevel 1457 0 stevel depstr = (char *)kobj_alloc(strlen(q) + 1, KM_WAIT); 1458 0 stevel (void) strcpy(depstr, q); 1459 0 stevel 1460 0 stevel return (depstr); 1461 0 stevel } 1462 0 stevel 1463 0 stevel void 1464 0 stevel kobj_getmodinfo(void *xmp, struct modinfo *modinfo) 1465 0 stevel { 1466 0 stevel struct module *mp; 1467 0 stevel mp = (struct module *)xmp; 1468 0 stevel 1469 0 stevel modinfo->mi_base = mp->text; 1470 0 stevel modinfo->mi_size = mp->text_size + mp->data_size; 1471 0 stevel } 1472 0 stevel 1473 0 stevel /* 1474 0 stevel * kobj_export_ksyms() performs the following services: 1475 0 stevel * 1476 0 stevel * (1) Migrates the symbol table from boot/kobj memory to the ksyms arena. 1477 0 stevel * (2) Removes unneeded symbols to save space. 1478 0 stevel * (3) Reduces memory footprint by using VM_BESTFIT allocations. 1479 0 stevel * (4) Makes the symbol table visible to /dev/ksyms. 1480 0 stevel */ 1481 0 stevel static void 1482 0 stevel kobj_export_ksyms(struct module *mp) 1483 0 stevel { 1484 0 stevel Sym *esp = (Sym *)(mp->symtbl + mp->symhdr->sh_size); 1485 0 stevel Sym *sp, *osp; 1486 0 stevel char *name; 1487 0 stevel size_t namelen; 1488 0 stevel struct module *omp; 1489 0 stevel uint_t nsyms; 1490 0 stevel size_t symsize = mp->symhdr->sh_entsize; 1491 0 stevel size_t locals = 1; 1492 0 stevel size_t strsize; 1493 0 stevel 1494 0 stevel /* 1495 0 stevel * Make a copy of the original module structure. 1496 0 stevel */ 1497 0 stevel omp = kobj_alloc(sizeof (struct module), KM_WAIT); 1498 0 stevel bcopy(mp, omp, sizeof (struct module)); 1499 0 stevel 1500 0 stevel /* 1501 0 stevel * Compute the sizes of the new symbol table sections. 1502 0 stevel */ 1503 0 stevel for (nsyms = strsize = 1, osp = (Sym *)omp->symtbl; osp < esp; osp++) { 1504 0 stevel if (osp->st_value == 0) 1505 0 stevel continue; 1506 0 stevel if (sym_lookup(omp, osp) == NULL) 1507 0 stevel continue; 1508 0 stevel name = omp->strings + osp->st_name; 1509 0 stevel namelen = strlen(name); 1510 0 stevel if (ELF_ST_BIND(osp->st_info) == STB_LOCAL) 1511 0 stevel locals++; 1512 0 stevel nsyms++; 1513 0 stevel strsize += namelen + 1; 1514 0 stevel } 1515 0 stevel 1516 0 stevel mp->nsyms = nsyms; 1517 0 stevel mp->hashsize = kobj_gethashsize(mp->nsyms); 1518 0 stevel 1519 0 stevel /* 1520 0 stevel * ksyms_lock must be held as writer during any operation that 1521 0 stevel * modifies ksyms_arena, including allocation from same, and 1522 0 stevel * must not be dropped until the arena is vmem_walk()able. 1523 0 stevel */ 1524 0 stevel rw_enter(&ksyms_lock, RW_WRITER); 1525 0 stevel 1526 0 stevel /* 1527 0 stevel * Allocate space for the new section headers (symtab and strtab), 1528 0 stevel * symbol table, buckets, chains, and strings. 1529 0 stevel */ 1530 0 stevel mp->symsize = (2 * sizeof (Shdr)) + (nsyms * symsize) + 1531 0 stevel (mp->hashsize + mp->nsyms) * sizeof (symid_t) + strsize; 1532 0 stevel 1533 0 stevel if (mp->flags & KOBJ_NOKSYMS) { 1534 0 stevel mp->symspace = kobj_alloc(mp->symsize, KM_WAIT); 1535 0 stevel } else { 1536 0 stevel mp->symspace = vmem_alloc(ksyms_arena, mp->symsize, 1537 0 stevel VM_BESTFIT | VM_SLEEP); 1538 0 stevel } 1539 0 stevel bzero(mp->symspace, mp->symsize); 1540 0 stevel 1541 0 stevel /* 1542 0 stevel * Divvy up symspace. 1543 0 stevel */ 1544 0 stevel mp->shdrs = mp->symspace; 1545 0 stevel mp->symhdr = (Shdr *)mp->shdrs; 1546 0 stevel mp->strhdr = (Shdr *)(mp->symhdr + 1); 1547 0 stevel mp->symtbl = (char *)(mp->strhdr + 1); 1548 0 stevel mp->buckets = (symid_t *)(mp->symtbl + (nsyms * symsize)); 1549 0 stevel mp->chains = (symid_t *)(mp->buckets + mp->hashsize); 1550 0 stevel mp->strings = (char *)(mp->chains + nsyms); 1551 0 stevel 1552 0 stevel /* 1553 0 stevel * Fill in the new section headers (symtab and strtab). 1554 0 stevel */ 1555 0 stevel mp->hdr.e_shnum = 2; 1556 0 stevel mp->symtbl_section = 0; 1557 0 stevel 1558 0 stevel mp->symhdr->sh_type = SHT_SYMTAB; 1559 0 stevel mp->symhdr->sh_addr = (Addr)mp->symtbl; 1560 0 stevel mp->symhdr->sh_size = nsyms * symsize; 1561 0 stevel mp->symhdr->sh_link = 1; 1562 0 stevel mp->symhdr->sh_info = locals; 1563 0 stevel mp->symhdr->sh_addralign = sizeof (Addr); 1564 0 stevel mp->symhdr->sh_entsize = symsize; 1565 0 stevel 1566 0 stevel mp->strhdr->sh_type = SHT_STRTAB; 1567 0 stevel mp->strhdr->sh_addr = (Addr)mp->strings; 1568 0 stevel mp->strhdr->sh_size = strsize; 1569 0 stevel mp->strhdr->sh_addralign = 1; 1570 0 stevel 1571 0 stevel /* 1572 0 stevel * Construct the new symbol table. 1573 0 stevel */ 1574 0 stevel for (nsyms = strsize = 1, osp = (Sym *)omp->symtbl; osp < esp; osp++) { 1575 0 stevel if (osp->st_value == 0) 1576 0 stevel continue; 1577 0 stevel if (sym_lookup(omp, osp) == NULL) 1578 0 stevel continue; 1579 0 stevel name = omp->strings + osp->st_name; 1580 0 stevel namelen = strlen(name); 1581 0 stevel sp = (Sym *)(mp->symtbl + symsize * nsyms); 1582 0 stevel bcopy(osp, sp, symsize); 1583 0 stevel bcopy(name, mp->strings + strsize, namelen); 1584 0 stevel sp->st_name = strsize; 1585 0 stevel sym_insert(mp, name, nsyms); 1586 0 stevel nsyms++; 1587 0 stevel strsize += namelen + 1; 1588 0 stevel } 1589 0 stevel 1590 0 stevel rw_exit(&ksyms_lock); 1591 0 stevel 1592 0 stevel /* 1593 0 stevel * Free the old section headers -- we'll never need them again. 1594 0 stevel */ 1595 4515 kchow if (!(mp->flags & KOBJ_PRIM)) { 1596 4515 kchow uint_t shn; 1597 4515 kchow Shdr *shp; 1598 4515 kchow 1599 4515 kchow for (shn = 1; shn < omp->hdr.e_shnum; shn++) { 1600 4515 kchow shp = (Shdr *)(omp->shdrs + shn * omp->hdr.e_shentsize); 1601 4515 kchow switch (shp->sh_type) { 1602 4515 kchow case SHT_RELA: 1603 4515 kchow case SHT_REL: 1604 4515 kchow if (shp->sh_addr != 0) { 1605 4515 kchow kobj_free((void *)shp->sh_addr, 1606 4515 kchow shp->sh_size); 1607 4515 kchow } 1608 4515 kchow break; 1609 4515 kchow } 1610 4515 kchow } 1611 0 stevel kobj_free(omp->shdrs, omp->hdr.e_shentsize * omp->hdr.e_shnum); 1612 4515 kchow } 1613 0 stevel /* 1614 0 stevel * Discard the old symbol table and our copy of the module strucure. 1615 0 stevel */ 1616 0 stevel if (!(mp->flags & KOBJ_PRIM)) 1617 0 stevel kobj_free(omp->symspace, omp->symsize); 1618 0 stevel kobj_free(omp, sizeof (struct module)); 1619 0 stevel } 1620 0 stevel 1621 0 stevel static void 1622 0 stevel kobj_export_ctf(struct module *mp) 1623 0 stevel { 1624 0 stevel char *data = mp->ctfdata; 1625 0 stevel size_t size = mp->ctfsize; 1626 0 stevel 1627 0 stevel if (data != NULL) { 1628 0 stevel if (_moddebug & MODDEBUG_NOCTF) { 1629 0 stevel mp->ctfdata = NULL; 1630 0 stevel mp->ctfsize = 0; 1631 0 stevel } else { 1632 0 stevel mp->ctfdata = vmem_alloc(ctf_arena, size, 1633 0 stevel VM_BESTFIT | VM_SLEEP); 1634 0 stevel bcopy(data, mp->ctfdata, size); 1635 0 stevel } 1636 0 stevel 1637 0 stevel if (!(mp->flags & KOBJ_PRIM)) 1638 0 stevel kobj_free(data, size); 1639 0 stevel } 1640 0 stevel } 1641 0 stevel 1642 0 stevel void 1643 0 stevel kobj_export_module(struct module *mp) 1644 0 stevel { 1645 0 stevel kobj_export_ksyms(mp); 1646 0 stevel kobj_export_ctf(mp); 1647 0 stevel 1648 0 stevel mp->flags |= KOBJ_EXPORTED; 1649 0 stevel } 1650 0 stevel 1651 0 stevel static int 1652 0 stevel process_dynamic(struct module *mp, char *dyndata, char *strdata) 1653 0 stevel { 1654 0 stevel char *path = NULL, *depstr = NULL; 1655 0 stevel int allocsize = 0, osize = 0, nsize = 0; 1656 0 stevel char *libname, *tmp; 1657 0 stevel int lsize; 1658 0 stevel Dyn *dynp; 1659 0 stevel 1660 0 stevel for (dynp = (Dyn *)dyndata; dynp && dynp->d_tag != DT_NULL; dynp++) { 1661 0 stevel switch (dynp->d_tag) { 1662 0 stevel case DT_NEEDED: 1663 0 stevel /* 1664 0 stevel * Read the DT_NEEDED entries, expanding the macros they 1665 0 stevel * contain (if any), and concatenating them into a 1666 0 stevel * single space-separated dependency list. 1667 0 stevel */ 1668 0 stevel libname = (ulong_t)dynp->d_un.d_ptr + strdata; 1669 0 stevel 1670 0 stevel if (strchr(libname, '$') != NULL) { 1671 0 stevel char *_lib; 1672 0 stevel 1673 0 stevel if (path == NULL) 1674 0 stevel path = kobj_alloc(MAXPATHLEN, KM_WAIT); 1675 0 stevel if ((_lib = expand_libmacro(libname, path, 1676 0 stevel path)) != NULL) 1677 0 stevel libname = _lib; 1678 0 stevel else { 1679 0 stevel _kobj_printf(ops, "krtld: " 1680 0 stevel "process_dynamic: failed to expand " 1681 0 stevel "%s\n", libname); 1682 0 stevel } 1683 0 stevel } 1684 0 stevel 1685 0 stevel lsize = strlen(libname); 1686 0 stevel nsize += lsize; 1687 0 stevel if (nsize + 1 > allocsize) { 1688 0 stevel tmp = kobj_alloc(allocsize + MAXPATHLEN, 1689 0 stevel KM_WAIT); 1690 0 stevel if (depstr != NULL) { 1691 0 stevel bcopy(depstr, tmp, osize); 1692 0 stevel kobj_free(depstr, allocsize); 1693 0 stevel } 1694 0 stevel depstr = tmp; 1695 0 stevel allocsize += MAXPATHLEN; 1696 0 stevel } 1697 0 stevel bcopy(libname, depstr + osize, lsize); 1698 0 stevel *(depstr + nsize) = ' '; /* separator */ 1699 0 stevel nsize++; 1700 0 stevel osize = nsize; 1701 0 stevel break; 1702 0 stevel 1703 0 stevel case DT_FLAGS_1: 1704 0 stevel if (dynp->d_un.d_val & DF_1_IGNMULDEF) 1705 0 stevel mp->flags |= KOBJ_IGNMULDEF; 1706 0 stevel if (dynp->d_un.d_val & DF_1_NOKSYMS) 1707 0 stevel mp->flags |= KOBJ_NOKSYMS; 1708 0 stevel 1709 0 stevel break; 1710 0 stevel } 1711 0 stevel } 1712 0 stevel 1713 0 stevel /* 1714 0 stevel * finish up the depends string (if any) 1715 0 stevel */ 1716 0 stevel if (depstr != NULL) { 1717 5331 amw *(depstr + nsize - 1) = '\0'; /* overwrite separator w/term */ 1718 0 stevel if (path != NULL) 1719 0 stevel kobj_free(path, MAXPATHLEN); 1720 0 stevel 1721 0 stevel tmp = kobj_alloc(nsize, KM_WAIT); 1722 0 stevel bcopy(depstr, tmp, nsize); 1723 0 stevel kobj_free(depstr, allocsize); 1724 0 stevel depstr = tmp; 1725 0 stevel 1726 0 stevel mp->depends_on = depstr; 1727 0 stevel } 1728 0 stevel 1729 0 stevel return (0); 1730 0 stevel } 1731 0 stevel 1732 0 stevel static int 1733 0 stevel do_dynamic(struct module *mp, struct _buf *file) 1734 0 stevel { 1735 0 stevel Shdr *dshp, *dstrp, *shp; 1736 0 stevel char *dyndata, *dstrdata; 1737 0 stevel int dshn, shn, rc; 1738 0 stevel 1739 0 stevel /* find and validate the dynamic section (if any) */ 1740 0 stevel 1741 0 stevel for (dshp = NULL, shn = 1; shn < mp->hdr.e_shnum; shn++) { 1742 0 stevel shp = (Shdr *)(mp->shdrs + shn * mp->hdr.e_shentsize); 1743 0 stevel switch (shp->sh_type) { 1744 0 stevel case SHT_DYNAMIC: 1745 0 stevel if (dshp != NULL) { 1746 0 stevel _kobj_printf(ops, "krtld: get_dynamic: %s, ", 1747 0 stevel mp->filename); 1748 0 stevel _kobj_printf(ops, 1749 0 stevel "multiple dynamic sections\n"); 1750 0 stevel return (-1); 1751 0 stevel } else { 1752 0 stevel dshp = shp; 1753 0 stevel dshn = shn; 1754 0 stevel } 1755 0 stevel break; 1756 0 stevel } 1757 0 stevel } 1758 0 stevel 1759 0 stevel if (dshp == NULL) 1760 0 stevel return (0); 1761 0 stevel 1762 0 stevel if (dshp->sh_link > mp->hdr.e_shnum) { 1763 0 stevel _kobj_printf(ops, "krtld: get_dynamic: %s, ", mp->filename); 1764 0 stevel _kobj_printf(ops, "no section for sh_link %d\n", dshp->sh_link); 1765 0 stevel return (-1); 1766 0 stevel } 1767 0 stevel dstrp = (Shdr *)(mp->shdrs + dshp->sh_link * mp->hdr.e_shentsize); 1768 0 stevel 1769 0 stevel if (dstrp->sh_type != SHT_STRTAB) { 1770 0 stevel _kobj_printf(ops, "krtld: get_dynamic: %s, ", mp->filename); 1771 0 stevel _kobj_printf(ops, "sh_link not a string table for section %d\n", 1772 0 stevel dshn); 1773 0 stevel return (-1); 1774 0 stevel } 1775 0 stevel 1776 0 stevel /* read it from disk */ 1777 0 stevel 1778 0 stevel dyndata = kobj_alloc(dshp->sh_size, KM_WAIT|KM_TMP); 1779 0 stevel if (kobj_read_file(file, dyndata, dshp->sh_size, dshp->sh_offset) < 0) { 1780 0 stevel _kobj_printf(ops, "krtld: get_dynamic: %s, ", mp->filename); 1781 0 stevel _kobj_printf(ops, "error reading section %d\n", dshn); 1782 0 stevel 1783 0 stevel kobj_free(dyndata, dshp->sh_size); 1784 0 stevel return (-1); 1785 0 stevel } 1786 0 stevel 1787 0 stevel dstrdata = kobj_alloc(dstrp->sh_size, KM_WAIT|KM_TMP); 1788 0 stevel if (kobj_read_file(file, dstrdata, dstrp->sh_size, 1789 0 stevel dstrp->sh_offset) < 0) { 1790 0 stevel _kobj_printf(ops, "krtld: get_dynamic: %s, ", mp->filename); 1791 0 stevel _kobj_printf(ops, "error reading section %d\n", dshp->sh_link); 1792 0 stevel 1793 0 stevel kobj_free(dyndata, dshp->sh_size); 1794 0 stevel kobj_free(dstrdata, dstrp->sh_size); 1795 0 stevel return (-1); 1796 0 stevel } 1797 0 stevel 1798 0 stevel /* pull the interesting pieces out */ 1799 0 stevel 1800 0 stevel rc = process_dynamic(mp, dyndata, dstrdata); 1801 0 stevel 1802 0 stevel kobj_free(dyndata, dshp->sh_size); 1803 0 stevel kobj_free(dstrdata, dstrp->sh_size); 1804 0 stevel 1805 0 stevel return (rc); 1806 0 stevel } 1807 0 stevel 1808 0 stevel void 1809 0 stevel kobj_set_ctf(struct module *mp, caddr_t data, size_t size) 1810 0 stevel { 1811 0 stevel if (!standalone) { 1812 0 stevel if (mp->ctfdata != NULL) { 1813 0 stevel if (vmem_contains(ctf_arena, mp->ctfdata, 1814 3912 lling mp->ctfsize)) { 1815 0 stevel vmem_free(ctf_arena, mp->ctfdata, mp->ctfsize); 1816 0 stevel } else { 1817 0 stevel kobj_free(mp->ctfdata, mp->ctfsize); 1818 0 stevel } 1819 0 stevel } 1820 0 stevel } 1821 0 stevel 1822 0 stevel /* 1823 0 stevel * The order is very important here. We need to make sure that 1824 0 stevel * consumers, at any given instant, see a consistent state. We'd 1825 0 stevel * rather they see no CTF data than the address of one buffer and the 1826 0 stevel * size of another. 1827 0 stevel */ 1828 0 stevel mp->ctfdata = NULL; 1829 0 stevel membar_producer(); 1830 0 stevel mp->ctfsize = size; 1831 0 stevel mp->ctfdata = data; 1832 0 stevel membar_producer(); 1833 0 stevel } 1834 0 stevel 1835 0 stevel int 1836 0 stevel kobj_load_module(struct modctl *modp, int use_path) 1837 0 stevel { 1838 0 stevel char *filename = modp->mod_filename; 1839 0 stevel char *modname = modp->mod_modname; 1840 0 stevel int i; 1841 0 stevel int n; 1842 0 stevel struct _buf *file; 1843 0 stevel struct module *mp = NULL; 1844 0 stevel #ifdef MODDIR_SUFFIX 1845 0 stevel int no_suffixdir_drv = 0; 1846 0 stevel #endif 1847 0 stevel 1848 0 stevel mp = kobj_zalloc(sizeof (struct module), KM_WAIT); 1849 0 stevel 1850 0 stevel /* 1851 0 stevel * We need to prevent kmdb's symbols from leaking into /dev/ksyms. 1852 0 stevel * kmdb contains a bunch of symbols with well-known names, symbols 1853 0 stevel * which will mask the real versions, thus causing no end of trouble 1854 0 stevel * for mdb. 1855 0 stevel */ 1856 0 stevel if (strcmp(modp->mod_modname, "kmdbmod") == 0) 1857 0 stevel mp->flags |= KOBJ_NOKSYMS; 1858 0 stevel 1859 0 stevel file = kobj_open_path(filename, use_path, 1); 1860 0 stevel if (file == (struct _buf *)-1) { 1861 0 stevel #ifdef MODDIR_SUFFIX 1862 0 stevel file = kobj_open_path(filename, use_path, 0); 1863 0 stevel #endif 1864 0 stevel if (file == (struct _buf *)-1) { 1865 0 stevel kobj_free(mp, sizeof (*mp)); 1866 0 stevel goto bad; 1867 0 stevel } 1868 0 stevel #ifdef MODDIR_SUFFIX 1869 0 stevel /* 1870 0 stevel * There is no driver module in the ISA specific (suffix) 1871 0 stevel * subdirectory but there is a module in the parent directory. 1872 0 stevel */ 1873 0 stevel if (strncmp(filename, "drv/", 4) == 0) { 1874 0 stevel no_suffixdir_drv = 1; 1875 0 stevel } 1876 0 stevel #endif 1877 0 stevel } 1878 0 stevel 1879 0 stevel mp->filename = kobj_alloc(strlen(file->_name) + 1, KM_WAIT); 1880 0 stevel (void) strcpy(mp->filename, file->_name); 1881 0 stevel 1882 0 stevel if (kobj_read_file(file, (char *)&mp->hdr, sizeof (mp->hdr), 0) < 0) { 1883 0 stevel _kobj_printf(ops, "kobj_load_module: %s read header failed\n", 1884 0 stevel modname); 1885 0 stevel kobj_free(mp->filename, strlen(file->_name) + 1); 1886 0 stevel kobj_free(mp, sizeof (*mp)); 1887 0 stevel goto bad; 1888 0 stevel } 1889 0 stevel for (i = 0; i < SELFMAG; i++) { 1890 0 stevel if (mp->hdr.e_ident[i] != ELFMAG[i]) { 1891 0 stevel if (_moddebug & MODDEBUG_ERRMSG) 1892 0 stevel _kobj_printf(ops, "%s not an elf module\n", 1893 0 stevel modname); 1894 0 stevel kobj_free(mp->filename, strlen(file->_name) + 1); 1895 0 stevel kobj_free(mp, sizeof (*mp)); 1896 0 stevel goto bad; 1897 0 stevel } 1898 0 stevel } 1899 0 stevel /* 1900 0 stevel * It's ELF, but is it our ISA? Interpreting the header 1901 0 stevel * from a file for a byte-swapped ISA could cause a huge 1902 0 stevel * and unsatisfiable value to be passed to kobj_alloc below 1903 0 stevel * and therefore hang booting. 1904 0 stevel */ 1905 0 stevel if (!elf_mach_ok(&mp->hdr)) { 1906 0 stevel if (_moddebug & MODDEBUG_ERRMSG) 1907 0 stevel _kobj_printf(ops, "%s not an elf module for this ISA\n", 1908 0 stevel modname); 1909 0 stevel kobj_free(mp->filename, strlen(file->_name) + 1); 1910 0 stevel kobj_free(mp, sizeof (*mp)); 1911 0 stevel #ifdef MODDIR_SUFFIX 1912 0 stevel /* 1913 0 stevel * The driver mod is not in the ISA specific subdirectory 1914 0 stevel * and the module in the parent directory is not our ISA. 1915 0 stevel * If it is our ISA, for now we will silently succeed. 1916 0 stevel */ 1917 0 stevel if (no_suffixdir_drv == 1) { 1918 0 stevel cmn_err(CE_CONT, "?NOTICE: %s: 64-bit driver module" 1919 0 stevel " not found\n", modname); 1920 0 stevel } 1921 0 stevel #endif 1922 0 stevel goto bad; 1923 0 stevel } 1924 0 stevel 1925 0 stevel /* 1926 0 stevel * All modules, save for unix, should be relocatable (as opposed to 1927 0 stevel * dynamic). Dynamic modules come with PLTs and GOTs, which can't 1928 0 stevel * currently be processed by krtld. 1929 0 stevel */ 1930 0 stevel if (mp->hdr.e_type != ET_REL) { 1931 0 stevel if (_moddebug & MODDEBUG_ERRMSG) 1932 0 stevel _kobj_printf(ops, "%s isn't a relocatable (ET_REL) " 1933 0 stevel "module\n", modname); 1934 0 stevel kobj_free(mp->filename, strlen(file->_name) + 1); 1935 0 stevel kobj_free(mp, sizeof (*mp)); 1936 0 stevel goto bad; 1937 0 stevel } 1938 0 stevel 1939 0 stevel n = mp->hdr.e_shentsize * mp->hdr.e_shnum; 1940 0 stevel mp->shdrs = kobj_alloc(n, KM_WAIT); 1941 0 stevel 1942 0 stevel if (kobj_read_file(file, mp->shdrs, n, mp->hdr.e_shoff) < 0) { 1943 0 stevel _kobj_printf(ops, "kobj_load_module: %s error reading " 1944 0 stevel "section headers\n", modname); 1945 0 stevel kobj_free(mp->shdrs, n); 1946 0 stevel kobj_free(mp->filename, strlen(file->_name) + 1); 1947 0 stevel kobj_free(mp, sizeof (*mp)); 1948 0 stevel goto bad; 1949 0 stevel } 1950 0 stevel 1951 0 stevel kobj_notify(KOBJ_NOTIFY_MODLOADING, modp); 1952 0 stevel module_assign(modp, mp); 1953 0 stevel 1954 0 stevel /* read in sections */ 1955 0 stevel if (get_progbits(mp, file) < 0) { 1956 0 stevel _kobj_printf(ops, "%s error reading sections\n", modname); 1957 0 stevel goto bad; 1958 0 stevel } 1959 0 stevel 1960 0 stevel if (do_dynamic(mp, file) < 0) { 1961 0 stevel _kobj_printf(ops, "%s error reading dynamic section\n", 1962 0 stevel modname); 1963 0 stevel goto bad; 1964 0 stevel } 1965 0 stevel 1966 0 stevel modp->mod_text = mp->text; 1967 0 stevel modp->mod_text_size = mp->text_size; 1968 0 stevel 1969 0 stevel /* read in symbols; adjust values for each section's real address */ 1970 0 stevel if (get_syms(mp, file) < 0) { 1971 0 stevel _kobj_printf(ops, "%s error reading symbols\n", 1972 0 stevel modname); 1973 0 stevel goto bad; 1974 0 stevel } 1975 0 stevel 1976 0 stevel /* 1977 0 stevel * If we didn't dependency information from the dynamic section, look 1978 0 stevel * for it the old-fashioned way. 1979 0 stevel */ 1980 0 stevel if (mp->depends_on == NULL) 1981 0 stevel mp->depends_on = depends_on(mp); 1982 0 stevel 1983 0 stevel if (get_ctf(mp, file) < 0) { 1984 0 stevel _kobj_printf(ops, "%s debug information will not " 1985 0 stevel "be available\n", modname); 1986 0 stevel } 1987 0 stevel 1988 0 stevel /* primary kernel modules do not have a signature section */ 1989 0 stevel if (!(mp->flags & KOBJ_PRIM)) 1990 0 stevel get_signature(mp, file); 1991 0 stevel 1992 0 stevel #ifdef KOBJ_DEBUG 1993 0 stevel if (kobj_debug & D_LOADING) { 1994 0 stevel _kobj_printf(ops, "krtld: file=%s\n", mp->filename); 1995 0 stevel _kobj_printf(ops, "\ttext:0x%p", mp->text); 1996 0 stevel _kobj_printf(ops, " size: 0x%x\n", mp->text_size); 1997 0 stevel _kobj_printf(ops, "\tdata:0x%p", mp->data); 1998 0 stevel _kobj_printf(ops, " dsize: 0x%x\n", mp->data_size); 1999 0 stevel } 2000 0 stevel #endif /* KOBJ_DEBUG */ 2001 0 stevel 2002 0 stevel /* 2003 0 stevel * For primary kernel modules, we defer 2004 0 stevel * symbol resolution and relocation until 2005 0 stevel * all primary objects have been loaded. 2006 0 stevel */ 2007 0 stevel if (!standalone) { 2008 0 stevel int ddrval, dcrval; 2009 0 stevel char *dependent_modname; 2010 0 stevel /* load all dependents */ 2011 0 stevel dependent_modname = kobj_zalloc(MODMAXNAMELEN, KM_WAIT); 2012 0 stevel ddrval = do_dependents(modp, dependent_modname, MODMAXNAMELEN); 2013 0 stevel 2014 0 stevel /* 2015 0 stevel * resolve undefined and common symbols, 2016 0 stevel * also allocates common space 2017 0 stevel */ 2018 0 stevel if ((dcrval = do_common(mp)) < 0) { 2019 0 stevel switch (dcrval) { 2020 0 stevel case DOSYM_UNSAFE: 2021 0 stevel _kobj_printf(ops, "WARNING: mod_load: " 2022 0 stevel "MT-unsafe module '%s' rejected\n", 2023 0 stevel modname); 2024 0 stevel break; 2025 0 stevel case DOSYM_UNDEF: 2026 0 stevel _kobj_printf(ops, "WARNING: mod_load: " 2027 0 stevel "cannot load module '%s'\n", 2028 0 stevel modname); 2029 0 stevel if (ddrval == -1) { 2030 0 stevel _kobj_printf(ops, "WARNING: %s: ", 2031 0 stevel modname); 2032 0 stevel _kobj_printf(ops, 2033 0 stevel "unable to resolve dependency, " 2034 0 stevel "module '%s' not found\n", 2035 0 stevel dependent_modname); 2036 0 stevel } 2037 0 stevel break; 2038 0 stevel } 2039 0 stevel } 2040 0 stevel kobj_free(dependent_modname, MODMAXNAMELEN); 2041 0 stevel if (dcrval < 0) 2042 0 stevel goto bad; 2043 0 stevel 2044 0 stevel /* process relocation tables */ 2045 0 stevel if (do_relocations(mp) < 0) { 2046 0 stevel _kobj_printf(ops, "%s error doing relocations\n", 2047 0 stevel modname); 2048 0 stevel goto bad; 2049 0 stevel } 2050 0 stevel 2051 0 stevel if (mp->destination) { 2052 0 stevel off_t off = (uintptr_t)mp->destination & PAGEOFFSET; 2053 0 stevel caddr_t base = (caddr_t)mp->destination - off; 2054 0 stevel size_t size = P2ROUNDUP(mp->text_size + off, PAGESIZE); 2055 0 stevel 2056 0 stevel hat_unload(kas.a_hat, base, size, HAT_UNLOAD_UNLOCK); 2057 0 stevel vmem_free(heap_arena, base, size); 2058 0 stevel } 2059 0 stevel 2060 0 stevel /* sync_instruction_memory */ 2061 0 stevel kobj_sync_instruction_memory(mp->text, mp->text_size); 2062 0 stevel kobj_export_module(mp); 2063 0 stevel kobj_notify(KOBJ_NOTIFY_MODLOADED, modp); 2064 0 stevel } 2065 0 stevel kobj_close_file(file); 2066 0 stevel return (0); 2067 0 stevel bad: 2068 0 stevel if (file != (struct _buf *)-1) 2069 0 stevel kobj_close_file(file); 2070 0 stevel if (modp->mod_mp != NULL) 2071 0 stevel free_module_data(modp->mod_mp); 2072 0 stevel 2073 0 stevel module_assign(modp, NULL); 2074 0 stevel return ((file == (struct _buf *)-1) ? ENOENT : EINVAL); 2075 0 stevel } 2076 0 stevel 2077 0 stevel int 2078 0 stevel kobj_load_primary_module(struct modctl *modp) 2079 0 stevel { 2080 0 stevel struct modctl *dep; 2081 0 stevel struct module *mp; 2082 0 stevel 2083 0 stevel if (kobj_load_module(modp, 0) != 0) 2084 0 stevel return (-1); 2085 0 stevel 2086 0 stevel mp = modp->mod_mp; 2087 0 stevel mp->flags |= KOBJ_PRIM; 2088 0 stevel 2089 0 stevel /* Bind new module to its dependents */ 2090 0 stevel if (mp->depends_on != NULL && (dep = 2091 0 stevel mod_already_loaded(mp->depends_on)) == NULL) { 2092 0 stevel #ifdef KOBJ_DEBUG 2093 0 stevel if (kobj_debug & D_DEBUG) { 2094 0 stevel _kobj_printf(ops, "krtld: failed to resolve deps " 2095 0 stevel "for primary %s\n", modp->mod_modname); 2096 0 stevel } 2097 0 stevel #endif 2098 0 stevel return (-1); 2099 0 stevel } 2100 0 stevel 2101 0 stevel add_dependent(mp, dep->mod_mp); 2102 0 stevel 2103 0 stevel /* 2104 0 stevel * Relocate it. This module may not be part of a link map, so we 2105 0 stevel * can't use bind_primary. 2106 0 stevel */ 2107 0 stevel if (do_common(mp) < 0 || do_symbols(mp, 0) < 0 || 2108 0 stevel do_relocations(mp) < 0) { 2109 0 stevel #ifdef KOBJ_DEBUG 2110 0 stevel if (kobj_debug & D_DEBUG) { 2111 0 stevel _kobj_printf(ops, "krtld: failed to relocate " 2112 0 stevel "primary %s\n", modp->mod_modname); 2113 0 stevel } 2114 0 stevel #endif 2115 0 stevel return (-1); 2116 0 stevel } 2117 0 stevel 2118 0 stevel return (0); 2119 0 stevel } 2120 0 stevel 2121 0 stevel static void 2122 0 stevel module_assign(struct modctl *cp, struct module *mp) 2123 0 stevel { 2124 0 stevel if (standalone) { 2125 0 stevel cp->mod_mp = mp; 2126 0 stevel return; 2127 0 stevel } 2128 0 stevel mutex_enter(&mod_lock); 2129 0 stevel cp->mod_mp = mp; 2130 0 stevel cp->mod_gencount++; 2131 0 stevel mutex_exit(&mod_lock); 2132 0 stevel } 2133 0 stevel 2134 0 stevel void 2135 0 stevel kobj_unload_module(struct modctl *modp) 2136 0 stevel { 2137 0 stevel struct module *mp = modp->mod_mp; 2138 0 stevel 2139 0 stevel if ((_moddebug & MODDEBUG_KEEPTEXT) && mp) { 2140 0 stevel _kobj_printf(ops, "text for %s ", mp->filename); 2141 0 stevel _kobj_printf(ops, "was at %p\n", mp->text); 2142 0 stevel mp->text = NULL; /* don't actually free it */ 2143 0 stevel } 2144 0 stevel 2145 0 stevel kobj_notify(KOBJ_NOTIFY_MODUNLOADING, modp); 2146 0 stevel 2147 0 stevel /* 2148 0 stevel * Null out mod_mp first, so consumers (debuggers) know not to look 2149 0 stevel * at the module structure any more. 2150 0 stevel */ 2151 0 stevel mutex_enter(&mod_lock); 2152 0 stevel modp->mod_mp = NULL; 2153 0 stevel mutex_exit(&mod_lock); 2154 0 stevel 2155 0 stevel kobj_notify(KOBJ_NOTIFY_MODUNLOADED, modp); 2156 0 stevel free_module_data(mp); 2157 0 stevel } 2158 0 stevel 2159 0 stevel static void 2160 0 stevel free_module_data(struct module *mp) 2161 0 stevel { 2162 0 stevel struct module_list *lp, *tmp; 2163 0 stevel int ksyms_exported = 0; 2164 0 stevel 2165 0 stevel lp = mp->head; 2166 0 stevel while (lp) { 2167 0 stevel tmp = lp; 2168 0 stevel lp = lp->next; 2169 0 stevel kobj_free((char *)tmp, sizeof (*tmp)); 2170 0 stevel } 2171 0 stevel 2172 0 stevel rw_enter(&ksyms_lock, RW_WRITER); 2173 0 stevel if (mp->symspace) { 2174 0 stevel if (vmem_contains(ksyms_arena, mp->symspace, mp->symsize)) { 2175 0 stevel vmem_free(ksyms_arena, mp->symspace, mp->symsize); 2176 0 stevel ksyms_exported = 1; 2177 0 stevel } else { 2178 0 stevel if (mp->flags & KOBJ_NOKSYMS) 2179 0 stevel ksyms_exported = 1; 2180 0 stevel kobj_free(mp->symspace, mp->symsize); 2181 0 stevel } 2182 0 stevel } 2183 0 stevel rw_exit(&ksyms_lock); 2184 0 stevel 2185 0 stevel if (mp->ctfdata) { 2186 0 stevel if (vmem_contains(ctf_arena, mp->ctfdata, mp->ctfsize)) 2187 0 stevel vmem_free(ctf_arena, mp->ctfdata, mp->ctfsize); 2188 0 stevel else 2189 0 stevel kobj_free(mp->ctfdata, mp->ctfsize); 2190 0 stevel } 2191 0 stevel 2192 0 stevel if (mp->sigdata) 2193 0 stevel kobj_free(mp->sigdata, mp->sigsize); 2194 0 stevel 2195 0 stevel /* 2196 0 stevel * We did not get far enough into kobj_export_ksyms() to free allocated 2197 0 stevel * buffers because we encounted error conditions. Free the buffers. 2198 0 stevel */ 2199 0 stevel if ((ksyms_exported == 0) && (mp->shdrs != NULL)) { 2200 0 stevel uint_t shn; 2201 0 stevel Shdr *shp; 2202 0 stevel 2203 0 stevel for (shn = 1; shn < mp->hdr.e_shnum; shn++) { 2204 0 stevel shp = (Shdr *)(mp->shdrs + shn * mp->hdr.e_shentsize); 2205 0 stevel switch (shp->sh_type) { 2206 0 stevel case SHT_RELA: 2207 0 stevel case SHT_REL: 2208 0 stevel if (shp->sh_addr != 0) 2209 0 stevel kobj_free((void *)shp->sh_addr, 2210 0 stevel shp->sh_size); 2211 0 stevel break; 2212 0 stevel } 2213 0 stevel } 2214 0 stevel err_free_done: 2215 0 stevel if (!(mp->flags & KOBJ_PRIM)) { 2216 0 stevel kobj_free(mp->shdrs, 2217 0 stevel mp->hdr.e_shentsize * mp->hdr.e_shnum); 2218 0 stevel } 2219 0 stevel } 2220 0 stevel 2221 0 stevel if (mp->bss) 2222 0 stevel vmem_free(data_arena, (void *)mp->bss, mp->bss_size); 2223 0 stevel 2224 0 stevel if (mp->fbt_tab) 2225 0 stevel kobj_texthole_free(mp->fbt_tab, mp->fbt_size); 2226 0 stevel 2227 0 stevel if (mp->textwin_base) 2228 0 stevel kobj_textwin_free(mp); 2229 0 stevel 2230 0 stevel if (mp->sdt_probes != NULL) { 2231 0 stevel sdt_probedesc_t *sdp = mp->sdt_probes, *next; 2232 0 stevel 2233 0 stevel while (sdp != NULL) { 2234 0 stevel next = sdp->sdpd_next; 2235 0 stevel kobj_free(sdp->sdpd_name, strlen(sdp->sdpd_name) + 1); 2236 0 stevel kobj_free(sdp, sizeof (sdt_probedesc_t)); 2237 0 stevel sdp = next; 2238 0 stevel } 2239 0 stevel } 2240 0 stevel 2241 0 stevel if (mp->sdt_tab) 2242 0 stevel kobj_texthole_free(mp->sdt_tab, mp->sdt_size); 2243 0 stevel if (mp->text) 2244 0 stevel vmem_free(text_arena, mp->text, mp->text_size); 2245 0 stevel if (mp->data) 2246 0 stevel vmem_free(data_arena, mp->data, mp->data_size); 2247 0 stevel if (mp->depends_on) 2248 0 stevel kobj_free(mp->depends_on, strlen(mp->depends_on)+1); 2249 0 stevel if (mp->filename) 2250 0 stevel kobj_free(mp->filename, strlen(mp->filename)+1); 2251 0 stevel 2252 0 stevel kobj_free((char *)mp, sizeof (*mp)); 2253 0 stevel } 2254 0 stevel 2255 0 stevel static int 2256 0 stevel get_progbits(struct module *mp, struct _buf *file) 2257 0 stevel { 2258 0 stevel struct proginfo *tp, *dp, *sdp; 2259 0 stevel Shdr *shp; 2260 0 stevel reloc_dest_t dest = NULL; 2261 0 stevel uintptr_t bits_ptr; 2262 6206 ab196087 uintptr_t text = 0, data, textptr; 2263 0 stevel uint_t shn; 2264 0 stevel int err = -1; 2265 0 stevel 2266 5648 setje tp = kobj_zalloc(sizeof (struct proginfo), KM_WAIT|KM_TMP); 2267 5648 setje dp = kobj_zalloc(sizeof (struct proginfo), KM_WAIT|KM_TMP); 2268 5648 setje sdp = kobj_zalloc(sizeof (struct proginfo), KM_WAIT|KM_TMP); 2269 0 stevel /* 2270 0 stevel * loop through sections to find out how much space we need 2271 0 stevel * for text, data, (also bss that is already assigned) 2272 0 stevel */ 2273 0 stevel if (get_progbits_size(mp, tp, dp, sdp) < 0) 2274 0 stevel goto done; 2275 0 stevel 2276 0 stevel mp->text_size = tp->size; 2277 0 stevel mp->data_size = dp->size; 2278 0 stevel 2279 0 stevel if (standalone) { 2280 3446 mrj caddr_t limit = _data; 2281 3446 mrj 2282 3446 mrj if (lg_pagesize && _text + lg_pagesize < limit) 2283 3446 mrj limit = _text + lg_pagesize; 2284 3446 mrj 2285 0 stevel mp->text = kobj_segbrk(&_etext, mp->text_size, 2286 3912 lling tp->align, limit); 2287 0 stevel /* 2288 0 stevel * If we can't grow the text segment, try the 2289 0 stevel * data segment before failing. 2290 0 stevel */ 2291 0 stevel if (mp->text == NULL) { 2292 0 stevel mp->text = kobj_segbrk(&_edata, mp->text_size, 2293 3912 lling tp->align, 0); 2294 0 stevel } 2295 0 stevel 2296 0 stevel mp->data = kobj_segbrk(&_edata, mp->data_size, dp->align, 0); 2297 0 stevel 2298 0 stevel if (mp->text == NULL || mp->data == NULL) 2299 0 stevel goto done; 2300 0 stevel 2301 0 stevel } else { 2302 0 stevel if (text_arena == NULL) 2303 0 stevel kobj_vmem_init(&text_arena, &data_arena); 2304 0 stevel 2305 0 stevel /* 2306 0 stevel * some architectures may want to load the module on a 2307 0 stevel * page that is currently read only. It may not be 2308 0 stevel * possible for those architectures to remap their page 2309 0 stevel * on the fly. So we provide a facility for them to hang 2310 0 stevel * a private hook where the memory they assign the module 2311 0 stevel * is not the actual place where the module loads. 2312 0 stevel * 2313 0 stevel * In this case there are two addresses that deal with the 2314 0 stevel * modload. 2315 0 stevel * 1) the final destination of the module 2316 0 stevel * 2) the address that is used to view the newly 2317 0 stevel * loaded module until all the relocations relative to 1 2318 0 stevel * above are completed. 2319 0 stevel * 2320 0 stevel * That is what dest is used for below. 2321 0 stevel */ 2322 0 stevel mp->text_size += tp->align; 2323 0 stevel mp->data_size += dp->align; 2324 0 stevel 2325 0 stevel mp->text = kobj_text_alloc(text_arena, mp->text_size); 2326 0 stevel 2327 0 stevel /* 2328 0 stevel * a remap is taking place. Align the text ptr relative 2329 0 stevel * to the secondary mapping. That is where the bits will 2330 0 stevel * be read in. 2331 0 stevel */ 2332 0 stevel if (kvseg.s_base != NULL && !vmem_contains(heaptext_arena, 2333 0 stevel mp->text, mp->text_size)) { 2334 0 stevel off_t off = (uintptr_t)mp->text & PAGEOFFSET; 2335 0 stevel size_t size = P2ROUNDUP(mp->text_size + off, PAGESIZE); 2336 0 stevel caddr_t map = vmem_alloc(heap_arena, size, VM_SLEEP); 2337 0 stevel caddr_t orig = mp->text - off; 2338 0 stevel pgcnt_t pages = size / PAGESIZE; 2339 0 stevel 2340 0 stevel dest = (reloc_dest_t)(map + off); 2341 0 stevel text = ALIGN((uintptr_t)dest, tp->align); 2342 0 stevel 2343 0 stevel while (pages--) { 2344 0 stevel hat_devload(kas.a_hat, map, PAGESIZE, 2345 0 stevel hat_getpfnum(kas.a_hat, orig), 2346 0 stevel PROT_READ | PROT_WRITE | PROT_EXEC, 2347 0 stevel HAT_LOAD_NOCONSIST | HAT_LOAD_LOCK); 2348 0 stevel map += PAGESIZE; 2349 0 stevel orig += PAGESIZE; 2350 0 stevel } 2351 0 stevel /* 2352 0 stevel * Since we set up a non-cacheable mapping, we need 2353 0 stevel * to flush any old entries in the cache that might 2354 0 stevel * be left around from the read-only mapping. 2355 0 stevel */ 2356 0 stevel dcache_flushall(); 2357 0 stevel } 2358 0 stevel if (mp->data_size) 2359 0 stevel mp->data = vmem_alloc(data_arena, mp->data_size, 2360 0 stevel VM_SLEEP | VM_BESTFIT); 2361 0 stevel } 2362 0 stevel textptr = (uintptr_t)mp->text; 2363 0 stevel textptr = ALIGN(textptr, tp->align); 2364 0 stevel mp->destination = dest; 2365 0 stevel 2366 0 stevel /* 2367 0 stevel * This is the case where a remap is not being done. 2368 0 stevel */ 2369 0 stevel if (text == 0) 2370 0 stevel text = ALIGN((uintptr_t)mp->text, tp->align); 2371 0 stevel data = ALIGN((uintptr_t)mp->data, dp->align); 2372 0 stevel 2373 0 stevel /* now loop though sections assigning addresses and loading the data */ 2374 0 stevel for (shn = 1; shn < mp->hdr.e_shnum; shn++) { 2375 0 stevel shp = (Shdr *)(mp->shdrs + shn * mp->hdr.e_shentsize); 2376 0 stevel if (!(shp->sh_flags & SHF_ALLOC)) 2377 0 stevel continue; 2378 0 stevel 2379 0 stevel if ((shp->sh_flags & SHF_WRITE) == 0) 2380 0 stevel bits_ptr = text; 2381 0 stevel else 2382 0 stevel bits_ptr = data; 2383 0 stevel 2384 0 stevel bits_ptr = ALIGN(bits_ptr, shp->sh_addralign); 2385 0 stevel 2386 0 stevel if (shp->sh_type == SHT_NOBITS) { 2387 0 stevel /* 2388 0 stevel * Zero bss. 2389 0 stevel */ 2390 0 stevel bzero((caddr_t)bits_ptr, shp->sh_size); 2391 0 stevel shp->sh_type = SHT_PROGBITS; 2392 0 stevel } else { 2393 0 stevel if (kobj_read_file(file, (char *)bits_ptr, 2394 0 stevel shp->sh_size, shp->sh_offset) < 0) 2395 0 stevel goto done; 2396 0 stevel } 2397 0 stevel 2398 0 stevel if (shp->sh_flags & SHF_WRITE) { 2399 0 stevel shp->sh_addr = bits_ptr; 2400 0 stevel } else { 2401 0 stevel textptr = ALIGN(textptr, shp->sh_addralign); 2402 0 stevel shp->sh_addr = textptr; 2403 0 stevel textptr += shp->sh_size; 2404 0 stevel } 2405 0 stevel 2406 0 stevel bits_ptr += shp->sh_size; 2407 0 stevel if ((shp->sh_flags & SHF_WRITE) == 0) 2408 0 stevel text = bits_ptr; 2409 0 stevel else 2410 0 stevel data = bits_ptr; 2411 0 stevel } 2412 0 stevel 2413 0 stevel err = 0; 2414 0 stevel done: 2415 0 stevel /* 2416 0 stevel * Free and mark as freed the section headers here so that 2417 0 stevel * free_module_data() does not have to worry about this buffer. 2418 0 stevel * 2419 0 stevel * This buffer is freed here because one of the possible reasons 2420 0 stevel * for error is a section with non-zero sh_addr and in that case 2421 0 stevel * free_module_data() would have no way of recognizing that this 2422 0 stevel * buffer was unallocated. 2423 0 stevel */ 2424 0 stevel if (err != 0) { 2425 0 stevel kobj_free(mp->shdrs, mp->hdr.e_shentsize * mp->hdr.e_shnum); 2426 0 stevel mp->shdrs = NULL; 2427 0 stevel } 2428 0 stevel 2429 0 stevel (void) kobj_free(tp, sizeof (struct proginfo)); 2430 0 stevel (void) kobj_free(dp, sizeof (struct proginfo)); 2431 0 stevel (void) kobj_free(sdp, sizeof (struct proginfo)); 2432 0 stevel 2433 0 stevel return (err); 2434 0 stevel } 2435 0 stevel 2436 0 stevel /* 2437 0 stevel * Go through suppress_sym_list to see if "multiply defined" 2438 0 stevel * warning of this symbol should be suppressed. Return 1 if 2439 0 stevel * warning should be suppressed, 0 otherwise. 2440 0 stevel */ 2441 0 stevel static int 2442 0 stevel kobj_suppress_warning(char *symname) 2443 0 stevel { 2444 0 stevel int i; 2445 0 stevel 2446 0 stevel for (i = 0; suppress_sym_list[i] != NULL; i++) { 2447 0 stevel if (strcmp(suppress_sym_list[i], symname) == 0) 2448 0 stevel return (1); 2449 0 stevel } 2450 0 stevel 2451 0 stevel return (0); 2452 0 stevel } 2453 0 stevel 2454 0 stevel static int 2455 0 stevel get_syms(struct module *mp, struct _buf *file) 2456 0 stevel { 2457 0 stevel uint_t shn; 2458 0 stevel Shdr *shp; 2459 0 stevel uint_t i; 2460 0 stevel Sym *sp, *ksp; 2461 0 stevel char *symname; 2462 0 stevel int dosymtab = 0; 2463 0 stevel 2464 0 stevel /* 2465 0 stevel * Find the interesting sections. 2466 0 stevel */ 2467 0 stevel for (shn = 1; shn < mp->hdr.e_shnum; shn++) { 2468 0 stevel shp = (Shdr *)(mp->shdrs + shn * mp->hdr.e_shentsize); 2469 0 stevel switch (shp->sh_type) { 2470 0 stevel case SHT_SYMTAB: 2471 0 stevel mp->symtbl_section = shn; 2472 0 stevel mp->symhdr = shp; 2473 0 stevel dosymtab++; 2474 0 stevel break; 2475 0 stevel 2476 0 stevel case SHT_RELA: 2477 0 stevel case SHT_REL: 2478 0 stevel /* 2479 0 stevel * Already loaded. 2480 0 stevel */ 2481 0 stevel if (shp->sh_addr) 2482 0 stevel continue; 2483 5648 setje 2484 5648 setje /* KM_TMP since kobj_free'd in do_relocations */ 2485 0 stevel shp->sh_addr = (Addr) 2486 0 stevel kobj_alloc(shp->sh_size, KM_WAIT|KM_TMP); 2487 0 stevel 2488 0 stevel if (kobj_read_file(file, (char *)shp->sh_addr, 2489 0 stevel shp->sh_size, shp->sh_offset) < 0) { 2490 0 stevel _kobj_printf(ops, "krtld: get_syms: %s, ", 2491 0 stevel mp->filename); 2492 0 stevel _kobj_printf(ops, "error reading section %d\n", 2493 0 stevel shn); 2494 0 stevel return (-1); 2495 0 stevel } 2496 0 stevel break; 2497 0 stevel } 2498 0 stevel } 2499 0 stevel 2500 0 stevel /* 2501 0 stevel * This is true for a stripped executable. In the case of 2502 0 stevel * 'unix' it can be stripped but it still contains the SHT_DYNSYM, 2503 0 stevel * and since that symbol information is still present everything 2504 0 stevel * is just fine. 2505 0 stevel */ 2506 0 stevel if (!dosymtab) { 2507 0 stevel if (mp->flags & KOBJ_EXEC) 2508 0 stevel return (0); 2509 0 stevel _kobj_printf(ops, "krtld: get_syms: %s ", 2510 3912 lling mp->filename); 2511 0 stevel _kobj_printf(ops, "no SHT_SYMTAB symbol table found\n"); 2512 0 stevel return (-1); 2513 0 stevel } 2514 0 stevel 2515 0 stevel /* 2516 0 stevel * get the associated string table header 2517 0 stevel */ 2518 0 stevel if ((mp->symhdr == 0) || (mp->symhdr->sh_link >= mp->hdr.e_shnum)) 2519 0 stevel return (-1); 2520 0 stevel mp->strhdr = (Shdr *) 2521 3912 lling (mp->shdrs + mp->symhdr->sh_link * mp->hdr.e_shentsize); 2522 0 stevel 2523 0 stevel mp->nsyms = mp->symhdr->sh_size / mp->symhdr->sh_entsize; 2524 0 stevel mp->hashsize = kobj_gethashsize(mp->nsyms); 2525 0 stevel 2526 0 stevel /* 2527 0 stevel * Allocate space for the symbol table, buckets, chains, and strings. 2528 0 stevel */ 2529 0 stevel mp->symsize = mp->symhdr->sh_size + 2530 0 stevel (mp->hashsize + mp->nsyms) * sizeof (symid_t) + mp->strhdr->sh_size; 2531 0 stevel mp->symspace = kobj_zalloc(mp->symsize, KM_WAIT|KM_SCRATCH); 2532 0 stevel 2533 0 stevel mp->symtbl = mp->symspace; 2534 0 stevel mp->buckets = (symid_t *)(mp->symtbl + mp->symhdr->sh_size); 2535 0 stevel mp->chains = mp->buckets + mp->hashsize; 2536 0 stevel mp->strings = (char *)(mp->chains + mp->nsyms); 2537 0 stevel 2538 0 stevel if (kobj_read_file(file, mp->symtbl, 2539 0 stevel mp->symhdr->sh_size, mp->symhdr->sh_offset) < 0 || 2540 0 stevel kobj_read_file(file, mp->strings, 2541 0 stevel mp->strhdr->sh_size, mp->strhdr->sh_offset) < 0) 2542 0 stevel return (-1); 2543 0 stevel 2544 0 stevel /* 2545 0 stevel * loop through the symbol table adjusting values to account 2546 0 stevel * for where each section got loaded into memory. Also 2547 0 stevel * fill in the hash table. 2548 0 stevel */ 2549 0 stevel for (i = 1; i < mp->nsyms; i++) { 2550 0 stevel sp = (Sym *)(mp->symtbl + i * mp->symhdr->sh_entsize); 2551 0 stevel if (sp->st_shndx < SHN_LORESERVE) { 2552 0 stevel if (sp->st_shndx >= mp->hdr.e_shnum) { 2553 0 stevel _kobj_printf(ops, "%s bad shndx ", 2554 0 stevel file->_name); 2555 0 stevel _kobj_printf(ops, "in symbol %d\n", i); 2556 0 stevel return (-1); 2557 0 stevel } 2558 0 stevel shp = (Shdr *) 2559 0 stevel (mp->shdrs + 2560 0 stevel sp->st_shndx * mp->hdr.e_shentsize); 2561 0 stevel if (!(mp->flags & KOBJ_EXEC)) 2562 0 stevel sp->st_value += shp->sh_addr; 2563 0 stevel } 2564 0 stevel 2565 0 stevel if (sp->st_name == 0 || sp->st_shndx == SHN_UNDEF) 2566 0 stevel continue; 2567 0 stevel if (sp->st_name >= mp->strhdr->sh_size) 2568 0 stevel return (-1); 2569 0 stevel 2570 0 stevel symname = mp->strings + sp->st_name; 2571 0 stevel 2572 0 stevel if (!(mp->flags & KOBJ_EXEC) && 2573 0 stevel ELF_ST_BIND(sp->st_info) == STB_GLOBAL) { 2574 0 stevel ksp = kobj_lookup_all(mp, symname, 0); 2575 0 stevel 2576 0 stevel if (ksp && ELF_ST_BIND(ksp->st_info) == STB_GLOBAL && 2577 0 stevel !kobj_suppress_warning(symname) && 2578 0 stevel sp->st_shndx != SHN_UNDEF && 2579 0 stevel sp->st_shndx != SHN_COMMON && 2580 0 stevel ksp->st_shndx != SHN_UNDEF && 2581 0 stevel ksp->st_shndx != SHN_COMMON) { 2582 0 stevel /* 2583 0 stevel * Unless this symbol is a stub, it's multiply 2584 0 stevel * defined. Multiply-defined symbols are 2585 0 stevel * usually bad, but some objects (kmdb) have 2586 0 stevel * a legitimate need to have their own 2587 0 stevel * copies of common functions. 2588 0 stevel */ 2589 0 stevel if ((standalone || 2590 0 stevel ksp->st_value < (uintptr_t)stubs_base || 2591 0 stevel ksp->st_value >= (uintptr_t)stubs_end) && 2592 0 stevel !(mp->flags & KOBJ_IGNMULDEF)) { 2593 0 stevel _kobj_printf(ops, 2594 0 stevel "%s symbol ", file->_name); 2595 0 stevel _kobj_printf(ops, 2596 0 stevel "%s multiply defined\n", symname); 2597 0 stevel } 2598 0 stevel } 2599 0 stevel } 2600 3446 mrj 2601 0 stevel sym_insert(mp, symname, i); 2602 0 stevel } 2603 0 stevel 2604 0 stevel return (0); 2605 0 stevel } 2606 0 stevel 2607 0 stevel static int 2608 0 stevel get_ctf(struct module *mp, struct _buf *file) 2609 0 stevel { 2610 0 stevel char *shstrtab, *ctfdata; 2611 0 stevel size_t shstrlen; 2612 0 stevel Shdr *shp; 2613 0 stevel uint_t i; 2614 0 stevel 2615 0 stevel if (_moddebug & MODDEBUG_NOCTF) 2616 0 stevel return (0); /* do not attempt to even load CTF data */ 2617 0 stevel 2618 0 stevel if (mp->hdr.e_shstrndx >= mp->hdr.e_shnum) { 2619 0 stevel _kobj_printf(ops, "krtld: get_ctf: %s, ", 2620 0 stevel mp->filename); 2621 0 stevel _kobj_printf(ops, "corrupt e_shstrndx %u\n", 2622 0 stevel mp->hdr.e_shstrndx); 2623 0 stevel return (-1); 2624 0 stevel } 2625 0 stevel 2626 0 stevel shp = (Shdr *)(mp->shdrs + mp->hdr.e_shstrndx * mp->hdr.e_shentsize); 2627 0 stevel shstrlen = shp->sh_size; 2628 0 stevel shstrtab = kobj_alloc(shstrlen, KM_WAIT|KM_TMP); 2629 0 stevel 2630 0 stevel if (kobj_read_file(file, shstrtab, shstrlen, shp->sh_offset) < 0) { 2631 0 stevel _kobj_printf(ops, "krtld: get_ctf: %s, ", 2632 0 stevel mp->filename); 2633 0 stevel _kobj_printf(ops, "error reading section %u\n", 2634 0 stevel mp->hdr.e_shstrndx); 2635 0 stevel kobj_free(shstrtab, shstrlen); 2636 0 stevel return (-1); 2637 0 stevel } 2638 0 stevel 2639 0 stevel for (i = 0; i < mp->hdr.e_shnum; i++) { 2640 0 stevel shp = (Shdr *)(mp->shdrs + i * mp->hdr.e_shentsize); 2641 0 stevel 2642 0 stevel if (shp->sh_size != 0 && shp->sh_name < shstrlen && 2643 0 stevel strcmp(shstrtab + shp->sh_name, ".SUNW_ctf") == 0) { 2644 0 stevel ctfdata = kobj_alloc(shp->sh_size, KM_WAIT|KM_SCRATCH); 2645 0 stevel 2646 0 stevel if (kobj_read_file(file, ctfdata, shp->sh_size, 2647 0 stevel shp->sh_offset) < 0) { 2648 0 stevel _kobj_printf(ops, "krtld: get_ctf: %s, error " 2649 0 stevel "reading .SUNW_ctf data\n", mp->filename); 2650 0 stevel kobj_free(ctfdata, shp->sh_size); 2651 0 stevel kobj_free(shstrtab, shstrlen); 2652 0 stevel return (-1); 2653 0 stevel } 2654 0 stevel 2655 0 stevel mp->ctfdata = ctfdata; 2656 0 stevel mp->ctfsize = shp->sh_size; 2657 0 stevel break; 2658 0 stevel } 2659 0 stevel } 2660 0 stevel 2661 0 stevel kobj_free(shstrtab, shstrlen); 2662 0 stevel return (0); 2663 0 stevel } 2664 0 stevel 2665 0 stevel #define SHA1_DIGEST_LENGTH 20 /* SHA1 digest length in bytes */ 2666 0 stevel 2667 0 stevel /* 2668 0 stevel * Return the hash of the ELF sections that are memory resident. 2669 0 stevel * i.e. text and data. We skip a SHT_NOBITS section since it occupies 2670 0 stevel * no space in the file. We use SHA1 here since libelfsign uses 2671 0 stevel * it and both places need to use the same algorithm. 2672 0 stevel */ 2673 0 stevel static void 2674 0 stevel crypto_es_hash(struct module *mp, char *hash, char *shstrtab) 2675 0 stevel { 2676 0 stevel uint_t shn; 2677 0 stevel Shdr *shp; 2678 0 stevel SHA1_CTX ctx; 2679 0 stevel 2680 0 stevel SHA1Init(&ctx); 2681 0 stevel 2682 0 stevel for (shn = 1; shn < mp->hdr.e_shnum; shn++) { 2683 0 stevel shp = (Shdr *)(mp->shdrs + shn * mp->hdr.e_shentsize); 2684 0 stevel if (!(shp->sh_flags & SHF_ALLOC) || shp->sh_size == 0) 2685 0 stevel continue; 2686 0 stevel 2687 0 stevel /* 2688 0 stevel * The check should ideally be shp->sh_type == SHT_NOBITS. 2689 0 stevel * However, we can't do that check here as get_progbits() 2690 0 stevel * resets the type. 2691 0 stevel */ 2692 0 stevel if (strcmp(shstrtab + shp->sh_name, ".bss") == 0) 2693 0 stevel continue; 2694 0 stevel #ifdef KOBJ_DEBUG 2695 0 stevel if (kobj_debug & D_DEBUG) 2696 0 stevel _kobj_printf(ops, 2697 0 stevel "krtld: crypto_es_hash: updating hash with" 2698 0 stevel " %s data size=%d\n", shstrtab + shp->sh_name, 2699 3912 lling shp->sh_size); 2700 0 stevel #endif 2701 0 stevel ASSERT(shp->sh_addr != NULL); 2702 0 stevel SHA1Update(&ctx, (const uint8_t *)shp->sh_addr, shp->sh_size); 2703 0 stevel } 2704 0 stevel 2705 0 stevel SHA1Final((uchar_t *)hash, &ctx); 2706 0 stevel } 2707 0 stevel 2708 0 stevel /* 2709 0 stevel * Get the .SUNW_signature section for the module, it it exists. 2710 0 stevel * 2711 0 stevel * This section exists only for crypto modules. None of the 2712 0 stevel * primary modules have this section currently. 2713 0 stevel */ 2714 0 stevel static void 2715 0 stevel get_signature(struct module *mp, struct _buf *file) 2716 0 stevel { 2717 0 stevel char *shstrtab, *sigdata = NULL; 2718 0 stevel size_t shstrlen; 2719 0 stevel Shdr *shp; 2720 0 stevel uint_t i; 2721 0 stevel 2722 0 stevel if (mp->hdr.e_shstrndx >= mp->hdr.e_shnum) { 2723 0 stevel _kobj_printf(ops, "krtld: get_signature: %s, ", 2724 0 stevel mp->filename); 2725 0 stevel _kobj_printf(ops, "corrupt e_shstrndx %u\n", 2726 0 stevel mp->hdr.e_shstrndx); 2727 0 stevel return; 2728 0 stevel } 2729 0 stevel 2730 0 stevel shp = (Shdr *)(mp->shdrs + mp->hdr.e_shstrndx * mp->hdr.e_shentsize); 2731 0 stevel shstrlen = shp->sh_size; 2732 0 stevel shstrtab = kobj_alloc(shstrlen, KM_WAIT|KM_TMP); 2733 0 stevel 2734 0 stevel if (kobj_read_file(file, shstrtab, shstrlen, shp->sh_offset) < 0) { 2735 0 stevel _kobj_printf(ops, "krtld: get_signature: %s, ", 2736 0 stevel mp->filename); 2737 0 stevel _kobj_printf(ops, "error reading section %u\n", 2738 0 stevel mp->hdr.e_shstrndx); 2739 0 stevel kobj_free(shstrtab, shstrlen); 2740 0 stevel return; 2741 0 stevel } 2742 0 stevel 2743 0 stevel for (i = 0; i < mp->hdr.e_shnum; i++) { 2744 0 stevel shp = (Shdr *)(mp->shdrs + i * mp->hdr.e_shentsize); 2745 0 stevel if (shp->sh_size != 0 && shp->sh_name < shstrlen && 2746 0 stevel strcmp(shstrtab + shp->sh_name, 2747 0 stevel ELF_SIGNATURE_SECTION) == 0) { 2748 0 stevel filesig_vers_t filesig_version; 2749 0 stevel size_t sigsize = shp->sh_size + SHA1_DIGEST_LENGTH; 2750 0 stevel sigdata = kobj_alloc(sigsize, KM_WAIT|KM_SCRATCH); 2751 0 stevel 2752 0 stevel if (kobj_read_file(file, sigdata, shp->sh_size, 2753 0 stevel shp->sh_offset) < 0) { 2754 0 stevel _kobj_printf(ops, "krtld: get_signature: %s," 2755 0 stevel " error reading .SUNW_signature data\n", 2756 0 stevel mp->filename); 2757 0 stevel kobj_free(sigdata, sigsize); 2758 0 stevel kobj_free(shstrtab, shstrlen); 2759 0 stevel return; 2760 0 stevel } 2761 0 stevel filesig_version = ((struct filesignatures *)sigdata)-> 2762 0 stevel filesig_sig.filesig_version; 2763 0 stevel if (!(filesig_version == FILESIG_VERSION1 || 2764 0 stevel filesig_version == FILESIG_VERSION3)) { 2765 0 stevel /* skip versions we don't understand */ 2766 0 stevel kobj_free(sigdata, sigsize); 2767 0 stevel kobj_free(shstrtab, shstrlen); 2768 0 stevel return; 2769 0 stevel } 2770 0 stevel 2771 0 stevel mp->sigdata = sigdata; 2772 0 stevel mp->sigsize = sigsize; 2773 0 stevel break; 2774 0 stevel } 2775 0 stevel } 2776 0 stevel 2777 0 stevel if (sigdata != NULL) { 2778 0 stevel crypto_es_hash(mp, sigdata + shp->sh_size, shstrtab); 2779 0 stevel } 2780 0 stevel 2781 0 stevel kobj_free(shstrtab, shstrlen); 2782 0 stevel } 2783 0 stevel 2784 0 stevel static void 2785 0 stevel add_dependent(struct module *mp, struct module *dep) 2786 0 stevel { 2787 0 stevel struct module_list *lp; 2788 0 stevel 2789 0 stevel for (lp = mp->head; lp; lp = lp->next) { 2790 0 stevel if (lp->mp == dep) 2791 0 stevel return; /* already on the list */ 2792 0 stevel } 2793 0 stevel 2794 0 stevel if (lp == NULL) { 2795 0 stevel lp = kobj_zalloc(sizeof (*lp), KM_WAIT); 2796 0 stevel 2797 0 stevel lp->mp = dep; 2798 0 stevel lp->next = NULL; 2799 0 stevel if (mp->tail) 2800 0 stevel mp->tail->next = lp; 2801 0 stevel else 2802 0 stevel mp->head = lp; 2803 0 stevel mp->tail = lp; 2804 0 stevel } 2805 0 stevel } 2806 0 stevel 2807 0 stevel static int 2808 0 stevel do_dependents(struct modctl *modp, char *modname, size_t modnamelen) 2809 0 stevel { 2810 0 stevel struct module *mp; 2811 0 stevel struct modctl *req; 2812 0 stevel char *d, *p, *q; 2813 0 stevel int c; 2814 0 stevel char *err_modname = NULL; 2815 0 stevel 2816 0 stevel mp = modp->mod_mp; 2817 0 stevel 2818 0 stevel if ((p = mp->depends_on) == NULL) 2819 0 stevel return (0); 2820 0 stevel 2821 0 stevel for (;;) { 2822 0 stevel /* 2823 0 stevel * Skip space. 2824 0 stevel */ 2825 0 stevel while (*p && (*p == ' ' || *p == '\t')) 2826 0 stevel p++; 2827 0 stevel /* 2828 0 stevel * Get module name. 2829 0 stevel */ 2830 0 stevel d = p; 2831 0 stevel q = modname; 2832 0 stevel c = 0; 2833 0 stevel while (*p && *p != ' ' && *p != '\t') { 2834 0 stevel if (c < modnamelen - 1) { 2835 0 stevel *q++ = *p; 2836 0 stevel c++; 2837 0 stevel } 2838 0 stevel p++; 2839 0 stevel } 2840 0 stevel 2841 0 stevel if (q == modname) 2842 0 stevel break; 2843 0 stevel 2844 0 stevel if (c == modnamelen - 1) { 2845 0 stevel char *dep = kobj_alloc(p - d + 1, KM_WAIT|KM_TMP); 2846 0 stevel 2847 0 stevel (void) strncpy(dep, d, p - d + 1); 2848 0 stevel dep[p - d] = '\0'; 2849 0 stevel 2850 0 stevel _kobj_printf(ops, "%s: dependency ", modp->mod_modname); 2851 0 stevel _kobj_printf(ops, "'%s' too long ", dep); 2852 0 stevel _kobj_printf(ops, "(max %d chars)\n", modnamelen); 2853 0 stevel 2854 0 stevel kobj_free(dep, p - d + 1); 2855 0 stevel 2856 0 stevel return (-1); 2857 0 stevel } 2858 0 stevel 2859 0 stevel *q = '\0'; 2860 0 stevel if ((req = mod_load_requisite(modp, modname)) == NULL) { 2861 0 stevel #ifndef KOBJ_DEBUG 2862 0 stevel if (_moddebug & MODDEBUG_LOADMSG) { 2863 0 stevel #endif /* KOBJ_DEBUG */ 2864 0 stevel _kobj_printf(ops, 2865 0 stevel "%s: unable to resolve dependency, ", 2866 0 stevel modp->mod_modname); 2867 0 stevel _kobj_printf(ops, "cannot load module '%s'\n", 2868 0 stevel modname); 2869 0 stevel #ifndef KOBJ_DEBUG 2870 0 stevel } 2871 0 stevel #endif /* KOBJ_DEBUG */ 2872 0 stevel if (err_modname == NULL) { 2873 0 stevel /* 2874 0 stevel * This must be the same size as the modname 2875 0 stevel * one. 2876 0 stevel */ 2877 0 stevel err_modname = kobj_zalloc(MODMAXNAMELEN, 2878 0 stevel KM_WAIT); 2879 0 stevel 2880 0 stevel /* 2881 0 stevel * We can use strcpy() here without fearing 2882 0 stevel * the NULL terminator because the size of 2883 0 stevel * err_modname is the same as one of modname, 2884 0 stevel * and it's filled with zeros. 2885 0 stevel */ 2886 0 stevel (void) strcpy(err_modname, modname); 2887 0 stevel } 2888 0 stevel continue; 2889 0 stevel } 2890 0 stevel 2891 0 stevel add_dependent(mp, req->mod_mp); 2892 0 stevel mod_release_mod(req); 2893 0 stevel 2894 0 stevel } 2895 0 stevel 2896 0 stevel if (err_modname != NULL) { 2897 0 stevel /* 2898 0 stevel * Copy the first module name where you detect an error to keep 2899 0 stevel * its behavior the same as before. 2900 0 stevel * This way keeps minimizing the memory use for error 2901 0 stevel * modules, and this might be important at boot time because 2902 0 stevel * the memory usage is a crucial factor for booting in most 2903 0 stevel * cases. You can expect more verbose messages when using 2904 0 stevel * a debug kernel or setting a bit in moddebug. 2905 0 stevel */ 2906 0 stevel bzero(modname, MODMAXNAMELEN); 2907 0 stevel (void) strcpy(modname, err_modname); 2908 0 stevel kobj_free(err_modname, MODMAXNAMELEN); 2909 0 stevel return (-1); 2910 0 stevel } 2911 0 stevel 2912 0 stevel return (0); 2913 0 stevel } 2914 0 stevel 2915 0 stevel static int 2916 0 stevel do_common(struct module *mp) 2917 0 stevel { 2918 0 stevel int err; 2919 0 stevel 2920 0 stevel /* 2921 0 stevel * first time through, assign all symbols defined in other 2922 0 stevel * modules, and count up how much common space will be needed 2923 0 stevel * (bss_size and bss_align) 2924 0 stevel */ 2925 0 stevel if ((err = do_symbols(mp, 0)) < 0) 2926 0 stevel return (err); 2927 0 stevel /* 2928 0 stevel * increase bss_size by the maximum delta that could be 2929 0 stevel * computed by the ALIGN below 2930 0 stevel */ 2931 0 stevel mp->bss_size += mp->bss_align; 2932 0 stevel if (mp->bss_size) { 2933 0 stevel if (standalone) 2934 0 stevel mp->bss = (uintptr_t)kobj_segbrk(&_edata, mp->bss_size, 2935 0 stevel MINALIGN, 0); 2936 0 stevel else 2937 0 stevel mp->bss = (uintptr_t)vmem_alloc(data_arena, 2938 0 stevel mp->bss_size, VM_SLEEP | VM_BESTFIT); 2939 0 stevel bzero((void *)mp->bss, mp->bss_size); 2940 0 stevel /* now assign addresses to all common symbols */ 2941 0 stevel if ((err = do_symbols(mp, ALIGN(mp->bss, mp->bss_align))) < 0) 2942 0 stevel return (err); 2943 0 stevel } 2944 0 stevel return (0); 2945 0 stevel } 2946 0 stevel 2947 0 stevel static int 2948 0 stevel do_symbols(struct module *mp, Elf64_Addr bss_base) 2949 0 stevel { 2950 0 stevel int bss_align; 2951 0 stevel uintptr_t bss_ptr; 2952 0 stevel int err; 2953 0 stevel int i; 2954 0 stevel Sym *sp, *sp1; 2955 0 stevel char *name; 2956 0 stevel int assign; 2957 0 stevel int resolved = 1; 2958 0 stevel 2959 0 stevel /* 2960 0 stevel * Nothing left to do (optimization). 2961 0 stevel */ 2962 0 stevel if (mp->flags & KOBJ_RESOLVED) 2963 0 stevel return (0); 2964 0 stevel 2965 0 stevel assign = (bss_base) ? 1 : 0; 2966 0 stevel bss_ptr = bss_base; 2967 0 stevel bss_align = 0; 2968 0 stevel err = 0; 2969 0 stevel 2970 0 stevel for (i = 1; i < mp->nsyms; i++) { 2971 0 stevel sp = (Sym *)(mp->symtbl + mp->symhdr->sh_entsize * i); 2972 0 stevel /* 2973 0 stevel * we know that st_name is in bounds, since get_sections 2974 0 stevel * has already checked all of the symbols 2975 0 stevel */ 2976 0 stevel name = mp->strings + sp->st_name; 2977 0 stevel if (sp->st_shndx != SHN_UNDEF && sp->st_shndx != SHN_COMMON) 2978 0 stevel continue; 2979 5648 setje #if defined(__sparc) 2980 0 stevel /* 2981 0 stevel * Register symbols are ignored in the kernel 2982 0 stevel */ 2983 0 stevel if (ELF_ST_TYPE(sp->st_info) == STT_SPARC_REGISTER) { 2984 0 stevel if (*name != '\0') { 2985 0 stevel _kobj_printf(ops, "%s: named REGISTER symbol ", 2986 3912 lling mp->filename); 2987 0 stevel _kobj_printf(ops, "not supported '%s'\n", 2988 3912 lling name); 2989 0 stevel err = DOSYM_UNDEF; 2990 0 stevel } 2991 0 stevel continue; 2992 0 stevel } 2993 0 stevel #endif /* __sparc */ 2994 0 stevel /* 2995 0 stevel * TLS symbols are ignored in the kernel 2996 0 stevel */ 2997 0 stevel if (ELF_ST_TYPE(sp->st_info) == STT_TLS) { 2998 0 stevel _kobj_printf(ops, "%s: TLS symbol ", 2999 3912 lling mp->filename); 3000 0 stevel _kobj_printf(ops, "not supported '%s'\n", 3001 3912 lling name); 3002 0 stevel err = DOSYM_UNDEF; 3003 0 stevel continue; 3004 0 stevel } 3005 0 stevel 3006 0 stevel if (ELF_ST_BIND(sp->st_info) != STB_LOCAL) { 3007 0 stevel if ((sp1 = kobj_lookup_all(mp, name, 0)) != NULL) { 3008 0 stevel sp->st_shndx = SHN_ABS; 3009 0 stevel sp->st_value = sp1->st_value; 3010 0 stevel continue; 3011 0 stevel } 3012 0 stevel } 3013 0 stevel 3014 0 stevel if (sp->st_shndx == SHN_UNDEF) { 3015 0 stevel resolved = 0; 3016 0 stevel 3017 0 stevel if (strncmp(name, sdt_prefix, strlen(sdt_prefix)) == 0) 3018 0 stevel continue; 3019 0 stevel 3020 0 stevel /* 3021 0 stevel * If it's not a weak reference and it's 3022 0 stevel * not a primary object, it's an error. 3023 0 stevel * (Primary objects may take more than 3024 0 stevel * one pass to resolve) 3025 0 stevel */ 3026 0 stevel if (!(mp->flags & KOBJ_PRIM) && 3027 0 stevel ELF_ST_BIND(sp->st_info) != STB_WEAK) { 3028 0 stevel _kobj_printf(ops, "%s: undefined symbol", 3029 0 stevel mp->filename); 3030 0 stevel _kobj_printf(ops, " '%s'\n", name); 3031 0 stevel /* 3032 0 stevel * Try to determine whether this symbol 3033 0 stevel * represents a dependency on obsolete 3034 0 stevel * unsafe driver support. This is just 3035 0 stevel * to make the warning more informative. 3036 0 stevel */ 3037 0 stevel if (strcmp(name, "sleep") == 0 || 3038 0 stevel strcmp(name, "unsleep") == 0 || 3039 0 stevel strcmp(name, "wakeup") == 0 || 3040 0 stevel strcmp(name, "bsd_compat_ioctl") == 0 || 3041 0 stevel strcmp(name, "unsafe_driver") == 0 || 3042 0 stevel strncmp(name, "spl", 3) == 0 || 3043 0 stevel strncmp(name, "i_ddi_spl", 9) == 0) 3044 0 stevel err = DOSYM_UNSAFE; 3045 0 stevel if (err == 0) 3046 0 stevel err = DOSYM_UNDEF; 3047 0 stevel } 3048 0 stevel continue; 3049 0 stevel } 3050 0 stevel /* 3051 0 stevel * It's a common symbol - st_value is the 3052 0 stevel * required alignment. 3053 0 stevel */ 3054 0 stevel if (sp->st_value > bss_align) 3055 0 stevel bss_align = sp->st_value; 3056 0 stevel bss_ptr = ALIGN(bss_ptr, sp->st_value); 3057 0 stevel if (assign) { 3058 0