17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 5facf4a8dSllai * Common Development and Distribution License (the "License"). 6facf4a8dSllai * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217aec1d6eScindi 227c478bd9Sstevel@tonic-gate /* 23e37c6c37Scth * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate /* 287c478bd9Sstevel@tonic-gate * modctl system call for loadable module support. 297c478bd9Sstevel@tonic-gate */ 307c478bd9Sstevel@tonic-gate 317c478bd9Sstevel@tonic-gate #include <sys/param.h> 327c478bd9Sstevel@tonic-gate #include <sys/user.h> 337c478bd9Sstevel@tonic-gate #include <sys/systm.h> 347c478bd9Sstevel@tonic-gate #include <sys/exec.h> 357c478bd9Sstevel@tonic-gate #include <sys/file.h> 367c478bd9Sstevel@tonic-gate #include <sys/stat.h> 377c478bd9Sstevel@tonic-gate #include <sys/conf.h> 387c478bd9Sstevel@tonic-gate #include <sys/time.h> 397c478bd9Sstevel@tonic-gate #include <sys/reboot.h> 407c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_fsdir.h> 417c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 427c478bd9Sstevel@tonic-gate #include <sys/sysconf.h> 437c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 447c478bd9Sstevel@tonic-gate #include <sys/ddi.h> 457c478bd9Sstevel@tonic-gate #include <sys/sunddi.h> 467c478bd9Sstevel@tonic-gate #include <sys/sunndi.h> 477c478bd9Sstevel@tonic-gate #include <sys/ndi_impldefs.h> 487c478bd9Sstevel@tonic-gate #include <sys/ddi_impldefs.h> 497c478bd9Sstevel@tonic-gate #include <sys/ddi_implfuncs.h> 507c478bd9Sstevel@tonic-gate #include <sys/bootconf.h> 517c478bd9Sstevel@tonic-gate #include <sys/dc_ki.h> 527c478bd9Sstevel@tonic-gate #include <sys/cladm.h> 537c478bd9Sstevel@tonic-gate #include <sys/dtrace.h> 547c478bd9Sstevel@tonic-gate #include <sys/kdi.h> 557c478bd9Sstevel@tonic-gate 567c478bd9Sstevel@tonic-gate #include <sys/devpolicy.h> 577c478bd9Sstevel@tonic-gate #include <sys/modctl.h> 587c478bd9Sstevel@tonic-gate #include <sys/kobj.h> 597c478bd9Sstevel@tonic-gate #include <sys/devops.h> 607c478bd9Sstevel@tonic-gate #include <sys/autoconf.h> 617c478bd9Sstevel@tonic-gate #include <sys/hwconf.h> 627c478bd9Sstevel@tonic-gate #include <sys/callb.h> 637c478bd9Sstevel@tonic-gate #include <sys/debug.h> 647c478bd9Sstevel@tonic-gate #include <sys/cpuvar.h> 657c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 667c478bd9Sstevel@tonic-gate #include <sys/sysevent.h> 677c478bd9Sstevel@tonic-gate #include <sys/sysevent_impl.h> 687c478bd9Sstevel@tonic-gate #include <sys/instance.h> 697c478bd9Sstevel@tonic-gate #include <sys/modhash.h> 707c478bd9Sstevel@tonic-gate #include <sys/modhash_impl.h> 717c478bd9Sstevel@tonic-gate #include <sys/dacf_impl.h> 727c478bd9Sstevel@tonic-gate #include <sys/vfs.h> 737c478bd9Sstevel@tonic-gate #include <sys/pathname.h> 747c478bd9Sstevel@tonic-gate #include <sys/console.h> 757c478bd9Sstevel@tonic-gate #include <sys/policy.h> 767c478bd9Sstevel@tonic-gate #include <ipp/ipp_impl.h> 777c478bd9Sstevel@tonic-gate #include <sys/fs/dv_node.h> 787c478bd9Sstevel@tonic-gate #include <sys/strsubr.h> 79facf4a8dSllai #include <sys/fs/sdev_node.h> 807c478bd9Sstevel@tonic-gate 817c478bd9Sstevel@tonic-gate static int mod_circdep(struct modctl *); 827c478bd9Sstevel@tonic-gate static int modinfo(modid_t, struct modinfo *); 837c478bd9Sstevel@tonic-gate 847c478bd9Sstevel@tonic-gate static void mod_uninstall_all(void); 857c478bd9Sstevel@tonic-gate static int mod_getinfo(struct modctl *, struct modinfo *); 867aec1d6eScindi static struct modctl *allocate_modp(const char *, const char *); 877c478bd9Sstevel@tonic-gate 887c478bd9Sstevel@tonic-gate static int mod_load(struct modctl *, int); 897c478bd9Sstevel@tonic-gate static void mod_unload(struct modctl *); 907c478bd9Sstevel@tonic-gate static int modinstall(struct modctl *); 917c478bd9Sstevel@tonic-gate static int moduninstall(struct modctl *); 927c478bd9Sstevel@tonic-gate 937aec1d6eScindi static struct modctl *mod_hold_by_name_common(struct modctl *, const char *); 947c478bd9Sstevel@tonic-gate static struct modctl *mod_hold_next_by_id(modid_t); 957c478bd9Sstevel@tonic-gate static struct modctl *mod_hold_loaded_mod(struct modctl *, char *, int *); 9620c794b3Sgavinm static struct modctl *mod_hold_installed_mod(char *, int, int, int *); 977c478bd9Sstevel@tonic-gate 987c478bd9Sstevel@tonic-gate static void mod_release(struct modctl *); 997c478bd9Sstevel@tonic-gate static void mod_make_requisite(struct modctl *, struct modctl *); 1007c478bd9Sstevel@tonic-gate static int mod_install_requisites(struct modctl *); 1017c478bd9Sstevel@tonic-gate static void check_esc_sequences(char *, char *); 1027c478bd9Sstevel@tonic-gate static struct modctl *mod_hold_by_name_requisite(struct modctl *, char *); 1037c478bd9Sstevel@tonic-gate 1047c478bd9Sstevel@tonic-gate /* 1057c478bd9Sstevel@tonic-gate * module loading thread control structure. Calls to kobj_load_module()() are 1067c478bd9Sstevel@tonic-gate * handled off to a separate thead using this structure. 1077c478bd9Sstevel@tonic-gate */ 1087c478bd9Sstevel@tonic-gate struct loadmt { 1097c478bd9Sstevel@tonic-gate ksema_t sema; 1107c478bd9Sstevel@tonic-gate struct modctl *mp; 1117c478bd9Sstevel@tonic-gate int usepath; 1127c478bd9Sstevel@tonic-gate kthread_t *owner; 1137c478bd9Sstevel@tonic-gate int retval; 1147c478bd9Sstevel@tonic-gate }; 1157c478bd9Sstevel@tonic-gate 1167c478bd9Sstevel@tonic-gate static void modload_thread(struct loadmt *); 1177c478bd9Sstevel@tonic-gate 1187c478bd9Sstevel@tonic-gate kcondvar_t mod_cv; 1197c478bd9Sstevel@tonic-gate kcondvar_t mod_uninstall_cv; /* Communication between swapper */ 1207c478bd9Sstevel@tonic-gate /* and the uninstall daemon. */ 1217c478bd9Sstevel@tonic-gate kmutex_t mod_lock; /* protects &modules insert linkage, */ 1227c478bd9Sstevel@tonic-gate /* mod_busy, mod_want, and mod_ref. */ 1237c478bd9Sstevel@tonic-gate /* blocking operations while holding */ 1247c478bd9Sstevel@tonic-gate /* mod_lock should be avoided */ 1257c478bd9Sstevel@tonic-gate kmutex_t mod_uninstall_lock; /* protects mod_uninstall_cv */ 1267c478bd9Sstevel@tonic-gate kthread_id_t mod_aul_thread; 1277c478bd9Sstevel@tonic-gate 128a7aa4df7Scth int modunload_wait; 129a7aa4df7Scth kmutex_t modunload_wait_mutex; 130a7aa4df7Scth kcondvar_t modunload_wait_cv; 131a7aa4df7Scth int modunload_active_count; 132a7aa4df7Scth int modunload_disable_count; 133a7aa4df7Scth 1347c478bd9Sstevel@tonic-gate int isminiroot; /* set if running as miniroot */ 1357c478bd9Sstevel@tonic-gate int modrootloaded; /* set after root driver and fs are loaded */ 1367c478bd9Sstevel@tonic-gate int moddebug = 0x0; /* debug flags for module writers */ 1377c478bd9Sstevel@tonic-gate int swaploaded; /* set after swap driver and fs are loaded */ 1387c478bd9Sstevel@tonic-gate int bop_io_quiesced = 0; /* set when BOP I/O can no longer be used */ 1397c478bd9Sstevel@tonic-gate int last_module_id; 1407c478bd9Sstevel@tonic-gate clock_t mod_uninstall_interval = 0; 1417c478bd9Sstevel@tonic-gate int ddi_modclose_unload = 1; /* 0 -> just decrement reference */ 1427c478bd9Sstevel@tonic-gate 1437c478bd9Sstevel@tonic-gate struct devnames *devnamesp; 1447c478bd9Sstevel@tonic-gate struct devnames orphanlist; 1457c478bd9Sstevel@tonic-gate 1467c478bd9Sstevel@tonic-gate krwlock_t devinfo_tree_lock; /* obsolete, to be removed */ 1477c478bd9Sstevel@tonic-gate 1487c478bd9Sstevel@tonic-gate #define MAJBINDFILE "/etc/name_to_major" 1497c478bd9Sstevel@tonic-gate #define SYSBINDFILE "/etc/name_to_sysnum" 1507c478bd9Sstevel@tonic-gate 1517c478bd9Sstevel@tonic-gate static char majbind[] = MAJBINDFILE; 1527c478bd9Sstevel@tonic-gate static char sysbind[] = SYSBINDFILE; 1537c478bd9Sstevel@tonic-gate static uint_t mod_autounload_key; /* for module autounload detection */ 1547c478bd9Sstevel@tonic-gate 1557c478bd9Sstevel@tonic-gate extern int obpdebug; 1567c478bd9Sstevel@tonic-gate extern int make_mbind(char *, int, char *, struct bind **); 1577c478bd9Sstevel@tonic-gate 1587c478bd9Sstevel@tonic-gate #define DEBUGGER_PRESENT ((boothowto & RB_DEBUG) || (obpdebug != 0)) 1597c478bd9Sstevel@tonic-gate 1607c478bd9Sstevel@tonic-gate static int minorperm_loaded = 0; 1617c478bd9Sstevel@tonic-gate 1627c478bd9Sstevel@tonic-gate void 1637c478bd9Sstevel@tonic-gate mod_setup(void) 1647c478bd9Sstevel@tonic-gate { 1657c478bd9Sstevel@tonic-gate struct sysent *callp; 1667c478bd9Sstevel@tonic-gate int callnum, exectype; 1677c478bd9Sstevel@tonic-gate int num_devs; 1687c478bd9Sstevel@tonic-gate int i; 1697c478bd9Sstevel@tonic-gate 1707c478bd9Sstevel@tonic-gate /* 1717c478bd9Sstevel@tonic-gate * Initialize the list of loaded driver dev_ops. 1727c478bd9Sstevel@tonic-gate * XXX - This must be done before reading the system file so that 1737c478bd9Sstevel@tonic-gate * forceloads of drivers will work. 1747c478bd9Sstevel@tonic-gate */ 1757c478bd9Sstevel@tonic-gate num_devs = read_binding_file(majbind, mb_hashtab, make_mbind); 1767c478bd9Sstevel@tonic-gate /* 1777c478bd9Sstevel@tonic-gate * Since read_binding_file is common code, it doesn't enforce that all 1787c478bd9Sstevel@tonic-gate * of the binding file entries have major numbers <= MAXMAJ32. Thus, 1797c478bd9Sstevel@tonic-gate * ensure that we don't allocate some massive amount of space due to a 1807c478bd9Sstevel@tonic-gate * bad entry. We can't have major numbers bigger than MAXMAJ32 1817c478bd9Sstevel@tonic-gate * until file system support for larger major numbers exists. 1827c478bd9Sstevel@tonic-gate */ 1837c478bd9Sstevel@tonic-gate 1847c478bd9Sstevel@tonic-gate /* 1857c478bd9Sstevel@tonic-gate * Leave space for expansion, but not more than L_MAXMAJ32 1867c478bd9Sstevel@tonic-gate */ 1877c478bd9Sstevel@tonic-gate devcnt = MIN(num_devs + 30, L_MAXMAJ32); 1887c478bd9Sstevel@tonic-gate devopsp = kmem_alloc(devcnt * sizeof (struct dev_ops *), KM_SLEEP); 1897c478bd9Sstevel@tonic-gate for (i = 0; i < devcnt; i++) 1907c478bd9Sstevel@tonic-gate devopsp[i] = &mod_nodev_ops; 1917c478bd9Sstevel@tonic-gate 1927c478bd9Sstevel@tonic-gate init_devnamesp(devcnt); 1937c478bd9Sstevel@tonic-gate 1947c478bd9Sstevel@tonic-gate /* 1957c478bd9Sstevel@tonic-gate * Sync up with the work that the stand-alone linker has already done. 1967c478bd9Sstevel@tonic-gate */ 1977c478bd9Sstevel@tonic-gate (void) kobj_sync(); 1987c478bd9Sstevel@tonic-gate 1997c478bd9Sstevel@tonic-gate if (boothowto & RB_DEBUG) 2007c478bd9Sstevel@tonic-gate kdi_dvec_modavail(); 2017c478bd9Sstevel@tonic-gate 2027c478bd9Sstevel@tonic-gate make_aliases(mb_hashtab); 2037c478bd9Sstevel@tonic-gate 2047c478bd9Sstevel@tonic-gate /* 2057c478bd9Sstevel@tonic-gate * Initialize streams device implementation structures. 2067c478bd9Sstevel@tonic-gate */ 2077c478bd9Sstevel@tonic-gate devimpl = kmem_zalloc(devcnt * sizeof (cdevsw_impl_t), KM_SLEEP); 2087c478bd9Sstevel@tonic-gate 2097c478bd9Sstevel@tonic-gate /* 2107c478bd9Sstevel@tonic-gate * If the cl_bootstrap module is present, 2117c478bd9Sstevel@tonic-gate * we should be configured as a cluster. Loading this module 2127c478bd9Sstevel@tonic-gate * will set "cluster_bootflags" to non-zero. 2137c478bd9Sstevel@tonic-gate */ 2147c478bd9Sstevel@tonic-gate (void) modload("misc", "cl_bootstrap"); 2157c478bd9Sstevel@tonic-gate 2167c478bd9Sstevel@tonic-gate (void) read_binding_file(sysbind, sb_hashtab, make_mbind); 2177c478bd9Sstevel@tonic-gate init_syscallnames(NSYSCALL); 2187c478bd9Sstevel@tonic-gate 2197c478bd9Sstevel@tonic-gate /* 2207c478bd9Sstevel@tonic-gate * Start up dynamic autoconfiguration framework (dacf). 2217c478bd9Sstevel@tonic-gate */ 2227c478bd9Sstevel@tonic-gate mod_hash_init(); 2237c478bd9Sstevel@tonic-gate dacf_init(); 2247c478bd9Sstevel@tonic-gate 2257c478bd9Sstevel@tonic-gate /* 2267c478bd9Sstevel@tonic-gate * Start up IP policy framework (ipp). 2277c478bd9Sstevel@tonic-gate */ 2287c478bd9Sstevel@tonic-gate ipp_init(); 2297c478bd9Sstevel@tonic-gate 2307c478bd9Sstevel@tonic-gate /* 2317c478bd9Sstevel@tonic-gate * Allocate loadable native system call locks. 2327c478bd9Sstevel@tonic-gate */ 2337c478bd9Sstevel@tonic-gate for (callnum = 0, callp = sysent; callnum < NSYSCALL; 2347c478bd9Sstevel@tonic-gate callnum++, callp++) { 2357c478bd9Sstevel@tonic-gate if (LOADABLE_SYSCALL(callp)) { 2367c478bd9Sstevel@tonic-gate if (mod_getsysname(callnum) != NULL) { 2377c478bd9Sstevel@tonic-gate callp->sy_lock = 2387c478bd9Sstevel@tonic-gate kobj_zalloc(sizeof (krwlock_t), KM_SLEEP); 2397c478bd9Sstevel@tonic-gate rw_init(callp->sy_lock, NULL, RW_DEFAULT, NULL); 2407c478bd9Sstevel@tonic-gate } else { 2417c478bd9Sstevel@tonic-gate callp->sy_flags &= ~SE_LOADABLE; 2427c478bd9Sstevel@tonic-gate callp->sy_callc = nosys; 2437c478bd9Sstevel@tonic-gate } 2447c478bd9Sstevel@tonic-gate #ifdef DEBUG 2457c478bd9Sstevel@tonic-gate } else { 2467c478bd9Sstevel@tonic-gate /* 2477c478bd9Sstevel@tonic-gate * Do some sanity checks on the sysent table 2487c478bd9Sstevel@tonic-gate */ 2497c478bd9Sstevel@tonic-gate switch (callp->sy_flags & SE_RVAL_MASK) { 2507c478bd9Sstevel@tonic-gate case SE_32RVAL1: 2517c478bd9Sstevel@tonic-gate /* only r_val1 returned */ 2527c478bd9Sstevel@tonic-gate case SE_32RVAL1 | SE_32RVAL2: 2537c478bd9Sstevel@tonic-gate /* r_val1 and r_val2 returned */ 2547c478bd9Sstevel@tonic-gate case SE_64RVAL: 2557c478bd9Sstevel@tonic-gate /* 64-bit rval returned */ 2567c478bd9Sstevel@tonic-gate break; 2577c478bd9Sstevel@tonic-gate default: 2587c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "sysent[%d]: bad flags %x", 2597c478bd9Sstevel@tonic-gate callnum, callp->sy_flags); 2607c478bd9Sstevel@tonic-gate } 2617c478bd9Sstevel@tonic-gate #endif 2627c478bd9Sstevel@tonic-gate } 2637c478bd9Sstevel@tonic-gate } 2647c478bd9Sstevel@tonic-gate 2657c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 2667c478bd9Sstevel@tonic-gate /* 2677c478bd9Sstevel@tonic-gate * Allocate loadable system call locks for 32-bit compat syscalls 2687c478bd9Sstevel@tonic-gate */ 2697c478bd9Sstevel@tonic-gate for (callnum = 0, callp = sysent32; callnum < NSYSCALL; 2707c478bd9Sstevel@tonic-gate callnum++, callp++) { 2717c478bd9Sstevel@tonic-gate if (LOADABLE_SYSCALL(callp)) { 2727c478bd9Sstevel@tonic-gate if (mod_getsysname(callnum) != NULL) { 2737c478bd9Sstevel@tonic-gate callp->sy_lock = 2747c478bd9Sstevel@tonic-gate kobj_zalloc(sizeof (krwlock_t), KM_SLEEP); 2757c478bd9Sstevel@tonic-gate rw_init(callp->sy_lock, NULL, RW_DEFAULT, NULL); 2767c478bd9Sstevel@tonic-gate } else { 2777c478bd9Sstevel@tonic-gate callp->sy_flags &= ~SE_LOADABLE; 2787c478bd9Sstevel@tonic-gate callp->sy_callc = nosys; 2797c478bd9Sstevel@tonic-gate } 2807c478bd9Sstevel@tonic-gate #ifdef DEBUG 2817c478bd9Sstevel@tonic-gate } else { 2827c478bd9Sstevel@tonic-gate /* 2837c478bd9Sstevel@tonic-gate * Do some sanity checks on the sysent table 2847c478bd9Sstevel@tonic-gate */ 2857c478bd9Sstevel@tonic-gate switch (callp->sy_flags & SE_RVAL_MASK) { 2867c478bd9Sstevel@tonic-gate case SE_32RVAL1: 2877c478bd9Sstevel@tonic-gate /* only r_val1 returned */ 2887c478bd9Sstevel@tonic-gate case SE_32RVAL1 | SE_32RVAL2: 2897c478bd9Sstevel@tonic-gate /* r_val1 and r_val2 returned */ 2907c478bd9Sstevel@tonic-gate case SE_64RVAL: 2917c478bd9Sstevel@tonic-gate /* 64-bit rval returned */ 2927c478bd9Sstevel@tonic-gate break; 2937c478bd9Sstevel@tonic-gate default: 2947c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "sysent32[%d]: bad flags %x", 2957c478bd9Sstevel@tonic-gate callnum, callp->sy_flags); 2967c478bd9Sstevel@tonic-gate goto skip; 2977c478bd9Sstevel@tonic-gate } 2987c478bd9Sstevel@tonic-gate 2997c478bd9Sstevel@tonic-gate /* 3007c478bd9Sstevel@tonic-gate * Cross-check the native and compatibility tables. 3017c478bd9Sstevel@tonic-gate */ 3027c478bd9Sstevel@tonic-gate if (callp->sy_callc == nosys || 3037c478bd9Sstevel@tonic-gate sysent[callnum].sy_callc == nosys) 3047c478bd9Sstevel@tonic-gate continue; 3057c478bd9Sstevel@tonic-gate /* 3067c478bd9Sstevel@tonic-gate * If only one or the other slot is loadable, then 3077c478bd9Sstevel@tonic-gate * there's an error -- they should match! 3087c478bd9Sstevel@tonic-gate */ 3097c478bd9Sstevel@tonic-gate if ((callp->sy_callc == loadable_syscall) ^ 3107c478bd9Sstevel@tonic-gate (sysent[callnum].sy_callc == loadable_syscall)) { 3117c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "sysent[%d] loadable?", 3127c478bd9Sstevel@tonic-gate callnum); 3137c478bd9Sstevel@tonic-gate } 3147c478bd9Sstevel@tonic-gate /* 3157c478bd9Sstevel@tonic-gate * This is more of a heuristic test -- if the 3167c478bd9Sstevel@tonic-gate * system call returns two values in the 32-bit 3177c478bd9Sstevel@tonic-gate * world, it should probably return two 32-bit 3187c478bd9Sstevel@tonic-gate * values in the 64-bit world too. 3197c478bd9Sstevel@tonic-gate */ 3207c478bd9Sstevel@tonic-gate if (((callp->sy_flags & SE_32RVAL2) == 0) ^ 3217c478bd9Sstevel@tonic-gate ((sysent[callnum].sy_flags & SE_32RVAL2) == 0)) { 3227c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "sysent[%d] rval2 mismatch!", 3237c478bd9Sstevel@tonic-gate callnum); 3247c478bd9Sstevel@tonic-gate } 3257c478bd9Sstevel@tonic-gate skip:; 3267c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 3277c478bd9Sstevel@tonic-gate } 3287c478bd9Sstevel@tonic-gate } 3297c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32_IMPL */ 3307c478bd9Sstevel@tonic-gate 3317c478bd9Sstevel@tonic-gate /* 3327c478bd9Sstevel@tonic-gate * Allocate loadable exec locks. (Assumes all execs are loadable) 3337c478bd9Sstevel@tonic-gate */ 3347c478bd9Sstevel@tonic-gate for (exectype = 0; exectype < nexectype; exectype++) { 3357c478bd9Sstevel@tonic-gate execsw[exectype].exec_lock = 3367c478bd9Sstevel@tonic-gate kobj_zalloc(sizeof (krwlock_t), KM_SLEEP); 3377c478bd9Sstevel@tonic-gate rw_init(execsw[exectype].exec_lock, NULL, RW_DEFAULT, NULL); 3387c478bd9Sstevel@tonic-gate } 3397c478bd9Sstevel@tonic-gate 3407c478bd9Sstevel@tonic-gate read_class_file(); 3417c478bd9Sstevel@tonic-gate 3427c478bd9Sstevel@tonic-gate /* init thread specific structure for mod_uninstall_all */ 3437c478bd9Sstevel@tonic-gate tsd_create(&mod_autounload_key, NULL); 3447c478bd9Sstevel@tonic-gate } 3457c478bd9Sstevel@tonic-gate 3467c478bd9Sstevel@tonic-gate static int 3477c478bd9Sstevel@tonic-gate modctl_modload(int use_path, char *filename, int *rvp) 3487c478bd9Sstevel@tonic-gate { 3497c478bd9Sstevel@tonic-gate struct modctl *modp; 3507c478bd9Sstevel@tonic-gate int retval = 0; 3517c478bd9Sstevel@tonic-gate char *filenamep; 3527c478bd9Sstevel@tonic-gate int modid; 3537c478bd9Sstevel@tonic-gate 3547c478bd9Sstevel@tonic-gate filenamep = kmem_zalloc(MOD_MAXPATH, KM_SLEEP); 3557c478bd9Sstevel@tonic-gate 3567c478bd9Sstevel@tonic-gate if (copyinstr(filename, filenamep, MOD_MAXPATH, 0)) { 3577c478bd9Sstevel@tonic-gate retval = EFAULT; 3587c478bd9Sstevel@tonic-gate goto out; 3597c478bd9Sstevel@tonic-gate } 3607c478bd9Sstevel@tonic-gate 3617c478bd9Sstevel@tonic-gate filenamep[MOD_MAXPATH - 1] = 0; 36220c794b3Sgavinm modp = mod_hold_installed_mod(filenamep, use_path, 0, &retval); 3637c478bd9Sstevel@tonic-gate 3647c478bd9Sstevel@tonic-gate if (modp == NULL) 3657c478bd9Sstevel@tonic-gate goto out; 3667c478bd9Sstevel@tonic-gate 3677c478bd9Sstevel@tonic-gate modp->mod_loadflags |= MOD_NOAUTOUNLOAD; 3687c478bd9Sstevel@tonic-gate modid = modp->mod_id; 3697c478bd9Sstevel@tonic-gate mod_release_mod(modp); 3700b38a8bdSahl CPU_STATS_ADDQ(CPU, sys, modload, 1); 3717c478bd9Sstevel@tonic-gate if (rvp != NULL && copyout(&modid, rvp, sizeof (modid)) != 0) 3727c478bd9Sstevel@tonic-gate retval = EFAULT; 3737c478bd9Sstevel@tonic-gate out: 3747c478bd9Sstevel@tonic-gate kmem_free(filenamep, MOD_MAXPATH); 3757c478bd9Sstevel@tonic-gate 3767c478bd9Sstevel@tonic-gate return (retval); 3777c478bd9Sstevel@tonic-gate } 3787c478bd9Sstevel@tonic-gate 3797c478bd9Sstevel@tonic-gate static int 3807c478bd9Sstevel@tonic-gate modctl_modunload(modid_t id) 3817c478bd9Sstevel@tonic-gate { 3827c478bd9Sstevel@tonic-gate int rval = 0; 3837c478bd9Sstevel@tonic-gate 3847c478bd9Sstevel@tonic-gate if (id == 0) { 3857c478bd9Sstevel@tonic-gate #ifdef DEBUG 3867c478bd9Sstevel@tonic-gate /* 3877c478bd9Sstevel@tonic-gate * Turn on mod_uninstall_daemon 3887c478bd9Sstevel@tonic-gate */ 3897c478bd9Sstevel@tonic-gate if (mod_uninstall_interval == 0) { 3907c478bd9Sstevel@tonic-gate mod_uninstall_interval = 60; 3917c478bd9Sstevel@tonic-gate modreap(); 3927c478bd9Sstevel@tonic-gate return (rval); 3937c478bd9Sstevel@tonic-gate } 3947c478bd9Sstevel@tonic-gate #endif 3957c478bd9Sstevel@tonic-gate mod_uninstall_all(); 3967c478bd9Sstevel@tonic-gate } else { 3977c478bd9Sstevel@tonic-gate rval = modunload(id); 3987c478bd9Sstevel@tonic-gate } 3997c478bd9Sstevel@tonic-gate return (rval); 4007c478bd9Sstevel@tonic-gate } 4017c478bd9Sstevel@tonic-gate 4027c478bd9Sstevel@tonic-gate static int 4037c478bd9Sstevel@tonic-gate modctl_modinfo(modid_t id, struct modinfo *umodi) 4047c478bd9Sstevel@tonic-gate { 4057c478bd9Sstevel@tonic-gate int retval; 4067c478bd9Sstevel@tonic-gate struct modinfo modi; 4077c478bd9Sstevel@tonic-gate #if defined(_SYSCALL32_IMPL) 4087c478bd9Sstevel@tonic-gate int nobase; 4097c478bd9Sstevel@tonic-gate struct modinfo32 modi32; 4107c478bd9Sstevel@tonic-gate #endif 4117c478bd9Sstevel@tonic-gate 4127c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 4137c478bd9Sstevel@tonic-gate if (copyin(umodi, &modi, sizeof (struct modinfo)) != 0) 4147c478bd9Sstevel@tonic-gate return (EFAULT); 4157c478bd9Sstevel@tonic-gate } 4167c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 4177c478bd9Sstevel@tonic-gate else { 4187c478bd9Sstevel@tonic-gate bzero(&modi, sizeof (modi)); 4197c478bd9Sstevel@tonic-gate if (copyin(umodi, &modi32, sizeof (struct modinfo32)) != 0) 4207c478bd9Sstevel@tonic-gate return (EFAULT); 4217c478bd9Sstevel@tonic-gate modi.mi_info = modi32.mi_info; 4227c478bd9Sstevel@tonic-gate modi.mi_id = modi32.mi_id; 4237c478bd9Sstevel@tonic-gate modi.mi_nextid = modi32.mi_nextid; 4247c478bd9Sstevel@tonic-gate nobase = modi.mi_info & MI_INFO_NOBASE; 4257c478bd9Sstevel@tonic-gate } 4267c478bd9Sstevel@tonic-gate #endif 4277c478bd9Sstevel@tonic-gate /* 4287c478bd9Sstevel@tonic-gate * This flag is -only- for the kernels use. 4297c478bd9Sstevel@tonic-gate */ 4307c478bd9Sstevel@tonic-gate modi.mi_info &= ~MI_INFO_LINKAGE; 4317c478bd9Sstevel@tonic-gate 4327c478bd9Sstevel@tonic-gate retval = modinfo(id, &modi); 4337c478bd9Sstevel@tonic-gate if (retval) 4347c478bd9Sstevel@tonic-gate return (retval); 4357c478bd9Sstevel@tonic-gate 4367c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 4377c478bd9Sstevel@tonic-gate if (copyout(&modi, umodi, sizeof (struct modinfo)) != 0) 4387c478bd9Sstevel@tonic-gate retval = EFAULT; 4397c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 4407c478bd9Sstevel@tonic-gate } else { 4417c478bd9Sstevel@tonic-gate int i; 4427c478bd9Sstevel@tonic-gate 4437c478bd9Sstevel@tonic-gate if (!nobase && (uintptr_t)modi.mi_base > UINT32_MAX) 4447c478bd9Sstevel@tonic-gate return (EOVERFLOW); 4457c478bd9Sstevel@tonic-gate 4467c478bd9Sstevel@tonic-gate modi32.mi_info = modi.mi_info; 4477c478bd9Sstevel@tonic-gate modi32.mi_state = modi.mi_state; 4487c478bd9Sstevel@tonic-gate modi32.mi_id = modi.mi_id; 4497c478bd9Sstevel@tonic-gate modi32.mi_nextid = modi.mi_nextid; 4507c478bd9Sstevel@tonic-gate modi32.mi_base = (caddr32_t)(uintptr_t)modi.mi_base; 4517c478bd9Sstevel@tonic-gate modi32.mi_size = modi.mi_size; 4527c478bd9Sstevel@tonic-gate modi32.mi_rev = modi.mi_rev; 4537c478bd9Sstevel@tonic-gate modi32.mi_loadcnt = modi.mi_loadcnt; 4547c478bd9Sstevel@tonic-gate bcopy(modi.mi_name, modi32.mi_name, sizeof (modi32.mi_name)); 4557c478bd9Sstevel@tonic-gate for (i = 0; i < MODMAXLINK32; i++) { 4567c478bd9Sstevel@tonic-gate modi32.mi_msinfo[i].msi_p0 = modi.mi_msinfo[i].msi_p0; 4577c478bd9Sstevel@tonic-gate bcopy(modi.mi_msinfo[i].msi_linkinfo, 4587c478bd9Sstevel@tonic-gate modi32.mi_msinfo[i].msi_linkinfo, 4597c478bd9Sstevel@tonic-gate sizeof (modi32.mi_msinfo[0].msi_linkinfo)); 4607c478bd9Sstevel@tonic-gate } 4617c478bd9Sstevel@tonic-gate if (copyout(&modi32, umodi, sizeof (struct modinfo32)) != 0) 4627c478bd9Sstevel@tonic-gate retval = EFAULT; 4637c478bd9Sstevel@tonic-gate #endif 4647c478bd9Sstevel@tonic-gate } 4657c478bd9Sstevel@tonic-gate 4667c478bd9Sstevel@tonic-gate return (retval); 4677c478bd9Sstevel@tonic-gate } 4687c478bd9Sstevel@tonic-gate 4697c478bd9Sstevel@tonic-gate /* 4707c478bd9Sstevel@tonic-gate * Return the last major number in the range of permissible major numbers. 4717c478bd9Sstevel@tonic-gate */ 4727c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 4737c478bd9Sstevel@tonic-gate static int 4747c478bd9Sstevel@tonic-gate modctl_modreserve(modid_t id, int *data) 4757c478bd9Sstevel@tonic-gate { 4767c478bd9Sstevel@tonic-gate if (copyout(&devcnt, data, sizeof (devcnt)) != 0) 4777c478bd9Sstevel@tonic-gate return (EFAULT); 4787c478bd9Sstevel@tonic-gate return (0); 4797c478bd9Sstevel@tonic-gate } 4807c478bd9Sstevel@tonic-gate 4817c478bd9Sstevel@tonic-gate static int 4827c478bd9Sstevel@tonic-gate modctl_add_major(int *data) 4837c478bd9Sstevel@tonic-gate { 4847c478bd9Sstevel@tonic-gate struct modconfig mc; 4857c478bd9Sstevel@tonic-gate int i, rv; 4867c478bd9Sstevel@tonic-gate struct aliases alias; 4877c478bd9Sstevel@tonic-gate struct aliases *ap; 4887c478bd9Sstevel@tonic-gate char name[MAXMODCONFNAME]; 4897c478bd9Sstevel@tonic-gate char cname[MAXMODCONFNAME]; 4907c478bd9Sstevel@tonic-gate char *drvname; 4917c478bd9Sstevel@tonic-gate 4927c478bd9Sstevel@tonic-gate bzero(&mc, sizeof (struct modconfig)); 4937c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 4947c478bd9Sstevel@tonic-gate if (copyin(data, &mc, sizeof (struct modconfig)) != 0) 4957c478bd9Sstevel@tonic-gate return (EFAULT); 4967c478bd9Sstevel@tonic-gate } 4977c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 4987c478bd9Sstevel@tonic-gate else { 4997c478bd9Sstevel@tonic-gate struct modconfig32 modc32; 5007c478bd9Sstevel@tonic-gate 5017c478bd9Sstevel@tonic-gate if (copyin(data, &modc32, sizeof (struct modconfig32)) != 0) 5027c478bd9Sstevel@tonic-gate return (EFAULT); 5037c478bd9Sstevel@tonic-gate else { 5047c478bd9Sstevel@tonic-gate bcopy(modc32.drvname, mc.drvname, 5057c478bd9Sstevel@tonic-gate sizeof (modc32.drvname)); 5067c478bd9Sstevel@tonic-gate bcopy(modc32.drvclass, mc.drvclass, 5077c478bd9Sstevel@tonic-gate sizeof (modc32.drvclass)); 5087c478bd9Sstevel@tonic-gate mc.major = modc32.major; 5097c478bd9Sstevel@tonic-gate mc.num_aliases = modc32.num_aliases; 5107c478bd9Sstevel@tonic-gate mc.ap = (struct aliases *)(uintptr_t)modc32.ap; 5117c478bd9Sstevel@tonic-gate } 5127c478bd9Sstevel@tonic-gate } 5137c478bd9Sstevel@tonic-gate #endif 5147c478bd9Sstevel@tonic-gate 5157c478bd9Sstevel@tonic-gate /* 5167c478bd9Sstevel@tonic-gate * If the driver is already in the mb_hashtab, and the name given 5177c478bd9Sstevel@tonic-gate * doesn't match that driver's name, fail. Otherwise, pass, since 5187c478bd9Sstevel@tonic-gate * we may be adding aliases. 5197c478bd9Sstevel@tonic-gate */ 5207c478bd9Sstevel@tonic-gate if ((drvname = mod_major_to_name(mc.major)) != NULL && 5217c478bd9Sstevel@tonic-gate strcmp(drvname, mc.drvname) != 0) 5227c478bd9Sstevel@tonic-gate return (EINVAL); 5237c478bd9Sstevel@tonic-gate 5247c478bd9Sstevel@tonic-gate /* 5257c478bd9Sstevel@tonic-gate * Add each supplied driver alias to mb_hashtab 5267c478bd9Sstevel@tonic-gate */ 5277c478bd9Sstevel@tonic-gate ap = mc.ap; 5287c478bd9Sstevel@tonic-gate for (i = 0; i < mc.num_aliases; i++) { 5297c478bd9Sstevel@tonic-gate bzero(&alias, sizeof (struct aliases)); 5307c478bd9Sstevel@tonic-gate 5317c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 5327c478bd9Sstevel@tonic-gate if (copyin(ap, &alias, sizeof (struct aliases)) != 0) 5337c478bd9Sstevel@tonic-gate return (EFAULT); 5347c478bd9Sstevel@tonic-gate 5357c478bd9Sstevel@tonic-gate if (alias.a_len > MAXMODCONFNAME) 5367c478bd9Sstevel@tonic-gate return (EINVAL); 5377c478bd9Sstevel@tonic-gate 5387c478bd9Sstevel@tonic-gate if (copyin(alias.a_name, name, alias.a_len) != 0) 5397c478bd9Sstevel@tonic-gate return (EFAULT); 5407c478bd9Sstevel@tonic-gate 5417c478bd9Sstevel@tonic-gate if (name[alias.a_len - 1] != '\0') 5427c478bd9Sstevel@tonic-gate return (EINVAL); 5437c478bd9Sstevel@tonic-gate } 5447c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 5457c478bd9Sstevel@tonic-gate else { 5467c478bd9Sstevel@tonic-gate struct aliases32 al32; 5477c478bd9Sstevel@tonic-gate 5487c478bd9Sstevel@tonic-gate bzero(&al32, sizeof (struct aliases32)); 5497c478bd9Sstevel@tonic-gate if (copyin(ap, &al32, sizeof (struct aliases32)) != 0) 5507c478bd9Sstevel@tonic-gate return (EFAULT); 5517c478bd9Sstevel@tonic-gate 5527c478bd9Sstevel@tonic-gate if (al32.a_len > MAXMODCONFNAME) 5537c478bd9Sstevel@tonic-gate return (EINVAL); 5547c478bd9Sstevel@tonic-gate 5557c478bd9Sstevel@tonic-gate if (copyin((void *)(uintptr_t)al32.a_name, 5567c478bd9Sstevel@tonic-gate name, al32.a_len) != 0) 5577c478bd9Sstevel@tonic-gate return (EFAULT); 5587c478bd9Sstevel@tonic-gate 5597c478bd9Sstevel@tonic-gate if (name[al32.a_len - 1] != '\0') 5607c478bd9Sstevel@tonic-gate return (EINVAL); 5617c478bd9Sstevel@tonic-gate 5627c478bd9Sstevel@tonic-gate alias.a_next = (void *)(uintptr_t)al32.a_next; 5637c478bd9Sstevel@tonic-gate } 5647c478bd9Sstevel@tonic-gate #endif 5657c478bd9Sstevel@tonic-gate check_esc_sequences(name, cname); 5667c478bd9Sstevel@tonic-gate (void) make_mbind(cname, mc.major, NULL, mb_hashtab); 5677c478bd9Sstevel@tonic-gate ap = alias.a_next; 5687c478bd9Sstevel@tonic-gate } 5697c478bd9Sstevel@tonic-gate 5707c478bd9Sstevel@tonic-gate /* 5717c478bd9Sstevel@tonic-gate * Try to establish an mbinding for mc.drvname, and add it to devnames. 5727c478bd9Sstevel@tonic-gate * Add class if any after establishing the major number 5737c478bd9Sstevel@tonic-gate */ 5747c478bd9Sstevel@tonic-gate (void) make_mbind(mc.drvname, mc.major, NULL, mb_hashtab); 5757c478bd9Sstevel@tonic-gate rv = make_devname(mc.drvname, mc.major); 5767c478bd9Sstevel@tonic-gate 5777c478bd9Sstevel@tonic-gate if (rv == 0) { 5787c478bd9Sstevel@tonic-gate if (mc.drvclass[0] != '\0') 5797c478bd9Sstevel@tonic-gate add_class(mc.drvname, mc.drvclass); 5807c478bd9Sstevel@tonic-gate (void) i_ddi_load_drvconf(mc.major); 5817c478bd9Sstevel@tonic-gate i_ddi_bind_devs(); 5827c478bd9Sstevel@tonic-gate i_ddi_di_cache_invalidate(KM_SLEEP); 5837c478bd9Sstevel@tonic-gate } 5847c478bd9Sstevel@tonic-gate return (rv); 5857c478bd9Sstevel@tonic-gate } 5867c478bd9Sstevel@tonic-gate 5877c478bd9Sstevel@tonic-gate static int 5887c478bd9Sstevel@tonic-gate modctl_rem_major(major_t major) 5897c478bd9Sstevel@tonic-gate { 5907c478bd9Sstevel@tonic-gate struct devnames *dnp; 5917c478bd9Sstevel@tonic-gate 5927c478bd9Sstevel@tonic-gate if (major >= devcnt) 5937c478bd9Sstevel@tonic-gate return (EINVAL); 5947c478bd9Sstevel@tonic-gate 5957c478bd9Sstevel@tonic-gate /* mark devnames as removed */ 5967c478bd9Sstevel@tonic-gate dnp = &devnamesp[major]; 5977c478bd9Sstevel@tonic-gate LOCK_DEV_OPS(&dnp->dn_lock); 5987c478bd9Sstevel@tonic-gate if (dnp->dn_name == NULL || 5997c478bd9Sstevel@tonic-gate (dnp->dn_flags & (DN_DRIVER_REMOVED | DN_TAKEN_GETUDEV))) { 6007c478bd9Sstevel@tonic-gate UNLOCK_DEV_OPS(&dnp->dn_lock); 6017c478bd9Sstevel@tonic-gate return (EINVAL); 6027c478bd9Sstevel@tonic-gate } 6037c478bd9Sstevel@tonic-gate dnp->dn_flags |= DN_DRIVER_REMOVED; 6047c478bd9Sstevel@tonic-gate pm_driver_removed(major); 6057c478bd9Sstevel@tonic-gate UNLOCK_DEV_OPS(&dnp->dn_lock); 6067c478bd9Sstevel@tonic-gate 6077c478bd9Sstevel@tonic-gate (void) i_ddi_unload_drvconf(major); 6087c478bd9Sstevel@tonic-gate i_ddi_unbind_devs(major); 6097c478bd9Sstevel@tonic-gate i_ddi_di_cache_invalidate(KM_SLEEP); 6107c478bd9Sstevel@tonic-gate return (0); 6117c478bd9Sstevel@tonic-gate } 6127c478bd9Sstevel@tonic-gate 6137c478bd9Sstevel@tonic-gate static struct vfs * 6147c478bd9Sstevel@tonic-gate path_to_vfs(char *name) 6157c478bd9Sstevel@tonic-gate { 6167c478bd9Sstevel@tonic-gate vnode_t *vp; 6177c478bd9Sstevel@tonic-gate struct vfs *vfsp; 6187c478bd9Sstevel@tonic-gate 6197c478bd9Sstevel@tonic-gate if (lookupname(name, UIO_SYSSPACE, FOLLOW, NULLVPP, &vp)) 6207c478bd9Sstevel@tonic-gate return (NULL); 6217c478bd9Sstevel@tonic-gate 6227c478bd9Sstevel@tonic-gate vfsp = vp->v_vfsp; 6237c478bd9Sstevel@tonic-gate VN_RELE(vp); 6247c478bd9Sstevel@tonic-gate return (vfsp); 6257c478bd9Sstevel@tonic-gate } 6267c478bd9Sstevel@tonic-gate 6277c478bd9Sstevel@tonic-gate static int 6287c478bd9Sstevel@tonic-gate new_vfs_in_modpath() 6297c478bd9Sstevel@tonic-gate { 6307c478bd9Sstevel@tonic-gate static int n_modpath = 0; 6317c478bd9Sstevel@tonic-gate static char *modpath_copy; 6327c478bd9Sstevel@tonic-gate static struct pathvfs { 6337c478bd9Sstevel@tonic-gate char *path; 6347c478bd9Sstevel@tonic-gate struct vfs *vfsp; 6357c478bd9Sstevel@tonic-gate } *pathvfs; 6367c478bd9Sstevel@tonic-gate 6377c478bd9Sstevel@tonic-gate int i, new_vfs = 0; 6387c478bd9Sstevel@tonic-gate char *tmp, *tmp1; 6397c478bd9Sstevel@tonic-gate struct vfs *vfsp; 6407c478bd9Sstevel@tonic-gate 6417c478bd9Sstevel@tonic-gate if (n_modpath != 0) { 6427c478bd9Sstevel@tonic-gate for (i = 0; i < n_modpath; i++) { 6437c478bd9Sstevel@tonic-gate vfsp = path_to_vfs(pathvfs[i].path); 6447c478bd9Sstevel@tonic-gate if (vfsp != pathvfs[i].vfsp) { 6457c478bd9Sstevel@tonic-gate pathvfs[i].vfsp = vfsp; 6467c478bd9Sstevel@tonic-gate if (vfsp) 6477c478bd9Sstevel@tonic-gate new_vfs = 1; 6487c478bd9Sstevel@tonic-gate } 6497c478bd9Sstevel@tonic-gate } 6507c478bd9Sstevel@tonic-gate return (new_vfs); 6517c478bd9Sstevel@tonic-gate } 6527c478bd9Sstevel@tonic-gate 6537c478bd9Sstevel@tonic-gate /* 6547c478bd9Sstevel@tonic-gate * First call, initialize the pathvfs structure 6557c478bd9Sstevel@tonic-gate */ 6567c478bd9Sstevel@tonic-gate modpath_copy = i_ddi_strdup(default_path, KM_SLEEP); 6577c478bd9Sstevel@tonic-gate tmp = modpath_copy; 6587c478bd9Sstevel@tonic-gate n_modpath = 1; 6597c478bd9Sstevel@tonic-gate tmp1 = strchr(tmp, ' '); 6607c478bd9Sstevel@tonic-gate while (tmp1) { 6617c478bd9Sstevel@tonic-gate *tmp1 = '\0'; 6627c478bd9Sstevel@tonic-gate n_modpath++; 6637c478bd9Sstevel@tonic-gate tmp = tmp1 + 1; 6647c478bd9Sstevel@tonic-gate tmp1 = strchr(tmp, ' '); 6657c478bd9Sstevel@tonic-gate } 6667c478bd9Sstevel@tonic-gate 6677c478bd9Sstevel@tonic-gate pathvfs = kmem_zalloc(n_modpath * sizeof (struct pathvfs), KM_SLEEP); 6687c478bd9Sstevel@tonic-gate tmp = modpath_copy; 6697c478bd9Sstevel@tonic-gate for (i = 0; i < n_modpath; i++) { 6707c478bd9Sstevel@tonic-gate pathvfs[i].path = tmp; 6717c478bd9Sstevel@tonic-gate vfsp = path_to_vfs(tmp); 6727c478bd9Sstevel@tonic-gate pathvfs[i].vfsp = vfsp; 6737c478bd9Sstevel@tonic-gate tmp += strlen(tmp) + 1; 6747c478bd9Sstevel@tonic-gate } 6757c478bd9Sstevel@tonic-gate return (1); /* always reread driver.conf the first time */ 6767c478bd9Sstevel@tonic-gate } 6777c478bd9Sstevel@tonic-gate 678facf4a8dSllai static int 679facf4a8dSllai modctl_load_drvconf(major_t major) 6807c478bd9Sstevel@tonic-gate { 6817c478bd9Sstevel@tonic-gate int ret; 6827c478bd9Sstevel@tonic-gate 683a204de77Scth if (major != DDI_MAJOR_T_NONE) { 6847c478bd9Sstevel@tonic-gate ret = i_ddi_load_drvconf(major); 6857c478bd9Sstevel@tonic-gate if (ret == 0) 6867c478bd9Sstevel@tonic-gate i_ddi_bind_devs(); 6877c478bd9Sstevel@tonic-gate return (ret); 6887c478bd9Sstevel@tonic-gate } 6897c478bd9Sstevel@tonic-gate 6907c478bd9Sstevel@tonic-gate /* 6917c478bd9Sstevel@tonic-gate * We are invoked to rescan new driver.conf files. It is 6927c478bd9Sstevel@tonic-gate * only necessary if a new file system was mounted in the 6937c478bd9Sstevel@tonic-gate * module_path. Because rescanning driver.conf files can 6947c478bd9Sstevel@tonic-gate * take some time on older platforms (sun4m), the following 6957c478bd9Sstevel@tonic-gate * code skips unnecessary driver.conf rescans to optimize 6967c478bd9Sstevel@tonic-gate * boot performance. 6977c478bd9Sstevel@tonic-gate */ 6987c478bd9Sstevel@tonic-gate if (new_vfs_in_modpath()) { 699a204de77Scth (void) i_ddi_load_drvconf(DDI_MAJOR_T_NONE); 7007c478bd9Sstevel@tonic-gate /* 7017c478bd9Sstevel@tonic-gate * If we are still initializing io subsystem, 7027c478bd9Sstevel@tonic-gate * load drivers with ddi-forceattach property 7037c478bd9Sstevel@tonic-gate */ 7047c478bd9Sstevel@tonic-gate if (!i_ddi_io_initialized()) 7057c478bd9Sstevel@tonic-gate i_ddi_forceattach_drivers(); 7067c478bd9Sstevel@tonic-gate } 7077c478bd9Sstevel@tonic-gate return (0); 7087c478bd9Sstevel@tonic-gate } 7097c478bd9Sstevel@tonic-gate 7107c478bd9Sstevel@tonic-gate static int 7117c478bd9Sstevel@tonic-gate modctl_unload_drvconf(major_t major) 7127c478bd9Sstevel@tonic-gate { 7137c478bd9Sstevel@tonic-gate int ret; 7147c478bd9Sstevel@tonic-gate 7157c478bd9Sstevel@tonic-gate if (major >= devcnt) 7167c478bd9Sstevel@tonic-gate return (EINVAL); 7177c478bd9Sstevel@tonic-gate 7187c478bd9Sstevel@tonic-gate ret = i_ddi_unload_drvconf(major); 7197c478bd9Sstevel@tonic-gate if (ret != 0) 7207c478bd9Sstevel@tonic-gate return (ret); 7217c478bd9Sstevel@tonic-gate (void) i_ddi_unbind_devs(major); 7227c478bd9Sstevel@tonic-gate 7237c478bd9Sstevel@tonic-gate return (0); 7247c478bd9Sstevel@tonic-gate } 7257c478bd9Sstevel@tonic-gate 7267c478bd9Sstevel@tonic-gate static void 7277c478bd9Sstevel@tonic-gate check_esc_sequences(char *str, char *cstr) 7287c478bd9Sstevel@tonic-gate { 7297c478bd9Sstevel@tonic-gate int i; 7307c478bd9Sstevel@tonic-gate size_t len; 7317c478bd9Sstevel@tonic-gate char *p; 7327c478bd9Sstevel@tonic-gate 7337c478bd9Sstevel@tonic-gate len = strlen(str); 7347c478bd9Sstevel@tonic-gate for (i = 0; i < len; i++, str++, cstr++) { 7357c478bd9Sstevel@tonic-gate if (*str != '\\') { 7367c478bd9Sstevel@tonic-gate *cstr = *str; 7377c478bd9Sstevel@tonic-gate } else { 7387c478bd9Sstevel@tonic-gate p = str + 1; 7397c478bd9Sstevel@tonic-gate /* 7407c478bd9Sstevel@tonic-gate * we only handle octal escape sequences for SPACE 7417c478bd9Sstevel@tonic-gate */ 7427c478bd9Sstevel@tonic-gate if (*p++ == '0' && *p++ == '4' && *p == '0') { 7437c478bd9Sstevel@tonic-gate *cstr = ' '; 7447c478bd9Sstevel@tonic-gate str += 3; 7457c478bd9Sstevel@tonic-gate } else { 7467c478bd9Sstevel@tonic-gate *cstr = *str; 7477c478bd9Sstevel@tonic-gate } 7487c478bd9Sstevel@tonic-gate } 7497c478bd9Sstevel@tonic-gate } 7507c478bd9Sstevel@tonic-gate *cstr = 0; 7517c478bd9Sstevel@tonic-gate } 7527c478bd9Sstevel@tonic-gate 7537c478bd9Sstevel@tonic-gate static int 7547c478bd9Sstevel@tonic-gate modctl_getmodpathlen(int *data) 7557c478bd9Sstevel@tonic-gate { 7567c478bd9Sstevel@tonic-gate int len; 7577c478bd9Sstevel@tonic-gate len = strlen(default_path); 7587c478bd9Sstevel@tonic-gate if (copyout(&len, data, sizeof (len)) != 0) 7597c478bd9Sstevel@tonic-gate return (EFAULT); 7607c478bd9Sstevel@tonic-gate return (0); 7617c478bd9Sstevel@tonic-gate } 7627c478bd9Sstevel@tonic-gate 7637c478bd9Sstevel@tonic-gate static int 7647c478bd9Sstevel@tonic-gate modctl_getmodpath(char *data) 7657c478bd9Sstevel@tonic-gate { 7667c478bd9Sstevel@tonic-gate if (copyout(default_path, data, strlen(default_path) + 1) != 0) 7677c478bd9Sstevel@tonic-gate return (EFAULT); 7687c478bd9Sstevel@tonic-gate return (0); 7697c478bd9Sstevel@tonic-gate } 7707c478bd9Sstevel@tonic-gate 7717c478bd9Sstevel@tonic-gate static int 7727c478bd9Sstevel@tonic-gate modctl_read_sysbinding_file(void) 7737c478bd9Sstevel@tonic-gate { 7747c478bd9Sstevel@tonic-gate (void) read_binding_file(sysbind, sb_hashtab, make_mbind); 7757c478bd9Sstevel@tonic-gate return (0); 7767c478bd9Sstevel@tonic-gate } 7777c478bd9Sstevel@tonic-gate 7787c478bd9Sstevel@tonic-gate static int 7797c478bd9Sstevel@tonic-gate modctl_getmaj(char *uname, uint_t ulen, int *umajorp) 7807c478bd9Sstevel@tonic-gate { 7817c478bd9Sstevel@tonic-gate char name[256]; 7827c478bd9Sstevel@tonic-gate int retval; 7837c478bd9Sstevel@tonic-gate major_t major; 7847c478bd9Sstevel@tonic-gate 785facf4a8dSllai if (ulen == 0) 786facf4a8dSllai return (EINVAL); 7877c478bd9Sstevel@tonic-gate if ((retval = copyinstr(uname, name, 7887c478bd9Sstevel@tonic-gate (ulen < 256) ? ulen : 256, 0)) != 0) 7897c478bd9Sstevel@tonic-gate return (retval); 790a204de77Scth if ((major = mod_name_to_major(name)) == DDI_MAJOR_T_NONE) 7917c478bd9Sstevel@tonic-gate return (ENODEV); 7927c478bd9Sstevel@tonic-gate if (copyout(&major, umajorp, sizeof (major_t)) != 0) 7937c478bd9Sstevel@tonic-gate return (EFAULT); 7947c478bd9Sstevel@tonic-gate return (0); 7957c478bd9Sstevel@tonic-gate } 7967c478bd9Sstevel@tonic-gate 79725e8c5aaSvikram static char ** 79825e8c5aaSvikram convert_constraint_string(char *constraints, size_t len) 79925e8c5aaSvikram { 80025e8c5aaSvikram int i; 80125e8c5aaSvikram int n; 80225e8c5aaSvikram char *p; 80325e8c5aaSvikram char **array; 80425e8c5aaSvikram 80525e8c5aaSvikram ASSERT(constraints != NULL); 80625e8c5aaSvikram ASSERT(len > 0); 80725e8c5aaSvikram 8081e1ddd6cScth for (i = 0, p = constraints; strlen(p) > 0; i++, p += strlen(p) + 1) 8091e1ddd6cScth ; 81025e8c5aaSvikram 81125e8c5aaSvikram n = i; 81225e8c5aaSvikram 81325e8c5aaSvikram if (n == 0) { 81425e8c5aaSvikram kmem_free(constraints, len); 81525e8c5aaSvikram return (NULL); 81625e8c5aaSvikram } 81725e8c5aaSvikram 81825e8c5aaSvikram array = kmem_alloc((n + 1) * sizeof (char *), KM_SLEEP); 81925e8c5aaSvikram 82025e8c5aaSvikram for (i = 0, p = constraints; i < n; i++, p += strlen(p) + 1) { 82125e8c5aaSvikram array[i] = i_ddi_strdup(p, KM_SLEEP); 82225e8c5aaSvikram } 82325e8c5aaSvikram array[n] = NULL; 82425e8c5aaSvikram 82525e8c5aaSvikram kmem_free(constraints, len); 82625e8c5aaSvikram 82725e8c5aaSvikram return (array); 82825e8c5aaSvikram } 82925e8c5aaSvikram /*ARGSUSED*/ 83025e8c5aaSvikram static int 83125e8c5aaSvikram modctl_retire(char *path, char *uconstraints, size_t ulen) 83225e8c5aaSvikram { 83325e8c5aaSvikram char *pathbuf; 83425e8c5aaSvikram char *devpath; 83525e8c5aaSvikram size_t pathsz; 83625e8c5aaSvikram int retval; 83725e8c5aaSvikram char *constraints; 83825e8c5aaSvikram char **cons_array; 83925e8c5aaSvikram 84025e8c5aaSvikram if (path == NULL) 84125e8c5aaSvikram return (EINVAL); 84225e8c5aaSvikram 84325e8c5aaSvikram if ((uconstraints == NULL) ^ (ulen == 0)) 84425e8c5aaSvikram return (EINVAL); 84525e8c5aaSvikram 84625e8c5aaSvikram pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP); 84725e8c5aaSvikram retval = copyinstr(path, pathbuf, MAXPATHLEN, &pathsz); 84825e8c5aaSvikram if (retval != 0) { 84925e8c5aaSvikram kmem_free(pathbuf, MAXPATHLEN); 85025e8c5aaSvikram return (retval); 85125e8c5aaSvikram } 85225e8c5aaSvikram devpath = i_ddi_strdup(pathbuf, KM_SLEEP); 85325e8c5aaSvikram kmem_free(pathbuf, MAXPATHLEN); 85425e8c5aaSvikram 85525e8c5aaSvikram /* 85625e8c5aaSvikram * First check if the device is already retired. 85725e8c5aaSvikram * If it is, this becomes a NOP 85825e8c5aaSvikram */ 85925e8c5aaSvikram if (e_ddi_device_retired(devpath)) { 86025e8c5aaSvikram cmn_err(CE_NOTE, "Device: already retired: %s", devpath); 86125e8c5aaSvikram kmem_free(devpath, strlen(devpath) + 1); 86225e8c5aaSvikram return (0); 86325e8c5aaSvikram } 86425e8c5aaSvikram 86525e8c5aaSvikram cons_array = NULL; 86625e8c5aaSvikram if (uconstraints) { 86725e8c5aaSvikram constraints = kmem_alloc(ulen, KM_SLEEP); 86825e8c5aaSvikram if (copyin(uconstraints, constraints, ulen)) { 86925e8c5aaSvikram kmem_free(constraints, ulen); 87025e8c5aaSvikram kmem_free(devpath, strlen(devpath) + 1); 87125e8c5aaSvikram return (EFAULT); 87225e8c5aaSvikram } 87325e8c5aaSvikram cons_array = convert_constraint_string(constraints, ulen); 87425e8c5aaSvikram } 87525e8c5aaSvikram 87625e8c5aaSvikram /* 87725e8c5aaSvikram * Try to retire the device first. The following 87825e8c5aaSvikram * routine will return an error only if the device 87925e8c5aaSvikram * is not retireable i.e. retire constraints forbid 88025e8c5aaSvikram * a retire. A return of success from this routine 88125e8c5aaSvikram * indicates that device is retireable. 88225e8c5aaSvikram */ 88325e8c5aaSvikram retval = e_ddi_retire_device(devpath, cons_array); 88425e8c5aaSvikram if (retval != DDI_SUCCESS) { 88525e8c5aaSvikram cmn_err(CE_WARN, "constraints forbid retire: %s", devpath); 88625e8c5aaSvikram kmem_free(devpath, strlen(devpath) + 1); 88725e8c5aaSvikram return (ENOTSUP); 88825e8c5aaSvikram } 88925e8c5aaSvikram 89025e8c5aaSvikram /* 89125e8c5aaSvikram * Ok, the retire succeeded. Persist the retire. 89225e8c5aaSvikram * If retiring a nexus, we need to only persist the 89325e8c5aaSvikram * nexus retire. Any children of a retired nexus 89425e8c5aaSvikram * are automatically covered by the retire store 89525e8c5aaSvikram * code. 89625e8c5aaSvikram */ 89725e8c5aaSvikram retval = e_ddi_retire_persist(devpath); 89825e8c5aaSvikram if (retval != 0) { 89925e8c5aaSvikram cmn_err(CE_WARN, "Failed to persist device retire: error %d: " 90025e8c5aaSvikram "%s", retval, devpath); 90125e8c5aaSvikram kmem_free(devpath, strlen(devpath) + 1); 90225e8c5aaSvikram return (retval); 90325e8c5aaSvikram } 90425e8c5aaSvikram if (moddebug & MODDEBUG_RETIRE) 90525e8c5aaSvikram cmn_err(CE_NOTE, "Persisted retire of device: %s", devpath); 90625e8c5aaSvikram 90725e8c5aaSvikram kmem_free(devpath, strlen(devpath) + 1); 90825e8c5aaSvikram return (0); 90925e8c5aaSvikram } 91025e8c5aaSvikram 91125e8c5aaSvikram static int 91225e8c5aaSvikram modctl_is_retired(char *path, int *statep) 91325e8c5aaSvikram { 91425e8c5aaSvikram char *pathbuf; 91525e8c5aaSvikram char *devpath; 91625e8c5aaSvikram size_t pathsz; 91725e8c5aaSvikram int error; 91825e8c5aaSvikram int status; 91925e8c5aaSvikram 92025e8c5aaSvikram if (path == NULL || statep == NULL) 92125e8c5aaSvikram return (EINVAL); 92225e8c5aaSvikram 92325e8c5aaSvikram pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP); 92425e8c5aaSvikram error = copyinstr(path, pathbuf, MAXPATHLEN, &pathsz); 92525e8c5aaSvikram if (error != 0) { 92625e8c5aaSvikram kmem_free(pathbuf, MAXPATHLEN); 92725e8c5aaSvikram return (error); 92825e8c5aaSvikram } 92925e8c5aaSvikram devpath = i_ddi_strdup(pathbuf, KM_SLEEP); 93025e8c5aaSvikram kmem_free(pathbuf, MAXPATHLEN); 93125e8c5aaSvikram 93225e8c5aaSvikram if (e_ddi_device_retired(devpath)) 93325e8c5aaSvikram status = 1; 93425e8c5aaSvikram else 93525e8c5aaSvikram status = 0; 93625e8c5aaSvikram kmem_free(devpath, strlen(devpath) + 1); 93725e8c5aaSvikram 93825e8c5aaSvikram return (copyout(&status, statep, sizeof (status)) ? EFAULT : 0); 93925e8c5aaSvikram } 94025e8c5aaSvikram 94125e8c5aaSvikram static int 94225e8c5aaSvikram modctl_unretire(char *path) 94325e8c5aaSvikram { 94425e8c5aaSvikram char *pathbuf; 94525e8c5aaSvikram char *devpath; 94625e8c5aaSvikram size_t pathsz; 94725e8c5aaSvikram int retired; 94825e8c5aaSvikram int retval; 94925e8c5aaSvikram 95025e8c5aaSvikram if (path == NULL) 95125e8c5aaSvikram return (EINVAL); 95225e8c5aaSvikram 95325e8c5aaSvikram pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP); 95425e8c5aaSvikram retval = copyinstr(path, pathbuf, MAXPATHLEN, &pathsz); 95525e8c5aaSvikram if (retval != 0) { 95625e8c5aaSvikram kmem_free(pathbuf, MAXPATHLEN); 95725e8c5aaSvikram return (retval); 95825e8c5aaSvikram } 95925e8c5aaSvikram devpath = i_ddi_strdup(pathbuf, KM_SLEEP); 96025e8c5aaSvikram kmem_free(pathbuf, MAXPATHLEN); 96125e8c5aaSvikram 96225e8c5aaSvikram /* 96325e8c5aaSvikram * We check if a device is retired (first) before 96425e8c5aaSvikram * unpersisting the retire, because we use the 96525e8c5aaSvikram * retire store to determine if a device is retired. 96625e8c5aaSvikram * If we unpersist first, the device will always appear 96725e8c5aaSvikram * to be unretired. For the rationale behind unpersisting 96825e8c5aaSvikram * a device that is not retired, see the next comment. 96925e8c5aaSvikram */ 97025e8c5aaSvikram retired = e_ddi_device_retired(devpath); 97125e8c5aaSvikram 97225e8c5aaSvikram /* 97325e8c5aaSvikram * We call unpersist unconditionally because the lookup 97425e8c5aaSvikram * for retired devices (e_ddi_device_retired()), skips "bypassed" 97525e8c5aaSvikram * devices. We still want to be able remove "bypassed" entries 97625e8c5aaSvikram * from the persistent store, so we unpersist unconditionally 97725e8c5aaSvikram * i.e. whether or not the entry is found on a lookup. 97825e8c5aaSvikram * 97925e8c5aaSvikram * e_ddi_retire_unpersist() returns 1 if it found and cleared 98025e8c5aaSvikram * an entry from the retire store or 0 otherwise. 98125e8c5aaSvikram */ 98225e8c5aaSvikram if (e_ddi_retire_unpersist(devpath)) 98325e8c5aaSvikram if (moddebug & MODDEBUG_RETIRE) { 98425e8c5aaSvikram cmn_err(CE_NOTE, "Unpersisted retire of device: %s", 98525e8c5aaSvikram devpath); 98625e8c5aaSvikram } 98725e8c5aaSvikram 98825e8c5aaSvikram /* 98925e8c5aaSvikram * Check if the device is already unretired. If so, 99025e8c5aaSvikram * the unretire becomes a NOP 99125e8c5aaSvikram */ 99225e8c5aaSvikram if (!retired) { 99325e8c5aaSvikram cmn_err(CE_NOTE, "Not retired: %s", devpath); 99425e8c5aaSvikram kmem_free(devpath, strlen(devpath) + 1); 99525e8c5aaSvikram return (0); 99625e8c5aaSvikram } 99725e8c5aaSvikram 99825e8c5aaSvikram retval = e_ddi_unretire_device(devpath); 99925e8c5aaSvikram if (retval != 0) { 100025e8c5aaSvikram cmn_err(CE_WARN, "cannot unretire device: error %d, path %s\n", 100125e8c5aaSvikram retval, devpath); 100225e8c5aaSvikram } 100325e8c5aaSvikram 100425e8c5aaSvikram kmem_free(devpath, strlen(devpath) + 1); 100525e8c5aaSvikram 100625e8c5aaSvikram return (retval); 100725e8c5aaSvikram } 100825e8c5aaSvikram 10097c478bd9Sstevel@tonic-gate static int 10107c478bd9Sstevel@tonic-gate modctl_getname(char *uname, uint_t ulen, int *umajorp) 10117c478bd9Sstevel@tonic-gate { 10127c478bd9Sstevel@tonic-gate char *name; 10137c478bd9Sstevel@tonic-gate major_t major; 10147c478bd9Sstevel@tonic-gate 10157c478bd9Sstevel@tonic-gate if (copyin(umajorp, &major, sizeof (major)) != 0) 10167c478bd9Sstevel@tonic-gate return (EFAULT); 10177c478bd9Sstevel@tonic-gate if ((name = mod_major_to_name(major)) == NULL) 10187c478bd9Sstevel@tonic-gate return (ENODEV); 10197c478bd9Sstevel@tonic-gate if ((strlen(name) + 1) > ulen) 10207c478bd9Sstevel@tonic-gate return (ENOSPC); 10217c478bd9Sstevel@tonic-gate return (copyoutstr(name, uname, ulen, NULL)); 10227c478bd9Sstevel@tonic-gate } 10237c478bd9Sstevel@tonic-gate 10247c478bd9Sstevel@tonic-gate static int 10257c478bd9Sstevel@tonic-gate modctl_devt2instance(dev_t dev, int *uinstancep) 10267c478bd9Sstevel@tonic-gate { 10277c478bd9Sstevel@tonic-gate int instance; 10287c478bd9Sstevel@tonic-gate 10297c478bd9Sstevel@tonic-gate if ((instance = dev_to_instance(dev)) == -1) 10307c478bd9Sstevel@tonic-gate return (EINVAL); 10317c478bd9Sstevel@tonic-gate 10327c478bd9Sstevel@tonic-gate return (copyout(&instance, uinstancep, sizeof (int))); 10337c478bd9Sstevel@tonic-gate } 10347c478bd9Sstevel@tonic-gate 10357c478bd9Sstevel@tonic-gate /* 10367c478bd9Sstevel@tonic-gate * Return the sizeof of the device id. 10377c478bd9Sstevel@tonic-gate */ 10387c478bd9Sstevel@tonic-gate static int 10397c478bd9Sstevel@tonic-gate modctl_sizeof_devid(dev_t dev, uint_t *len) 10407c478bd9Sstevel@tonic-gate { 10417c478bd9Sstevel@tonic-gate uint_t sz; 10427c478bd9Sstevel@tonic-gate ddi_devid_t devid; 10437c478bd9Sstevel@tonic-gate 10447c478bd9Sstevel@tonic-gate /* get device id */ 10457c478bd9Sstevel@tonic-gate if (ddi_lyr_get_devid(dev, &devid) == DDI_FAILURE) 10467c478bd9Sstevel@tonic-gate return (EINVAL); 10477c478bd9Sstevel@tonic-gate 10487c478bd9Sstevel@tonic-gate sz = ddi_devid_sizeof(devid); 10497c478bd9Sstevel@tonic-gate ddi_devid_free(devid); 10507c478bd9Sstevel@tonic-gate 10517c478bd9Sstevel@tonic-gate /* copyout device id size */ 10527c478bd9Sstevel@tonic-gate if (copyout(&sz, len, sizeof (sz)) != 0) 10537c478bd9Sstevel@tonic-gate return (EFAULT); 10547c478bd9Sstevel@tonic-gate 10557c478bd9Sstevel@tonic-gate return (0); 10567c478bd9Sstevel@tonic-gate } 10577c478bd9Sstevel@tonic-gate 10587c478bd9Sstevel@tonic-gate /* 10597c478bd9Sstevel@tonic-gate * Return a copy of the device id. 10607c478bd9Sstevel@tonic-gate */ 10617c478bd9Sstevel@tonic-gate static int 10627c478bd9Sstevel@tonic-gate modctl_get_devid(dev_t dev, uint_t len, ddi_devid_t udevid) 10637c478bd9Sstevel@tonic-gate { 10647c478bd9Sstevel@tonic-gate uint_t sz; 10657c478bd9Sstevel@tonic-gate ddi_devid_t devid; 10667c478bd9Sstevel@tonic-gate int err = 0; 10677c478bd9Sstevel@tonic-gate 10687c478bd9Sstevel@tonic-gate /* get device id */ 10697c478bd9Sstevel@tonic-gate if (ddi_lyr_get_devid(dev, &devid) == DDI_FAILURE) 10707c478bd9Sstevel@tonic-gate return (EINVAL); 10717c478bd9Sstevel@tonic-gate 10727c478bd9Sstevel@tonic-gate sz = ddi_devid_sizeof(devid); 10737c478bd9Sstevel@tonic-gate 10747c478bd9Sstevel@tonic-gate /* Error if device id is larger than space allocated */ 10757c478bd9Sstevel@tonic-gate if (sz > len) { 10767c478bd9Sstevel@tonic-gate ddi_devid_free(devid); 10777c478bd9Sstevel@tonic-gate return (ENOSPC); 10787c478bd9Sstevel@tonic-gate } 10797c478bd9Sstevel@tonic-gate 10807c478bd9Sstevel@tonic-gate /* copy out device id */ 10817c478bd9Sstevel@tonic-gate if (copyout(devid, udevid, sz) != 0) 10827c478bd9Sstevel@tonic-gate err = EFAULT; 10837c478bd9Sstevel@tonic-gate ddi_devid_free(devid); 10847c478bd9Sstevel@tonic-gate return (err); 10857c478bd9Sstevel@tonic-gate } 10867c478bd9Sstevel@tonic-gate 10877c478bd9Sstevel@tonic-gate /* 10887c478bd9Sstevel@tonic-gate * return the /devices paths associated with the specified devid and 10897c478bd9Sstevel@tonic-gate * minor name. 10907c478bd9Sstevel@tonic-gate */ 10917c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 10927c478bd9Sstevel@tonic-gate static int 10937c478bd9Sstevel@tonic-gate modctl_devid2paths(ddi_devid_t udevid, char *uminor_name, uint_t flag, 10947c478bd9Sstevel@tonic-gate size_t *ulensp, char *upaths) 10957c478bd9Sstevel@tonic-gate { 10967c478bd9Sstevel@tonic-gate ddi_devid_t devid = NULL; 10977c478bd9Sstevel@tonic-gate int devid_len; 10987c478bd9Sstevel@tonic-gate char *minor_name = NULL; 10997c478bd9Sstevel@tonic-gate dev_info_t *dip = NULL; 1100b9ccdc5aScth int circ; 11017c478bd9Sstevel@tonic-gate struct ddi_minor_data *dmdp; 11027c478bd9Sstevel@tonic-gate char *path = NULL; 11037c478bd9Sstevel@tonic-gate int ulens; 11047c478bd9Sstevel@tonic-gate int lens; 11057c478bd9Sstevel@tonic-gate int len; 11067c478bd9Sstevel@tonic-gate dev_t *devlist = NULL; 11077c478bd9Sstevel@tonic-gate int ndevs; 11087c478bd9Sstevel@tonic-gate int i; 11097c478bd9Sstevel@tonic-gate int ret = 0; 11107c478bd9Sstevel@tonic-gate 11117c478bd9Sstevel@tonic-gate /* 11127c478bd9Sstevel@tonic-gate * If upaths is NULL then we are only computing the amount of space 11137c478bd9Sstevel@tonic-gate * needed to hold the paths and returning the value in *ulensp. If we 11147c478bd9Sstevel@tonic-gate * are copying out paths then we get the amount of space allocated by 11157c478bd9Sstevel@tonic-gate * the caller. If the actual space needed for paths is larger, or 11167c478bd9Sstevel@tonic-gate * things are changing out from under us, then we return EAGAIN. 11177c478bd9Sstevel@tonic-gate */ 11187c478bd9Sstevel@tonic-gate if (upaths) { 11197c478bd9Sstevel@tonic-gate if (ulensp == NULL) 11207c478bd9Sstevel@tonic-gate return (EINVAL); 11217c478bd9Sstevel@tonic-gate if (copyin(ulensp, &ulens, sizeof (ulens)) != 0) 11227c478bd9Sstevel@tonic-gate return (EFAULT); 11237c478bd9Sstevel@tonic-gate } 11247c478bd9Sstevel@tonic-gate 11257c478bd9Sstevel@tonic-gate /* 11267c478bd9Sstevel@tonic-gate * copyin enough of the devid to determine the length then 11277c478bd9Sstevel@tonic-gate * reallocate and copy in the entire devid. 11287c478bd9Sstevel@tonic-gate */ 11297c478bd9Sstevel@tonic-gate devid_len = ddi_devid_sizeof(NULL); 11307c478bd9Sstevel@tonic-gate devid = kmem_alloc(devid_len, KM_SLEEP); 11317c478bd9Sstevel@tonic-gate if (copyin(udevid, devid, devid_len)) { 11327c478bd9Sstevel@tonic-gate ret = EFAULT; 11337c478bd9Sstevel@tonic-gate goto out; 11347c478bd9Sstevel@tonic-gate } 11357c478bd9Sstevel@tonic-gate len = devid_len; 11367c478bd9Sstevel@tonic-gate devid_len = ddi_devid_sizeof(devid); 11377c478bd9Sstevel@tonic-gate kmem_free(devid, len); 11387c478bd9Sstevel@tonic-gate devid = kmem_alloc(devid_len, KM_SLEEP); 11397c478bd9Sstevel@tonic-gate if (copyin(udevid, devid, devid_len)) { 11407c478bd9Sstevel@tonic-gate ret = EFAULT; 11417c478bd9Sstevel@tonic-gate goto out; 11427c478bd9Sstevel@tonic-gate } 11437c478bd9Sstevel@tonic-gate 11447c478bd9Sstevel@tonic-gate /* copyin the minor name if specified. */ 11457c478bd9Sstevel@tonic-gate minor_name = uminor_name; 11467c478bd9Sstevel@tonic-gate if ((minor_name != DEVID_MINOR_NAME_ALL) && 11477c478bd9Sstevel@tonic-gate (minor_name != DEVID_MINOR_NAME_ALL_CHR) && 11487c478bd9Sstevel@tonic-gate (minor_name != DEVID_MINOR_NAME_ALL_BLK)) { 11497c478bd9Sstevel@tonic-gate minor_name = kmem_alloc(MAXPATHLEN, KM_SLEEP); 11507c478bd9Sstevel@tonic-gate if (copyinstr(uminor_name, minor_name, MAXPATHLEN, 0)) { 11517c478bd9Sstevel@tonic-gate ret = EFAULT; 11527c478bd9Sstevel@tonic-gate goto out; 11537c478bd9Sstevel@tonic-gate } 11547c478bd9Sstevel@tonic-gate } 11557c478bd9Sstevel@tonic-gate 11567c478bd9Sstevel@tonic-gate /* 11577c478bd9Sstevel@tonic-gate * Use existing function to resolve the devid into a devlist. 11587c478bd9Sstevel@tonic-gate * 11597c478bd9Sstevel@tonic-gate * NOTE: there is a loss of spectype information in the current 11607c478bd9Sstevel@tonic-gate * ddi_lyr_devid_to_devlist implementation. We work around this by not 11617c478bd9Sstevel@tonic-gate * passing down DEVID_MINOR_NAME_ALL here, but reproducing all minor 11627c478bd9Sstevel@tonic-gate * node forms in the loop processing the devlist below. It would be 11637c478bd9Sstevel@tonic-gate * best if at some point the use of this interface here was replaced 11647c478bd9Sstevel@tonic-gate * with a path oriented call. 11657c478bd9Sstevel@tonic-gate */ 11667c478bd9Sstevel@tonic-gate if (ddi_lyr_devid_to_devlist(devid, 11677c478bd9Sstevel@tonic-gate (minor_name == DEVID_MINOR_NAME_ALL) ? 11687c478bd9Sstevel@tonic-gate DEVID_MINOR_NAME_ALL_CHR : minor_name, 11697c478bd9Sstevel@tonic-gate &ndevs, &devlist) != DDI_SUCCESS) { 11707c478bd9Sstevel@tonic-gate ret = EINVAL; 11717c478bd9Sstevel@tonic-gate goto out; 11727c478bd9Sstevel@tonic-gate } 11737c478bd9Sstevel@tonic-gate 11747c478bd9Sstevel@tonic-gate /* 11757c478bd9Sstevel@tonic-gate * loop over the devlist, converting each devt to a path and doing 11767c478bd9Sstevel@tonic-gate * a copyout of the path and computation of the amount of space 11777c478bd9Sstevel@tonic-gate * needed to hold all the paths 11787c478bd9Sstevel@tonic-gate */ 11797c478bd9Sstevel@tonic-gate path = kmem_alloc(MAXPATHLEN, KM_SLEEP); 11807c478bd9Sstevel@tonic-gate for (i = 0, lens = 0; i < ndevs; i++) { 11817c478bd9Sstevel@tonic-gate 11827c478bd9Sstevel@tonic-gate /* find the dip associated with the dev_t */ 11837c478bd9Sstevel@tonic-gate if ((dip = e_ddi_hold_devi_by_dev(devlist[i], 0)) == NULL) 11847c478bd9Sstevel@tonic-gate continue; 11857c478bd9Sstevel@tonic-gate 11867c478bd9Sstevel@tonic-gate /* loop over all the minor nodes, skipping ones we don't want */ 1187b9ccdc5aScth ndi_devi_enter(dip, &circ); 11887c478bd9Sstevel@tonic-gate for (dmdp = DEVI(dip)->devi_minor; dmdp; dmdp = dmdp->next) { 11897c478bd9Sstevel@tonic-gate if ((dmdp->ddm_dev != devlist[i]) || 11907c478bd9Sstevel@tonic-gate (dmdp->type != DDM_MINOR)) 11917c478bd9Sstevel@tonic-gate continue; 11927c478bd9Sstevel@tonic-gate 11937c478bd9Sstevel@tonic-gate if ((minor_name != DEVID_MINOR_NAME_ALL) && 11947c478bd9Sstevel@tonic-gate (minor_name != DEVID_MINOR_NAME_ALL_CHR) && 11957c478bd9Sstevel@tonic-gate (minor_name != DEVID_MINOR_NAME_ALL_BLK) && 11967c478bd9Sstevel@tonic-gate strcmp(minor_name, dmdp->ddm_name)) 11977c478bd9Sstevel@tonic-gate continue; 11987c478bd9Sstevel@tonic-gate else { 11997c478bd9Sstevel@tonic-gate if ((minor_name == DEVID_MINOR_NAME_ALL_CHR) && 12007c478bd9Sstevel@tonic-gate (dmdp->ddm_spec_type != S_IFCHR)) 12017c478bd9Sstevel@tonic-gate continue; 12027c478bd9Sstevel@tonic-gate if ((minor_name == DEVID_MINOR_NAME_ALL_BLK) && 12037c478bd9Sstevel@tonic-gate (dmdp->ddm_spec_type != S_IFBLK)) 12047c478bd9Sstevel@tonic-gate continue; 12057c478bd9Sstevel@tonic-gate } 12067c478bd9Sstevel@tonic-gate 1207*f9722deaSChris Horne (void) ddi_pathname_minor(dmdp, path); 12087c478bd9Sstevel@tonic-gate len = strlen(path) + 1; 12097c478bd9Sstevel@tonic-gate *(path + len) = '\0'; /* set double termination */ 12107c478bd9Sstevel@tonic-gate lens += len; 12117c478bd9Sstevel@tonic-gate 12127c478bd9Sstevel@tonic-gate /* copyout the path with double terminations */ 12137c478bd9Sstevel@tonic-gate if (upaths) { 12147c478bd9Sstevel@tonic-gate if (lens > ulens) { 12157c478bd9Sstevel@tonic-gate ret = EAGAIN; 12167c478bd9Sstevel@tonic-gate goto out; 12177c478bd9Sstevel@tonic-gate } 12187c478bd9Sstevel@tonic-gate if (copyout(path, upaths, len + 1)) { 12197c478bd9Sstevel@tonic-gate ret = EFAULT; 12207c478bd9Sstevel@tonic-gate goto out; 12217c478bd9Sstevel@tonic-gate } 12227c478bd9Sstevel@tonic-gate upaths += len; 12237c478bd9Sstevel@tonic-gate } 12247c478bd9Sstevel@tonic-gate } 1225b9ccdc5aScth ndi_devi_exit(dip, circ); 12267c478bd9Sstevel@tonic-gate ddi_release_devi(dip); 12277c478bd9Sstevel@tonic-gate dip = NULL; 12287c478bd9Sstevel@tonic-gate } 12297c478bd9Sstevel@tonic-gate lens++; /* add one for double termination */ 12307c478bd9Sstevel@tonic-gate 12317c478bd9Sstevel@tonic-gate /* copy out the amount of space needed to hold the paths */ 12327c478bd9Sstevel@tonic-gate if (ulensp && copyout(&lens, ulensp, sizeof (lens))) { 12337c478bd9Sstevel@tonic-gate ret = EFAULT; 12347c478bd9Sstevel@tonic-gate goto out; 12357c478bd9Sstevel@tonic-gate } 12367c478bd9Sstevel@tonic-gate ret = 0; 12377c478bd9Sstevel@tonic-gate 1238b9ccdc5aScth out: if (dip) { 1239b9ccdc5aScth ndi_devi_exit(dip, circ); 12407c478bd9Sstevel@tonic-gate ddi_release_devi(dip); 1241b9ccdc5aScth } 12427c478bd9Sstevel@tonic-gate if (path) 12437c478bd9Sstevel@tonic-gate kmem_free(path, MAXPATHLEN); 12447c478bd9Sstevel@tonic-gate if (devlist) 12457c478bd9Sstevel@tonic-gate ddi_lyr_free_devlist(devlist, ndevs); 12467c478bd9Sstevel@tonic-gate if (minor_name && 12477c478bd9Sstevel@tonic-gate (minor_name != DEVID_MINOR_NAME_ALL) && 12487c478bd9Sstevel@tonic-gate (minor_name != DEVID_MINOR_NAME_ALL_CHR) && 12497c478bd9Sstevel@tonic-gate (minor_name != DEVID_MINOR_NAME_ALL_BLK)) 12507c478bd9Sstevel@tonic-gate kmem_free(minor_name, MAXPATHLEN); 12517c478bd9Sstevel@tonic-gate if (devid) 12527c478bd9Sstevel@tonic-gate kmem_free(devid, devid_len); 12537c478bd9Sstevel@tonic-gate return (ret); 12547c478bd9Sstevel@tonic-gate } 12557c478bd9Sstevel@tonic-gate 12567c478bd9Sstevel@tonic-gate /* 12577c478bd9Sstevel@tonic-gate * Return the size of the minor name. 12587c478bd9Sstevel@tonic-gate */ 12597c478bd9Sstevel@tonic-gate static int 12607c478bd9Sstevel@tonic-gate modctl_sizeof_minorname(dev_t dev, int spectype, uint_t *len) 12617c478bd9Sstevel@tonic-gate { 12627c478bd9Sstevel@tonic-gate uint_t sz; 12637c478bd9Sstevel@tonic-gate char *name; 12647c478bd9Sstevel@tonic-gate 12657c478bd9Sstevel@tonic-gate /* get the minor name */ 12667c478bd9Sstevel@tonic-gate if (ddi_lyr_get_minor_name(dev, spectype, &name) == DDI_FAILURE) 12677c478bd9Sstevel@tonic-gate return (EINVAL); 12687c478bd9Sstevel@tonic-gate 12697c478bd9Sstevel@tonic-gate sz = strlen(name) + 1; 12707c478bd9Sstevel@tonic-gate kmem_free(name, sz); 12717c478bd9Sstevel@tonic-gate 12727c478bd9Sstevel@tonic-gate /* copy out the size of the minor name */ 12737c478bd9Sstevel@tonic-gate if (copyout(&sz, len, sizeof (sz)) != 0) 12747c478bd9Sstevel@tonic-gate return (EFAULT); 12757c478bd9Sstevel@tonic-gate 12767c478bd9Sstevel@tonic-gate return (0); 12777c478bd9Sstevel@tonic-gate } 12787c478bd9Sstevel@tonic-gate 12797c478bd9Sstevel@tonic-gate /* 12807c478bd9Sstevel@tonic-gate * Return the minor name. 12817c478bd9Sstevel@tonic-gate */ 12827c478bd9Sstevel@tonic-gate static int 12837c478bd9Sstevel@tonic-gate modctl_get_minorname(dev_t dev, int spectype, uint_t len, char *uname) 12847c478bd9Sstevel@tonic-gate { 12857c478bd9Sstevel@tonic-gate uint_t sz; 12867c478bd9Sstevel@tonic-gate char *name; 12877c478bd9Sstevel@tonic-gate int err = 0; 12887c478bd9Sstevel@tonic-gate 12897c478bd9Sstevel@tonic-gate /* get the minor name */ 12907c478bd9Sstevel@tonic-gate if (ddi_lyr_get_minor_name(dev, spectype, &name) == DDI_FAILURE) 12917c478bd9Sstevel@tonic-gate return (EINVAL); 12927c478bd9Sstevel@tonic-gate 12937c478bd9Sstevel@tonic-gate sz = strlen(name) + 1; 12947c478bd9Sstevel@tonic-gate 12957c478bd9Sstevel@tonic-gate /* Error if the minor name is larger than the space allocated */ 12967c478bd9Sstevel@tonic-gate if (sz > len) { 12977c478bd9Sstevel@tonic-gate kmem_free(name, sz); 12987c478bd9Sstevel@tonic-gate return (ENOSPC); 12997c478bd9Sstevel@tonic-gate } 13007c478bd9Sstevel@tonic-gate 13017c478bd9Sstevel@tonic-gate /* copy out the minor name */ 13027c478bd9Sstevel@tonic-gate if (copyout(name, uname, sz) != 0) 13037c478bd9Sstevel@tonic-gate err = EFAULT; 13047c478bd9Sstevel@tonic-gate kmem_free(name, sz); 13057c478bd9Sstevel@tonic-gate return (err); 13067c478bd9Sstevel@tonic-gate } 13077c478bd9Sstevel@tonic-gate 13087c478bd9Sstevel@tonic-gate /* 1309a08731ecScth * Return the size of the (dev_t,spectype) devfspath name. 13107c478bd9Sstevel@tonic-gate */ 13117c478bd9Sstevel@tonic-gate static int 13127c478bd9Sstevel@tonic-gate modctl_devfspath_len(dev_t dev, int spectype, uint_t *len) 13137c478bd9Sstevel@tonic-gate { 13147c478bd9Sstevel@tonic-gate uint_t sz; 13157c478bd9Sstevel@tonic-gate char *name; 13167c478bd9Sstevel@tonic-gate 13177c478bd9Sstevel@tonic-gate /* get the path name */ 13187c478bd9Sstevel@tonic-gate name = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 13197c478bd9Sstevel@tonic-gate if (ddi_dev_pathname(dev, spectype, name) == DDI_FAILURE) { 13207c478bd9Sstevel@tonic-gate kmem_free(name, MAXPATHLEN); 13217c478bd9Sstevel@tonic-gate return (EINVAL); 13227c478bd9Sstevel@tonic-gate } 13237c478bd9Sstevel@tonic-gate 13247c478bd9Sstevel@tonic-gate sz = strlen(name) + 1; 13257c478bd9Sstevel@tonic-gate kmem_free(name, MAXPATHLEN); 13267c478bd9Sstevel@tonic-gate 13277c478bd9Sstevel@tonic-gate /* copy out the size of the path name */ 13287c478bd9Sstevel@tonic-gate if (copyout(&sz, len, sizeof (sz)) != 0) 13297c478bd9Sstevel@tonic-gate return (EFAULT); 13307c478bd9Sstevel@tonic-gate 13317c478bd9Sstevel@tonic-gate return (0); 13327c478bd9Sstevel@tonic-gate } 13337c478bd9Sstevel@tonic-gate 13347c478bd9Sstevel@tonic-gate /* 1335a08731ecScth * Return the (dev_t,spectype) devfspath name. 13367c478bd9Sstevel@tonic-gate */ 13377c478bd9Sstevel@tonic-gate static int 13387c478bd9Sstevel@tonic-gate modctl_devfspath(dev_t dev, int spectype, uint_t len, char *uname) 13397c478bd9Sstevel@tonic-gate { 13407c478bd9Sstevel@tonic-gate uint_t sz; 13417c478bd9Sstevel@tonic-gate char *name; 13427c478bd9Sstevel@tonic-gate int err = 0; 13437c478bd9Sstevel@tonic-gate 13447c478bd9Sstevel@tonic-gate /* get the path name */ 13457c478bd9Sstevel@tonic-gate name = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 13467c478bd9Sstevel@tonic-gate if (ddi_dev_pathname(dev, spectype, name) == DDI_FAILURE) { 13477c478bd9Sstevel@tonic-gate kmem_free(name, MAXPATHLEN); 13487c478bd9Sstevel@tonic-gate return (EINVAL); 13497c478bd9Sstevel@tonic-gate } 13507c478bd9Sstevel@tonic-gate 13517c478bd9Sstevel@tonic-gate sz = strlen(name) + 1; 13527c478bd9Sstevel@tonic-gate 13537c478bd9Sstevel@tonic-gate /* Error if the path name is larger than the space allocated */ 13547c478bd9Sstevel@tonic-gate if (sz > len) { 13557c478bd9Sstevel@tonic-gate kmem_free(name, MAXPATHLEN); 13567c478bd9Sstevel@tonic-gate return (ENOSPC); 13577c478bd9Sstevel@tonic-gate } 13587c478bd9Sstevel@tonic-gate 13597c478bd9Sstevel@tonic-gate /* copy out the path name */ 13607c478bd9Sstevel@tonic-gate if (copyout(name, uname, sz) != 0) 13617c478bd9Sstevel@tonic-gate err = EFAULT; 13627c478bd9Sstevel@tonic-gate kmem_free(name, MAXPATHLEN); 13637c478bd9Sstevel@tonic-gate return (err); 13647c478bd9Sstevel@tonic-gate } 13657c478bd9Sstevel@tonic-gate 1366a08731ecScth /* 1367a08731ecScth * Return the size of the (major,instance) devfspath name. 1368a08731ecScth */ 1369a08731ecScth static int 1370a08731ecScth modctl_devfspath_mi_len(major_t major, int instance, uint_t *len) 1371a08731ecScth { 1372a08731ecScth uint_t sz; 1373a08731ecScth char *name; 1374a08731ecScth 1375a08731ecScth /* get the path name */ 1376a08731ecScth name = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 1377a08731ecScth if (e_ddi_majorinstance_to_path(major, instance, name) != DDI_SUCCESS) { 1378a08731ecScth kmem_free(name, MAXPATHLEN); 1379a08731ecScth return (EINVAL); 1380a08731ecScth } 1381a08731ecScth 1382a08731ecScth sz = strlen(name) + 1; 1383a08731ecScth kmem_free(name, MAXPATHLEN); 1384a08731ecScth 1385a08731ecScth /* copy out the size of the path name */ 1386a08731ecScth if (copyout(&sz, len, sizeof (sz)) != 0) 1387a08731ecScth return (EFAULT); 1388a08731ecScth 1389a08731ecScth return (0); 1390a08731ecScth } 1391a08731ecScth 1392a08731ecScth /* 1393a08731ecScth * Return the (major_instance) devfspath name. 1394a08731ecScth * NOTE: e_ddi_majorinstance_to_path does not require the device to attach to 1395a08731ecScth * return a path - it uses the instance tree. 1396a08731ecScth */ 1397a08731ecScth static int 1398a08731ecScth modctl_devfspath_mi(major_t major, int instance, uint_t len, char *uname) 1399a08731ecScth { 1400a08731ecScth uint_t sz; 1401a08731ecScth char *name; 1402a08731ecScth int err = 0; 1403a08731ecScth 1404a08731ecScth /* get the path name */ 1405a08731ecScth name = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 1406a08731ecScth if (e_ddi_majorinstance_to_path(major, instance, name) != DDI_SUCCESS) { 1407a08731ecScth kmem_free(name, MAXPATHLEN); 1408a08731ecScth return (EINVAL); 1409a08731ecScth } 1410a08731ecScth 1411a08731ecScth sz = strlen(name) + 1; 1412a08731ecScth 1413a08731ecScth /* Error if the path name is larger than the space allocated */ 1414a08731ecScth if (sz > len) { 1415a08731ecScth kmem_free(name, MAXPATHLEN); 1416a08731ecScth return (ENOSPC); 1417a08731ecScth } 1418a08731ecScth 1419a08731ecScth /* copy out the path name */ 1420a08731ecScth if (copyout(name, uname, sz) != 0) 1421a08731ecScth err = EFAULT; 1422a08731ecScth kmem_free(name, MAXPATHLEN); 1423a08731ecScth return (err); 1424a08731ecScth } 1425a08731ecScth 14267c478bd9Sstevel@tonic-gate static int 14277c478bd9Sstevel@tonic-gate modctl_get_fbname(char *path) 14287c478bd9Sstevel@tonic-gate { 14297c478bd9Sstevel@tonic-gate extern dev_t fbdev; 14307c478bd9Sstevel@tonic-gate char *pathname = NULL; 14317c478bd9Sstevel@tonic-gate int rval = 0; 14327c478bd9Sstevel@tonic-gate 14337c478bd9Sstevel@tonic-gate /* make sure fbdev is set before we plunge in */ 14347c478bd9Sstevel@tonic-gate if (fbdev == NODEV) 14357c478bd9Sstevel@tonic-gate return (ENODEV); 14367c478bd9Sstevel@tonic-gate 14377c478bd9Sstevel@tonic-gate pathname = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 14387c478bd9Sstevel@tonic-gate if ((rval = ddi_dev_pathname(fbdev, S_IFCHR, 14397c478bd9Sstevel@tonic-gate pathname)) == DDI_SUCCESS) { 14407c478bd9Sstevel@tonic-gate if (copyout(pathname, path, strlen(pathname)+1) != 0) { 14417c478bd9Sstevel@tonic-gate rval = EFAULT; 14427c478bd9Sstevel@tonic-gate } 14437c478bd9Sstevel@tonic-gate } 14447c478bd9Sstevel@tonic-gate kmem_free(pathname, MAXPATHLEN); 14457c478bd9Sstevel@tonic-gate return (rval); 14467c478bd9Sstevel@tonic-gate } 14477c478bd9Sstevel@tonic-gate 14487c478bd9Sstevel@tonic-gate /* 14497c478bd9Sstevel@tonic-gate * modctl_reread_dacf() 14507c478bd9Sstevel@tonic-gate * Reread the dacf rules database from the named binding file. 14517c478bd9Sstevel@tonic-gate * If NULL is specified, pass along the NULL, it means 'use the default'. 14527c478bd9Sstevel@tonic-gate */ 14537c478bd9Sstevel@tonic-gate static int 14547c478bd9Sstevel@tonic-gate modctl_reread_dacf(char *path) 14557c478bd9Sstevel@tonic-gate { 14567c478bd9Sstevel@tonic-gate int rval = 0; 14577c478bd9Sstevel@tonic-gate char *filename, *filenamep; 14587c478bd9Sstevel@tonic-gate 14597c478bd9Sstevel@tonic-gate filename = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 14607c478bd9Sstevel@tonic-gate 14617c478bd9Sstevel@tonic-gate if (path == NULL) { 14627c478bd9Sstevel@tonic-gate filenamep = NULL; 14637c478bd9Sstevel@tonic-gate } else { 14647c478bd9Sstevel@tonic-gate if (copyinstr(path, filename, MAXPATHLEN, 0) != 0) { 14657c478bd9Sstevel@tonic-gate rval = EFAULT; 14667c478bd9Sstevel@tonic-gate goto out; 14677c478bd9Sstevel@tonic-gate } 14687c478bd9Sstevel@tonic-gate filenamep = filename; 14697c478bd9Sstevel@tonic-gate filenamep[MAXPATHLEN - 1] = '\0'; 14707c478bd9Sstevel@tonic-gate } 14717c478bd9Sstevel@tonic-gate 14727c478bd9Sstevel@tonic-gate rval = read_dacf_binding_file(filenamep); 14737c478bd9Sstevel@tonic-gate out: 14747c478bd9Sstevel@tonic-gate kmem_free(filename, MAXPATHLEN); 14757c478bd9Sstevel@tonic-gate return (rval); 14767c478bd9Sstevel@tonic-gate } 14777c478bd9Sstevel@tonic-gate 14787c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 14797c478bd9Sstevel@tonic-gate static int 14807c478bd9Sstevel@tonic-gate modctl_modevents(int subcmd, uintptr_t a2, uintptr_t a3, uintptr_t a4, 14817c478bd9Sstevel@tonic-gate uint_t flag) 14827c478bd9Sstevel@tonic-gate { 14837c478bd9Sstevel@tonic-gate int error = 0; 14847c478bd9Sstevel@tonic-gate char *filenamep; 14857c478bd9Sstevel@tonic-gate 14867c478bd9Sstevel@tonic-gate switch (subcmd) { 14877c478bd9Sstevel@tonic-gate 14887c478bd9Sstevel@tonic-gate case MODEVENTS_FLUSH: 14897c478bd9Sstevel@tonic-gate /* flush all currently queued events */ 14907c478bd9Sstevel@tonic-gate log_sysevent_flushq(subcmd, flag); 14917c478bd9Sstevel@tonic-gate break; 14927c478bd9Sstevel@tonic-gate 14937c478bd9Sstevel@tonic-gate case MODEVENTS_SET_DOOR_UPCALL_FILENAME: 14947c478bd9Sstevel@tonic-gate /* 14957c478bd9Sstevel@tonic-gate * bind door_upcall to filename 14967c478bd9Sstevel@tonic-gate * this should only be done once per invocation 14977c478bd9Sstevel@tonic-gate * of the event daemon. 14987c478bd9Sstevel@tonic-gate */ 14997c478bd9Sstevel@tonic-gate 15007c478bd9Sstevel@tonic-gate filenamep = kmem_zalloc(MOD_MAXPATH, KM_SLEEP); 15017c478bd9Sstevel@tonic-gate 15027c478bd9Sstevel@tonic-gate if (copyinstr((char *)a2, filenamep, MOD_MAXPATH, 0)) { 15037c478bd9Sstevel@tonic-gate error = EFAULT; 15047c478bd9Sstevel@tonic-gate } else { 15057c478bd9Sstevel@tonic-gate error = log_sysevent_filename(filenamep); 15067c478bd9Sstevel@tonic-gate } 15077c478bd9Sstevel@tonic-gate kmem_free(filenamep, MOD_MAXPATH); 15087c478bd9Sstevel@tonic-gate break; 15097c478bd9Sstevel@tonic-gate 15107c478bd9Sstevel@tonic-gate case MODEVENTS_GETDATA: 15117c478bd9Sstevel@tonic-gate error = log_sysevent_copyout_data((sysevent_id_t *)a2, 15127c478bd9Sstevel@tonic-gate (size_t)a3, (caddr_t)a4); 15137c478bd9Sstevel@tonic-gate break; 15147c478bd9Sstevel@tonic-gate 15157c478bd9Sstevel@tonic-gate case MODEVENTS_FREEDATA: 15167c478bd9Sstevel@tonic-gate error = log_sysevent_free_data((sysevent_id_t *)a2); 15177c478bd9Sstevel@tonic-gate break; 15187c478bd9Sstevel@tonic-gate case MODEVENTS_POST_EVENT: 15197c478bd9Sstevel@tonic-gate error = log_usr_sysevent((sysevent_t *)a2, (uint32_t)a3, 15201e1ddd6cScth (sysevent_id_t *)a4); 15217c478bd9Sstevel@tonic-gate break; 15227c478bd9Sstevel@tonic-gate case MODEVENTS_REGISTER_EVENT: 15237c478bd9Sstevel@tonic-gate error = log_sysevent_register((char *)a2, (char *)a3, 15247c478bd9Sstevel@tonic-gate (se_pubsub_t *)a4); 15257c478bd9Sstevel@tonic-gate break; 15267c478bd9Sstevel@tonic-gate default: 15277c478bd9Sstevel@tonic-gate error = EINVAL; 15287c478bd9Sstevel@tonic-gate } 15297c478bd9Sstevel@tonic-gate 15307c478bd9Sstevel@tonic-gate return (error); 15317c478bd9Sstevel@tonic-gate } 15327c478bd9Sstevel@tonic-gate 15337c478bd9Sstevel@tonic-gate static void 15347c478bd9Sstevel@tonic-gate free_mperm(mperm_t *mp) 15357c478bd9Sstevel@tonic-gate { 15367c478bd9Sstevel@tonic-gate int len; 15377c478bd9Sstevel@tonic-gate 15387c478bd9Sstevel@tonic-gate if (mp->mp_minorname) { 15397c478bd9Sstevel@tonic-gate len = strlen(mp->mp_minorname) + 1; 15407c478bd9Sstevel@tonic-gate kmem_free(mp->mp_minorname, len); 15417c478bd9Sstevel@tonic-gate } 15427c478bd9Sstevel@tonic-gate kmem_free(mp, sizeof (mperm_t)); 15437c478bd9Sstevel@tonic-gate } 15447c478bd9Sstevel@tonic-gate 15457c478bd9Sstevel@tonic-gate #define MP_NO_DRV_ERR \ 15467c478bd9Sstevel@tonic-gate "/etc/minor_perm: no driver for %s\n" 15477c478bd9Sstevel@tonic-gate 15487c478bd9Sstevel@tonic-gate #define MP_EMPTY_MINOR \ 15497c478bd9Sstevel@tonic-gate "/etc/minor_perm: empty minor name for driver %s\n" 15507c478bd9Sstevel@tonic-gate 15517c478bd9Sstevel@tonic-gate #define MP_NO_MINOR \ 15527c478bd9Sstevel@tonic-gate "/etc/minor_perm: no minor matching %s for driver %s\n" 15537c478bd9Sstevel@tonic-gate 15547c478bd9Sstevel@tonic-gate /* 15557c478bd9Sstevel@tonic-gate * Remove mperm entry with matching minorname 15567c478bd9Sstevel@tonic-gate */ 15577c478bd9Sstevel@tonic-gate static void 15587c478bd9Sstevel@tonic-gate rem_minorperm(major_t major, char *drvname, mperm_t *mp, int is_clone) 15597c478bd9Sstevel@tonic-gate { 15607c478bd9Sstevel@tonic-gate mperm_t **mp_head; 15617c478bd9Sstevel@tonic-gate mperm_t *freemp = NULL; 15627c478bd9Sstevel@tonic-gate struct devnames *dnp = &devnamesp[major]; 15637c478bd9Sstevel@tonic-gate mperm_t **wildmp; 15647c478bd9Sstevel@tonic-gate 15657c478bd9Sstevel@tonic-gate ASSERT(mp->mp_minorname && strlen(mp->mp_minorname) > 0); 15667c478bd9Sstevel@tonic-gate 15677c478bd9Sstevel@tonic-gate LOCK_DEV_OPS(&dnp->dn_lock); 15687c478bd9Sstevel@tonic-gate if (strcmp(mp->mp_minorname, "*") == 0) { 15697c478bd9Sstevel@tonic-gate wildmp = ((is_clone == 0) ? 15701e1ddd6cScth &dnp->dn_mperm_wild : &dnp->dn_mperm_clone); 15717c478bd9Sstevel@tonic-gate if (*wildmp) 15727c478bd9Sstevel@tonic-gate freemp = *wildmp; 15737c478bd9Sstevel@tonic-gate *wildmp = NULL; 15747c478bd9Sstevel@tonic-gate } else { 15757c478bd9Sstevel@tonic-gate mp_head = &dnp->dn_mperm; 15767c478bd9Sstevel@tonic-gate while (*mp_head) { 15777c478bd9Sstevel@tonic-gate if (strcmp((*mp_head)->mp_minorname, 15787c478bd9Sstevel@tonic-gate mp->mp_minorname) != 0) { 15797c478bd9Sstevel@tonic-gate mp_head = &(*mp_head)->mp_next; 15807c478bd9Sstevel@tonic-gate continue; 15817c478bd9Sstevel@tonic-gate } 15827c478bd9Sstevel@tonic-gate /* remove the entry */ 15837c478bd9Sstevel@tonic-gate freemp = *mp_head; 15847c478bd9Sstevel@tonic-gate *mp_head = freemp->mp_next; 15857c478bd9Sstevel@tonic-gate break; 15867c478bd9Sstevel@tonic-gate } 15877c478bd9Sstevel@tonic-gate } 15887c478bd9Sstevel@tonic-gate if (freemp) { 15897c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MINORPERM) { 15907c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, "< %s %s 0%o %d %d\n", 15917c478bd9Sstevel@tonic-gate drvname, freemp->mp_minorname, 15927c478bd9Sstevel@tonic-gate freemp->mp_mode & 0777, 15937c478bd9Sstevel@tonic-gate freemp->mp_uid, freemp->mp_gid); 15947c478bd9Sstevel@tonic-gate } 15957c478bd9Sstevel@tonic-gate free_mperm(freemp); 15967c478bd9Sstevel@tonic-gate } else { 15977c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MINORPERM) { 15987c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, MP_NO_MINOR, 15991e1ddd6cScth drvname, mp->mp_minorname); 16007c478bd9Sstevel@tonic-gate } 16017c478bd9Sstevel@tonic-gate } 16027c478bd9Sstevel@tonic-gate 16037c478bd9Sstevel@tonic-gate UNLOCK_DEV_OPS(&dnp->dn_lock); 16047c478bd9Sstevel@tonic-gate } 16057c478bd9Sstevel@tonic-gate 16067c478bd9Sstevel@tonic-gate /* 16077c478bd9Sstevel@tonic-gate * Add minor perm entry 16087c478bd9Sstevel@tonic-gate */ 16097c478bd9Sstevel@tonic-gate static void 16107c478bd9Sstevel@tonic-gate add_minorperm(major_t major, char *drvname, mperm_t *mp, int is_clone) 16117c478bd9Sstevel@tonic-gate { 16127c478bd9Sstevel@tonic-gate mperm_t **mp_head; 16137c478bd9Sstevel@tonic-gate mperm_t *freemp = NULL; 16147c478bd9Sstevel@tonic-gate struct devnames *dnp = &devnamesp[major]; 16157c478bd9Sstevel@tonic-gate mperm_t **wildmp; 16167c478bd9Sstevel@tonic-gate 16177c478bd9Sstevel@tonic-gate ASSERT(mp->mp_minorname && strlen(mp->mp_minorname) > 0); 16187c478bd9Sstevel@tonic-gate 16197c478bd9Sstevel@tonic-gate /* 16207c478bd9Sstevel@tonic-gate * Note that update_drv replace semantics require 16217c478bd9Sstevel@tonic-gate * replacing matching entries with the new permissions. 16227c478bd9Sstevel@tonic-gate */ 16237c478bd9Sstevel@tonic-gate LOCK_DEV_OPS(&dnp->dn_lock); 16247c478bd9Sstevel@tonic-gate if (strcmp(mp->mp_minorname, "*") == 0) { 16257c478bd9Sstevel@tonic-gate wildmp = ((is_clone == 0) ? 16261e1ddd6cScth &dnp->dn_mperm_wild : &dnp->dn_mperm_clone); 16277c478bd9Sstevel@tonic-gate if (*wildmp) 16287c478bd9Sstevel@tonic-gate freemp = *wildmp; 16297c478bd9Sstevel@tonic-gate *wildmp = mp; 16307c478bd9Sstevel@tonic-gate } else { 16317c478bd9Sstevel@tonic-gate mperm_t *p, *v = NULL; 16327c478bd9Sstevel@tonic-gate for (p = dnp->dn_mperm; p; v = p, p = p->mp_next) { 16337c478bd9Sstevel@tonic-gate if (strcmp(p->mp_minorname, mp->mp_minorname) == 0) { 16347c478bd9Sstevel@tonic-gate if (v == NULL) 16357c478bd9Sstevel@tonic-gate dnp->dn_mperm = mp; 16367c478bd9Sstevel@tonic-gate else 16377c478bd9Sstevel@tonic-gate v->mp_next = mp; 16387c478bd9Sstevel@tonic-gate mp->mp_next = p->mp_next; 16397c478bd9Sstevel@tonic-gate freemp = p; 16407c478bd9Sstevel@tonic-gate goto replaced; 16417c478bd9Sstevel@tonic-gate } 16427c478bd9Sstevel@tonic-gate } 16437c478bd9Sstevel@tonic-gate if (p == NULL) { 16447c478bd9Sstevel@tonic-gate mp_head = &dnp->dn_mperm; 16457c478bd9Sstevel@tonic-gate if (*mp_head == NULL) { 16467c478bd9Sstevel@tonic-gate *mp_head = mp; 16477c478bd9Sstevel@tonic-gate } else { 16487c478bd9Sstevel@tonic-gate mp->mp_next = *mp_head; 16497c478bd9Sstevel@tonic-gate *mp_head = mp; 16507c478bd9Sstevel@tonic-gate } 16517c478bd9Sstevel@tonic-gate } 16527c478bd9Sstevel@tonic-gate } 16537c478bd9Sstevel@tonic-gate replaced: 16547c478bd9Sstevel@tonic-gate if (freemp) { 16557c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MINORPERM) { 16567c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, "< %s %s 0%o %d %d\n", 16577c478bd9Sstevel@tonic-gate drvname, freemp->mp_minorname, 16587c478bd9Sstevel@tonic-gate freemp->mp_mode & 0777, 16597c478bd9Sstevel@tonic-gate freemp->mp_uid, freemp->mp_gid); 16607c478bd9Sstevel@tonic-gate } 16617c478bd9Sstevel@tonic-gate free_mperm(freemp); 16627c478bd9Sstevel@tonic-gate } 16637c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MINORPERM) { 16647c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, "> %s %s 0%o %d %d\n", 16657c478bd9Sstevel@tonic-gate drvname, mp->mp_minorname, mp->mp_mode & 0777, 16667c478bd9Sstevel@tonic-gate mp->mp_uid, mp->mp_gid); 16677c478bd9Sstevel@tonic-gate } 16687c478bd9Sstevel@tonic-gate UNLOCK_DEV_OPS(&dnp->dn_lock); 16697c478bd9Sstevel@tonic-gate } 16707c478bd9Sstevel@tonic-gate 16717c478bd9Sstevel@tonic-gate 16727c478bd9Sstevel@tonic-gate static int 16737c478bd9Sstevel@tonic-gate process_minorperm(int cmd, nvlist_t *nvl) 16747c478bd9Sstevel@tonic-gate { 16757c478bd9Sstevel@tonic-gate char *minor; 16767c478bd9Sstevel@tonic-gate major_t major; 16777c478bd9Sstevel@tonic-gate mperm_t *mp; 16787c478bd9Sstevel@tonic-gate nvpair_t *nvp; 16797c478bd9Sstevel@tonic-gate char *name; 16807c478bd9Sstevel@tonic-gate int is_clone; 16817c478bd9Sstevel@tonic-gate major_t minmaj; 16827c478bd9Sstevel@tonic-gate 16837c478bd9Sstevel@tonic-gate ASSERT(cmd == MODLOADMINORPERM || 16847c478bd9Sstevel@tonic-gate cmd == MODADDMINORPERM || cmd == MODREMMINORPERM); 16857c478bd9Sstevel@tonic-gate 16867c478bd9Sstevel@tonic-gate nvp = NULL; 16877c478bd9Sstevel@tonic-gate while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) { 16887c478bd9Sstevel@tonic-gate name = nvpair_name(nvp); 16897c478bd9Sstevel@tonic-gate 16907c478bd9Sstevel@tonic-gate is_clone = 0; 16917c478bd9Sstevel@tonic-gate (void) nvpair_value_string(nvp, &minor); 16927c478bd9Sstevel@tonic-gate major = ddi_name_to_major(name); 1693a204de77Scth if (major != DDI_MAJOR_T_NONE) { 16947c478bd9Sstevel@tonic-gate mp = kmem_zalloc(sizeof (*mp), KM_SLEEP); 16957c478bd9Sstevel@tonic-gate if (minor == NULL || strlen(minor) == 0) { 16967c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MINORPERM) { 16977c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, MP_EMPTY_MINOR, name); 16987c478bd9Sstevel@tonic-gate } 16997c478bd9Sstevel@tonic-gate minor = "*"; 17007c478bd9Sstevel@tonic-gate } 17017c478bd9Sstevel@tonic-gate 17027c478bd9Sstevel@tonic-gate /* 17037c478bd9Sstevel@tonic-gate * The minor name of a node using the clone 17047c478bd9Sstevel@tonic-gate * driver must be the driver name. To avoid 17057c478bd9Sstevel@tonic-gate * multiple searches, we map entries in the form 17067c478bd9Sstevel@tonic-gate * clone:<driver> to <driver>:*. This also allows us 17077c478bd9Sstevel@tonic-gate * to filter out some of the litter in /etc/minor_perm. 17087c478bd9Sstevel@tonic-gate * Minor perm alias entries where the name is not 17097c478bd9Sstevel@tonic-gate * the driver kept on the clone list itself. 17107c478bd9Sstevel@tonic-gate * This all seems very fragile as a driver could 17117c478bd9Sstevel@tonic-gate * be introduced with an existing alias name. 17127c478bd9Sstevel@tonic-gate */ 17137c478bd9Sstevel@tonic-gate if (strcmp(name, "clone") == 0) { 17147c478bd9Sstevel@tonic-gate minmaj = ddi_name_to_major(minor); 1715a204de77Scth if (minmaj != DDI_MAJOR_T_NONE) { 17167c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MINORPERM) { 17177c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, 17187c478bd9Sstevel@tonic-gate "mapping %s:%s to %s:*\n", 17197c478bd9Sstevel@tonic-gate name, minor, minor); 17207c478bd9Sstevel@tonic-gate } 17217c478bd9Sstevel@tonic-gate major = minmaj; 17227c478bd9Sstevel@tonic-gate name = minor; 17237c478bd9Sstevel@tonic-gate minor = "*"; 17247c478bd9Sstevel@tonic-gate is_clone = 1; 17257c478bd9Sstevel@tonic-gate } 17267c478bd9Sstevel@tonic-gate } 17277c478bd9Sstevel@tonic-gate 17287c478bd9Sstevel@tonic-gate if (mp) { 17297c478bd9Sstevel@tonic-gate mp->mp_minorname = 17307c478bd9Sstevel@tonic-gate i_ddi_strdup(minor, KM_SLEEP); 17317c478bd9Sstevel@tonic-gate } 17327c478bd9Sstevel@tonic-gate } else { 17337c478bd9Sstevel@tonic-gate mp = NULL; 17347c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MINORPERM) { 17357c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, MP_NO_DRV_ERR, name); 17367c478bd9Sstevel@tonic-gate } 17377c478bd9Sstevel@tonic-gate } 17387c478bd9Sstevel@tonic-gate 17397c478bd9Sstevel@tonic-gate /* mode */ 17407c478bd9Sstevel@tonic-gate nvp = nvlist_next_nvpair(nvl, nvp); 17417c478bd9Sstevel@tonic-gate ASSERT(strcmp(nvpair_name(nvp), "mode") == 0); 17427c478bd9Sstevel@tonic-gate if (mp) 17437c478bd9Sstevel@tonic-gate (void) nvpair_value_int32(nvp, (int *)&mp->mp_mode); 17447c478bd9Sstevel@tonic-gate /* uid */ 17457c478bd9Sstevel@tonic-gate nvp = nvlist_next_nvpair(nvl, nvp); 17467c478bd9Sstevel@tonic-gate ASSERT(strcmp(nvpair_name(nvp), "uid") == 0); 17477c478bd9Sstevel@tonic-gate if (mp) 1748f48205beScasper (void) nvpair_value_uint32(nvp, &mp->mp_uid); 17497c478bd9Sstevel@tonic-gate /* gid */ 17507c478bd9Sstevel@tonic-gate nvp = nvlist_next_nvpair(nvl, nvp); 17517c478bd9Sstevel@tonic-gate ASSERT(strcmp(nvpair_name(nvp), "gid") == 0); 17527c478bd9Sstevel@tonic-gate if (mp) { 1753f48205beScasper (void) nvpair_value_uint32(nvp, &mp->mp_gid); 17547c478bd9Sstevel@tonic-gate 17557c478bd9Sstevel@tonic-gate if (cmd == MODREMMINORPERM) { 17567c478bd9Sstevel@tonic-gate rem_minorperm(major, name, mp, is_clone); 17577c478bd9Sstevel@tonic-gate free_mperm(mp); 17587c478bd9Sstevel@tonic-gate } else { 17597c478bd9Sstevel@tonic-gate add_minorperm(major, name, mp, is_clone); 17607c478bd9Sstevel@tonic-gate } 17617c478bd9Sstevel@tonic-gate } 17627c478bd9Sstevel@tonic-gate } 17637c478bd9Sstevel@tonic-gate 17647c478bd9Sstevel@tonic-gate if (cmd == MODLOADMINORPERM) 17657c478bd9Sstevel@tonic-gate minorperm_loaded = 1; 17667c478bd9Sstevel@tonic-gate 17677c478bd9Sstevel@tonic-gate /* 17687c478bd9Sstevel@tonic-gate * Reset permissions of cached dv_nodes 17697c478bd9Sstevel@tonic-gate */ 17707c478bd9Sstevel@tonic-gate (void) devfs_reset_perm(DV_RESET_PERM); 17717c478bd9Sstevel@tonic-gate 17727c478bd9Sstevel@tonic-gate return (0); 17737c478bd9Sstevel@tonic-gate } 17747c478bd9Sstevel@tonic-gate 17757c478bd9Sstevel@tonic-gate static int 17767c478bd9Sstevel@tonic-gate modctl_minorperm(int cmd, char *usrbuf, size_t buflen) 17777c478bd9Sstevel@tonic-gate { 17787c478bd9Sstevel@tonic-gate int error; 17797c478bd9Sstevel@tonic-gate nvlist_t *nvl; 17807c478bd9Sstevel@tonic-gate char *buf = kmem_alloc(buflen, KM_SLEEP); 17817c478bd9Sstevel@tonic-gate 17827c478bd9Sstevel@tonic-gate if ((error = ddi_copyin(usrbuf, buf, buflen, 0)) != 0) { 17837c478bd9Sstevel@tonic-gate kmem_free(buf, buflen); 17847c478bd9Sstevel@tonic-gate return (error); 17857c478bd9Sstevel@tonic-gate } 17867c478bd9Sstevel@tonic-gate 17877c478bd9Sstevel@tonic-gate error = nvlist_unpack(buf, buflen, &nvl, KM_SLEEP); 17887c478bd9Sstevel@tonic-gate kmem_free(buf, buflen); 17897c478bd9Sstevel@tonic-gate if (error) 17907c478bd9Sstevel@tonic-gate return (error); 17917c478bd9Sstevel@tonic-gate 17927c478bd9Sstevel@tonic-gate error = process_minorperm(cmd, nvl); 17937c478bd9Sstevel@tonic-gate nvlist_free(nvl); 17947c478bd9Sstevel@tonic-gate return (error); 17957c478bd9Sstevel@tonic-gate } 17967c478bd9Sstevel@tonic-gate 17977c478bd9Sstevel@tonic-gate struct walk_args { 17987c478bd9Sstevel@tonic-gate char *wa_drvname; 17997c478bd9Sstevel@tonic-gate list_t wa_pathlist; 18007c478bd9Sstevel@tonic-gate }; 18017c478bd9Sstevel@tonic-gate 18027c478bd9Sstevel@tonic-gate struct path_elem { 18037c478bd9Sstevel@tonic-gate char *pe_dir; 18047c478bd9Sstevel@tonic-gate char *pe_nodename; 18057c478bd9Sstevel@tonic-gate list_node_t pe_node; 18067c478bd9Sstevel@tonic-gate int pe_dirlen; 18077c478bd9Sstevel@tonic-gate }; 18087c478bd9Sstevel@tonic-gate 18097c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 18107c478bd9Sstevel@tonic-gate static int 18117c478bd9Sstevel@tonic-gate modctl_inst_walker(const char *path, in_node_t *np, in_drv_t *dp, void *arg) 18127c478bd9Sstevel@tonic-gate { 18137c478bd9Sstevel@tonic-gate struct walk_args *wargs = (struct walk_args *)arg; 18147c478bd9Sstevel@tonic-gate struct path_elem *pe; 18157c478bd9Sstevel@tonic-gate char *nodename; 18167c478bd9Sstevel@tonic-gate 18171aef0e11Sjg /* 18181aef0e11Sjg * Search may be restricted to a single driver in the case of rem_drv 18191aef0e11Sjg */ 18201aef0e11Sjg if (wargs->wa_drvname && 18211aef0e11Sjg strcmp(dp->ind_driver_name, wargs->wa_drvname) != 0) 18227c478bd9Sstevel@tonic-gate return (INST_WALK_CONTINUE); 18237c478bd9Sstevel@tonic-gate 18247c478bd9Sstevel@tonic-gate pe = kmem_zalloc(sizeof (*pe), KM_SLEEP); 18257c478bd9Sstevel@tonic-gate pe->pe_dir = i_ddi_strdup((char *)path, KM_SLEEP); 18267c478bd9Sstevel@tonic-gate pe->pe_dirlen = strlen(pe->pe_dir) + 1; 18277c478bd9Sstevel@tonic-gate ASSERT(strrchr(pe->pe_dir, '/') != NULL); 18287c478bd9Sstevel@tonic-gate nodename = strrchr(pe->pe_dir, '/'); 18297c478bd9Sstevel@tonic-gate *nodename++ = 0; 18307c478bd9Sstevel@tonic-gate pe->pe_nodename = nodename; 18317c478bd9Sstevel@tonic-gate list_insert_tail(&wargs->wa_pathlist, pe); 18327c478bd9Sstevel@tonic-gate 18337c478bd9Sstevel@tonic-gate return (INST_WALK_CONTINUE); 18347c478bd9Sstevel@tonic-gate } 18357c478bd9Sstevel@tonic-gate 18361aef0e11Sjg /* 18371aef0e11Sjg * /devices attribute nodes clean-up optionally performed 18381aef0e11Sjg * when removing a driver (rem_drv -C). 18391aef0e11Sjg * 18401aef0e11Sjg * Removing attribute nodes allows a machine to be reprovisioned 18411aef0e11Sjg * without the side-effect of inadvertently picking up stale 18421aef0e11Sjg * device node ownership or permissions. 18431aef0e11Sjg * 18441aef0e11Sjg * Preserving attributes (not performing cleanup) allows devices 18451aef0e11Sjg * attribute changes to be preserved across upgrades, as 18461aef0e11Sjg * upgrade rather heavy-handedly does a rem_drv/add_drv cycle. 18471aef0e11Sjg */ 18487c478bd9Sstevel@tonic-gate static int 18497c478bd9Sstevel@tonic-gate modctl_remdrv_cleanup(const char *u_drvname) 18507c478bd9Sstevel@tonic-gate { 18517c478bd9Sstevel@tonic-gate struct walk_args *wargs; 18527c478bd9Sstevel@tonic-gate struct path_elem *pe; 18537c478bd9Sstevel@tonic-gate char *drvname; 18547c478bd9Sstevel@tonic-gate int err, rval = 0; 18557c478bd9Sstevel@tonic-gate 18567c478bd9Sstevel@tonic-gate drvname = kmem_alloc(MAXMODCONFNAME, KM_SLEEP); 18577c478bd9Sstevel@tonic-gate if ((err = copyinstr(u_drvname, drvname, MAXMODCONFNAME, 0))) { 18587c478bd9Sstevel@tonic-gate kmem_free(drvname, MAXMODCONFNAME); 18597c478bd9Sstevel@tonic-gate return (err); 18607c478bd9Sstevel@tonic-gate } 18617c478bd9Sstevel@tonic-gate 18627c478bd9Sstevel@tonic-gate /* 18637c478bd9Sstevel@tonic-gate * First go through the instance database. For each 18647c478bd9Sstevel@tonic-gate * instance of a device bound to the driver being 18657c478bd9Sstevel@tonic-gate * removed, remove any underlying devfs attribute nodes. 18667c478bd9Sstevel@tonic-gate * 18677c478bd9Sstevel@tonic-gate * This is a two-step process. First we go through 18687c478bd9Sstevel@tonic-gate * the instance data itself, constructing a list of 18697c478bd9Sstevel@tonic-gate * the nodes discovered. The second step is then 18707c478bd9Sstevel@tonic-gate * to find and remove any devfs attribute nodes 18717c478bd9Sstevel@tonic-gate * for the instances discovered in the first step. 18727c478bd9Sstevel@tonic-gate * The two-step process avoids any difficulties 18737c478bd9Sstevel@tonic-gate * which could arise by holding the instance data 18747c478bd9Sstevel@tonic-gate * lock with simultaneous devfs operations. 18757c478bd9Sstevel@tonic-gate */ 18767c478bd9Sstevel@tonic-gate wargs = kmem_zalloc(sizeof (*wargs), KM_SLEEP); 18777c478bd9Sstevel@tonic-gate 18787c478bd9Sstevel@tonic-gate wargs->wa_drvname = drvname; 18797c478bd9Sstevel@tonic-gate list_create(&wargs->wa_pathlist, 18807c478bd9Sstevel@tonic-gate sizeof (struct path_elem), offsetof(struct path_elem, pe_node)); 18817c478bd9Sstevel@tonic-gate 18827c478bd9Sstevel@tonic-gate (void) e_ddi_walk_instances(modctl_inst_walker, (void *)wargs); 18837c478bd9Sstevel@tonic-gate 18847c478bd9Sstevel@tonic-gate for (pe = list_head(&wargs->wa_pathlist); pe != NULL; 18857c478bd9Sstevel@tonic-gate pe = list_next(&wargs->wa_pathlist, pe)) { 18867c478bd9Sstevel@tonic-gate err = devfs_remdrv_cleanup((const char *)pe->pe_dir, 18871e1ddd6cScth (const char *)pe->pe_nodename); 18887c478bd9Sstevel@tonic-gate if (rval == 0) 18897c478bd9Sstevel@tonic-gate rval = err; 18907c478bd9Sstevel@tonic-gate } 18917c478bd9Sstevel@tonic-gate 18927c478bd9Sstevel@tonic-gate while ((pe = list_head(&wargs->wa_pathlist)) != NULL) { 18937c478bd9Sstevel@tonic-gate list_remove(&wargs->wa_pathlist, pe); 18947c478bd9Sstevel@tonic-gate kmem_free(pe->pe_dir, pe->pe_dirlen); 18957c478bd9Sstevel@tonic-gate kmem_free(pe, sizeof (*pe)); 18967c478bd9Sstevel@tonic-gate } 18977c478bd9Sstevel@tonic-gate kmem_free(wargs, sizeof (*wargs)); 18987c478bd9Sstevel@tonic-gate 18997c478bd9Sstevel@tonic-gate /* 19007c478bd9Sstevel@tonic-gate * Pseudo nodes aren't recorded in the instance database 19017c478bd9Sstevel@tonic-gate * so any such nodes need to be handled separately. 19027c478bd9Sstevel@tonic-gate */ 19037c478bd9Sstevel@tonic-gate err = devfs_remdrv_cleanup("pseudo", (const char *)drvname); 19047c478bd9Sstevel@tonic-gate if (rval == 0) 19057c478bd9Sstevel@tonic-gate rval = err; 19067c478bd9Sstevel@tonic-gate 19077c478bd9Sstevel@tonic-gate kmem_free(drvname, MAXMODCONFNAME); 19087c478bd9Sstevel@tonic-gate return (rval); 19097c478bd9Sstevel@tonic-gate } 19107c478bd9Sstevel@tonic-gate 19111aef0e11Sjg /* 19121aef0e11Sjg * Perform a cleanup of non-existent /devices attribute nodes, 19131aef0e11Sjg * similar to rem_drv -C, but for all drivers/devices. 19141aef0e11Sjg * This is also optional, performed as part of devfsadm -C. 19151aef0e11Sjg */ 19161aef0e11Sjg void 19171aef0e11Sjg dev_devices_cleanup() 19181aef0e11Sjg { 19191aef0e11Sjg struct walk_args *wargs; 19201aef0e11Sjg struct path_elem *pe; 19211aef0e11Sjg dev_info_t *devi; 19221aef0e11Sjg char *path; 19231aef0e11Sjg int err; 19241aef0e11Sjg 19251aef0e11Sjg /* 19261aef0e11Sjg * It's expected that all drivers have been loaded and 19271aef0e11Sjg * module unloading disabled while performing cleanup. 19281aef0e11Sjg */ 19291aef0e11Sjg ASSERT(modunload_disable_count > 0); 19301aef0e11Sjg 19311aef0e11Sjg wargs = kmem_zalloc(sizeof (*wargs), KM_SLEEP); 19321aef0e11Sjg wargs->wa_drvname = NULL; 19331aef0e11Sjg list_create(&wargs->wa_pathlist, 19341aef0e11Sjg sizeof (struct path_elem), offsetof(struct path_elem, pe_node)); 19351aef0e11Sjg 19361aef0e11Sjg (void) e_ddi_walk_instances(modctl_inst_walker, (void *)wargs); 19371aef0e11Sjg 19381aef0e11Sjg path = kmem_alloc(MAXPATHLEN, KM_SLEEP); 19391aef0e11Sjg 19401aef0e11Sjg for (pe = list_head(&wargs->wa_pathlist); pe != NULL; 19411aef0e11Sjg pe = list_next(&wargs->wa_pathlist, pe)) { 19421aef0e11Sjg (void) snprintf(path, MAXPATHLEN, "%s/%s", 19431aef0e11Sjg pe->pe_dir, pe->pe_nodename); 19441aef0e11Sjg devi = e_ddi_hold_devi_by_path(path, 0); 19451aef0e11Sjg if (devi != NULL) { 19461aef0e11Sjg ddi_release_devi(devi); 19471aef0e11Sjg } else { 19481aef0e11Sjg err = devfs_remdrv_cleanup((const char *)pe->pe_dir, 19491aef0e11Sjg (const char *)pe->pe_nodename); 19501aef0e11Sjg if (err) { 19511aef0e11Sjg cmn_err(CE_CONT, 19521aef0e11Sjg "devfs: %s: clean-up error %d\n", 19531aef0e11Sjg path, err); 19541aef0e11Sjg } 19551aef0e11Sjg } 19561aef0e11Sjg } 19571aef0e11Sjg 19581aef0e11Sjg while ((pe = list_head(&wargs->wa_pathlist)) != NULL) { 19591aef0e11Sjg list_remove(&wargs->wa_pathlist, pe); 19601aef0e11Sjg kmem_free(pe->pe_dir, pe->pe_dirlen); 19611aef0e11Sjg kmem_free(pe, sizeof (*pe)); 19621aef0e11Sjg } 19631aef0e11Sjg kmem_free(wargs, sizeof (*wargs)); 19641aef0e11Sjg kmem_free(path, MAXPATHLEN); 19651aef0e11Sjg } 19661aef0e11Sjg 19677c478bd9Sstevel@tonic-gate static int 19687c478bd9Sstevel@tonic-gate modctl_allocpriv(const char *name) 19697c478bd9Sstevel@tonic-gate { 19707c478bd9Sstevel@tonic-gate char *pstr = kmem_alloc(PRIVNAME_MAX, KM_SLEEP); 19717c478bd9Sstevel@tonic-gate int error; 19727c478bd9Sstevel@tonic-gate 19737c478bd9Sstevel@tonic-gate if ((error = copyinstr(name, pstr, PRIVNAME_MAX, 0))) { 19747c478bd9Sstevel@tonic-gate kmem_free(pstr, PRIVNAME_MAX); 19757c478bd9Sstevel@tonic-gate return (error); 19767c478bd9Sstevel@tonic-gate } 19777c478bd9Sstevel@tonic-gate error = priv_getbyname(pstr, PRIV_ALLOC); 19787c478bd9Sstevel@tonic-gate if (error < 0) 19797c478bd9Sstevel@tonic-gate error = -error; 19807c478bd9Sstevel@tonic-gate else 19817c478bd9Sstevel@tonic-gate error = 0; 19827c478bd9Sstevel@tonic-gate kmem_free(pstr, PRIVNAME_MAX); 19837c478bd9Sstevel@tonic-gate return (error); 19847c478bd9Sstevel@tonic-gate } 19857c478bd9Sstevel@tonic-gate 1986facf4a8dSllai static int 1987facf4a8dSllai modctl_devexists(const char *upath, int pathlen) 1988facf4a8dSllai { 1989facf4a8dSllai char *path; 1990facf4a8dSllai int ret; 1991facf4a8dSllai 1992facf4a8dSllai /* 1993facf4a8dSllai * copy in the path, including the terminating null 1994facf4a8dSllai */ 1995facf4a8dSllai pathlen++; 1996facf4a8dSllai if (pathlen <= 1 || pathlen > MAXPATHLEN) 1997facf4a8dSllai return (EINVAL); 1998facf4a8dSllai path = kmem_zalloc(pathlen + 1, KM_SLEEP); 1999facf4a8dSllai if ((ret = copyinstr(upath, path, pathlen, NULL)) == 0) { 2000facf4a8dSllai ret = sdev_modctl_devexists(path); 2001facf4a8dSllai } 2002facf4a8dSllai 2003facf4a8dSllai kmem_free(path, pathlen + 1); 2004facf4a8dSllai return (ret); 2005facf4a8dSllai } 2006facf4a8dSllai 2007facf4a8dSllai static int 2008facf4a8dSllai modctl_devreaddir(const char *udir, int udirlen, 2009facf4a8dSllai char *upaths, int64_t *ulensp) 2010facf4a8dSllai { 2011facf4a8dSllai char *paths = NULL; 2012facf4a8dSllai char **dirlist = NULL; 2013facf4a8dSllai char *dir; 2014facf4a8dSllai int64_t ulens; 2015facf4a8dSllai int64_t lens; 2016facf4a8dSllai int i, n; 2017facf4a8dSllai int ret = 0; 2018facf4a8dSllai char *p; 2019facf4a8dSllai int npaths; 2020facf4a8dSllai int npaths_alloc; 2021facf4a8dSllai 2022facf4a8dSllai /* 2023facf4a8dSllai * If upaths is NULL then we are only computing the amount of space 2024facf4a8dSllai * needed to return the paths, with the value returned in *ulensp. If we 2025facf4a8dSllai * are copying out paths then we get the amount of space allocated by 2026facf4a8dSllai * the caller. If the actual space needed for paths is larger, or 2027facf4a8dSllai * things are changing out from under us, then we return EAGAIN. 2028facf4a8dSllai */ 2029facf4a8dSllai if (upaths) { 2030facf4a8dSllai if (ulensp == NULL) 2031facf4a8dSllai return (EINVAL); 2032facf4a8dSllai if (copyin(ulensp, &ulens, sizeof (ulens)) != 0) 2033facf4a8dSllai return (EFAULT); 2034facf4a8dSllai } 2035facf4a8dSllai 2036facf4a8dSllai /* 2037facf4a8dSllai * copyin the /dev path including terminating null 2038facf4a8dSllai */ 2039facf4a8dSllai udirlen++; 2040facf4a8dSllai if (udirlen <= 1 || udirlen > MAXPATHLEN) 2041facf4a8dSllai return (EINVAL); 2042facf4a8dSllai dir = kmem_zalloc(udirlen + 1, KM_SLEEP); 2043facf4a8dSllai if ((ret = copyinstr(udir, dir, udirlen, NULL)) != 0) 2044facf4a8dSllai goto err; 2045facf4a8dSllai 2046facf4a8dSllai if ((ret = sdev_modctl_readdir(dir, &dirlist, 2047e37c6c37Scth &npaths, &npaths_alloc, 0)) != 0) { 2048facf4a8dSllai ASSERT(dirlist == NULL); 2049facf4a8dSllai goto err; 2050facf4a8dSllai } 2051facf4a8dSllai 2052facf4a8dSllai lens = 0; 2053facf4a8dSllai for (i = 0; i < npaths; i++) { 2054facf4a8dSllai lens += strlen(dirlist[i]) + 1; 2055facf4a8dSllai } 2056facf4a8dSllai lens++; /* add one for double termination */ 2057facf4a8dSllai 2058facf4a8dSllai if (upaths) { 2059facf4a8dSllai if (lens > ulens) { 2060facf4a8dSllai ret = EAGAIN; 2061facf4a8dSllai goto out; 2062facf4a8dSllai } 2063facf4a8dSllai 2064facf4a8dSllai paths = kmem_alloc(lens, KM_SLEEP); 2065facf4a8dSllai 2066facf4a8dSllai p = paths; 2067facf4a8dSllai for (i = 0; i < npaths; i++) { 2068facf4a8dSllai n = strlen(dirlist[i]) + 1; 2069facf4a8dSllai bcopy(dirlist[i], p, n); 2070facf4a8dSllai p += n; 2071facf4a8dSllai } 2072facf4a8dSllai *p = 0; 2073facf4a8dSllai 2074facf4a8dSllai if (copyout(paths, upaths, lens)) { 2075facf4a8dSllai ret = EFAULT; 2076facf4a8dSllai goto err; 2077facf4a8dSllai } 2078facf4a8dSllai } 2079facf4a8dSllai 2080facf4a8dSllai out: 2081facf4a8dSllai /* copy out the amount of space needed to hold the paths */ 2082facf4a8dSllai if (copyout(&lens, ulensp, sizeof (lens))) 2083facf4a8dSllai ret = EFAULT; 2084facf4a8dSllai 2085facf4a8dSllai err: 2086facf4a8dSllai if (dirlist) 2087facf4a8dSllai sdev_modctl_readdir_free(dirlist, npaths, npaths_alloc); 2088facf4a8dSllai if (paths) 2089facf4a8dSllai kmem_free(paths, lens); 2090facf4a8dSllai kmem_free(dir, udirlen + 1); 2091facf4a8dSllai return (ret); 2092facf4a8dSllai } 2093facf4a8dSllai 2094e37c6c37Scth static int 2095e37c6c37Scth modctl_devemptydir(const char *udir, int udirlen, int *uempty) 2096e37c6c37Scth { 2097e37c6c37Scth char *dir; 2098e37c6c37Scth int ret; 2099e37c6c37Scth char **dirlist = NULL; 2100e37c6c37Scth int npaths; 2101e37c6c37Scth int npaths_alloc; 2102e37c6c37Scth int empty; 2103e37c6c37Scth 2104e37c6c37Scth /* 2105e37c6c37Scth * copyin the /dev path including terminating null 2106e37c6c37Scth */ 2107e37c6c37Scth udirlen++; 2108e37c6c37Scth if (udirlen <= 1 || udirlen > MAXPATHLEN) 2109e37c6c37Scth return (EINVAL); 2110e37c6c37Scth dir = kmem_zalloc(udirlen + 1, KM_SLEEP); 2111e37c6c37Scth if ((ret = copyinstr(udir, dir, udirlen, NULL)) != 0) 2112e37c6c37Scth goto err; 2113e37c6c37Scth 2114e37c6c37Scth if ((ret = sdev_modctl_readdir(dir, &dirlist, 2115e37c6c37Scth &npaths, &npaths_alloc, 1)) != 0) { 2116e37c6c37Scth goto err; 2117e37c6c37Scth } 2118e37c6c37Scth 2119e37c6c37Scth empty = npaths ? 0 : 1; 2120e37c6c37Scth if (copyout(&empty, uempty, sizeof (empty))) 2121e37c6c37Scth ret = EFAULT; 2122e37c6c37Scth 2123e37c6c37Scth err: 2124e37c6c37Scth if (dirlist) 2125e37c6c37Scth sdev_modctl_readdir_free(dirlist, npaths, npaths_alloc); 2126e37c6c37Scth kmem_free(dir, udirlen + 1); 2127e37c6c37Scth return (ret); 2128e37c6c37Scth } 2129e37c6c37Scth 2130facf4a8dSllai int 2131facf4a8dSllai modctl_moddevname(int subcmd, uintptr_t a1, uintptr_t a2) 2132facf4a8dSllai { 2133facf4a8dSllai int error = 0; 2134facf4a8dSllai 2135facf4a8dSllai switch (subcmd) { 2136facf4a8dSllai case MODDEVNAME_LOOKUPDOOR: 2137facf4a8dSllai case MODDEVNAME_DEVFSADMNODE: 2138facf4a8dSllai error = devname_filename_register(subcmd, (char *)a1); 2139facf4a8dSllai break; 2140facf4a8dSllai case MODDEVNAME_NSMAPS: 2141facf4a8dSllai error = devname_nsmaps_register((char *)a1, (size_t)a2); 2142facf4a8dSllai break; 2143facf4a8dSllai case MODDEVNAME_PROFILE: 2144facf4a8dSllai error = devname_profile_update((char *)a1, (size_t)a2); 2145facf4a8dSllai break; 2146facf4a8dSllai case MODDEVNAME_RECONFIG: 2147facf4a8dSllai i_ddi_set_reconfig(); 2148facf4a8dSllai break; 2149facf4a8dSllai case MODDEVNAME_SYSAVAIL: 2150facf4a8dSllai i_ddi_set_sysavail(); 2151facf4a8dSllai break; 2152facf4a8dSllai default: 2153facf4a8dSllai error = EINVAL; 2154facf4a8dSllai break; 2155facf4a8dSllai } 2156facf4a8dSllai 2157facf4a8dSllai return (error); 2158facf4a8dSllai } 2159facf4a8dSllai 21607c478bd9Sstevel@tonic-gate /*ARGSUSED5*/ 21617c478bd9Sstevel@tonic-gate int 21627c478bd9Sstevel@tonic-gate modctl(int cmd, uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4, 21637c478bd9Sstevel@tonic-gate uintptr_t a5) 21647c478bd9Sstevel@tonic-gate { 21657c478bd9Sstevel@tonic-gate int error = EINVAL; 21667c478bd9Sstevel@tonic-gate dev_t dev; 21677c478bd9Sstevel@tonic-gate 21687c478bd9Sstevel@tonic-gate if (secpolicy_modctl(CRED(), cmd) != 0) 21697c478bd9Sstevel@tonic-gate return (set_errno(EPERM)); 21707c478bd9Sstevel@tonic-gate 21717c478bd9Sstevel@tonic-gate switch (cmd) { 21727c478bd9Sstevel@tonic-gate case MODLOAD: /* load a module */ 21737c478bd9Sstevel@tonic-gate error = modctl_modload((int)a1, (char *)a2, (int *)a3); 21747c478bd9Sstevel@tonic-gate break; 21757c478bd9Sstevel@tonic-gate 21767c478bd9Sstevel@tonic-gate case MODUNLOAD: /* unload a module */ 21777c478bd9Sstevel@tonic-gate error = modctl_modunload((modid_t)a1); 21787c478bd9Sstevel@tonic-gate break; 21797c478bd9Sstevel@tonic-gate 21807c478bd9Sstevel@tonic-gate case MODINFO: /* get module status */ 21817c478bd9Sstevel@tonic-gate error = modctl_modinfo((modid_t)a1, (struct modinfo *)a2); 21827c478bd9Sstevel@tonic-gate break; 21837c478bd9Sstevel@tonic-gate 21847c478bd9Sstevel@tonic-gate case MODRESERVED: /* get last major number in range */ 21857c478bd9Sstevel@tonic-gate error = modctl_modreserve((modid_t)a1, (int *)a2); 21867c478bd9Sstevel@tonic-gate break; 21877c478bd9Sstevel@tonic-gate 21887c478bd9Sstevel@tonic-gate case MODSETMINIROOT: /* we are running in miniroot */ 21897c478bd9Sstevel@tonic-gate isminiroot = 1; 21907c478bd9Sstevel@tonic-gate error = 0; 21917c478bd9Sstevel@tonic-gate break; 21927c478bd9Sstevel@tonic-gate 21937c478bd9Sstevel@tonic-gate case MODADDMAJBIND: /* read major binding file */ 21947c478bd9Sstevel@tonic-gate error = modctl_add_major((int *)a2); 21957c478bd9Sstevel@tonic-gate break; 21967c478bd9Sstevel@tonic-gate 21977c478bd9Sstevel@tonic-gate case MODGETPATHLEN: /* get modpath length */ 21987c478bd9Sstevel@tonic-gate error = modctl_getmodpathlen((int *)a2); 21997c478bd9Sstevel@tonic-gate break; 22007c478bd9Sstevel@tonic-gate 22017c478bd9Sstevel@tonic-gate case MODGETPATH: /* get modpath */ 22027c478bd9Sstevel@tonic-gate error = modctl_getmodpath((char *)a2); 22037c478bd9Sstevel@tonic-gate break; 22047c478bd9Sstevel@tonic-gate 22057c478bd9Sstevel@tonic-gate case MODREADSYSBIND: /* read system call binding file */ 22067c478bd9Sstevel@tonic-gate error = modctl_read_sysbinding_file(); 22077c478bd9Sstevel@tonic-gate break; 22087c478bd9Sstevel@tonic-gate 22097c478bd9Sstevel@tonic-gate case MODGETMAJBIND: /* get major number for named device */ 22107c478bd9Sstevel@tonic-gate error = modctl_getmaj((char *)a1, (uint_t)a2, (int *)a3); 22117c478bd9Sstevel@tonic-gate break; 22127c478bd9Sstevel@tonic-gate 22137c478bd9Sstevel@tonic-gate case MODGETNAME: /* get name of device given major number */ 22147c478bd9Sstevel@tonic-gate error = modctl_getname((char *)a1, (uint_t)a2, (int *)a3); 22157c478bd9Sstevel@tonic-gate break; 22167c478bd9Sstevel@tonic-gate 22177c478bd9Sstevel@tonic-gate case MODDEVT2INSTANCE: 22187c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 22197c478bd9Sstevel@tonic-gate dev = (dev_t)a1; 22207c478bd9Sstevel@tonic-gate } 22217c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 22227c478bd9Sstevel@tonic-gate else { 22237c478bd9Sstevel@tonic-gate dev = expldev(a1); 22247c478bd9Sstevel@tonic-gate } 22257c478bd9Sstevel@tonic-gate #endif 22267c478bd9Sstevel@tonic-gate error = modctl_devt2instance(dev, (int *)a2); 22277c478bd9Sstevel@tonic-gate break; 22287c478bd9Sstevel@tonic-gate 22297c478bd9Sstevel@tonic-gate case MODSIZEOF_DEVID: /* sizeof device id of device given dev_t */ 22307c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 22317c478bd9Sstevel@tonic-gate dev = (dev_t)a1; 22327c478bd9Sstevel@tonic-gate } 22337c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 22347c478bd9Sstevel@tonic-gate else { 22357c478bd9Sstevel@tonic-gate dev = expldev(a1); 22367c478bd9Sstevel@tonic-gate } 22377c478bd9Sstevel@tonic-gate #endif 22387c478bd9Sstevel@tonic-gate error = modctl_sizeof_devid(dev, (uint_t *)a2); 22397c478bd9Sstevel@tonic-gate break; 22407c478bd9Sstevel@tonic-gate 22417c478bd9Sstevel@tonic-gate case MODGETDEVID: /* get device id of device given dev_t */ 22427c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 22437c478bd9Sstevel@tonic-gate dev = (dev_t)a1; 22447c478bd9Sstevel@tonic-gate } 22457c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 22467c478bd9Sstevel@tonic-gate else { 22477c478bd9Sstevel@tonic-gate dev = expldev(a1); 22487c478bd9Sstevel@tonic-gate } 22497c478bd9Sstevel@tonic-gate #endif 22507c478bd9Sstevel@tonic-gate error = modctl_get_devid(dev, (uint_t)a2, (ddi_devid_t)a3); 22517c478bd9Sstevel@tonic-gate break; 22527c478bd9Sstevel@tonic-gate 2253a08731ecScth case MODSIZEOF_MINORNAME: /* sizeof minor nm (dev_t,spectype) */ 22547c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 22557c478bd9Sstevel@tonic-gate error = modctl_sizeof_minorname((dev_t)a1, (int)a2, 22567c478bd9Sstevel@tonic-gate (uint_t *)a3); 22577c478bd9Sstevel@tonic-gate } 22587c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 22597c478bd9Sstevel@tonic-gate else { 22607c478bd9Sstevel@tonic-gate error = modctl_sizeof_minorname(expldev(a1), (int)a2, 22617c478bd9Sstevel@tonic-gate (uint_t *)a3); 22627c478bd9Sstevel@tonic-gate } 22637c478bd9Sstevel@tonic-gate 22647c478bd9Sstevel@tonic-gate #endif 22657c478bd9Sstevel@tonic-gate break; 22667c478bd9Sstevel@tonic-gate 2267a08731ecScth case MODGETMINORNAME: /* get minor name of (dev_t,spectype) */ 22687c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 22697c478bd9Sstevel@tonic-gate error = modctl_get_minorname((dev_t)a1, (int)a2, 22707c478bd9Sstevel@tonic-gate (uint_t)a3, (char *)a4); 22717c478bd9Sstevel@tonic-gate } 22727c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 22737c478bd9Sstevel@tonic-gate else { 22747c478bd9Sstevel@tonic-gate error = modctl_get_minorname(expldev(a1), (int)a2, 22757c478bd9Sstevel@tonic-gate (uint_t)a3, (char *)a4); 22767c478bd9Sstevel@tonic-gate } 22777c478bd9Sstevel@tonic-gate #endif 22787c478bd9Sstevel@tonic-gate break; 22797c478bd9Sstevel@tonic-gate 2280a08731ecScth case MODGETDEVFSPATH_LEN: /* sizeof path nm of (dev_t,spectype) */ 22817c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 22827c478bd9Sstevel@tonic-gate error = modctl_devfspath_len((dev_t)a1, (int)a2, 22837c478bd9Sstevel@tonic-gate (uint_t *)a3); 22847c478bd9Sstevel@tonic-gate } 22857c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 22867c478bd9Sstevel@tonic-gate else { 22877c478bd9Sstevel@tonic-gate error = modctl_devfspath_len(expldev(a1), (int)a2, 22887c478bd9Sstevel@tonic-gate (uint_t *)a3); 22897c478bd9Sstevel@tonic-gate } 22907c478bd9Sstevel@tonic-gate 22917c478bd9Sstevel@tonic-gate #endif 22927c478bd9Sstevel@tonic-gate break; 22937c478bd9Sstevel@tonic-gate 2294a08731ecScth case MODGETDEVFSPATH: /* get path name of (dev_t,spec) type */ 22957c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 22967c478bd9Sstevel@tonic-gate error = modctl_devfspath((dev_t)a1, (int)a2, 22977c478bd9Sstevel@tonic-gate (uint_t)a3, (char *)a4); 22987c478bd9Sstevel@tonic-gate } 22997c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 23007c478bd9Sstevel@tonic-gate else { 23017c478bd9Sstevel@tonic-gate error = modctl_devfspath(expldev(a1), (int)a2, 23027c478bd9Sstevel@tonic-gate (uint_t)a3, (char *)a4); 23037c478bd9Sstevel@tonic-gate } 23047c478bd9Sstevel@tonic-gate #endif 23057c478bd9Sstevel@tonic-gate break; 23067c478bd9Sstevel@tonic-gate 2307a08731ecScth case MODGETDEVFSPATH_MI_LEN: /* sizeof path nm of (major,instance) */ 2308a08731ecScth error = modctl_devfspath_mi_len((major_t)a1, (int)a2, 23091e1ddd6cScth (uint_t *)a3); 2310a08731ecScth break; 2311a08731ecScth 2312a08731ecScth case MODGETDEVFSPATH_MI: /* get path name of (major,instance) */ 2313a08731ecScth error = modctl_devfspath_mi((major_t)a1, (int)a2, 23141e1ddd6cScth (uint_t)a3, (char *)a4); 2315a08731ecScth break; 2316a08731ecScth 23177c478bd9Sstevel@tonic-gate 23187c478bd9Sstevel@tonic-gate case MODEVENTS: 23197c478bd9Sstevel@tonic-gate error = modctl_modevents((int)a1, a2, a3, a4, (uint_t)a5); 23207c478bd9Sstevel@tonic-gate break; 23217c478bd9Sstevel@tonic-gate 23227c478bd9Sstevel@tonic-gate case MODGETFBNAME: /* get the framebuffer name */ 23237c478bd9Sstevel@tonic-gate error = modctl_get_fbname((char *)a1); 23247c478bd9Sstevel@tonic-gate break; 23257c478bd9Sstevel@tonic-gate 23267c478bd9Sstevel@tonic-gate case MODREREADDACF: /* reread dacf rule database from given file */ 23277c478bd9Sstevel@tonic-gate error = modctl_reread_dacf((char *)a1); 23287c478bd9Sstevel@tonic-gate break; 23297c478bd9Sstevel@tonic-gate 23307c478bd9Sstevel@tonic-gate case MODLOADDRVCONF: /* load driver.conf file for major */ 23317c478bd9Sstevel@tonic-gate error = modctl_load_drvconf((major_t)a1); 23327c478bd9Sstevel@tonic-gate break; 23337c478bd9Sstevel@tonic-gate 23347c478bd9Sstevel@tonic-gate case MODUNLOADDRVCONF: /* unload driver.conf file for major */ 23357c478bd9Sstevel@tonic-gate error = modctl_unload_drvconf((major_t)a1); 23367c478bd9Sstevel@tonic-gate break; 23377c478bd9Sstevel@tonic-gate 23387c478bd9Sstevel@tonic-gate case MODREMMAJBIND: /* remove a major binding */ 23397c478bd9Sstevel@tonic-gate error = modctl_rem_major((major_t)a1); 23407c478bd9Sstevel@tonic-gate break; 23417c478bd9Sstevel@tonic-gate 23427c478bd9Sstevel@tonic-gate case MODDEVID2PATHS: /* get paths given devid */ 23437c478bd9Sstevel@tonic-gate error = modctl_devid2paths((ddi_devid_t)a1, (char *)a2, 23447c478bd9Sstevel@tonic-gate (uint_t)a3, (size_t *)a4, (char *)a5); 23457c478bd9Sstevel@tonic-gate break; 23467c478bd9Sstevel@tonic-gate 23477c478bd9Sstevel@tonic-gate case MODSETDEVPOLICY: /* establish device policy */ 23487c478bd9Sstevel@tonic-gate error = devpolicy_load((int)a1, (size_t)a2, (devplcysys_t *)a3); 23497c478bd9Sstevel@tonic-gate break; 23507c478bd9Sstevel@tonic-gate 23517c478bd9Sstevel@tonic-gate case MODGETDEVPOLICY: /* get device policy */ 23527c478bd9Sstevel@tonic-gate error = devpolicy_get((int *)a1, (size_t)a2, 23531e1ddd6cScth (devplcysys_t *)a3); 23547c478bd9Sstevel@tonic-gate break; 23557c478bd9Sstevel@tonic-gate 23567c478bd9Sstevel@tonic-gate case MODALLOCPRIV: 23577c478bd9Sstevel@tonic-gate error = modctl_allocpriv((const char *)a1); 23587c478bd9Sstevel@tonic-gate break; 23597c478bd9Sstevel@tonic-gate 23607c478bd9Sstevel@tonic-gate case MODGETDEVPOLICYBYNAME: 23617c478bd9Sstevel@tonic-gate error = devpolicy_getbyname((size_t)a1, 23627c478bd9Sstevel@tonic-gate (devplcysys_t *)a2, (char *)a3); 23637c478bd9Sstevel@tonic-gate break; 23647c478bd9Sstevel@tonic-gate 23657c478bd9Sstevel@tonic-gate case MODLOADMINORPERM: 23667c478bd9Sstevel@tonic-gate case MODADDMINORPERM: 23677c478bd9Sstevel@tonic-gate case MODREMMINORPERM: 23687c478bd9Sstevel@tonic-gate error = modctl_minorperm(cmd, (char *)a1, (size_t)a2); 23697c478bd9Sstevel@tonic-gate break; 23707c478bd9Sstevel@tonic-gate 23717c478bd9Sstevel@tonic-gate case MODREMDRVCLEANUP: 23727c478bd9Sstevel@tonic-gate error = modctl_remdrv_cleanup((const char *)a1); 23737c478bd9Sstevel@tonic-gate break; 23747c478bd9Sstevel@tonic-gate 2375facf4a8dSllai case MODDEVEXISTS: /* non-reconfiguring /dev lookup */ 2376facf4a8dSllai error = modctl_devexists((const char *)a1, (size_t)a2); 2377facf4a8dSllai break; 2378facf4a8dSllai 2379facf4a8dSllai case MODDEVREADDIR: /* non-reconfiguring /dev readdir */ 2380facf4a8dSllai error = modctl_devreaddir((const char *)a1, (size_t)a2, 2381facf4a8dSllai (char *)a3, (int64_t *)a4); 2382facf4a8dSllai break; 2383facf4a8dSllai 2384e37c6c37Scth case MODDEVEMPTYDIR: /* non-reconfiguring /dev emptydir */ 2385e37c6c37Scth error = modctl_devemptydir((const char *)a1, (size_t)a2, 2386e37c6c37Scth (int *)a3); 2387e37c6c37Scth break; 2388e37c6c37Scth 2389facf4a8dSllai case MODDEVNAME: 2390facf4a8dSllai error = modctl_moddevname((int)a1, a2, a3); 2391facf4a8dSllai break; 2392facf4a8dSllai 239325e8c5aaSvikram case MODRETIRE: /* retire device named by physpath a1 */ 239425e8c5aaSvikram error = modctl_retire((char *)a1, (char *)a2, (size_t)a3); 239525e8c5aaSvikram break; 239625e8c5aaSvikram 239725e8c5aaSvikram case MODISRETIRED: /* check if a device is retired. */ 239825e8c5aaSvikram error = modctl_is_retired((char *)a1, (int *)a2); 239925e8c5aaSvikram break; 240025e8c5aaSvikram 240125e8c5aaSvikram case MODUNRETIRE: /* unretire device named by physpath a1 */ 240225e8c5aaSvikram error = modctl_unretire((char *)a1); 240325e8c5aaSvikram break; 240425e8c5aaSvikram 24057c478bd9Sstevel@tonic-gate default: 24067c478bd9Sstevel@tonic-gate error = EINVAL; 24077c478bd9Sstevel@tonic-gate break; 24087c478bd9Sstevel@tonic-gate } 24097c478bd9Sstevel@tonic-gate 24107c478bd9Sstevel@tonic-gate return (error ? set_errno(error) : 0); 24117c478bd9Sstevel@tonic-gate } 24127c478bd9Sstevel@tonic-gate 24137c478bd9Sstevel@tonic-gate /* 24147c478bd9Sstevel@tonic-gate * Calls to kobj_load_module()() are handled off to this routine in a 24157c478bd9Sstevel@tonic-gate * separate thread. 24167c478bd9Sstevel@tonic-gate */ 24177c478bd9Sstevel@tonic-gate static void 24187c478bd9Sstevel@tonic-gate modload_thread(struct loadmt *ltp) 24197c478bd9Sstevel@tonic-gate { 24207c478bd9Sstevel@tonic-gate /* load the module and signal the creator of this thread */ 24217c478bd9Sstevel@tonic-gate kmutex_t cpr_lk; 24227c478bd9Sstevel@tonic-gate callb_cpr_t cpr_i; 24237c478bd9Sstevel@tonic-gate 24247c478bd9Sstevel@tonic-gate mutex_init(&cpr_lk, NULL, MUTEX_DEFAULT, NULL); 24257c478bd9Sstevel@tonic-gate CALLB_CPR_INIT(&cpr_i, &cpr_lk, callb_generic_cpr, "modload"); 24267c478bd9Sstevel@tonic-gate /* borrow the devi lock from thread which invoked us */ 24277c478bd9Sstevel@tonic-gate pm_borrow_lock(ltp->owner); 24287c478bd9Sstevel@tonic-gate ltp->retval = kobj_load_module(ltp->mp, ltp->usepath); 24297c478bd9Sstevel@tonic-gate pm_return_lock(); 24307c478bd9Sstevel@tonic-gate sema_v(<p->sema); 24317c478bd9Sstevel@tonic-gate mutex_enter(&cpr_lk); 24327c478bd9Sstevel@tonic-gate CALLB_CPR_EXIT(&cpr_i); 24337c478bd9Sstevel@tonic-gate mutex_destroy(&cpr_lk); 24347c478bd9Sstevel@tonic-gate thread_exit(); 24357c478bd9Sstevel@tonic-gate } 24367c478bd9Sstevel@tonic-gate 24377c478bd9Sstevel@tonic-gate /* 24387c478bd9Sstevel@tonic-gate * load a module, adding a reference if caller specifies rmodp. If rmodp 24397c478bd9Sstevel@tonic-gate * is specified then an errno is returned, otherwise a module index is 24407c478bd9Sstevel@tonic-gate * returned (-1 on error). 24417c478bd9Sstevel@tonic-gate */ 24427c478bd9Sstevel@tonic-gate static int 244343d5cd3dSjohnlev modrload(const char *subdir, const char *filename, struct modctl **rmodp) 24447c478bd9Sstevel@tonic-gate { 24457c478bd9Sstevel@tonic-gate struct modctl *modp; 24467c478bd9Sstevel@tonic-gate size_t size; 24477c478bd9Sstevel@tonic-gate char *fullname; 24487c478bd9Sstevel@tonic-gate int retval = EINVAL; 24497c478bd9Sstevel@tonic-gate int id = -1; 24507c478bd9Sstevel@tonic-gate 24517c478bd9Sstevel@tonic-gate if (rmodp) 24527c478bd9Sstevel@tonic-gate *rmodp = NULL; /* avoid garbage */ 24537c478bd9Sstevel@tonic-gate 24547c478bd9Sstevel@tonic-gate if (subdir != NULL) { 24557c478bd9Sstevel@tonic-gate /* 24567c478bd9Sstevel@tonic-gate * refuse / in filename to prevent "../" escapes. 24577c478bd9Sstevel@tonic-gate */ 24587c478bd9Sstevel@tonic-gate if (strchr(filename, '/') != NULL) 24597c478bd9Sstevel@tonic-gate return (rmodp ? retval : id); 24607c478bd9Sstevel@tonic-gate 24617c478bd9Sstevel@tonic-gate /* 24627c478bd9Sstevel@tonic-gate * allocate enough space for <subdir>/<filename><NULL> 24637c478bd9Sstevel@tonic-gate */ 24647c478bd9Sstevel@tonic-gate size = strlen(subdir) + strlen(filename) + 2; 24657c478bd9Sstevel@tonic-gate fullname = kmem_zalloc(size, KM_SLEEP); 24667c478bd9Sstevel@tonic-gate (void) sprintf(fullname, "%s/%s", subdir, filename); 24677c478bd9Sstevel@tonic-gate } else { 246843d5cd3dSjohnlev fullname = (char *)filename; 24697c478bd9Sstevel@tonic-gate } 24707c478bd9Sstevel@tonic-gate 247120c794b3Sgavinm modp = mod_hold_installed_mod(fullname, 1, 0, &retval); 24727c478bd9Sstevel@tonic-gate if (modp != NULL) { 24737c478bd9Sstevel@tonic-gate id = modp->mod_id; 24747c478bd9Sstevel@tonic-gate if (rmodp) { 24757c478bd9Sstevel@tonic-gate /* add mod_ref and return *rmodp */ 24767c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 24777c478bd9Sstevel@tonic-gate modp->mod_ref++; 24787c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 24797c478bd9Sstevel@tonic-gate *rmodp = modp; 24807c478bd9Sstevel@tonic-gate } 24817c478bd9Sstevel@tonic-gate mod_release_mod(modp); 24827c478bd9Sstevel@tonic-gate CPU_STATS_ADDQ(CPU, sys, modload, 1); 24837c478bd9Sstevel@tonic-gate } 24847c478bd9Sstevel@tonic-gate 24857c478bd9Sstevel@tonic-gate done: if (subdir != NULL) 24867c478bd9Sstevel@tonic-gate kmem_free(fullname, size); 24877c478bd9Sstevel@tonic-gate return (rmodp ? retval : id); 24887c478bd9Sstevel@tonic-gate } 24897c478bd9Sstevel@tonic-gate 24907c478bd9Sstevel@tonic-gate /* 24917c478bd9Sstevel@tonic-gate * This is the primary kernel interface to load a module. It loads and 24927c478bd9Sstevel@tonic-gate * installs the named module. It does not hold mod_ref of the module, so 24937c478bd9Sstevel@tonic-gate * a module unload attempt can occur at any time - it is up to the 24947c478bd9Sstevel@tonic-gate * _fini/mod_remove implementation to determine if unload will succeed. 24957c478bd9Sstevel@tonic-gate */ 24967c478bd9Sstevel@tonic-gate int 249743d5cd3dSjohnlev modload(const char *subdir, const char *filename) 24987c478bd9Sstevel@tonic-gate { 24997c478bd9Sstevel@tonic-gate return (modrload(subdir, filename, NULL)); 25007c478bd9Sstevel@tonic-gate } 25017c478bd9Sstevel@tonic-gate 25027aec1d6eScindi /* 25037aec1d6eScindi * Load a module using a series of qualified names from most specific to least 25047aec1d6eScindi * specific, e.g. for subdir "foo", p1 "bar", p2 "baz", we might try: 250520c794b3Sgavinm * Value returned in *chosen 250620c794b3Sgavinm * foo/bar.baz.1.2.3 3 250720c794b3Sgavinm * foo/bar.baz.1.2 2 250820c794b3Sgavinm * foo/bar.baz.1 1 250920c794b3Sgavinm * foo/bar.baz 0 25107aec1d6eScindi * 251120c794b3Sgavinm * Return the module ID on success; -1 if no module was loaded. On success 251220c794b3Sgavinm * and if 'chosen' is not NULL we also return the number of suffices that 251320c794b3Sgavinm * were in the module we chose to load. 25147aec1d6eScindi */ 25157aec1d6eScindi int 25167aec1d6eScindi modload_qualified(const char *subdir, const char *p1, 251720c794b3Sgavinm const char *p2, const char *delim, uint_t suffv[], int suffc, int *chosen) 25187aec1d6eScindi { 25197aec1d6eScindi char path[MOD_MAXPATH]; 25207aec1d6eScindi size_t n, resid = sizeof (path); 25217aec1d6eScindi char *p = path; 25227aec1d6eScindi 25237aec1d6eScindi char **dotv; 25247aec1d6eScindi int i, rc, id; 25257aec1d6eScindi modctl_t *mp; 25267aec1d6eScindi 25277aec1d6eScindi if (p2 != NULL) 25287aec1d6eScindi n = snprintf(p, resid, "%s/%s%s%s", subdir, p1, delim, p2); 25297aec1d6eScindi else 25307aec1d6eScindi n = snprintf(p, resid, "%s/%s", subdir, p1); 25317aec1d6eScindi 25327aec1d6eScindi if (n >= resid) 25337aec1d6eScindi return (-1); 25347aec1d6eScindi 25357aec1d6eScindi p += n; 25367aec1d6eScindi resid -= n; 25377aec1d6eScindi dotv = kmem_alloc(sizeof (char *) * (suffc + 1), KM_SLEEP); 25387aec1d6eScindi 25397aec1d6eScindi for (i = 0; i < suffc; i++) { 25407aec1d6eScindi dotv[i] = p; 25417aec1d6eScindi n = snprintf(p, resid, "%s%u", delim, suffv[i]); 25427aec1d6eScindi 25437aec1d6eScindi if (n >= resid) { 25447aec1d6eScindi kmem_free(dotv, sizeof (char *) * (suffc + 1)); 25457aec1d6eScindi return (-1); 25467aec1d6eScindi } 25477aec1d6eScindi 25487aec1d6eScindi p += n; 25497aec1d6eScindi resid -= n; 25507aec1d6eScindi } 25517aec1d6eScindi 25527aec1d6eScindi dotv[suffc] = p; 25537aec1d6eScindi 25547aec1d6eScindi for (i = suffc; i >= 0; i--) { 25557aec1d6eScindi dotv[i][0] = '\0'; 255620c794b3Sgavinm mp = mod_hold_installed_mod(path, 1, 1, &rc); 25577aec1d6eScindi 25587aec1d6eScindi if (mp != NULL) { 25597aec1d6eScindi kmem_free(dotv, sizeof (char *) * (suffc + 1)); 25607aec1d6eScindi id = mp->mod_id; 25617aec1d6eScindi mod_release_mod(mp); 256220c794b3Sgavinm if (chosen != NULL) 256320c794b3Sgavinm *chosen = i; 25647aec1d6eScindi return (id); 25657aec1d6eScindi } 25667aec1d6eScindi } 25677aec1d6eScindi 25687aec1d6eScindi kmem_free(dotv, sizeof (char *) * (suffc + 1)); 25697aec1d6eScindi return (-1); 25707aec1d6eScindi } 25717aec1d6eScindi 25727c478bd9Sstevel@tonic-gate /* 25737c478bd9Sstevel@tonic-gate * Load a module. 25747c478bd9Sstevel@tonic-gate */ 25757c478bd9Sstevel@tonic-gate int 257643d5cd3dSjohnlev modloadonly(const char *subdir, const char *filename) 25777c478bd9Sstevel@tonic-gate { 25787c478bd9Sstevel@tonic-gate struct modctl *modp; 25797c478bd9Sstevel@tonic-gate char *fullname; 25807c478bd9Sstevel@tonic-gate size_t size; 25817c478bd9Sstevel@tonic-gate int id, retval; 25827c478bd9Sstevel@tonic-gate 25837c478bd9Sstevel@tonic-gate if (subdir != NULL) { 25847c478bd9Sstevel@tonic-gate /* 25857c478bd9Sstevel@tonic-gate * allocate enough space for <subdir>/<filename><NULL> 25867c478bd9Sstevel@tonic-gate */ 25877c478bd9Sstevel@tonic-gate size = strlen(subdir) + strlen(filename) + 2; 25887c478bd9Sstevel@tonic-gate fullname = kmem_zalloc(size, KM_SLEEP); 25897c478bd9Sstevel@tonic-gate (void) sprintf(fullname, "%s/%s", subdir, filename); 25907c478bd9Sstevel@tonic-gate } else { 259143d5cd3dSjohnlev fullname = (char *)filename; 25927c478bd9Sstevel@tonic-gate } 25937c478bd9Sstevel@tonic-gate 25947c478bd9Sstevel@tonic-gate modp = mod_hold_loaded_mod(NULL, fullname, &retval); 25957c478bd9Sstevel@tonic-gate if (modp) { 25967c478bd9Sstevel@tonic-gate id = modp->mod_id; 25977c478bd9Sstevel@tonic-gate mod_release_mod(modp); 25987c478bd9Sstevel@tonic-gate } 25997c478bd9Sstevel@tonic-gate 26007c478bd9Sstevel@tonic-gate if (subdir != NULL) 26017c478bd9Sstevel@tonic-gate kmem_free(fullname, size); 26027c478bd9Sstevel@tonic-gate 26037c478bd9Sstevel@tonic-gate if (retval == 0) 26047c478bd9Sstevel@tonic-gate return (id); 26057c478bd9Sstevel@tonic-gate return (-1); 26067c478bd9Sstevel@tonic-gate } 26077c478bd9Sstevel@tonic-gate 26087c478bd9Sstevel@tonic-gate /* 26097c478bd9Sstevel@tonic-gate * Try to uninstall and unload a module, removing a reference if caller 26107c478bd9Sstevel@tonic-gate * specifies rmodp. 26117c478bd9Sstevel@tonic-gate */ 26127c478bd9Sstevel@tonic-gate static int 26137c478bd9Sstevel@tonic-gate modunrload(modid_t id, struct modctl **rmodp, int unload) 26147c478bd9Sstevel@tonic-gate { 26157c478bd9Sstevel@tonic-gate struct modctl *modp; 26167c478bd9Sstevel@tonic-gate int retval; 26177c478bd9Sstevel@tonic-gate 26187c478bd9Sstevel@tonic-gate if (rmodp) 26197c478bd9Sstevel@tonic-gate *rmodp = NULL; /* avoid garbage */ 26207c478bd9Sstevel@tonic-gate 26217c478bd9Sstevel@tonic-gate if ((modp = mod_hold_by_id((modid_t)id)) == NULL) 26227c478bd9Sstevel@tonic-gate return (EINVAL); 26237c478bd9Sstevel@tonic-gate 26247c478bd9Sstevel@tonic-gate if (rmodp) { 26257c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 26267c478bd9Sstevel@tonic-gate modp->mod_ref--; 26277c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 26287c478bd9Sstevel@tonic-gate *rmodp = modp; 26297c478bd9Sstevel@tonic-gate } 26307c478bd9Sstevel@tonic-gate 26317c478bd9Sstevel@tonic-gate if (unload) { 26327c478bd9Sstevel@tonic-gate retval = moduninstall(modp); 26337c478bd9Sstevel@tonic-gate if (retval == 0) { 26347c478bd9Sstevel@tonic-gate mod_unload(modp); 26357c478bd9Sstevel@tonic-gate CPU_STATS_ADDQ(CPU, sys, modunload, 1); 26367c478bd9Sstevel@tonic-gate } else if (retval == EALREADY) 26377c478bd9Sstevel@tonic-gate retval = 0; /* already unloaded, not an error */ 26387c478bd9Sstevel@tonic-gate } else 26397c478bd9Sstevel@tonic-gate retval = 0; 26407c478bd9Sstevel@tonic-gate 26417c478bd9Sstevel@tonic-gate mod_release_mod(modp); 26427c478bd9Sstevel@tonic-gate return (retval); 26437c478bd9Sstevel@tonic-gate } 26447c478bd9Sstevel@tonic-gate 26457c478bd9Sstevel@tonic-gate /* 26467c478bd9Sstevel@tonic-gate * Uninstall and unload a module. 26477c478bd9Sstevel@tonic-gate */ 26487c478bd9Sstevel@tonic-gate int 26497c478bd9Sstevel@tonic-gate modunload(modid_t id) 26507c478bd9Sstevel@tonic-gate { 2651a7aa4df7Scth int retval; 2652a7aa4df7Scth 2653a7aa4df7Scth /* synchronize with any active modunload_disable() */ 2654a7aa4df7Scth modunload_begin(); 2655a7aa4df7Scth if (ddi_root_node()) 2656a7aa4df7Scth (void) devfs_clean(ddi_root_node(), NULL, 0); 2657a7aa4df7Scth retval = modunrload(id, NULL, 1); 2658a7aa4df7Scth modunload_end(); 2659a7aa4df7Scth return (retval); 26607c478bd9Sstevel@tonic-gate } 26617c478bd9Sstevel@tonic-gate 26627c478bd9Sstevel@tonic-gate /* 26637c478bd9Sstevel@tonic-gate * Return status of a loaded module. 26647c478bd9Sstevel@tonic-gate */ 26657c478bd9Sstevel@tonic-gate static int 26667c478bd9Sstevel@tonic-gate modinfo(modid_t id, struct modinfo *modinfop) 26677c478bd9Sstevel@tonic-gate { 26687c478bd9Sstevel@tonic-gate struct modctl *modp; 26697c478bd9Sstevel@tonic-gate modid_t mid; 26707c478bd9Sstevel@tonic-gate int i; 26717c478bd9Sstevel@tonic-gate 26727c478bd9Sstevel@tonic-gate mid = modinfop->mi_id; 26737c478bd9Sstevel@tonic-gate if (modinfop->mi_info & MI_INFO_ALL) { 26747c478bd9Sstevel@tonic-gate while ((modp = mod_hold_next_by_id(mid++)) != NULL) { 26757c478bd9Sstevel@tonic-gate if ((modinfop->mi_info & MI_INFO_CNT) || 26767c478bd9Sstevel@tonic-gate modp->mod_installed) 26777c478bd9Sstevel@tonic-gate break; 26787c478bd9Sstevel@tonic-gate mod_release_mod(modp); 26797c478bd9Sstevel@tonic-gate } 26807c478bd9Sstevel@tonic-gate if (modp == NULL) 26817c478bd9Sstevel@tonic-gate return (EINVAL); 26827c478bd9Sstevel@tonic-gate } else { 26837c478bd9Sstevel@tonic-gate modp = mod_hold_by_id(id); 26847c478bd9Sstevel@tonic-gate if (modp == NULL) 26857c478bd9Sstevel@tonic-gate return (EINVAL); 26867c478bd9Sstevel@tonic-gate if (!(modinfop->mi_info & MI_INFO_CNT) && 26877c478bd9Sstevel@tonic-gate (modp->mod_installed == 0)) { 26887c478bd9Sstevel@tonic-gate mod_release_mod(modp); 26897c478bd9Sstevel@tonic-gate return (EINVAL); 26907c478bd9Sstevel@tonic-gate } 26917c478bd9Sstevel@tonic-gate } 26927c478bd9Sstevel@tonic-gate 26937c478bd9Sstevel@tonic-gate modinfop->mi_rev = 0; 26947c478bd9Sstevel@tonic-gate modinfop->mi_state = 0; 26957c478bd9Sstevel@tonic-gate for (i = 0; i < MODMAXLINK; i++) { 26967c478bd9Sstevel@tonic-gate modinfop->mi_msinfo[i].msi_p0 = -1; 26977c478bd9Sstevel@tonic-gate modinfop->mi_msinfo[i].msi_linkinfo[0] = 0; 26987c478bd9Sstevel@tonic-gate } 26997c478bd9Sstevel@tonic-gate if (modp->mod_loaded) { 27007c478bd9Sstevel@tonic-gate modinfop->mi_state = MI_LOADED; 27017c478bd9Sstevel@tonic-gate kobj_getmodinfo(modp->mod_mp, modinfop); 27027c478bd9Sstevel@tonic-gate } 27037c478bd9Sstevel@tonic-gate if (modp->mod_installed) { 27047c478bd9Sstevel@tonic-gate modinfop->mi_state |= MI_INSTALLED; 27057c478bd9Sstevel@tonic-gate 27067c478bd9Sstevel@tonic-gate (void) mod_getinfo(modp, modinfop); 27077c478bd9Sstevel@tonic-gate } 27087c478bd9Sstevel@tonic-gate 27097c478bd9Sstevel@tonic-gate modinfop->mi_id = modp->mod_id; 27107c478bd9Sstevel@tonic-gate modinfop->mi_loadcnt = modp->mod_loadcnt; 27117c478bd9Sstevel@tonic-gate (void) strcpy(modinfop->mi_name, modp->mod_modname); 27127c478bd9Sstevel@tonic-gate 27137c478bd9Sstevel@tonic-gate mod_release_mod(modp); 27147c478bd9Sstevel@tonic-gate return (0); 27157c478bd9Sstevel@tonic-gate } 27167c478bd9Sstevel@tonic-gate 27177c478bd9Sstevel@tonic-gate static char mod_stub_err[] = "mod_hold_stub: Couldn't load stub module %s"; 27187c478bd9Sstevel@tonic-gate static char no_err[] = "No error function for weak stub %s"; 27197c478bd9Sstevel@tonic-gate 27207c478bd9Sstevel@tonic-gate /* 27217c478bd9Sstevel@tonic-gate * used by the stubs themselves to load and hold a module. 27227c478bd9Sstevel@tonic-gate * Returns 0 if the module is successfully held; 27237c478bd9Sstevel@tonic-gate * the stub needs to call mod_release_stub(). 27247c478bd9Sstevel@tonic-gate * -1 if the stub should just call the err_fcn. 27257c478bd9Sstevel@tonic-gate * Note that this code is stretched out so that we avoid subroutine calls 27267c478bd9Sstevel@tonic-gate * and optimize for the most likely case. That is, the case where the 27277c478bd9Sstevel@tonic-gate * module is loaded and installed and not held. In that case we just inc 27287c478bd9Sstevel@tonic-gate * the mod_ref count and continue. 27297c478bd9Sstevel@tonic-gate */ 27307c478bd9Sstevel@tonic-gate int 27317c478bd9Sstevel@tonic-gate mod_hold_stub(struct mod_stub_info *stub) 27327c478bd9Sstevel@tonic-gate { 27337c478bd9Sstevel@tonic-gate struct modctl *mp; 27347c478bd9Sstevel@tonic-gate struct mod_modinfo *mip; 27357c478bd9Sstevel@tonic-gate 27367c478bd9Sstevel@tonic-gate mip = stub->mods_modinfo; 27377c478bd9Sstevel@tonic-gate 27387c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 27397c478bd9Sstevel@tonic-gate 27407c478bd9Sstevel@tonic-gate /* we do mod_hold_by_modctl inline for speed */ 27417c478bd9Sstevel@tonic-gate 27427c478bd9Sstevel@tonic-gate mod_check_again: 27437c478bd9Sstevel@tonic-gate if ((mp = mip->mp) != NULL) { 27447c478bd9Sstevel@tonic-gate if (mp->mod_busy == 0) { 27457c478bd9Sstevel@tonic-gate if (mp->mod_installed) { 27467c478bd9Sstevel@tonic-gate /* increment the reference count */ 27477c478bd9Sstevel@tonic-gate mp->mod_ref++; 27487c478bd9Sstevel@tonic-gate ASSERT(mp->mod_ref && mp->mod_installed); 27497c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 27507c478bd9Sstevel@tonic-gate return (0); 27517c478bd9Sstevel@tonic-gate } else { 27527c478bd9Sstevel@tonic-gate mp->mod_busy = 1; 27537c478bd9Sstevel@tonic-gate mp->mod_inprogress_thread = 27547c478bd9Sstevel@tonic-gate (curthread == NULL ? 27557c478bd9Sstevel@tonic-gate (kthread_id_t)-1 : curthread); 27567c478bd9Sstevel@tonic-gate } 27577c478bd9Sstevel@tonic-gate } else { 27587c478bd9Sstevel@tonic-gate /* 27597c478bd9Sstevel@tonic-gate * wait one time and then go see if someone 27607c478bd9Sstevel@tonic-gate * else has resolved the stub (set mip->mp). 27617c478bd9Sstevel@tonic-gate */ 27627c478bd9Sstevel@tonic-gate if (mod_hold_by_modctl(mp, 27637c478bd9Sstevel@tonic-gate MOD_WAIT_ONCE | MOD_LOCK_HELD)) 27647c478bd9Sstevel@tonic-gate goto mod_check_again; 27657c478bd9Sstevel@tonic-gate 27667c478bd9Sstevel@tonic-gate /* 27677c478bd9Sstevel@tonic-gate * what we have now may have been unloaded!, in 27687c478bd9Sstevel@tonic-gate * that case, mip->mp will be NULL, we'll hit this 27697c478bd9Sstevel@tonic-gate * module and load again.. 27707c478bd9Sstevel@tonic-gate */ 27717c478bd9Sstevel@tonic-gate cmn_err(CE_PANIC, "mod_hold_stub should have blocked"); 27727c478bd9Sstevel@tonic-gate } 27737c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 27747c478bd9Sstevel@tonic-gate } else { 27757c478bd9Sstevel@tonic-gate /* first time we've hit this module */ 27767c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 27777c478bd9Sstevel@tonic-gate mp = mod_hold_by_name(mip->modm_module_name); 27787c478bd9Sstevel@tonic-gate mip->mp = mp; 27797c478bd9Sstevel@tonic-gate } 27807c478bd9Sstevel@tonic-gate 27817c478bd9Sstevel@tonic-gate /* 27827c478bd9Sstevel@tonic-gate * If we are here, it means that the following conditions 27837c478bd9Sstevel@tonic-gate * are satisfied. 27847c478bd9Sstevel@tonic-gate * 27857c478bd9Sstevel@tonic-gate * mip->mp != NULL 27867c478bd9Sstevel@tonic-gate * this thread has set the mp->mod_busy = 1 27877c478bd9Sstevel@tonic-gate * mp->mod_installed = 0 27887c478bd9Sstevel@tonic-gate * 27897c478bd9Sstevel@tonic-gate */ 27907c478bd9Sstevel@tonic-gate ASSERT(mp != NULL); 27917c478bd9Sstevel@tonic-gate ASSERT(mp->mod_busy == 1); 27927c478bd9Sstevel@tonic-gate 27937c478bd9Sstevel@tonic-gate if (mp->mod_installed == 0) { 27947c478bd9Sstevel@tonic-gate /* Module not loaded, if weak stub don't load it */ 27957c478bd9Sstevel@tonic-gate if (stub->mods_flag & MODS_WEAK) { 27967c478bd9Sstevel@tonic-gate if (stub->mods_errfcn == NULL) { 27977c478bd9Sstevel@tonic-gate mod_release_mod(mp); 27987c478bd9Sstevel@tonic-gate cmn_err(CE_PANIC, no_err, 27997c478bd9Sstevel@tonic-gate mip->modm_module_name); 28007c478bd9Sstevel@tonic-gate } 28017c478bd9Sstevel@tonic-gate } else { 28027c478bd9Sstevel@tonic-gate /* Not a weak stub so load the module */ 28037c478bd9Sstevel@tonic-gate 28047c478bd9Sstevel@tonic-gate if (mod_load(mp, 1) != 0 || modinstall(mp) != 0) { 28057c478bd9Sstevel@tonic-gate /* 28067c478bd9Sstevel@tonic-gate * If mod_load() was successful 28077c478bd9Sstevel@tonic-gate * and modinstall() failed, then 28087c478bd9Sstevel@tonic-gate * unload the module. 28097c478bd9Sstevel@tonic-gate */ 28107c478bd9Sstevel@tonic-gate if (mp->mod_loaded) 28117c478bd9Sstevel@tonic-gate mod_unload(mp); 28127c478bd9Sstevel@tonic-gate 28137c478bd9Sstevel@tonic-gate mod_release_mod(mp); 28147c478bd9Sstevel@tonic-gate if (stub->mods_errfcn == NULL) { 28157c478bd9Sstevel@tonic-gate cmn_err(CE_PANIC, mod_stub_err, 28167c478bd9Sstevel@tonic-gate mip->modm_module_name); 28177c478bd9Sstevel@tonic-gate } else { 28187c478bd9Sstevel@tonic-gate return (-1); 28197c478bd9Sstevel@tonic-gate } 28207c478bd9Sstevel@tonic-gate } 28217c478bd9Sstevel@tonic-gate } 28227c478bd9Sstevel@tonic-gate } 28237c478bd9Sstevel@tonic-gate 28247c478bd9Sstevel@tonic-gate /* 28257c478bd9Sstevel@tonic-gate * At this point module is held and loaded. Release 28267c478bd9Sstevel@tonic-gate * the mod_busy and mod_inprogress_thread before 28277c478bd9Sstevel@tonic-gate * returning. We actually call mod_release() here so 28287c478bd9Sstevel@tonic-gate * that if another stub wants to access this module, 28297c478bd9Sstevel@tonic-gate * it can do so. mod_ref is incremented before mod_release() 28307c478bd9Sstevel@tonic-gate * is called to prevent someone else from snatching the 28317c478bd9Sstevel@tonic-gate * module from this thread. 28327c478bd9Sstevel@tonic-gate */ 28337c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 28347c478bd9Sstevel@tonic-gate mp->mod_ref++; 28357c478bd9Sstevel@tonic-gate ASSERT(mp->mod_ref && 28367c478bd9Sstevel@tonic-gate (mp->mod_loaded || (stub->mods_flag & MODS_WEAK))); 28377c478bd9Sstevel@tonic-gate mod_release(mp); 28387c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 28397c478bd9Sstevel@tonic-gate return (0); 28407c478bd9Sstevel@tonic-gate } 28417c478bd9Sstevel@tonic-gate 28427c478bd9Sstevel@tonic-gate void 28437c478bd9Sstevel@tonic-gate mod_release_stub(struct mod_stub_info *stub) 28447c478bd9Sstevel@tonic-gate { 28457c478bd9Sstevel@tonic-gate struct modctl *mp = stub->mods_modinfo->mp; 28467c478bd9Sstevel@tonic-gate 28477c478bd9Sstevel@tonic-gate /* inline mod_release_mod */ 28487c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 28497c478bd9Sstevel@tonic-gate ASSERT(mp->mod_ref && 28507c478bd9Sstevel@tonic-gate (mp->mod_loaded || (stub->mods_flag & MODS_WEAK))); 28517c478bd9Sstevel@tonic-gate mp->mod_ref--; 28527c478bd9Sstevel@tonic-gate if (mp->mod_want) { 28537c478bd9Sstevel@tonic-gate mp->mod_want = 0; 28547c478bd9Sstevel@tonic-gate cv_broadcast(&mod_cv); 28557c478bd9Sstevel@tonic-gate } 28567c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 28577c478bd9Sstevel@tonic-gate } 28587c478bd9Sstevel@tonic-gate 28597c478bd9Sstevel@tonic-gate static struct modctl * 28607c478bd9Sstevel@tonic-gate mod_hold_loaded_mod(struct modctl *dep, char *filename, int *status) 28617c478bd9Sstevel@tonic-gate { 28627c478bd9Sstevel@tonic-gate struct modctl *modp; 28637c478bd9Sstevel@tonic-gate int retval; 28647c478bd9Sstevel@tonic-gate 28657c478bd9Sstevel@tonic-gate /* 28667c478bd9Sstevel@tonic-gate * Hold the module. 28677c478bd9Sstevel@tonic-gate */ 28687c478bd9Sstevel@tonic-gate modp = mod_hold_by_name_requisite(dep, filename); 28697c478bd9Sstevel@tonic-gate if (modp) { 28707c478bd9Sstevel@tonic-gate retval = mod_load(modp, 1); 28717c478bd9Sstevel@tonic-gate if (retval != 0) { 28727c478bd9Sstevel@tonic-gate mod_release_mod(modp); 28737c478bd9Sstevel@tonic-gate modp = NULL; 28747c478bd9Sstevel@tonic-gate } 28757c478bd9Sstevel@tonic-gate *status = retval; 28767c478bd9Sstevel@tonic-gate } else { 28777c478bd9Sstevel@tonic-gate *status = ENOSPC; 28787c478bd9Sstevel@tonic-gate } 28797c478bd9Sstevel@tonic-gate 28807c478bd9Sstevel@tonic-gate /* 28817c478bd9Sstevel@tonic-gate * if dep is not NULL, clear the module dependency information. 28827c478bd9Sstevel@tonic-gate * This information is set in mod_hold_by_name_common(). 28837c478bd9Sstevel@tonic-gate */ 28847c478bd9Sstevel@tonic-gate if (dep != NULL && dep->mod_requisite_loading != NULL) { 28857c478bd9Sstevel@tonic-gate ASSERT(dep->mod_busy); 28867c478bd9Sstevel@tonic-gate dep->mod_requisite_loading = NULL; 28877c478bd9Sstevel@tonic-gate } 28887c478bd9Sstevel@tonic-gate 28897c478bd9Sstevel@tonic-gate return (modp); 28907c478bd9Sstevel@tonic-gate } 28917c478bd9Sstevel@tonic-gate 28927c478bd9Sstevel@tonic-gate /* 28937c478bd9Sstevel@tonic-gate * hold, load, and install the named module 28947c478bd9Sstevel@tonic-gate */ 28957c478bd9Sstevel@tonic-gate static struct modctl * 289620c794b3Sgavinm mod_hold_installed_mod(char *name, int usepath, int forcecheck, int *r) 28977c478bd9Sstevel@tonic-gate { 28987c478bd9Sstevel@tonic-gate struct modctl *modp; 28997c478bd9Sstevel@tonic-gate int retval; 29002bac1547Scth 29012bac1547Scth /* 29022bac1547Scth * Verify that that module in question actually exists on disk 29032bac1547Scth * before allocation of module structure by mod_hold_by_name. 29042bac1547Scth */ 290520c794b3Sgavinm if (modrootloaded && swaploaded || forcecheck) { 29065c311300Scth if (!kobj_path_exists(name, usepath)) { 29072bac1547Scth *r = ENOENT; 29082bac1547Scth return (NULL); 29092bac1547Scth } 29102bac1547Scth } 29117c478bd9Sstevel@tonic-gate 29127c478bd9Sstevel@tonic-gate /* 29137c478bd9Sstevel@tonic-gate * Hold the module. 29147c478bd9Sstevel@tonic-gate */ 29157c478bd9Sstevel@tonic-gate modp = mod_hold_by_name(name); 29167c478bd9Sstevel@tonic-gate if (modp) { 29177c478bd9Sstevel@tonic-gate retval = mod_load(modp, usepath); 29187c478bd9Sstevel@tonic-gate if (retval != 0) { 29197c478bd9Sstevel@tonic-gate mod_release_mod(modp); 29207c478bd9Sstevel@tonic-gate modp = NULL; 29217c478bd9Sstevel@tonic-gate *r = retval; 29227c478bd9Sstevel@tonic-gate } else { 29237c478bd9Sstevel@tonic-gate if ((*r = modinstall(modp)) != 0) { 29247c478bd9Sstevel@tonic-gate /* 29257c478bd9Sstevel@tonic-gate * We loaded it, but failed to _init() it. 29267c478bd9Sstevel@tonic-gate * Be kind to developers -- force it 29277c478bd9Sstevel@tonic-gate * out of memory now so that the next 29287c478bd9Sstevel@tonic-gate * attempt to use the module will cause 29297c478bd9Sstevel@tonic-gate * a reload. See 1093793. 29307c478bd9Sstevel@tonic-gate */ 29317c478bd9Sstevel@tonic-gate mod_unload(modp); 29327c478bd9Sstevel@tonic-gate mod_release_mod(modp); 29337c478bd9Sstevel@tonic-gate modp = NULL; 29347c478bd9Sstevel@tonic-gate } 29357c478bd9Sstevel@tonic-gate } 29367c478bd9Sstevel@tonic-gate } else { 29377c478bd9Sstevel@tonic-gate *r = ENOSPC; 29387c478bd9Sstevel@tonic-gate } 29397c478bd9Sstevel@tonic-gate return (modp); 29407c478bd9Sstevel@tonic-gate } 29417c478bd9Sstevel@tonic-gate 29427c478bd9Sstevel@tonic-gate static char mod_excl_msg[] = 29437c478bd9Sstevel@tonic-gate "module %s(%s) is EXCLUDED and will not be loaded\n"; 29447c478bd9Sstevel@tonic-gate static char mod_init_msg[] = "loadmodule:%s(%s): _init() error %d\n"; 29457c478bd9Sstevel@tonic-gate 29467c478bd9Sstevel@tonic-gate /* 29477c478bd9Sstevel@tonic-gate * This routine is needed for dependencies. Users specify dependencies 29487c478bd9Sstevel@tonic-gate * by declaring a character array initialized to filenames of dependents. 29497c478bd9Sstevel@tonic-gate * So the code that handles dependents deals with filenames (and not 29507c478bd9Sstevel@tonic-gate * module names) because that's all it has. We load by filename and once 29517c478bd9Sstevel@tonic-gate * we've loaded a file we can get the module name. 29527c478bd9Sstevel@tonic-gate * Unfortunately there isn't a single unified filename/modulename namespace. 29537c478bd9Sstevel@tonic-gate * C'est la vie. 29547c478bd9Sstevel@tonic-gate * 29557c478bd9Sstevel@tonic-gate * We allow the name being looked up to be prepended by an optional 29567c478bd9Sstevel@tonic-gate * subdirectory e.g. we can lookup (NULL, "fs/ufs") or ("fs", "ufs") 29577c478bd9Sstevel@tonic-gate */ 29587c478bd9Sstevel@tonic-gate struct modctl * 29597c478bd9Sstevel@tonic-gate mod_find_by_filename(char *subdir, char *filename) 29607c478bd9Sstevel@tonic-gate { 29617c478bd9Sstevel@tonic-gate struct modctl *mp; 29627c478bd9Sstevel@tonic-gate size_t sublen; 29637c478bd9Sstevel@tonic-gate 29647c478bd9Sstevel@tonic-gate ASSERT(!MUTEX_HELD(&mod_lock)); 29657c478bd9Sstevel@tonic-gate if (subdir != NULL) 29667c478bd9Sstevel@tonic-gate sublen = strlen(subdir); 29677c478bd9Sstevel@tonic-gate else 29687c478bd9Sstevel@tonic-gate sublen = 0; 29697c478bd9Sstevel@tonic-gate 29707c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 29717c478bd9Sstevel@tonic-gate mp = &modules; 29727c478bd9Sstevel@tonic-gate do { 29737c478bd9Sstevel@tonic-gate if (sublen) { 29747c478bd9Sstevel@tonic-gate char *mod_filename = mp->mod_filename; 29757c478bd9Sstevel@tonic-gate 29767c478bd9Sstevel@tonic-gate if (strncmp(subdir, mod_filename, sublen) == 0 && 29777c478bd9Sstevel@tonic-gate mod_filename[sublen] == '/' && 29787c478bd9Sstevel@tonic-gate strcmp(filename, &mod_filename[sublen + 1]) == 0) { 29797c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 29807c478bd9Sstevel@tonic-gate return (mp); 29817c478bd9Sstevel@tonic-gate } 29827c478bd9Sstevel@tonic-gate } else if (strcmp(filename, mp->mod_filename) == 0) { 29837c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 29847c478bd9Sstevel@tonic-gate return (mp); 29857c478bd9Sstevel@tonic-gate } 29867c478bd9Sstevel@tonic-gate } while ((mp = mp->mod_next) != &modules); 29877c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 29887c478bd9Sstevel@tonic-gate return (NULL); 29897c478bd9Sstevel@tonic-gate } 29907c478bd9Sstevel@tonic-gate 29917c478bd9Sstevel@tonic-gate /* 29927c478bd9Sstevel@tonic-gate * Check for circular dependencies. This is called from do_dependents() 29937c478bd9Sstevel@tonic-gate * in kobj.c. If we are the thread already loading this module, then 29947c478bd9Sstevel@tonic-gate * we're trying to load a dependent that we're already loading which 29957c478bd9Sstevel@tonic-gate * means the user specified circular dependencies. 29967c478bd9Sstevel@tonic-gate */ 29977c478bd9Sstevel@tonic-gate static int 29987c478bd9Sstevel@tonic-gate mod_circdep(struct modctl *modp) 29997c478bd9Sstevel@tonic-gate { 30007c478bd9Sstevel@tonic-gate struct modctl *rmod; 30017c478bd9Sstevel@tonic-gate 30027c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&mod_lock)); 30037c478bd9Sstevel@tonic-gate 30047c478bd9Sstevel@tonic-gate /* 30057c478bd9Sstevel@tonic-gate * Check the mod_inprogress_thread first. 30067c478bd9Sstevel@tonic-gate * mod_inprogress_thread is used in mod_hold_stub() 30077c478bd9Sstevel@tonic-gate * directly to improve performance. 30087c478bd9Sstevel@tonic-gate */ 30097c478bd9Sstevel@tonic-gate if (modp->mod_inprogress_thread == curthread) 30107c478bd9Sstevel@tonic-gate return (1); 30117c478bd9Sstevel@tonic-gate 30127c478bd9Sstevel@tonic-gate /* 30137c478bd9Sstevel@tonic-gate * Check the module circular dependencies. 30147c478bd9Sstevel@tonic-gate */ 30157c478bd9Sstevel@tonic-gate for (rmod = modp; rmod != NULL; rmod = rmod->mod_requisite_loading) { 30167c478bd9Sstevel@tonic-gate /* 30177c478bd9Sstevel@tonic-gate * Check if there is a module circular dependency. 30187c478bd9Sstevel@tonic-gate */ 30197c478bd9Sstevel@tonic-gate if (rmod->mod_requisite_loading == modp) 30207c478bd9Sstevel@tonic-gate return (1); 30217c478bd9Sstevel@tonic-gate } 30227c478bd9Sstevel@tonic-gate return (0); 30237c478bd9Sstevel@tonic-gate } 30247c478bd9Sstevel@tonic-gate 30257c478bd9Sstevel@tonic-gate static int 30267c478bd9Sstevel@tonic-gate mod_getinfo(struct modctl *modp, struct modinfo *modinfop) 30277c478bd9Sstevel@tonic-gate { 30287c478bd9Sstevel@tonic-gate int (*func)(struct modinfo *); 30297c478bd9Sstevel@tonic-gate int retval; 30307c478bd9Sstevel@tonic-gate 30317c478bd9Sstevel@tonic-gate ASSERT(modp->mod_busy); 30327c478bd9Sstevel@tonic-gate 30337c478bd9Sstevel@tonic-gate /* primary modules don't do getinfo */ 30347c478bd9Sstevel@tonic-gate if (modp->mod_prim) 30357c478bd9Sstevel@tonic-gate return (0); 30367c478bd9Sstevel@tonic-gate 30377c478bd9Sstevel@tonic-gate func = (int (*)(struct modinfo *))kobj_lookup(modp->mod_mp, "_info"); 30387c478bd9Sstevel@tonic-gate 30397c478bd9Sstevel@tonic-gate if (kobj_addrcheck(modp->mod_mp, (caddr_t)func)) { 30407c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "_info() not defined properly in %s", 30417c478bd9Sstevel@tonic-gate modp->mod_filename); 30427c478bd9Sstevel@tonic-gate /* 30437c478bd9Sstevel@tonic-gate * The semantics of mod_info(9F) are that 0 is failure 30447c478bd9Sstevel@tonic-gate * and non-zero is success. 30457c478bd9Sstevel@tonic-gate */ 30467c478bd9Sstevel@tonic-gate retval = 0; 30477c478bd9Sstevel@tonic-gate } else 30487c478bd9Sstevel@tonic-gate retval = (*func)(modinfop); /* call _info() function */ 30497c478bd9Sstevel@tonic-gate 30507c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_USERDEBUG) 30517c478bd9Sstevel@tonic-gate printf("Returned from _info, retval = %x\n", retval); 30527c478bd9Sstevel@tonic-gate 30537c478bd9Sstevel@tonic-gate return (retval); 30547c478bd9Sstevel@tonic-gate } 30557c478bd9Sstevel@tonic-gate 30567c478bd9Sstevel@tonic-gate static void 30577c478bd9Sstevel@tonic-gate modadd(struct modctl *mp) 30587c478bd9Sstevel@tonic-gate { 30597c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&mod_lock)); 30607c478bd9Sstevel@tonic-gate 30617c478bd9Sstevel@tonic-gate mp->mod_id = last_module_id++; 30627c478bd9Sstevel@tonic-gate mp->mod_next = &modules; 30637c478bd9Sstevel@tonic-gate mp->mod_prev = modules.mod_prev; 30647c478bd9Sstevel@tonic-gate modules.mod_prev->mod_next = mp; 30657c478bd9Sstevel@tonic-gate modules.mod_prev = mp; 30667c478bd9Sstevel@tonic-gate } 30677c478bd9Sstevel@tonic-gate 30687c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 30697c478bd9Sstevel@tonic-gate static struct modctl * 30707aec1d6eScindi allocate_modp(const char *filename, const char *modname) 30717c478bd9Sstevel@tonic-gate { 30727c478bd9Sstevel@tonic-gate struct modctl *mp; 30737c478bd9Sstevel@tonic-gate 30747c478bd9Sstevel@tonic-gate mp = kobj_zalloc(sizeof (*mp), KM_SLEEP); 30757c478bd9Sstevel@tonic-gate mp->mod_modname = kobj_zalloc(strlen(modname) + 1, KM_SLEEP); 30767c478bd9Sstevel@tonic-gate (void) strcpy(mp->mod_modname, modname); 30777c478bd9Sstevel@tonic-gate return (mp); 30787c478bd9Sstevel@tonic-gate } 30797c478bd9Sstevel@tonic-gate 30807c478bd9Sstevel@tonic-gate /* 30817c478bd9Sstevel@tonic-gate * Get the value of a symbol. This is a wrapper routine that 30827c478bd9Sstevel@tonic-gate * calls kobj_getsymvalue(). kobj_getsymvalue() may go away but this 30837c478bd9Sstevel@tonic-gate * wrapper will prevent callers from noticing. 30847c478bd9Sstevel@tonic-gate */ 30857c478bd9Sstevel@tonic-gate uintptr_t 30867c478bd9Sstevel@tonic-gate modgetsymvalue(char *name, int kernelonly) 30877c478bd9Sstevel@tonic-gate { 30887c478bd9Sstevel@tonic-gate return (kobj_getsymvalue(name, kernelonly)); 30897c478bd9Sstevel@tonic-gate } 30907c478bd9Sstevel@tonic-gate 30917c478bd9Sstevel@tonic-gate /* 30927c478bd9Sstevel@tonic-gate * Get the symbol nearest an address. This is a wrapper routine that 30937c478bd9Sstevel@tonic-gate * calls kobj_getsymname(). kobj_getsymname() may go away but this 30947c478bd9Sstevel@tonic-gate * wrapper will prevent callers from noticing. 30957c478bd9Sstevel@tonic-gate */ 30967c478bd9Sstevel@tonic-gate char * 30977c478bd9Sstevel@tonic-gate modgetsymname(uintptr_t value, ulong_t *offset) 30987c478bd9Sstevel@tonic-gate { 30997c478bd9Sstevel@tonic-gate return (kobj_getsymname(value, offset)); 31007c478bd9Sstevel@tonic-gate } 31017c478bd9Sstevel@tonic-gate 31027c478bd9Sstevel@tonic-gate /* 31037aec1d6eScindi * Lookup a symbol in a specified module. These are wrapper routines that 31047aec1d6eScindi * call kobj_lookup(). kobj_lookup() may go away but these wrappers will 31057aec1d6eScindi * prevent callers from noticing. 31067c478bd9Sstevel@tonic-gate */ 31077c478bd9Sstevel@tonic-gate uintptr_t 31087aec1d6eScindi modlookup(const char *modname, const char *symname) 31097c478bd9Sstevel@tonic-gate { 31107c478bd9Sstevel@tonic-gate struct modctl *modp; 31117c478bd9Sstevel@tonic-gate uintptr_t val; 31127c478bd9Sstevel@tonic-gate 31137c478bd9Sstevel@tonic-gate if ((modp = mod_hold_by_name(modname)) == NULL) 31147c478bd9Sstevel@tonic-gate return (0); 31157c478bd9Sstevel@tonic-gate val = kobj_lookup(modp->mod_mp, symname); 31167c478bd9Sstevel@tonic-gate mod_release_mod(modp); 31177c478bd9Sstevel@tonic-gate return (val); 31187c478bd9Sstevel@tonic-gate } 31197c478bd9Sstevel@tonic-gate 31207aec1d6eScindi uintptr_t 31217aec1d6eScindi modlookup_by_modctl(modctl_t *modp, const char *symname) 31227aec1d6eScindi { 31237aec1d6eScindi ASSERT(modp->mod_ref > 0 || modp->mod_busy); 31247aec1d6eScindi 31257aec1d6eScindi return (kobj_lookup(modp->mod_mp, symname)); 31267aec1d6eScindi } 31277aec1d6eScindi 31287c478bd9Sstevel@tonic-gate /* 31297c478bd9Sstevel@tonic-gate * Ask the user for the name of the system file and the default path 31307c478bd9Sstevel@tonic-gate * for modules. 31317c478bd9Sstevel@tonic-gate */ 31327c478bd9Sstevel@tonic-gate void 31337c478bd9Sstevel@tonic-gate mod_askparams() 31347c478bd9Sstevel@tonic-gate { 31357c478bd9Sstevel@tonic-gate static char s0[64]; 31367c478bd9Sstevel@tonic-gate intptr_t fd; 31377c478bd9Sstevel@tonic-gate 31387c478bd9Sstevel@tonic-gate if ((fd = kobj_open(systemfile)) != -1L) 31397c478bd9Sstevel@tonic-gate kobj_close(fd); 31407c478bd9Sstevel@tonic-gate else 31417c478bd9Sstevel@tonic-gate systemfile = NULL; 31427c478bd9Sstevel@tonic-gate 31437c478bd9Sstevel@tonic-gate /*CONSTANTCONDITION*/ 31447c478bd9Sstevel@tonic-gate while (1) { 31457c478bd9Sstevel@tonic-gate printf("Name of system file [%s]: ", 31461e1ddd6cScth systemfile ? systemfile : "/dev/null"); 31477c478bd9Sstevel@tonic-gate 31487c478bd9Sstevel@tonic-gate console_gets(s0, sizeof (s0)); 31497c478bd9Sstevel@tonic-gate 31507c478bd9Sstevel@tonic-gate if (s0[0] == '\0') 31517c478bd9Sstevel@tonic-gate break; 31527c478bd9Sstevel@tonic-gate else if (strcmp(s0, "/dev/null") == 0) { 31537c478bd9Sstevel@tonic-gate systemfile = NULL; 31547c478bd9Sstevel@tonic-gate break; 31557c478bd9Sstevel@tonic-gate } else { 31567c478bd9Sstevel@tonic-gate if ((fd = kobj_open(s0)) != -1L) { 31577c478bd9Sstevel@tonic-gate kobj_close(fd); 31587c478bd9Sstevel@tonic-gate systemfile = s0; 31597c478bd9Sstevel@tonic-gate break; 31607c478bd9Sstevel@tonic-gate } 31617c478bd9Sstevel@tonic-gate } 31627c478bd9Sstevel@tonic-gate printf("can't find file %s\n", s0); 31637c478bd9Sstevel@tonic-gate } 31647c478bd9Sstevel@tonic-gate } 31657c478bd9Sstevel@tonic-gate 31667c478bd9Sstevel@tonic-gate static char loading_msg[] = "loading '%s' id %d\n"; 31677c478bd9Sstevel@tonic-gate static char load_msg[] = "load '%s' id %d loaded @ 0x%p/0x%p size %d/%d\n"; 31687c478bd9Sstevel@tonic-gate 31697c478bd9Sstevel@tonic-gate /* 31707c478bd9Sstevel@tonic-gate * Common code for loading a module (but not installing it). 3171da6c28aaSamw * Handoff the task of module loading to a separate thread 31727c478bd9Sstevel@tonic-gate * with a large stack if possible, since this code may recurse a few times. 31737c478bd9Sstevel@tonic-gate * Return zero if there are no errors or an errno value. 31747c478bd9Sstevel@tonic-gate */ 31757c478bd9Sstevel@tonic-gate static int 31767c478bd9Sstevel@tonic-gate mod_load(struct modctl *mp, int usepath) 31777c478bd9Sstevel@tonic-gate { 31787c478bd9Sstevel@tonic-gate int retval; 31797c478bd9Sstevel@tonic-gate struct modinfo *modinfop = NULL; 31807c478bd9Sstevel@tonic-gate struct loadmt lt; 31817c478bd9Sstevel@tonic-gate 31827c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&mod_lock)); 31837c478bd9Sstevel@tonic-gate ASSERT(mp->mod_busy); 31847c478bd9Sstevel@tonic-gate 31857c478bd9Sstevel@tonic-gate if (mp->mod_loaded) 31867c478bd9Sstevel@tonic-gate return (0); 31877c478bd9Sstevel@tonic-gate 31887c478bd9Sstevel@tonic-gate if (mod_sysctl(SYS_CHECK_EXCLUDE, mp->mod_modname) != 0 || 31897c478bd9Sstevel@tonic-gate mod_sysctl(SYS_CHECK_EXCLUDE, mp->mod_filename) != 0) { 31907c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_LOADMSG) { 31917c478bd9Sstevel@tonic-gate printf(mod_excl_msg, mp->mod_filename, 31921e1ddd6cScth mp->mod_modname); 31937c478bd9Sstevel@tonic-gate } 31947c478bd9Sstevel@tonic-gate return (ENXIO); 31957c478bd9Sstevel@tonic-gate } 31967c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_LOADMSG2) 31977c478bd9Sstevel@tonic-gate printf(loading_msg, mp->mod_filename, mp->mod_id); 31987c478bd9Sstevel@tonic-gate 31997c478bd9Sstevel@tonic-gate if (curthread != &t0) { 32007c478bd9Sstevel@tonic-gate lt.mp = mp; 32017c478bd9Sstevel@tonic-gate lt.usepath = usepath; 32027c478bd9Sstevel@tonic-gate lt.owner = curthread; 32037c478bd9Sstevel@tonic-gate sema_init(<.sema, 0, NULL, SEMA_DEFAULT, NULL); 32047c478bd9Sstevel@tonic-gate 32057c478bd9Sstevel@tonic-gate /* create thread to hand of call to */ 32067c478bd9Sstevel@tonic-gate (void) thread_create(NULL, DEFAULTSTKSZ * 2, 32077c478bd9Sstevel@tonic-gate modload_thread, <, 0, &p0, TS_RUN, maxclsyspri); 32087c478bd9Sstevel@tonic-gate 32097c478bd9Sstevel@tonic-gate /* wait for thread to complete kobj_load_module */ 32107c478bd9Sstevel@tonic-gate sema_p(<.sema); 32117c478bd9Sstevel@tonic-gate 32127c478bd9Sstevel@tonic-gate sema_destroy(<.sema); 32137c478bd9Sstevel@tonic-gate retval = lt.retval; 32147c478bd9Sstevel@tonic-gate } else 32157c478bd9Sstevel@tonic-gate retval = kobj_load_module(mp, usepath); 32167c478bd9Sstevel@tonic-gate 32177c478bd9Sstevel@tonic-gate if (mp->mod_mp) { 32187c478bd9Sstevel@tonic-gate ASSERT(retval == 0); 32197c478bd9Sstevel@tonic-gate mp->mod_loaded = 1; 32207c478bd9Sstevel@tonic-gate mp->mod_loadcnt++; 32217c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_LOADMSG) { 32227c478bd9Sstevel@tonic-gate printf(load_msg, mp->mod_filename, mp->mod_id, 32231e1ddd6cScth (void *)((struct module *)mp->mod_mp)->text, 32241e1ddd6cScth (void *)((struct module *)mp->mod_mp)->data, 32251e1ddd6cScth ((struct module *)mp->mod_mp)->text_size, 32261e1ddd6cScth ((struct module *)mp->mod_mp)->data_size); 32277c478bd9Sstevel@tonic-gate } 32287c478bd9Sstevel@tonic-gate 32297c478bd9Sstevel@tonic-gate /* 32307c478bd9Sstevel@tonic-gate * XXX - There should be a better way to get this. 32317c478bd9Sstevel@tonic-gate */ 32327c478bd9Sstevel@tonic-gate modinfop = kmem_zalloc(sizeof (struct modinfo), KM_SLEEP); 32337c478bd9Sstevel@tonic-gate modinfop->mi_info = MI_INFO_LINKAGE; 32347c478bd9Sstevel@tonic-gate if (mod_getinfo(mp, modinfop) == 0) 32357c478bd9Sstevel@tonic-gate mp->mod_linkage = NULL; 32367c478bd9Sstevel@tonic-gate else { 32377c478bd9Sstevel@tonic-gate mp->mod_linkage = (void *)modinfop->mi_base; 32387c478bd9Sstevel@tonic-gate ASSERT(mp->mod_linkage->ml_rev == MODREV_1); 32397c478bd9Sstevel@tonic-gate } 32407c478bd9Sstevel@tonic-gate 32417c478bd9Sstevel@tonic-gate /* 32427c478bd9Sstevel@tonic-gate * DCS: bootstrapping code. If the driver is loaded 32437c478bd9Sstevel@tonic-gate * before root mount, it is assumed that the driver 32447c478bd9Sstevel@tonic-gate * may be used before mounting root. In order to 32457c478bd9Sstevel@tonic-gate * access mappings of global to local minor no.'s 32467c478bd9Sstevel@tonic-gate * during installation/open of the driver, we load 32477c478bd9Sstevel@tonic-gate * them into memory here while the BOP_interfaces 32487c478bd9Sstevel@tonic-gate * are still up. 32497c478bd9Sstevel@tonic-gate */ 32507c478bd9Sstevel@tonic-gate if ((cluster_bootflags & CLUSTER_BOOTED) && !modrootloaded) { 32517c478bd9Sstevel@tonic-gate retval = clboot_modload(mp); 32527c478bd9Sstevel@tonic-gate } 32537c478bd9Sstevel@tonic-gate 32547c478bd9Sstevel@tonic-gate kmem_free(modinfop, sizeof (struct modinfo)); 32557c478bd9Sstevel@tonic-gate (void) mod_sysctl(SYS_SET_MVAR, (void *)mp); 32567c478bd9Sstevel@tonic-gate retval = install_stubs_by_name(mp, mp->mod_modname); 32577c478bd9Sstevel@tonic-gate 32587c478bd9Sstevel@tonic-gate /* 32597c478bd9Sstevel@tonic-gate * Now that the module is loaded, we need to give DTrace 32607c478bd9Sstevel@tonic-gate * a chance to notify its providers. This is done via 32617c478bd9Sstevel@tonic-gate * the dtrace_modload function pointer. 32627c478bd9Sstevel@tonic-gate */ 32637c478bd9Sstevel@tonic-gate if (strcmp(mp->mod_modname, "dtrace") != 0) { 32647c478bd9Sstevel@tonic-gate struct modctl *dmp = mod_hold_by_name("dtrace"); 32657c478bd9Sstevel@tonic-gate 32667c478bd9Sstevel@tonic-gate if (dmp != NULL && dtrace_modload != NULL) 32677c478bd9Sstevel@tonic-gate (*dtrace_modload)(mp); 32687c478bd9Sstevel@tonic-gate 32697c478bd9Sstevel@tonic-gate mod_release_mod(dmp); 32707c478bd9Sstevel@tonic-gate } 32717c478bd9Sstevel@tonic-gate 32727c478bd9Sstevel@tonic-gate } else { 32737c478bd9Sstevel@tonic-gate /* 32747c478bd9Sstevel@tonic-gate * If load failed then we need to release any requisites 32757c478bd9Sstevel@tonic-gate * that we had established. 32767c478bd9Sstevel@tonic-gate */ 32777c478bd9Sstevel@tonic-gate ASSERT(retval); 32787c478bd9Sstevel@tonic-gate mod_release_requisites(mp); 32797c478bd9Sstevel@tonic-gate 32807c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_ERRMSG) 32817c478bd9Sstevel@tonic-gate printf("error loading '%s', error %d\n", 32827c478bd9Sstevel@tonic-gate mp->mod_filename, retval); 32837c478bd9Sstevel@tonic-gate } 32847c478bd9Sstevel@tonic-gate return (retval); 32857c478bd9Sstevel@tonic-gate } 32867c478bd9Sstevel@tonic-gate 32877c478bd9Sstevel@tonic-gate static char unload_msg[] = "unloading %s, module id %d, loadcnt %d.\n"; 32887c478bd9Sstevel@tonic-gate 32897c478bd9Sstevel@tonic-gate static void 32907c478bd9Sstevel@tonic-gate mod_unload(struct modctl *mp) 32917c478bd9Sstevel@tonic-gate { 32927c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&mod_lock)); 32937c478bd9Sstevel@tonic-gate ASSERT(mp->mod_busy); 32947c478bd9Sstevel@tonic-gate ASSERT((mp->mod_loaded && (mp->mod_installed == 0)) && 32957c478bd9Sstevel@tonic-gate ((mp->mod_prim == 0) && (mp->mod_ref >= 0))); 32967c478bd9Sstevel@tonic-gate 32977c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_LOADMSG) 32987c478bd9Sstevel@tonic-gate printf(unload_msg, mp->mod_modname, 32991e1ddd6cScth mp->mod_id, mp->mod_loadcnt); 33007c478bd9Sstevel@tonic-gate 33017c478bd9Sstevel@tonic-gate /* 33027c478bd9Sstevel@tonic-gate * If mod_ref is not zero, it means some modules might still refer 33037c478bd9Sstevel@tonic-gate * to this module. Then you can't unload this module right now. 33047c478bd9Sstevel@tonic-gate * Instead, set 1 to mod_delay_unload to notify the system of 33057c478bd9Sstevel@tonic-gate * unloading this module later when it's not required any more. 33067c478bd9Sstevel@tonic-gate */ 33077c478bd9Sstevel@tonic-gate if (mp->mod_ref > 0) { 33087c478bd9Sstevel@tonic-gate mp->mod_delay_unload = 1; 33097c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_LOADMSG2) { 33107c478bd9Sstevel@tonic-gate printf("module %s not unloaded," 33117c478bd9Sstevel@tonic-gate " non-zero reference count (%d)", 33127c478bd9Sstevel@tonic-gate mp->mod_modname, mp->mod_ref); 33137c478bd9Sstevel@tonic-gate } 33147c478bd9Sstevel@tonic-gate return; 33157c478bd9Sstevel@tonic-gate } 33167c478bd9Sstevel@tonic-gate 33177c478bd9Sstevel@tonic-gate if (((mp->mod_loaded == 0) || mp->mod_installed) || 33187c478bd9Sstevel@tonic-gate (mp->mod_ref || mp->mod_prim)) { 33197c478bd9Sstevel@tonic-gate /* 33207c478bd9Sstevel@tonic-gate * A DEBUG kernel would ASSERT panic above, the code is broken 33217c478bd9Sstevel@tonic-gate * if we get this warning. 33227c478bd9Sstevel@tonic-gate */ 33237c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "mod_unload: %s in incorrect state: %d %d %d", 33247c478bd9Sstevel@tonic-gate mp->mod_filename, mp->mod_installed, mp->mod_loaded, 33257c478bd9Sstevel@tonic-gate mp->mod_ref); 33267c478bd9Sstevel@tonic-gate return; 33277c478bd9Sstevel@tonic-gate } 33287c478bd9Sstevel@tonic-gate 33297c478bd9Sstevel@tonic-gate /* reset stub functions to call the binder again */ 33307c478bd9Sstevel@tonic-gate reset_stubs(mp); 33317c478bd9Sstevel@tonic-gate 33327c478bd9Sstevel@tonic-gate /* 33337c478bd9Sstevel@tonic-gate * mark module as unloaded before the modctl structure is freed. 33347c478bd9Sstevel@tonic-gate * This is required not to reuse the modctl structure before 33357c478bd9Sstevel@tonic-gate * the module is marked as unloaded. 33367c478bd9Sstevel@tonic-gate */ 33377c478bd9Sstevel@tonic-gate mp->mod_loaded = 0; 33387c478bd9Sstevel@tonic-gate mp->mod_linkage = NULL; 33397c478bd9Sstevel@tonic-gate 33407c478bd9Sstevel@tonic-gate /* free the memory */ 33417c478bd9Sstevel@tonic-gate kobj_unload_module(mp); 33427c478bd9Sstevel@tonic-gate 33437c478bd9Sstevel@tonic-gate if (mp->mod_delay_unload) { 33447c478bd9Sstevel@tonic-gate mp->mod_delay_unload = 0; 33457c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_LOADMSG2) { 33467c478bd9Sstevel@tonic-gate printf("deferred unload of module %s" 33477c478bd9Sstevel@tonic-gate " (id %d) successful", 33487c478bd9Sstevel@tonic-gate mp->mod_modname, mp->mod_id); 33497c478bd9Sstevel@tonic-gate } 33507c478bd9Sstevel@tonic-gate } 33517c478bd9Sstevel@tonic-gate 33527c478bd9Sstevel@tonic-gate /* release hold on requisites */ 33537c478bd9Sstevel@tonic-gate mod_release_requisites(mp); 33547c478bd9Sstevel@tonic-gate 33557c478bd9Sstevel@tonic-gate /* 33567c478bd9Sstevel@tonic-gate * Now that the module is gone, we need to give DTrace a chance to 33577c478bd9Sstevel@tonic-gate * remove any probes that it may have had in the module. This is 33587c478bd9Sstevel@tonic-gate * done via the dtrace_modunload function pointer. 33597c478bd9Sstevel@tonic-gate */ 33607c478bd9Sstevel@tonic-gate if (strcmp(mp->mod_modname, "dtrace") != 0) { 33617c478bd9Sstevel@tonic-gate struct modctl *dmp = mod_hold_by_name("dtrace"); 33627c478bd9Sstevel@tonic-gate 33637c478bd9Sstevel@tonic-gate if (dmp != NULL && dtrace_modunload != NULL) 33647c478bd9Sstevel@tonic-gate (*dtrace_modunload)(mp); 33657c478bd9Sstevel@tonic-gate 33667c478bd9Sstevel@tonic-gate mod_release_mod(dmp); 33677c478bd9Sstevel@tonic-gate } 33687c478bd9Sstevel@tonic-gate } 33697c478bd9Sstevel@tonic-gate 33707c478bd9Sstevel@tonic-gate static int 33717c478bd9Sstevel@tonic-gate modinstall(struct modctl *mp) 33727c478bd9Sstevel@tonic-gate { 33737c478bd9Sstevel@tonic-gate int val; 33747c478bd9Sstevel@tonic-gate int (*func)(void); 33757c478bd9Sstevel@tonic-gate 33767c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&mod_lock)); 33777c478bd9Sstevel@tonic-gate ASSERT(mp->mod_busy && mp->mod_loaded); 33787c478bd9Sstevel@tonic-gate 33797c478bd9Sstevel@tonic-gate if (mp->mod_installed) 33807c478bd9Sstevel@tonic-gate return (0); 33817c478bd9Sstevel@tonic-gate /* 33827c478bd9Sstevel@tonic-gate * If mod_delay_unload is on, it means the system chose the deferred 33837c478bd9Sstevel@tonic-gate * unload for this module. Then you can't install this module until 33847c478bd9Sstevel@tonic-gate * it's unloaded from the system. 33857c478bd9Sstevel@tonic-gate */ 33867c478bd9Sstevel@tonic-gate if (mp->mod_delay_unload) 33877c478bd9Sstevel@tonic-gate return (ENXIO); 33887c478bd9Sstevel@tonic-gate 33897c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_LOADMSG) 33907c478bd9Sstevel@tonic-gate printf("installing %s, module id %d.\n", 33911e1ddd6cScth mp->mod_modname, mp->mod_id); 33927c478bd9Sstevel@tonic-gate 33937c478bd9Sstevel@tonic-gate ASSERT(mp->mod_mp != NULL); 33947c478bd9Sstevel@tonic-gate if (mod_install_requisites(mp) != 0) { 33957c478bd9Sstevel@tonic-gate /* 33967c478bd9Sstevel@tonic-gate * Note that we can't call mod_unload(mp) here since 33977c478bd9Sstevel@tonic-gate * if modinstall() was called by mod_install_requisites(), 33987c478bd9Sstevel@tonic-gate * we won't be able to hold the dependent modules 33997c478bd9Sstevel@tonic-gate * (otherwise there would be a deadlock). 34007c478bd9Sstevel@tonic-gate */ 34017c478bd9Sstevel@tonic-gate return (ENXIO); 34027c478bd9Sstevel@tonic-gate } 34037c478bd9Sstevel@tonic-gate 34047c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_ERRMSG) { 34057c478bd9Sstevel@tonic-gate printf("init '%s' id %d loaded @ 0x%p/0x%p size %lu/%lu\n", 34061e1ddd6cScth mp->mod_filename, mp->mod_id, 34071e1ddd6cScth (void *)((struct module *)mp->mod_mp)->text, 34081e1ddd6cScth (void *)((struct module *)mp->mod_mp)->data, 34091e1ddd6cScth ((struct module *)mp->mod_mp)->text_size, 34101e1ddd6cScth ((struct module *)mp->mod_mp)->data_size); 34117c478bd9Sstevel@tonic-gate } 34127c478bd9Sstevel@tonic-gate 34137c478bd9Sstevel@tonic-gate func = (int (*)())kobj_lookup(mp->mod_mp, "_init"); 34147c478bd9Sstevel@tonic-gate 34157c478bd9Sstevel@tonic-gate if (kobj_addrcheck(mp->mod_mp, (caddr_t)func)) { 34167c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "_init() not defined properly in %s", 34177c478bd9Sstevel@tonic-gate mp->mod_filename); 34187c478bd9Sstevel@tonic-gate return (EFAULT); 34197c478bd9Sstevel@tonic-gate } 34207c478bd9Sstevel@tonic-gate 34217c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_USERDEBUG) { 34227c478bd9Sstevel@tonic-gate printf("breakpoint before calling %s:_init()\n", 34237c478bd9Sstevel@tonic-gate mp->mod_modname); 34247c478bd9Sstevel@tonic-gate if (DEBUGGER_PRESENT) 34257c478bd9Sstevel@tonic-gate debug_enter("_init"); 34267c478bd9Sstevel@tonic-gate } 34277c478bd9Sstevel@tonic-gate 34287c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&mod_lock)); 34297c478bd9Sstevel@tonic-gate ASSERT(mp->mod_busy && mp->mod_loaded); 34307c478bd9Sstevel@tonic-gate val = (*func)(); /* call _init */ 34317c478bd9Sstevel@tonic-gate 34327c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_USERDEBUG) 34337c478bd9Sstevel@tonic-gate printf("Returned from _init, val = %x\n", val); 34347c478bd9Sstevel@tonic-gate 34357c478bd9Sstevel@tonic-gate if (val == 0) { 34367c478bd9Sstevel@tonic-gate /* 34377c478bd9Sstevel@tonic-gate * Set the MODS_INSTALLED flag to enable this module 34387c478bd9Sstevel@tonic-gate * being called now. 34397c478bd9Sstevel@tonic-gate */ 34407c478bd9Sstevel@tonic-gate install_stubs(mp); 34417c478bd9Sstevel@tonic-gate mp->mod_installed = 1; 34427c478bd9Sstevel@tonic-gate } else if (moddebug & MODDEBUG_ERRMSG) 34437c478bd9Sstevel@tonic-gate printf(mod_init_msg, mp->mod_filename, mp->mod_modname, val); 34447c478bd9Sstevel@tonic-gate 34457c478bd9Sstevel@tonic-gate return (val); 34467c478bd9Sstevel@tonic-gate } 34477c478bd9Sstevel@tonic-gate 3448a7aa4df7Scth int detach_driver_unconfig = 0; 3449a7aa4df7Scth 34507c478bd9Sstevel@tonic-gate static int 34517c478bd9Sstevel@tonic-gate detach_driver(char *name) 34527c478bd9Sstevel@tonic-gate { 34537c478bd9Sstevel@tonic-gate major_t major; 34547c478bd9Sstevel@tonic-gate int error; 34557c478bd9Sstevel@tonic-gate 34567c478bd9Sstevel@tonic-gate /* 34577c478bd9Sstevel@tonic-gate * If being called from mod_uninstall_all() then the appropriate 34587c478bd9Sstevel@tonic-gate * driver detaches (leaf only) have already been done. 34597c478bd9Sstevel@tonic-gate */ 34607c478bd9Sstevel@tonic-gate if (mod_in_autounload()) 34617c478bd9Sstevel@tonic-gate return (0); 34627c478bd9Sstevel@tonic-gate 34637c478bd9Sstevel@tonic-gate major = ddi_name_to_major(name); 3464a204de77Scth if (major == DDI_MAJOR_T_NONE) 34657c478bd9Sstevel@tonic-gate return (0); 34667c478bd9Sstevel@tonic-gate 34677c478bd9Sstevel@tonic-gate error = ndi_devi_unconfig_driver(ddi_root_node(), 3468a7aa4df7Scth NDI_DETACH_DRIVER | detach_driver_unconfig, major); 34697c478bd9Sstevel@tonic-gate return (error == NDI_SUCCESS ? 0 : -1); 34707c478bd9Sstevel@tonic-gate } 34717c478bd9Sstevel@tonic-gate 34727c478bd9Sstevel@tonic-gate static char finiret_msg[] = "Returned from _fini for %s, status = %x\n"; 34737c478bd9Sstevel@tonic-gate 34747c478bd9Sstevel@tonic-gate static int 34757c478bd9Sstevel@tonic-gate moduninstall(struct modctl *mp) 34767c478bd9Sstevel@tonic-gate { 34777c478bd9Sstevel@tonic-gate int status = 0; 34787c478bd9Sstevel@tonic-gate int (*func)(void); 34797c478bd9Sstevel@tonic-gate 34807c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&mod_lock)); 34817c478bd9Sstevel@tonic-gate ASSERT(mp->mod_busy); 34827c478bd9Sstevel@tonic-gate 34837c478bd9Sstevel@tonic-gate /* 34847c478bd9Sstevel@tonic-gate * Verify that we need to do something and can uninstall the module. 34857c478bd9Sstevel@tonic-gate * 34867c478bd9Sstevel@tonic-gate * If we should not uninstall the module or if the module is not in 34877c478bd9Sstevel@tonic-gate * the correct state to start an uninstall we return EBUSY to prevent 34887c478bd9Sstevel@tonic-gate * us from progressing to mod_unload. If the module has already been 34897c478bd9Sstevel@tonic-gate * uninstalled and unloaded we return EALREADY. 34907c478bd9Sstevel@tonic-gate */ 34917c478bd9Sstevel@tonic-gate if (mp->mod_prim || mp->mod_ref || mp->mod_nenabled != 0) 34927c478bd9Sstevel@tonic-gate return (EBUSY); 34937c478bd9Sstevel@tonic-gate if ((mp->mod_installed == 0) || (mp->mod_loaded == 0)) 34947c478bd9Sstevel@tonic-gate return (EALREADY); 34957c478bd9Sstevel@tonic-gate 34967c478bd9Sstevel@tonic-gate /* 34977c478bd9Sstevel@tonic-gate * To avoid devinfo / module deadlock we must release this module 34987c478bd9Sstevel@tonic-gate * prior to initiating the detach_driver, otherwise the detach_driver 34997c478bd9Sstevel@tonic-gate * might deadlock on a devinfo node held by another thread 35007c478bd9Sstevel@tonic-gate * coming top down and involving the module we have locked. 35017c478bd9Sstevel@tonic-gate * 35027c478bd9Sstevel@tonic-gate * When we regrab the module we must reverify that it is OK 35037c478bd9Sstevel@tonic-gate * to proceed with the uninstall operation. 35047c478bd9Sstevel@tonic-gate */ 35057c478bd9Sstevel@tonic-gate mod_release_mod(mp); 35067c478bd9Sstevel@tonic-gate status = detach_driver(mp->mod_modname); 35077c478bd9Sstevel@tonic-gate (void) mod_hold_by_modctl(mp, MOD_WAIT_FOREVER | MOD_LOCK_NOT_HELD); 35087c478bd9Sstevel@tonic-gate 35097c478bd9Sstevel@tonic-gate /* check detach status and reverify state with lock */ 35107c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 35117c478bd9Sstevel@tonic-gate if ((status != 0) || mp->mod_prim || mp->mod_ref) { 35127c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 35137c478bd9Sstevel@tonic-gate return (EBUSY); 35147c478bd9Sstevel@tonic-gate } 35157c478bd9Sstevel@tonic-gate if ((mp->mod_installed == 0) || (mp->mod_loaded == 0)) { 35167c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 35177c478bd9Sstevel@tonic-gate return (EALREADY); 35187c478bd9Sstevel@tonic-gate } 35197c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 35207c478bd9Sstevel@tonic-gate 35217c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_LOADMSG2) 35227c478bd9Sstevel@tonic-gate printf("uninstalling %s\n", mp->mod_modname); 35237c478bd9Sstevel@tonic-gate 35247c478bd9Sstevel@tonic-gate /* 35257c478bd9Sstevel@tonic-gate * lookup _fini, return EBUSY if not defined. 35267c478bd9Sstevel@tonic-gate * 35277c478bd9Sstevel@tonic-gate * The MODDEBUG_FINI_EBUSY is usefull in resolving leaks in 35287c478bd9Sstevel@tonic-gate * detach(9E) - it allows bufctl addresses to be resolved. 35297c478bd9Sstevel@tonic-gate */ 35307c478bd9Sstevel@tonic-gate func = (int (*)())kobj_lookup(mp->mod_mp, "_fini"); 35317c478bd9Sstevel@tonic-gate if ((func == NULL) || (mp->mod_loadflags & MOD_NOUNLOAD) || 35327c478bd9Sstevel@tonic-gate (moddebug & MODDEBUG_FINI_EBUSY)) 35337c478bd9Sstevel@tonic-gate return (EBUSY); 35347c478bd9Sstevel@tonic-gate 35357c478bd9Sstevel@tonic-gate /* verify that _fini is in this module */ 35367c478bd9Sstevel@tonic-gate if (kobj_addrcheck(mp->mod_mp, (caddr_t)func)) { 35377c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "_fini() not defined properly in %s", 35387c478bd9Sstevel@tonic-gate mp->mod_filename); 35397c478bd9Sstevel@tonic-gate return (EFAULT); 35407c478bd9Sstevel@tonic-gate } 35417c478bd9Sstevel@tonic-gate 35427c478bd9Sstevel@tonic-gate /* call _fini() */ 35437c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&mod_lock)); 35447c478bd9Sstevel@tonic-gate ASSERT(mp->mod_busy && mp->mod_loaded && mp->mod_installed); 35457c478bd9Sstevel@tonic-gate 35467c478bd9Sstevel@tonic-gate status = (*func)(); 35477c478bd9Sstevel@tonic-gate 35487c478bd9Sstevel@tonic-gate if (status == 0) { 35497c478bd9Sstevel@tonic-gate /* _fini returned success, the module is no longer installed */ 35507c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_LOADMSG) 35517c478bd9Sstevel@tonic-gate printf("uninstalled %s\n", mp->mod_modname); 35527c478bd9Sstevel@tonic-gate 35537c478bd9Sstevel@tonic-gate /* 35547c478bd9Sstevel@tonic-gate * Even though we only set mod_installed to zero here, a zero 3555da6c28aaSamw * return value means we are committed to a code path were 35567c478bd9Sstevel@tonic-gate * mod_loaded will also end up as zero - we have no other 35577c478bd9Sstevel@tonic-gate * way to get the module data and bss back to the pre _init 35587c478bd9Sstevel@tonic-gate * state except a reload. To ensure this, after return, 35597c478bd9Sstevel@tonic-gate * mod_busy must stay set until mod_loaded is cleared. 35607c478bd9Sstevel@tonic-gate */ 35617c478bd9Sstevel@tonic-gate mp->mod_installed = 0; 35627c478bd9Sstevel@tonic-gate 35637c478bd9Sstevel@tonic-gate /* 35647c478bd9Sstevel@tonic-gate * Clear the MODS_INSTALLED flag not to call functions 35657c478bd9Sstevel@tonic-gate * in the module directly from now on. 35667c478bd9Sstevel@tonic-gate */ 35677c478bd9Sstevel@tonic-gate uninstall_stubs(mp); 35687c478bd9Sstevel@tonic-gate } else { 35697c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_USERDEBUG) 35707c478bd9Sstevel@tonic-gate printf(finiret_msg, mp->mod_filename, status); 35717c478bd9Sstevel@tonic-gate /* 35727c478bd9Sstevel@tonic-gate * By definition _fini is only allowed to return EBUSY or the 35737c478bd9Sstevel@tonic-gate * result of mod_remove (EBUSY or EINVAL). In the off chance 35747c478bd9Sstevel@tonic-gate * that a driver returns EALREADY we convert this to EINVAL 35757c478bd9Sstevel@tonic-gate * since to our caller EALREADY means module was already 35767c478bd9Sstevel@tonic-gate * removed. 35777c478bd9Sstevel@tonic-gate */ 35787c478bd9Sstevel@tonic-gate if (status == EALREADY) 35797c478bd9Sstevel@tonic-gate status = EINVAL; 35807c478bd9Sstevel@tonic-gate } 35817c478bd9Sstevel@tonic-gate 35827c478bd9Sstevel@tonic-gate return (status); 35837c478bd9Sstevel@tonic-gate } 35847c478bd9Sstevel@tonic-gate 35857c478bd9Sstevel@tonic-gate /* 35867c478bd9Sstevel@tonic-gate * Uninstall all modules. 35877c478bd9Sstevel@tonic-gate */ 35887c478bd9Sstevel@tonic-gate static void 35897c478bd9Sstevel@tonic-gate mod_uninstall_all(void) 35907c478bd9Sstevel@tonic-gate { 35917c478bd9Sstevel@tonic-gate struct modctl *mp; 35927c478bd9Sstevel@tonic-gate modid_t modid = 0; 35937c478bd9Sstevel@tonic-gate 3594a7aa4df7Scth /* synchronize with any active modunload_disable() */ 3595a7aa4df7Scth modunload_begin(); 3596a7aa4df7Scth 35977c478bd9Sstevel@tonic-gate /* mark this thread as doing autounloading */ 35987c478bd9Sstevel@tonic-gate (void) tsd_set(mod_autounload_key, (void *)1); 35997c478bd9Sstevel@tonic-gate 36007c478bd9Sstevel@tonic-gate (void) devfs_clean(ddi_root_node(), NULL, 0); 36017c478bd9Sstevel@tonic-gate (void) ndi_devi_unconfig(ddi_root_node(), NDI_AUTODETACH); 36027c478bd9Sstevel@tonic-gate 36037c478bd9Sstevel@tonic-gate while ((mp = mod_hold_next_by_id(modid)) != NULL) { 36047c478bd9Sstevel@tonic-gate modid = mp->mod_id; 36057c478bd9Sstevel@tonic-gate /* 36067c478bd9Sstevel@tonic-gate * Skip modules with the MOD_NOAUTOUNLOAD flag set 36077c478bd9Sstevel@tonic-gate */ 36087c478bd9Sstevel@tonic-gate if (mp->mod_loadflags & MOD_NOAUTOUNLOAD) { 36097c478bd9Sstevel@tonic-gate mod_release_mod(mp); 36107c478bd9Sstevel@tonic-gate continue; 36117c478bd9Sstevel@tonic-gate } 36127c478bd9Sstevel@tonic-gate 36130b38a8bdSahl if (moduninstall(mp) == 0) { 36147c478bd9Sstevel@tonic-gate mod_unload(mp); 36150b38a8bdSahl CPU_STATS_ADDQ(CPU, sys, modunload, 1); 36160b38a8bdSahl } 36177c478bd9Sstevel@tonic-gate mod_release_mod(mp); 36187c478bd9Sstevel@tonic-gate } 36197c478bd9Sstevel@tonic-gate 36207c478bd9Sstevel@tonic-gate (void) tsd_set(mod_autounload_key, NULL); 3621a7aa4df7Scth modunload_end(); 36227c478bd9Sstevel@tonic-gate } 36237c478bd9Sstevel@tonic-gate 3624a7aa4df7Scth /* wait for unloads that have begun before registering disable */ 36257c478bd9Sstevel@tonic-gate void 36267c478bd9Sstevel@tonic-gate modunload_disable(void) 36277c478bd9Sstevel@tonic-gate { 3628a7aa4df7Scth mutex_enter(&modunload_wait_mutex); 3629a7aa4df7Scth while (modunload_active_count) { 3630a7aa4df7Scth modunload_wait++; 3631a7aa4df7Scth cv_wait(&modunload_wait_cv, &modunload_wait_mutex); 3632a7aa4df7Scth modunload_wait--; 3633a7aa4df7Scth } 3634a7aa4df7Scth modunload_disable_count++; 3635a7aa4df7Scth mutex_exit(&modunload_wait_mutex); 36367c478bd9Sstevel@tonic-gate } 36377c478bd9Sstevel@tonic-gate 3638a7aa4df7Scth /* mark end of disable and signal waiters */ 36397c478bd9Sstevel@tonic-gate void 36407c478bd9Sstevel@tonic-gate modunload_enable(void) 36417c478bd9Sstevel@tonic-gate { 3642a7aa4df7Scth mutex_enter(&modunload_wait_mutex); 3643a7aa4df7Scth modunload_disable_count--; 3644a7aa4df7Scth if ((modunload_disable_count == 0) && modunload_wait) 3645a7aa4df7Scth cv_broadcast(&modunload_wait_cv); 3646a7aa4df7Scth mutex_exit(&modunload_wait_mutex); 3647a7aa4df7Scth } 3648a7aa4df7Scth 3649a7aa4df7Scth /* wait for disables to complete before begining unload */ 3650a7aa4df7Scth void 3651a7aa4df7Scth modunload_begin() 3652a7aa4df7Scth { 3653a7aa4df7Scth mutex_enter(&modunload_wait_mutex); 3654a7aa4df7Scth while (modunload_disable_count) { 3655a7aa4df7Scth modunload_wait++; 3656a7aa4df7Scth cv_wait(&modunload_wait_cv, &modunload_wait_mutex); 3657a7aa4df7Scth modunload_wait--; 3658a7aa4df7Scth } 3659a7aa4df7Scth modunload_active_count++; 3660a7aa4df7Scth mutex_exit(&modunload_wait_mutex); 3661a7aa4df7Scth } 3662a7aa4df7Scth 3663a7aa4df7Scth /* mark end of unload and signal waiters */ 3664a7aa4df7Scth void 3665a7aa4df7Scth modunload_end() 3666a7aa4df7Scth { 3667a7aa4df7Scth mutex_enter(&modunload_wait_mutex); 3668a7aa4df7Scth modunload_active_count--; 3669a7aa4df7Scth if ((modunload_active_count == 0) && modunload_wait) 3670a7aa4df7Scth cv_broadcast(&modunload_wait_cv); 3671a7aa4df7Scth mutex_exit(&modunload_wait_mutex); 36727c478bd9Sstevel@tonic-gate } 36737c478bd9Sstevel@tonic-gate 36747c478bd9Sstevel@tonic-gate void 36757c478bd9Sstevel@tonic-gate mod_uninstall_daemon(void) 36767c478bd9Sstevel@tonic-gate { 36777c478bd9Sstevel@tonic-gate callb_cpr_t cprinfo; 36787c478bd9Sstevel@tonic-gate clock_t ticks = 0; 36797c478bd9Sstevel@tonic-gate 36807c478bd9Sstevel@tonic-gate mod_aul_thread = curthread; 36817c478bd9Sstevel@tonic-gate 36827c478bd9Sstevel@tonic-gate CALLB_CPR_INIT(&cprinfo, &mod_uninstall_lock, callb_generic_cpr, "mud"); 36837c478bd9Sstevel@tonic-gate for (;;) { 36847c478bd9Sstevel@tonic-gate mutex_enter(&mod_uninstall_lock); 36857c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_BEGIN(&cprinfo); 36867c478bd9Sstevel@tonic-gate /* 36877c478bd9Sstevel@tonic-gate * In DEBUG kernels, unheld drivers are uninstalled periodically 36887c478bd9Sstevel@tonic-gate * every mod_uninstall_interval seconds. Periodic uninstall can 36897c478bd9Sstevel@tonic-gate * be disabled by setting mod_uninstall_interval to 0 which is 36907c478bd9Sstevel@tonic-gate * the default for a non-DEBUG kernel. 36917c478bd9Sstevel@tonic-gate */ 36927c478bd9Sstevel@tonic-gate if (mod_uninstall_interval) { 36937c478bd9Sstevel@tonic-gate ticks = ddi_get_lbolt() + 36941e1ddd6cScth drv_usectohz(mod_uninstall_interval * 1000000); 36957c478bd9Sstevel@tonic-gate (void) cv_timedwait(&mod_uninstall_cv, 36961e1ddd6cScth &mod_uninstall_lock, ticks); 36977c478bd9Sstevel@tonic-gate } else { 36987c478bd9Sstevel@tonic-gate cv_wait(&mod_uninstall_cv, &mod_uninstall_lock); 36997c478bd9Sstevel@tonic-gate } 37007c478bd9Sstevel@tonic-gate /* 37017c478bd9Sstevel@tonic-gate * The whole daemon is safe for CPR except we don't want 37027c478bd9Sstevel@tonic-gate * the daemon to run if FREEZE is issued and this daemon 37037c478bd9Sstevel@tonic-gate * wakes up from the cv_wait above. In this case, it'll be 37047c478bd9Sstevel@tonic-gate * blocked in CALLB_CPR_SAFE_END until THAW is issued. 37057c478bd9Sstevel@tonic-gate * 37067c478bd9Sstevel@tonic-gate * The reason of calling CALLB_CPR_SAFE_BEGIN twice is that 37077c478bd9Sstevel@tonic-gate * mod_uninstall_lock is used to protect cprinfo and 37087c478bd9Sstevel@tonic-gate * CALLB_CPR_SAFE_BEGIN assumes that this lock is held when 37097c478bd9Sstevel@tonic-gate * called. 37107c478bd9Sstevel@tonic-gate */ 37117c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_END(&cprinfo, &mod_uninstall_lock); 37127c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_BEGIN(&cprinfo); 37137c478bd9Sstevel@tonic-gate mutex_exit(&mod_uninstall_lock); 37147c478bd9Sstevel@tonic-gate if ((modunload_disable_count == 0) && 37157c478bd9Sstevel@tonic-gate ((moddebug & MODDEBUG_NOAUTOUNLOAD) == 0)) { 37167c478bd9Sstevel@tonic-gate mod_uninstall_all(); 37177c478bd9Sstevel@tonic-gate } 37187c478bd9Sstevel@tonic-gate } 37197c478bd9Sstevel@tonic-gate } 37207c478bd9Sstevel@tonic-gate 37217c478bd9Sstevel@tonic-gate /* 37227c478bd9Sstevel@tonic-gate * Unload all uninstalled modules. 37237c478bd9Sstevel@tonic-gate */ 37247c478bd9Sstevel@tonic-gate void 37257c478bd9Sstevel@tonic-gate modreap(void) 37267c478bd9Sstevel@tonic-gate { 37277c478bd9Sstevel@tonic-gate mutex_enter(&mod_uninstall_lock); 37287c478bd9Sstevel@tonic-gate cv_broadcast(&mod_uninstall_cv); 37297c478bd9Sstevel@tonic-gate mutex_exit(&mod_uninstall_lock); 37307c478bd9Sstevel@tonic-gate } 37317c478bd9Sstevel@tonic-gate 37327c478bd9Sstevel@tonic-gate /* 37337c478bd9Sstevel@tonic-gate * Hold the specified module. This is the module holding primitive. 37347c478bd9Sstevel@tonic-gate * 37357c478bd9Sstevel@tonic-gate * If MOD_LOCK_HELD then the caller already holds the mod_lock. 37367c478bd9Sstevel@tonic-gate * 37377c478bd9Sstevel@tonic-gate * Return values: 37387c478bd9Sstevel@tonic-gate * 0 ==> the module is held 37397c478bd9Sstevel@tonic-gate * 1 ==> the module is not held and the MOD_WAIT_ONCE caller needs 37407c478bd9Sstevel@tonic-gate * to determine how to retry. 37417c478bd9Sstevel@tonic-gate */ 37427c478bd9Sstevel@tonic-gate int 37437c478bd9Sstevel@tonic-gate mod_hold_by_modctl(struct modctl *mp, int f) 37447c478bd9Sstevel@tonic-gate { 37457c478bd9Sstevel@tonic-gate ASSERT((f & (MOD_WAIT_ONCE | MOD_WAIT_FOREVER)) && 37467c478bd9Sstevel@tonic-gate ((f & (MOD_WAIT_ONCE | MOD_WAIT_FOREVER)) != 37477c478bd9Sstevel@tonic-gate (MOD_WAIT_ONCE | MOD_WAIT_FOREVER))); 37487c478bd9Sstevel@tonic-gate ASSERT((f & (MOD_LOCK_HELD | MOD_LOCK_NOT_HELD)) && 37497c478bd9Sstevel@tonic-gate ((f & (MOD_LOCK_HELD | MOD_LOCK_NOT_HELD)) != 37507c478bd9Sstevel@tonic-gate (MOD_LOCK_HELD | MOD_LOCK_NOT_HELD))); 37517c478bd9Sstevel@tonic-gate ASSERT((f & MOD_LOCK_NOT_HELD) || MUTEX_HELD(&mod_lock)); 37527c478bd9Sstevel@tonic-gate 37537c478bd9Sstevel@tonic-gate if (f & MOD_LOCK_NOT_HELD) 37547c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 37557c478bd9Sstevel@tonic-gate 37567c478bd9Sstevel@tonic-gate while (mp->mod_busy) { 37577c478bd9Sstevel@tonic-gate mp->mod_want = 1; 37587c478bd9Sstevel@tonic-gate cv_wait(&mod_cv, &mod_lock); 37597c478bd9Sstevel@tonic-gate /* 37607c478bd9Sstevel@tonic-gate * Module may be unloaded by daemon. 37617c478bd9Sstevel@tonic-gate * Nevertheless, modctl structure is still in linked list 37627c478bd9Sstevel@tonic-gate * (i.e., off &modules), not freed! 37637c478bd9Sstevel@tonic-gate * Caller is not supposed to assume "mp" is valid, but there 37647c478bd9Sstevel@tonic-gate * is no reasonable way to detect this but using 37657c478bd9Sstevel@tonic-gate * mp->mod_modinfo->mp == NULL check (follow the back pointer) 37667c478bd9Sstevel@tonic-gate * (or similar check depending on calling context) 37677c478bd9Sstevel@tonic-gate * DON'T free modctl structure, it will be very very 37687c478bd9Sstevel@tonic-gate * problematic. 37697c478bd9Sstevel@tonic-gate */ 37707c478bd9Sstevel@tonic-gate if (f & MOD_WAIT_ONCE) { 37717c478bd9Sstevel@tonic-gate if (f & MOD_LOCK_NOT_HELD) 37727c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 37737c478bd9Sstevel@tonic-gate return (1); /* caller decides how to retry */ 37747c478bd9Sstevel@tonic-gate } 37757c478bd9Sstevel@tonic-gate } 37767c478bd9Sstevel@tonic-gate 37777c478bd9Sstevel@tonic-gate mp->mod_busy = 1; 37787c478bd9Sstevel@tonic-gate mp->mod_inprogress_thread = 37797c478bd9Sstevel@tonic-gate (curthread == NULL ? (kthread_id_t)-1 : curthread); 37807c478bd9Sstevel@tonic-gate 37817c478bd9Sstevel@tonic-gate if (f & MOD_LOCK_NOT_HELD) 37827c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 37837c478bd9Sstevel@tonic-gate return (0); 37847c478bd9Sstevel@tonic-gate } 37857c478bd9Sstevel@tonic-gate 37867c478bd9Sstevel@tonic-gate static struct modctl * 37877aec1d6eScindi mod_hold_by_name_common(struct modctl *dep, const char *filename) 37887c478bd9Sstevel@tonic-gate { 37897aec1d6eScindi const char *modname; 37907c478bd9Sstevel@tonic-gate struct modctl *mp; 37917c478bd9Sstevel@tonic-gate char *curname, *newname; 37927c478bd9Sstevel@tonic-gate int found = 0; 37937c478bd9Sstevel@tonic-gate 37947c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 37957c478bd9Sstevel@tonic-gate 37967c478bd9Sstevel@tonic-gate if ((modname = strrchr(filename, '/')) == NULL) 37977c478bd9Sstevel@tonic-gate modname = filename; 37987c478bd9Sstevel@tonic-gate else 37997c478bd9Sstevel@tonic-gate modname++; 38007c478bd9Sstevel@tonic-gate 38017c478bd9Sstevel@tonic-gate mp = &modules; 38027c478bd9Sstevel@tonic-gate do { 38037c478bd9Sstevel@tonic-gate if (strcmp(modname, mp->mod_modname) == 0) { 38047c478bd9Sstevel@tonic-gate found = 1; 38057c478bd9Sstevel@tonic-gate break; 38067c478bd9Sstevel@tonic-gate } 38077c478bd9Sstevel@tonic-gate } while ((mp = mp->mod_next) != &modules); 38087c478bd9Sstevel@tonic-gate 38097c478bd9Sstevel@tonic-gate if (found == 0) { 38107c478bd9Sstevel@tonic-gate mp = allocate_modp(filename, modname); 38117c478bd9Sstevel@tonic-gate modadd(mp); 38127c478bd9Sstevel@tonic-gate } 38137c478bd9Sstevel@tonic-gate 38147c478bd9Sstevel@tonic-gate /* 38157c478bd9Sstevel@tonic-gate * if dep is not NULL, set the mp in mod_requisite_loading for 38167c478bd9Sstevel@tonic-gate * the module circular dependency check. This field is used in 38177c478bd9Sstevel@tonic-gate * mod_circdep(), but it's cleard in mod_hold_loaded_mod(). 38187c478bd9Sstevel@tonic-gate */ 38197c478bd9Sstevel@tonic-gate if (dep != NULL) { 38207c478bd9Sstevel@tonic-gate ASSERT(dep->mod_busy && dep->mod_requisite_loading == NULL); 38217c478bd9Sstevel@tonic-gate dep->mod_requisite_loading = mp; 38227c478bd9Sstevel@tonic-gate } 38237c478bd9Sstevel@tonic-gate 38247c478bd9Sstevel@tonic-gate /* 38257c478bd9Sstevel@tonic-gate * If the module was held, then it must be us who has it held. 38267c478bd9Sstevel@tonic-gate */ 38277c478bd9Sstevel@tonic-gate if (mod_circdep(mp)) 38287c478bd9Sstevel@tonic-gate mp = NULL; 38297c478bd9Sstevel@tonic-gate else { 38307c478bd9Sstevel@tonic-gate (void) mod_hold_by_modctl(mp, MOD_WAIT_FOREVER | MOD_LOCK_HELD); 38317c478bd9Sstevel@tonic-gate 38327c478bd9Sstevel@tonic-gate /* 38337c478bd9Sstevel@tonic-gate * If the name hadn't been set or has changed, allocate 38347c478bd9Sstevel@tonic-gate * space and set it. Free space used by previous name. 38357c478bd9Sstevel@tonic-gate * 38367c478bd9Sstevel@tonic-gate * Do not change the name of primary modules, for primary 38377c478bd9Sstevel@tonic-gate * modules the mod_filename was allocated in standalone mode: 38387c478bd9Sstevel@tonic-gate * it is illegal to kobj_alloc in standalone mode and kobj_free 38397c478bd9Sstevel@tonic-gate * in non-standalone mode. 38407c478bd9Sstevel@tonic-gate */ 38417c478bd9Sstevel@tonic-gate curname = mp->mod_filename; 38427c478bd9Sstevel@tonic-gate if (curname == NULL || 38437c478bd9Sstevel@tonic-gate ((mp->mod_prim == 0) && 38447c478bd9Sstevel@tonic-gate (curname != filename) && 38457c478bd9Sstevel@tonic-gate (modname != filename) && 38467c478bd9Sstevel@tonic-gate (strcmp(curname, filename) != 0))) { 38477c478bd9Sstevel@tonic-gate newname = kobj_zalloc(strlen(filename) + 1, KM_SLEEP); 38487c478bd9Sstevel@tonic-gate (void) strcpy(newname, filename); 38497c478bd9Sstevel@tonic-gate mp->mod_filename = newname; 38507c478bd9Sstevel@tonic-gate if (curname != NULL) 38517c478bd9Sstevel@tonic-gate kobj_free(curname, strlen(curname) + 1); 38527c478bd9Sstevel@tonic-gate } 38537c478bd9Sstevel@tonic-gate } 38547c478bd9Sstevel@tonic-gate 38557c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 38567c478bd9Sstevel@tonic-gate if (mp && moddebug & MODDEBUG_LOADMSG2) 38577c478bd9Sstevel@tonic-gate printf("Holding %s\n", mp->mod_filename); 38587c478bd9Sstevel@tonic-gate if (mp == NULL && moddebug & MODDEBUG_LOADMSG2) 38597c478bd9Sstevel@tonic-gate printf("circular dependency loading %s\n", filename); 38607c478bd9Sstevel@tonic-gate return (mp); 38617c478bd9Sstevel@tonic-gate } 38627c478bd9Sstevel@tonic-gate 38637c478bd9Sstevel@tonic-gate static struct modctl * 38647c478bd9Sstevel@tonic-gate mod_hold_by_name_requisite(struct modctl *dep, char *filename) 38657c478bd9Sstevel@tonic-gate { 38667c478bd9Sstevel@tonic-gate return (mod_hold_by_name_common(dep, filename)); 38677c478bd9Sstevel@tonic-gate } 38687c478bd9Sstevel@tonic-gate 38697c478bd9Sstevel@tonic-gate struct modctl * 38707aec1d6eScindi mod_hold_by_name(const char *filename) 38717c478bd9Sstevel@tonic-gate { 38727c478bd9Sstevel@tonic-gate return (mod_hold_by_name_common(NULL, filename)); 38737c478bd9Sstevel@tonic-gate } 38747c478bd9Sstevel@tonic-gate 38757aec1d6eScindi struct modctl * 38767c478bd9Sstevel@tonic-gate mod_hold_by_id(modid_t modid) 38777c478bd9Sstevel@tonic-gate { 38787c478bd9Sstevel@tonic-gate struct modctl *mp; 38797c478bd9Sstevel@tonic-gate int found = 0; 38807c478bd9Sstevel@tonic-gate 38817c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 38827c478bd9Sstevel@tonic-gate mp = &modules; 38837c478bd9Sstevel@tonic-gate do { 38847c478bd9Sstevel@tonic-gate if (mp->mod_id == modid) { 38857c478bd9Sstevel@tonic-gate found = 1; 38867c478bd9Sstevel@tonic-gate break; 38877c478bd9Sstevel@tonic-gate } 38887c478bd9Sstevel@tonic-gate } while ((mp = mp->mod_next) != &modules); 38897c478bd9Sstevel@tonic-gate 38907c478bd9Sstevel@tonic-gate if ((found == 0) || mod_circdep(mp)) 38917c478bd9Sstevel@tonic-gate mp = NULL; 38927c478bd9Sstevel@tonic-gate else 38937c478bd9Sstevel@tonic-gate (void) mod_hold_by_modctl(mp, MOD_WAIT_FOREVER | MOD_LOCK_HELD); 38947c478bd9Sstevel@tonic-gate 38957c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 38967c478bd9Sstevel@tonic-gate return (mp); 38977c478bd9Sstevel@tonic-gate } 38987c478bd9Sstevel@tonic-gate 38997c478bd9Sstevel@tonic-gate static struct modctl * 39007c478bd9Sstevel@tonic-gate mod_hold_next_by_id(modid_t modid) 39017c478bd9Sstevel@tonic-gate { 39027c478bd9Sstevel@tonic-gate struct modctl *mp; 39037c478bd9Sstevel@tonic-gate int found = 0; 39047c478bd9Sstevel@tonic-gate 39057c478bd9Sstevel@tonic-gate if (modid < -1) 39067c478bd9Sstevel@tonic-gate return (NULL); 39077c478bd9Sstevel@tonic-gate 39087c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 39097c478bd9Sstevel@tonic-gate 39107c478bd9Sstevel@tonic-gate mp = &modules; 39117c478bd9Sstevel@tonic-gate do { 39127c478bd9Sstevel@tonic-gate if (mp->mod_id > modid) { 39137c478bd9Sstevel@tonic-gate found = 1; 39147c478bd9Sstevel@tonic-gate break; 39157c478bd9Sstevel@tonic-gate } 39167c478bd9Sstevel@tonic-gate } while ((mp = mp->mod_next) != &modules); 39177c478bd9Sstevel@tonic-gate 39187c478bd9Sstevel@tonic-gate if ((found == 0) || mod_circdep(mp)) 39197c478bd9Sstevel@tonic-gate mp = NULL; 39207c478bd9Sstevel@tonic-gate else 39217c478bd9Sstevel@tonic-gate (void) mod_hold_by_modctl(mp, MOD_WAIT_FOREVER | MOD_LOCK_HELD); 39227c478bd9Sstevel@tonic-gate 39237c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 39247c478bd9Sstevel@tonic-gate return (mp); 39257c478bd9Sstevel@tonic-gate } 39267c478bd9Sstevel@tonic-gate 39277c478bd9Sstevel@tonic-gate static void 39287c478bd9Sstevel@tonic-gate mod_release(struct modctl *mp) 39297c478bd9Sstevel@tonic-gate { 39307c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&mod_lock)); 39317c478bd9Sstevel@tonic-gate ASSERT(mp->mod_busy); 39327c478bd9Sstevel@tonic-gate 39337c478bd9Sstevel@tonic-gate mp->mod_busy = 0; 39347c478bd9Sstevel@tonic-gate mp->mod_inprogress_thread = NULL; 39357c478bd9Sstevel@tonic-gate if (mp->mod_want) { 39367c478bd9Sstevel@tonic-gate mp->mod_want = 0; 39377c478bd9Sstevel@tonic-gate cv_broadcast(&mod_cv); 39387c478bd9Sstevel@tonic-gate } 39397c478bd9Sstevel@tonic-gate } 39407c478bd9Sstevel@tonic-gate 39417c478bd9Sstevel@tonic-gate void 39427c478bd9Sstevel@tonic-gate mod_release_mod(struct modctl *mp) 39437c478bd9Sstevel@tonic-gate { 39447c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_LOADMSG2) 39457c478bd9Sstevel@tonic-gate printf("Releasing %s\n", mp->mod_filename); 39467c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 39477c478bd9Sstevel@tonic-gate mod_release(mp); 39487c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 39497c478bd9Sstevel@tonic-gate } 39507c478bd9Sstevel@tonic-gate 39517c478bd9Sstevel@tonic-gate modid_t 39527c478bd9Sstevel@tonic-gate mod_name_to_modid(char *filename) 39537c478bd9Sstevel@tonic-gate { 39547c478bd9Sstevel@tonic-gate char *modname; 39557c478bd9Sstevel@tonic-gate struct modctl *mp; 39567c478bd9Sstevel@tonic-gate 39577c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 39587c478bd9Sstevel@tonic-gate 39597c478bd9Sstevel@tonic-gate if ((modname = strrchr(filename, '/')) == NULL) 39607c478bd9Sstevel@tonic-gate modname = filename; 39617c478bd9Sstevel@tonic-gate else 39627c478bd9Sstevel@tonic-gate modname++; 39637c478bd9Sstevel@tonic-gate 39647c478bd9Sstevel@tonic-gate mp = &modules; 39657c478bd9Sstevel@tonic-gate do { 39667c478bd9Sstevel@tonic-gate if (strcmp(modname, mp->mod_modname) == 0) { 39677c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 39687c478bd9Sstevel@tonic-gate return (mp->mod_id); 39697c478bd9Sstevel@tonic-gate } 39707c478bd9Sstevel@tonic-gate } while ((mp = mp->mod_next) != &modules); 39717c478bd9Sstevel@tonic-gate 39727c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 39737c478bd9Sstevel@tonic-gate return (-1); 39747c478bd9Sstevel@tonic-gate } 39757c478bd9Sstevel@tonic-gate 39767c478bd9Sstevel@tonic-gate 39777c478bd9Sstevel@tonic-gate int 39787c478bd9Sstevel@tonic-gate mod_remove_by_name(char *name) 39797c478bd9Sstevel@tonic-gate { 39807c478bd9Sstevel@tonic-gate struct modctl *mp; 39817c478bd9Sstevel@tonic-gate int retval; 39827c478bd9Sstevel@tonic-gate 39837c478bd9Sstevel@tonic-gate mp = mod_hold_by_name(name); 39847c478bd9Sstevel@tonic-gate 39857c478bd9Sstevel@tonic-gate if (mp == NULL) 39867c478bd9Sstevel@tonic-gate return (EINVAL); 39877c478bd9Sstevel@tonic-gate 39887c478bd9Sstevel@tonic-gate if (mp->mod_loadflags & MOD_NOAUTOUNLOAD) { 39897c478bd9Sstevel@tonic-gate /* 39907c478bd9Sstevel@tonic-gate * Do not unload forceloaded modules 39917c478bd9Sstevel@tonic-gate */ 39927c478bd9Sstevel@tonic-gate mod_release_mod(mp); 39937c478bd9Sstevel@tonic-gate return (0); 39947c478bd9Sstevel@tonic-gate } 39957c478bd9Sstevel@tonic-gate 39960b38a8bdSahl if ((retval = moduninstall(mp)) == 0) { 39977c478bd9Sstevel@tonic-gate mod_unload(mp); 39980b38a8bdSahl CPU_STATS_ADDQ(CPU, sys, modunload, 1); 39990b38a8bdSahl } else if (retval == EALREADY) 40007c478bd9Sstevel@tonic-gate retval = 0; /* already unloaded, not an error */ 40017c478bd9Sstevel@tonic-gate mod_release_mod(mp); 40027c478bd9Sstevel@tonic-gate return (retval); 40037c478bd9Sstevel@tonic-gate } 40047c478bd9Sstevel@tonic-gate 40057c478bd9Sstevel@tonic-gate /* 40067c478bd9Sstevel@tonic-gate * Record that module "dep" is dependent on module "on_mod." 40077c478bd9Sstevel@tonic-gate */ 40087c478bd9Sstevel@tonic-gate static void 40097c478bd9Sstevel@tonic-gate mod_make_requisite(struct modctl *dependent, struct modctl *on_mod) 40107c478bd9Sstevel@tonic-gate { 40117c478bd9Sstevel@tonic-gate struct modctl_list **pmlnp; /* previous next pointer */ 40127c478bd9Sstevel@tonic-gate struct modctl_list *mlp; 40137c478bd9Sstevel@tonic-gate struct modctl_list *new; 40147c478bd9Sstevel@tonic-gate 40157c478bd9Sstevel@tonic-gate ASSERT(dependent->mod_busy && on_mod->mod_busy); 40167c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 40177c478bd9Sstevel@tonic-gate 40187c478bd9Sstevel@tonic-gate /* 40197c478bd9Sstevel@tonic-gate * Search dependent's requisite list to see if on_mod is recorded. 40207c478bd9Sstevel@tonic-gate * List is ordered by id. 40217c478bd9Sstevel@tonic-gate */ 40227c478bd9Sstevel@tonic-gate for (pmlnp = &dependent->mod_requisites, mlp = *pmlnp; 40237c478bd9Sstevel@tonic-gate mlp; pmlnp = &mlp->modl_next, mlp = *pmlnp) 40247c478bd9Sstevel@tonic-gate if (mlp->modl_modp->mod_id >= on_mod->mod_id) 40257c478bd9Sstevel@tonic-gate break; 40267c478bd9Sstevel@tonic-gate 40277c478bd9Sstevel@tonic-gate /* Create and insert if not already recorded */ 40287c478bd9Sstevel@tonic-gate if ((mlp == NULL) || (mlp->modl_modp->mod_id != on_mod->mod_id)) { 40297c478bd9Sstevel@tonic-gate new = kobj_zalloc(sizeof (*new), KM_SLEEP); 40307c478bd9Sstevel@tonic-gate new->modl_modp = on_mod; 40317c478bd9Sstevel@tonic-gate new->modl_next = mlp; 40327c478bd9Sstevel@tonic-gate *pmlnp = new; 40337c478bd9Sstevel@tonic-gate 40347c478bd9Sstevel@tonic-gate /* 40357c478bd9Sstevel@tonic-gate * Increment the mod_ref count in our new requisite module. 40367c478bd9Sstevel@tonic-gate * This is what keeps a module that has other modules 40377c478bd9Sstevel@tonic-gate * which are dependent on it from being uninstalled and 40387c478bd9Sstevel@tonic-gate * unloaded. "on_mod"'s mod_ref count decremented in 40397c478bd9Sstevel@tonic-gate * mod_release_requisites when the "dependent" module 40407c478bd9Sstevel@tonic-gate * unload is complete. "on_mod" must be loaded, but may not 40417c478bd9Sstevel@tonic-gate * yet be installed. 40427c478bd9Sstevel@tonic-gate */ 40437c478bd9Sstevel@tonic-gate on_mod->mod_ref++; 40447c478bd9Sstevel@tonic-gate ASSERT(on_mod->mod_ref && on_mod->mod_loaded); 40457c478bd9Sstevel@tonic-gate } 40467c478bd9Sstevel@tonic-gate 40477c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 40487c478bd9Sstevel@tonic-gate } 40497c478bd9Sstevel@tonic-gate 40507c478bd9Sstevel@tonic-gate /* 40517c478bd9Sstevel@tonic-gate * release the hold associated with mod_make_requisite mod_ref++ 40527c478bd9Sstevel@tonic-gate * as part of unload. 40537c478bd9Sstevel@tonic-gate */ 40547c478bd9Sstevel@tonic-gate void 40557c478bd9Sstevel@tonic-gate mod_release_requisites(struct modctl *modp) 40567c478bd9Sstevel@tonic-gate { 40577c478bd9Sstevel@tonic-gate struct modctl_list *modl; 40587c478bd9Sstevel@tonic-gate struct modctl_list *next; 40597c478bd9Sstevel@tonic-gate struct modctl *req; 40607c478bd9Sstevel@tonic-gate struct modctl_list *start = NULL, *mod_garbage; 40617c478bd9Sstevel@tonic-gate 40627c478bd9Sstevel@tonic-gate ASSERT(modp->mod_busy); 40637c478bd9Sstevel@tonic-gate ASSERT(!MUTEX_HELD(&mod_lock)); 40647c478bd9Sstevel@tonic-gate 40657c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); /* needed for manipulation of req */ 40667c478bd9Sstevel@tonic-gate for (modl = modp->mod_requisites; modl; modl = next) { 40677c478bd9Sstevel@tonic-gate next = modl->modl_next; 40687c478bd9Sstevel@tonic-gate req = modl->modl_modp; 40697c478bd9Sstevel@tonic-gate ASSERT(req->mod_ref >= 1 && req->mod_loaded); 40707c478bd9Sstevel@tonic-gate req->mod_ref--; 40717c478bd9Sstevel@tonic-gate 40727c478bd9Sstevel@tonic-gate /* 40737c478bd9Sstevel@tonic-gate * Check if the module has to be unloaded or not. 40747c478bd9Sstevel@tonic-gate */ 40757c478bd9Sstevel@tonic-gate if (req->mod_ref == 0 && req->mod_delay_unload) { 40767c478bd9Sstevel@tonic-gate struct modctl_list *new; 40777c478bd9Sstevel@tonic-gate /* 40787c478bd9Sstevel@tonic-gate * Allocate the modclt_list holding the garbage 40797c478bd9Sstevel@tonic-gate * module which should be unloaded later. 40807c478bd9Sstevel@tonic-gate */ 40817c478bd9Sstevel@tonic-gate new = kobj_zalloc(sizeof (struct modctl_list), 40827c478bd9Sstevel@tonic-gate KM_SLEEP); 40837c478bd9Sstevel@tonic-gate new->modl_modp = req; 40847c478bd9Sstevel@tonic-gate 40857c478bd9Sstevel@tonic-gate if (start == NULL) 40867c478bd9Sstevel@tonic-gate mod_garbage = start = new; 40877c478bd9Sstevel@tonic-gate else { 40887c478bd9Sstevel@tonic-gate mod_garbage->modl_next = new; 40897c478bd9Sstevel@tonic-gate mod_garbage = new; 40907c478bd9Sstevel@tonic-gate } 40917c478bd9Sstevel@tonic-gate } 40927c478bd9Sstevel@tonic-gate 40937c478bd9Sstevel@tonic-gate /* free the list as we go */ 40947c478bd9Sstevel@tonic-gate kobj_free(modl, sizeof (*modl)); 40957c478bd9Sstevel@tonic-gate } 40967c478bd9Sstevel@tonic-gate modp->mod_requisites = NULL; 40977c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 40987c478bd9Sstevel@tonic-gate 40997c478bd9Sstevel@tonic-gate /* 41007c478bd9Sstevel@tonic-gate * Unload the garbage modules. 41017c478bd9Sstevel@tonic-gate */ 41027c478bd9Sstevel@tonic-gate for (mod_garbage = start; mod_garbage != NULL; /* nothing */) { 41037c478bd9Sstevel@tonic-gate struct modctl_list *old = mod_garbage; 41047c478bd9Sstevel@tonic-gate struct modctl *mp = mod_garbage->modl_modp; 41057c478bd9Sstevel@tonic-gate ASSERT(mp != NULL); 41067c478bd9Sstevel@tonic-gate 41077c478bd9Sstevel@tonic-gate /* 41087c478bd9Sstevel@tonic-gate * Hold this module until it's unloaded completely. 41097c478bd9Sstevel@tonic-gate */ 41107c478bd9Sstevel@tonic-gate (void) mod_hold_by_modctl(mp, 41117c478bd9Sstevel@tonic-gate MOD_WAIT_FOREVER | MOD_LOCK_NOT_HELD); 41127c478bd9Sstevel@tonic-gate /* 41137c478bd9Sstevel@tonic-gate * Check if the module is not unloaded yet and nobody requires 41147c478bd9Sstevel@tonic-gate * the module. If it's unloaded already or somebody still 41157c478bd9Sstevel@tonic-gate * requires the module, don't unload it now. 41167c478bd9Sstevel@tonic-gate */ 41177c478bd9Sstevel@tonic-gate if (mp->mod_loaded && mp->mod_ref == 0) 41187c478bd9Sstevel@tonic-gate mod_unload(mp); 41197c478bd9Sstevel@tonic-gate ASSERT((mp->mod_loaded == 0 && mp->mod_delay_unload == 0) || 41207c478bd9Sstevel@tonic-gate (mp->mod_ref > 0)); 41217c478bd9Sstevel@tonic-gate mod_release_mod(mp); 41227c478bd9Sstevel@tonic-gate 41237c478bd9Sstevel@tonic-gate mod_garbage = mod_garbage->modl_next; 41247c478bd9Sstevel@tonic-gate kobj_free(old, sizeof (struct modctl_list)); 41257c478bd9Sstevel@tonic-gate } 41267c478bd9Sstevel@tonic-gate } 41277c478bd9Sstevel@tonic-gate 41287c478bd9Sstevel@tonic-gate /* 41297c478bd9Sstevel@tonic-gate * Process dependency of the module represented by "dep" on the 41307c478bd9Sstevel@tonic-gate * module named by "on." 41317c478bd9Sstevel@tonic-gate * 41327c478bd9Sstevel@tonic-gate * Called from kobj_do_dependents() to load a module "on" on which 41337c478bd9Sstevel@tonic-gate * "dep" depends. 41347c478bd9Sstevel@tonic-gate */ 41357c478bd9Sstevel@tonic-gate struct modctl * 41367c478bd9Sstevel@tonic-gate mod_load_requisite(struct modctl *dep, char *on) 41377c478bd9Sstevel@tonic-gate { 41387c478bd9Sstevel@tonic-gate struct modctl *on_mod; 41397c478bd9Sstevel@tonic-gate int retval; 41407c478bd9Sstevel@tonic-gate 41417c478bd9Sstevel@tonic-gate if ((on_mod = mod_hold_loaded_mod(dep, on, &retval)) != NULL) { 41427c478bd9Sstevel@tonic-gate mod_make_requisite(dep, on_mod); 41437c478bd9Sstevel@tonic-gate } else if (moddebug & MODDEBUG_ERRMSG) { 41447c478bd9Sstevel@tonic-gate printf("error processing %s on which module %s depends\n", 41451e1ddd6cScth on, dep->mod_modname); 41467c478bd9Sstevel@tonic-gate } 41477c478bd9Sstevel@tonic-gate return (on_mod); 41487c478bd9Sstevel@tonic-gate } 41497c478bd9Sstevel@tonic-gate 41507c478bd9Sstevel@tonic-gate static int 41517c478bd9Sstevel@tonic-gate mod_install_requisites(struct modctl *modp) 41527c478bd9Sstevel@tonic-gate { 41537c478bd9Sstevel@tonic-gate struct modctl_list *modl; 41547c478bd9Sstevel@tonic-gate struct modctl *req; 41557c478bd9Sstevel@tonic-gate int status = 0; 41567c478bd9Sstevel@tonic-gate 41577c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&mod_lock)); 41587c478bd9Sstevel@tonic-gate ASSERT(modp->mod_busy); 41597c478bd9Sstevel@tonic-gate 41607c478bd9Sstevel@tonic-gate for (modl = modp->mod_requisites; modl; modl = modl->modl_next) { 41617c478bd9Sstevel@tonic-gate req = modl->modl_modp; 41627c478bd9Sstevel@tonic-gate (void) mod_hold_by_modctl(req, 41637c478bd9Sstevel@tonic-gate MOD_WAIT_FOREVER | MOD_LOCK_NOT_HELD); 41647c478bd9Sstevel@tonic-gate status = modinstall(req); 41657c478bd9Sstevel@tonic-gate mod_release_mod(req); 41667c478bd9Sstevel@tonic-gate 41677c478bd9Sstevel@tonic-gate if (status != 0) 41687c478bd9Sstevel@tonic-gate break; 41697c478bd9Sstevel@tonic-gate } 41707c478bd9Sstevel@tonic-gate return (status); 41717c478bd9Sstevel@tonic-gate } 41727c478bd9Sstevel@tonic-gate 41737c478bd9Sstevel@tonic-gate /* 41747c478bd9Sstevel@tonic-gate * returns 1 if this thread is doing autounload, 0 otherwise. 41757c478bd9Sstevel@tonic-gate * see mod_uninstall_all. 41767c478bd9Sstevel@tonic-gate */ 41777c478bd9Sstevel@tonic-gate int 41787c478bd9Sstevel@tonic-gate mod_in_autounload() 41797c478bd9Sstevel@tonic-gate { 41807c478bd9Sstevel@tonic-gate return ((int)(uintptr_t)tsd_get(mod_autounload_key)); 41817c478bd9Sstevel@tonic-gate } 41827c478bd9Sstevel@tonic-gate 41837c478bd9Sstevel@tonic-gate /* 41847c478bd9Sstevel@tonic-gate * gmatch adapted from libc, stripping the wchar stuff 41857c478bd9Sstevel@tonic-gate */ 41861aef0e11Sjg #define popchar(p, c) { \ 41871aef0e11Sjg c = *p++; \ 41881aef0e11Sjg if (c == 0) { \ 41891aef0e11Sjg return (0); \ 41901aef0e11Sjg } \ 41911aef0e11Sjg } 41927c478bd9Sstevel@tonic-gate 4193facf4a8dSllai int 41947c478bd9Sstevel@tonic-gate gmatch(const char *s, const char *p) 41957c478bd9Sstevel@tonic-gate { 41967c478bd9Sstevel@tonic-gate int c, sc; 41977c478bd9Sstevel@tonic-gate int ok, lc, notflag; 41987c478bd9Sstevel@tonic-gate 41997c478bd9Sstevel@tonic-gate sc = *s++; 42007c478bd9Sstevel@tonic-gate c = *p++; 42017c478bd9Sstevel@tonic-gate if (c == 0) 42027c478bd9Sstevel@tonic-gate return (sc == c); /* nothing matches nothing */ 42037c478bd9Sstevel@tonic-gate 42047c478bd9Sstevel@tonic-gate switch (c) { 42057c478bd9Sstevel@tonic-gate case '\\': 42067c478bd9Sstevel@tonic-gate /* skip to quoted character */ 42071e1ddd6cScth popchar(p, c); 42087c478bd9Sstevel@tonic-gate /*FALLTHRU*/ 42097c478bd9Sstevel@tonic-gate 42107c478bd9Sstevel@tonic-gate default: 42117c478bd9Sstevel@tonic-gate /* straight comparison */ 42127c478bd9Sstevel@tonic-gate if (c != sc) 42137c478bd9Sstevel@tonic-gate return (0); 42147c478bd9Sstevel@tonic-gate /*FALLTHRU*/ 42157c478bd9Sstevel@tonic-gate 42167c478bd9Sstevel@tonic-gate case '?': 42177c478bd9Sstevel@tonic-gate /* first char matches, move to remainder */ 42187c478bd9Sstevel@tonic-gate return (sc != '\0' ? gmatch(s, p) : 0); 42197c478bd9Sstevel@tonic-gate 42207c478bd9Sstevel@tonic-gate 42217c478bd9Sstevel@tonic-gate case '*': 42227c478bd9Sstevel@tonic-gate while (*p == '*') 42237c478bd9Sstevel@tonic-gate p++; 42247c478bd9Sstevel@tonic-gate 42257c478bd9Sstevel@tonic-gate /* * matches everything */ 42267c478bd9Sstevel@tonic-gate if (*p == 0) 42277c478bd9Sstevel@tonic-gate return (1); 42287c478bd9Sstevel@tonic-gate 42297c478bd9Sstevel@tonic-gate /* undo skip at the beginning & iterate over substrings */ 42307c478bd9Sstevel@tonic-gate --s; 42317c478bd9Sstevel@tonic-gate while (*s) { 42327c478bd9Sstevel@tonic-gate if (gmatch(s, p)) 42337c478bd9Sstevel@tonic-gate return (1); 42347c478bd9Sstevel@tonic-gate s++; 42357c478bd9Sstevel@tonic-gate } 42367c478bd9Sstevel@tonic-gate return (0); 42377c478bd9Sstevel@tonic-gate 42387c478bd9Sstevel@tonic-gate case '[': 42397c478bd9Sstevel@tonic-gate /* match any char within [] */ 42407c478bd9Sstevel@tonic-gate if (sc == 0) 42417c478bd9Sstevel@tonic-gate return (0); 42427c478bd9Sstevel@tonic-gate 42437c478bd9Sstevel@tonic-gate ok = lc = notflag = 0; 42447c478bd9Sstevel@tonic-gate 42457c478bd9Sstevel@tonic-gate if (*p == '!') { 42467c478bd9Sstevel@tonic-gate notflag = 1; 42477c478bd9Sstevel@tonic-gate p++; 42487c478bd9Sstevel@tonic-gate } 42491e1ddd6cScth popchar(p, c); 42507c478bd9Sstevel@tonic-gate 42517c478bd9Sstevel@tonic-gate do { 42527c478bd9Sstevel@tonic-gate if (c == '-' && lc && *p != ']') { 42537c478bd9Sstevel@tonic-gate /* test sc against range [c1-c2] */ 42541e1ddd6cScth popchar(p, c); 42557c478bd9Sstevel@tonic-gate if (c == '\\') { 42561e1ddd6cScth popchar(p, c); 42577c478bd9Sstevel@tonic-gate } 42587c478bd9Sstevel@tonic-gate 42597c478bd9Sstevel@tonic-gate if (notflag) { 42607c478bd9Sstevel@tonic-gate /* return 0 on mismatch */ 42617c478bd9Sstevel@tonic-gate if (lc <= sc && sc <= c) 42627c478bd9Sstevel@tonic-gate return (0); 42637c478bd9Sstevel@tonic-gate ok++; 42647c478bd9Sstevel@tonic-gate } else if (lc <= sc && sc <= c) { 42657c478bd9Sstevel@tonic-gate ok++; 42667c478bd9Sstevel@tonic-gate } 42677c478bd9Sstevel@tonic-gate /* keep going, may get a match next */ 42687c478bd9Sstevel@tonic-gate } else if (c == '\\') { 42697c478bd9Sstevel@tonic-gate /* skip to quoted character */ 42701e1ddd6cScth popchar(p, c); 42717c478bd9Sstevel@tonic-gate } 42727c478bd9Sstevel@tonic-gate lc = c; 42737c478bd9Sstevel@tonic-gate if (notflag) { 42747c478bd9Sstevel@tonic-gate if (sc == lc) 42757c478bd9Sstevel@tonic-gate return (0); 42767c478bd9Sstevel@tonic-gate ok++; 42777c478bd9Sstevel@tonic-gate } else if (sc == lc) { 42787c478bd9Sstevel@tonic-gate ok++; 42797c478bd9Sstevel@tonic-gate } 42801e1ddd6cScth popchar(p, c); 42817c478bd9Sstevel@tonic-gate } while (c != ']'); 42827c478bd9Sstevel@tonic-gate 42837c478bd9Sstevel@tonic-gate /* recurse on remainder of string */ 42847c478bd9Sstevel@tonic-gate return (ok ? gmatch(s, p) : 0); 42857c478bd9Sstevel@tonic-gate } 42867c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 42877c478bd9Sstevel@tonic-gate } 42887c478bd9Sstevel@tonic-gate 42897c478bd9Sstevel@tonic-gate 42907c478bd9Sstevel@tonic-gate /* 42917c478bd9Sstevel@tonic-gate * Get default perm for device from /etc/minor_perm. Return 0 if match found. 42927c478bd9Sstevel@tonic-gate * 42937c478bd9Sstevel@tonic-gate * Pure wild-carded patterns are handled separately so the ordering of 42947c478bd9Sstevel@tonic-gate * these patterns doesn't matter. We're still dependent on ordering 42957c478bd9Sstevel@tonic-gate * however as the first matching entry is the one returned. 42967c478bd9Sstevel@tonic-gate * Not ideal but all existing examples and usage do imply this 42977c478bd9Sstevel@tonic-gate * ordering implicitly. 42987c478bd9Sstevel@tonic-gate * 42997c478bd9Sstevel@tonic-gate * Drivers using the clone driver are always good for some entertainment. 43007c478bd9Sstevel@tonic-gate * Clone nodes under pseudo have the form clone@0:<driver>. Some minor 43017c478bd9Sstevel@tonic-gate * perm entries have the form clone:<driver>, others use <driver>:* 43027c478bd9Sstevel@tonic-gate * Examples are clone:llc1 vs. llc2:*, for example. 43037c478bd9Sstevel@tonic-gate * 43047c478bd9Sstevel@tonic-gate * Minor perms in the clone:<driver> form are mapped to the drivers's 43057c478bd9Sstevel@tonic-gate * mperm list, not the clone driver, as wildcard entries for clone 43067c478bd9Sstevel@tonic-gate * reference only. In other words, a clone wildcard will match 43077c478bd9Sstevel@tonic-gate * references for clone@0:<driver> but never <driver>@<minor>. 43087c478bd9Sstevel@tonic-gate * 43097c478bd9Sstevel@tonic-gate * Additional minor perms in the standard form are also supported, 43107c478bd9Sstevel@tonic-gate * for mixed usage, ie a node with an entry clone:<driver> could 43117c478bd9Sstevel@tonic-gate * provide further entries <driver>:<minor>. 43127c478bd9Sstevel@tonic-gate * 43137c478bd9Sstevel@tonic-gate * Finally, some uses of clone use an alias as the minor name rather 43147c478bd9Sstevel@tonic-gate * than the driver name, with the alias as the minor perm entry. 43157c478bd9Sstevel@tonic-gate * This case is handled by attaching the driver to bring its 43167c478bd9Sstevel@tonic-gate * minor list into existence, then discover the alias via DDI_ALIAS. 43177c478bd9Sstevel@tonic-gate * The clone device's minor perm list can then be searched for 43187c478bd9Sstevel@tonic-gate * that alias. 43197c478bd9Sstevel@tonic-gate */ 43207c478bd9Sstevel@tonic-gate 43217c478bd9Sstevel@tonic-gate static int 43227c478bd9Sstevel@tonic-gate dev_alias_minorperm(dev_info_t *dip, char *minor_name, mperm_t *rmp) 43237c478bd9Sstevel@tonic-gate { 4324b9ccdc5aScth major_t major; 4325b9ccdc5aScth struct devnames *dnp; 4326b9ccdc5aScth mperm_t *mp; 4327b9ccdc5aScth char *alias = NULL; 4328b9ccdc5aScth dev_info_t *cdevi; 4329b9ccdc5aScth int circ; 4330b9ccdc5aScth struct ddi_minor_data *dmd; 43317c478bd9Sstevel@tonic-gate 43327c478bd9Sstevel@tonic-gate major = ddi_name_to_major(minor_name); 43337c478bd9Sstevel@tonic-gate 43347c478bd9Sstevel@tonic-gate ASSERT(dip == clone_dip); 4335a204de77Scth ASSERT(major != DDI_MAJOR_T_NONE); 43367c478bd9Sstevel@tonic-gate 43377c478bd9Sstevel@tonic-gate /* 43387c478bd9Sstevel@tonic-gate * Attach the driver named by the minor node, then 43397c478bd9Sstevel@tonic-gate * search its first instance's minor list for an 43407c478bd9Sstevel@tonic-gate * alias node. 43417c478bd9Sstevel@tonic-gate */ 43427c478bd9Sstevel@tonic-gate if (ddi_hold_installed_driver(major) == NULL) 43437c478bd9Sstevel@tonic-gate return (1); 43447c478bd9Sstevel@tonic-gate 43457c478bd9Sstevel@tonic-gate dnp = &devnamesp[major]; 43467c478bd9Sstevel@tonic-gate LOCK_DEV_OPS(&dnp->dn_lock); 43477c478bd9Sstevel@tonic-gate 43487c478bd9Sstevel@tonic-gate if ((cdevi = dnp->dn_head) != NULL) { 4349b9ccdc5aScth ndi_devi_enter(cdevi, &circ); 43507c478bd9Sstevel@tonic-gate for (dmd = DEVI(cdevi)->devi_minor; dmd; dmd = dmd->next) { 43517c478bd9Sstevel@tonic-gate if (dmd->type == DDM_ALIAS) { 43527c478bd9Sstevel@tonic-gate alias = i_ddi_strdup(dmd->ddm_name, KM_SLEEP); 43537c478bd9Sstevel@tonic-gate break; 43547c478bd9Sstevel@tonic-gate } 43557c478bd9Sstevel@tonic-gate } 4356b9ccdc5aScth ndi_devi_exit(cdevi, circ); 43577c478bd9Sstevel@tonic-gate } 43587c478bd9Sstevel@tonic-gate 43597c478bd9Sstevel@tonic-gate UNLOCK_DEV_OPS(&dnp->dn_lock); 43607c478bd9Sstevel@tonic-gate ddi_rele_driver(major); 43617c478bd9Sstevel@tonic-gate 43627c478bd9Sstevel@tonic-gate if (alias == NULL) { 43637c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MINORPERM) 43647c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, "dev_minorperm: " 43657c478bd9Sstevel@tonic-gate "no alias for %s\n", minor_name); 43667c478bd9Sstevel@tonic-gate return (1); 43677c478bd9Sstevel@tonic-gate } 43687c478bd9Sstevel@tonic-gate 43697c478bd9Sstevel@tonic-gate major = ddi_driver_major(clone_dip); 43707c478bd9Sstevel@tonic-gate dnp = &devnamesp[major]; 43717c478bd9Sstevel@tonic-gate LOCK_DEV_OPS(&dnp->dn_lock); 43727c478bd9Sstevel@tonic-gate 43737c478bd9Sstevel@tonic-gate /* 43747c478bd9Sstevel@tonic-gate * Go through the clone driver's mperm list looking 43757c478bd9Sstevel@tonic-gate * for a match for the specified alias. 43767c478bd9Sstevel@tonic-gate */ 43777c478bd9Sstevel@tonic-gate for (mp = dnp->dn_mperm; mp; mp = mp->mp_next) { 43787c478bd9Sstevel@tonic-gate if (strcmp(alias, mp->mp_minorname) == 0) { 43797c478bd9Sstevel@tonic-gate break; 43807c478bd9Sstevel@tonic-gate } 43817c478bd9Sstevel@tonic-gate } 43827c478bd9Sstevel@tonic-gate 43837c478bd9Sstevel@tonic-gate if (mp) { 43847c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MP_MATCH) { 43857c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, 43867c478bd9Sstevel@tonic-gate "minor perm defaults: %s %s 0%o %d %d (aliased)\n", 43877c478bd9Sstevel@tonic-gate minor_name, alias, mp->mp_mode, 43887c478bd9Sstevel@tonic-gate mp->mp_uid, mp->mp_gid); 43897c478bd9Sstevel@tonic-gate } 43907c478bd9Sstevel@tonic-gate rmp->mp_uid = mp->mp_uid; 43917c478bd9Sstevel@tonic-gate rmp->mp_gid = mp->mp_gid; 43927c478bd9Sstevel@tonic-gate rmp->mp_mode = mp->mp_mode; 43937c478bd9Sstevel@tonic-gate } 43947c478bd9Sstevel@tonic-gate UNLOCK_DEV_OPS(&dnp->dn_lock); 43957c478bd9Sstevel@tonic-gate 43967c478bd9Sstevel@tonic-gate kmem_free(alias, strlen(alias)+1); 43977c478bd9Sstevel@tonic-gate 43987c478bd9Sstevel@tonic-gate return (mp == NULL); 43997c478bd9Sstevel@tonic-gate } 44007c478bd9Sstevel@tonic-gate 44017c478bd9Sstevel@tonic-gate int 44027c478bd9Sstevel@tonic-gate dev_minorperm(dev_info_t *dip, char *name, mperm_t *rmp) 44037c478bd9Sstevel@tonic-gate { 44047c478bd9Sstevel@tonic-gate major_t major; 44057c478bd9Sstevel@tonic-gate char *minor_name; 44067c478bd9Sstevel@tonic-gate struct devnames *dnp; 44077c478bd9Sstevel@tonic-gate mperm_t *mp; 44087c478bd9Sstevel@tonic-gate int is_clone = 0; 44097c478bd9Sstevel@tonic-gate 44107c478bd9Sstevel@tonic-gate if (!minorperm_loaded) { 44117c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MINORPERM) 44127c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, 44137c478bd9Sstevel@tonic-gate "%s: minor perm not yet loaded\n", name); 44147c478bd9Sstevel@tonic-gate return (1); 44157c478bd9Sstevel@tonic-gate } 44167c478bd9Sstevel@tonic-gate 44177c478bd9Sstevel@tonic-gate minor_name = strchr(name, ':'); 44187c478bd9Sstevel@tonic-gate if (minor_name == NULL) 44197c478bd9Sstevel@tonic-gate return (1); 44207c478bd9Sstevel@tonic-gate minor_name++; 44217c478bd9Sstevel@tonic-gate 44227c478bd9Sstevel@tonic-gate /* 44237c478bd9Sstevel@tonic-gate * If it's the clone driver, search the driver as named 44247c478bd9Sstevel@tonic-gate * by the minor. All clone minor perm entries other than 44257c478bd9Sstevel@tonic-gate * alias nodes are actually installed on the real driver's list. 44267c478bd9Sstevel@tonic-gate */ 44277c478bd9Sstevel@tonic-gate if (dip == clone_dip) { 44287c478bd9Sstevel@tonic-gate major = ddi_name_to_major(minor_name); 4429a204de77Scth if (major == DDI_MAJOR_T_NONE) { 44307c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MINORPERM) 44317c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, "dev_minorperm: " 44327c478bd9Sstevel@tonic-gate "%s: no such driver\n", minor_name); 44337c478bd9Sstevel@tonic-gate return (1); 44347c478bd9Sstevel@tonic-gate } 44357c478bd9Sstevel@tonic-gate is_clone = 1; 44367c478bd9Sstevel@tonic-gate } else { 44377c478bd9Sstevel@tonic-gate major = ddi_driver_major(dip); 4438a204de77Scth ASSERT(major != DDI_MAJOR_T_NONE); 44397c478bd9Sstevel@tonic-gate } 44407c478bd9Sstevel@tonic-gate 44417c478bd9Sstevel@tonic-gate dnp = &devnamesp[major]; 44427c478bd9Sstevel@tonic-gate LOCK_DEV_OPS(&dnp->dn_lock); 44437c478bd9Sstevel@tonic-gate 44447c478bd9Sstevel@tonic-gate /* 44457c478bd9Sstevel@tonic-gate * Go through the driver's mperm list looking for 44467c478bd9Sstevel@tonic-gate * a match for the specified minor. If there's 44477c478bd9Sstevel@tonic-gate * no matching pattern, use the wild card. 44487c478bd9Sstevel@tonic-gate * Defer to the clone wild for clone if specified, 44497c478bd9Sstevel@tonic-gate * otherwise fall back to the normal form. 44507c478bd9Sstevel@tonic-gate */ 44517c478bd9Sstevel@tonic-gate for (mp = dnp->dn_mperm; mp; mp = mp->mp_next) { 44527c478bd9Sstevel@tonic-gate if (gmatch(minor_name, mp->mp_minorname) != 0) { 44537c478bd9Sstevel@tonic-gate break; 44547c478bd9Sstevel@tonic-gate } 44557c478bd9Sstevel@tonic-gate } 44567c478bd9Sstevel@tonic-gate if (mp == NULL) { 44577c478bd9Sstevel@tonic-gate if (is_clone) 44587c478bd9Sstevel@tonic-gate mp = dnp->dn_mperm_clone; 44597c478bd9Sstevel@tonic-gate if (mp == NULL) 44607c478bd9Sstevel@tonic-gate mp = dnp->dn_mperm_wild; 44617c478bd9Sstevel@tonic-gate } 44627c478bd9Sstevel@tonic-gate 44637c478bd9Sstevel@tonic-gate if (mp) { 44647c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MP_MATCH) { 44657c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, 44667c478bd9Sstevel@tonic-gate "minor perm defaults: %s %s 0%o %d %d\n", 44677c478bd9Sstevel@tonic-gate name, mp->mp_minorname, mp->mp_mode, 44687c478bd9Sstevel@tonic-gate mp->mp_uid, mp->mp_gid); 44697c478bd9Sstevel@tonic-gate } 44707c478bd9Sstevel@tonic-gate rmp->mp_uid = mp->mp_uid; 44717c478bd9Sstevel@tonic-gate rmp->mp_gid = mp->mp_gid; 44727c478bd9Sstevel@tonic-gate rmp->mp_mode = mp->mp_mode; 44737c478bd9Sstevel@tonic-gate } 44747c478bd9Sstevel@tonic-gate UNLOCK_DEV_OPS(&dnp->dn_lock); 44757c478bd9Sstevel@tonic-gate 44767c478bd9Sstevel@tonic-gate /* 44777c478bd9Sstevel@tonic-gate * If no match can be found for a clone node, 44787c478bd9Sstevel@tonic-gate * search for a possible match for an alias. 44797c478bd9Sstevel@tonic-gate * One such example is /dev/ptmx -> /devices/pseudo/clone@0:ptm, 44807c478bd9Sstevel@tonic-gate * with minor perm entry clone:ptmx. 44817c478bd9Sstevel@tonic-gate */ 44827c478bd9Sstevel@tonic-gate if (mp == NULL && is_clone) { 44837c478bd9Sstevel@tonic-gate return (dev_alias_minorperm(dip, minor_name, rmp)); 44847c478bd9Sstevel@tonic-gate } 44857c478bd9Sstevel@tonic-gate 44867c478bd9Sstevel@tonic-gate return (mp == NULL); 44877c478bd9Sstevel@tonic-gate } 44887c478bd9Sstevel@tonic-gate 44897c478bd9Sstevel@tonic-gate /* 44907c478bd9Sstevel@tonic-gate * dynamicaly reference load a dl module/library, returning handle 44917c478bd9Sstevel@tonic-gate */ 44927c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 44937c478bd9Sstevel@tonic-gate ddi_modhandle_t 44947c478bd9Sstevel@tonic-gate ddi_modopen(const char *modname, int mode, int *errnop) 44957c478bd9Sstevel@tonic-gate { 44967c478bd9Sstevel@tonic-gate char *subdir; 44977c478bd9Sstevel@tonic-gate char *mod; 44987c478bd9Sstevel@tonic-gate int subdirlen; 44997c478bd9Sstevel@tonic-gate struct modctl *hmodp = NULL; 45007c478bd9Sstevel@tonic-gate int retval = EINVAL; 45017c478bd9Sstevel@tonic-gate 45027c478bd9Sstevel@tonic-gate ASSERT(modname && (mode == KRTLD_MODE_FIRST)); 45037c478bd9Sstevel@tonic-gate if ((modname == NULL) || (mode != KRTLD_MODE_FIRST)) 45047c478bd9Sstevel@tonic-gate goto out; 45057c478bd9Sstevel@tonic-gate 45061e1ddd6cScth /* find last '/' in modname */ 45071e1ddd6cScth mod = strrchr(modname, '/'); 45087c478bd9Sstevel@tonic-gate 45097c478bd9Sstevel@tonic-gate if (mod) { 45107c478bd9Sstevel@tonic-gate /* for subdir string without modification to argument */ 45117c478bd9Sstevel@tonic-gate mod++; 45127c478bd9Sstevel@tonic-gate subdirlen = mod - modname; 45137c478bd9Sstevel@tonic-gate subdir = kmem_alloc(subdirlen, KM_SLEEP); 45147c478bd9Sstevel@tonic-gate (void) strlcpy(subdir, modname, subdirlen); 45157c478bd9Sstevel@tonic-gate } else { 45167c478bd9Sstevel@tonic-gate subdirlen = 0; 45177c478bd9Sstevel@tonic-gate subdir = "misc"; 45187c478bd9Sstevel@tonic-gate mod = (char *)modname; 45197c478bd9Sstevel@tonic-gate } 45207c478bd9Sstevel@tonic-gate 45217c478bd9Sstevel@tonic-gate /* reference load with errno return value */ 45227c478bd9Sstevel@tonic-gate retval = modrload(subdir, mod, &hmodp); 45237c478bd9Sstevel@tonic-gate 45247c478bd9Sstevel@tonic-gate if (subdirlen) 45257c478bd9Sstevel@tonic-gate kmem_free(subdir, subdirlen); 45267c478bd9Sstevel@tonic-gate 45277c478bd9Sstevel@tonic-gate out: if (errnop) 45287c478bd9Sstevel@tonic-gate *errnop = retval; 45297c478bd9Sstevel@tonic-gate 45307c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_DDI_MOD) 45317c478bd9Sstevel@tonic-gate printf("ddi_modopen %s mode %x: %s %p %d\n", 45327c478bd9Sstevel@tonic-gate modname ? modname : "<unknown>", mode, 45337c478bd9Sstevel@tonic-gate hmodp ? hmodp->mod_filename : "<unknown>", 45347c478bd9Sstevel@tonic-gate (void *)hmodp, retval); 45357c478bd9Sstevel@tonic-gate 45367c478bd9Sstevel@tonic-gate return ((ddi_modhandle_t)hmodp); 45377c478bd9Sstevel@tonic-gate } 45387c478bd9Sstevel@tonic-gate 45397c478bd9Sstevel@tonic-gate /* lookup "name" in open dl module/library */ 45407c478bd9Sstevel@tonic-gate void * 45417c478bd9Sstevel@tonic-gate ddi_modsym(ddi_modhandle_t h, const char *name, int *errnop) 45427c478bd9Sstevel@tonic-gate { 45437c478bd9Sstevel@tonic-gate struct modctl *hmodp = (struct modctl *)h; 45447c478bd9Sstevel@tonic-gate void *f; 45457c478bd9Sstevel@tonic-gate int retval; 45467c478bd9Sstevel@tonic-gate 45477c478bd9Sstevel@tonic-gate ASSERT(hmodp && name && hmodp->mod_installed && (hmodp->mod_ref >= 1)); 45487c478bd9Sstevel@tonic-gate if ((hmodp == NULL) || (name == NULL) || 45497c478bd9Sstevel@tonic-gate (hmodp->mod_installed == 0) || (hmodp->mod_ref < 1)) { 45507c478bd9Sstevel@tonic-gate f = NULL; 45517c478bd9Sstevel@tonic-gate retval = EINVAL; 45527c478bd9Sstevel@tonic-gate } else { 45537c478bd9Sstevel@tonic-gate f = (void *)kobj_lookup(hmodp->mod_mp, (char *)name); 45547c478bd9Sstevel@tonic-gate if (f) 45557c478bd9Sstevel@tonic-gate retval = 0; 45567c478bd9Sstevel@tonic-gate else 45577c478bd9Sstevel@tonic-gate retval = ENOTSUP; 45587c478bd9Sstevel@tonic-gate } 45597c478bd9Sstevel@tonic-gate 45607c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_DDI_MOD) 45617c478bd9Sstevel@tonic-gate printf("ddi_modsym in %s of %s: %d %p\n", 45627c478bd9Sstevel@tonic-gate hmodp ? hmodp->mod_modname : "<unknown>", 45637c478bd9Sstevel@tonic-gate name ? name : "<unknown>", retval, f); 45647c478bd9Sstevel@tonic-gate 45657c478bd9Sstevel@tonic-gate if (errnop) 45667c478bd9Sstevel@tonic-gate *errnop = retval; 45677c478bd9Sstevel@tonic-gate return (f); 45687c478bd9Sstevel@tonic-gate } 45697c478bd9Sstevel@tonic-gate 45707c478bd9Sstevel@tonic-gate /* dynamic (un)reference unload of an open dl module/library */ 45717c478bd9Sstevel@tonic-gate int 45727c478bd9Sstevel@tonic-gate ddi_modclose(ddi_modhandle_t h) 45737c478bd9Sstevel@tonic-gate { 45747c478bd9Sstevel@tonic-gate struct modctl *hmodp = (struct modctl *)h; 45757c478bd9Sstevel@tonic-gate struct modctl *modp = NULL; 45767c478bd9Sstevel@tonic-gate int retval; 45777c478bd9Sstevel@tonic-gate 45787c478bd9Sstevel@tonic-gate ASSERT(hmodp && hmodp->mod_installed && (hmodp->mod_ref >= 1)); 45797c478bd9Sstevel@tonic-gate if ((hmodp == NULL) || 45807c478bd9Sstevel@tonic-gate (hmodp->mod_installed == 0) || (hmodp->mod_ref < 1)) { 45817c478bd9Sstevel@tonic-gate retval = EINVAL; 45827c478bd9Sstevel@tonic-gate goto out; 45837c478bd9Sstevel@tonic-gate } 45847c478bd9Sstevel@tonic-gate 45857c478bd9Sstevel@tonic-gate retval = modunrload(hmodp->mod_id, &modp, ddi_modclose_unload); 45867c478bd9Sstevel@tonic-gate if (retval == EBUSY) 45877c478bd9Sstevel@tonic-gate retval = 0; /* EBUSY is not an error */ 45887c478bd9Sstevel@tonic-gate 45897c478bd9Sstevel@tonic-gate if (retval == 0) { 45907c478bd9Sstevel@tonic-gate ASSERT(hmodp == modp); 45917c478bd9Sstevel@tonic-gate if (hmodp != modp) 45927c478bd9Sstevel@tonic-gate retval = EINVAL; 45937c478bd9Sstevel@tonic-gate } 45947c478bd9Sstevel@tonic-gate 45957c478bd9Sstevel@tonic-gate out: if (moddebug & MODDEBUG_DDI_MOD) 45967c478bd9Sstevel@tonic-gate printf("ddi_modclose %s: %d\n", 45977c478bd9Sstevel@tonic-gate hmodp ? hmodp->mod_modname : "<unknown>", retval); 45987c478bd9Sstevel@tonic-gate 45997c478bd9Sstevel@tonic-gate return (retval); 46007c478bd9Sstevel@tonic-gate } 4601