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 57c478bd9Sstevel@tonic-gate * Common Development and Distribution License, Version 1.0 only 67c478bd9Sstevel@tonic-gate * (the "License"). You may not use this file except in compliance 77c478bd9Sstevel@tonic-gate * with the License. 87c478bd9Sstevel@tonic-gate * 97c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 107c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 117c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 127c478bd9Sstevel@tonic-gate * and limitations under the License. 137c478bd9Sstevel@tonic-gate * 147c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 157c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 167c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 177c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 187c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 197c478bd9Sstevel@tonic-gate * 207c478bd9Sstevel@tonic-gate * CDDL HEADER END 217c478bd9Sstevel@tonic-gate */ 227c478bd9Sstevel@tonic-gate /* 237c478bd9Sstevel@tonic-gate * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 287c478bd9Sstevel@tonic-gate 297c478bd9Sstevel@tonic-gate /* 307c478bd9Sstevel@tonic-gate * modctl system call for loadable module support. 317c478bd9Sstevel@tonic-gate */ 327c478bd9Sstevel@tonic-gate 337c478bd9Sstevel@tonic-gate #include <sys/param.h> 347c478bd9Sstevel@tonic-gate #include <sys/user.h> 357c478bd9Sstevel@tonic-gate #include <sys/systm.h> 367c478bd9Sstevel@tonic-gate #include <sys/exec.h> 377c478bd9Sstevel@tonic-gate #include <sys/file.h> 387c478bd9Sstevel@tonic-gate #include <sys/stat.h> 397c478bd9Sstevel@tonic-gate #include <sys/conf.h> 407c478bd9Sstevel@tonic-gate #include <sys/time.h> 417c478bd9Sstevel@tonic-gate #include <sys/reboot.h> 427c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_fsdir.h> 437c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 447c478bd9Sstevel@tonic-gate #include <sys/sysconf.h> 457c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 467c478bd9Sstevel@tonic-gate #include <sys/ddi.h> 477c478bd9Sstevel@tonic-gate #include <sys/sunddi.h> 487c478bd9Sstevel@tonic-gate #include <sys/sunndi.h> 497c478bd9Sstevel@tonic-gate #include <sys/ndi_impldefs.h> 507c478bd9Sstevel@tonic-gate #include <sys/ddi_impldefs.h> 517c478bd9Sstevel@tonic-gate #include <sys/ddi_implfuncs.h> 527c478bd9Sstevel@tonic-gate #include <sys/bootconf.h> 537c478bd9Sstevel@tonic-gate #include <sys/dc_ki.h> 547c478bd9Sstevel@tonic-gate #include <sys/cladm.h> 557c478bd9Sstevel@tonic-gate #include <sys/dtrace.h> 567c478bd9Sstevel@tonic-gate #include <sys/kdi.h> 577c478bd9Sstevel@tonic-gate 587c478bd9Sstevel@tonic-gate #include <sys/devpolicy.h> 597c478bd9Sstevel@tonic-gate #include <sys/modctl.h> 607c478bd9Sstevel@tonic-gate #include <sys/kobj.h> 617c478bd9Sstevel@tonic-gate #include <sys/devops.h> 627c478bd9Sstevel@tonic-gate #include <sys/autoconf.h> 637c478bd9Sstevel@tonic-gate #include <sys/hwconf.h> 647c478bd9Sstevel@tonic-gate #include <sys/callb.h> 657c478bd9Sstevel@tonic-gate #include <sys/debug.h> 667c478bd9Sstevel@tonic-gate #include <sys/cpuvar.h> 677c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 687c478bd9Sstevel@tonic-gate #include <sys/sysevent.h> 697c478bd9Sstevel@tonic-gate #include <sys/sysevent_impl.h> 707c478bd9Sstevel@tonic-gate #include <sys/instance.h> 717c478bd9Sstevel@tonic-gate #include <sys/modhash.h> 727c478bd9Sstevel@tonic-gate #include <sys/modhash_impl.h> 737c478bd9Sstevel@tonic-gate #include <sys/dacf_impl.h> 747c478bd9Sstevel@tonic-gate #include <sys/vfs.h> 757c478bd9Sstevel@tonic-gate #include <sys/pathname.h> 767c478bd9Sstevel@tonic-gate #include <sys/console.h> 777c478bd9Sstevel@tonic-gate #include <sys/policy.h> 787c478bd9Sstevel@tonic-gate #include <ipp/ipp_impl.h> 797c478bd9Sstevel@tonic-gate #include <sys/fs/dv_node.h> 807c478bd9Sstevel@tonic-gate #include <sys/strsubr.h> 817c478bd9Sstevel@tonic-gate 827c478bd9Sstevel@tonic-gate static int mod_circdep(struct modctl *); 837c478bd9Sstevel@tonic-gate static int modinfo(modid_t, struct modinfo *); 847c478bd9Sstevel@tonic-gate 857c478bd9Sstevel@tonic-gate static void mod_uninstall_all(void); 867c478bd9Sstevel@tonic-gate static int mod_getinfo(struct modctl *, struct modinfo *); 877c478bd9Sstevel@tonic-gate static struct modctl *allocate_modp(char *, char *); 887c478bd9Sstevel@tonic-gate 897c478bd9Sstevel@tonic-gate static int mod_load(struct modctl *, int); 907c478bd9Sstevel@tonic-gate static void mod_unload(struct modctl *); 917c478bd9Sstevel@tonic-gate static int modinstall(struct modctl *); 927c478bd9Sstevel@tonic-gate static int moduninstall(struct modctl *); 937c478bd9Sstevel@tonic-gate 947c478bd9Sstevel@tonic-gate static struct modctl *mod_hold_by_name_common(struct modctl *, char *); 957c478bd9Sstevel@tonic-gate static struct modctl *mod_hold_by_id(modid_t); 967c478bd9Sstevel@tonic-gate static struct modctl *mod_hold_next_by_id(modid_t); 977c478bd9Sstevel@tonic-gate static struct modctl *mod_hold_loaded_mod(struct modctl *, char *, int *); 987c478bd9Sstevel@tonic-gate static struct modctl *mod_hold_installed_mod(char *, int, int *); 997c478bd9Sstevel@tonic-gate 1007c478bd9Sstevel@tonic-gate static void mod_release(struct modctl *); 1017c478bd9Sstevel@tonic-gate static void mod_make_requisite(struct modctl *, struct modctl *); 1027c478bd9Sstevel@tonic-gate static int mod_install_requisites(struct modctl *); 1037c478bd9Sstevel@tonic-gate static void check_esc_sequences(char *, char *); 1047c478bd9Sstevel@tonic-gate static struct modctl *mod_hold_by_name_requisite(struct modctl *, char *); 1057c478bd9Sstevel@tonic-gate 1067c478bd9Sstevel@tonic-gate /* 1077c478bd9Sstevel@tonic-gate * module loading thread control structure. Calls to kobj_load_module()() are 1087c478bd9Sstevel@tonic-gate * handled off to a separate thead using this structure. 1097c478bd9Sstevel@tonic-gate */ 1107c478bd9Sstevel@tonic-gate struct loadmt { 1117c478bd9Sstevel@tonic-gate ksema_t sema; 1127c478bd9Sstevel@tonic-gate struct modctl *mp; 1137c478bd9Sstevel@tonic-gate int usepath; 1147c478bd9Sstevel@tonic-gate kthread_t *owner; 1157c478bd9Sstevel@tonic-gate int retval; 1167c478bd9Sstevel@tonic-gate }; 1177c478bd9Sstevel@tonic-gate 1187c478bd9Sstevel@tonic-gate static void modload_thread(struct loadmt *); 1197c478bd9Sstevel@tonic-gate 1207c478bd9Sstevel@tonic-gate kcondvar_t mod_cv; 1217c478bd9Sstevel@tonic-gate kcondvar_t mod_uninstall_cv; /* Communication between swapper */ 1227c478bd9Sstevel@tonic-gate /* and the uninstall daemon. */ 1237c478bd9Sstevel@tonic-gate kmutex_t mod_lock; /* protects &modules insert linkage, */ 1247c478bd9Sstevel@tonic-gate /* mod_busy, mod_want, and mod_ref. */ 1257c478bd9Sstevel@tonic-gate /* blocking operations while holding */ 1267c478bd9Sstevel@tonic-gate /* mod_lock should be avoided */ 1277c478bd9Sstevel@tonic-gate kmutex_t mod_uninstall_lock; /* protects mod_uninstall_cv */ 1287c478bd9Sstevel@tonic-gate kthread_id_t mod_aul_thread; 1297c478bd9Sstevel@tonic-gate 1307c478bd9Sstevel@tonic-gate int isminiroot; /* set if running as miniroot */ 1317c478bd9Sstevel@tonic-gate int modrootloaded; /* set after root driver and fs are loaded */ 1327c478bd9Sstevel@tonic-gate int moddebug = 0x0; /* debug flags for module writers */ 1337c478bd9Sstevel@tonic-gate int swaploaded; /* set after swap driver and fs are loaded */ 1347c478bd9Sstevel@tonic-gate int bop_io_quiesced = 0; /* set when BOP I/O can no longer be used */ 1357c478bd9Sstevel@tonic-gate int last_module_id; 1367c478bd9Sstevel@tonic-gate clock_t mod_uninstall_interval = 0; 1377c478bd9Sstevel@tonic-gate int ddi_modclose_unload = 1; /* 0 -> just decrement reference */ 1387c478bd9Sstevel@tonic-gate 1397c478bd9Sstevel@tonic-gate struct devnames *devnamesp; 1407c478bd9Sstevel@tonic-gate struct devnames orphanlist; 1417c478bd9Sstevel@tonic-gate 1427c478bd9Sstevel@tonic-gate krwlock_t devinfo_tree_lock; /* obsolete, to be removed */ 1437c478bd9Sstevel@tonic-gate 1447c478bd9Sstevel@tonic-gate #define MAJBINDFILE "/etc/name_to_major" 1457c478bd9Sstevel@tonic-gate #define SYSBINDFILE "/etc/name_to_sysnum" 1467c478bd9Sstevel@tonic-gate 1477c478bd9Sstevel@tonic-gate static char majbind[] = MAJBINDFILE; 1487c478bd9Sstevel@tonic-gate static char sysbind[] = SYSBINDFILE; 1497c478bd9Sstevel@tonic-gate static uint_t mod_autounload_key; /* for module autounload detection */ 1507c478bd9Sstevel@tonic-gate 1517c478bd9Sstevel@tonic-gate extern int obpdebug; 1527c478bd9Sstevel@tonic-gate extern int make_mbind(char *, int, char *, struct bind **); 1537c478bd9Sstevel@tonic-gate 1547c478bd9Sstevel@tonic-gate #define DEBUGGER_PRESENT ((boothowto & RB_DEBUG) || (obpdebug != 0)) 1557c478bd9Sstevel@tonic-gate 1567c478bd9Sstevel@tonic-gate static int minorperm_loaded = 0; 1577c478bd9Sstevel@tonic-gate 1587c478bd9Sstevel@tonic-gate 1597c478bd9Sstevel@tonic-gate 1607c478bd9Sstevel@tonic-gate void 1617c478bd9Sstevel@tonic-gate mod_setup(void) 1627c478bd9Sstevel@tonic-gate { 1637c478bd9Sstevel@tonic-gate struct sysent *callp; 1647c478bd9Sstevel@tonic-gate int callnum, exectype; 1657c478bd9Sstevel@tonic-gate int num_devs; 1667c478bd9Sstevel@tonic-gate int i; 1677c478bd9Sstevel@tonic-gate 1687c478bd9Sstevel@tonic-gate /* 1697c478bd9Sstevel@tonic-gate * Initialize the list of loaded driver dev_ops. 1707c478bd9Sstevel@tonic-gate * XXX - This must be done before reading the system file so that 1717c478bd9Sstevel@tonic-gate * forceloads of drivers will work. 1727c478bd9Sstevel@tonic-gate */ 1737c478bd9Sstevel@tonic-gate num_devs = read_binding_file(majbind, mb_hashtab, make_mbind); 1747c478bd9Sstevel@tonic-gate /* 1757c478bd9Sstevel@tonic-gate * Since read_binding_file is common code, it doesn't enforce that all 1767c478bd9Sstevel@tonic-gate * of the binding file entries have major numbers <= MAXMAJ32. Thus, 1777c478bd9Sstevel@tonic-gate * ensure that we don't allocate some massive amount of space due to a 1787c478bd9Sstevel@tonic-gate * bad entry. We can't have major numbers bigger than MAXMAJ32 1797c478bd9Sstevel@tonic-gate * until file system support for larger major numbers exists. 1807c478bd9Sstevel@tonic-gate */ 1817c478bd9Sstevel@tonic-gate 1827c478bd9Sstevel@tonic-gate /* 1837c478bd9Sstevel@tonic-gate * Leave space for expansion, but not more than L_MAXMAJ32 1847c478bd9Sstevel@tonic-gate */ 1857c478bd9Sstevel@tonic-gate devcnt = MIN(num_devs + 30, L_MAXMAJ32); 1867c478bd9Sstevel@tonic-gate devopsp = kmem_alloc(devcnt * sizeof (struct dev_ops *), KM_SLEEP); 1877c478bd9Sstevel@tonic-gate for (i = 0; i < devcnt; i++) 1887c478bd9Sstevel@tonic-gate devopsp[i] = &mod_nodev_ops; 1897c478bd9Sstevel@tonic-gate 1907c478bd9Sstevel@tonic-gate init_devnamesp(devcnt); 1917c478bd9Sstevel@tonic-gate 1927c478bd9Sstevel@tonic-gate /* 1937c478bd9Sstevel@tonic-gate * Sync up with the work that the stand-alone linker has already done. 1947c478bd9Sstevel@tonic-gate */ 1957c478bd9Sstevel@tonic-gate (void) kobj_sync(); 1967c478bd9Sstevel@tonic-gate 1977c478bd9Sstevel@tonic-gate if (boothowto & RB_DEBUG) 1987c478bd9Sstevel@tonic-gate kdi_dvec_modavail(); 1997c478bd9Sstevel@tonic-gate 2007c478bd9Sstevel@tonic-gate make_aliases(mb_hashtab); 2017c478bd9Sstevel@tonic-gate 2027c478bd9Sstevel@tonic-gate /* 2037c478bd9Sstevel@tonic-gate * Initialize streams device implementation structures. 2047c478bd9Sstevel@tonic-gate */ 2057c478bd9Sstevel@tonic-gate devimpl = kmem_zalloc(devcnt * sizeof (cdevsw_impl_t), KM_SLEEP); 2067c478bd9Sstevel@tonic-gate 2077c478bd9Sstevel@tonic-gate /* 2087c478bd9Sstevel@tonic-gate * If the cl_bootstrap module is present, 2097c478bd9Sstevel@tonic-gate * we should be configured as a cluster. Loading this module 2107c478bd9Sstevel@tonic-gate * will set "cluster_bootflags" to non-zero. 2117c478bd9Sstevel@tonic-gate */ 2127c478bd9Sstevel@tonic-gate (void) modload("misc", "cl_bootstrap"); 2137c478bd9Sstevel@tonic-gate 2147c478bd9Sstevel@tonic-gate (void) read_binding_file(sysbind, sb_hashtab, make_mbind); 2157c478bd9Sstevel@tonic-gate init_syscallnames(NSYSCALL); 2167c478bd9Sstevel@tonic-gate 2177c478bd9Sstevel@tonic-gate /* 2187c478bd9Sstevel@tonic-gate * Start up dynamic autoconfiguration framework (dacf). 2197c478bd9Sstevel@tonic-gate */ 2207c478bd9Sstevel@tonic-gate mod_hash_init(); 2217c478bd9Sstevel@tonic-gate dacf_init(); 2227c478bd9Sstevel@tonic-gate 2237c478bd9Sstevel@tonic-gate /* 2247c478bd9Sstevel@tonic-gate * Start up IP policy framework (ipp). 2257c478bd9Sstevel@tonic-gate */ 2267c478bd9Sstevel@tonic-gate ipp_init(); 2277c478bd9Sstevel@tonic-gate 2287c478bd9Sstevel@tonic-gate /* 2297c478bd9Sstevel@tonic-gate * Allocate loadable native system call locks. 2307c478bd9Sstevel@tonic-gate */ 2317c478bd9Sstevel@tonic-gate for (callnum = 0, callp = sysent; callnum < NSYSCALL; 2327c478bd9Sstevel@tonic-gate callnum++, callp++) { 2337c478bd9Sstevel@tonic-gate if (LOADABLE_SYSCALL(callp)) { 2347c478bd9Sstevel@tonic-gate if (mod_getsysname(callnum) != NULL) { 2357c478bd9Sstevel@tonic-gate callp->sy_lock = 2367c478bd9Sstevel@tonic-gate kobj_zalloc(sizeof (krwlock_t), KM_SLEEP); 2377c478bd9Sstevel@tonic-gate rw_init(callp->sy_lock, NULL, RW_DEFAULT, NULL); 2387c478bd9Sstevel@tonic-gate } else { 2397c478bd9Sstevel@tonic-gate callp->sy_flags &= ~SE_LOADABLE; 2407c478bd9Sstevel@tonic-gate callp->sy_callc = nosys; 2417c478bd9Sstevel@tonic-gate } 2427c478bd9Sstevel@tonic-gate #ifdef DEBUG 2437c478bd9Sstevel@tonic-gate } else { 2447c478bd9Sstevel@tonic-gate /* 2457c478bd9Sstevel@tonic-gate * Do some sanity checks on the sysent table 2467c478bd9Sstevel@tonic-gate */ 2477c478bd9Sstevel@tonic-gate switch (callp->sy_flags & SE_RVAL_MASK) { 2487c478bd9Sstevel@tonic-gate case SE_32RVAL1: 2497c478bd9Sstevel@tonic-gate /* only r_val1 returned */ 2507c478bd9Sstevel@tonic-gate case SE_32RVAL1 | SE_32RVAL2: 2517c478bd9Sstevel@tonic-gate /* r_val1 and r_val2 returned */ 2527c478bd9Sstevel@tonic-gate case SE_64RVAL: 2537c478bd9Sstevel@tonic-gate /* 64-bit rval returned */ 2547c478bd9Sstevel@tonic-gate break; 2557c478bd9Sstevel@tonic-gate default: 2567c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "sysent[%d]: bad flags %x", 2577c478bd9Sstevel@tonic-gate callnum, callp->sy_flags); 2587c478bd9Sstevel@tonic-gate } 2597c478bd9Sstevel@tonic-gate #endif 2607c478bd9Sstevel@tonic-gate } 2617c478bd9Sstevel@tonic-gate } 2627c478bd9Sstevel@tonic-gate 2637c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 2647c478bd9Sstevel@tonic-gate /* 2657c478bd9Sstevel@tonic-gate * Allocate loadable system call locks for 32-bit compat syscalls 2667c478bd9Sstevel@tonic-gate */ 2677c478bd9Sstevel@tonic-gate for (callnum = 0, callp = sysent32; callnum < NSYSCALL; 2687c478bd9Sstevel@tonic-gate callnum++, callp++) { 2697c478bd9Sstevel@tonic-gate if (LOADABLE_SYSCALL(callp)) { 2707c478bd9Sstevel@tonic-gate if (mod_getsysname(callnum) != NULL) { 2717c478bd9Sstevel@tonic-gate callp->sy_lock = 2727c478bd9Sstevel@tonic-gate kobj_zalloc(sizeof (krwlock_t), KM_SLEEP); 2737c478bd9Sstevel@tonic-gate rw_init(callp->sy_lock, NULL, RW_DEFAULT, NULL); 2747c478bd9Sstevel@tonic-gate } else { 2757c478bd9Sstevel@tonic-gate callp->sy_flags &= ~SE_LOADABLE; 2767c478bd9Sstevel@tonic-gate callp->sy_callc = nosys; 2777c478bd9Sstevel@tonic-gate } 2787c478bd9Sstevel@tonic-gate #ifdef DEBUG 2797c478bd9Sstevel@tonic-gate } else { 2807c478bd9Sstevel@tonic-gate /* 2817c478bd9Sstevel@tonic-gate * Do some sanity checks on the sysent table 2827c478bd9Sstevel@tonic-gate */ 2837c478bd9Sstevel@tonic-gate switch (callp->sy_flags & SE_RVAL_MASK) { 2847c478bd9Sstevel@tonic-gate case SE_32RVAL1: 2857c478bd9Sstevel@tonic-gate /* only r_val1 returned */ 2867c478bd9Sstevel@tonic-gate case SE_32RVAL1 | SE_32RVAL2: 2877c478bd9Sstevel@tonic-gate /* r_val1 and r_val2 returned */ 2887c478bd9Sstevel@tonic-gate case SE_64RVAL: 2897c478bd9Sstevel@tonic-gate /* 64-bit rval returned */ 2907c478bd9Sstevel@tonic-gate break; 2917c478bd9Sstevel@tonic-gate default: 2927c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "sysent32[%d]: bad flags %x", 2937c478bd9Sstevel@tonic-gate callnum, callp->sy_flags); 2947c478bd9Sstevel@tonic-gate goto skip; 2957c478bd9Sstevel@tonic-gate } 2967c478bd9Sstevel@tonic-gate 2977c478bd9Sstevel@tonic-gate /* 2987c478bd9Sstevel@tonic-gate * Cross-check the native and compatibility tables. 2997c478bd9Sstevel@tonic-gate */ 3007c478bd9Sstevel@tonic-gate if (callp->sy_callc == nosys || 3017c478bd9Sstevel@tonic-gate sysent[callnum].sy_callc == nosys) 3027c478bd9Sstevel@tonic-gate continue; 3037c478bd9Sstevel@tonic-gate /* 3047c478bd9Sstevel@tonic-gate * If only one or the other slot is loadable, then 3057c478bd9Sstevel@tonic-gate * there's an error -- they should match! 3067c478bd9Sstevel@tonic-gate */ 3077c478bd9Sstevel@tonic-gate if ((callp->sy_callc == loadable_syscall) ^ 3087c478bd9Sstevel@tonic-gate (sysent[callnum].sy_callc == loadable_syscall)) { 3097c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "sysent[%d] loadable?", 3107c478bd9Sstevel@tonic-gate callnum); 3117c478bd9Sstevel@tonic-gate } 3127c478bd9Sstevel@tonic-gate /* 3137c478bd9Sstevel@tonic-gate * This is more of a heuristic test -- if the 3147c478bd9Sstevel@tonic-gate * system call returns two values in the 32-bit 3157c478bd9Sstevel@tonic-gate * world, it should probably return two 32-bit 3167c478bd9Sstevel@tonic-gate * values in the 64-bit world too. 3177c478bd9Sstevel@tonic-gate */ 3187c478bd9Sstevel@tonic-gate if (((callp->sy_flags & SE_32RVAL2) == 0) ^ 3197c478bd9Sstevel@tonic-gate ((sysent[callnum].sy_flags & SE_32RVAL2) == 0)) { 3207c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "sysent[%d] rval2 mismatch!", 3217c478bd9Sstevel@tonic-gate callnum); 3227c478bd9Sstevel@tonic-gate } 3237c478bd9Sstevel@tonic-gate skip:; 3247c478bd9Sstevel@tonic-gate #endif /* DEBUG */ 3257c478bd9Sstevel@tonic-gate } 3267c478bd9Sstevel@tonic-gate } 3277c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32_IMPL */ 3287c478bd9Sstevel@tonic-gate 3297c478bd9Sstevel@tonic-gate /* 3307c478bd9Sstevel@tonic-gate * Allocate loadable exec locks. (Assumes all execs are loadable) 3317c478bd9Sstevel@tonic-gate */ 3327c478bd9Sstevel@tonic-gate for (exectype = 0; exectype < nexectype; exectype++) { 3337c478bd9Sstevel@tonic-gate execsw[exectype].exec_lock = 3347c478bd9Sstevel@tonic-gate kobj_zalloc(sizeof (krwlock_t), KM_SLEEP); 3357c478bd9Sstevel@tonic-gate rw_init(execsw[exectype].exec_lock, NULL, RW_DEFAULT, NULL); 3367c478bd9Sstevel@tonic-gate } 3377c478bd9Sstevel@tonic-gate 3387c478bd9Sstevel@tonic-gate read_class_file(); 3397c478bd9Sstevel@tonic-gate 3407c478bd9Sstevel@tonic-gate /* init thread specific structure for mod_uninstall_all */ 3417c478bd9Sstevel@tonic-gate tsd_create(&mod_autounload_key, NULL); 3427c478bd9Sstevel@tonic-gate } 3437c478bd9Sstevel@tonic-gate 3447c478bd9Sstevel@tonic-gate static int 3457c478bd9Sstevel@tonic-gate modctl_modload(int use_path, char *filename, int *rvp) 3467c478bd9Sstevel@tonic-gate { 3477c478bd9Sstevel@tonic-gate struct modctl *modp; 3487c478bd9Sstevel@tonic-gate int retval = 0; 3497c478bd9Sstevel@tonic-gate char *filenamep; 3507c478bd9Sstevel@tonic-gate int modid; 3517c478bd9Sstevel@tonic-gate 3527c478bd9Sstevel@tonic-gate filenamep = kmem_zalloc(MOD_MAXPATH, KM_SLEEP); 3537c478bd9Sstevel@tonic-gate 3547c478bd9Sstevel@tonic-gate if (copyinstr(filename, filenamep, MOD_MAXPATH, 0)) { 3557c478bd9Sstevel@tonic-gate retval = EFAULT; 3567c478bd9Sstevel@tonic-gate goto out; 3577c478bd9Sstevel@tonic-gate } 3587c478bd9Sstevel@tonic-gate 3597c478bd9Sstevel@tonic-gate filenamep[MOD_MAXPATH - 1] = 0; 3607c478bd9Sstevel@tonic-gate modp = mod_hold_installed_mod(filenamep, use_path, &retval); 3617c478bd9Sstevel@tonic-gate 3627c478bd9Sstevel@tonic-gate if (modp == NULL) 3637c478bd9Sstevel@tonic-gate goto out; 3647c478bd9Sstevel@tonic-gate 3657c478bd9Sstevel@tonic-gate modp->mod_loadflags |= MOD_NOAUTOUNLOAD; 3667c478bd9Sstevel@tonic-gate modid = modp->mod_id; 3677c478bd9Sstevel@tonic-gate mod_release_mod(modp); 368*0b38a8bdSahl CPU_STATS_ADDQ(CPU, sys, modload, 1); 3697c478bd9Sstevel@tonic-gate if (rvp != NULL && copyout(&modid, rvp, sizeof (modid)) != 0) 3707c478bd9Sstevel@tonic-gate retval = EFAULT; 3717c478bd9Sstevel@tonic-gate out: 3727c478bd9Sstevel@tonic-gate kmem_free(filenamep, MOD_MAXPATH); 3737c478bd9Sstevel@tonic-gate 3747c478bd9Sstevel@tonic-gate return (retval); 3757c478bd9Sstevel@tonic-gate } 3767c478bd9Sstevel@tonic-gate 3777c478bd9Sstevel@tonic-gate static int 3787c478bd9Sstevel@tonic-gate modctl_modunload(modid_t id) 3797c478bd9Sstevel@tonic-gate { 3807c478bd9Sstevel@tonic-gate int rval = 0; 3817c478bd9Sstevel@tonic-gate 3827c478bd9Sstevel@tonic-gate if (id == 0) { 3837c478bd9Sstevel@tonic-gate #ifdef DEBUG 3847c478bd9Sstevel@tonic-gate /* 3857c478bd9Sstevel@tonic-gate * Turn on mod_uninstall_daemon 3867c478bd9Sstevel@tonic-gate */ 3877c478bd9Sstevel@tonic-gate if (mod_uninstall_interval == 0) { 3887c478bd9Sstevel@tonic-gate mod_uninstall_interval = 60; 3897c478bd9Sstevel@tonic-gate modreap(); 3907c478bd9Sstevel@tonic-gate return (rval); 3917c478bd9Sstevel@tonic-gate } 3927c478bd9Sstevel@tonic-gate #endif 3937c478bd9Sstevel@tonic-gate mod_uninstall_all(); 3947c478bd9Sstevel@tonic-gate } else { 3957c478bd9Sstevel@tonic-gate (void) devfs_clean(ddi_root_node(), NULL, 0); 3967c478bd9Sstevel@tonic-gate rval = modunload(id); 3977c478bd9Sstevel@tonic-gate } 3987c478bd9Sstevel@tonic-gate return (rval); 3997c478bd9Sstevel@tonic-gate } 4007c478bd9Sstevel@tonic-gate 4017c478bd9Sstevel@tonic-gate static int 4027c478bd9Sstevel@tonic-gate modctl_modinfo(modid_t id, struct modinfo *umodi) 4037c478bd9Sstevel@tonic-gate { 4047c478bd9Sstevel@tonic-gate int retval; 4057c478bd9Sstevel@tonic-gate struct modinfo modi; 4067c478bd9Sstevel@tonic-gate #if defined(_SYSCALL32_IMPL) 4077c478bd9Sstevel@tonic-gate int nobase; 4087c478bd9Sstevel@tonic-gate struct modinfo32 modi32; 4097c478bd9Sstevel@tonic-gate #endif 4107c478bd9Sstevel@tonic-gate 4117c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 4127c478bd9Sstevel@tonic-gate if (copyin(umodi, &modi, sizeof (struct modinfo)) != 0) 4137c478bd9Sstevel@tonic-gate return (EFAULT); 4147c478bd9Sstevel@tonic-gate } 4157c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 4167c478bd9Sstevel@tonic-gate else { 4177c478bd9Sstevel@tonic-gate bzero(&modi, sizeof (modi)); 4187c478bd9Sstevel@tonic-gate if (copyin(umodi, &modi32, sizeof (struct modinfo32)) != 0) 4197c478bd9Sstevel@tonic-gate return (EFAULT); 4207c478bd9Sstevel@tonic-gate modi.mi_info = modi32.mi_info; 4217c478bd9Sstevel@tonic-gate modi.mi_id = modi32.mi_id; 4227c478bd9Sstevel@tonic-gate modi.mi_nextid = modi32.mi_nextid; 4237c478bd9Sstevel@tonic-gate nobase = modi.mi_info & MI_INFO_NOBASE; 4247c478bd9Sstevel@tonic-gate } 4257c478bd9Sstevel@tonic-gate #endif 4267c478bd9Sstevel@tonic-gate /* 4277c478bd9Sstevel@tonic-gate * This flag is -only- for the kernels use. 4287c478bd9Sstevel@tonic-gate */ 4297c478bd9Sstevel@tonic-gate modi.mi_info &= ~MI_INFO_LINKAGE; 4307c478bd9Sstevel@tonic-gate 4317c478bd9Sstevel@tonic-gate retval = modinfo(id, &modi); 4327c478bd9Sstevel@tonic-gate if (retval) 4337c478bd9Sstevel@tonic-gate return (retval); 4347c478bd9Sstevel@tonic-gate 4357c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 4367c478bd9Sstevel@tonic-gate if (copyout(&modi, umodi, sizeof (struct modinfo)) != 0) 4377c478bd9Sstevel@tonic-gate retval = EFAULT; 4387c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 4397c478bd9Sstevel@tonic-gate } else { 4407c478bd9Sstevel@tonic-gate int i; 4417c478bd9Sstevel@tonic-gate 4427c478bd9Sstevel@tonic-gate if (!nobase && (uintptr_t)modi.mi_base > UINT32_MAX) 4437c478bd9Sstevel@tonic-gate return (EOVERFLOW); 4447c478bd9Sstevel@tonic-gate 4457c478bd9Sstevel@tonic-gate modi32.mi_info = modi.mi_info; 4467c478bd9Sstevel@tonic-gate modi32.mi_state = modi.mi_state; 4477c478bd9Sstevel@tonic-gate modi32.mi_id = modi.mi_id; 4487c478bd9Sstevel@tonic-gate modi32.mi_nextid = modi.mi_nextid; 4497c478bd9Sstevel@tonic-gate modi32.mi_base = (caddr32_t)(uintptr_t)modi.mi_base; 4507c478bd9Sstevel@tonic-gate modi32.mi_size = modi.mi_size; 4517c478bd9Sstevel@tonic-gate modi32.mi_rev = modi.mi_rev; 4527c478bd9Sstevel@tonic-gate modi32.mi_loadcnt = modi.mi_loadcnt; 4537c478bd9Sstevel@tonic-gate bcopy(modi.mi_name, modi32.mi_name, sizeof (modi32.mi_name)); 4547c478bd9Sstevel@tonic-gate for (i = 0; i < MODMAXLINK32; i++) { 4557c478bd9Sstevel@tonic-gate modi32.mi_msinfo[i].msi_p0 = modi.mi_msinfo[i].msi_p0; 4567c478bd9Sstevel@tonic-gate bcopy(modi.mi_msinfo[i].msi_linkinfo, 4577c478bd9Sstevel@tonic-gate modi32.mi_msinfo[i].msi_linkinfo, 4587c478bd9Sstevel@tonic-gate sizeof (modi32.mi_msinfo[0].msi_linkinfo)); 4597c478bd9Sstevel@tonic-gate } 4607c478bd9Sstevel@tonic-gate if (copyout(&modi32, umodi, sizeof (struct modinfo32)) != 0) 4617c478bd9Sstevel@tonic-gate retval = EFAULT; 4627c478bd9Sstevel@tonic-gate #endif 4637c478bd9Sstevel@tonic-gate } 4647c478bd9Sstevel@tonic-gate 4657c478bd9Sstevel@tonic-gate return (retval); 4667c478bd9Sstevel@tonic-gate } 4677c478bd9Sstevel@tonic-gate 4687c478bd9Sstevel@tonic-gate /* 4697c478bd9Sstevel@tonic-gate * Return the last major number in the range of permissible major numbers. 4707c478bd9Sstevel@tonic-gate */ 4717c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 4727c478bd9Sstevel@tonic-gate static int 4737c478bd9Sstevel@tonic-gate modctl_modreserve(modid_t id, int *data) 4747c478bd9Sstevel@tonic-gate { 4757c478bd9Sstevel@tonic-gate if (copyout(&devcnt, data, sizeof (devcnt)) != 0) 4767c478bd9Sstevel@tonic-gate return (EFAULT); 4777c478bd9Sstevel@tonic-gate return (0); 4787c478bd9Sstevel@tonic-gate } 4797c478bd9Sstevel@tonic-gate 4807c478bd9Sstevel@tonic-gate static int 4817c478bd9Sstevel@tonic-gate modctl_add_major(int *data) 4827c478bd9Sstevel@tonic-gate { 4837c478bd9Sstevel@tonic-gate struct modconfig mc; 4847c478bd9Sstevel@tonic-gate int i, rv; 4857c478bd9Sstevel@tonic-gate struct aliases alias; 4867c478bd9Sstevel@tonic-gate struct aliases *ap; 4877c478bd9Sstevel@tonic-gate char name[MAXMODCONFNAME]; 4887c478bd9Sstevel@tonic-gate char cname[MAXMODCONFNAME]; 4897c478bd9Sstevel@tonic-gate char *drvname; 4907c478bd9Sstevel@tonic-gate 4917c478bd9Sstevel@tonic-gate bzero(&mc, sizeof (struct modconfig)); 4927c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 4937c478bd9Sstevel@tonic-gate if (copyin(data, &mc, sizeof (struct modconfig)) != 0) 4947c478bd9Sstevel@tonic-gate return (EFAULT); 4957c478bd9Sstevel@tonic-gate } 4967c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 4977c478bd9Sstevel@tonic-gate else { 4987c478bd9Sstevel@tonic-gate struct modconfig32 modc32; 4997c478bd9Sstevel@tonic-gate 5007c478bd9Sstevel@tonic-gate if (copyin(data, &modc32, sizeof (struct modconfig32)) != 0) 5017c478bd9Sstevel@tonic-gate return (EFAULT); 5027c478bd9Sstevel@tonic-gate else { 5037c478bd9Sstevel@tonic-gate bcopy(modc32.drvname, mc.drvname, 5047c478bd9Sstevel@tonic-gate sizeof (modc32.drvname)); 5057c478bd9Sstevel@tonic-gate bcopy(modc32.drvclass, mc.drvclass, 5067c478bd9Sstevel@tonic-gate sizeof (modc32.drvclass)); 5077c478bd9Sstevel@tonic-gate mc.major = modc32.major; 5087c478bd9Sstevel@tonic-gate mc.num_aliases = modc32.num_aliases; 5097c478bd9Sstevel@tonic-gate mc.ap = (struct aliases *)(uintptr_t)modc32.ap; 5107c478bd9Sstevel@tonic-gate } 5117c478bd9Sstevel@tonic-gate } 5127c478bd9Sstevel@tonic-gate #endif 5137c478bd9Sstevel@tonic-gate 5147c478bd9Sstevel@tonic-gate /* 5157c478bd9Sstevel@tonic-gate * If the driver is already in the mb_hashtab, and the name given 5167c478bd9Sstevel@tonic-gate * doesn't match that driver's name, fail. Otherwise, pass, since 5177c478bd9Sstevel@tonic-gate * we may be adding aliases. 5187c478bd9Sstevel@tonic-gate */ 5197c478bd9Sstevel@tonic-gate if ((drvname = mod_major_to_name(mc.major)) != NULL && 5207c478bd9Sstevel@tonic-gate strcmp(drvname, mc.drvname) != 0) 5217c478bd9Sstevel@tonic-gate return (EINVAL); 5227c478bd9Sstevel@tonic-gate 5237c478bd9Sstevel@tonic-gate /* 5247c478bd9Sstevel@tonic-gate * Add each supplied driver alias to mb_hashtab 5257c478bd9Sstevel@tonic-gate */ 5267c478bd9Sstevel@tonic-gate ap = mc.ap; 5277c478bd9Sstevel@tonic-gate for (i = 0; i < mc.num_aliases; i++) { 5287c478bd9Sstevel@tonic-gate bzero(&alias, sizeof (struct aliases)); 5297c478bd9Sstevel@tonic-gate 5307c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 5317c478bd9Sstevel@tonic-gate if (copyin(ap, &alias, sizeof (struct aliases)) != 0) 5327c478bd9Sstevel@tonic-gate return (EFAULT); 5337c478bd9Sstevel@tonic-gate 5347c478bd9Sstevel@tonic-gate if (alias.a_len > MAXMODCONFNAME) 5357c478bd9Sstevel@tonic-gate return (EINVAL); 5367c478bd9Sstevel@tonic-gate 5377c478bd9Sstevel@tonic-gate if (copyin(alias.a_name, name, alias.a_len) != 0) 5387c478bd9Sstevel@tonic-gate return (EFAULT); 5397c478bd9Sstevel@tonic-gate 5407c478bd9Sstevel@tonic-gate if (name[alias.a_len - 1] != '\0') 5417c478bd9Sstevel@tonic-gate return (EINVAL); 5427c478bd9Sstevel@tonic-gate } 5437c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 5447c478bd9Sstevel@tonic-gate else { 5457c478bd9Sstevel@tonic-gate struct aliases32 al32; 5467c478bd9Sstevel@tonic-gate 5477c478bd9Sstevel@tonic-gate bzero(&al32, sizeof (struct aliases32)); 5487c478bd9Sstevel@tonic-gate if (copyin(ap, &al32, sizeof (struct aliases32)) != 0) 5497c478bd9Sstevel@tonic-gate return (EFAULT); 5507c478bd9Sstevel@tonic-gate 5517c478bd9Sstevel@tonic-gate if (al32.a_len > MAXMODCONFNAME) 5527c478bd9Sstevel@tonic-gate return (EINVAL); 5537c478bd9Sstevel@tonic-gate 5547c478bd9Sstevel@tonic-gate if (copyin((void *)(uintptr_t)al32.a_name, 5557c478bd9Sstevel@tonic-gate name, al32.a_len) != 0) 5567c478bd9Sstevel@tonic-gate return (EFAULT); 5577c478bd9Sstevel@tonic-gate 5587c478bd9Sstevel@tonic-gate if (name[al32.a_len - 1] != '\0') 5597c478bd9Sstevel@tonic-gate return (EINVAL); 5607c478bd9Sstevel@tonic-gate 5617c478bd9Sstevel@tonic-gate alias.a_next = (void *)(uintptr_t)al32.a_next; 5627c478bd9Sstevel@tonic-gate } 5637c478bd9Sstevel@tonic-gate #endif 5647c478bd9Sstevel@tonic-gate check_esc_sequences(name, cname); 5657c478bd9Sstevel@tonic-gate (void) make_mbind(cname, mc.major, NULL, mb_hashtab); 5667c478bd9Sstevel@tonic-gate ap = alias.a_next; 5677c478bd9Sstevel@tonic-gate } 5687c478bd9Sstevel@tonic-gate 5697c478bd9Sstevel@tonic-gate /* 5707c478bd9Sstevel@tonic-gate * Try to establish an mbinding for mc.drvname, and add it to devnames. 5717c478bd9Sstevel@tonic-gate * Add class if any after establishing the major number 5727c478bd9Sstevel@tonic-gate */ 5737c478bd9Sstevel@tonic-gate (void) make_mbind(mc.drvname, mc.major, NULL, mb_hashtab); 5747c478bd9Sstevel@tonic-gate rv = make_devname(mc.drvname, mc.major); 5757c478bd9Sstevel@tonic-gate 5767c478bd9Sstevel@tonic-gate if (rv == 0) { 5777c478bd9Sstevel@tonic-gate if (mc.drvclass[0] != '\0') 5787c478bd9Sstevel@tonic-gate add_class(mc.drvname, mc.drvclass); 5797c478bd9Sstevel@tonic-gate (void) i_ddi_load_drvconf(mc.major); 5807c478bd9Sstevel@tonic-gate i_ddi_bind_devs(); 5817c478bd9Sstevel@tonic-gate i_ddi_di_cache_invalidate(KM_SLEEP); 5827c478bd9Sstevel@tonic-gate } 5837c478bd9Sstevel@tonic-gate return (rv); 5847c478bd9Sstevel@tonic-gate } 5857c478bd9Sstevel@tonic-gate 5867c478bd9Sstevel@tonic-gate static int 5877c478bd9Sstevel@tonic-gate modctl_rem_major(major_t major) 5887c478bd9Sstevel@tonic-gate { 5897c478bd9Sstevel@tonic-gate struct devnames *dnp; 5907c478bd9Sstevel@tonic-gate 5917c478bd9Sstevel@tonic-gate if (major >= devcnt) 5927c478bd9Sstevel@tonic-gate return (EINVAL); 5937c478bd9Sstevel@tonic-gate 5947c478bd9Sstevel@tonic-gate /* mark devnames as removed */ 5957c478bd9Sstevel@tonic-gate dnp = &devnamesp[major]; 5967c478bd9Sstevel@tonic-gate LOCK_DEV_OPS(&dnp->dn_lock); 5977c478bd9Sstevel@tonic-gate if (dnp->dn_name == NULL || 5987c478bd9Sstevel@tonic-gate (dnp->dn_flags & (DN_DRIVER_REMOVED | DN_TAKEN_GETUDEV))) { 5997c478bd9Sstevel@tonic-gate UNLOCK_DEV_OPS(&dnp->dn_lock); 6007c478bd9Sstevel@tonic-gate return (EINVAL); 6017c478bd9Sstevel@tonic-gate } 6027c478bd9Sstevel@tonic-gate dnp->dn_flags |= DN_DRIVER_REMOVED; 6037c478bd9Sstevel@tonic-gate pm_driver_removed(major); 6047c478bd9Sstevel@tonic-gate UNLOCK_DEV_OPS(&dnp->dn_lock); 6057c478bd9Sstevel@tonic-gate 6067c478bd9Sstevel@tonic-gate (void) i_ddi_unload_drvconf(major); 6077c478bd9Sstevel@tonic-gate i_ddi_unbind_devs(major); 6087c478bd9Sstevel@tonic-gate i_ddi_di_cache_invalidate(KM_SLEEP); 6097c478bd9Sstevel@tonic-gate return (0); 6107c478bd9Sstevel@tonic-gate } 6117c478bd9Sstevel@tonic-gate 6127c478bd9Sstevel@tonic-gate static struct vfs * 6137c478bd9Sstevel@tonic-gate path_to_vfs(char *name) 6147c478bd9Sstevel@tonic-gate { 6157c478bd9Sstevel@tonic-gate vnode_t *vp; 6167c478bd9Sstevel@tonic-gate struct vfs *vfsp; 6177c478bd9Sstevel@tonic-gate 6187c478bd9Sstevel@tonic-gate if (lookupname(name, UIO_SYSSPACE, FOLLOW, NULLVPP, &vp)) 6197c478bd9Sstevel@tonic-gate return (NULL); 6207c478bd9Sstevel@tonic-gate 6217c478bd9Sstevel@tonic-gate vfsp = vp->v_vfsp; 6227c478bd9Sstevel@tonic-gate VN_RELE(vp); 6237c478bd9Sstevel@tonic-gate return (vfsp); 6247c478bd9Sstevel@tonic-gate } 6257c478bd9Sstevel@tonic-gate 6267c478bd9Sstevel@tonic-gate static int 6277c478bd9Sstevel@tonic-gate new_vfs_in_modpath() 6287c478bd9Sstevel@tonic-gate { 6297c478bd9Sstevel@tonic-gate static int n_modpath = 0; 6307c478bd9Sstevel@tonic-gate static char *modpath_copy; 6317c478bd9Sstevel@tonic-gate static struct pathvfs { 6327c478bd9Sstevel@tonic-gate char *path; 6337c478bd9Sstevel@tonic-gate struct vfs *vfsp; 6347c478bd9Sstevel@tonic-gate } *pathvfs; 6357c478bd9Sstevel@tonic-gate 6367c478bd9Sstevel@tonic-gate int i, new_vfs = 0; 6377c478bd9Sstevel@tonic-gate char *tmp, *tmp1; 6387c478bd9Sstevel@tonic-gate struct vfs *vfsp; 6397c478bd9Sstevel@tonic-gate 6407c478bd9Sstevel@tonic-gate if (n_modpath != 0) { 6417c478bd9Sstevel@tonic-gate for (i = 0; i < n_modpath; i++) { 6427c478bd9Sstevel@tonic-gate vfsp = path_to_vfs(pathvfs[i].path); 6437c478bd9Sstevel@tonic-gate if (vfsp != pathvfs[i].vfsp) { 6447c478bd9Sstevel@tonic-gate pathvfs[i].vfsp = vfsp; 6457c478bd9Sstevel@tonic-gate if (vfsp) 6467c478bd9Sstevel@tonic-gate new_vfs = 1; 6477c478bd9Sstevel@tonic-gate } 6487c478bd9Sstevel@tonic-gate } 6497c478bd9Sstevel@tonic-gate return (new_vfs); 6507c478bd9Sstevel@tonic-gate } 6517c478bd9Sstevel@tonic-gate 6527c478bd9Sstevel@tonic-gate /* 6537c478bd9Sstevel@tonic-gate * First call, initialize the pathvfs structure 6547c478bd9Sstevel@tonic-gate */ 6557c478bd9Sstevel@tonic-gate modpath_copy = i_ddi_strdup(default_path, KM_SLEEP); 6567c478bd9Sstevel@tonic-gate tmp = modpath_copy; 6577c478bd9Sstevel@tonic-gate n_modpath = 1; 6587c478bd9Sstevel@tonic-gate tmp1 = strchr(tmp, ' '); 6597c478bd9Sstevel@tonic-gate while (tmp1) { 6607c478bd9Sstevel@tonic-gate *tmp1 = '\0'; 6617c478bd9Sstevel@tonic-gate n_modpath++; 6627c478bd9Sstevel@tonic-gate tmp = tmp1 + 1; 6637c478bd9Sstevel@tonic-gate tmp1 = strchr(tmp, ' '); 6647c478bd9Sstevel@tonic-gate } 6657c478bd9Sstevel@tonic-gate 6667c478bd9Sstevel@tonic-gate pathvfs = kmem_zalloc(n_modpath * sizeof (struct pathvfs), KM_SLEEP); 6677c478bd9Sstevel@tonic-gate tmp = modpath_copy; 6687c478bd9Sstevel@tonic-gate for (i = 0; i < n_modpath; i++) { 6697c478bd9Sstevel@tonic-gate pathvfs[i].path = tmp; 6707c478bd9Sstevel@tonic-gate vfsp = path_to_vfs(tmp); 6717c478bd9Sstevel@tonic-gate pathvfs[i].vfsp = vfsp; 6727c478bd9Sstevel@tonic-gate tmp += strlen(tmp) + 1; 6737c478bd9Sstevel@tonic-gate } 6747c478bd9Sstevel@tonic-gate return (1); /* always reread driver.conf the first time */ 6757c478bd9Sstevel@tonic-gate } 6767c478bd9Sstevel@tonic-gate 6777c478bd9Sstevel@tonic-gate static int modctl_load_drvconf(major_t major) 6787c478bd9Sstevel@tonic-gate { 6797c478bd9Sstevel@tonic-gate int ret; 6807c478bd9Sstevel@tonic-gate 6817c478bd9Sstevel@tonic-gate if (major != (major_t)-1) { 6827c478bd9Sstevel@tonic-gate ret = i_ddi_load_drvconf(major); 6837c478bd9Sstevel@tonic-gate if (ret == 0) 6847c478bd9Sstevel@tonic-gate i_ddi_bind_devs(); 6857c478bd9Sstevel@tonic-gate return (ret); 6867c478bd9Sstevel@tonic-gate } 6877c478bd9Sstevel@tonic-gate 6887c478bd9Sstevel@tonic-gate /* 6897c478bd9Sstevel@tonic-gate * We are invoked to rescan new driver.conf files. It is 6907c478bd9Sstevel@tonic-gate * only necessary if a new file system was mounted in the 6917c478bd9Sstevel@tonic-gate * module_path. Because rescanning driver.conf files can 6927c478bd9Sstevel@tonic-gate * take some time on older platforms (sun4m), the following 6937c478bd9Sstevel@tonic-gate * code skips unnecessary driver.conf rescans to optimize 6947c478bd9Sstevel@tonic-gate * boot performance. 6957c478bd9Sstevel@tonic-gate */ 6967c478bd9Sstevel@tonic-gate if (new_vfs_in_modpath()) { 6977c478bd9Sstevel@tonic-gate (void) i_ddi_load_drvconf((major_t)-1); 6987c478bd9Sstevel@tonic-gate /* 6997c478bd9Sstevel@tonic-gate * If we are still initializing io subsystem, 7007c478bd9Sstevel@tonic-gate * load drivers with ddi-forceattach property 7017c478bd9Sstevel@tonic-gate */ 7027c478bd9Sstevel@tonic-gate if (!i_ddi_io_initialized()) 7037c478bd9Sstevel@tonic-gate i_ddi_forceattach_drivers(); 7047c478bd9Sstevel@tonic-gate } 7057c478bd9Sstevel@tonic-gate return (0); 7067c478bd9Sstevel@tonic-gate } 7077c478bd9Sstevel@tonic-gate 7087c478bd9Sstevel@tonic-gate static int 7097c478bd9Sstevel@tonic-gate modctl_unload_drvconf(major_t major) 7107c478bd9Sstevel@tonic-gate { 7117c478bd9Sstevel@tonic-gate int ret; 7127c478bd9Sstevel@tonic-gate 7137c478bd9Sstevel@tonic-gate if (major >= devcnt) 7147c478bd9Sstevel@tonic-gate return (EINVAL); 7157c478bd9Sstevel@tonic-gate 7167c478bd9Sstevel@tonic-gate ret = i_ddi_unload_drvconf(major); 7177c478bd9Sstevel@tonic-gate if (ret != 0) 7187c478bd9Sstevel@tonic-gate return (ret); 7197c478bd9Sstevel@tonic-gate (void) i_ddi_unbind_devs(major); 7207c478bd9Sstevel@tonic-gate 7217c478bd9Sstevel@tonic-gate return (0); 7227c478bd9Sstevel@tonic-gate } 7237c478bd9Sstevel@tonic-gate 7247c478bd9Sstevel@tonic-gate static void 7257c478bd9Sstevel@tonic-gate check_esc_sequences(char *str, char *cstr) 7267c478bd9Sstevel@tonic-gate { 7277c478bd9Sstevel@tonic-gate int i; 7287c478bd9Sstevel@tonic-gate size_t len; 7297c478bd9Sstevel@tonic-gate char *p; 7307c478bd9Sstevel@tonic-gate 7317c478bd9Sstevel@tonic-gate len = strlen(str); 7327c478bd9Sstevel@tonic-gate for (i = 0; i < len; i++, str++, cstr++) { 7337c478bd9Sstevel@tonic-gate if (*str != '\\') { 7347c478bd9Sstevel@tonic-gate *cstr = *str; 7357c478bd9Sstevel@tonic-gate } else { 7367c478bd9Sstevel@tonic-gate p = str + 1; 7377c478bd9Sstevel@tonic-gate /* 7387c478bd9Sstevel@tonic-gate * we only handle octal escape sequences for SPACE 7397c478bd9Sstevel@tonic-gate */ 7407c478bd9Sstevel@tonic-gate if (*p++ == '0' && *p++ == '4' && *p == '0') { 7417c478bd9Sstevel@tonic-gate *cstr = ' '; 7427c478bd9Sstevel@tonic-gate str += 3; 7437c478bd9Sstevel@tonic-gate } else { 7447c478bd9Sstevel@tonic-gate *cstr = *str; 7457c478bd9Sstevel@tonic-gate } 7467c478bd9Sstevel@tonic-gate } 7477c478bd9Sstevel@tonic-gate } 7487c478bd9Sstevel@tonic-gate *cstr = 0; 7497c478bd9Sstevel@tonic-gate } 7507c478bd9Sstevel@tonic-gate 7517c478bd9Sstevel@tonic-gate static int 7527c478bd9Sstevel@tonic-gate modctl_getmodpathlen(int *data) 7537c478bd9Sstevel@tonic-gate { 7547c478bd9Sstevel@tonic-gate int len; 7557c478bd9Sstevel@tonic-gate len = strlen(default_path); 7567c478bd9Sstevel@tonic-gate if (copyout(&len, data, sizeof (len)) != 0) 7577c478bd9Sstevel@tonic-gate return (EFAULT); 7587c478bd9Sstevel@tonic-gate return (0); 7597c478bd9Sstevel@tonic-gate } 7607c478bd9Sstevel@tonic-gate 7617c478bd9Sstevel@tonic-gate static int 7627c478bd9Sstevel@tonic-gate modctl_getmodpath(char *data) 7637c478bd9Sstevel@tonic-gate { 7647c478bd9Sstevel@tonic-gate if (copyout(default_path, data, strlen(default_path) + 1) != 0) 7657c478bd9Sstevel@tonic-gate return (EFAULT); 7667c478bd9Sstevel@tonic-gate return (0); 7677c478bd9Sstevel@tonic-gate } 7687c478bd9Sstevel@tonic-gate 7697c478bd9Sstevel@tonic-gate static int 7707c478bd9Sstevel@tonic-gate modctl_read_sysbinding_file(void) 7717c478bd9Sstevel@tonic-gate { 7727c478bd9Sstevel@tonic-gate (void) read_binding_file(sysbind, sb_hashtab, make_mbind); 7737c478bd9Sstevel@tonic-gate return (0); 7747c478bd9Sstevel@tonic-gate } 7757c478bd9Sstevel@tonic-gate 7767c478bd9Sstevel@tonic-gate static int 7777c478bd9Sstevel@tonic-gate modctl_getmaj(char *uname, uint_t ulen, int *umajorp) 7787c478bd9Sstevel@tonic-gate { 7797c478bd9Sstevel@tonic-gate char name[256]; 7807c478bd9Sstevel@tonic-gate int retval; 7817c478bd9Sstevel@tonic-gate major_t major; 7827c478bd9Sstevel@tonic-gate 7837c478bd9Sstevel@tonic-gate if ((retval = copyinstr(uname, name, 7847c478bd9Sstevel@tonic-gate (ulen < 256) ? ulen : 256, 0)) != 0) 7857c478bd9Sstevel@tonic-gate return (retval); 7867c478bd9Sstevel@tonic-gate if ((major = mod_name_to_major(name)) == (major_t)-1) 7877c478bd9Sstevel@tonic-gate return (ENODEV); 7887c478bd9Sstevel@tonic-gate if (copyout(&major, umajorp, sizeof (major_t)) != 0) 7897c478bd9Sstevel@tonic-gate return (EFAULT); 7907c478bd9Sstevel@tonic-gate return (0); 7917c478bd9Sstevel@tonic-gate } 7927c478bd9Sstevel@tonic-gate 7937c478bd9Sstevel@tonic-gate static int 7947c478bd9Sstevel@tonic-gate modctl_getname(char *uname, uint_t ulen, int *umajorp) 7957c478bd9Sstevel@tonic-gate { 7967c478bd9Sstevel@tonic-gate char *name; 7977c478bd9Sstevel@tonic-gate major_t major; 7987c478bd9Sstevel@tonic-gate 7997c478bd9Sstevel@tonic-gate if (copyin(umajorp, &major, sizeof (major)) != 0) 8007c478bd9Sstevel@tonic-gate return (EFAULT); 8017c478bd9Sstevel@tonic-gate if ((name = mod_major_to_name(major)) == NULL) 8027c478bd9Sstevel@tonic-gate return (ENODEV); 8037c478bd9Sstevel@tonic-gate if ((strlen(name) + 1) > ulen) 8047c478bd9Sstevel@tonic-gate return (ENOSPC); 8057c478bd9Sstevel@tonic-gate return (copyoutstr(name, uname, ulen, NULL)); 8067c478bd9Sstevel@tonic-gate } 8077c478bd9Sstevel@tonic-gate 8087c478bd9Sstevel@tonic-gate static int 8097c478bd9Sstevel@tonic-gate modctl_devt2instance(dev_t dev, int *uinstancep) 8107c478bd9Sstevel@tonic-gate { 8117c478bd9Sstevel@tonic-gate int instance; 8127c478bd9Sstevel@tonic-gate 8137c478bd9Sstevel@tonic-gate if ((instance = dev_to_instance(dev)) == -1) 8147c478bd9Sstevel@tonic-gate return (EINVAL); 8157c478bd9Sstevel@tonic-gate 8167c478bd9Sstevel@tonic-gate return (copyout(&instance, uinstancep, sizeof (int))); 8177c478bd9Sstevel@tonic-gate } 8187c478bd9Sstevel@tonic-gate 8197c478bd9Sstevel@tonic-gate /* 8207c478bd9Sstevel@tonic-gate * Return the sizeof of the device id. 8217c478bd9Sstevel@tonic-gate */ 8227c478bd9Sstevel@tonic-gate static int 8237c478bd9Sstevel@tonic-gate modctl_sizeof_devid(dev_t dev, uint_t *len) 8247c478bd9Sstevel@tonic-gate { 8257c478bd9Sstevel@tonic-gate uint_t sz; 8267c478bd9Sstevel@tonic-gate ddi_devid_t devid; 8277c478bd9Sstevel@tonic-gate 8287c478bd9Sstevel@tonic-gate /* get device id */ 8297c478bd9Sstevel@tonic-gate if (ddi_lyr_get_devid(dev, &devid) == DDI_FAILURE) 8307c478bd9Sstevel@tonic-gate return (EINVAL); 8317c478bd9Sstevel@tonic-gate 8327c478bd9Sstevel@tonic-gate sz = ddi_devid_sizeof(devid); 8337c478bd9Sstevel@tonic-gate ddi_devid_free(devid); 8347c478bd9Sstevel@tonic-gate 8357c478bd9Sstevel@tonic-gate /* copyout device id size */ 8367c478bd9Sstevel@tonic-gate if (copyout(&sz, len, sizeof (sz)) != 0) 8377c478bd9Sstevel@tonic-gate return (EFAULT); 8387c478bd9Sstevel@tonic-gate 8397c478bd9Sstevel@tonic-gate return (0); 8407c478bd9Sstevel@tonic-gate } 8417c478bd9Sstevel@tonic-gate 8427c478bd9Sstevel@tonic-gate /* 8437c478bd9Sstevel@tonic-gate * Return a copy of the device id. 8447c478bd9Sstevel@tonic-gate */ 8457c478bd9Sstevel@tonic-gate static int 8467c478bd9Sstevel@tonic-gate modctl_get_devid(dev_t dev, uint_t len, ddi_devid_t udevid) 8477c478bd9Sstevel@tonic-gate { 8487c478bd9Sstevel@tonic-gate uint_t sz; 8497c478bd9Sstevel@tonic-gate ddi_devid_t devid; 8507c478bd9Sstevel@tonic-gate int err = 0; 8517c478bd9Sstevel@tonic-gate 8527c478bd9Sstevel@tonic-gate /* get device id */ 8537c478bd9Sstevel@tonic-gate if (ddi_lyr_get_devid(dev, &devid) == DDI_FAILURE) 8547c478bd9Sstevel@tonic-gate return (EINVAL); 8557c478bd9Sstevel@tonic-gate 8567c478bd9Sstevel@tonic-gate sz = ddi_devid_sizeof(devid); 8577c478bd9Sstevel@tonic-gate 8587c478bd9Sstevel@tonic-gate /* Error if device id is larger than space allocated */ 8597c478bd9Sstevel@tonic-gate if (sz > len) { 8607c478bd9Sstevel@tonic-gate ddi_devid_free(devid); 8617c478bd9Sstevel@tonic-gate return (ENOSPC); 8627c478bd9Sstevel@tonic-gate } 8637c478bd9Sstevel@tonic-gate 8647c478bd9Sstevel@tonic-gate /* copy out device id */ 8657c478bd9Sstevel@tonic-gate if (copyout(devid, udevid, sz) != 0) 8667c478bd9Sstevel@tonic-gate err = EFAULT; 8677c478bd9Sstevel@tonic-gate ddi_devid_free(devid); 8687c478bd9Sstevel@tonic-gate return (err); 8697c478bd9Sstevel@tonic-gate } 8707c478bd9Sstevel@tonic-gate 8717c478bd9Sstevel@tonic-gate /* 8727c478bd9Sstevel@tonic-gate * return the /devices paths associated with the specified devid and 8737c478bd9Sstevel@tonic-gate * minor name. 8747c478bd9Sstevel@tonic-gate */ 8757c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 8767c478bd9Sstevel@tonic-gate static int 8777c478bd9Sstevel@tonic-gate modctl_devid2paths(ddi_devid_t udevid, char *uminor_name, uint_t flag, 8787c478bd9Sstevel@tonic-gate size_t *ulensp, char *upaths) 8797c478bd9Sstevel@tonic-gate { 8807c478bd9Sstevel@tonic-gate ddi_devid_t devid = NULL; 8817c478bd9Sstevel@tonic-gate int devid_len; 8827c478bd9Sstevel@tonic-gate char *minor_name = NULL; 8837c478bd9Sstevel@tonic-gate dev_info_t *dip = NULL; 8847c478bd9Sstevel@tonic-gate struct ddi_minor_data *dmdp; 8857c478bd9Sstevel@tonic-gate char *path = NULL; 8867c478bd9Sstevel@tonic-gate int ulens; 8877c478bd9Sstevel@tonic-gate int lens; 8887c478bd9Sstevel@tonic-gate int len; 8897c478bd9Sstevel@tonic-gate dev_t *devlist = NULL; 8907c478bd9Sstevel@tonic-gate int ndevs; 8917c478bd9Sstevel@tonic-gate int i; 8927c478bd9Sstevel@tonic-gate int ret = 0; 8937c478bd9Sstevel@tonic-gate 8947c478bd9Sstevel@tonic-gate /* 8957c478bd9Sstevel@tonic-gate * If upaths is NULL then we are only computing the amount of space 8967c478bd9Sstevel@tonic-gate * needed to hold the paths and returning the value in *ulensp. If we 8977c478bd9Sstevel@tonic-gate * are copying out paths then we get the amount of space allocated by 8987c478bd9Sstevel@tonic-gate * the caller. If the actual space needed for paths is larger, or 8997c478bd9Sstevel@tonic-gate * things are changing out from under us, then we return EAGAIN. 9007c478bd9Sstevel@tonic-gate */ 9017c478bd9Sstevel@tonic-gate if (upaths) { 9027c478bd9Sstevel@tonic-gate if (ulensp == NULL) 9037c478bd9Sstevel@tonic-gate return (EINVAL); 9047c478bd9Sstevel@tonic-gate if (copyin(ulensp, &ulens, sizeof (ulens)) != 0) 9057c478bd9Sstevel@tonic-gate return (EFAULT); 9067c478bd9Sstevel@tonic-gate } 9077c478bd9Sstevel@tonic-gate 9087c478bd9Sstevel@tonic-gate /* 9097c478bd9Sstevel@tonic-gate * copyin enough of the devid to determine the length then 9107c478bd9Sstevel@tonic-gate * reallocate and copy in the entire devid. 9117c478bd9Sstevel@tonic-gate */ 9127c478bd9Sstevel@tonic-gate devid_len = ddi_devid_sizeof(NULL); 9137c478bd9Sstevel@tonic-gate devid = kmem_alloc(devid_len, KM_SLEEP); 9147c478bd9Sstevel@tonic-gate if (copyin(udevid, devid, devid_len)) { 9157c478bd9Sstevel@tonic-gate ret = EFAULT; 9167c478bd9Sstevel@tonic-gate goto out; 9177c478bd9Sstevel@tonic-gate } 9187c478bd9Sstevel@tonic-gate len = devid_len; 9197c478bd9Sstevel@tonic-gate devid_len = ddi_devid_sizeof(devid); 9207c478bd9Sstevel@tonic-gate kmem_free(devid, len); 9217c478bd9Sstevel@tonic-gate devid = kmem_alloc(devid_len, KM_SLEEP); 9227c478bd9Sstevel@tonic-gate if (copyin(udevid, devid, devid_len)) { 9237c478bd9Sstevel@tonic-gate ret = EFAULT; 9247c478bd9Sstevel@tonic-gate goto out; 9257c478bd9Sstevel@tonic-gate } 9267c478bd9Sstevel@tonic-gate 9277c478bd9Sstevel@tonic-gate /* copyin the minor name if specified. */ 9287c478bd9Sstevel@tonic-gate minor_name = uminor_name; 9297c478bd9Sstevel@tonic-gate if ((minor_name != DEVID_MINOR_NAME_ALL) && 9307c478bd9Sstevel@tonic-gate (minor_name != DEVID_MINOR_NAME_ALL_CHR) && 9317c478bd9Sstevel@tonic-gate (minor_name != DEVID_MINOR_NAME_ALL_BLK)) { 9327c478bd9Sstevel@tonic-gate minor_name = kmem_alloc(MAXPATHLEN, KM_SLEEP); 9337c478bd9Sstevel@tonic-gate if (copyinstr(uminor_name, minor_name, MAXPATHLEN, 0)) { 9347c478bd9Sstevel@tonic-gate ret = EFAULT; 9357c478bd9Sstevel@tonic-gate goto out; 9367c478bd9Sstevel@tonic-gate } 9377c478bd9Sstevel@tonic-gate } 9387c478bd9Sstevel@tonic-gate 9397c478bd9Sstevel@tonic-gate /* 9407c478bd9Sstevel@tonic-gate * Use existing function to resolve the devid into a devlist. 9417c478bd9Sstevel@tonic-gate * 9427c478bd9Sstevel@tonic-gate * NOTE: there is a loss of spectype information in the current 9437c478bd9Sstevel@tonic-gate * ddi_lyr_devid_to_devlist implementation. We work around this by not 9447c478bd9Sstevel@tonic-gate * passing down DEVID_MINOR_NAME_ALL here, but reproducing all minor 9457c478bd9Sstevel@tonic-gate * node forms in the loop processing the devlist below. It would be 9467c478bd9Sstevel@tonic-gate * best if at some point the use of this interface here was replaced 9477c478bd9Sstevel@tonic-gate * with a path oriented call. 9487c478bd9Sstevel@tonic-gate */ 9497c478bd9Sstevel@tonic-gate if (ddi_lyr_devid_to_devlist(devid, 9507c478bd9Sstevel@tonic-gate (minor_name == DEVID_MINOR_NAME_ALL) ? 9517c478bd9Sstevel@tonic-gate DEVID_MINOR_NAME_ALL_CHR : minor_name, 9527c478bd9Sstevel@tonic-gate &ndevs, &devlist) != DDI_SUCCESS) { 9537c478bd9Sstevel@tonic-gate ret = EINVAL; 9547c478bd9Sstevel@tonic-gate goto out; 9557c478bd9Sstevel@tonic-gate } 9567c478bd9Sstevel@tonic-gate 9577c478bd9Sstevel@tonic-gate /* 9587c478bd9Sstevel@tonic-gate * loop over the devlist, converting each devt to a path and doing 9597c478bd9Sstevel@tonic-gate * a copyout of the path and computation of the amount of space 9607c478bd9Sstevel@tonic-gate * needed to hold all the paths 9617c478bd9Sstevel@tonic-gate */ 9627c478bd9Sstevel@tonic-gate path = kmem_alloc(MAXPATHLEN, KM_SLEEP); 9637c478bd9Sstevel@tonic-gate for (i = 0, lens = 0; i < ndevs; i++) { 9647c478bd9Sstevel@tonic-gate 9657c478bd9Sstevel@tonic-gate /* find the dip associated with the dev_t */ 9667c478bd9Sstevel@tonic-gate if ((dip = e_ddi_hold_devi_by_dev(devlist[i], 0)) == NULL) 9677c478bd9Sstevel@tonic-gate continue; 9687c478bd9Sstevel@tonic-gate 9697c478bd9Sstevel@tonic-gate /* loop over all the minor nodes, skipping ones we don't want */ 9707c478bd9Sstevel@tonic-gate for (dmdp = DEVI(dip)->devi_minor; dmdp; dmdp = dmdp->next) { 9717c478bd9Sstevel@tonic-gate if ((dmdp->ddm_dev != devlist[i]) || 9727c478bd9Sstevel@tonic-gate (dmdp->type != DDM_MINOR)) 9737c478bd9Sstevel@tonic-gate continue; 9747c478bd9Sstevel@tonic-gate 9757c478bd9Sstevel@tonic-gate if ((minor_name != DEVID_MINOR_NAME_ALL) && 9767c478bd9Sstevel@tonic-gate (minor_name != DEVID_MINOR_NAME_ALL_CHR) && 9777c478bd9Sstevel@tonic-gate (minor_name != DEVID_MINOR_NAME_ALL_BLK) && 9787c478bd9Sstevel@tonic-gate strcmp(minor_name, dmdp->ddm_name)) 9797c478bd9Sstevel@tonic-gate continue; 9807c478bd9Sstevel@tonic-gate else { 9817c478bd9Sstevel@tonic-gate if ((minor_name == DEVID_MINOR_NAME_ALL_CHR) && 9827c478bd9Sstevel@tonic-gate (dmdp->ddm_spec_type != S_IFCHR)) 9837c478bd9Sstevel@tonic-gate continue; 9847c478bd9Sstevel@tonic-gate if ((minor_name == DEVID_MINOR_NAME_ALL_BLK) && 9857c478bd9Sstevel@tonic-gate (dmdp->ddm_spec_type != S_IFBLK)) 9867c478bd9Sstevel@tonic-gate continue; 9877c478bd9Sstevel@tonic-gate } 9887c478bd9Sstevel@tonic-gate 9897c478bd9Sstevel@tonic-gate /* XXX need ddi_pathname_minor(dmdp, path); interface */ 9907c478bd9Sstevel@tonic-gate if (ddi_dev_pathname(dmdp->ddm_dev, dmdp->ddm_spec_type, 9917c478bd9Sstevel@tonic-gate path) != DDI_SUCCESS) { 9927c478bd9Sstevel@tonic-gate ret = EAGAIN; 9937c478bd9Sstevel@tonic-gate goto out; 9947c478bd9Sstevel@tonic-gate } 9957c478bd9Sstevel@tonic-gate len = strlen(path) + 1; 9967c478bd9Sstevel@tonic-gate *(path + len) = '\0'; /* set double termination */ 9977c478bd9Sstevel@tonic-gate lens += len; 9987c478bd9Sstevel@tonic-gate 9997c478bd9Sstevel@tonic-gate /* copyout the path with double terminations */ 10007c478bd9Sstevel@tonic-gate if (upaths) { 10017c478bd9Sstevel@tonic-gate if (lens > ulens) { 10027c478bd9Sstevel@tonic-gate ret = EAGAIN; 10037c478bd9Sstevel@tonic-gate goto out; 10047c478bd9Sstevel@tonic-gate } 10057c478bd9Sstevel@tonic-gate if (copyout(path, upaths, len + 1)) { 10067c478bd9Sstevel@tonic-gate ret = EFAULT; 10077c478bd9Sstevel@tonic-gate goto out; 10087c478bd9Sstevel@tonic-gate } 10097c478bd9Sstevel@tonic-gate upaths += len; 10107c478bd9Sstevel@tonic-gate } 10117c478bd9Sstevel@tonic-gate } 10127c478bd9Sstevel@tonic-gate ddi_release_devi(dip); 10137c478bd9Sstevel@tonic-gate dip = NULL; 10147c478bd9Sstevel@tonic-gate } 10157c478bd9Sstevel@tonic-gate lens++; /* add one for double termination */ 10167c478bd9Sstevel@tonic-gate 10177c478bd9Sstevel@tonic-gate /* copy out the amount of space needed to hold the paths */ 10187c478bd9Sstevel@tonic-gate if (ulensp && copyout(&lens, ulensp, sizeof (lens))) { 10197c478bd9Sstevel@tonic-gate ret = EFAULT; 10207c478bd9Sstevel@tonic-gate goto out; 10217c478bd9Sstevel@tonic-gate } 10227c478bd9Sstevel@tonic-gate ret = 0; 10237c478bd9Sstevel@tonic-gate 10247c478bd9Sstevel@tonic-gate out: if (dip) 10257c478bd9Sstevel@tonic-gate ddi_release_devi(dip); 10267c478bd9Sstevel@tonic-gate if (path) 10277c478bd9Sstevel@tonic-gate kmem_free(path, MAXPATHLEN); 10287c478bd9Sstevel@tonic-gate if (devlist) 10297c478bd9Sstevel@tonic-gate ddi_lyr_free_devlist(devlist, ndevs); 10307c478bd9Sstevel@tonic-gate if (minor_name && 10317c478bd9Sstevel@tonic-gate (minor_name != DEVID_MINOR_NAME_ALL) && 10327c478bd9Sstevel@tonic-gate (minor_name != DEVID_MINOR_NAME_ALL_CHR) && 10337c478bd9Sstevel@tonic-gate (minor_name != DEVID_MINOR_NAME_ALL_BLK)) 10347c478bd9Sstevel@tonic-gate kmem_free(minor_name, MAXPATHLEN); 10357c478bd9Sstevel@tonic-gate if (devid) 10367c478bd9Sstevel@tonic-gate kmem_free(devid, devid_len); 10377c478bd9Sstevel@tonic-gate return (ret); 10387c478bd9Sstevel@tonic-gate } 10397c478bd9Sstevel@tonic-gate 10407c478bd9Sstevel@tonic-gate /* 10417c478bd9Sstevel@tonic-gate * Return the size of the minor name. 10427c478bd9Sstevel@tonic-gate */ 10437c478bd9Sstevel@tonic-gate static int 10447c478bd9Sstevel@tonic-gate modctl_sizeof_minorname(dev_t dev, int spectype, uint_t *len) 10457c478bd9Sstevel@tonic-gate { 10467c478bd9Sstevel@tonic-gate uint_t sz; 10477c478bd9Sstevel@tonic-gate char *name; 10487c478bd9Sstevel@tonic-gate 10497c478bd9Sstevel@tonic-gate /* get the minor name */ 10507c478bd9Sstevel@tonic-gate if (ddi_lyr_get_minor_name(dev, spectype, &name) == DDI_FAILURE) 10517c478bd9Sstevel@tonic-gate return (EINVAL); 10527c478bd9Sstevel@tonic-gate 10537c478bd9Sstevel@tonic-gate sz = strlen(name) + 1; 10547c478bd9Sstevel@tonic-gate kmem_free(name, sz); 10557c478bd9Sstevel@tonic-gate 10567c478bd9Sstevel@tonic-gate /* copy out the size of the minor name */ 10577c478bd9Sstevel@tonic-gate if (copyout(&sz, len, sizeof (sz)) != 0) 10587c478bd9Sstevel@tonic-gate return (EFAULT); 10597c478bd9Sstevel@tonic-gate 10607c478bd9Sstevel@tonic-gate return (0); 10617c478bd9Sstevel@tonic-gate } 10627c478bd9Sstevel@tonic-gate 10637c478bd9Sstevel@tonic-gate /* 10647c478bd9Sstevel@tonic-gate * Return the minor name. 10657c478bd9Sstevel@tonic-gate */ 10667c478bd9Sstevel@tonic-gate static int 10677c478bd9Sstevel@tonic-gate modctl_get_minorname(dev_t dev, int spectype, uint_t len, char *uname) 10687c478bd9Sstevel@tonic-gate { 10697c478bd9Sstevel@tonic-gate uint_t sz; 10707c478bd9Sstevel@tonic-gate char *name; 10717c478bd9Sstevel@tonic-gate int err = 0; 10727c478bd9Sstevel@tonic-gate 10737c478bd9Sstevel@tonic-gate /* get the minor name */ 10747c478bd9Sstevel@tonic-gate if (ddi_lyr_get_minor_name(dev, spectype, &name) == DDI_FAILURE) 10757c478bd9Sstevel@tonic-gate return (EINVAL); 10767c478bd9Sstevel@tonic-gate 10777c478bd9Sstevel@tonic-gate sz = strlen(name) + 1; 10787c478bd9Sstevel@tonic-gate 10797c478bd9Sstevel@tonic-gate /* Error if the minor name is larger than the space allocated */ 10807c478bd9Sstevel@tonic-gate if (sz > len) { 10817c478bd9Sstevel@tonic-gate kmem_free(name, sz); 10827c478bd9Sstevel@tonic-gate return (ENOSPC); 10837c478bd9Sstevel@tonic-gate } 10847c478bd9Sstevel@tonic-gate 10857c478bd9Sstevel@tonic-gate /* copy out the minor name */ 10867c478bd9Sstevel@tonic-gate if (copyout(name, uname, sz) != 0) 10877c478bd9Sstevel@tonic-gate err = EFAULT; 10887c478bd9Sstevel@tonic-gate kmem_free(name, sz); 10897c478bd9Sstevel@tonic-gate return (err); 10907c478bd9Sstevel@tonic-gate } 10917c478bd9Sstevel@tonic-gate 10927c478bd9Sstevel@tonic-gate /* 10937c478bd9Sstevel@tonic-gate * Return the size of the devfspath name. 10947c478bd9Sstevel@tonic-gate */ 10957c478bd9Sstevel@tonic-gate static int 10967c478bd9Sstevel@tonic-gate modctl_devfspath_len(dev_t dev, int spectype, uint_t *len) 10977c478bd9Sstevel@tonic-gate { 10987c478bd9Sstevel@tonic-gate uint_t sz; 10997c478bd9Sstevel@tonic-gate char *name; 11007c478bd9Sstevel@tonic-gate 11017c478bd9Sstevel@tonic-gate /* get the path name */ 11027c478bd9Sstevel@tonic-gate name = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 11037c478bd9Sstevel@tonic-gate if (ddi_dev_pathname(dev, spectype, name) == DDI_FAILURE) { 11047c478bd9Sstevel@tonic-gate kmem_free(name, MAXPATHLEN); 11057c478bd9Sstevel@tonic-gate return (EINVAL); 11067c478bd9Sstevel@tonic-gate } 11077c478bd9Sstevel@tonic-gate 11087c478bd9Sstevel@tonic-gate sz = strlen(name) + 1; 11097c478bd9Sstevel@tonic-gate kmem_free(name, MAXPATHLEN); 11107c478bd9Sstevel@tonic-gate 11117c478bd9Sstevel@tonic-gate /* copy out the size of the path name */ 11127c478bd9Sstevel@tonic-gate if (copyout(&sz, len, sizeof (sz)) != 0) 11137c478bd9Sstevel@tonic-gate return (EFAULT); 11147c478bd9Sstevel@tonic-gate 11157c478bd9Sstevel@tonic-gate return (0); 11167c478bd9Sstevel@tonic-gate } 11177c478bd9Sstevel@tonic-gate 11187c478bd9Sstevel@tonic-gate /* 11197c478bd9Sstevel@tonic-gate * Return the devfspath name. 11207c478bd9Sstevel@tonic-gate */ 11217c478bd9Sstevel@tonic-gate static int 11227c478bd9Sstevel@tonic-gate modctl_devfspath(dev_t dev, int spectype, uint_t len, char *uname) 11237c478bd9Sstevel@tonic-gate { 11247c478bd9Sstevel@tonic-gate uint_t sz; 11257c478bd9Sstevel@tonic-gate char *name; 11267c478bd9Sstevel@tonic-gate int err = 0; 11277c478bd9Sstevel@tonic-gate 11287c478bd9Sstevel@tonic-gate /* get the path name */ 11297c478bd9Sstevel@tonic-gate name = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 11307c478bd9Sstevel@tonic-gate if (ddi_dev_pathname(dev, spectype, name) == DDI_FAILURE) { 11317c478bd9Sstevel@tonic-gate kmem_free(name, MAXPATHLEN); 11327c478bd9Sstevel@tonic-gate return (EINVAL); 11337c478bd9Sstevel@tonic-gate } 11347c478bd9Sstevel@tonic-gate 11357c478bd9Sstevel@tonic-gate sz = strlen(name) + 1; 11367c478bd9Sstevel@tonic-gate 11377c478bd9Sstevel@tonic-gate /* Error if the path name is larger than the space allocated */ 11387c478bd9Sstevel@tonic-gate if (sz > len) { 11397c478bd9Sstevel@tonic-gate kmem_free(name, MAXPATHLEN); 11407c478bd9Sstevel@tonic-gate return (ENOSPC); 11417c478bd9Sstevel@tonic-gate } 11427c478bd9Sstevel@tonic-gate 11437c478bd9Sstevel@tonic-gate /* copy out the path name */ 11447c478bd9Sstevel@tonic-gate if (copyout(name, uname, sz) != 0) 11457c478bd9Sstevel@tonic-gate err = EFAULT; 11467c478bd9Sstevel@tonic-gate kmem_free(name, MAXPATHLEN); 11477c478bd9Sstevel@tonic-gate return (err); 11487c478bd9Sstevel@tonic-gate } 11497c478bd9Sstevel@tonic-gate 11507c478bd9Sstevel@tonic-gate static int 11517c478bd9Sstevel@tonic-gate modctl_get_fbname(char *path) 11527c478bd9Sstevel@tonic-gate { 11537c478bd9Sstevel@tonic-gate extern dev_t fbdev; 11547c478bd9Sstevel@tonic-gate char *pathname = NULL; 11557c478bd9Sstevel@tonic-gate int rval = 0; 11567c478bd9Sstevel@tonic-gate 11577c478bd9Sstevel@tonic-gate /* make sure fbdev is set before we plunge in */ 11587c478bd9Sstevel@tonic-gate if (fbdev == NODEV) 11597c478bd9Sstevel@tonic-gate return (ENODEV); 11607c478bd9Sstevel@tonic-gate 11617c478bd9Sstevel@tonic-gate pathname = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 11627c478bd9Sstevel@tonic-gate if ((rval = ddi_dev_pathname(fbdev, S_IFCHR, 11637c478bd9Sstevel@tonic-gate pathname)) == DDI_SUCCESS) { 11647c478bd9Sstevel@tonic-gate if (copyout(pathname, path, strlen(pathname)+1) != 0) { 11657c478bd9Sstevel@tonic-gate rval = EFAULT; 11667c478bd9Sstevel@tonic-gate } 11677c478bd9Sstevel@tonic-gate } 11687c478bd9Sstevel@tonic-gate kmem_free(pathname, MAXPATHLEN); 11697c478bd9Sstevel@tonic-gate return (rval); 11707c478bd9Sstevel@tonic-gate } 11717c478bd9Sstevel@tonic-gate 11727c478bd9Sstevel@tonic-gate /* 11737c478bd9Sstevel@tonic-gate * modctl_reread_dacf() 11747c478bd9Sstevel@tonic-gate * Reread the dacf rules database from the named binding file. 11757c478bd9Sstevel@tonic-gate * If NULL is specified, pass along the NULL, it means 'use the default'. 11767c478bd9Sstevel@tonic-gate */ 11777c478bd9Sstevel@tonic-gate static int 11787c478bd9Sstevel@tonic-gate modctl_reread_dacf(char *path) 11797c478bd9Sstevel@tonic-gate { 11807c478bd9Sstevel@tonic-gate int rval = 0; 11817c478bd9Sstevel@tonic-gate char *filename, *filenamep; 11827c478bd9Sstevel@tonic-gate 11837c478bd9Sstevel@tonic-gate filename = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 11847c478bd9Sstevel@tonic-gate 11857c478bd9Sstevel@tonic-gate if (path == NULL) { 11867c478bd9Sstevel@tonic-gate filenamep = NULL; 11877c478bd9Sstevel@tonic-gate } else { 11887c478bd9Sstevel@tonic-gate if (copyinstr(path, filename, MAXPATHLEN, 0) != 0) { 11897c478bd9Sstevel@tonic-gate rval = EFAULT; 11907c478bd9Sstevel@tonic-gate goto out; 11917c478bd9Sstevel@tonic-gate } 11927c478bd9Sstevel@tonic-gate filenamep = filename; 11937c478bd9Sstevel@tonic-gate filenamep[MAXPATHLEN - 1] = '\0'; 11947c478bd9Sstevel@tonic-gate } 11957c478bd9Sstevel@tonic-gate 11967c478bd9Sstevel@tonic-gate rval = read_dacf_binding_file(filenamep); 11977c478bd9Sstevel@tonic-gate out: 11987c478bd9Sstevel@tonic-gate kmem_free(filename, MAXPATHLEN); 11997c478bd9Sstevel@tonic-gate return (rval); 12007c478bd9Sstevel@tonic-gate } 12017c478bd9Sstevel@tonic-gate 12027c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 12037c478bd9Sstevel@tonic-gate static int 12047c478bd9Sstevel@tonic-gate modctl_modevents(int subcmd, uintptr_t a2, uintptr_t a3, uintptr_t a4, 12057c478bd9Sstevel@tonic-gate uint_t flag) 12067c478bd9Sstevel@tonic-gate { 12077c478bd9Sstevel@tonic-gate int error = 0; 12087c478bd9Sstevel@tonic-gate char *filenamep; 12097c478bd9Sstevel@tonic-gate 12107c478bd9Sstevel@tonic-gate switch (subcmd) { 12117c478bd9Sstevel@tonic-gate 12127c478bd9Sstevel@tonic-gate case MODEVENTS_FLUSH: 12137c478bd9Sstevel@tonic-gate /* flush all currently queued events */ 12147c478bd9Sstevel@tonic-gate log_sysevent_flushq(subcmd, flag); 12157c478bd9Sstevel@tonic-gate break; 12167c478bd9Sstevel@tonic-gate 12177c478bd9Sstevel@tonic-gate case MODEVENTS_SET_DOOR_UPCALL_FILENAME: 12187c478bd9Sstevel@tonic-gate /* 12197c478bd9Sstevel@tonic-gate * bind door_upcall to filename 12207c478bd9Sstevel@tonic-gate * this should only be done once per invocation 12217c478bd9Sstevel@tonic-gate * of the event daemon. 12227c478bd9Sstevel@tonic-gate */ 12237c478bd9Sstevel@tonic-gate 12247c478bd9Sstevel@tonic-gate filenamep = kmem_zalloc(MOD_MAXPATH, KM_SLEEP); 12257c478bd9Sstevel@tonic-gate 12267c478bd9Sstevel@tonic-gate if (copyinstr((char *)a2, filenamep, MOD_MAXPATH, 0)) { 12277c478bd9Sstevel@tonic-gate error = EFAULT; 12287c478bd9Sstevel@tonic-gate } else { 12297c478bd9Sstevel@tonic-gate error = log_sysevent_filename(filenamep); 12307c478bd9Sstevel@tonic-gate } 12317c478bd9Sstevel@tonic-gate kmem_free(filenamep, MOD_MAXPATH); 12327c478bd9Sstevel@tonic-gate break; 12337c478bd9Sstevel@tonic-gate 12347c478bd9Sstevel@tonic-gate case MODEVENTS_GETDATA: 12357c478bd9Sstevel@tonic-gate error = log_sysevent_copyout_data((sysevent_id_t *)a2, 12367c478bd9Sstevel@tonic-gate (size_t)a3, (caddr_t)a4); 12377c478bd9Sstevel@tonic-gate break; 12387c478bd9Sstevel@tonic-gate 12397c478bd9Sstevel@tonic-gate case MODEVENTS_FREEDATA: 12407c478bd9Sstevel@tonic-gate error = log_sysevent_free_data((sysevent_id_t *)a2); 12417c478bd9Sstevel@tonic-gate break; 12427c478bd9Sstevel@tonic-gate case MODEVENTS_POST_EVENT: 12437c478bd9Sstevel@tonic-gate error = log_usr_sysevent((sysevent_t *)a2, (uint32_t)a3, 12447c478bd9Sstevel@tonic-gate (sysevent_id_t *)a4); 12457c478bd9Sstevel@tonic-gate break; 12467c478bd9Sstevel@tonic-gate case MODEVENTS_REGISTER_EVENT: 12477c478bd9Sstevel@tonic-gate error = log_sysevent_register((char *)a2, (char *)a3, 12487c478bd9Sstevel@tonic-gate (se_pubsub_t *)a4); 12497c478bd9Sstevel@tonic-gate break; 12507c478bd9Sstevel@tonic-gate default: 12517c478bd9Sstevel@tonic-gate error = EINVAL; 12527c478bd9Sstevel@tonic-gate } 12537c478bd9Sstevel@tonic-gate 12547c478bd9Sstevel@tonic-gate return (error); 12557c478bd9Sstevel@tonic-gate } 12567c478bd9Sstevel@tonic-gate 12577c478bd9Sstevel@tonic-gate static void 12587c478bd9Sstevel@tonic-gate free_mperm(mperm_t *mp) 12597c478bd9Sstevel@tonic-gate { 12607c478bd9Sstevel@tonic-gate int len; 12617c478bd9Sstevel@tonic-gate 12627c478bd9Sstevel@tonic-gate if (mp->mp_minorname) { 12637c478bd9Sstevel@tonic-gate len = strlen(mp->mp_minorname) + 1; 12647c478bd9Sstevel@tonic-gate kmem_free(mp->mp_minorname, len); 12657c478bd9Sstevel@tonic-gate } 12667c478bd9Sstevel@tonic-gate kmem_free(mp, sizeof (mperm_t)); 12677c478bd9Sstevel@tonic-gate } 12687c478bd9Sstevel@tonic-gate 12697c478bd9Sstevel@tonic-gate #define MP_NO_DRV_ERR \ 12707c478bd9Sstevel@tonic-gate "/etc/minor_perm: no driver for %s\n" 12717c478bd9Sstevel@tonic-gate 12727c478bd9Sstevel@tonic-gate #define MP_EMPTY_MINOR \ 12737c478bd9Sstevel@tonic-gate "/etc/minor_perm: empty minor name for driver %s\n" 12747c478bd9Sstevel@tonic-gate 12757c478bd9Sstevel@tonic-gate #define MP_NO_MINOR \ 12767c478bd9Sstevel@tonic-gate "/etc/minor_perm: no minor matching %s for driver %s\n" 12777c478bd9Sstevel@tonic-gate 12787c478bd9Sstevel@tonic-gate /* 12797c478bd9Sstevel@tonic-gate * Remove mperm entry with matching minorname 12807c478bd9Sstevel@tonic-gate */ 12817c478bd9Sstevel@tonic-gate static void 12827c478bd9Sstevel@tonic-gate rem_minorperm(major_t major, char *drvname, mperm_t *mp, int is_clone) 12837c478bd9Sstevel@tonic-gate { 12847c478bd9Sstevel@tonic-gate mperm_t **mp_head; 12857c478bd9Sstevel@tonic-gate mperm_t *freemp = NULL; 12867c478bd9Sstevel@tonic-gate struct devnames *dnp = &devnamesp[major]; 12877c478bd9Sstevel@tonic-gate mperm_t **wildmp; 12887c478bd9Sstevel@tonic-gate 12897c478bd9Sstevel@tonic-gate ASSERT(mp->mp_minorname && strlen(mp->mp_minorname) > 0); 12907c478bd9Sstevel@tonic-gate 12917c478bd9Sstevel@tonic-gate LOCK_DEV_OPS(&dnp->dn_lock); 12927c478bd9Sstevel@tonic-gate if (strcmp(mp->mp_minorname, "*") == 0) { 12937c478bd9Sstevel@tonic-gate wildmp = ((is_clone == 0) ? 12947c478bd9Sstevel@tonic-gate &dnp->dn_mperm_wild : &dnp->dn_mperm_clone); 12957c478bd9Sstevel@tonic-gate if (*wildmp) 12967c478bd9Sstevel@tonic-gate freemp = *wildmp; 12977c478bd9Sstevel@tonic-gate *wildmp = NULL; 12987c478bd9Sstevel@tonic-gate } else { 12997c478bd9Sstevel@tonic-gate mp_head = &dnp->dn_mperm; 13007c478bd9Sstevel@tonic-gate while (*mp_head) { 13017c478bd9Sstevel@tonic-gate if (strcmp((*mp_head)->mp_minorname, 13027c478bd9Sstevel@tonic-gate mp->mp_minorname) != 0) { 13037c478bd9Sstevel@tonic-gate mp_head = &(*mp_head)->mp_next; 13047c478bd9Sstevel@tonic-gate continue; 13057c478bd9Sstevel@tonic-gate } 13067c478bd9Sstevel@tonic-gate /* remove the entry */ 13077c478bd9Sstevel@tonic-gate freemp = *mp_head; 13087c478bd9Sstevel@tonic-gate *mp_head = freemp->mp_next; 13097c478bd9Sstevel@tonic-gate break; 13107c478bd9Sstevel@tonic-gate } 13117c478bd9Sstevel@tonic-gate } 13127c478bd9Sstevel@tonic-gate if (freemp) { 13137c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MINORPERM) { 13147c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, "< %s %s 0%o %d %d\n", 13157c478bd9Sstevel@tonic-gate drvname, freemp->mp_minorname, 13167c478bd9Sstevel@tonic-gate freemp->mp_mode & 0777, 13177c478bd9Sstevel@tonic-gate freemp->mp_uid, freemp->mp_gid); 13187c478bd9Sstevel@tonic-gate } 13197c478bd9Sstevel@tonic-gate free_mperm(freemp); 13207c478bd9Sstevel@tonic-gate } else { 13217c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MINORPERM) { 13227c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, MP_NO_MINOR, 13237c478bd9Sstevel@tonic-gate drvname, mp->mp_minorname); 13247c478bd9Sstevel@tonic-gate } 13257c478bd9Sstevel@tonic-gate } 13267c478bd9Sstevel@tonic-gate 13277c478bd9Sstevel@tonic-gate UNLOCK_DEV_OPS(&dnp->dn_lock); 13287c478bd9Sstevel@tonic-gate } 13297c478bd9Sstevel@tonic-gate 13307c478bd9Sstevel@tonic-gate /* 13317c478bd9Sstevel@tonic-gate * Add minor perm entry 13327c478bd9Sstevel@tonic-gate */ 13337c478bd9Sstevel@tonic-gate static void 13347c478bd9Sstevel@tonic-gate add_minorperm(major_t major, char *drvname, mperm_t *mp, int is_clone) 13357c478bd9Sstevel@tonic-gate { 13367c478bd9Sstevel@tonic-gate mperm_t **mp_head; 13377c478bd9Sstevel@tonic-gate mperm_t *freemp = NULL; 13387c478bd9Sstevel@tonic-gate struct devnames *dnp = &devnamesp[major]; 13397c478bd9Sstevel@tonic-gate mperm_t **wildmp; 13407c478bd9Sstevel@tonic-gate 13417c478bd9Sstevel@tonic-gate ASSERT(mp->mp_minorname && strlen(mp->mp_minorname) > 0); 13427c478bd9Sstevel@tonic-gate 13437c478bd9Sstevel@tonic-gate /* 13447c478bd9Sstevel@tonic-gate * Note that update_drv replace semantics require 13457c478bd9Sstevel@tonic-gate * replacing matching entries with the new permissions. 13467c478bd9Sstevel@tonic-gate */ 13477c478bd9Sstevel@tonic-gate LOCK_DEV_OPS(&dnp->dn_lock); 13487c478bd9Sstevel@tonic-gate if (strcmp(mp->mp_minorname, "*") == 0) { 13497c478bd9Sstevel@tonic-gate wildmp = ((is_clone == 0) ? 13507c478bd9Sstevel@tonic-gate &dnp->dn_mperm_wild : &dnp->dn_mperm_clone); 13517c478bd9Sstevel@tonic-gate if (*wildmp) 13527c478bd9Sstevel@tonic-gate freemp = *wildmp; 13537c478bd9Sstevel@tonic-gate *wildmp = mp; 13547c478bd9Sstevel@tonic-gate } else { 13557c478bd9Sstevel@tonic-gate mperm_t *p, *v = NULL; 13567c478bd9Sstevel@tonic-gate for (p = dnp->dn_mperm; p; v = p, p = p->mp_next) { 13577c478bd9Sstevel@tonic-gate if (strcmp(p->mp_minorname, mp->mp_minorname) == 0) { 13587c478bd9Sstevel@tonic-gate if (v == NULL) 13597c478bd9Sstevel@tonic-gate dnp->dn_mperm = mp; 13607c478bd9Sstevel@tonic-gate else 13617c478bd9Sstevel@tonic-gate v->mp_next = mp; 13627c478bd9Sstevel@tonic-gate mp->mp_next = p->mp_next; 13637c478bd9Sstevel@tonic-gate freemp = p; 13647c478bd9Sstevel@tonic-gate goto replaced; 13657c478bd9Sstevel@tonic-gate } 13667c478bd9Sstevel@tonic-gate } 13677c478bd9Sstevel@tonic-gate if (p == NULL) { 13687c478bd9Sstevel@tonic-gate mp_head = &dnp->dn_mperm; 13697c478bd9Sstevel@tonic-gate if (*mp_head == NULL) { 13707c478bd9Sstevel@tonic-gate *mp_head = mp; 13717c478bd9Sstevel@tonic-gate } else { 13727c478bd9Sstevel@tonic-gate mp->mp_next = *mp_head; 13737c478bd9Sstevel@tonic-gate *mp_head = mp; 13747c478bd9Sstevel@tonic-gate } 13757c478bd9Sstevel@tonic-gate } 13767c478bd9Sstevel@tonic-gate } 13777c478bd9Sstevel@tonic-gate replaced: 13787c478bd9Sstevel@tonic-gate if (freemp) { 13797c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MINORPERM) { 13807c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, "< %s %s 0%o %d %d\n", 13817c478bd9Sstevel@tonic-gate drvname, freemp->mp_minorname, 13827c478bd9Sstevel@tonic-gate freemp->mp_mode & 0777, 13837c478bd9Sstevel@tonic-gate freemp->mp_uid, freemp->mp_gid); 13847c478bd9Sstevel@tonic-gate } 13857c478bd9Sstevel@tonic-gate free_mperm(freemp); 13867c478bd9Sstevel@tonic-gate } 13877c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MINORPERM) { 13887c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, "> %s %s 0%o %d %d\n", 13897c478bd9Sstevel@tonic-gate drvname, mp->mp_minorname, mp->mp_mode & 0777, 13907c478bd9Sstevel@tonic-gate mp->mp_uid, mp->mp_gid); 13917c478bd9Sstevel@tonic-gate } 13927c478bd9Sstevel@tonic-gate UNLOCK_DEV_OPS(&dnp->dn_lock); 13937c478bd9Sstevel@tonic-gate } 13947c478bd9Sstevel@tonic-gate 13957c478bd9Sstevel@tonic-gate 13967c478bd9Sstevel@tonic-gate static int 13977c478bd9Sstevel@tonic-gate process_minorperm(int cmd, nvlist_t *nvl) 13987c478bd9Sstevel@tonic-gate { 13997c478bd9Sstevel@tonic-gate char *minor; 14007c478bd9Sstevel@tonic-gate major_t major; 14017c478bd9Sstevel@tonic-gate mperm_t *mp; 14027c478bd9Sstevel@tonic-gate nvpair_t *nvp; 14037c478bd9Sstevel@tonic-gate char *name; 14047c478bd9Sstevel@tonic-gate int is_clone; 14057c478bd9Sstevel@tonic-gate major_t minmaj; 14067c478bd9Sstevel@tonic-gate 14077c478bd9Sstevel@tonic-gate ASSERT(cmd == MODLOADMINORPERM || 14087c478bd9Sstevel@tonic-gate cmd == MODADDMINORPERM || cmd == MODREMMINORPERM); 14097c478bd9Sstevel@tonic-gate 14107c478bd9Sstevel@tonic-gate nvp = NULL; 14117c478bd9Sstevel@tonic-gate while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) { 14127c478bd9Sstevel@tonic-gate name = nvpair_name(nvp); 14137c478bd9Sstevel@tonic-gate 14147c478bd9Sstevel@tonic-gate is_clone = 0; 14157c478bd9Sstevel@tonic-gate (void) nvpair_value_string(nvp, &minor); 14167c478bd9Sstevel@tonic-gate major = ddi_name_to_major(name); 14177c478bd9Sstevel@tonic-gate if (major != (major_t)-1) { 14187c478bd9Sstevel@tonic-gate mp = kmem_zalloc(sizeof (*mp), KM_SLEEP); 14197c478bd9Sstevel@tonic-gate if (minor == NULL || strlen(minor) == 0) { 14207c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MINORPERM) { 14217c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, MP_EMPTY_MINOR, name); 14227c478bd9Sstevel@tonic-gate } 14237c478bd9Sstevel@tonic-gate minor = "*"; 14247c478bd9Sstevel@tonic-gate } 14257c478bd9Sstevel@tonic-gate 14267c478bd9Sstevel@tonic-gate /* 14277c478bd9Sstevel@tonic-gate * The minor name of a node using the clone 14287c478bd9Sstevel@tonic-gate * driver must be the driver name. To avoid 14297c478bd9Sstevel@tonic-gate * multiple searches, we map entries in the form 14307c478bd9Sstevel@tonic-gate * clone:<driver> to <driver>:*. This also allows us 14317c478bd9Sstevel@tonic-gate * to filter out some of the litter in /etc/minor_perm. 14327c478bd9Sstevel@tonic-gate * Minor perm alias entries where the name is not 14337c478bd9Sstevel@tonic-gate * the driver kept on the clone list itself. 14347c478bd9Sstevel@tonic-gate * This all seems very fragile as a driver could 14357c478bd9Sstevel@tonic-gate * be introduced with an existing alias name. 14367c478bd9Sstevel@tonic-gate */ 14377c478bd9Sstevel@tonic-gate if (strcmp(name, "clone") == 0) { 14387c478bd9Sstevel@tonic-gate minmaj = ddi_name_to_major(minor); 14397c478bd9Sstevel@tonic-gate if (minmaj != (major_t)-1) { 14407c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MINORPERM) { 14417c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, 14427c478bd9Sstevel@tonic-gate "mapping %s:%s to %s:*\n", 14437c478bd9Sstevel@tonic-gate name, minor, minor); 14447c478bd9Sstevel@tonic-gate } 14457c478bd9Sstevel@tonic-gate major = minmaj; 14467c478bd9Sstevel@tonic-gate name = minor; 14477c478bd9Sstevel@tonic-gate minor = "*"; 14487c478bd9Sstevel@tonic-gate is_clone = 1; 14497c478bd9Sstevel@tonic-gate } 14507c478bd9Sstevel@tonic-gate } 14517c478bd9Sstevel@tonic-gate 14527c478bd9Sstevel@tonic-gate if (mp) { 14537c478bd9Sstevel@tonic-gate mp->mp_minorname = 14547c478bd9Sstevel@tonic-gate i_ddi_strdup(minor, KM_SLEEP); 14557c478bd9Sstevel@tonic-gate } 14567c478bd9Sstevel@tonic-gate } else { 14577c478bd9Sstevel@tonic-gate mp = NULL; 14587c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MINORPERM) { 14597c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, MP_NO_DRV_ERR, name); 14607c478bd9Sstevel@tonic-gate } 14617c478bd9Sstevel@tonic-gate } 14627c478bd9Sstevel@tonic-gate 14637c478bd9Sstevel@tonic-gate /* mode */ 14647c478bd9Sstevel@tonic-gate nvp = nvlist_next_nvpair(nvl, nvp); 14657c478bd9Sstevel@tonic-gate ASSERT(strcmp(nvpair_name(nvp), "mode") == 0); 14667c478bd9Sstevel@tonic-gate if (mp) 14677c478bd9Sstevel@tonic-gate (void) nvpair_value_int32(nvp, (int *)&mp->mp_mode); 14687c478bd9Sstevel@tonic-gate /* uid */ 14697c478bd9Sstevel@tonic-gate nvp = nvlist_next_nvpair(nvl, nvp); 14707c478bd9Sstevel@tonic-gate ASSERT(strcmp(nvpair_name(nvp), "uid") == 0); 14717c478bd9Sstevel@tonic-gate if (mp) 14727c478bd9Sstevel@tonic-gate (void) nvpair_value_int32(nvp, &mp->mp_uid); 14737c478bd9Sstevel@tonic-gate /* gid */ 14747c478bd9Sstevel@tonic-gate nvp = nvlist_next_nvpair(nvl, nvp); 14757c478bd9Sstevel@tonic-gate ASSERT(strcmp(nvpair_name(nvp), "gid") == 0); 14767c478bd9Sstevel@tonic-gate if (mp) { 14777c478bd9Sstevel@tonic-gate (void) nvpair_value_int32(nvp, &mp->mp_gid); 14787c478bd9Sstevel@tonic-gate 14797c478bd9Sstevel@tonic-gate if (cmd == MODREMMINORPERM) { 14807c478bd9Sstevel@tonic-gate rem_minorperm(major, name, mp, is_clone); 14817c478bd9Sstevel@tonic-gate free_mperm(mp); 14827c478bd9Sstevel@tonic-gate } else { 14837c478bd9Sstevel@tonic-gate add_minorperm(major, name, mp, is_clone); 14847c478bd9Sstevel@tonic-gate } 14857c478bd9Sstevel@tonic-gate } 14867c478bd9Sstevel@tonic-gate } 14877c478bd9Sstevel@tonic-gate 14887c478bd9Sstevel@tonic-gate if (cmd == MODLOADMINORPERM) 14897c478bd9Sstevel@tonic-gate minorperm_loaded = 1; 14907c478bd9Sstevel@tonic-gate 14917c478bd9Sstevel@tonic-gate /* 14927c478bd9Sstevel@tonic-gate * Reset permissions of cached dv_nodes 14937c478bd9Sstevel@tonic-gate */ 14947c478bd9Sstevel@tonic-gate (void) devfs_reset_perm(DV_RESET_PERM); 14957c478bd9Sstevel@tonic-gate 14967c478bd9Sstevel@tonic-gate return (0); 14977c478bd9Sstevel@tonic-gate } 14987c478bd9Sstevel@tonic-gate 14997c478bd9Sstevel@tonic-gate static int 15007c478bd9Sstevel@tonic-gate modctl_minorperm(int cmd, char *usrbuf, size_t buflen) 15017c478bd9Sstevel@tonic-gate { 15027c478bd9Sstevel@tonic-gate int error; 15037c478bd9Sstevel@tonic-gate nvlist_t *nvl; 15047c478bd9Sstevel@tonic-gate char *buf = kmem_alloc(buflen, KM_SLEEP); 15057c478bd9Sstevel@tonic-gate 15067c478bd9Sstevel@tonic-gate if ((error = ddi_copyin(usrbuf, buf, buflen, 0)) != 0) { 15077c478bd9Sstevel@tonic-gate kmem_free(buf, buflen); 15087c478bd9Sstevel@tonic-gate return (error); 15097c478bd9Sstevel@tonic-gate } 15107c478bd9Sstevel@tonic-gate 15117c478bd9Sstevel@tonic-gate error = nvlist_unpack(buf, buflen, &nvl, KM_SLEEP); 15127c478bd9Sstevel@tonic-gate kmem_free(buf, buflen); 15137c478bd9Sstevel@tonic-gate if (error) 15147c478bd9Sstevel@tonic-gate return (error); 15157c478bd9Sstevel@tonic-gate 15167c478bd9Sstevel@tonic-gate error = process_minorperm(cmd, nvl); 15177c478bd9Sstevel@tonic-gate nvlist_free(nvl); 15187c478bd9Sstevel@tonic-gate return (error); 15197c478bd9Sstevel@tonic-gate } 15207c478bd9Sstevel@tonic-gate 15217c478bd9Sstevel@tonic-gate struct walk_args { 15227c478bd9Sstevel@tonic-gate char *wa_drvname; 15237c478bd9Sstevel@tonic-gate list_t wa_pathlist; 15247c478bd9Sstevel@tonic-gate }; 15257c478bd9Sstevel@tonic-gate 15267c478bd9Sstevel@tonic-gate struct path_elem { 15277c478bd9Sstevel@tonic-gate char *pe_dir; 15287c478bd9Sstevel@tonic-gate char *pe_nodename; 15297c478bd9Sstevel@tonic-gate list_node_t pe_node; 15307c478bd9Sstevel@tonic-gate int pe_dirlen; 15317c478bd9Sstevel@tonic-gate }; 15327c478bd9Sstevel@tonic-gate 15337c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 15347c478bd9Sstevel@tonic-gate static int 15357c478bd9Sstevel@tonic-gate modctl_inst_walker(const char *path, in_node_t *np, in_drv_t *dp, void *arg) 15367c478bd9Sstevel@tonic-gate { 15377c478bd9Sstevel@tonic-gate struct walk_args *wargs = (struct walk_args *)arg; 15387c478bd9Sstevel@tonic-gate struct path_elem *pe; 15397c478bd9Sstevel@tonic-gate char *nodename; 15407c478bd9Sstevel@tonic-gate 15417c478bd9Sstevel@tonic-gate if (strcmp(dp->ind_driver_name, wargs->wa_drvname) != 0) 15427c478bd9Sstevel@tonic-gate return (INST_WALK_CONTINUE); 15437c478bd9Sstevel@tonic-gate 15447c478bd9Sstevel@tonic-gate pe = kmem_zalloc(sizeof (*pe), KM_SLEEP); 15457c478bd9Sstevel@tonic-gate pe->pe_dir = i_ddi_strdup((char *)path, KM_SLEEP); 15467c478bd9Sstevel@tonic-gate pe->pe_dirlen = strlen(pe->pe_dir) + 1; 15477c478bd9Sstevel@tonic-gate ASSERT(strrchr(pe->pe_dir, '/') != NULL); 15487c478bd9Sstevel@tonic-gate nodename = strrchr(pe->pe_dir, '/'); 15497c478bd9Sstevel@tonic-gate *nodename++ = 0; 15507c478bd9Sstevel@tonic-gate pe->pe_nodename = nodename; 15517c478bd9Sstevel@tonic-gate list_insert_tail(&wargs->wa_pathlist, pe); 15527c478bd9Sstevel@tonic-gate 15537c478bd9Sstevel@tonic-gate return (INST_WALK_CONTINUE); 15547c478bd9Sstevel@tonic-gate } 15557c478bd9Sstevel@tonic-gate 15567c478bd9Sstevel@tonic-gate static int 15577c478bd9Sstevel@tonic-gate modctl_remdrv_cleanup(const char *u_drvname) 15587c478bd9Sstevel@tonic-gate { 15597c478bd9Sstevel@tonic-gate struct walk_args *wargs; 15607c478bd9Sstevel@tonic-gate struct path_elem *pe; 15617c478bd9Sstevel@tonic-gate char *drvname; 15627c478bd9Sstevel@tonic-gate int err, rval = 0; 15637c478bd9Sstevel@tonic-gate 15647c478bd9Sstevel@tonic-gate drvname = kmem_alloc(MAXMODCONFNAME, KM_SLEEP); 15657c478bd9Sstevel@tonic-gate if ((err = copyinstr(u_drvname, drvname, MAXMODCONFNAME, 0))) { 15667c478bd9Sstevel@tonic-gate kmem_free(drvname, MAXMODCONFNAME); 15677c478bd9Sstevel@tonic-gate return (err); 15687c478bd9Sstevel@tonic-gate } 15697c478bd9Sstevel@tonic-gate 15707c478bd9Sstevel@tonic-gate /* 15717c478bd9Sstevel@tonic-gate * First go through the instance database. For each 15727c478bd9Sstevel@tonic-gate * instance of a device bound to the driver being 15737c478bd9Sstevel@tonic-gate * removed, remove any underlying devfs attribute nodes. 15747c478bd9Sstevel@tonic-gate * 15757c478bd9Sstevel@tonic-gate * This is a two-step process. First we go through 15767c478bd9Sstevel@tonic-gate * the instance data itself, constructing a list of 15777c478bd9Sstevel@tonic-gate * the nodes discovered. The second step is then 15787c478bd9Sstevel@tonic-gate * to find and remove any devfs attribute nodes 15797c478bd9Sstevel@tonic-gate * for the instances discovered in the first step. 15807c478bd9Sstevel@tonic-gate * The two-step process avoids any difficulties 15817c478bd9Sstevel@tonic-gate * which could arise by holding the instance data 15827c478bd9Sstevel@tonic-gate * lock with simultaneous devfs operations. 15837c478bd9Sstevel@tonic-gate */ 15847c478bd9Sstevel@tonic-gate wargs = kmem_zalloc(sizeof (*wargs), KM_SLEEP); 15857c478bd9Sstevel@tonic-gate 15867c478bd9Sstevel@tonic-gate wargs->wa_drvname = drvname; 15877c478bd9Sstevel@tonic-gate list_create(&wargs->wa_pathlist, 15887c478bd9Sstevel@tonic-gate sizeof (struct path_elem), offsetof(struct path_elem, pe_node)); 15897c478bd9Sstevel@tonic-gate 15907c478bd9Sstevel@tonic-gate (void) e_ddi_walk_instances(modctl_inst_walker, (void *)wargs); 15917c478bd9Sstevel@tonic-gate 15927c478bd9Sstevel@tonic-gate for (pe = list_head(&wargs->wa_pathlist); pe != NULL; 15937c478bd9Sstevel@tonic-gate pe = list_next(&wargs->wa_pathlist, pe)) { 15947c478bd9Sstevel@tonic-gate err = devfs_remdrv_cleanup((const char *)pe->pe_dir, 15957c478bd9Sstevel@tonic-gate (const char *)pe->pe_nodename); 15967c478bd9Sstevel@tonic-gate if (rval == 0) 15977c478bd9Sstevel@tonic-gate rval = err; 15987c478bd9Sstevel@tonic-gate } 15997c478bd9Sstevel@tonic-gate 16007c478bd9Sstevel@tonic-gate while ((pe = list_head(&wargs->wa_pathlist)) != NULL) { 16017c478bd9Sstevel@tonic-gate list_remove(&wargs->wa_pathlist, pe); 16027c478bd9Sstevel@tonic-gate kmem_free(pe->pe_dir, pe->pe_dirlen); 16037c478bd9Sstevel@tonic-gate kmem_free(pe, sizeof (*pe)); 16047c478bd9Sstevel@tonic-gate } 16057c478bd9Sstevel@tonic-gate kmem_free(wargs, sizeof (*wargs)); 16067c478bd9Sstevel@tonic-gate 16077c478bd9Sstevel@tonic-gate /* 16087c478bd9Sstevel@tonic-gate * Pseudo nodes aren't recorded in the instance database 16097c478bd9Sstevel@tonic-gate * so any such nodes need to be handled separately. 16107c478bd9Sstevel@tonic-gate */ 16117c478bd9Sstevel@tonic-gate err = devfs_remdrv_cleanup("pseudo", (const char *)drvname); 16127c478bd9Sstevel@tonic-gate if (rval == 0) 16137c478bd9Sstevel@tonic-gate rval = err; 16147c478bd9Sstevel@tonic-gate 16157c478bd9Sstevel@tonic-gate kmem_free(drvname, MAXMODCONFNAME); 16167c478bd9Sstevel@tonic-gate return (rval); 16177c478bd9Sstevel@tonic-gate } 16187c478bd9Sstevel@tonic-gate 16197c478bd9Sstevel@tonic-gate static int 16207c478bd9Sstevel@tonic-gate modctl_allocpriv(const char *name) 16217c478bd9Sstevel@tonic-gate { 16227c478bd9Sstevel@tonic-gate char *pstr = kmem_alloc(PRIVNAME_MAX, KM_SLEEP); 16237c478bd9Sstevel@tonic-gate int error; 16247c478bd9Sstevel@tonic-gate 16257c478bd9Sstevel@tonic-gate if ((error = copyinstr(name, pstr, PRIVNAME_MAX, 0))) { 16267c478bd9Sstevel@tonic-gate kmem_free(pstr, PRIVNAME_MAX); 16277c478bd9Sstevel@tonic-gate return (error); 16287c478bd9Sstevel@tonic-gate } 16297c478bd9Sstevel@tonic-gate error = priv_getbyname(pstr, PRIV_ALLOC); 16307c478bd9Sstevel@tonic-gate if (error < 0) 16317c478bd9Sstevel@tonic-gate error = -error; 16327c478bd9Sstevel@tonic-gate else 16337c478bd9Sstevel@tonic-gate error = 0; 16347c478bd9Sstevel@tonic-gate kmem_free(pstr, PRIVNAME_MAX); 16357c478bd9Sstevel@tonic-gate return (error); 16367c478bd9Sstevel@tonic-gate } 16377c478bd9Sstevel@tonic-gate 16387c478bd9Sstevel@tonic-gate /*ARGSUSED5*/ 16397c478bd9Sstevel@tonic-gate int 16407c478bd9Sstevel@tonic-gate modctl(int cmd, uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4, 16417c478bd9Sstevel@tonic-gate uintptr_t a5) 16427c478bd9Sstevel@tonic-gate { 16437c478bd9Sstevel@tonic-gate int error = EINVAL; 16447c478bd9Sstevel@tonic-gate dev_t dev; 16457c478bd9Sstevel@tonic-gate 16467c478bd9Sstevel@tonic-gate if (secpolicy_modctl(CRED(), cmd) != 0) 16477c478bd9Sstevel@tonic-gate return (set_errno(EPERM)); 16487c478bd9Sstevel@tonic-gate 16497c478bd9Sstevel@tonic-gate switch (cmd) { 16507c478bd9Sstevel@tonic-gate case MODLOAD: /* load a module */ 16517c478bd9Sstevel@tonic-gate error = modctl_modload((int)a1, (char *)a2, (int *)a3); 16527c478bd9Sstevel@tonic-gate break; 16537c478bd9Sstevel@tonic-gate 16547c478bd9Sstevel@tonic-gate case MODUNLOAD: /* unload a module */ 16557c478bd9Sstevel@tonic-gate error = modctl_modunload((modid_t)a1); 16567c478bd9Sstevel@tonic-gate break; 16577c478bd9Sstevel@tonic-gate 16587c478bd9Sstevel@tonic-gate case MODINFO: /* get module status */ 16597c478bd9Sstevel@tonic-gate error = modctl_modinfo((modid_t)a1, (struct modinfo *)a2); 16607c478bd9Sstevel@tonic-gate break; 16617c478bd9Sstevel@tonic-gate 16627c478bd9Sstevel@tonic-gate case MODRESERVED: /* get last major number in range */ 16637c478bd9Sstevel@tonic-gate error = modctl_modreserve((modid_t)a1, (int *)a2); 16647c478bd9Sstevel@tonic-gate break; 16657c478bd9Sstevel@tonic-gate 16667c478bd9Sstevel@tonic-gate case MODSETMINIROOT: /* we are running in miniroot */ 16677c478bd9Sstevel@tonic-gate isminiroot = 1; 16687c478bd9Sstevel@tonic-gate error = 0; 16697c478bd9Sstevel@tonic-gate break; 16707c478bd9Sstevel@tonic-gate 16717c478bd9Sstevel@tonic-gate case MODADDMAJBIND: /* read major binding file */ 16727c478bd9Sstevel@tonic-gate error = modctl_add_major((int *)a2); 16737c478bd9Sstevel@tonic-gate break; 16747c478bd9Sstevel@tonic-gate 16757c478bd9Sstevel@tonic-gate case MODGETPATHLEN: /* get modpath length */ 16767c478bd9Sstevel@tonic-gate error = modctl_getmodpathlen((int *)a2); 16777c478bd9Sstevel@tonic-gate break; 16787c478bd9Sstevel@tonic-gate 16797c478bd9Sstevel@tonic-gate case MODGETPATH: /* get modpath */ 16807c478bd9Sstevel@tonic-gate error = modctl_getmodpath((char *)a2); 16817c478bd9Sstevel@tonic-gate break; 16827c478bd9Sstevel@tonic-gate 16837c478bd9Sstevel@tonic-gate case MODREADSYSBIND: /* read system call binding file */ 16847c478bd9Sstevel@tonic-gate error = modctl_read_sysbinding_file(); 16857c478bd9Sstevel@tonic-gate break; 16867c478bd9Sstevel@tonic-gate 16877c478bd9Sstevel@tonic-gate case MODGETMAJBIND: /* get major number for named device */ 16887c478bd9Sstevel@tonic-gate error = modctl_getmaj((char *)a1, (uint_t)a2, (int *)a3); 16897c478bd9Sstevel@tonic-gate break; 16907c478bd9Sstevel@tonic-gate 16917c478bd9Sstevel@tonic-gate case MODGETNAME: /* get name of device given major number */ 16927c478bd9Sstevel@tonic-gate error = modctl_getname((char *)a1, (uint_t)a2, (int *)a3); 16937c478bd9Sstevel@tonic-gate break; 16947c478bd9Sstevel@tonic-gate 16957c478bd9Sstevel@tonic-gate case MODDEVT2INSTANCE: 16967c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 16977c478bd9Sstevel@tonic-gate dev = (dev_t)a1; 16987c478bd9Sstevel@tonic-gate } 16997c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 17007c478bd9Sstevel@tonic-gate else { 17017c478bd9Sstevel@tonic-gate dev = expldev(a1); 17027c478bd9Sstevel@tonic-gate } 17037c478bd9Sstevel@tonic-gate #endif 17047c478bd9Sstevel@tonic-gate error = modctl_devt2instance(dev, (int *)a2); 17057c478bd9Sstevel@tonic-gate break; 17067c478bd9Sstevel@tonic-gate 17077c478bd9Sstevel@tonic-gate case MODSIZEOF_DEVID: /* sizeof device id of device given dev_t */ 17087c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 17097c478bd9Sstevel@tonic-gate dev = (dev_t)a1; 17107c478bd9Sstevel@tonic-gate } 17117c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 17127c478bd9Sstevel@tonic-gate else { 17137c478bd9Sstevel@tonic-gate dev = expldev(a1); 17147c478bd9Sstevel@tonic-gate } 17157c478bd9Sstevel@tonic-gate #endif 17167c478bd9Sstevel@tonic-gate error = modctl_sizeof_devid(dev, (uint_t *)a2); 17177c478bd9Sstevel@tonic-gate break; 17187c478bd9Sstevel@tonic-gate 17197c478bd9Sstevel@tonic-gate case MODGETDEVID: /* get device id of device given dev_t */ 17207c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 17217c478bd9Sstevel@tonic-gate dev = (dev_t)a1; 17227c478bd9Sstevel@tonic-gate } 17237c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 17247c478bd9Sstevel@tonic-gate else { 17257c478bd9Sstevel@tonic-gate dev = expldev(a1); 17267c478bd9Sstevel@tonic-gate } 17277c478bd9Sstevel@tonic-gate #endif 17287c478bd9Sstevel@tonic-gate error = modctl_get_devid(dev, (uint_t)a2, (ddi_devid_t)a3); 17297c478bd9Sstevel@tonic-gate break; 17307c478bd9Sstevel@tonic-gate 17317c478bd9Sstevel@tonic-gate case MODSIZEOF_MINORNAME: /* sizeof minor nm of dev_t/spectype */ 17327c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 17337c478bd9Sstevel@tonic-gate error = modctl_sizeof_minorname((dev_t)a1, (int)a2, 17347c478bd9Sstevel@tonic-gate (uint_t *)a3); 17357c478bd9Sstevel@tonic-gate } 17367c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 17377c478bd9Sstevel@tonic-gate else { 17387c478bd9Sstevel@tonic-gate error = modctl_sizeof_minorname(expldev(a1), (int)a2, 17397c478bd9Sstevel@tonic-gate (uint_t *)a3); 17407c478bd9Sstevel@tonic-gate } 17417c478bd9Sstevel@tonic-gate 17427c478bd9Sstevel@tonic-gate #endif 17437c478bd9Sstevel@tonic-gate break; 17447c478bd9Sstevel@tonic-gate 17457c478bd9Sstevel@tonic-gate case MODGETMINORNAME: /* get minor name of dev_t and spec type */ 17467c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 17477c478bd9Sstevel@tonic-gate error = modctl_get_minorname((dev_t)a1, (int)a2, 17487c478bd9Sstevel@tonic-gate (uint_t)a3, (char *)a4); 17497c478bd9Sstevel@tonic-gate } 17507c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 17517c478bd9Sstevel@tonic-gate else { 17527c478bd9Sstevel@tonic-gate error = modctl_get_minorname(expldev(a1), (int)a2, 17537c478bd9Sstevel@tonic-gate (uint_t)a3, (char *)a4); 17547c478bd9Sstevel@tonic-gate } 17557c478bd9Sstevel@tonic-gate #endif 17567c478bd9Sstevel@tonic-gate break; 17577c478bd9Sstevel@tonic-gate 17587c478bd9Sstevel@tonic-gate case MODGETDEVFSPATH_LEN: /* sizeof path nm of dev_t/spectype */ 17597c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 17607c478bd9Sstevel@tonic-gate error = modctl_devfspath_len((dev_t)a1, (int)a2, 17617c478bd9Sstevel@tonic-gate (uint_t *)a3); 17627c478bd9Sstevel@tonic-gate } 17637c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 17647c478bd9Sstevel@tonic-gate else { 17657c478bd9Sstevel@tonic-gate error = modctl_devfspath_len(expldev(a1), (int)a2, 17667c478bd9Sstevel@tonic-gate (uint_t *)a3); 17677c478bd9Sstevel@tonic-gate } 17687c478bd9Sstevel@tonic-gate 17697c478bd9Sstevel@tonic-gate #endif 17707c478bd9Sstevel@tonic-gate break; 17717c478bd9Sstevel@tonic-gate 17727c478bd9Sstevel@tonic-gate case MODGETDEVFSPATH: /* get path name of dev_t and spec type */ 17737c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 17747c478bd9Sstevel@tonic-gate error = modctl_devfspath((dev_t)a1, (int)a2, 17757c478bd9Sstevel@tonic-gate (uint_t)a3, (char *)a4); 17767c478bd9Sstevel@tonic-gate } 17777c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 17787c478bd9Sstevel@tonic-gate else { 17797c478bd9Sstevel@tonic-gate error = modctl_devfspath(expldev(a1), (int)a2, 17807c478bd9Sstevel@tonic-gate (uint_t)a3, (char *)a4); 17817c478bd9Sstevel@tonic-gate } 17827c478bd9Sstevel@tonic-gate #endif 17837c478bd9Sstevel@tonic-gate break; 17847c478bd9Sstevel@tonic-gate 17857c478bd9Sstevel@tonic-gate 17867c478bd9Sstevel@tonic-gate case MODEVENTS: 17877c478bd9Sstevel@tonic-gate error = modctl_modevents((int)a1, a2, a3, a4, (uint_t)a5); 17887c478bd9Sstevel@tonic-gate break; 17897c478bd9Sstevel@tonic-gate 17907c478bd9Sstevel@tonic-gate case MODGETFBNAME: /* get the framebuffer name */ 17917c478bd9Sstevel@tonic-gate error = modctl_get_fbname((char *)a1); 17927c478bd9Sstevel@tonic-gate break; 17937c478bd9Sstevel@tonic-gate 17947c478bd9Sstevel@tonic-gate case MODREREADDACF: /* reread dacf rule database from given file */ 17957c478bd9Sstevel@tonic-gate error = modctl_reread_dacf((char *)a1); 17967c478bd9Sstevel@tonic-gate break; 17977c478bd9Sstevel@tonic-gate 17987c478bd9Sstevel@tonic-gate case MODLOADDRVCONF: /* load driver.conf file for major */ 17997c478bd9Sstevel@tonic-gate error = modctl_load_drvconf((major_t)a1); 18007c478bd9Sstevel@tonic-gate break; 18017c478bd9Sstevel@tonic-gate 18027c478bd9Sstevel@tonic-gate case MODUNLOADDRVCONF: /* unload driver.conf file for major */ 18037c478bd9Sstevel@tonic-gate error = modctl_unload_drvconf((major_t)a1); 18047c478bd9Sstevel@tonic-gate break; 18057c478bd9Sstevel@tonic-gate 18067c478bd9Sstevel@tonic-gate case MODREMMAJBIND: /* remove a major binding */ 18077c478bd9Sstevel@tonic-gate error = modctl_rem_major((major_t)a1); 18087c478bd9Sstevel@tonic-gate break; 18097c478bd9Sstevel@tonic-gate 18107c478bd9Sstevel@tonic-gate case MODDEVID2PATHS: /* get paths given devid */ 18117c478bd9Sstevel@tonic-gate error = modctl_devid2paths((ddi_devid_t)a1, (char *)a2, 18127c478bd9Sstevel@tonic-gate (uint_t)a3, (size_t *)a4, (char *)a5); 18137c478bd9Sstevel@tonic-gate break; 18147c478bd9Sstevel@tonic-gate 18157c478bd9Sstevel@tonic-gate case MODSETDEVPOLICY: /* establish device policy */ 18167c478bd9Sstevel@tonic-gate error = devpolicy_load((int)a1, (size_t)a2, (devplcysys_t *)a3); 18177c478bd9Sstevel@tonic-gate break; 18187c478bd9Sstevel@tonic-gate 18197c478bd9Sstevel@tonic-gate case MODGETDEVPOLICY: /* get device policy */ 18207c478bd9Sstevel@tonic-gate error = devpolicy_get((int *)a1, (size_t)a2, 18217c478bd9Sstevel@tonic-gate (devplcysys_t *)a3); 18227c478bd9Sstevel@tonic-gate break; 18237c478bd9Sstevel@tonic-gate 18247c478bd9Sstevel@tonic-gate case MODALLOCPRIV: 18257c478bd9Sstevel@tonic-gate error = modctl_allocpriv((const char *)a1); 18267c478bd9Sstevel@tonic-gate break; 18277c478bd9Sstevel@tonic-gate 18287c478bd9Sstevel@tonic-gate case MODGETDEVPOLICYBYNAME: 18297c478bd9Sstevel@tonic-gate error = devpolicy_getbyname((size_t)a1, 18307c478bd9Sstevel@tonic-gate (devplcysys_t *)a2, (char *)a3); 18317c478bd9Sstevel@tonic-gate break; 18327c478bd9Sstevel@tonic-gate 18337c478bd9Sstevel@tonic-gate case MODCLEANUP: 18347c478bd9Sstevel@tonic-gate e_devid_cache_cleanup(); 18357c478bd9Sstevel@tonic-gate error = 0; 18367c478bd9Sstevel@tonic-gate break; 18377c478bd9Sstevel@tonic-gate 18387c478bd9Sstevel@tonic-gate case MODLOADMINORPERM: 18397c478bd9Sstevel@tonic-gate case MODADDMINORPERM: 18407c478bd9Sstevel@tonic-gate case MODREMMINORPERM: 18417c478bd9Sstevel@tonic-gate error = modctl_minorperm(cmd, (char *)a1, (size_t)a2); 18427c478bd9Sstevel@tonic-gate break; 18437c478bd9Sstevel@tonic-gate 18447c478bd9Sstevel@tonic-gate case MODREMDRVCLEANUP: 18457c478bd9Sstevel@tonic-gate error = modctl_remdrv_cleanup((const char *)a1); 18467c478bd9Sstevel@tonic-gate break; 18477c478bd9Sstevel@tonic-gate 18487c478bd9Sstevel@tonic-gate default: 18497c478bd9Sstevel@tonic-gate error = EINVAL; 18507c478bd9Sstevel@tonic-gate break; 18517c478bd9Sstevel@tonic-gate } 18527c478bd9Sstevel@tonic-gate 18537c478bd9Sstevel@tonic-gate return (error ? set_errno(error) : 0); 18547c478bd9Sstevel@tonic-gate } 18557c478bd9Sstevel@tonic-gate 18567c478bd9Sstevel@tonic-gate /* 18577c478bd9Sstevel@tonic-gate * Calls to kobj_load_module()() are handled off to this routine in a 18587c478bd9Sstevel@tonic-gate * separate thread. 18597c478bd9Sstevel@tonic-gate */ 18607c478bd9Sstevel@tonic-gate static void 18617c478bd9Sstevel@tonic-gate modload_thread(struct loadmt *ltp) 18627c478bd9Sstevel@tonic-gate { 18637c478bd9Sstevel@tonic-gate /* load the module and signal the creator of this thread */ 18647c478bd9Sstevel@tonic-gate kmutex_t cpr_lk; 18657c478bd9Sstevel@tonic-gate callb_cpr_t cpr_i; 18667c478bd9Sstevel@tonic-gate 18677c478bd9Sstevel@tonic-gate mutex_init(&cpr_lk, NULL, MUTEX_DEFAULT, NULL); 18687c478bd9Sstevel@tonic-gate CALLB_CPR_INIT(&cpr_i, &cpr_lk, callb_generic_cpr, "modload"); 18697c478bd9Sstevel@tonic-gate /* borrow the devi lock from thread which invoked us */ 18707c478bd9Sstevel@tonic-gate pm_borrow_lock(ltp->owner); 18717c478bd9Sstevel@tonic-gate ltp->retval = kobj_load_module(ltp->mp, ltp->usepath); 18727c478bd9Sstevel@tonic-gate pm_return_lock(); 18737c478bd9Sstevel@tonic-gate sema_v(<p->sema); 18747c478bd9Sstevel@tonic-gate mutex_enter(&cpr_lk); 18757c478bd9Sstevel@tonic-gate CALLB_CPR_EXIT(&cpr_i); 18767c478bd9Sstevel@tonic-gate mutex_destroy(&cpr_lk); 18777c478bd9Sstevel@tonic-gate thread_exit(); 18787c478bd9Sstevel@tonic-gate } 18797c478bd9Sstevel@tonic-gate 18807c478bd9Sstevel@tonic-gate /* 18817c478bd9Sstevel@tonic-gate * load a module, adding a reference if caller specifies rmodp. If rmodp 18827c478bd9Sstevel@tonic-gate * is specified then an errno is returned, otherwise a module index is 18837c478bd9Sstevel@tonic-gate * returned (-1 on error). 18847c478bd9Sstevel@tonic-gate */ 18857c478bd9Sstevel@tonic-gate static int 18867c478bd9Sstevel@tonic-gate modrload(char *subdir, char *filename, struct modctl **rmodp) 18877c478bd9Sstevel@tonic-gate { 18887c478bd9Sstevel@tonic-gate struct modctl *modp; 18897c478bd9Sstevel@tonic-gate size_t size; 18907c478bd9Sstevel@tonic-gate char *fullname; 18917c478bd9Sstevel@tonic-gate int retval = EINVAL; 18927c478bd9Sstevel@tonic-gate int id = -1; 18937c478bd9Sstevel@tonic-gate 18947c478bd9Sstevel@tonic-gate if (rmodp) 18957c478bd9Sstevel@tonic-gate *rmodp = NULL; /* avoid garbage */ 18967c478bd9Sstevel@tonic-gate 18977c478bd9Sstevel@tonic-gate if (subdir != NULL) { 18987c478bd9Sstevel@tonic-gate /* 18997c478bd9Sstevel@tonic-gate * refuse / in filename to prevent "../" escapes. 19007c478bd9Sstevel@tonic-gate */ 19017c478bd9Sstevel@tonic-gate if (strchr(filename, '/') != NULL) 19027c478bd9Sstevel@tonic-gate return (rmodp ? retval : id); 19037c478bd9Sstevel@tonic-gate 19047c478bd9Sstevel@tonic-gate /* 19057c478bd9Sstevel@tonic-gate * allocate enough space for <subdir>/<filename><NULL> 19067c478bd9Sstevel@tonic-gate */ 19077c478bd9Sstevel@tonic-gate size = strlen(subdir) + strlen(filename) + 2; 19087c478bd9Sstevel@tonic-gate fullname = kmem_zalloc(size, KM_SLEEP); 19097c478bd9Sstevel@tonic-gate (void) sprintf(fullname, "%s/%s", subdir, filename); 19107c478bd9Sstevel@tonic-gate } else { 19117c478bd9Sstevel@tonic-gate fullname = filename; 19127c478bd9Sstevel@tonic-gate } 19137c478bd9Sstevel@tonic-gate 19147c478bd9Sstevel@tonic-gate modp = mod_hold_installed_mod(fullname, 1, &retval); 19157c478bd9Sstevel@tonic-gate if (modp != NULL) { 19167c478bd9Sstevel@tonic-gate id = modp->mod_id; 19177c478bd9Sstevel@tonic-gate if (rmodp) { 19187c478bd9Sstevel@tonic-gate /* add mod_ref and return *rmodp */ 19197c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 19207c478bd9Sstevel@tonic-gate modp->mod_ref++; 19217c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 19227c478bd9Sstevel@tonic-gate *rmodp = modp; 19237c478bd9Sstevel@tonic-gate } 19247c478bd9Sstevel@tonic-gate mod_release_mod(modp); 19257c478bd9Sstevel@tonic-gate CPU_STATS_ADDQ(CPU, sys, modload, 1); 19267c478bd9Sstevel@tonic-gate } 19277c478bd9Sstevel@tonic-gate 19287c478bd9Sstevel@tonic-gate done: if (subdir != NULL) 19297c478bd9Sstevel@tonic-gate kmem_free(fullname, size); 19307c478bd9Sstevel@tonic-gate return (rmodp ? retval : id); 19317c478bd9Sstevel@tonic-gate } 19327c478bd9Sstevel@tonic-gate 19337c478bd9Sstevel@tonic-gate /* 19347c478bd9Sstevel@tonic-gate * This is the primary kernel interface to load a module. It loads and 19357c478bd9Sstevel@tonic-gate * installs the named module. It does not hold mod_ref of the module, so 19367c478bd9Sstevel@tonic-gate * a module unload attempt can occur at any time - it is up to the 19377c478bd9Sstevel@tonic-gate * _fini/mod_remove implementation to determine if unload will succeed. 19387c478bd9Sstevel@tonic-gate */ 19397c478bd9Sstevel@tonic-gate int 19407c478bd9Sstevel@tonic-gate modload(char *subdir, char *filename) 19417c478bd9Sstevel@tonic-gate { 19427c478bd9Sstevel@tonic-gate return (modrload(subdir, filename, NULL)); 19437c478bd9Sstevel@tonic-gate } 19447c478bd9Sstevel@tonic-gate 19457c478bd9Sstevel@tonic-gate /* 19467c478bd9Sstevel@tonic-gate * Load a module. 19477c478bd9Sstevel@tonic-gate */ 19487c478bd9Sstevel@tonic-gate int 19497c478bd9Sstevel@tonic-gate modloadonly(char *subdir, char *filename) 19507c478bd9Sstevel@tonic-gate { 19517c478bd9Sstevel@tonic-gate struct modctl *modp; 19527c478bd9Sstevel@tonic-gate char *fullname; 19537c478bd9Sstevel@tonic-gate size_t size; 19547c478bd9Sstevel@tonic-gate int id, retval; 19557c478bd9Sstevel@tonic-gate 19567c478bd9Sstevel@tonic-gate if (subdir != NULL) { 19577c478bd9Sstevel@tonic-gate /* 19587c478bd9Sstevel@tonic-gate * allocate enough space for <subdir>/<filename><NULL> 19597c478bd9Sstevel@tonic-gate */ 19607c478bd9Sstevel@tonic-gate size = strlen(subdir) + strlen(filename) + 2; 19617c478bd9Sstevel@tonic-gate fullname = kmem_zalloc(size, KM_SLEEP); 19627c478bd9Sstevel@tonic-gate (void) sprintf(fullname, "%s/%s", subdir, filename); 19637c478bd9Sstevel@tonic-gate } else { 19647c478bd9Sstevel@tonic-gate fullname = filename; 19657c478bd9Sstevel@tonic-gate } 19667c478bd9Sstevel@tonic-gate 19677c478bd9Sstevel@tonic-gate modp = mod_hold_loaded_mod(NULL, fullname, &retval); 19687c478bd9Sstevel@tonic-gate if (modp) { 19697c478bd9Sstevel@tonic-gate id = modp->mod_id; 19707c478bd9Sstevel@tonic-gate mod_release_mod(modp); 19717c478bd9Sstevel@tonic-gate } 19727c478bd9Sstevel@tonic-gate 19737c478bd9Sstevel@tonic-gate if (subdir != NULL) 19747c478bd9Sstevel@tonic-gate kmem_free(fullname, size); 19757c478bd9Sstevel@tonic-gate 19767c478bd9Sstevel@tonic-gate if (retval == 0) 19777c478bd9Sstevel@tonic-gate return (id); 19787c478bd9Sstevel@tonic-gate return (-1); 19797c478bd9Sstevel@tonic-gate } 19807c478bd9Sstevel@tonic-gate 19817c478bd9Sstevel@tonic-gate /* 19827c478bd9Sstevel@tonic-gate * Try to uninstall and unload a module, removing a reference if caller 19837c478bd9Sstevel@tonic-gate * specifies rmodp. 19847c478bd9Sstevel@tonic-gate */ 19857c478bd9Sstevel@tonic-gate static int 19867c478bd9Sstevel@tonic-gate modunrload(modid_t id, struct modctl **rmodp, int unload) 19877c478bd9Sstevel@tonic-gate { 19887c478bd9Sstevel@tonic-gate struct modctl *modp; 19897c478bd9Sstevel@tonic-gate int retval; 19907c478bd9Sstevel@tonic-gate 19917c478bd9Sstevel@tonic-gate if (rmodp) 19927c478bd9Sstevel@tonic-gate *rmodp = NULL; /* avoid garbage */ 19937c478bd9Sstevel@tonic-gate 19947c478bd9Sstevel@tonic-gate if ((modp = mod_hold_by_id((modid_t)id)) == NULL) 19957c478bd9Sstevel@tonic-gate return (EINVAL); 19967c478bd9Sstevel@tonic-gate 19977c478bd9Sstevel@tonic-gate if (rmodp) { 19987c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 19997c478bd9Sstevel@tonic-gate modp->mod_ref--; 20007c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 20017c478bd9Sstevel@tonic-gate *rmodp = modp; 20027c478bd9Sstevel@tonic-gate } 20037c478bd9Sstevel@tonic-gate 20047c478bd9Sstevel@tonic-gate if (unload) { 20057c478bd9Sstevel@tonic-gate retval = moduninstall(modp); 20067c478bd9Sstevel@tonic-gate if (retval == 0) { 20077c478bd9Sstevel@tonic-gate mod_unload(modp); 20087c478bd9Sstevel@tonic-gate CPU_STATS_ADDQ(CPU, sys, modunload, 1); 20097c478bd9Sstevel@tonic-gate } else if (retval == EALREADY) 20107c478bd9Sstevel@tonic-gate retval = 0; /* already unloaded, not an error */ 20117c478bd9Sstevel@tonic-gate } else 20127c478bd9Sstevel@tonic-gate retval = 0; 20137c478bd9Sstevel@tonic-gate 20147c478bd9Sstevel@tonic-gate mod_release_mod(modp); 20157c478bd9Sstevel@tonic-gate return (retval); 20167c478bd9Sstevel@tonic-gate } 20177c478bd9Sstevel@tonic-gate 20187c478bd9Sstevel@tonic-gate /* 20197c478bd9Sstevel@tonic-gate * Uninstall and unload a module. 20207c478bd9Sstevel@tonic-gate */ 20217c478bd9Sstevel@tonic-gate int 20227c478bd9Sstevel@tonic-gate modunload(modid_t id) 20237c478bd9Sstevel@tonic-gate { 20247c478bd9Sstevel@tonic-gate return (modunrload(id, NULL, 1)); 20257c478bd9Sstevel@tonic-gate } 20267c478bd9Sstevel@tonic-gate 20277c478bd9Sstevel@tonic-gate /* 20287c478bd9Sstevel@tonic-gate * Return status of a loaded module. 20297c478bd9Sstevel@tonic-gate */ 20307c478bd9Sstevel@tonic-gate static int 20317c478bd9Sstevel@tonic-gate modinfo(modid_t id, struct modinfo *modinfop) 20327c478bd9Sstevel@tonic-gate { 20337c478bd9Sstevel@tonic-gate struct modctl *modp; 20347c478bd9Sstevel@tonic-gate modid_t mid; 20357c478bd9Sstevel@tonic-gate int i; 20367c478bd9Sstevel@tonic-gate 20377c478bd9Sstevel@tonic-gate mid = modinfop->mi_id; 20387c478bd9Sstevel@tonic-gate if (modinfop->mi_info & MI_INFO_ALL) { 20397c478bd9Sstevel@tonic-gate while ((modp = mod_hold_next_by_id(mid++)) != NULL) { 20407c478bd9Sstevel@tonic-gate if ((modinfop->mi_info & MI_INFO_CNT) || 20417c478bd9Sstevel@tonic-gate modp->mod_installed) 20427c478bd9Sstevel@tonic-gate break; 20437c478bd9Sstevel@tonic-gate mod_release_mod(modp); 20447c478bd9Sstevel@tonic-gate } 20457c478bd9Sstevel@tonic-gate if (modp == NULL) 20467c478bd9Sstevel@tonic-gate return (EINVAL); 20477c478bd9Sstevel@tonic-gate } else { 20487c478bd9Sstevel@tonic-gate modp = mod_hold_by_id(id); 20497c478bd9Sstevel@tonic-gate if (modp == NULL) 20507c478bd9Sstevel@tonic-gate return (EINVAL); 20517c478bd9Sstevel@tonic-gate if (!(modinfop->mi_info & MI_INFO_CNT) && 20527c478bd9Sstevel@tonic-gate (modp->mod_installed == 0)) { 20537c478bd9Sstevel@tonic-gate mod_release_mod(modp); 20547c478bd9Sstevel@tonic-gate return (EINVAL); 20557c478bd9Sstevel@tonic-gate } 20567c478bd9Sstevel@tonic-gate } 20577c478bd9Sstevel@tonic-gate 20587c478bd9Sstevel@tonic-gate modinfop->mi_rev = 0; 20597c478bd9Sstevel@tonic-gate modinfop->mi_state = 0; 20607c478bd9Sstevel@tonic-gate for (i = 0; i < MODMAXLINK; i++) { 20617c478bd9Sstevel@tonic-gate modinfop->mi_msinfo[i].msi_p0 = -1; 20627c478bd9Sstevel@tonic-gate modinfop->mi_msinfo[i].msi_linkinfo[0] = 0; 20637c478bd9Sstevel@tonic-gate } 20647c478bd9Sstevel@tonic-gate if (modp->mod_loaded) { 20657c478bd9Sstevel@tonic-gate modinfop->mi_state = MI_LOADED; 20667c478bd9Sstevel@tonic-gate kobj_getmodinfo(modp->mod_mp, modinfop); 20677c478bd9Sstevel@tonic-gate } 20687c478bd9Sstevel@tonic-gate if (modp->mod_installed) { 20697c478bd9Sstevel@tonic-gate modinfop->mi_state |= MI_INSTALLED; 20707c478bd9Sstevel@tonic-gate 20717c478bd9Sstevel@tonic-gate (void) mod_getinfo(modp, modinfop); 20727c478bd9Sstevel@tonic-gate } 20737c478bd9Sstevel@tonic-gate 20747c478bd9Sstevel@tonic-gate modinfop->mi_id = modp->mod_id; 20757c478bd9Sstevel@tonic-gate modinfop->mi_loadcnt = modp->mod_loadcnt; 20767c478bd9Sstevel@tonic-gate (void) strcpy(modinfop->mi_name, modp->mod_modname); 20777c478bd9Sstevel@tonic-gate 20787c478bd9Sstevel@tonic-gate mod_release_mod(modp); 20797c478bd9Sstevel@tonic-gate return (0); 20807c478bd9Sstevel@tonic-gate } 20817c478bd9Sstevel@tonic-gate 20827c478bd9Sstevel@tonic-gate static char mod_stub_err[] = "mod_hold_stub: Couldn't load stub module %s"; 20837c478bd9Sstevel@tonic-gate static char no_err[] = "No error function for weak stub %s"; 20847c478bd9Sstevel@tonic-gate 20857c478bd9Sstevel@tonic-gate /* 20867c478bd9Sstevel@tonic-gate * used by the stubs themselves to load and hold a module. 20877c478bd9Sstevel@tonic-gate * Returns 0 if the module is successfully held; 20887c478bd9Sstevel@tonic-gate * the stub needs to call mod_release_stub(). 20897c478bd9Sstevel@tonic-gate * -1 if the stub should just call the err_fcn. 20907c478bd9Sstevel@tonic-gate * Note that this code is stretched out so that we avoid subroutine calls 20917c478bd9Sstevel@tonic-gate * and optimize for the most likely case. That is, the case where the 20927c478bd9Sstevel@tonic-gate * module is loaded and installed and not held. In that case we just inc 20937c478bd9Sstevel@tonic-gate * the mod_ref count and continue. 20947c478bd9Sstevel@tonic-gate */ 20957c478bd9Sstevel@tonic-gate int 20967c478bd9Sstevel@tonic-gate mod_hold_stub(struct mod_stub_info *stub) 20977c478bd9Sstevel@tonic-gate { 20987c478bd9Sstevel@tonic-gate struct modctl *mp; 20997c478bd9Sstevel@tonic-gate struct mod_modinfo *mip; 21007c478bd9Sstevel@tonic-gate 21017c478bd9Sstevel@tonic-gate mip = stub->mods_modinfo; 21027c478bd9Sstevel@tonic-gate 21037c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 21047c478bd9Sstevel@tonic-gate 21057c478bd9Sstevel@tonic-gate /* we do mod_hold_by_modctl inline for speed */ 21067c478bd9Sstevel@tonic-gate 21077c478bd9Sstevel@tonic-gate mod_check_again: 21087c478bd9Sstevel@tonic-gate if ((mp = mip->mp) != NULL) { 21097c478bd9Sstevel@tonic-gate if (mp->mod_busy == 0) { 21107c478bd9Sstevel@tonic-gate if (mp->mod_installed) { 21117c478bd9Sstevel@tonic-gate /* increment the reference count */ 21127c478bd9Sstevel@tonic-gate mp->mod_ref++; 21137c478bd9Sstevel@tonic-gate ASSERT(mp->mod_ref && mp->mod_installed); 21147c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 21157c478bd9Sstevel@tonic-gate return (0); 21167c478bd9Sstevel@tonic-gate } else { 21177c478bd9Sstevel@tonic-gate mp->mod_busy = 1; 21187c478bd9Sstevel@tonic-gate mp->mod_inprogress_thread = 21197c478bd9Sstevel@tonic-gate (curthread == NULL ? 21207c478bd9Sstevel@tonic-gate (kthread_id_t)-1 : curthread); 21217c478bd9Sstevel@tonic-gate } 21227c478bd9Sstevel@tonic-gate } else { 21237c478bd9Sstevel@tonic-gate /* 21247c478bd9Sstevel@tonic-gate * wait one time and then go see if someone 21257c478bd9Sstevel@tonic-gate * else has resolved the stub (set mip->mp). 21267c478bd9Sstevel@tonic-gate */ 21277c478bd9Sstevel@tonic-gate if (mod_hold_by_modctl(mp, 21287c478bd9Sstevel@tonic-gate MOD_WAIT_ONCE | MOD_LOCK_HELD)) 21297c478bd9Sstevel@tonic-gate goto mod_check_again; 21307c478bd9Sstevel@tonic-gate 21317c478bd9Sstevel@tonic-gate /* 21327c478bd9Sstevel@tonic-gate * what we have now may have been unloaded!, in 21337c478bd9Sstevel@tonic-gate * that case, mip->mp will be NULL, we'll hit this 21347c478bd9Sstevel@tonic-gate * module and load again.. 21357c478bd9Sstevel@tonic-gate */ 21367c478bd9Sstevel@tonic-gate cmn_err(CE_PANIC, "mod_hold_stub should have blocked"); 21377c478bd9Sstevel@tonic-gate } 21387c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 21397c478bd9Sstevel@tonic-gate } else { 21407c478bd9Sstevel@tonic-gate /* first time we've hit this module */ 21417c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 21427c478bd9Sstevel@tonic-gate mp = mod_hold_by_name(mip->modm_module_name); 21437c478bd9Sstevel@tonic-gate mip->mp = mp; 21447c478bd9Sstevel@tonic-gate } 21457c478bd9Sstevel@tonic-gate 21467c478bd9Sstevel@tonic-gate /* 21477c478bd9Sstevel@tonic-gate * If we are here, it means that the following conditions 21487c478bd9Sstevel@tonic-gate * are satisfied. 21497c478bd9Sstevel@tonic-gate * 21507c478bd9Sstevel@tonic-gate * mip->mp != NULL 21517c478bd9Sstevel@tonic-gate * this thread has set the mp->mod_busy = 1 21527c478bd9Sstevel@tonic-gate * mp->mod_installed = 0 21537c478bd9Sstevel@tonic-gate * 21547c478bd9Sstevel@tonic-gate */ 21557c478bd9Sstevel@tonic-gate ASSERT(mp != NULL); 21567c478bd9Sstevel@tonic-gate ASSERT(mp->mod_busy == 1); 21577c478bd9Sstevel@tonic-gate 21587c478bd9Sstevel@tonic-gate if (mp->mod_installed == 0) { 21597c478bd9Sstevel@tonic-gate /* Module not loaded, if weak stub don't load it */ 21607c478bd9Sstevel@tonic-gate if (stub->mods_flag & MODS_WEAK) { 21617c478bd9Sstevel@tonic-gate if (stub->mods_errfcn == NULL) { 21627c478bd9Sstevel@tonic-gate mod_release_mod(mp); 21637c478bd9Sstevel@tonic-gate cmn_err(CE_PANIC, no_err, 21647c478bd9Sstevel@tonic-gate mip->modm_module_name); 21657c478bd9Sstevel@tonic-gate } 21667c478bd9Sstevel@tonic-gate } else { 21677c478bd9Sstevel@tonic-gate /* Not a weak stub so load the module */ 21687c478bd9Sstevel@tonic-gate 21697c478bd9Sstevel@tonic-gate if (mod_load(mp, 1) != 0 || modinstall(mp) != 0) { 21707c478bd9Sstevel@tonic-gate /* 21717c478bd9Sstevel@tonic-gate * If mod_load() was successful 21727c478bd9Sstevel@tonic-gate * and modinstall() failed, then 21737c478bd9Sstevel@tonic-gate * unload the module. 21747c478bd9Sstevel@tonic-gate */ 21757c478bd9Sstevel@tonic-gate if (mp->mod_loaded) 21767c478bd9Sstevel@tonic-gate mod_unload(mp); 21777c478bd9Sstevel@tonic-gate 21787c478bd9Sstevel@tonic-gate mod_release_mod(mp); 21797c478bd9Sstevel@tonic-gate if (stub->mods_errfcn == NULL) { 21807c478bd9Sstevel@tonic-gate cmn_err(CE_PANIC, mod_stub_err, 21817c478bd9Sstevel@tonic-gate mip->modm_module_name); 21827c478bd9Sstevel@tonic-gate } else { 21837c478bd9Sstevel@tonic-gate return (-1); 21847c478bd9Sstevel@tonic-gate } 21857c478bd9Sstevel@tonic-gate } 21867c478bd9Sstevel@tonic-gate } 21877c478bd9Sstevel@tonic-gate } 21887c478bd9Sstevel@tonic-gate 21897c478bd9Sstevel@tonic-gate /* 21907c478bd9Sstevel@tonic-gate * At this point module is held and loaded. Release 21917c478bd9Sstevel@tonic-gate * the mod_busy and mod_inprogress_thread before 21927c478bd9Sstevel@tonic-gate * returning. We actually call mod_release() here so 21937c478bd9Sstevel@tonic-gate * that if another stub wants to access this module, 21947c478bd9Sstevel@tonic-gate * it can do so. mod_ref is incremented before mod_release() 21957c478bd9Sstevel@tonic-gate * is called to prevent someone else from snatching the 21967c478bd9Sstevel@tonic-gate * module from this thread. 21977c478bd9Sstevel@tonic-gate */ 21987c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 21997c478bd9Sstevel@tonic-gate mp->mod_ref++; 22007c478bd9Sstevel@tonic-gate ASSERT(mp->mod_ref && 22017c478bd9Sstevel@tonic-gate (mp->mod_loaded || (stub->mods_flag & MODS_WEAK))); 22027c478bd9Sstevel@tonic-gate mod_release(mp); 22037c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 22047c478bd9Sstevel@tonic-gate return (0); 22057c478bd9Sstevel@tonic-gate } 22067c478bd9Sstevel@tonic-gate 22077c478bd9Sstevel@tonic-gate void 22087c478bd9Sstevel@tonic-gate mod_release_stub(struct mod_stub_info *stub) 22097c478bd9Sstevel@tonic-gate { 22107c478bd9Sstevel@tonic-gate struct modctl *mp = stub->mods_modinfo->mp; 22117c478bd9Sstevel@tonic-gate 22127c478bd9Sstevel@tonic-gate /* inline mod_release_mod */ 22137c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 22147c478bd9Sstevel@tonic-gate ASSERT(mp->mod_ref && 22157c478bd9Sstevel@tonic-gate (mp->mod_loaded || (stub->mods_flag & MODS_WEAK))); 22167c478bd9Sstevel@tonic-gate mp->mod_ref--; 22177c478bd9Sstevel@tonic-gate if (mp->mod_want) { 22187c478bd9Sstevel@tonic-gate mp->mod_want = 0; 22197c478bd9Sstevel@tonic-gate cv_broadcast(&mod_cv); 22207c478bd9Sstevel@tonic-gate } 22217c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 22227c478bd9Sstevel@tonic-gate } 22237c478bd9Sstevel@tonic-gate 22247c478bd9Sstevel@tonic-gate static struct modctl * 22257c478bd9Sstevel@tonic-gate mod_hold_loaded_mod(struct modctl *dep, char *filename, int *status) 22267c478bd9Sstevel@tonic-gate { 22277c478bd9Sstevel@tonic-gate struct modctl *modp; 22287c478bd9Sstevel@tonic-gate int retval; 22297c478bd9Sstevel@tonic-gate 22307c478bd9Sstevel@tonic-gate /* 22317c478bd9Sstevel@tonic-gate * Hold the module. 22327c478bd9Sstevel@tonic-gate */ 22337c478bd9Sstevel@tonic-gate modp = mod_hold_by_name_requisite(dep, filename); 22347c478bd9Sstevel@tonic-gate if (modp) { 22357c478bd9Sstevel@tonic-gate retval = mod_load(modp, 1); 22367c478bd9Sstevel@tonic-gate if (retval != 0) { 22377c478bd9Sstevel@tonic-gate mod_release_mod(modp); 22387c478bd9Sstevel@tonic-gate modp = NULL; 22397c478bd9Sstevel@tonic-gate } 22407c478bd9Sstevel@tonic-gate *status = retval; 22417c478bd9Sstevel@tonic-gate } else { 22427c478bd9Sstevel@tonic-gate *status = ENOSPC; 22437c478bd9Sstevel@tonic-gate } 22447c478bd9Sstevel@tonic-gate 22457c478bd9Sstevel@tonic-gate /* 22467c478bd9Sstevel@tonic-gate * if dep is not NULL, clear the module dependency information. 22477c478bd9Sstevel@tonic-gate * This information is set in mod_hold_by_name_common(). 22487c478bd9Sstevel@tonic-gate */ 22497c478bd9Sstevel@tonic-gate if (dep != NULL && dep->mod_requisite_loading != NULL) { 22507c478bd9Sstevel@tonic-gate ASSERT(dep->mod_busy); 22517c478bd9Sstevel@tonic-gate dep->mod_requisite_loading = NULL; 22527c478bd9Sstevel@tonic-gate } 22537c478bd9Sstevel@tonic-gate 22547c478bd9Sstevel@tonic-gate return (modp); 22557c478bd9Sstevel@tonic-gate } 22567c478bd9Sstevel@tonic-gate 22577c478bd9Sstevel@tonic-gate /* 22587c478bd9Sstevel@tonic-gate * hold, load, and install the named module 22597c478bd9Sstevel@tonic-gate */ 22607c478bd9Sstevel@tonic-gate static struct modctl * 22617c478bd9Sstevel@tonic-gate mod_hold_installed_mod(char *name, int usepath, int *r) 22627c478bd9Sstevel@tonic-gate { 22637c478bd9Sstevel@tonic-gate struct modctl *modp; 22647c478bd9Sstevel@tonic-gate int retval; 22652bac1547Scth struct _buf *file; 22662bac1547Scth 22672bac1547Scth /* 22682bac1547Scth * Verify that that module in question actually exists on disk 22692bac1547Scth * before allocation of module structure by mod_hold_by_name. 22702bac1547Scth */ 22712bac1547Scth if (modrootloaded && swaploaded) { 22722bac1547Scth file = kobj_open_path(name, usepath, 1); 22732bac1547Scth #ifdef MODDIR_SUFFIX 22742bac1547Scth if (file == (struct _buf *)-1) 22752bac1547Scth file = kobj_open_path(name, usepath, 0); 22762bac1547Scth #endif /* MODDIR_SUFFIX */ 22772bac1547Scth if (file == (struct _buf *)-1) { 22782bac1547Scth *r = ENOENT; 22792bac1547Scth return (NULL); 22802bac1547Scth } 22812bac1547Scth kobj_close_file(file); 22822bac1547Scth } 22837c478bd9Sstevel@tonic-gate 22847c478bd9Sstevel@tonic-gate /* 22857c478bd9Sstevel@tonic-gate * Hold the module. 22867c478bd9Sstevel@tonic-gate */ 22877c478bd9Sstevel@tonic-gate modp = mod_hold_by_name(name); 22887c478bd9Sstevel@tonic-gate if (modp) { 22897c478bd9Sstevel@tonic-gate retval = mod_load(modp, usepath); 22907c478bd9Sstevel@tonic-gate if (retval != 0) { 22917c478bd9Sstevel@tonic-gate mod_release_mod(modp); 22927c478bd9Sstevel@tonic-gate modp = NULL; 22937c478bd9Sstevel@tonic-gate *r = retval; 22947c478bd9Sstevel@tonic-gate } else { 22957c478bd9Sstevel@tonic-gate if ((*r = modinstall(modp)) != 0) { 22967c478bd9Sstevel@tonic-gate /* 22977c478bd9Sstevel@tonic-gate * We loaded it, but failed to _init() it. 22987c478bd9Sstevel@tonic-gate * Be kind to developers -- force it 22997c478bd9Sstevel@tonic-gate * out of memory now so that the next 23007c478bd9Sstevel@tonic-gate * attempt to use the module will cause 23017c478bd9Sstevel@tonic-gate * a reload. See 1093793. 23027c478bd9Sstevel@tonic-gate */ 23037c478bd9Sstevel@tonic-gate mod_unload(modp); 23047c478bd9Sstevel@tonic-gate mod_release_mod(modp); 23057c478bd9Sstevel@tonic-gate modp = NULL; 23067c478bd9Sstevel@tonic-gate } 23077c478bd9Sstevel@tonic-gate } 23087c478bd9Sstevel@tonic-gate } else { 23097c478bd9Sstevel@tonic-gate *r = ENOSPC; 23107c478bd9Sstevel@tonic-gate } 23117c478bd9Sstevel@tonic-gate return (modp); 23127c478bd9Sstevel@tonic-gate } 23137c478bd9Sstevel@tonic-gate 23147c478bd9Sstevel@tonic-gate static char mod_excl_msg[] = 23157c478bd9Sstevel@tonic-gate "module %s(%s) is EXCLUDED and will not be loaded\n"; 23167c478bd9Sstevel@tonic-gate static char mod_init_msg[] = "loadmodule:%s(%s): _init() error %d\n"; 23177c478bd9Sstevel@tonic-gate 23187c478bd9Sstevel@tonic-gate /* 23197c478bd9Sstevel@tonic-gate * This routine is needed for dependencies. Users specify dependencies 23207c478bd9Sstevel@tonic-gate * by declaring a character array initialized to filenames of dependents. 23217c478bd9Sstevel@tonic-gate * So the code that handles dependents deals with filenames (and not 23227c478bd9Sstevel@tonic-gate * module names) because that's all it has. We load by filename and once 23237c478bd9Sstevel@tonic-gate * we've loaded a file we can get the module name. 23247c478bd9Sstevel@tonic-gate * Unfortunately there isn't a single unified filename/modulename namespace. 23257c478bd9Sstevel@tonic-gate * C'est la vie. 23267c478bd9Sstevel@tonic-gate * 23277c478bd9Sstevel@tonic-gate * We allow the name being looked up to be prepended by an optional 23287c478bd9Sstevel@tonic-gate * subdirectory e.g. we can lookup (NULL, "fs/ufs") or ("fs", "ufs") 23297c478bd9Sstevel@tonic-gate */ 23307c478bd9Sstevel@tonic-gate struct modctl * 23317c478bd9Sstevel@tonic-gate mod_find_by_filename(char *subdir, char *filename) 23327c478bd9Sstevel@tonic-gate { 23337c478bd9Sstevel@tonic-gate struct modctl *mp; 23347c478bd9Sstevel@tonic-gate size_t sublen; 23357c478bd9Sstevel@tonic-gate 23367c478bd9Sstevel@tonic-gate ASSERT(!MUTEX_HELD(&mod_lock)); 23377c478bd9Sstevel@tonic-gate if (subdir != NULL) 23387c478bd9Sstevel@tonic-gate sublen = strlen(subdir); 23397c478bd9Sstevel@tonic-gate else 23407c478bd9Sstevel@tonic-gate sublen = 0; 23417c478bd9Sstevel@tonic-gate 23427c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 23437c478bd9Sstevel@tonic-gate mp = &modules; 23447c478bd9Sstevel@tonic-gate do { 23457c478bd9Sstevel@tonic-gate if (sublen) { 23467c478bd9Sstevel@tonic-gate char *mod_filename = mp->mod_filename; 23477c478bd9Sstevel@tonic-gate 23487c478bd9Sstevel@tonic-gate if (strncmp(subdir, mod_filename, sublen) == 0 && 23497c478bd9Sstevel@tonic-gate mod_filename[sublen] == '/' && 23507c478bd9Sstevel@tonic-gate strcmp(filename, &mod_filename[sublen + 1]) == 0) { 23517c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 23527c478bd9Sstevel@tonic-gate return (mp); 23537c478bd9Sstevel@tonic-gate } 23547c478bd9Sstevel@tonic-gate } else if (strcmp(filename, mp->mod_filename) == 0) { 23557c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 23567c478bd9Sstevel@tonic-gate return (mp); 23577c478bd9Sstevel@tonic-gate } 23587c478bd9Sstevel@tonic-gate } while ((mp = mp->mod_next) != &modules); 23597c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 23607c478bd9Sstevel@tonic-gate return (NULL); 23617c478bd9Sstevel@tonic-gate } 23627c478bd9Sstevel@tonic-gate 23637c478bd9Sstevel@tonic-gate /* 23647c478bd9Sstevel@tonic-gate * Check for circular dependencies. This is called from do_dependents() 23657c478bd9Sstevel@tonic-gate * in kobj.c. If we are the thread already loading this module, then 23667c478bd9Sstevel@tonic-gate * we're trying to load a dependent that we're already loading which 23677c478bd9Sstevel@tonic-gate * means the user specified circular dependencies. 23687c478bd9Sstevel@tonic-gate */ 23697c478bd9Sstevel@tonic-gate static int 23707c478bd9Sstevel@tonic-gate mod_circdep(struct modctl *modp) 23717c478bd9Sstevel@tonic-gate { 23727c478bd9Sstevel@tonic-gate struct modctl *rmod; 23737c478bd9Sstevel@tonic-gate 23747c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&mod_lock)); 23757c478bd9Sstevel@tonic-gate 23767c478bd9Sstevel@tonic-gate /* 23777c478bd9Sstevel@tonic-gate * Check the mod_inprogress_thread first. 23787c478bd9Sstevel@tonic-gate * mod_inprogress_thread is used in mod_hold_stub() 23797c478bd9Sstevel@tonic-gate * directly to improve performance. 23807c478bd9Sstevel@tonic-gate */ 23817c478bd9Sstevel@tonic-gate if (modp->mod_inprogress_thread == curthread) 23827c478bd9Sstevel@tonic-gate return (1); 23837c478bd9Sstevel@tonic-gate 23847c478bd9Sstevel@tonic-gate /* 23857c478bd9Sstevel@tonic-gate * Check the module circular dependencies. 23867c478bd9Sstevel@tonic-gate */ 23877c478bd9Sstevel@tonic-gate for (rmod = modp; rmod != NULL; rmod = rmod->mod_requisite_loading) { 23887c478bd9Sstevel@tonic-gate /* 23897c478bd9Sstevel@tonic-gate * Check if there is a module circular dependency. 23907c478bd9Sstevel@tonic-gate */ 23917c478bd9Sstevel@tonic-gate if (rmod->mod_requisite_loading == modp) 23927c478bd9Sstevel@tonic-gate return (1); 23937c478bd9Sstevel@tonic-gate } 23947c478bd9Sstevel@tonic-gate return (0); 23957c478bd9Sstevel@tonic-gate } 23967c478bd9Sstevel@tonic-gate 23977c478bd9Sstevel@tonic-gate static int 23987c478bd9Sstevel@tonic-gate mod_getinfo(struct modctl *modp, struct modinfo *modinfop) 23997c478bd9Sstevel@tonic-gate { 24007c478bd9Sstevel@tonic-gate int (*func)(struct modinfo *); 24017c478bd9Sstevel@tonic-gate int retval; 24027c478bd9Sstevel@tonic-gate 24037c478bd9Sstevel@tonic-gate ASSERT(modp->mod_busy); 24047c478bd9Sstevel@tonic-gate 24057c478bd9Sstevel@tonic-gate /* primary modules don't do getinfo */ 24067c478bd9Sstevel@tonic-gate if (modp->mod_prim) 24077c478bd9Sstevel@tonic-gate return (0); 24087c478bd9Sstevel@tonic-gate 24097c478bd9Sstevel@tonic-gate func = (int (*)(struct modinfo *))kobj_lookup(modp->mod_mp, "_info"); 24107c478bd9Sstevel@tonic-gate 24117c478bd9Sstevel@tonic-gate if (kobj_addrcheck(modp->mod_mp, (caddr_t)func)) { 24127c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "_info() not defined properly in %s", 24137c478bd9Sstevel@tonic-gate modp->mod_filename); 24147c478bd9Sstevel@tonic-gate /* 24157c478bd9Sstevel@tonic-gate * The semantics of mod_info(9F) are that 0 is failure 24167c478bd9Sstevel@tonic-gate * and non-zero is success. 24177c478bd9Sstevel@tonic-gate */ 24187c478bd9Sstevel@tonic-gate retval = 0; 24197c478bd9Sstevel@tonic-gate } else 24207c478bd9Sstevel@tonic-gate retval = (*func)(modinfop); /* call _info() function */ 24217c478bd9Sstevel@tonic-gate 24227c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_USERDEBUG) 24237c478bd9Sstevel@tonic-gate printf("Returned from _info, retval = %x\n", retval); 24247c478bd9Sstevel@tonic-gate 24257c478bd9Sstevel@tonic-gate return (retval); 24267c478bd9Sstevel@tonic-gate } 24277c478bd9Sstevel@tonic-gate 24287c478bd9Sstevel@tonic-gate static void 24297c478bd9Sstevel@tonic-gate modadd(struct modctl *mp) 24307c478bd9Sstevel@tonic-gate { 24317c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&mod_lock)); 24327c478bd9Sstevel@tonic-gate 24337c478bd9Sstevel@tonic-gate mp->mod_id = last_module_id++; 24347c478bd9Sstevel@tonic-gate mp->mod_next = &modules; 24357c478bd9Sstevel@tonic-gate mp->mod_prev = modules.mod_prev; 24367c478bd9Sstevel@tonic-gate modules.mod_prev->mod_next = mp; 24377c478bd9Sstevel@tonic-gate modules.mod_prev = mp; 24387c478bd9Sstevel@tonic-gate } 24397c478bd9Sstevel@tonic-gate 24407c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 24417c478bd9Sstevel@tonic-gate static struct modctl * 24427c478bd9Sstevel@tonic-gate allocate_modp(char *filename, char *modname) 24437c478bd9Sstevel@tonic-gate { 24447c478bd9Sstevel@tonic-gate struct modctl *mp; 24457c478bd9Sstevel@tonic-gate 24467c478bd9Sstevel@tonic-gate mp = kobj_zalloc(sizeof (*mp), KM_SLEEP); 24477c478bd9Sstevel@tonic-gate mp->mod_modname = kobj_zalloc(strlen(modname) + 1, KM_SLEEP); 24487c478bd9Sstevel@tonic-gate (void) strcpy(mp->mod_modname, modname); 24497c478bd9Sstevel@tonic-gate return (mp); 24507c478bd9Sstevel@tonic-gate } 24517c478bd9Sstevel@tonic-gate 24527c478bd9Sstevel@tonic-gate /* 24537c478bd9Sstevel@tonic-gate * Get the value of a symbol. This is a wrapper routine that 24547c478bd9Sstevel@tonic-gate * calls kobj_getsymvalue(). kobj_getsymvalue() may go away but this 24557c478bd9Sstevel@tonic-gate * wrapper will prevent callers from noticing. 24567c478bd9Sstevel@tonic-gate */ 24577c478bd9Sstevel@tonic-gate uintptr_t 24587c478bd9Sstevel@tonic-gate modgetsymvalue(char *name, int kernelonly) 24597c478bd9Sstevel@tonic-gate { 24607c478bd9Sstevel@tonic-gate return (kobj_getsymvalue(name, kernelonly)); 24617c478bd9Sstevel@tonic-gate } 24627c478bd9Sstevel@tonic-gate 24637c478bd9Sstevel@tonic-gate /* 24647c478bd9Sstevel@tonic-gate * Get the symbol nearest an address. This is a wrapper routine that 24657c478bd9Sstevel@tonic-gate * calls kobj_getsymname(). kobj_getsymname() may go away but this 24667c478bd9Sstevel@tonic-gate * wrapper will prevent callers from noticing. 24677c478bd9Sstevel@tonic-gate */ 24687c478bd9Sstevel@tonic-gate char * 24697c478bd9Sstevel@tonic-gate modgetsymname(uintptr_t value, ulong_t *offset) 24707c478bd9Sstevel@tonic-gate { 24717c478bd9Sstevel@tonic-gate return (kobj_getsymname(value, offset)); 24727c478bd9Sstevel@tonic-gate } 24737c478bd9Sstevel@tonic-gate 24747c478bd9Sstevel@tonic-gate /* 24757c478bd9Sstevel@tonic-gate * Lookup a symbol in a specified module. This is a wrapper routine that 24767c478bd9Sstevel@tonic-gate * calls kobj_lookup(). kobj_lookup() may go away but this 24777c478bd9Sstevel@tonic-gate * wrapper will prevent callers from noticing. 24787c478bd9Sstevel@tonic-gate */ 24797c478bd9Sstevel@tonic-gate uintptr_t 24807c478bd9Sstevel@tonic-gate modlookup(char *modname, char *symname) 24817c478bd9Sstevel@tonic-gate { 24827c478bd9Sstevel@tonic-gate struct modctl *modp; 24837c478bd9Sstevel@tonic-gate uintptr_t val; 24847c478bd9Sstevel@tonic-gate 24857c478bd9Sstevel@tonic-gate if ((modp = mod_hold_by_name(modname)) == NULL) 24867c478bd9Sstevel@tonic-gate return (0); 24877c478bd9Sstevel@tonic-gate val = kobj_lookup(modp->mod_mp, symname); 24887c478bd9Sstevel@tonic-gate mod_release_mod(modp); 24897c478bd9Sstevel@tonic-gate return (val); 24907c478bd9Sstevel@tonic-gate } 24917c478bd9Sstevel@tonic-gate 24927c478bd9Sstevel@tonic-gate /* 24937c478bd9Sstevel@tonic-gate * Ask the user for the name of the system file and the default path 24947c478bd9Sstevel@tonic-gate * for modules. 24957c478bd9Sstevel@tonic-gate */ 24967c478bd9Sstevel@tonic-gate void 24977c478bd9Sstevel@tonic-gate mod_askparams() 24987c478bd9Sstevel@tonic-gate { 24997c478bd9Sstevel@tonic-gate static char s0[64]; 25007c478bd9Sstevel@tonic-gate intptr_t fd; 25017c478bd9Sstevel@tonic-gate 25027c478bd9Sstevel@tonic-gate if ((fd = kobj_open(systemfile)) != -1L) 25037c478bd9Sstevel@tonic-gate kobj_close(fd); 25047c478bd9Sstevel@tonic-gate else 25057c478bd9Sstevel@tonic-gate systemfile = NULL; 25067c478bd9Sstevel@tonic-gate 25077c478bd9Sstevel@tonic-gate /*CONSTANTCONDITION*/ 25087c478bd9Sstevel@tonic-gate while (1) { 25097c478bd9Sstevel@tonic-gate printf("Name of system file [%s]: ", 25107c478bd9Sstevel@tonic-gate systemfile ? systemfile : "/dev/null"); 25117c478bd9Sstevel@tonic-gate 25127c478bd9Sstevel@tonic-gate console_gets(s0, sizeof (s0)); 25137c478bd9Sstevel@tonic-gate 25147c478bd9Sstevel@tonic-gate if (s0[0] == '\0') 25157c478bd9Sstevel@tonic-gate break; 25167c478bd9Sstevel@tonic-gate else if (strcmp(s0, "/dev/null") == 0) { 25177c478bd9Sstevel@tonic-gate systemfile = NULL; 25187c478bd9Sstevel@tonic-gate break; 25197c478bd9Sstevel@tonic-gate } else { 25207c478bd9Sstevel@tonic-gate if ((fd = kobj_open(s0)) != -1L) { 25217c478bd9Sstevel@tonic-gate kobj_close(fd); 25227c478bd9Sstevel@tonic-gate systemfile = s0; 25237c478bd9Sstevel@tonic-gate break; 25247c478bd9Sstevel@tonic-gate } 25257c478bd9Sstevel@tonic-gate } 25267c478bd9Sstevel@tonic-gate printf("can't find file %s\n", s0); 25277c478bd9Sstevel@tonic-gate } 25287c478bd9Sstevel@tonic-gate } 25297c478bd9Sstevel@tonic-gate 25307c478bd9Sstevel@tonic-gate static char loading_msg[] = "loading '%s' id %d\n"; 25317c478bd9Sstevel@tonic-gate static char load_msg[] = "load '%s' id %d loaded @ 0x%p/0x%p size %d/%d\n"; 25327c478bd9Sstevel@tonic-gate 25337c478bd9Sstevel@tonic-gate /* 25347c478bd9Sstevel@tonic-gate * Common code for loading a module (but not installing it). 25357c478bd9Sstevel@tonic-gate * Handoff the task of module loading to a seperate thread 25367c478bd9Sstevel@tonic-gate * with a large stack if possible, since this code may recurse a few times. 25377c478bd9Sstevel@tonic-gate * Return zero if there are no errors or an errno value. 25387c478bd9Sstevel@tonic-gate */ 25397c478bd9Sstevel@tonic-gate static int 25407c478bd9Sstevel@tonic-gate mod_load(struct modctl *mp, int usepath) 25417c478bd9Sstevel@tonic-gate { 25427c478bd9Sstevel@tonic-gate int retval; 25437c478bd9Sstevel@tonic-gate struct modinfo *modinfop = NULL; 25447c478bd9Sstevel@tonic-gate struct loadmt lt; 25457c478bd9Sstevel@tonic-gate 25467c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&mod_lock)); 25477c478bd9Sstevel@tonic-gate ASSERT(mp->mod_busy); 25487c478bd9Sstevel@tonic-gate 25497c478bd9Sstevel@tonic-gate if (mp->mod_loaded) 25507c478bd9Sstevel@tonic-gate return (0); 25517c478bd9Sstevel@tonic-gate 25527c478bd9Sstevel@tonic-gate if (mod_sysctl(SYS_CHECK_EXCLUDE, mp->mod_modname) != 0 || 25537c478bd9Sstevel@tonic-gate mod_sysctl(SYS_CHECK_EXCLUDE, mp->mod_filename) != 0) { 25547c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_LOADMSG) { 25557c478bd9Sstevel@tonic-gate printf(mod_excl_msg, mp->mod_filename, 25567c478bd9Sstevel@tonic-gate mp->mod_modname); 25577c478bd9Sstevel@tonic-gate } 25587c478bd9Sstevel@tonic-gate return (ENXIO); 25597c478bd9Sstevel@tonic-gate } 25607c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_LOADMSG2) 25617c478bd9Sstevel@tonic-gate printf(loading_msg, mp->mod_filename, mp->mod_id); 25627c478bd9Sstevel@tonic-gate 25637c478bd9Sstevel@tonic-gate if (curthread != &t0) { 25647c478bd9Sstevel@tonic-gate lt.mp = mp; 25657c478bd9Sstevel@tonic-gate lt.usepath = usepath; 25667c478bd9Sstevel@tonic-gate lt.owner = curthread; 25677c478bd9Sstevel@tonic-gate sema_init(<.sema, 0, NULL, SEMA_DEFAULT, NULL); 25687c478bd9Sstevel@tonic-gate 25697c478bd9Sstevel@tonic-gate /* create thread to hand of call to */ 25707c478bd9Sstevel@tonic-gate (void) thread_create(NULL, DEFAULTSTKSZ * 2, 25717c478bd9Sstevel@tonic-gate modload_thread, <, 0, &p0, TS_RUN, maxclsyspri); 25727c478bd9Sstevel@tonic-gate 25737c478bd9Sstevel@tonic-gate /* wait for thread to complete kobj_load_module */ 25747c478bd9Sstevel@tonic-gate sema_p(<.sema); 25757c478bd9Sstevel@tonic-gate 25767c478bd9Sstevel@tonic-gate sema_destroy(<.sema); 25777c478bd9Sstevel@tonic-gate retval = lt.retval; 25787c478bd9Sstevel@tonic-gate } else 25797c478bd9Sstevel@tonic-gate retval = kobj_load_module(mp, usepath); 25807c478bd9Sstevel@tonic-gate 25817c478bd9Sstevel@tonic-gate if (mp->mod_mp) { 25827c478bd9Sstevel@tonic-gate ASSERT(retval == 0); 25837c478bd9Sstevel@tonic-gate mp->mod_loaded = 1; 25847c478bd9Sstevel@tonic-gate mp->mod_loadcnt++; 25857c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_LOADMSG) { 25867c478bd9Sstevel@tonic-gate printf(load_msg, mp->mod_filename, mp->mod_id, 25877c478bd9Sstevel@tonic-gate (void *)((struct module *)mp->mod_mp)->text, 25887c478bd9Sstevel@tonic-gate (void *)((struct module *)mp->mod_mp)->data, 25897c478bd9Sstevel@tonic-gate ((struct module *)mp->mod_mp)->text_size, 25907c478bd9Sstevel@tonic-gate ((struct module *)mp->mod_mp)->data_size); 25917c478bd9Sstevel@tonic-gate } 25927c478bd9Sstevel@tonic-gate 25937c478bd9Sstevel@tonic-gate /* 25947c478bd9Sstevel@tonic-gate * XXX - There should be a better way to get this. 25957c478bd9Sstevel@tonic-gate */ 25967c478bd9Sstevel@tonic-gate modinfop = kmem_zalloc(sizeof (struct modinfo), KM_SLEEP); 25977c478bd9Sstevel@tonic-gate modinfop->mi_info = MI_INFO_LINKAGE; 25987c478bd9Sstevel@tonic-gate if (mod_getinfo(mp, modinfop) == 0) 25997c478bd9Sstevel@tonic-gate mp->mod_linkage = NULL; 26007c478bd9Sstevel@tonic-gate else { 26017c478bd9Sstevel@tonic-gate mp->mod_linkage = (void *)modinfop->mi_base; 26027c478bd9Sstevel@tonic-gate ASSERT(mp->mod_linkage->ml_rev == MODREV_1); 26037c478bd9Sstevel@tonic-gate } 26047c478bd9Sstevel@tonic-gate 26057c478bd9Sstevel@tonic-gate /* 26067c478bd9Sstevel@tonic-gate * DCS: bootstrapping code. If the driver is loaded 26077c478bd9Sstevel@tonic-gate * before root mount, it is assumed that the driver 26087c478bd9Sstevel@tonic-gate * may be used before mounting root. In order to 26097c478bd9Sstevel@tonic-gate * access mappings of global to local minor no.'s 26107c478bd9Sstevel@tonic-gate * during installation/open of the driver, we load 26117c478bd9Sstevel@tonic-gate * them into memory here while the BOP_interfaces 26127c478bd9Sstevel@tonic-gate * are still up. 26137c478bd9Sstevel@tonic-gate */ 26147c478bd9Sstevel@tonic-gate if ((cluster_bootflags & CLUSTER_BOOTED) && !modrootloaded) { 26157c478bd9Sstevel@tonic-gate retval = clboot_modload(mp); 26167c478bd9Sstevel@tonic-gate } 26177c478bd9Sstevel@tonic-gate 26187c478bd9Sstevel@tonic-gate kmem_free(modinfop, sizeof (struct modinfo)); 26197c478bd9Sstevel@tonic-gate (void) mod_sysctl(SYS_SET_MVAR, (void *)mp); 26207c478bd9Sstevel@tonic-gate retval = install_stubs_by_name(mp, mp->mod_modname); 26217c478bd9Sstevel@tonic-gate 26227c478bd9Sstevel@tonic-gate /* 26237c478bd9Sstevel@tonic-gate * Now that the module is loaded, we need to give DTrace 26247c478bd9Sstevel@tonic-gate * a chance to notify its providers. This is done via 26257c478bd9Sstevel@tonic-gate * the dtrace_modload function pointer. 26267c478bd9Sstevel@tonic-gate */ 26277c478bd9Sstevel@tonic-gate if (strcmp(mp->mod_modname, "dtrace") != 0) { 26287c478bd9Sstevel@tonic-gate struct modctl *dmp = mod_hold_by_name("dtrace"); 26297c478bd9Sstevel@tonic-gate 26307c478bd9Sstevel@tonic-gate if (dmp != NULL && dtrace_modload != NULL) 26317c478bd9Sstevel@tonic-gate (*dtrace_modload)(mp); 26327c478bd9Sstevel@tonic-gate 26337c478bd9Sstevel@tonic-gate mod_release_mod(dmp); 26347c478bd9Sstevel@tonic-gate } 26357c478bd9Sstevel@tonic-gate 26367c478bd9Sstevel@tonic-gate } else { 26377c478bd9Sstevel@tonic-gate /* 26387c478bd9Sstevel@tonic-gate * If load failed then we need to release any requisites 26397c478bd9Sstevel@tonic-gate * that we had established. 26407c478bd9Sstevel@tonic-gate */ 26417c478bd9Sstevel@tonic-gate ASSERT(retval); 26427c478bd9Sstevel@tonic-gate mod_release_requisites(mp); 26437c478bd9Sstevel@tonic-gate 26447c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_ERRMSG) 26457c478bd9Sstevel@tonic-gate printf("error loading '%s', error %d\n", 26467c478bd9Sstevel@tonic-gate mp->mod_filename, retval); 26477c478bd9Sstevel@tonic-gate } 26487c478bd9Sstevel@tonic-gate return (retval); 26497c478bd9Sstevel@tonic-gate } 26507c478bd9Sstevel@tonic-gate 26517c478bd9Sstevel@tonic-gate static char unload_msg[] = "unloading %s, module id %d, loadcnt %d.\n"; 26527c478bd9Sstevel@tonic-gate 26537c478bd9Sstevel@tonic-gate static void 26547c478bd9Sstevel@tonic-gate mod_unload(struct modctl *mp) 26557c478bd9Sstevel@tonic-gate { 26567c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&mod_lock)); 26577c478bd9Sstevel@tonic-gate ASSERT(mp->mod_busy); 26587c478bd9Sstevel@tonic-gate ASSERT((mp->mod_loaded && (mp->mod_installed == 0)) && 26597c478bd9Sstevel@tonic-gate ((mp->mod_prim == 0) && (mp->mod_ref >= 0))); 26607c478bd9Sstevel@tonic-gate 26617c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_LOADMSG) 26627c478bd9Sstevel@tonic-gate printf(unload_msg, mp->mod_modname, 26637c478bd9Sstevel@tonic-gate mp->mod_id, mp->mod_loadcnt); 26647c478bd9Sstevel@tonic-gate 26657c478bd9Sstevel@tonic-gate /* 26667c478bd9Sstevel@tonic-gate * If mod_ref is not zero, it means some modules might still refer 26677c478bd9Sstevel@tonic-gate * to this module. Then you can't unload this module right now. 26687c478bd9Sstevel@tonic-gate * Instead, set 1 to mod_delay_unload to notify the system of 26697c478bd9Sstevel@tonic-gate * unloading this module later when it's not required any more. 26707c478bd9Sstevel@tonic-gate */ 26717c478bd9Sstevel@tonic-gate if (mp->mod_ref > 0) { 26727c478bd9Sstevel@tonic-gate mp->mod_delay_unload = 1; 26737c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_LOADMSG2) { 26747c478bd9Sstevel@tonic-gate printf("module %s not unloaded," 26757c478bd9Sstevel@tonic-gate " non-zero reference count (%d)", 26767c478bd9Sstevel@tonic-gate mp->mod_modname, mp->mod_ref); 26777c478bd9Sstevel@tonic-gate } 26787c478bd9Sstevel@tonic-gate return; 26797c478bd9Sstevel@tonic-gate } 26807c478bd9Sstevel@tonic-gate 26817c478bd9Sstevel@tonic-gate if (((mp->mod_loaded == 0) || mp->mod_installed) || 26827c478bd9Sstevel@tonic-gate (mp->mod_ref || mp->mod_prim)) { 26837c478bd9Sstevel@tonic-gate /* 26847c478bd9Sstevel@tonic-gate * A DEBUG kernel would ASSERT panic above, the code is broken 26857c478bd9Sstevel@tonic-gate * if we get this warning. 26867c478bd9Sstevel@tonic-gate */ 26877c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "mod_unload: %s in incorrect state: %d %d %d", 26887c478bd9Sstevel@tonic-gate mp->mod_filename, mp->mod_installed, mp->mod_loaded, 26897c478bd9Sstevel@tonic-gate mp->mod_ref); 26907c478bd9Sstevel@tonic-gate return; 26917c478bd9Sstevel@tonic-gate } 26927c478bd9Sstevel@tonic-gate 26937c478bd9Sstevel@tonic-gate /* reset stub functions to call the binder again */ 26947c478bd9Sstevel@tonic-gate reset_stubs(mp); 26957c478bd9Sstevel@tonic-gate 26967c478bd9Sstevel@tonic-gate /* 26977c478bd9Sstevel@tonic-gate * mark module as unloaded before the modctl structure is freed. 26987c478bd9Sstevel@tonic-gate * This is required not to reuse the modctl structure before 26997c478bd9Sstevel@tonic-gate * the module is marked as unloaded. 27007c478bd9Sstevel@tonic-gate */ 27017c478bd9Sstevel@tonic-gate mp->mod_loaded = 0; 27027c478bd9Sstevel@tonic-gate mp->mod_linkage = NULL; 27037c478bd9Sstevel@tonic-gate 27047c478bd9Sstevel@tonic-gate /* free the memory */ 27057c478bd9Sstevel@tonic-gate kobj_unload_module(mp); 27067c478bd9Sstevel@tonic-gate 27077c478bd9Sstevel@tonic-gate if (mp->mod_delay_unload) { 27087c478bd9Sstevel@tonic-gate mp->mod_delay_unload = 0; 27097c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_LOADMSG2) { 27107c478bd9Sstevel@tonic-gate printf("deferred unload of module %s" 27117c478bd9Sstevel@tonic-gate " (id %d) successful", 27127c478bd9Sstevel@tonic-gate mp->mod_modname, mp->mod_id); 27137c478bd9Sstevel@tonic-gate } 27147c478bd9Sstevel@tonic-gate } 27157c478bd9Sstevel@tonic-gate 27167c478bd9Sstevel@tonic-gate /* release hold on requisites */ 27177c478bd9Sstevel@tonic-gate mod_release_requisites(mp); 27187c478bd9Sstevel@tonic-gate 27197c478bd9Sstevel@tonic-gate /* 27207c478bd9Sstevel@tonic-gate * Now that the module is gone, we need to give DTrace a chance to 27217c478bd9Sstevel@tonic-gate * remove any probes that it may have had in the module. This is 27227c478bd9Sstevel@tonic-gate * done via the dtrace_modunload function pointer. 27237c478bd9Sstevel@tonic-gate */ 27247c478bd9Sstevel@tonic-gate if (strcmp(mp->mod_modname, "dtrace") != 0) { 27257c478bd9Sstevel@tonic-gate struct modctl *dmp = mod_hold_by_name("dtrace"); 27267c478bd9Sstevel@tonic-gate 27277c478bd9Sstevel@tonic-gate if (dmp != NULL && dtrace_modunload != NULL) 27287c478bd9Sstevel@tonic-gate (*dtrace_modunload)(mp); 27297c478bd9Sstevel@tonic-gate 27307c478bd9Sstevel@tonic-gate mod_release_mod(dmp); 27317c478bd9Sstevel@tonic-gate } 27327c478bd9Sstevel@tonic-gate } 27337c478bd9Sstevel@tonic-gate 27347c478bd9Sstevel@tonic-gate static int 27357c478bd9Sstevel@tonic-gate modinstall(struct modctl *mp) 27367c478bd9Sstevel@tonic-gate { 27377c478bd9Sstevel@tonic-gate int val; 27387c478bd9Sstevel@tonic-gate int (*func)(void); 27397c478bd9Sstevel@tonic-gate 27407c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&mod_lock)); 27417c478bd9Sstevel@tonic-gate ASSERT(mp->mod_busy && mp->mod_loaded); 27427c478bd9Sstevel@tonic-gate 27437c478bd9Sstevel@tonic-gate if (mp->mod_installed) 27447c478bd9Sstevel@tonic-gate return (0); 27457c478bd9Sstevel@tonic-gate /* 27467c478bd9Sstevel@tonic-gate * If mod_delay_unload is on, it means the system chose the deferred 27477c478bd9Sstevel@tonic-gate * unload for this module. Then you can't install this module until 27487c478bd9Sstevel@tonic-gate * it's unloaded from the system. 27497c478bd9Sstevel@tonic-gate */ 27507c478bd9Sstevel@tonic-gate if (mp->mod_delay_unload) 27517c478bd9Sstevel@tonic-gate return (ENXIO); 27527c478bd9Sstevel@tonic-gate 27537c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_LOADMSG) 27547c478bd9Sstevel@tonic-gate printf("installing %s, module id %d.\n", 27557c478bd9Sstevel@tonic-gate mp->mod_modname, mp->mod_id); 27567c478bd9Sstevel@tonic-gate 27577c478bd9Sstevel@tonic-gate ASSERT(mp->mod_mp != NULL); 27587c478bd9Sstevel@tonic-gate if (mod_install_requisites(mp) != 0) { 27597c478bd9Sstevel@tonic-gate /* 27607c478bd9Sstevel@tonic-gate * Note that we can't call mod_unload(mp) here since 27617c478bd9Sstevel@tonic-gate * if modinstall() was called by mod_install_requisites(), 27627c478bd9Sstevel@tonic-gate * we won't be able to hold the dependent modules 27637c478bd9Sstevel@tonic-gate * (otherwise there would be a deadlock). 27647c478bd9Sstevel@tonic-gate */ 27657c478bd9Sstevel@tonic-gate return (ENXIO); 27667c478bd9Sstevel@tonic-gate } 27677c478bd9Sstevel@tonic-gate 27687c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_ERRMSG) { 27697c478bd9Sstevel@tonic-gate printf("init '%s' id %d loaded @ 0x%p/0x%p size %lu/%lu\n", 27707c478bd9Sstevel@tonic-gate mp->mod_filename, mp->mod_id, 27717c478bd9Sstevel@tonic-gate (void *)((struct module *)mp->mod_mp)->text, 27727c478bd9Sstevel@tonic-gate (void *)((struct module *)mp->mod_mp)->data, 27737c478bd9Sstevel@tonic-gate ((struct module *)mp->mod_mp)->text_size, 27747c478bd9Sstevel@tonic-gate ((struct module *)mp->mod_mp)->data_size); 27757c478bd9Sstevel@tonic-gate } 27767c478bd9Sstevel@tonic-gate 27777c478bd9Sstevel@tonic-gate func = (int (*)())kobj_lookup(mp->mod_mp, "_init"); 27787c478bd9Sstevel@tonic-gate 27797c478bd9Sstevel@tonic-gate if (kobj_addrcheck(mp->mod_mp, (caddr_t)func)) { 27807c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "_init() not defined properly in %s", 27817c478bd9Sstevel@tonic-gate mp->mod_filename); 27827c478bd9Sstevel@tonic-gate return (EFAULT); 27837c478bd9Sstevel@tonic-gate } 27847c478bd9Sstevel@tonic-gate 27857c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_USERDEBUG) { 27867c478bd9Sstevel@tonic-gate printf("breakpoint before calling %s:_init()\n", 27877c478bd9Sstevel@tonic-gate mp->mod_modname); 27887c478bd9Sstevel@tonic-gate if (DEBUGGER_PRESENT) 27897c478bd9Sstevel@tonic-gate debug_enter("_init"); 27907c478bd9Sstevel@tonic-gate } 27917c478bd9Sstevel@tonic-gate 27927c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&mod_lock)); 27937c478bd9Sstevel@tonic-gate ASSERT(mp->mod_busy && mp->mod_loaded); 27947c478bd9Sstevel@tonic-gate val = (*func)(); /* call _init */ 27957c478bd9Sstevel@tonic-gate 27967c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_USERDEBUG) 27977c478bd9Sstevel@tonic-gate printf("Returned from _init, val = %x\n", val); 27987c478bd9Sstevel@tonic-gate 27997c478bd9Sstevel@tonic-gate if (val == 0) { 28007c478bd9Sstevel@tonic-gate /* 28017c478bd9Sstevel@tonic-gate * Set the MODS_INSTALLED flag to enable this module 28027c478bd9Sstevel@tonic-gate * being called now. 28037c478bd9Sstevel@tonic-gate */ 28047c478bd9Sstevel@tonic-gate install_stubs(mp); 28057c478bd9Sstevel@tonic-gate mp->mod_installed = 1; 28067c478bd9Sstevel@tonic-gate } else if (moddebug & MODDEBUG_ERRMSG) 28077c478bd9Sstevel@tonic-gate printf(mod_init_msg, mp->mod_filename, mp->mod_modname, val); 28087c478bd9Sstevel@tonic-gate 28097c478bd9Sstevel@tonic-gate return (val); 28107c478bd9Sstevel@tonic-gate } 28117c478bd9Sstevel@tonic-gate 28127c478bd9Sstevel@tonic-gate static int 28137c478bd9Sstevel@tonic-gate detach_driver(char *name) 28147c478bd9Sstevel@tonic-gate { 28157c478bd9Sstevel@tonic-gate major_t major; 28167c478bd9Sstevel@tonic-gate int error; 28177c478bd9Sstevel@tonic-gate 28187c478bd9Sstevel@tonic-gate /* 28197c478bd9Sstevel@tonic-gate * If being called from mod_uninstall_all() then the appropriate 28207c478bd9Sstevel@tonic-gate * driver detaches (leaf only) have already been done. 28217c478bd9Sstevel@tonic-gate */ 28227c478bd9Sstevel@tonic-gate if (mod_in_autounload()) 28237c478bd9Sstevel@tonic-gate return (0); 28247c478bd9Sstevel@tonic-gate 28257c478bd9Sstevel@tonic-gate major = ddi_name_to_major(name); 28267c478bd9Sstevel@tonic-gate if (major == (major_t)-1) 28277c478bd9Sstevel@tonic-gate return (0); 28287c478bd9Sstevel@tonic-gate 28297c478bd9Sstevel@tonic-gate error = ndi_devi_unconfig_driver(ddi_root_node(), 28307c478bd9Sstevel@tonic-gate NDI_DETACH_DRIVER, major); 28317c478bd9Sstevel@tonic-gate return (error == NDI_SUCCESS ? 0 : -1); 28327c478bd9Sstevel@tonic-gate } 28337c478bd9Sstevel@tonic-gate 28347c478bd9Sstevel@tonic-gate static char finiret_msg[] = "Returned from _fini for %s, status = %x\n"; 28357c478bd9Sstevel@tonic-gate 28367c478bd9Sstevel@tonic-gate static int 28377c478bd9Sstevel@tonic-gate moduninstall(struct modctl *mp) 28387c478bd9Sstevel@tonic-gate { 28397c478bd9Sstevel@tonic-gate int status = 0; 28407c478bd9Sstevel@tonic-gate int (*func)(void); 28417c478bd9Sstevel@tonic-gate 28427c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&mod_lock)); 28437c478bd9Sstevel@tonic-gate ASSERT(mp->mod_busy); 28447c478bd9Sstevel@tonic-gate 28457c478bd9Sstevel@tonic-gate /* 28467c478bd9Sstevel@tonic-gate * Verify that we need to do something and can uninstall the module. 28477c478bd9Sstevel@tonic-gate * 28487c478bd9Sstevel@tonic-gate * If we should not uninstall the module or if the module is not in 28497c478bd9Sstevel@tonic-gate * the correct state to start an uninstall we return EBUSY to prevent 28507c478bd9Sstevel@tonic-gate * us from progressing to mod_unload. If the module has already been 28517c478bd9Sstevel@tonic-gate * uninstalled and unloaded we return EALREADY. 28527c478bd9Sstevel@tonic-gate */ 28537c478bd9Sstevel@tonic-gate if (mp->mod_prim || mp->mod_ref || mp->mod_nenabled != 0) 28547c478bd9Sstevel@tonic-gate return (EBUSY); 28557c478bd9Sstevel@tonic-gate if ((mp->mod_installed == 0) || (mp->mod_loaded == 0)) 28567c478bd9Sstevel@tonic-gate return (EALREADY); 28577c478bd9Sstevel@tonic-gate 28587c478bd9Sstevel@tonic-gate /* 28597c478bd9Sstevel@tonic-gate * To avoid devinfo / module deadlock we must release this module 28607c478bd9Sstevel@tonic-gate * prior to initiating the detach_driver, otherwise the detach_driver 28617c478bd9Sstevel@tonic-gate * might deadlock on a devinfo node held by another thread 28627c478bd9Sstevel@tonic-gate * coming top down and involving the module we have locked. 28637c478bd9Sstevel@tonic-gate * 28647c478bd9Sstevel@tonic-gate * When we regrab the module we must reverify that it is OK 28657c478bd9Sstevel@tonic-gate * to proceed with the uninstall operation. 28667c478bd9Sstevel@tonic-gate */ 28677c478bd9Sstevel@tonic-gate mod_release_mod(mp); 28687c478bd9Sstevel@tonic-gate status = detach_driver(mp->mod_modname); 28697c478bd9Sstevel@tonic-gate (void) mod_hold_by_modctl(mp, MOD_WAIT_FOREVER | MOD_LOCK_NOT_HELD); 28707c478bd9Sstevel@tonic-gate 28717c478bd9Sstevel@tonic-gate /* check detach status and reverify state with lock */ 28727c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 28737c478bd9Sstevel@tonic-gate if ((status != 0) || mp->mod_prim || mp->mod_ref) { 28747c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 28757c478bd9Sstevel@tonic-gate return (EBUSY); 28767c478bd9Sstevel@tonic-gate } 28777c478bd9Sstevel@tonic-gate if ((mp->mod_installed == 0) || (mp->mod_loaded == 0)) { 28787c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 28797c478bd9Sstevel@tonic-gate return (EALREADY); 28807c478bd9Sstevel@tonic-gate } 28817c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 28827c478bd9Sstevel@tonic-gate 28837c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_LOADMSG2) 28847c478bd9Sstevel@tonic-gate printf("uninstalling %s\n", mp->mod_modname); 28857c478bd9Sstevel@tonic-gate 28867c478bd9Sstevel@tonic-gate /* 28877c478bd9Sstevel@tonic-gate * lookup _fini, return EBUSY if not defined. 28887c478bd9Sstevel@tonic-gate * 28897c478bd9Sstevel@tonic-gate * The MODDEBUG_FINI_EBUSY is usefull in resolving leaks in 28907c478bd9Sstevel@tonic-gate * detach(9E) - it allows bufctl addresses to be resolved. 28917c478bd9Sstevel@tonic-gate */ 28927c478bd9Sstevel@tonic-gate func = (int (*)())kobj_lookup(mp->mod_mp, "_fini"); 28937c478bd9Sstevel@tonic-gate if ((func == NULL) || (mp->mod_loadflags & MOD_NOUNLOAD) || 28947c478bd9Sstevel@tonic-gate (moddebug & MODDEBUG_FINI_EBUSY)) 28957c478bd9Sstevel@tonic-gate return (EBUSY); 28967c478bd9Sstevel@tonic-gate 28977c478bd9Sstevel@tonic-gate /* verify that _fini is in this module */ 28987c478bd9Sstevel@tonic-gate if (kobj_addrcheck(mp->mod_mp, (caddr_t)func)) { 28997c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "_fini() not defined properly in %s", 29007c478bd9Sstevel@tonic-gate mp->mod_filename); 29017c478bd9Sstevel@tonic-gate return (EFAULT); 29027c478bd9Sstevel@tonic-gate } 29037c478bd9Sstevel@tonic-gate 29047c478bd9Sstevel@tonic-gate /* call _fini() */ 29057c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&mod_lock)); 29067c478bd9Sstevel@tonic-gate ASSERT(mp->mod_busy && mp->mod_loaded && mp->mod_installed); 29077c478bd9Sstevel@tonic-gate 29087c478bd9Sstevel@tonic-gate status = (*func)(); 29097c478bd9Sstevel@tonic-gate 29107c478bd9Sstevel@tonic-gate if (status == 0) { 29117c478bd9Sstevel@tonic-gate /* _fini returned success, the module is no longer installed */ 29127c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_LOADMSG) 29137c478bd9Sstevel@tonic-gate printf("uninstalled %s\n", mp->mod_modname); 29147c478bd9Sstevel@tonic-gate 29157c478bd9Sstevel@tonic-gate /* 29167c478bd9Sstevel@tonic-gate * Even though we only set mod_installed to zero here, a zero 29177c478bd9Sstevel@tonic-gate * return value means we are commited to a code path were 29187c478bd9Sstevel@tonic-gate * mod_loaded will also end up as zero - we have no other 29197c478bd9Sstevel@tonic-gate * way to get the module data and bss back to the pre _init 29207c478bd9Sstevel@tonic-gate * state except a reload. To ensure this, after return, 29217c478bd9Sstevel@tonic-gate * mod_busy must stay set until mod_loaded is cleared. 29227c478bd9Sstevel@tonic-gate */ 29237c478bd9Sstevel@tonic-gate mp->mod_installed = 0; 29247c478bd9Sstevel@tonic-gate 29257c478bd9Sstevel@tonic-gate /* 29267c478bd9Sstevel@tonic-gate * Clear the MODS_INSTALLED flag not to call functions 29277c478bd9Sstevel@tonic-gate * in the module directly from now on. 29287c478bd9Sstevel@tonic-gate */ 29297c478bd9Sstevel@tonic-gate uninstall_stubs(mp); 29307c478bd9Sstevel@tonic-gate } else { 29317c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_USERDEBUG) 29327c478bd9Sstevel@tonic-gate printf(finiret_msg, mp->mod_filename, status); 29337c478bd9Sstevel@tonic-gate /* 29347c478bd9Sstevel@tonic-gate * By definition _fini is only allowed to return EBUSY or the 29357c478bd9Sstevel@tonic-gate * result of mod_remove (EBUSY or EINVAL). In the off chance 29367c478bd9Sstevel@tonic-gate * that a driver returns EALREADY we convert this to EINVAL 29377c478bd9Sstevel@tonic-gate * since to our caller EALREADY means module was already 29387c478bd9Sstevel@tonic-gate * removed. 29397c478bd9Sstevel@tonic-gate */ 29407c478bd9Sstevel@tonic-gate if (status == EALREADY) 29417c478bd9Sstevel@tonic-gate status = EINVAL; 29427c478bd9Sstevel@tonic-gate } 29437c478bd9Sstevel@tonic-gate 29447c478bd9Sstevel@tonic-gate return (status); 29457c478bd9Sstevel@tonic-gate } 29467c478bd9Sstevel@tonic-gate 29477c478bd9Sstevel@tonic-gate /* 29487c478bd9Sstevel@tonic-gate * Uninstall all modules. 29497c478bd9Sstevel@tonic-gate */ 29507c478bd9Sstevel@tonic-gate static void 29517c478bd9Sstevel@tonic-gate mod_uninstall_all(void) 29527c478bd9Sstevel@tonic-gate { 29537c478bd9Sstevel@tonic-gate struct modctl *mp; 29547c478bd9Sstevel@tonic-gate modid_t modid = 0; 29557c478bd9Sstevel@tonic-gate 29567c478bd9Sstevel@tonic-gate /* mark this thread as doing autounloading */ 29577c478bd9Sstevel@tonic-gate (void) tsd_set(mod_autounload_key, (void *)1); 29587c478bd9Sstevel@tonic-gate 29597c478bd9Sstevel@tonic-gate (void) devfs_clean(ddi_root_node(), NULL, 0); 29607c478bd9Sstevel@tonic-gate (void) ndi_devi_unconfig(ddi_root_node(), NDI_AUTODETACH); 29617c478bd9Sstevel@tonic-gate 29627c478bd9Sstevel@tonic-gate while ((mp = mod_hold_next_by_id(modid)) != NULL) { 29637c478bd9Sstevel@tonic-gate modid = mp->mod_id; 29647c478bd9Sstevel@tonic-gate /* 29657c478bd9Sstevel@tonic-gate * Skip modules with the MOD_NOAUTOUNLOAD flag set 29667c478bd9Sstevel@tonic-gate */ 29677c478bd9Sstevel@tonic-gate if (mp->mod_loadflags & MOD_NOAUTOUNLOAD) { 29687c478bd9Sstevel@tonic-gate mod_release_mod(mp); 29697c478bd9Sstevel@tonic-gate continue; 29707c478bd9Sstevel@tonic-gate } 29717c478bd9Sstevel@tonic-gate 2972*0b38a8bdSahl if (moduninstall(mp) == 0) { 29737c478bd9Sstevel@tonic-gate mod_unload(mp); 2974*0b38a8bdSahl CPU_STATS_ADDQ(CPU, sys, modunload, 1); 2975*0b38a8bdSahl } 29767c478bd9Sstevel@tonic-gate mod_release_mod(mp); 29777c478bd9Sstevel@tonic-gate } 29787c478bd9Sstevel@tonic-gate 29797c478bd9Sstevel@tonic-gate (void) tsd_set(mod_autounload_key, NULL); 29807c478bd9Sstevel@tonic-gate } 29817c478bd9Sstevel@tonic-gate 29827c478bd9Sstevel@tonic-gate static int modunload_disable_count; 29837c478bd9Sstevel@tonic-gate 29847c478bd9Sstevel@tonic-gate void 29857c478bd9Sstevel@tonic-gate modunload_disable(void) 29867c478bd9Sstevel@tonic-gate { 29877c478bd9Sstevel@tonic-gate INCR_COUNT(&modunload_disable_count, &mod_uninstall_lock); 29887c478bd9Sstevel@tonic-gate } 29897c478bd9Sstevel@tonic-gate 29907c478bd9Sstevel@tonic-gate void 29917c478bd9Sstevel@tonic-gate modunload_enable(void) 29927c478bd9Sstevel@tonic-gate { 29937c478bd9Sstevel@tonic-gate DECR_COUNT(&modunload_disable_count, &mod_uninstall_lock); 29947c478bd9Sstevel@tonic-gate } 29957c478bd9Sstevel@tonic-gate 29967c478bd9Sstevel@tonic-gate void 29977c478bd9Sstevel@tonic-gate mod_uninstall_daemon(void) 29987c478bd9Sstevel@tonic-gate { 29997c478bd9Sstevel@tonic-gate callb_cpr_t cprinfo; 30007c478bd9Sstevel@tonic-gate clock_t ticks = 0; 30017c478bd9Sstevel@tonic-gate 30027c478bd9Sstevel@tonic-gate mod_aul_thread = curthread; 30037c478bd9Sstevel@tonic-gate 30047c478bd9Sstevel@tonic-gate CALLB_CPR_INIT(&cprinfo, &mod_uninstall_lock, callb_generic_cpr, "mud"); 30057c478bd9Sstevel@tonic-gate for (;;) { 30067c478bd9Sstevel@tonic-gate mutex_enter(&mod_uninstall_lock); 30077c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_BEGIN(&cprinfo); 30087c478bd9Sstevel@tonic-gate /* 30097c478bd9Sstevel@tonic-gate * In DEBUG kernels, unheld drivers are uninstalled periodically 30107c478bd9Sstevel@tonic-gate * every mod_uninstall_interval seconds. Periodic uninstall can 30117c478bd9Sstevel@tonic-gate * be disabled by setting mod_uninstall_interval to 0 which is 30127c478bd9Sstevel@tonic-gate * the default for a non-DEBUG kernel. 30137c478bd9Sstevel@tonic-gate */ 30147c478bd9Sstevel@tonic-gate if (mod_uninstall_interval) { 30157c478bd9Sstevel@tonic-gate ticks = ddi_get_lbolt() + 30167c478bd9Sstevel@tonic-gate drv_usectohz(mod_uninstall_interval * 1000000); 30177c478bd9Sstevel@tonic-gate (void) cv_timedwait(&mod_uninstall_cv, 30187c478bd9Sstevel@tonic-gate &mod_uninstall_lock, ticks); 30197c478bd9Sstevel@tonic-gate } else { 30207c478bd9Sstevel@tonic-gate cv_wait(&mod_uninstall_cv, &mod_uninstall_lock); 30217c478bd9Sstevel@tonic-gate } 30227c478bd9Sstevel@tonic-gate /* 30237c478bd9Sstevel@tonic-gate * The whole daemon is safe for CPR except we don't want 30247c478bd9Sstevel@tonic-gate * the daemon to run if FREEZE is issued and this daemon 30257c478bd9Sstevel@tonic-gate * wakes up from the cv_wait above. In this case, it'll be 30267c478bd9Sstevel@tonic-gate * blocked in CALLB_CPR_SAFE_END until THAW is issued. 30277c478bd9Sstevel@tonic-gate * 30287c478bd9Sstevel@tonic-gate * The reason of calling CALLB_CPR_SAFE_BEGIN twice is that 30297c478bd9Sstevel@tonic-gate * mod_uninstall_lock is used to protect cprinfo and 30307c478bd9Sstevel@tonic-gate * CALLB_CPR_SAFE_BEGIN assumes that this lock is held when 30317c478bd9Sstevel@tonic-gate * called. 30327c478bd9Sstevel@tonic-gate */ 30337c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_END(&cprinfo, &mod_uninstall_lock); 30347c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_BEGIN(&cprinfo); 30357c478bd9Sstevel@tonic-gate mutex_exit(&mod_uninstall_lock); 30367c478bd9Sstevel@tonic-gate if ((modunload_disable_count == 0) && 30377c478bd9Sstevel@tonic-gate ((moddebug & MODDEBUG_NOAUTOUNLOAD) == 0)) { 30387c478bd9Sstevel@tonic-gate mod_uninstall_all(); 30397c478bd9Sstevel@tonic-gate } 30407c478bd9Sstevel@tonic-gate } 30417c478bd9Sstevel@tonic-gate } 30427c478bd9Sstevel@tonic-gate 30437c478bd9Sstevel@tonic-gate /* 30447c478bd9Sstevel@tonic-gate * Unload all uninstalled modules. 30457c478bd9Sstevel@tonic-gate */ 30467c478bd9Sstevel@tonic-gate void 30477c478bd9Sstevel@tonic-gate modreap(void) 30487c478bd9Sstevel@tonic-gate { 30497c478bd9Sstevel@tonic-gate mutex_enter(&mod_uninstall_lock); 30507c478bd9Sstevel@tonic-gate cv_broadcast(&mod_uninstall_cv); 30517c478bd9Sstevel@tonic-gate mutex_exit(&mod_uninstall_lock); 30527c478bd9Sstevel@tonic-gate } 30537c478bd9Sstevel@tonic-gate 30547c478bd9Sstevel@tonic-gate /* 30557c478bd9Sstevel@tonic-gate * Hold the specified module. This is the module holding primitive. 30567c478bd9Sstevel@tonic-gate * 30577c478bd9Sstevel@tonic-gate * If MOD_LOCK_HELD then the caller already holds the mod_lock. 30587c478bd9Sstevel@tonic-gate * 30597c478bd9Sstevel@tonic-gate * Return values: 30607c478bd9Sstevel@tonic-gate * 0 ==> the module is held 30617c478bd9Sstevel@tonic-gate * 1 ==> the module is not held and the MOD_WAIT_ONCE caller needs 30627c478bd9Sstevel@tonic-gate * to determine how to retry. 30637c478bd9Sstevel@tonic-gate */ 30647c478bd9Sstevel@tonic-gate int 30657c478bd9Sstevel@tonic-gate mod_hold_by_modctl(struct modctl *mp, int f) 30667c478bd9Sstevel@tonic-gate { 30677c478bd9Sstevel@tonic-gate ASSERT((f & (MOD_WAIT_ONCE | MOD_WAIT_FOREVER)) && 30687c478bd9Sstevel@tonic-gate ((f & (MOD_WAIT_ONCE | MOD_WAIT_FOREVER)) != 30697c478bd9Sstevel@tonic-gate (MOD_WAIT_ONCE | MOD_WAIT_FOREVER))); 30707c478bd9Sstevel@tonic-gate ASSERT((f & (MOD_LOCK_HELD | MOD_LOCK_NOT_HELD)) && 30717c478bd9Sstevel@tonic-gate ((f & (MOD_LOCK_HELD | MOD_LOCK_NOT_HELD)) != 30727c478bd9Sstevel@tonic-gate (MOD_LOCK_HELD | MOD_LOCK_NOT_HELD))); 30737c478bd9Sstevel@tonic-gate ASSERT((f & MOD_LOCK_NOT_HELD) || MUTEX_HELD(&mod_lock)); 30747c478bd9Sstevel@tonic-gate 30757c478bd9Sstevel@tonic-gate if (f & MOD_LOCK_NOT_HELD) 30767c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 30777c478bd9Sstevel@tonic-gate 30787c478bd9Sstevel@tonic-gate while (mp->mod_busy) { 30797c478bd9Sstevel@tonic-gate mp->mod_want = 1; 30807c478bd9Sstevel@tonic-gate cv_wait(&mod_cv, &mod_lock); 30817c478bd9Sstevel@tonic-gate /* 30827c478bd9Sstevel@tonic-gate * Module may be unloaded by daemon. 30837c478bd9Sstevel@tonic-gate * Nevertheless, modctl structure is still in linked list 30847c478bd9Sstevel@tonic-gate * (i.e., off &modules), not freed! 30857c478bd9Sstevel@tonic-gate * Caller is not supposed to assume "mp" is valid, but there 30867c478bd9Sstevel@tonic-gate * is no reasonable way to detect this but using 30877c478bd9Sstevel@tonic-gate * mp->mod_modinfo->mp == NULL check (follow the back pointer) 30887c478bd9Sstevel@tonic-gate * (or similar check depending on calling context) 30897c478bd9Sstevel@tonic-gate * DON'T free modctl structure, it will be very very 30907c478bd9Sstevel@tonic-gate * problematic. 30917c478bd9Sstevel@tonic-gate */ 30927c478bd9Sstevel@tonic-gate if (f & MOD_WAIT_ONCE) { 30937c478bd9Sstevel@tonic-gate if (f & MOD_LOCK_NOT_HELD) 30947c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 30957c478bd9Sstevel@tonic-gate return (1); /* caller decides how to retry */ 30967c478bd9Sstevel@tonic-gate } 30977c478bd9Sstevel@tonic-gate } 30987c478bd9Sstevel@tonic-gate 30997c478bd9Sstevel@tonic-gate mp->mod_busy = 1; 31007c478bd9Sstevel@tonic-gate mp->mod_inprogress_thread = 31017c478bd9Sstevel@tonic-gate (curthread == NULL ? (kthread_id_t)-1 : curthread); 31027c478bd9Sstevel@tonic-gate 31037c478bd9Sstevel@tonic-gate if (f & MOD_LOCK_NOT_HELD) 31047c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 31057c478bd9Sstevel@tonic-gate return (0); 31067c478bd9Sstevel@tonic-gate } 31077c478bd9Sstevel@tonic-gate 31087c478bd9Sstevel@tonic-gate static struct modctl * 31097c478bd9Sstevel@tonic-gate mod_hold_by_name_common(struct modctl *dep, char *filename) 31107c478bd9Sstevel@tonic-gate { 31117c478bd9Sstevel@tonic-gate char *modname; 31127c478bd9Sstevel@tonic-gate struct modctl *mp; 31137c478bd9Sstevel@tonic-gate char *curname, *newname; 31147c478bd9Sstevel@tonic-gate int found = 0; 31157c478bd9Sstevel@tonic-gate 31167c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 31177c478bd9Sstevel@tonic-gate 31187c478bd9Sstevel@tonic-gate if ((modname = strrchr(filename, '/')) == NULL) 31197c478bd9Sstevel@tonic-gate modname = filename; 31207c478bd9Sstevel@tonic-gate else 31217c478bd9Sstevel@tonic-gate modname++; 31227c478bd9Sstevel@tonic-gate 31237c478bd9Sstevel@tonic-gate mp = &modules; 31247c478bd9Sstevel@tonic-gate do { 31257c478bd9Sstevel@tonic-gate if (strcmp(modname, mp->mod_modname) == 0) { 31267c478bd9Sstevel@tonic-gate found = 1; 31277c478bd9Sstevel@tonic-gate break; 31287c478bd9Sstevel@tonic-gate } 31297c478bd9Sstevel@tonic-gate } while ((mp = mp->mod_next) != &modules); 31307c478bd9Sstevel@tonic-gate 31317c478bd9Sstevel@tonic-gate if (found == 0) { 31327c478bd9Sstevel@tonic-gate mp = allocate_modp(filename, modname); 31337c478bd9Sstevel@tonic-gate modadd(mp); 31347c478bd9Sstevel@tonic-gate } 31357c478bd9Sstevel@tonic-gate 31367c478bd9Sstevel@tonic-gate /* 31377c478bd9Sstevel@tonic-gate * if dep is not NULL, set the mp in mod_requisite_loading for 31387c478bd9Sstevel@tonic-gate * the module circular dependency check. This field is used in 31397c478bd9Sstevel@tonic-gate * mod_circdep(), but it's cleard in mod_hold_loaded_mod(). 31407c478bd9Sstevel@tonic-gate */ 31417c478bd9Sstevel@tonic-gate if (dep != NULL) { 31427c478bd9Sstevel@tonic-gate ASSERT(dep->mod_busy && dep->mod_requisite_loading == NULL); 31437c478bd9Sstevel@tonic-gate dep->mod_requisite_loading = mp; 31447c478bd9Sstevel@tonic-gate } 31457c478bd9Sstevel@tonic-gate 31467c478bd9Sstevel@tonic-gate /* 31477c478bd9Sstevel@tonic-gate * If the module was held, then it must be us who has it held. 31487c478bd9Sstevel@tonic-gate */ 31497c478bd9Sstevel@tonic-gate if (mod_circdep(mp)) 31507c478bd9Sstevel@tonic-gate mp = NULL; 31517c478bd9Sstevel@tonic-gate else { 31527c478bd9Sstevel@tonic-gate (void) mod_hold_by_modctl(mp, MOD_WAIT_FOREVER | MOD_LOCK_HELD); 31537c478bd9Sstevel@tonic-gate 31547c478bd9Sstevel@tonic-gate /* 31557c478bd9Sstevel@tonic-gate * If the name hadn't been set or has changed, allocate 31567c478bd9Sstevel@tonic-gate * space and set it. Free space used by previous name. 31577c478bd9Sstevel@tonic-gate * 31587c478bd9Sstevel@tonic-gate * Do not change the name of primary modules, for primary 31597c478bd9Sstevel@tonic-gate * modules the mod_filename was allocated in standalone mode: 31607c478bd9Sstevel@tonic-gate * it is illegal to kobj_alloc in standalone mode and kobj_free 31617c478bd9Sstevel@tonic-gate * in non-standalone mode. 31627c478bd9Sstevel@tonic-gate */ 31637c478bd9Sstevel@tonic-gate curname = mp->mod_filename; 31647c478bd9Sstevel@tonic-gate if (curname == NULL || 31657c478bd9Sstevel@tonic-gate ((mp->mod_prim == 0) && 31667c478bd9Sstevel@tonic-gate (curname != filename) && 31677c478bd9Sstevel@tonic-gate (modname != filename) && 31687c478bd9Sstevel@tonic-gate (strcmp(curname, filename) != 0))) { 31697c478bd9Sstevel@tonic-gate newname = kobj_zalloc(strlen(filename) + 1, KM_SLEEP); 31707c478bd9Sstevel@tonic-gate (void) strcpy(newname, filename); 31717c478bd9Sstevel@tonic-gate mp->mod_filename = newname; 31727c478bd9Sstevel@tonic-gate if (curname != NULL) 31737c478bd9Sstevel@tonic-gate kobj_free(curname, strlen(curname) + 1); 31747c478bd9Sstevel@tonic-gate } 31757c478bd9Sstevel@tonic-gate } 31767c478bd9Sstevel@tonic-gate 31777c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 31787c478bd9Sstevel@tonic-gate if (mp && moddebug & MODDEBUG_LOADMSG2) 31797c478bd9Sstevel@tonic-gate printf("Holding %s\n", mp->mod_filename); 31807c478bd9Sstevel@tonic-gate if (mp == NULL && moddebug & MODDEBUG_LOADMSG2) 31817c478bd9Sstevel@tonic-gate printf("circular dependency loading %s\n", filename); 31827c478bd9Sstevel@tonic-gate return (mp); 31837c478bd9Sstevel@tonic-gate } 31847c478bd9Sstevel@tonic-gate 31857c478bd9Sstevel@tonic-gate static struct modctl * 31867c478bd9Sstevel@tonic-gate mod_hold_by_name_requisite(struct modctl *dep, char *filename) 31877c478bd9Sstevel@tonic-gate { 31887c478bd9Sstevel@tonic-gate return (mod_hold_by_name_common(dep, filename)); 31897c478bd9Sstevel@tonic-gate } 31907c478bd9Sstevel@tonic-gate 31917c478bd9Sstevel@tonic-gate struct modctl * 31927c478bd9Sstevel@tonic-gate mod_hold_by_name(char *filename) 31937c478bd9Sstevel@tonic-gate { 31947c478bd9Sstevel@tonic-gate return (mod_hold_by_name_common(NULL, filename)); 31957c478bd9Sstevel@tonic-gate } 31967c478bd9Sstevel@tonic-gate 31977c478bd9Sstevel@tonic-gate static struct modctl * 31987c478bd9Sstevel@tonic-gate mod_hold_by_id(modid_t modid) 31997c478bd9Sstevel@tonic-gate { 32007c478bd9Sstevel@tonic-gate struct modctl *mp; 32017c478bd9Sstevel@tonic-gate int found = 0; 32027c478bd9Sstevel@tonic-gate 32037c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 32047c478bd9Sstevel@tonic-gate mp = &modules; 32057c478bd9Sstevel@tonic-gate do { 32067c478bd9Sstevel@tonic-gate if (mp->mod_id == modid) { 32077c478bd9Sstevel@tonic-gate found = 1; 32087c478bd9Sstevel@tonic-gate break; 32097c478bd9Sstevel@tonic-gate } 32107c478bd9Sstevel@tonic-gate } while ((mp = mp->mod_next) != &modules); 32117c478bd9Sstevel@tonic-gate 32127c478bd9Sstevel@tonic-gate if ((found == 0) || mod_circdep(mp)) 32137c478bd9Sstevel@tonic-gate mp = NULL; 32147c478bd9Sstevel@tonic-gate else 32157c478bd9Sstevel@tonic-gate (void) mod_hold_by_modctl(mp, MOD_WAIT_FOREVER | MOD_LOCK_HELD); 32167c478bd9Sstevel@tonic-gate 32177c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 32187c478bd9Sstevel@tonic-gate return (mp); 32197c478bd9Sstevel@tonic-gate } 32207c478bd9Sstevel@tonic-gate 32217c478bd9Sstevel@tonic-gate static struct modctl * 32227c478bd9Sstevel@tonic-gate mod_hold_next_by_id(modid_t modid) 32237c478bd9Sstevel@tonic-gate { 32247c478bd9Sstevel@tonic-gate struct modctl *mp; 32257c478bd9Sstevel@tonic-gate int found = 0; 32267c478bd9Sstevel@tonic-gate 32277c478bd9Sstevel@tonic-gate if (modid < -1) 32287c478bd9Sstevel@tonic-gate return (NULL); 32297c478bd9Sstevel@tonic-gate 32307c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 32317c478bd9Sstevel@tonic-gate 32327c478bd9Sstevel@tonic-gate mp = &modules; 32337c478bd9Sstevel@tonic-gate do { 32347c478bd9Sstevel@tonic-gate if (mp->mod_id > modid) { 32357c478bd9Sstevel@tonic-gate found = 1; 32367c478bd9Sstevel@tonic-gate break; 32377c478bd9Sstevel@tonic-gate } 32387c478bd9Sstevel@tonic-gate } while ((mp = mp->mod_next) != &modules); 32397c478bd9Sstevel@tonic-gate 32407c478bd9Sstevel@tonic-gate if ((found == 0) || mod_circdep(mp)) 32417c478bd9Sstevel@tonic-gate mp = NULL; 32427c478bd9Sstevel@tonic-gate else 32437c478bd9Sstevel@tonic-gate (void) mod_hold_by_modctl(mp, MOD_WAIT_FOREVER | MOD_LOCK_HELD); 32447c478bd9Sstevel@tonic-gate 32457c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 32467c478bd9Sstevel@tonic-gate return (mp); 32477c478bd9Sstevel@tonic-gate } 32487c478bd9Sstevel@tonic-gate 32497c478bd9Sstevel@tonic-gate static void 32507c478bd9Sstevel@tonic-gate mod_release(struct modctl *mp) 32517c478bd9Sstevel@tonic-gate { 32527c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&mod_lock)); 32537c478bd9Sstevel@tonic-gate ASSERT(mp->mod_busy); 32547c478bd9Sstevel@tonic-gate 32557c478bd9Sstevel@tonic-gate mp->mod_busy = 0; 32567c478bd9Sstevel@tonic-gate mp->mod_inprogress_thread = NULL; 32577c478bd9Sstevel@tonic-gate if (mp->mod_want) { 32587c478bd9Sstevel@tonic-gate mp->mod_want = 0; 32597c478bd9Sstevel@tonic-gate cv_broadcast(&mod_cv); 32607c478bd9Sstevel@tonic-gate } 32617c478bd9Sstevel@tonic-gate } 32627c478bd9Sstevel@tonic-gate 32637c478bd9Sstevel@tonic-gate void 32647c478bd9Sstevel@tonic-gate mod_release_mod(struct modctl *mp) 32657c478bd9Sstevel@tonic-gate { 32667c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_LOADMSG2) 32677c478bd9Sstevel@tonic-gate printf("Releasing %s\n", mp->mod_filename); 32687c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 32697c478bd9Sstevel@tonic-gate mod_release(mp); 32707c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 32717c478bd9Sstevel@tonic-gate } 32727c478bd9Sstevel@tonic-gate 32737c478bd9Sstevel@tonic-gate modid_t 32747c478bd9Sstevel@tonic-gate mod_name_to_modid(char *filename) 32757c478bd9Sstevel@tonic-gate { 32767c478bd9Sstevel@tonic-gate char *modname; 32777c478bd9Sstevel@tonic-gate struct modctl *mp; 32787c478bd9Sstevel@tonic-gate 32797c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 32807c478bd9Sstevel@tonic-gate 32817c478bd9Sstevel@tonic-gate if ((modname = strrchr(filename, '/')) == NULL) 32827c478bd9Sstevel@tonic-gate modname = filename; 32837c478bd9Sstevel@tonic-gate else 32847c478bd9Sstevel@tonic-gate modname++; 32857c478bd9Sstevel@tonic-gate 32867c478bd9Sstevel@tonic-gate mp = &modules; 32877c478bd9Sstevel@tonic-gate do { 32887c478bd9Sstevel@tonic-gate if (strcmp(modname, mp->mod_modname) == 0) { 32897c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 32907c478bd9Sstevel@tonic-gate return (mp->mod_id); 32917c478bd9Sstevel@tonic-gate } 32927c478bd9Sstevel@tonic-gate } while ((mp = mp->mod_next) != &modules); 32937c478bd9Sstevel@tonic-gate 32947c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 32957c478bd9Sstevel@tonic-gate return (-1); 32967c478bd9Sstevel@tonic-gate } 32977c478bd9Sstevel@tonic-gate 32987c478bd9Sstevel@tonic-gate 32997c478bd9Sstevel@tonic-gate int 33007c478bd9Sstevel@tonic-gate mod_remove_by_name(char *name) 33017c478bd9Sstevel@tonic-gate { 33027c478bd9Sstevel@tonic-gate struct modctl *mp; 33037c478bd9Sstevel@tonic-gate int retval; 33047c478bd9Sstevel@tonic-gate 33057c478bd9Sstevel@tonic-gate mp = mod_hold_by_name(name); 33067c478bd9Sstevel@tonic-gate 33077c478bd9Sstevel@tonic-gate if (mp == NULL) 33087c478bd9Sstevel@tonic-gate return (EINVAL); 33097c478bd9Sstevel@tonic-gate 33107c478bd9Sstevel@tonic-gate if (mp->mod_loadflags & MOD_NOAUTOUNLOAD) { 33117c478bd9Sstevel@tonic-gate /* 33127c478bd9Sstevel@tonic-gate * Do not unload forceloaded modules 33137c478bd9Sstevel@tonic-gate */ 33147c478bd9Sstevel@tonic-gate mod_release_mod(mp); 33157c478bd9Sstevel@tonic-gate return (0); 33167c478bd9Sstevel@tonic-gate } 33177c478bd9Sstevel@tonic-gate 3318*0b38a8bdSahl if ((retval = moduninstall(mp)) == 0) { 33197c478bd9Sstevel@tonic-gate mod_unload(mp); 3320*0b38a8bdSahl CPU_STATS_ADDQ(CPU, sys, modunload, 1); 3321*0b38a8bdSahl } else if (retval == EALREADY) 33227c478bd9Sstevel@tonic-gate retval = 0; /* already unloaded, not an error */ 33237c478bd9Sstevel@tonic-gate mod_release_mod(mp); 33247c478bd9Sstevel@tonic-gate return (retval); 33257c478bd9Sstevel@tonic-gate } 33267c478bd9Sstevel@tonic-gate 33277c478bd9Sstevel@tonic-gate /* 33287c478bd9Sstevel@tonic-gate * Record that module "dep" is dependent on module "on_mod." 33297c478bd9Sstevel@tonic-gate */ 33307c478bd9Sstevel@tonic-gate static void 33317c478bd9Sstevel@tonic-gate mod_make_requisite(struct modctl *dependent, struct modctl *on_mod) 33327c478bd9Sstevel@tonic-gate { 33337c478bd9Sstevel@tonic-gate struct modctl_list **pmlnp; /* previous next pointer */ 33347c478bd9Sstevel@tonic-gate struct modctl_list *mlp; 33357c478bd9Sstevel@tonic-gate struct modctl_list *new; 33367c478bd9Sstevel@tonic-gate 33377c478bd9Sstevel@tonic-gate ASSERT(dependent->mod_busy && on_mod->mod_busy); 33387c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); 33397c478bd9Sstevel@tonic-gate 33407c478bd9Sstevel@tonic-gate /* 33417c478bd9Sstevel@tonic-gate * Search dependent's requisite list to see if on_mod is recorded. 33427c478bd9Sstevel@tonic-gate * List is ordered by id. 33437c478bd9Sstevel@tonic-gate */ 33447c478bd9Sstevel@tonic-gate for (pmlnp = &dependent->mod_requisites, mlp = *pmlnp; 33457c478bd9Sstevel@tonic-gate mlp; pmlnp = &mlp->modl_next, mlp = *pmlnp) 33467c478bd9Sstevel@tonic-gate if (mlp->modl_modp->mod_id >= on_mod->mod_id) 33477c478bd9Sstevel@tonic-gate break; 33487c478bd9Sstevel@tonic-gate 33497c478bd9Sstevel@tonic-gate /* Create and insert if not already recorded */ 33507c478bd9Sstevel@tonic-gate if ((mlp == NULL) || (mlp->modl_modp->mod_id != on_mod->mod_id)) { 33517c478bd9Sstevel@tonic-gate new = kobj_zalloc(sizeof (*new), KM_SLEEP); 33527c478bd9Sstevel@tonic-gate new->modl_modp = on_mod; 33537c478bd9Sstevel@tonic-gate new->modl_next = mlp; 33547c478bd9Sstevel@tonic-gate *pmlnp = new; 33557c478bd9Sstevel@tonic-gate 33567c478bd9Sstevel@tonic-gate /* 33577c478bd9Sstevel@tonic-gate * Increment the mod_ref count in our new requisite module. 33587c478bd9Sstevel@tonic-gate * This is what keeps a module that has other modules 33597c478bd9Sstevel@tonic-gate * which are dependent on it from being uninstalled and 33607c478bd9Sstevel@tonic-gate * unloaded. "on_mod"'s mod_ref count decremented in 33617c478bd9Sstevel@tonic-gate * mod_release_requisites when the "dependent" module 33627c478bd9Sstevel@tonic-gate * unload is complete. "on_mod" must be loaded, but may not 33637c478bd9Sstevel@tonic-gate * yet be installed. 33647c478bd9Sstevel@tonic-gate */ 33657c478bd9Sstevel@tonic-gate on_mod->mod_ref++; 33667c478bd9Sstevel@tonic-gate ASSERT(on_mod->mod_ref && on_mod->mod_loaded); 33677c478bd9Sstevel@tonic-gate } 33687c478bd9Sstevel@tonic-gate 33697c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 33707c478bd9Sstevel@tonic-gate } 33717c478bd9Sstevel@tonic-gate 33727c478bd9Sstevel@tonic-gate /* 33737c478bd9Sstevel@tonic-gate * release the hold associated with mod_make_requisite mod_ref++ 33747c478bd9Sstevel@tonic-gate * as part of unload. 33757c478bd9Sstevel@tonic-gate */ 33767c478bd9Sstevel@tonic-gate void 33777c478bd9Sstevel@tonic-gate mod_release_requisites(struct modctl *modp) 33787c478bd9Sstevel@tonic-gate { 33797c478bd9Sstevel@tonic-gate struct modctl_list *modl; 33807c478bd9Sstevel@tonic-gate struct modctl_list *next; 33817c478bd9Sstevel@tonic-gate struct modctl *req; 33827c478bd9Sstevel@tonic-gate struct modctl_list *start = NULL, *mod_garbage; 33837c478bd9Sstevel@tonic-gate 33847c478bd9Sstevel@tonic-gate ASSERT(modp->mod_busy); 33857c478bd9Sstevel@tonic-gate ASSERT(!MUTEX_HELD(&mod_lock)); 33867c478bd9Sstevel@tonic-gate 33877c478bd9Sstevel@tonic-gate mutex_enter(&mod_lock); /* needed for manipulation of req */ 33887c478bd9Sstevel@tonic-gate for (modl = modp->mod_requisites; modl; modl = next) { 33897c478bd9Sstevel@tonic-gate next = modl->modl_next; 33907c478bd9Sstevel@tonic-gate req = modl->modl_modp; 33917c478bd9Sstevel@tonic-gate ASSERT(req->mod_ref >= 1 && req->mod_loaded); 33927c478bd9Sstevel@tonic-gate req->mod_ref--; 33937c478bd9Sstevel@tonic-gate 33947c478bd9Sstevel@tonic-gate /* 33957c478bd9Sstevel@tonic-gate * Check if the module has to be unloaded or not. 33967c478bd9Sstevel@tonic-gate */ 33977c478bd9Sstevel@tonic-gate if (req->mod_ref == 0 && req->mod_delay_unload) { 33987c478bd9Sstevel@tonic-gate struct modctl_list *new; 33997c478bd9Sstevel@tonic-gate /* 34007c478bd9Sstevel@tonic-gate * Allocate the modclt_list holding the garbage 34017c478bd9Sstevel@tonic-gate * module which should be unloaded later. 34027c478bd9Sstevel@tonic-gate */ 34037c478bd9Sstevel@tonic-gate new = kobj_zalloc(sizeof (struct modctl_list), 34047c478bd9Sstevel@tonic-gate KM_SLEEP); 34057c478bd9Sstevel@tonic-gate new->modl_modp = req; 34067c478bd9Sstevel@tonic-gate 34077c478bd9Sstevel@tonic-gate if (start == NULL) 34087c478bd9Sstevel@tonic-gate mod_garbage = start = new; 34097c478bd9Sstevel@tonic-gate else { 34107c478bd9Sstevel@tonic-gate mod_garbage->modl_next = new; 34117c478bd9Sstevel@tonic-gate mod_garbage = new; 34127c478bd9Sstevel@tonic-gate } 34137c478bd9Sstevel@tonic-gate } 34147c478bd9Sstevel@tonic-gate 34157c478bd9Sstevel@tonic-gate /* free the list as we go */ 34167c478bd9Sstevel@tonic-gate kobj_free(modl, sizeof (*modl)); 34177c478bd9Sstevel@tonic-gate } 34187c478bd9Sstevel@tonic-gate modp->mod_requisites = NULL; 34197c478bd9Sstevel@tonic-gate mutex_exit(&mod_lock); 34207c478bd9Sstevel@tonic-gate 34217c478bd9Sstevel@tonic-gate /* 34227c478bd9Sstevel@tonic-gate * Unload the garbage modules. 34237c478bd9Sstevel@tonic-gate */ 34247c478bd9Sstevel@tonic-gate for (mod_garbage = start; mod_garbage != NULL; /* nothing */) { 34257c478bd9Sstevel@tonic-gate struct modctl_list *old = mod_garbage; 34267c478bd9Sstevel@tonic-gate struct modctl *mp = mod_garbage->modl_modp; 34277c478bd9Sstevel@tonic-gate ASSERT(mp != NULL); 34287c478bd9Sstevel@tonic-gate 34297c478bd9Sstevel@tonic-gate /* 34307c478bd9Sstevel@tonic-gate * Hold this module until it's unloaded completely. 34317c478bd9Sstevel@tonic-gate */ 34327c478bd9Sstevel@tonic-gate (void) mod_hold_by_modctl(mp, 34337c478bd9Sstevel@tonic-gate MOD_WAIT_FOREVER | MOD_LOCK_NOT_HELD); 34347c478bd9Sstevel@tonic-gate /* 34357c478bd9Sstevel@tonic-gate * Check if the module is not unloaded yet and nobody requires 34367c478bd9Sstevel@tonic-gate * the module. If it's unloaded already or somebody still 34377c478bd9Sstevel@tonic-gate * requires the module, don't unload it now. 34387c478bd9Sstevel@tonic-gate */ 34397c478bd9Sstevel@tonic-gate if (mp->mod_loaded && mp->mod_ref == 0) 34407c478bd9Sstevel@tonic-gate mod_unload(mp); 34417c478bd9Sstevel@tonic-gate ASSERT((mp->mod_loaded == 0 && mp->mod_delay_unload == 0) || 34427c478bd9Sstevel@tonic-gate (mp->mod_ref > 0)); 34437c478bd9Sstevel@tonic-gate mod_release_mod(mp); 34447c478bd9Sstevel@tonic-gate 34457c478bd9Sstevel@tonic-gate mod_garbage = mod_garbage->modl_next; 34467c478bd9Sstevel@tonic-gate kobj_free(old, sizeof (struct modctl_list)); 34477c478bd9Sstevel@tonic-gate } 34487c478bd9Sstevel@tonic-gate } 34497c478bd9Sstevel@tonic-gate 34507c478bd9Sstevel@tonic-gate /* 34517c478bd9Sstevel@tonic-gate * Process dependency of the module represented by "dep" on the 34527c478bd9Sstevel@tonic-gate * module named by "on." 34537c478bd9Sstevel@tonic-gate * 34547c478bd9Sstevel@tonic-gate * Called from kobj_do_dependents() to load a module "on" on which 34557c478bd9Sstevel@tonic-gate * "dep" depends. 34567c478bd9Sstevel@tonic-gate */ 34577c478bd9Sstevel@tonic-gate struct modctl * 34587c478bd9Sstevel@tonic-gate mod_load_requisite(struct modctl *dep, char *on) 34597c478bd9Sstevel@tonic-gate { 34607c478bd9Sstevel@tonic-gate struct modctl *on_mod; 34617c478bd9Sstevel@tonic-gate int retval; 34627c478bd9Sstevel@tonic-gate 34637c478bd9Sstevel@tonic-gate if ((on_mod = mod_hold_loaded_mod(dep, on, &retval)) != NULL) { 34647c478bd9Sstevel@tonic-gate mod_make_requisite(dep, on_mod); 34657c478bd9Sstevel@tonic-gate } else if (moddebug & MODDEBUG_ERRMSG) { 34667c478bd9Sstevel@tonic-gate printf("error processing %s on which module %s depends\n", 34677c478bd9Sstevel@tonic-gate on, dep->mod_modname); 34687c478bd9Sstevel@tonic-gate } 34697c478bd9Sstevel@tonic-gate return (on_mod); 34707c478bd9Sstevel@tonic-gate } 34717c478bd9Sstevel@tonic-gate 34727c478bd9Sstevel@tonic-gate static int 34737c478bd9Sstevel@tonic-gate mod_install_requisites(struct modctl *modp) 34747c478bd9Sstevel@tonic-gate { 34757c478bd9Sstevel@tonic-gate struct modctl_list *modl; 34767c478bd9Sstevel@tonic-gate struct modctl *req; 34777c478bd9Sstevel@tonic-gate int status = 0; 34787c478bd9Sstevel@tonic-gate 34797c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&mod_lock)); 34807c478bd9Sstevel@tonic-gate ASSERT(modp->mod_busy); 34817c478bd9Sstevel@tonic-gate 34827c478bd9Sstevel@tonic-gate for (modl = modp->mod_requisites; modl; modl = modl->modl_next) { 34837c478bd9Sstevel@tonic-gate req = modl->modl_modp; 34847c478bd9Sstevel@tonic-gate (void) mod_hold_by_modctl(req, 34857c478bd9Sstevel@tonic-gate MOD_WAIT_FOREVER | MOD_LOCK_NOT_HELD); 34867c478bd9Sstevel@tonic-gate status = modinstall(req); 34877c478bd9Sstevel@tonic-gate mod_release_mod(req); 34887c478bd9Sstevel@tonic-gate 34897c478bd9Sstevel@tonic-gate if (status != 0) 34907c478bd9Sstevel@tonic-gate break; 34917c478bd9Sstevel@tonic-gate } 34927c478bd9Sstevel@tonic-gate return (status); 34937c478bd9Sstevel@tonic-gate } 34947c478bd9Sstevel@tonic-gate 34957c478bd9Sstevel@tonic-gate /* 34967c478bd9Sstevel@tonic-gate * returns 1 if this thread is doing autounload, 0 otherwise. 34977c478bd9Sstevel@tonic-gate * see mod_uninstall_all. 34987c478bd9Sstevel@tonic-gate */ 34997c478bd9Sstevel@tonic-gate int 35007c478bd9Sstevel@tonic-gate mod_in_autounload() 35017c478bd9Sstevel@tonic-gate { 35027c478bd9Sstevel@tonic-gate return ((int)(uintptr_t)tsd_get(mod_autounload_key)); 35037c478bd9Sstevel@tonic-gate } 35047c478bd9Sstevel@tonic-gate 35057c478bd9Sstevel@tonic-gate /* 35067c478bd9Sstevel@tonic-gate * gmatch adapted from libc, stripping the wchar stuff 35077c478bd9Sstevel@tonic-gate */ 35087c478bd9Sstevel@tonic-gate #define popchar(p, c) \ 35097c478bd9Sstevel@tonic-gate c = *p++; \ 35107c478bd9Sstevel@tonic-gate if (c == 0) \ 35117c478bd9Sstevel@tonic-gate return (0); 35127c478bd9Sstevel@tonic-gate 35137c478bd9Sstevel@tonic-gate static int 35147c478bd9Sstevel@tonic-gate gmatch(const char *s, const char *p) 35157c478bd9Sstevel@tonic-gate { 35167c478bd9Sstevel@tonic-gate int c, sc; 35177c478bd9Sstevel@tonic-gate int ok, lc, notflag; 35187c478bd9Sstevel@tonic-gate 35197c478bd9Sstevel@tonic-gate sc = *s++; 35207c478bd9Sstevel@tonic-gate c = *p++; 35217c478bd9Sstevel@tonic-gate if (c == 0) 35227c478bd9Sstevel@tonic-gate return (sc == c); /* nothing matches nothing */ 35237c478bd9Sstevel@tonic-gate 35247c478bd9Sstevel@tonic-gate switch (c) { 35257c478bd9Sstevel@tonic-gate case '\\': 35267c478bd9Sstevel@tonic-gate /* skip to quoted character */ 35277c478bd9Sstevel@tonic-gate popchar(p, c) 35287c478bd9Sstevel@tonic-gate /*FALLTHRU*/ 35297c478bd9Sstevel@tonic-gate 35307c478bd9Sstevel@tonic-gate default: 35317c478bd9Sstevel@tonic-gate /* straight comparison */ 35327c478bd9Sstevel@tonic-gate if (c != sc) 35337c478bd9Sstevel@tonic-gate return (0); 35347c478bd9Sstevel@tonic-gate /*FALLTHRU*/ 35357c478bd9Sstevel@tonic-gate 35367c478bd9Sstevel@tonic-gate case '?': 35377c478bd9Sstevel@tonic-gate /* first char matches, move to remainder */ 35387c478bd9Sstevel@tonic-gate return (sc != '\0' ? gmatch(s, p) : 0); 35397c478bd9Sstevel@tonic-gate 35407c478bd9Sstevel@tonic-gate 35417c478bd9Sstevel@tonic-gate case '*': 35427c478bd9Sstevel@tonic-gate while (*p == '*') 35437c478bd9Sstevel@tonic-gate p++; 35447c478bd9Sstevel@tonic-gate 35457c478bd9Sstevel@tonic-gate /* * matches everything */ 35467c478bd9Sstevel@tonic-gate if (*p == 0) 35477c478bd9Sstevel@tonic-gate return (1); 35487c478bd9Sstevel@tonic-gate 35497c478bd9Sstevel@tonic-gate /* undo skip at the beginning & iterate over substrings */ 35507c478bd9Sstevel@tonic-gate --s; 35517c478bd9Sstevel@tonic-gate while (*s) { 35527c478bd9Sstevel@tonic-gate if (gmatch(s, p)) 35537c478bd9Sstevel@tonic-gate return (1); 35547c478bd9Sstevel@tonic-gate s++; 35557c478bd9Sstevel@tonic-gate } 35567c478bd9Sstevel@tonic-gate return (0); 35577c478bd9Sstevel@tonic-gate 35587c478bd9Sstevel@tonic-gate case '[': 35597c478bd9Sstevel@tonic-gate /* match any char within [] */ 35607c478bd9Sstevel@tonic-gate if (sc == 0) 35617c478bd9Sstevel@tonic-gate return (0); 35627c478bd9Sstevel@tonic-gate 35637c478bd9Sstevel@tonic-gate ok = lc = notflag = 0; 35647c478bd9Sstevel@tonic-gate 35657c478bd9Sstevel@tonic-gate if (*p == '!') { 35667c478bd9Sstevel@tonic-gate notflag = 1; 35677c478bd9Sstevel@tonic-gate p++; 35687c478bd9Sstevel@tonic-gate } 35697c478bd9Sstevel@tonic-gate popchar(p, c) 35707c478bd9Sstevel@tonic-gate 35717c478bd9Sstevel@tonic-gate do { 35727c478bd9Sstevel@tonic-gate if (c == '-' && lc && *p != ']') { 35737c478bd9Sstevel@tonic-gate /* test sc against range [c1-c2] */ 35747c478bd9Sstevel@tonic-gate popchar(p, c) 35757c478bd9Sstevel@tonic-gate if (c == '\\') { 35767c478bd9Sstevel@tonic-gate popchar(p, c) 35777c478bd9Sstevel@tonic-gate } 35787c478bd9Sstevel@tonic-gate 35797c478bd9Sstevel@tonic-gate if (notflag) { 35807c478bd9Sstevel@tonic-gate /* return 0 on mismatch */ 35817c478bd9Sstevel@tonic-gate if (lc <= sc && sc <= c) 35827c478bd9Sstevel@tonic-gate return (0); 35837c478bd9Sstevel@tonic-gate ok++; 35847c478bd9Sstevel@tonic-gate } else if (lc <= sc && sc <= c) { 35857c478bd9Sstevel@tonic-gate ok++; 35867c478bd9Sstevel@tonic-gate } 35877c478bd9Sstevel@tonic-gate /* keep going, may get a match next */ 35887c478bd9Sstevel@tonic-gate } else if (c == '\\') { 35897c478bd9Sstevel@tonic-gate /* skip to quoted character */ 35907c478bd9Sstevel@tonic-gate popchar(p, c) 35917c478bd9Sstevel@tonic-gate } 35927c478bd9Sstevel@tonic-gate lc = c; 35937c478bd9Sstevel@tonic-gate if (notflag) { 35947c478bd9Sstevel@tonic-gate if (sc == lc) 35957c478bd9Sstevel@tonic-gate return (0); 35967c478bd9Sstevel@tonic-gate ok++; 35977c478bd9Sstevel@tonic-gate } else if (sc == lc) { 35987c478bd9Sstevel@tonic-gate ok++; 35997c478bd9Sstevel@tonic-gate } 36007c478bd9Sstevel@tonic-gate popchar(p, c) 36017c478bd9Sstevel@tonic-gate } while (c != ']'); 36027c478bd9Sstevel@tonic-gate 36037c478bd9Sstevel@tonic-gate /* recurse on remainder of string */ 36047c478bd9Sstevel@tonic-gate return (ok ? gmatch(s, p) : 0); 36057c478bd9Sstevel@tonic-gate } 36067c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 36077c478bd9Sstevel@tonic-gate } 36087c478bd9Sstevel@tonic-gate 36097c478bd9Sstevel@tonic-gate 36107c478bd9Sstevel@tonic-gate /* 36117c478bd9Sstevel@tonic-gate * Get default perm for device from /etc/minor_perm. Return 0 if match found. 36127c478bd9Sstevel@tonic-gate * 36137c478bd9Sstevel@tonic-gate * Pure wild-carded patterns are handled separately so the ordering of 36147c478bd9Sstevel@tonic-gate * these patterns doesn't matter. We're still dependent on ordering 36157c478bd9Sstevel@tonic-gate * however as the first matching entry is the one returned. 36167c478bd9Sstevel@tonic-gate * Not ideal but all existing examples and usage do imply this 36177c478bd9Sstevel@tonic-gate * ordering implicitly. 36187c478bd9Sstevel@tonic-gate * 36197c478bd9Sstevel@tonic-gate * Drivers using the clone driver are always good for some entertainment. 36207c478bd9Sstevel@tonic-gate * Clone nodes under pseudo have the form clone@0:<driver>. Some minor 36217c478bd9Sstevel@tonic-gate * perm entries have the form clone:<driver>, others use <driver>:* 36227c478bd9Sstevel@tonic-gate * Examples are clone:llc1 vs. llc2:*, for example. 36237c478bd9Sstevel@tonic-gate * 36247c478bd9Sstevel@tonic-gate * Minor perms in the clone:<driver> form are mapped to the drivers's 36257c478bd9Sstevel@tonic-gate * mperm list, not the clone driver, as wildcard entries for clone 36267c478bd9Sstevel@tonic-gate * reference only. In other words, a clone wildcard will match 36277c478bd9Sstevel@tonic-gate * references for clone@0:<driver> but never <driver>@<minor>. 36287c478bd9Sstevel@tonic-gate * 36297c478bd9Sstevel@tonic-gate * Additional minor perms in the standard form are also supported, 36307c478bd9Sstevel@tonic-gate * for mixed usage, ie a node with an entry clone:<driver> could 36317c478bd9Sstevel@tonic-gate * provide further entries <driver>:<minor>. 36327c478bd9Sstevel@tonic-gate * 36337c478bd9Sstevel@tonic-gate * Finally, some uses of clone use an alias as the minor name rather 36347c478bd9Sstevel@tonic-gate * than the driver name, with the alias as the minor perm entry. 36357c478bd9Sstevel@tonic-gate * This case is handled by attaching the driver to bring its 36367c478bd9Sstevel@tonic-gate * minor list into existence, then discover the alias via DDI_ALIAS. 36377c478bd9Sstevel@tonic-gate * The clone device's minor perm list can then be searched for 36387c478bd9Sstevel@tonic-gate * that alias. 36397c478bd9Sstevel@tonic-gate */ 36407c478bd9Sstevel@tonic-gate 36417c478bd9Sstevel@tonic-gate static int 36427c478bd9Sstevel@tonic-gate dev_alias_minorperm(dev_info_t *dip, char *minor_name, mperm_t *rmp) 36437c478bd9Sstevel@tonic-gate { 36447c478bd9Sstevel@tonic-gate major_t major; 36457c478bd9Sstevel@tonic-gate struct devnames *dnp; 36467c478bd9Sstevel@tonic-gate mperm_t *mp; 36477c478bd9Sstevel@tonic-gate char *alias = NULL; 36487c478bd9Sstevel@tonic-gate dev_info_t *cdevi; 36497c478bd9Sstevel@tonic-gate struct ddi_minor_data *dmd; 36507c478bd9Sstevel@tonic-gate 36517c478bd9Sstevel@tonic-gate major = ddi_name_to_major(minor_name); 36527c478bd9Sstevel@tonic-gate 36537c478bd9Sstevel@tonic-gate ASSERT(dip == clone_dip); 36547c478bd9Sstevel@tonic-gate ASSERT(major != (major_t)-1); 36557c478bd9Sstevel@tonic-gate 36567c478bd9Sstevel@tonic-gate /* 36577c478bd9Sstevel@tonic-gate * Attach the driver named by the minor node, then 36587c478bd9Sstevel@tonic-gate * search its first instance's minor list for an 36597c478bd9Sstevel@tonic-gate * alias node. 36607c478bd9Sstevel@tonic-gate */ 36617c478bd9Sstevel@tonic-gate if (ddi_hold_installed_driver(major) == NULL) 36627c478bd9Sstevel@tonic-gate return (1); 36637c478bd9Sstevel@tonic-gate 36647c478bd9Sstevel@tonic-gate dnp = &devnamesp[major]; 36657c478bd9Sstevel@tonic-gate LOCK_DEV_OPS(&dnp->dn_lock); 36667c478bd9Sstevel@tonic-gate 36677c478bd9Sstevel@tonic-gate if ((cdevi = dnp->dn_head) != NULL) { 36687c478bd9Sstevel@tonic-gate mutex_enter(&DEVI(cdevi)->devi_lock); 36697c478bd9Sstevel@tonic-gate for (dmd = DEVI(cdevi)->devi_minor; dmd; dmd = dmd->next) { 36707c478bd9Sstevel@tonic-gate if (dmd->type == DDM_ALIAS) { 36717c478bd9Sstevel@tonic-gate alias = i_ddi_strdup(dmd->ddm_name, KM_SLEEP); 36727c478bd9Sstevel@tonic-gate break; 36737c478bd9Sstevel@tonic-gate } 36747c478bd9Sstevel@tonic-gate } 36757c478bd9Sstevel@tonic-gate mutex_exit(&DEVI(cdevi)->devi_lock); 36767c478bd9Sstevel@tonic-gate } 36777c478bd9Sstevel@tonic-gate 36787c478bd9Sstevel@tonic-gate UNLOCK_DEV_OPS(&dnp->dn_lock); 36797c478bd9Sstevel@tonic-gate ddi_rele_driver(major); 36807c478bd9Sstevel@tonic-gate 36817c478bd9Sstevel@tonic-gate if (alias == NULL) { 36827c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MINORPERM) 36837c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, "dev_minorperm: " 36847c478bd9Sstevel@tonic-gate "no alias for %s\n", minor_name); 36857c478bd9Sstevel@tonic-gate return (1); 36867c478bd9Sstevel@tonic-gate } 36877c478bd9Sstevel@tonic-gate 36887c478bd9Sstevel@tonic-gate major = ddi_driver_major(clone_dip); 36897c478bd9Sstevel@tonic-gate dnp = &devnamesp[major]; 36907c478bd9Sstevel@tonic-gate LOCK_DEV_OPS(&dnp->dn_lock); 36917c478bd9Sstevel@tonic-gate 36927c478bd9Sstevel@tonic-gate /* 36937c478bd9Sstevel@tonic-gate * Go through the clone driver's mperm list looking 36947c478bd9Sstevel@tonic-gate * for a match for the specified alias. 36957c478bd9Sstevel@tonic-gate */ 36967c478bd9Sstevel@tonic-gate for (mp = dnp->dn_mperm; mp; mp = mp->mp_next) { 36977c478bd9Sstevel@tonic-gate if (strcmp(alias, mp->mp_minorname) == 0) { 36987c478bd9Sstevel@tonic-gate break; 36997c478bd9Sstevel@tonic-gate } 37007c478bd9Sstevel@tonic-gate } 37017c478bd9Sstevel@tonic-gate 37027c478bd9Sstevel@tonic-gate if (mp) { 37037c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MP_MATCH) { 37047c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, 37057c478bd9Sstevel@tonic-gate "minor perm defaults: %s %s 0%o %d %d (aliased)\n", 37067c478bd9Sstevel@tonic-gate minor_name, alias, mp->mp_mode, 37077c478bd9Sstevel@tonic-gate mp->mp_uid, mp->mp_gid); 37087c478bd9Sstevel@tonic-gate } 37097c478bd9Sstevel@tonic-gate rmp->mp_uid = mp->mp_uid; 37107c478bd9Sstevel@tonic-gate rmp->mp_gid = mp->mp_gid; 37117c478bd9Sstevel@tonic-gate rmp->mp_mode = mp->mp_mode; 37127c478bd9Sstevel@tonic-gate } 37137c478bd9Sstevel@tonic-gate UNLOCK_DEV_OPS(&dnp->dn_lock); 37147c478bd9Sstevel@tonic-gate 37157c478bd9Sstevel@tonic-gate kmem_free(alias, strlen(alias)+1); 37167c478bd9Sstevel@tonic-gate 37177c478bd9Sstevel@tonic-gate return (mp == NULL); 37187c478bd9Sstevel@tonic-gate } 37197c478bd9Sstevel@tonic-gate 37207c478bd9Sstevel@tonic-gate int 37217c478bd9Sstevel@tonic-gate dev_minorperm(dev_info_t *dip, char *name, mperm_t *rmp) 37227c478bd9Sstevel@tonic-gate { 37237c478bd9Sstevel@tonic-gate major_t major; 37247c478bd9Sstevel@tonic-gate char *minor_name; 37257c478bd9Sstevel@tonic-gate struct devnames *dnp; 37267c478bd9Sstevel@tonic-gate mperm_t *mp; 37277c478bd9Sstevel@tonic-gate int is_clone = 0; 37287c478bd9Sstevel@tonic-gate 37297c478bd9Sstevel@tonic-gate if (!minorperm_loaded) { 37307c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MINORPERM) 37317c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, 37327c478bd9Sstevel@tonic-gate "%s: minor perm not yet loaded\n", name); 37337c478bd9Sstevel@tonic-gate return (1); 37347c478bd9Sstevel@tonic-gate } 37357c478bd9Sstevel@tonic-gate 37367c478bd9Sstevel@tonic-gate minor_name = strchr(name, ':'); 37377c478bd9Sstevel@tonic-gate if (minor_name == NULL) 37387c478bd9Sstevel@tonic-gate return (1); 37397c478bd9Sstevel@tonic-gate minor_name++; 37407c478bd9Sstevel@tonic-gate 37417c478bd9Sstevel@tonic-gate /* 37427c478bd9Sstevel@tonic-gate * If it's the clone driver, search the driver as named 37437c478bd9Sstevel@tonic-gate * by the minor. All clone minor perm entries other than 37447c478bd9Sstevel@tonic-gate * alias nodes are actually installed on the real driver's list. 37457c478bd9Sstevel@tonic-gate */ 37467c478bd9Sstevel@tonic-gate if (dip == clone_dip) { 37477c478bd9Sstevel@tonic-gate major = ddi_name_to_major(minor_name); 37487c478bd9Sstevel@tonic-gate if (major == (major_t)-1) { 37497c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MINORPERM) 37507c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, "dev_minorperm: " 37517c478bd9Sstevel@tonic-gate "%s: no such driver\n", minor_name); 37527c478bd9Sstevel@tonic-gate return (1); 37537c478bd9Sstevel@tonic-gate } 37547c478bd9Sstevel@tonic-gate is_clone = 1; 37557c478bd9Sstevel@tonic-gate } else { 37567c478bd9Sstevel@tonic-gate major = ddi_driver_major(dip); 37577c478bd9Sstevel@tonic-gate ASSERT(major != (major_t)-1); 37587c478bd9Sstevel@tonic-gate } 37597c478bd9Sstevel@tonic-gate 37607c478bd9Sstevel@tonic-gate dnp = &devnamesp[major]; 37617c478bd9Sstevel@tonic-gate LOCK_DEV_OPS(&dnp->dn_lock); 37627c478bd9Sstevel@tonic-gate 37637c478bd9Sstevel@tonic-gate /* 37647c478bd9Sstevel@tonic-gate * Go through the driver's mperm list looking for 37657c478bd9Sstevel@tonic-gate * a match for the specified minor. If there's 37667c478bd9Sstevel@tonic-gate * no matching pattern, use the wild card. 37677c478bd9Sstevel@tonic-gate * Defer to the clone wild for clone if specified, 37687c478bd9Sstevel@tonic-gate * otherwise fall back to the normal form. 37697c478bd9Sstevel@tonic-gate */ 37707c478bd9Sstevel@tonic-gate for (mp = dnp->dn_mperm; mp; mp = mp->mp_next) { 37717c478bd9Sstevel@tonic-gate if (gmatch(minor_name, mp->mp_minorname) != 0) { 37727c478bd9Sstevel@tonic-gate break; 37737c478bd9Sstevel@tonic-gate } 37747c478bd9Sstevel@tonic-gate } 37757c478bd9Sstevel@tonic-gate if (mp == NULL) { 37767c478bd9Sstevel@tonic-gate if (is_clone) 37777c478bd9Sstevel@tonic-gate mp = dnp->dn_mperm_clone; 37787c478bd9Sstevel@tonic-gate if (mp == NULL) 37797c478bd9Sstevel@tonic-gate mp = dnp->dn_mperm_wild; 37807c478bd9Sstevel@tonic-gate } 37817c478bd9Sstevel@tonic-gate 37827c478bd9Sstevel@tonic-gate if (mp) { 37837c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_MP_MATCH) { 37847c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, 37857c478bd9Sstevel@tonic-gate "minor perm defaults: %s %s 0%o %d %d\n", 37867c478bd9Sstevel@tonic-gate name, mp->mp_minorname, mp->mp_mode, 37877c478bd9Sstevel@tonic-gate mp->mp_uid, mp->mp_gid); 37887c478bd9Sstevel@tonic-gate } 37897c478bd9Sstevel@tonic-gate rmp->mp_uid = mp->mp_uid; 37907c478bd9Sstevel@tonic-gate rmp->mp_gid = mp->mp_gid; 37917c478bd9Sstevel@tonic-gate rmp->mp_mode = mp->mp_mode; 37927c478bd9Sstevel@tonic-gate } 37937c478bd9Sstevel@tonic-gate UNLOCK_DEV_OPS(&dnp->dn_lock); 37947c478bd9Sstevel@tonic-gate 37957c478bd9Sstevel@tonic-gate /* 37967c478bd9Sstevel@tonic-gate * If no match can be found for a clone node, 37977c478bd9Sstevel@tonic-gate * search for a possible match for an alias. 37987c478bd9Sstevel@tonic-gate * One such example is /dev/ptmx -> /devices/pseudo/clone@0:ptm, 37997c478bd9Sstevel@tonic-gate * with minor perm entry clone:ptmx. 38007c478bd9Sstevel@tonic-gate */ 38017c478bd9Sstevel@tonic-gate if (mp == NULL && is_clone) { 38027c478bd9Sstevel@tonic-gate return (dev_alias_minorperm(dip, minor_name, rmp)); 38037c478bd9Sstevel@tonic-gate } 38047c478bd9Sstevel@tonic-gate 38057c478bd9Sstevel@tonic-gate return (mp == NULL); 38067c478bd9Sstevel@tonic-gate } 38077c478bd9Sstevel@tonic-gate 38087c478bd9Sstevel@tonic-gate /* 38097c478bd9Sstevel@tonic-gate * dynamicaly reference load a dl module/library, returning handle 38107c478bd9Sstevel@tonic-gate */ 38117c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 38127c478bd9Sstevel@tonic-gate ddi_modhandle_t 38137c478bd9Sstevel@tonic-gate ddi_modopen(const char *modname, int mode, int *errnop) 38147c478bd9Sstevel@tonic-gate { 38157c478bd9Sstevel@tonic-gate char *subdir; 38167c478bd9Sstevel@tonic-gate char *mod; 38177c478bd9Sstevel@tonic-gate int subdirlen; 38187c478bd9Sstevel@tonic-gate struct modctl *hmodp = NULL; 38197c478bd9Sstevel@tonic-gate int retval = EINVAL; 38207c478bd9Sstevel@tonic-gate 38217c478bd9Sstevel@tonic-gate ASSERT(modname && (mode == KRTLD_MODE_FIRST)); 38227c478bd9Sstevel@tonic-gate if ((modname == NULL) || (mode != KRTLD_MODE_FIRST)) 38237c478bd9Sstevel@tonic-gate goto out; 38247c478bd9Sstevel@tonic-gate 38257c478bd9Sstevel@tonic-gate /* find optional first '/' in modname */ 38267c478bd9Sstevel@tonic-gate mod = strchr(modname, '/'); 38277c478bd9Sstevel@tonic-gate if (mod != strrchr(modname, '/')) 38287c478bd9Sstevel@tonic-gate goto out; /* only one '/' is legal */ 38297c478bd9Sstevel@tonic-gate 38307c478bd9Sstevel@tonic-gate if (mod) { 38317c478bd9Sstevel@tonic-gate /* for subdir string without modification to argument */ 38327c478bd9Sstevel@tonic-gate mod++; 38337c478bd9Sstevel@tonic-gate subdirlen = mod - modname; 38347c478bd9Sstevel@tonic-gate subdir = kmem_alloc(subdirlen, KM_SLEEP); 38357c478bd9Sstevel@tonic-gate (void) strlcpy(subdir, modname, subdirlen); 38367c478bd9Sstevel@tonic-gate } else { 38377c478bd9Sstevel@tonic-gate subdirlen = 0; 38387c478bd9Sstevel@tonic-gate subdir = "misc"; 38397c478bd9Sstevel@tonic-gate mod = (char *)modname; 38407c478bd9Sstevel@tonic-gate } 38417c478bd9Sstevel@tonic-gate 38427c478bd9Sstevel@tonic-gate /* reference load with errno return value */ 38437c478bd9Sstevel@tonic-gate retval = modrload(subdir, mod, &hmodp); 38447c478bd9Sstevel@tonic-gate 38457c478bd9Sstevel@tonic-gate if (subdirlen) 38467c478bd9Sstevel@tonic-gate kmem_free(subdir, subdirlen); 38477c478bd9Sstevel@tonic-gate 38487c478bd9Sstevel@tonic-gate out: if (errnop) 38497c478bd9Sstevel@tonic-gate *errnop = retval; 38507c478bd9Sstevel@tonic-gate 38517c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_DDI_MOD) 38527c478bd9Sstevel@tonic-gate printf("ddi_modopen %s mode %x: %s %p %d\n", 38537c478bd9Sstevel@tonic-gate modname ? modname : "<unknown>", mode, 38547c478bd9Sstevel@tonic-gate hmodp ? hmodp->mod_filename : "<unknown>", 38557c478bd9Sstevel@tonic-gate (void *)hmodp, retval); 38567c478bd9Sstevel@tonic-gate 38577c478bd9Sstevel@tonic-gate return ((ddi_modhandle_t)hmodp); 38587c478bd9Sstevel@tonic-gate } 38597c478bd9Sstevel@tonic-gate 38607c478bd9Sstevel@tonic-gate /* lookup "name" in open dl module/library */ 38617c478bd9Sstevel@tonic-gate void * 38627c478bd9Sstevel@tonic-gate ddi_modsym(ddi_modhandle_t h, const char *name, int *errnop) 38637c478bd9Sstevel@tonic-gate { 38647c478bd9Sstevel@tonic-gate struct modctl *hmodp = (struct modctl *)h; 38657c478bd9Sstevel@tonic-gate void *f; 38667c478bd9Sstevel@tonic-gate int retval; 38677c478bd9Sstevel@tonic-gate 38687c478bd9Sstevel@tonic-gate ASSERT(hmodp && name && hmodp->mod_installed && (hmodp->mod_ref >= 1)); 38697c478bd9Sstevel@tonic-gate if ((hmodp == NULL) || (name == NULL) || 38707c478bd9Sstevel@tonic-gate (hmodp->mod_installed == 0) || (hmodp->mod_ref < 1)) { 38717c478bd9Sstevel@tonic-gate f = NULL; 38727c478bd9Sstevel@tonic-gate retval = EINVAL; 38737c478bd9Sstevel@tonic-gate } else { 38747c478bd9Sstevel@tonic-gate f = (void *)kobj_lookup(hmodp->mod_mp, (char *)name); 38757c478bd9Sstevel@tonic-gate if (f) 38767c478bd9Sstevel@tonic-gate retval = 0; 38777c478bd9Sstevel@tonic-gate else 38787c478bd9Sstevel@tonic-gate retval = ENOTSUP; 38797c478bd9Sstevel@tonic-gate } 38807c478bd9Sstevel@tonic-gate 38817c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_DDI_MOD) 38827c478bd9Sstevel@tonic-gate printf("ddi_modsym in %s of %s: %d %p\n", 38837c478bd9Sstevel@tonic-gate hmodp ? hmodp->mod_modname : "<unknown>", 38847c478bd9Sstevel@tonic-gate name ? name : "<unknown>", retval, f); 38857c478bd9Sstevel@tonic-gate 38867c478bd9Sstevel@tonic-gate if (errnop) 38877c478bd9Sstevel@tonic-gate *errnop = retval; 38887c478bd9Sstevel@tonic-gate return (f); 38897c478bd9Sstevel@tonic-gate } 38907c478bd9Sstevel@tonic-gate 38917c478bd9Sstevel@tonic-gate /* dynamic (un)reference unload of an open dl module/library */ 38927c478bd9Sstevel@tonic-gate int 38937c478bd9Sstevel@tonic-gate ddi_modclose(ddi_modhandle_t h) 38947c478bd9Sstevel@tonic-gate { 38957c478bd9Sstevel@tonic-gate struct modctl *hmodp = (struct modctl *)h; 38967c478bd9Sstevel@tonic-gate struct modctl *modp = NULL; 38977c478bd9Sstevel@tonic-gate int retval; 38987c478bd9Sstevel@tonic-gate 38997c478bd9Sstevel@tonic-gate ASSERT(hmodp && hmodp->mod_installed && (hmodp->mod_ref >= 1)); 39007c478bd9Sstevel@tonic-gate if ((hmodp == NULL) || 39017c478bd9Sstevel@tonic-gate (hmodp->mod_installed == 0) || (hmodp->mod_ref < 1)) { 39027c478bd9Sstevel@tonic-gate retval = EINVAL; 39037c478bd9Sstevel@tonic-gate goto out; 39047c478bd9Sstevel@tonic-gate } 39057c478bd9Sstevel@tonic-gate 39067c478bd9Sstevel@tonic-gate retval = modunrload(hmodp->mod_id, &modp, ddi_modclose_unload); 39077c478bd9Sstevel@tonic-gate if (retval == EBUSY) 39087c478bd9Sstevel@tonic-gate retval = 0; /* EBUSY is not an error */ 39097c478bd9Sstevel@tonic-gate 39107c478bd9Sstevel@tonic-gate if (retval == 0) { 39117c478bd9Sstevel@tonic-gate ASSERT(hmodp == modp); 39127c478bd9Sstevel@tonic-gate if (hmodp != modp) 39137c478bd9Sstevel@tonic-gate retval = EINVAL; 39147c478bd9Sstevel@tonic-gate } 39157c478bd9Sstevel@tonic-gate 39167c478bd9Sstevel@tonic-gate out: if (moddebug & MODDEBUG_DDI_MOD) 39177c478bd9Sstevel@tonic-gate printf("ddi_modclose %s: %d\n", 39187c478bd9Sstevel@tonic-gate hmodp ? hmodp->mod_modname : "<unknown>", retval); 39197c478bd9Sstevel@tonic-gate 39207c478bd9Sstevel@tonic-gate return (retval); 39217c478bd9Sstevel@tonic-gate } 3922