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 55a59a8b3Srsb * Common Development and Distribution License (the "License"). 65a59a8b3Srsb * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217c478bd9Sstevel@tonic-gate /* 227aec1d6eScindi * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 237c478bd9Sstevel@tonic-gate * Use is subject to license terms. 247c478bd9Sstevel@tonic-gate */ 257c478bd9Sstevel@tonic-gate 267c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 277c478bd9Sstevel@tonic-gate 287c478bd9Sstevel@tonic-gate #include <sys/types.h> 297c478bd9Sstevel@tonic-gate #include <sys/systm.h> 307c478bd9Sstevel@tonic-gate #include <sys/param.h> 317c478bd9Sstevel@tonic-gate #include <sys/user.h> 327c478bd9Sstevel@tonic-gate #include <sys/vm.h> 337c478bd9Sstevel@tonic-gate #include <sys/conf.h> 347c478bd9Sstevel@tonic-gate #include <sys/class.h> 357c478bd9Sstevel@tonic-gate #include <sys/vfs.h> 365a59a8b3Srsb #include <sys/vnode.h> 377c478bd9Sstevel@tonic-gate #include <sys/mount.h> 387c478bd9Sstevel@tonic-gate #include <sys/systm.h> 397c478bd9Sstevel@tonic-gate #include <sys/modctl.h> 407c478bd9Sstevel@tonic-gate #include <sys/exec.h> 417c478bd9Sstevel@tonic-gate #include <sys/exechdr.h> 427c478bd9Sstevel@tonic-gate #include <sys/devops.h> 437c478bd9Sstevel@tonic-gate #include <sys/ddi.h> 447c478bd9Sstevel@tonic-gate #include <sys/sunddi.h> 457c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 467c478bd9Sstevel@tonic-gate #include <sys/hwconf.h> 477c478bd9Sstevel@tonic-gate #include <sys/ddi_impldefs.h> 487c478bd9Sstevel@tonic-gate #include <sys/autoconf.h> 497c478bd9Sstevel@tonic-gate #include <sys/disp.h> 507c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 517c478bd9Sstevel@tonic-gate #include <sys/instance.h> 527c478bd9Sstevel@tonic-gate #include <sys/modhash.h> 537c478bd9Sstevel@tonic-gate #include <sys/dacf.h> 547c478bd9Sstevel@tonic-gate #include <sys/debug.h> 557c478bd9Sstevel@tonic-gate #include <ipp/ipp.h> 567c478bd9Sstevel@tonic-gate #include <sys/strsubr.h> 577c478bd9Sstevel@tonic-gate #include <sys/kcpc.h> 587c478bd9Sstevel@tonic-gate #include <sys/cpc_pcbe.h> 595a59a8b3Srsb #include <sys/kstat.h> 60*facf4a8dSllai1 #include <sys/fs/sdev_node.h> 617c478bd9Sstevel@tonic-gate 627c478bd9Sstevel@tonic-gate extern int moddebug; 637c478bd9Sstevel@tonic-gate 647c478bd9Sstevel@tonic-gate extern struct cb_ops no_cb_ops; 657c478bd9Sstevel@tonic-gate extern struct dev_ops nodev_ops; 667c478bd9Sstevel@tonic-gate extern struct dev_ops mod_nodev_ops; 677c478bd9Sstevel@tonic-gate 687c478bd9Sstevel@tonic-gate extern struct modctl *mod_getctl(struct modlinkage *); 697c478bd9Sstevel@tonic-gate extern int errsys(), nodev(), nulldev(); 707c478bd9Sstevel@tonic-gate 717c478bd9Sstevel@tonic-gate extern int findmodbyname(char *); 727c478bd9Sstevel@tonic-gate extern int mod_getsysnum(char *); 737c478bd9Sstevel@tonic-gate 747c478bd9Sstevel@tonic-gate extern struct execsw execsw[]; 757c478bd9Sstevel@tonic-gate 767c478bd9Sstevel@tonic-gate /* 777c478bd9Sstevel@tonic-gate * Define dev_ops for unused devopsp entry. 787c478bd9Sstevel@tonic-gate */ 797c478bd9Sstevel@tonic-gate struct dev_ops mod_nodev_ops = { 807c478bd9Sstevel@tonic-gate DEVO_REV, /* devo_rev */ 817c478bd9Sstevel@tonic-gate 0, /* refcnt */ 827c478bd9Sstevel@tonic-gate ddi_no_info, /* info */ 837c478bd9Sstevel@tonic-gate nulldev, /* identify */ 847c478bd9Sstevel@tonic-gate nulldev, /* probe */ 857c478bd9Sstevel@tonic-gate ddifail, /* attach */ 867c478bd9Sstevel@tonic-gate nodev, /* detach */ 877c478bd9Sstevel@tonic-gate nulldev, /* reset */ 887c478bd9Sstevel@tonic-gate &no_cb_ops, /* character/block driver operations */ 897c478bd9Sstevel@tonic-gate (struct bus_ops *)0 /* bus operations for nexus drivers */ 907c478bd9Sstevel@tonic-gate }; 917c478bd9Sstevel@tonic-gate 927c478bd9Sstevel@tonic-gate /* 937c478bd9Sstevel@tonic-gate * Define mod_ops for each supported module type 947c478bd9Sstevel@tonic-gate */ 957c478bd9Sstevel@tonic-gate 967c478bd9Sstevel@tonic-gate /* 977c478bd9Sstevel@tonic-gate * Null operations; used for uninitialized and "misc" modules. 987c478bd9Sstevel@tonic-gate */ 997c478bd9Sstevel@tonic-gate static int mod_null(struct modldrv *, struct modlinkage *); 1007c478bd9Sstevel@tonic-gate static int mod_infonull(void *, struct modlinkage *, int *); 1017c478bd9Sstevel@tonic-gate 1027c478bd9Sstevel@tonic-gate struct mod_ops mod_miscops = { 1037c478bd9Sstevel@tonic-gate mod_null, mod_null, mod_infonull 1047c478bd9Sstevel@tonic-gate }; 1057c478bd9Sstevel@tonic-gate 1067aec1d6eScindi /* CPU Modules */ 1077aec1d6eScindi struct mod_ops mod_cpuops = { 1087aec1d6eScindi mod_null, mod_null, mod_infonull 1097aec1d6eScindi }; 1107aec1d6eScindi 1117c478bd9Sstevel@tonic-gate /* 1127c478bd9Sstevel@tonic-gate * Cryptographic Modules 1137c478bd9Sstevel@tonic-gate */ 1147c478bd9Sstevel@tonic-gate struct mod_ops mod_cryptoops = { 1157c478bd9Sstevel@tonic-gate mod_null, mod_null, mod_infonull 1167c478bd9Sstevel@tonic-gate }; 1177c478bd9Sstevel@tonic-gate 1187c478bd9Sstevel@tonic-gate /* 1197c478bd9Sstevel@tonic-gate * IP Policy Modules 1207c478bd9Sstevel@tonic-gate */ 1217c478bd9Sstevel@tonic-gate static int mod_installipp(struct modlipp *, struct modlinkage *); 1227c478bd9Sstevel@tonic-gate static int mod_removeipp(struct modlipp *, struct modlinkage *); 1237c478bd9Sstevel@tonic-gate static int mod_infoipp(struct modlipp *, struct modlinkage *, int *); 1247c478bd9Sstevel@tonic-gate 1257c478bd9Sstevel@tonic-gate struct mod_ops mod_ippops = { 1267c478bd9Sstevel@tonic-gate mod_installipp, mod_removeipp, mod_infoipp 1277c478bd9Sstevel@tonic-gate }; 1287c478bd9Sstevel@tonic-gate 1297c478bd9Sstevel@tonic-gate /* 1307c478bd9Sstevel@tonic-gate * Device drivers 1317c478bd9Sstevel@tonic-gate */ 1327c478bd9Sstevel@tonic-gate static int mod_infodrv(struct modldrv *, struct modlinkage *, int *); 1337c478bd9Sstevel@tonic-gate static int mod_installdrv(struct modldrv *, struct modlinkage *); 1347c478bd9Sstevel@tonic-gate static int mod_removedrv(struct modldrv *, struct modlinkage *); 1357c478bd9Sstevel@tonic-gate 1367c478bd9Sstevel@tonic-gate struct mod_ops mod_driverops = { 1377c478bd9Sstevel@tonic-gate mod_installdrv, mod_removedrv, mod_infodrv 1387c478bd9Sstevel@tonic-gate }; 1397c478bd9Sstevel@tonic-gate 1407c478bd9Sstevel@tonic-gate /* 1417c478bd9Sstevel@tonic-gate * System calls (new interface) 1427c478bd9Sstevel@tonic-gate */ 1437c478bd9Sstevel@tonic-gate static int mod_infosys(struct modlsys *, struct modlinkage *, int *); 1447c478bd9Sstevel@tonic-gate static int mod_installsys(struct modlsys *, struct modlinkage *); 1457c478bd9Sstevel@tonic-gate static int mod_removesys(struct modlsys *, struct modlinkage *); 1467c478bd9Sstevel@tonic-gate 1477c478bd9Sstevel@tonic-gate struct mod_ops mod_syscallops = { 1487c478bd9Sstevel@tonic-gate mod_installsys, mod_removesys, mod_infosys 1497c478bd9Sstevel@tonic-gate }; 1507c478bd9Sstevel@tonic-gate 1517c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 1527c478bd9Sstevel@tonic-gate /* 1537c478bd9Sstevel@tonic-gate * 32-bit system calls in 64-bit kernel 1547c478bd9Sstevel@tonic-gate */ 1557c478bd9Sstevel@tonic-gate static int mod_infosys32(struct modlsys *, struct modlinkage *, int *); 1567c478bd9Sstevel@tonic-gate static int mod_installsys32(struct modlsys *, struct modlinkage *); 1577c478bd9Sstevel@tonic-gate static int mod_removesys32(struct modlsys *, struct modlinkage *); 1587c478bd9Sstevel@tonic-gate 1597c478bd9Sstevel@tonic-gate struct mod_ops mod_syscallops32 = { 1607c478bd9Sstevel@tonic-gate mod_installsys32, mod_removesys32, mod_infosys32 1617c478bd9Sstevel@tonic-gate }; 1627c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32_IMPL */ 1637c478bd9Sstevel@tonic-gate 1647c478bd9Sstevel@tonic-gate /* 1657c478bd9Sstevel@tonic-gate * Filesystems 1667c478bd9Sstevel@tonic-gate */ 1677c478bd9Sstevel@tonic-gate static int mod_infofs(struct modlfs *, struct modlinkage *, int *); 1687c478bd9Sstevel@tonic-gate static int mod_installfs(struct modlfs *, struct modlinkage *); 1697c478bd9Sstevel@tonic-gate static int mod_removefs(struct modlfs *, struct modlinkage *); 1707c478bd9Sstevel@tonic-gate 1717c478bd9Sstevel@tonic-gate struct mod_ops mod_fsops = { 1727c478bd9Sstevel@tonic-gate mod_installfs, mod_removefs, mod_infofs 1737c478bd9Sstevel@tonic-gate }; 1747c478bd9Sstevel@tonic-gate 1757c478bd9Sstevel@tonic-gate /* 1767c478bd9Sstevel@tonic-gate * Streams modules. 1777c478bd9Sstevel@tonic-gate */ 1787c478bd9Sstevel@tonic-gate static int mod_infostrmod(struct modlstrmod *, struct modlinkage *, int *); 1797c478bd9Sstevel@tonic-gate static int mod_installstrmod(struct modlstrmod *, struct modlinkage *); 1807c478bd9Sstevel@tonic-gate static int mod_removestrmod(struct modlstrmod *, struct modlinkage *); 1817c478bd9Sstevel@tonic-gate 1827c478bd9Sstevel@tonic-gate struct mod_ops mod_strmodops = { 1837c478bd9Sstevel@tonic-gate mod_installstrmod, mod_removestrmod, mod_infostrmod 1847c478bd9Sstevel@tonic-gate }; 1857c478bd9Sstevel@tonic-gate 1867c478bd9Sstevel@tonic-gate /* 1877c478bd9Sstevel@tonic-gate * Scheduling classes. 1887c478bd9Sstevel@tonic-gate */ 1897c478bd9Sstevel@tonic-gate static int mod_infosched(struct modlsched *, struct modlinkage *, int *); 1907c478bd9Sstevel@tonic-gate static int mod_installsched(struct modlsched *, struct modlinkage *); 1917c478bd9Sstevel@tonic-gate static int mod_removesched(struct modlsched *, struct modlinkage *); 1927c478bd9Sstevel@tonic-gate 1937c478bd9Sstevel@tonic-gate struct mod_ops mod_schedops = { 1947c478bd9Sstevel@tonic-gate mod_installsched, mod_removesched, mod_infosched 1957c478bd9Sstevel@tonic-gate }; 1967c478bd9Sstevel@tonic-gate 1977c478bd9Sstevel@tonic-gate /* 1987c478bd9Sstevel@tonic-gate * Exec file type (like ELF, ...). 1997c478bd9Sstevel@tonic-gate */ 2007c478bd9Sstevel@tonic-gate static int mod_infoexec(struct modlexec *, struct modlinkage *, int *); 2017c478bd9Sstevel@tonic-gate static int mod_installexec(struct modlexec *, struct modlinkage *); 2027c478bd9Sstevel@tonic-gate static int mod_removeexec(struct modlexec *, struct modlinkage *); 2037c478bd9Sstevel@tonic-gate 2047c478bd9Sstevel@tonic-gate struct mod_ops mod_execops = { 2057c478bd9Sstevel@tonic-gate mod_installexec, mod_removeexec, mod_infoexec 2067c478bd9Sstevel@tonic-gate }; 2077c478bd9Sstevel@tonic-gate 2087c478bd9Sstevel@tonic-gate /* 2097c478bd9Sstevel@tonic-gate * Dacf (Dynamic Autoconfiguration) modules. 2107c478bd9Sstevel@tonic-gate */ 2117c478bd9Sstevel@tonic-gate static int mod_infodacf(struct modldacf *, struct modlinkage *, int *); 2127c478bd9Sstevel@tonic-gate static int mod_installdacf(struct modldacf *, struct modlinkage *); 2137c478bd9Sstevel@tonic-gate static int mod_removedacf(struct modldacf *, struct modlinkage *); 2147c478bd9Sstevel@tonic-gate 2157c478bd9Sstevel@tonic-gate struct mod_ops mod_dacfops = { 2167c478bd9Sstevel@tonic-gate mod_installdacf, mod_removedacf, mod_infodacf 2177c478bd9Sstevel@tonic-gate }; 2187c478bd9Sstevel@tonic-gate 2197c478bd9Sstevel@tonic-gate /* 220*facf4a8dSllai1 * /dev fs modules 221*facf4a8dSllai1 */ 222*facf4a8dSllai1 static int mod_infodev(struct modldev *, struct modlinkage *, int *); 223*facf4a8dSllai1 static int mod_installdev(struct modldev *, struct modlinkage *); 224*facf4a8dSllai1 static int mod_removedev(struct modldev *, struct modlinkage *); 225*facf4a8dSllai1 226*facf4a8dSllai1 struct mod_ops mod_devfsops = { 227*facf4a8dSllai1 mod_installdev, mod_removedev, mod_infodev 228*facf4a8dSllai1 }; 229*facf4a8dSllai1 230*facf4a8dSllai1 /* 2317c478bd9Sstevel@tonic-gate * PCBE (Performance Counter BackEnd) modules. 2327c478bd9Sstevel@tonic-gate */ 2337c478bd9Sstevel@tonic-gate static int mod_installpcbe(struct modlpcbe *, struct modlinkage *); 2347c478bd9Sstevel@tonic-gate static int mod_removepcbe(struct modlpcbe *, struct modlinkage *); 2357c478bd9Sstevel@tonic-gate 2367c478bd9Sstevel@tonic-gate struct mod_ops mod_pcbeops = { 2377c478bd9Sstevel@tonic-gate mod_installpcbe, mod_removepcbe, mod_infonull 2387c478bd9Sstevel@tonic-gate }; 2397c478bd9Sstevel@tonic-gate 2407c478bd9Sstevel@tonic-gate static struct sysent *mod_getsysent(struct modlinkage *, struct sysent *); 2417c478bd9Sstevel@tonic-gate 2427c478bd9Sstevel@tonic-gate static char uninstall_err[] = "Cannot uninstall %s; not installed"; 2437c478bd9Sstevel@tonic-gate 2447c478bd9Sstevel@tonic-gate /* 2457c478bd9Sstevel@tonic-gate * Debugging support 2467c478bd9Sstevel@tonic-gate */ 2477c478bd9Sstevel@tonic-gate #define DRV_DBG MODDEBUG_LOADMSG2 2487c478bd9Sstevel@tonic-gate 2497c478bd9Sstevel@tonic-gate /*PRINTFLIKE2*/ 2507c478bd9Sstevel@tonic-gate static void mod_dprintf(int flag, const char *format, ...) __KPRINTFLIKE(2); 2517c478bd9Sstevel@tonic-gate 2527c478bd9Sstevel@tonic-gate static void 2537c478bd9Sstevel@tonic-gate mod_dprintf(int flag, const char *format, ...) 2547c478bd9Sstevel@tonic-gate { 2557c478bd9Sstevel@tonic-gate va_list alist; 2567c478bd9Sstevel@tonic-gate 2577c478bd9Sstevel@tonic-gate if ((moddebug & flag) != 0) { 2587c478bd9Sstevel@tonic-gate va_start(alist, format); 2597c478bd9Sstevel@tonic-gate (void) vprintf(format, alist); 2607c478bd9Sstevel@tonic-gate va_end(alist); 2617c478bd9Sstevel@tonic-gate } 2627c478bd9Sstevel@tonic-gate } 2637c478bd9Sstevel@tonic-gate 2647c478bd9Sstevel@tonic-gate /* 2657c478bd9Sstevel@tonic-gate * Install a module. 2667c478bd9Sstevel@tonic-gate * (This routine is in the Solaris SPARC DDI/DKI) 2677c478bd9Sstevel@tonic-gate */ 2687c478bd9Sstevel@tonic-gate int 2697c478bd9Sstevel@tonic-gate mod_install(struct modlinkage *modlp) 2707c478bd9Sstevel@tonic-gate { 2717c478bd9Sstevel@tonic-gate int retval = -1; /* No linkage structures */ 2727c478bd9Sstevel@tonic-gate struct modlmisc **linkpp; 2737c478bd9Sstevel@tonic-gate struct modlmisc **linkpp1; 2747c478bd9Sstevel@tonic-gate 2757c478bd9Sstevel@tonic-gate if (modlp->ml_rev != MODREV_1) { 2767c478bd9Sstevel@tonic-gate printf("mod_install: modlinkage structure is not MODREV_1\n"); 2777c478bd9Sstevel@tonic-gate return (EINVAL); 2787c478bd9Sstevel@tonic-gate } 2797c478bd9Sstevel@tonic-gate linkpp = (struct modlmisc **)&modlp->ml_linkage[0]; 2807c478bd9Sstevel@tonic-gate 2817c478bd9Sstevel@tonic-gate while (*linkpp != NULL) { 2827c478bd9Sstevel@tonic-gate if ((retval = MODL_INSTALL(*linkpp, modlp)) != 0) { 2837c478bd9Sstevel@tonic-gate linkpp1 = (struct modlmisc **)&modlp->ml_linkage[0]; 2847c478bd9Sstevel@tonic-gate 2857c478bd9Sstevel@tonic-gate while (linkpp1 != linkpp) { 2867c478bd9Sstevel@tonic-gate MODL_REMOVE(*linkpp1, modlp); /* clean up */ 2877c478bd9Sstevel@tonic-gate linkpp1++; 2887c478bd9Sstevel@tonic-gate } 2897c478bd9Sstevel@tonic-gate break; 2907c478bd9Sstevel@tonic-gate } 2917c478bd9Sstevel@tonic-gate linkpp++; 2927c478bd9Sstevel@tonic-gate } 2937c478bd9Sstevel@tonic-gate return (retval); 2947c478bd9Sstevel@tonic-gate } 2957c478bd9Sstevel@tonic-gate 2967c478bd9Sstevel@tonic-gate static char *reins_err = 2977c478bd9Sstevel@tonic-gate "Could not reinstall %s\nReboot to correct the problem"; 2987c478bd9Sstevel@tonic-gate 2997c478bd9Sstevel@tonic-gate /* 3007c478bd9Sstevel@tonic-gate * Remove a module. This is called by the module wrapper routine. 3017c478bd9Sstevel@tonic-gate * (This routine is in the Solaris SPARC DDI/DKI) 3027c478bd9Sstevel@tonic-gate */ 3037c478bd9Sstevel@tonic-gate int 3047c478bd9Sstevel@tonic-gate mod_remove(struct modlinkage *modlp) 3057c478bd9Sstevel@tonic-gate { 3067c478bd9Sstevel@tonic-gate int retval = 0; 3077c478bd9Sstevel@tonic-gate struct modlmisc **linkpp, *last_linkp; 3087c478bd9Sstevel@tonic-gate 3097c478bd9Sstevel@tonic-gate linkpp = (struct modlmisc **)&modlp->ml_linkage[0]; 3107c478bd9Sstevel@tonic-gate 3117c478bd9Sstevel@tonic-gate while (*linkpp != NULL) { 3127c478bd9Sstevel@tonic-gate if ((retval = MODL_REMOVE(*linkpp, modlp)) != 0) { 3137c478bd9Sstevel@tonic-gate last_linkp = *linkpp; 3147c478bd9Sstevel@tonic-gate linkpp = (struct modlmisc **)&modlp->ml_linkage[0]; 3157c478bd9Sstevel@tonic-gate while (*linkpp != last_linkp) { 3167c478bd9Sstevel@tonic-gate if (MODL_INSTALL(*linkpp, modlp) != 0) { 3177c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, reins_err, 3187c478bd9Sstevel@tonic-gate (*linkpp)->misc_linkinfo); 3197c478bd9Sstevel@tonic-gate break; 3207c478bd9Sstevel@tonic-gate } 3217c478bd9Sstevel@tonic-gate linkpp++; 3227c478bd9Sstevel@tonic-gate } 3237c478bd9Sstevel@tonic-gate break; 3247c478bd9Sstevel@tonic-gate } 3257c478bd9Sstevel@tonic-gate linkpp++; 3267c478bd9Sstevel@tonic-gate } 3277c478bd9Sstevel@tonic-gate return (retval); 3287c478bd9Sstevel@tonic-gate } 3297c478bd9Sstevel@tonic-gate 3307c478bd9Sstevel@tonic-gate /* 3317c478bd9Sstevel@tonic-gate * Get module status. 3327c478bd9Sstevel@tonic-gate * (This routine is in the Solaris SPARC DDI/DKI) 3337c478bd9Sstevel@tonic-gate */ 3347c478bd9Sstevel@tonic-gate int 3357c478bd9Sstevel@tonic-gate mod_info(struct modlinkage *modlp, struct modinfo *modinfop) 3367c478bd9Sstevel@tonic-gate { 3377c478bd9Sstevel@tonic-gate int i; 3387c478bd9Sstevel@tonic-gate int retval = 0; 3397c478bd9Sstevel@tonic-gate struct modspecific_info *msip; 3407c478bd9Sstevel@tonic-gate struct modlmisc **linkpp; 3417c478bd9Sstevel@tonic-gate 3427c478bd9Sstevel@tonic-gate modinfop->mi_rev = modlp->ml_rev; 3437c478bd9Sstevel@tonic-gate 3447c478bd9Sstevel@tonic-gate linkpp = (struct modlmisc **)modlp->ml_linkage; 3457c478bd9Sstevel@tonic-gate msip = &modinfop->mi_msinfo[0]; 3467c478bd9Sstevel@tonic-gate 3477c478bd9Sstevel@tonic-gate for (i = 0; i < MODMAXLINK; i++) { 3487c478bd9Sstevel@tonic-gate if (*linkpp == NULL) { 3497c478bd9Sstevel@tonic-gate msip->msi_linkinfo[0] = '\0'; 3507c478bd9Sstevel@tonic-gate } else { 3517c478bd9Sstevel@tonic-gate (void) strncpy(msip->msi_linkinfo, 3527c478bd9Sstevel@tonic-gate (*linkpp)->misc_linkinfo, MODMAXLINKINFOLEN); 3537c478bd9Sstevel@tonic-gate retval = MODL_INFO(*linkpp, modlp, &msip->msi_p0); 3547c478bd9Sstevel@tonic-gate if (retval != 0) 3557c478bd9Sstevel@tonic-gate break; 3567c478bd9Sstevel@tonic-gate linkpp++; 3577c478bd9Sstevel@tonic-gate } 3587c478bd9Sstevel@tonic-gate msip++; 3597c478bd9Sstevel@tonic-gate } 3607c478bd9Sstevel@tonic-gate 3617c478bd9Sstevel@tonic-gate if (modinfop->mi_info == MI_INFO_LINKAGE) { 3627c478bd9Sstevel@tonic-gate /* 3637c478bd9Sstevel@tonic-gate * Slight kludge used to extract the address of the 3647c478bd9Sstevel@tonic-gate * modlinkage structure from the module (just after 3657c478bd9Sstevel@tonic-gate * loading a module for the very first time) 3667c478bd9Sstevel@tonic-gate */ 3677c478bd9Sstevel@tonic-gate modinfop->mi_base = (void *)modlp; 3687c478bd9Sstevel@tonic-gate } 3697c478bd9Sstevel@tonic-gate 3707c478bd9Sstevel@tonic-gate if (retval == 0) 3717c478bd9Sstevel@tonic-gate return (1); 3727c478bd9Sstevel@tonic-gate return (0); 3737c478bd9Sstevel@tonic-gate } 3747c478bd9Sstevel@tonic-gate 3757c478bd9Sstevel@tonic-gate /* 3767c478bd9Sstevel@tonic-gate * Get module name. 3777c478bd9Sstevel@tonic-gate */ 3787c478bd9Sstevel@tonic-gate char * 3797c478bd9Sstevel@tonic-gate mod_modname(struct modlinkage *modlp) 3807c478bd9Sstevel@tonic-gate { 3817c478bd9Sstevel@tonic-gate struct modctl *mcp; 3827c478bd9Sstevel@tonic-gate 3837c478bd9Sstevel@tonic-gate if ((mcp = mod_getctl(modlp)) == NULL) 3847c478bd9Sstevel@tonic-gate return (NULL); 3857c478bd9Sstevel@tonic-gate 3867c478bd9Sstevel@tonic-gate return (mcp->mod_modname); 3877c478bd9Sstevel@tonic-gate } 3887c478bd9Sstevel@tonic-gate 3897c478bd9Sstevel@tonic-gate /* 3907c478bd9Sstevel@tonic-gate * Null operation; return 0. 3917c478bd9Sstevel@tonic-gate */ 3927c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 3937c478bd9Sstevel@tonic-gate static int 3947c478bd9Sstevel@tonic-gate mod_null(struct modldrv *modl, struct modlinkage *modlp) 3957c478bd9Sstevel@tonic-gate { 3967c478bd9Sstevel@tonic-gate return (0); 3977c478bd9Sstevel@tonic-gate } 3987c478bd9Sstevel@tonic-gate 3997c478bd9Sstevel@tonic-gate /* 4007c478bd9Sstevel@tonic-gate * Status for User modules. 4017c478bd9Sstevel@tonic-gate */ 4027c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 4037c478bd9Sstevel@tonic-gate static int 4047c478bd9Sstevel@tonic-gate mod_infonull(void *modl, struct modlinkage *modlp, int *p0) 4057c478bd9Sstevel@tonic-gate { 4067c478bd9Sstevel@tonic-gate *p0 = -1; /* for modinfo display */ 4077c478bd9Sstevel@tonic-gate return (0); 4087c478bd9Sstevel@tonic-gate } 4097c478bd9Sstevel@tonic-gate 4107c478bd9Sstevel@tonic-gate /* 4117c478bd9Sstevel@tonic-gate * Driver status info 4127c478bd9Sstevel@tonic-gate */ 4137c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 4147c478bd9Sstevel@tonic-gate static int 4157c478bd9Sstevel@tonic-gate mod_infodrv(struct modldrv *modl, struct modlinkage *modlp, int *p0) 4167c478bd9Sstevel@tonic-gate { 4177c478bd9Sstevel@tonic-gate struct modctl *mcp; 4187c478bd9Sstevel@tonic-gate char *mod_name; 4197c478bd9Sstevel@tonic-gate 4207c478bd9Sstevel@tonic-gate if ((mcp = mod_getctl(modlp)) == NULL) { 4217c478bd9Sstevel@tonic-gate *p0 = -1; 4227c478bd9Sstevel@tonic-gate return (0); /* driver is not yet installed */ 4237c478bd9Sstevel@tonic-gate } 4247c478bd9Sstevel@tonic-gate 4257c478bd9Sstevel@tonic-gate mod_name = mcp->mod_modname; 4267c478bd9Sstevel@tonic-gate 4277c478bd9Sstevel@tonic-gate *p0 = ddi_name_to_major(mod_name); 4287c478bd9Sstevel@tonic-gate return (0); 4297c478bd9Sstevel@tonic-gate } 4307c478bd9Sstevel@tonic-gate 4317c478bd9Sstevel@tonic-gate /* 4327c478bd9Sstevel@tonic-gate * Manage dacf (device autoconfiguration) modules 4337c478bd9Sstevel@tonic-gate */ 4347c478bd9Sstevel@tonic-gate 4357c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 4367c478bd9Sstevel@tonic-gate static int 4377c478bd9Sstevel@tonic-gate mod_infodacf(struct modldacf *modl, struct modlinkage *modlp, int *p0) 4387c478bd9Sstevel@tonic-gate { 4397c478bd9Sstevel@tonic-gate if (mod_getctl(modlp) == NULL) { 4407c478bd9Sstevel@tonic-gate *p0 = -1; 4417c478bd9Sstevel@tonic-gate return (0); /* module is not yet installed */ 4427c478bd9Sstevel@tonic-gate } 4437c478bd9Sstevel@tonic-gate 4447c478bd9Sstevel@tonic-gate *p0 = 0; 4457c478bd9Sstevel@tonic-gate return (0); 4467c478bd9Sstevel@tonic-gate } 4477c478bd9Sstevel@tonic-gate 4487c478bd9Sstevel@tonic-gate static int 4497c478bd9Sstevel@tonic-gate mod_installdacf(struct modldacf *modl, struct modlinkage *modlp) 4507c478bd9Sstevel@tonic-gate { 4517c478bd9Sstevel@tonic-gate struct modctl *mcp; 4527c478bd9Sstevel@tonic-gate 4537c478bd9Sstevel@tonic-gate if ((mcp = mod_getctl(modlp)) == NULL) 4547c478bd9Sstevel@tonic-gate return (EINVAL); 4557c478bd9Sstevel@tonic-gate return (dacf_module_register(mcp->mod_modname, modl->dacf_dacfsw)); 4567c478bd9Sstevel@tonic-gate } 4577c478bd9Sstevel@tonic-gate 4587c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 4597c478bd9Sstevel@tonic-gate static int 4607c478bd9Sstevel@tonic-gate mod_removedacf(struct modldacf *modl, struct modlinkage *modlp) 4617c478bd9Sstevel@tonic-gate { 4627c478bd9Sstevel@tonic-gate struct modctl *mcp; 4637c478bd9Sstevel@tonic-gate 4647c478bd9Sstevel@tonic-gate if ((mcp = mod_getctl(modlp)) == NULL) 4657c478bd9Sstevel@tonic-gate return (EINVAL); 4667c478bd9Sstevel@tonic-gate return (dacf_module_unregister(mcp->mod_modname)); 4677c478bd9Sstevel@tonic-gate } 4687c478bd9Sstevel@tonic-gate 4697c478bd9Sstevel@tonic-gate /* 4707c478bd9Sstevel@tonic-gate * Manage PCBE (Performance Counter BackEnd) modules. 4717c478bd9Sstevel@tonic-gate */ 4727c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 4737c478bd9Sstevel@tonic-gate static int 4747c478bd9Sstevel@tonic-gate mod_installpcbe(struct modlpcbe *modl, struct modlinkage *modlp) 4757c478bd9Sstevel@tonic-gate { 4767c478bd9Sstevel@tonic-gate if (modl->pcbe_ops->pcbe_ver != PCBE_VER_1) { 4777c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "pcbe '%s' version mismatch", 4787c478bd9Sstevel@tonic-gate modl->pcbe_linkinfo); 4797c478bd9Sstevel@tonic-gate return (EINVAL); 4807c478bd9Sstevel@tonic-gate } 4817c478bd9Sstevel@tonic-gate 4827c478bd9Sstevel@tonic-gate kcpc_register_pcbe(modl->pcbe_ops); 4837c478bd9Sstevel@tonic-gate return (0); 4847c478bd9Sstevel@tonic-gate } 4857c478bd9Sstevel@tonic-gate 4867c478bd9Sstevel@tonic-gate /* 4877c478bd9Sstevel@tonic-gate * PCBEs may not be unloaded. It would make CPC locking too complex, and since 4887c478bd9Sstevel@tonic-gate * PCBEs are loaded once and used for life, there is no harm done in leaving 4897c478bd9Sstevel@tonic-gate * them in the system. 4907c478bd9Sstevel@tonic-gate */ 4917c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 4927c478bd9Sstevel@tonic-gate static int 4937c478bd9Sstevel@tonic-gate mod_removepcbe(struct modlpcbe *modl, struct modlinkage *modlp) 4947c478bd9Sstevel@tonic-gate { 4957c478bd9Sstevel@tonic-gate return (EBUSY); 4967c478bd9Sstevel@tonic-gate } 4977c478bd9Sstevel@tonic-gate 498*facf4a8dSllai1 /* 499*facf4a8dSllai1 * manage /dev fs modules 500*facf4a8dSllai1 */ 501*facf4a8dSllai1 /*ARGSUSED*/ 502*facf4a8dSllai1 static int 503*facf4a8dSllai1 mod_infodev(struct modldev *modl, struct modlinkage *modlp, int *p0) 504*facf4a8dSllai1 { 505*facf4a8dSllai1 if (mod_getctl(modlp) == NULL) { 506*facf4a8dSllai1 *p0 = -1; 507*facf4a8dSllai1 return (0); /* module is not yet installed */ 508*facf4a8dSllai1 } 509*facf4a8dSllai1 510*facf4a8dSllai1 *p0 = 0; 511*facf4a8dSllai1 return (0); 512*facf4a8dSllai1 } 513*facf4a8dSllai1 514*facf4a8dSllai1 static int 515*facf4a8dSllai1 mod_installdev(struct modldev *modl, struct modlinkage *modlp) 516*facf4a8dSllai1 { 517*facf4a8dSllai1 struct modctl *mcp; 518*facf4a8dSllai1 519*facf4a8dSllai1 if ((mcp = mod_getctl(modlp)) == NULL) 520*facf4a8dSllai1 return (EINVAL); 521*facf4a8dSllai1 return (sdev_module_register(mcp->mod_modname, modl->dev_ops)); 522*facf4a8dSllai1 } 523*facf4a8dSllai1 524*facf4a8dSllai1 /* 525*facf4a8dSllai1 * /dev modules are not unloadable. 526*facf4a8dSllai1 */ 527*facf4a8dSllai1 /*ARGSUSED*/ 528*facf4a8dSllai1 static int 529*facf4a8dSllai1 mod_removedev(struct modldev *modl, struct modlinkage *modlp) 530*facf4a8dSllai1 { 531*facf4a8dSllai1 return (EBUSY); 532*facf4a8dSllai1 } 5337c478bd9Sstevel@tonic-gate 5347c478bd9Sstevel@tonic-gate /* 5357c478bd9Sstevel@tonic-gate * Install a new driver 5367c478bd9Sstevel@tonic-gate */ 5377c478bd9Sstevel@tonic-gate static int 5387c478bd9Sstevel@tonic-gate mod_installdrv(struct modldrv *modl, struct modlinkage *modlp) 5397c478bd9Sstevel@tonic-gate { 5407c478bd9Sstevel@tonic-gate struct modctl *mcp; 5417c478bd9Sstevel@tonic-gate struct dev_ops *ops; 5427c478bd9Sstevel@tonic-gate char *modname; 5437c478bd9Sstevel@tonic-gate major_t major; 5447c478bd9Sstevel@tonic-gate struct dev_ops *dp; 5457c478bd9Sstevel@tonic-gate struct devnames *dnp; 5467c478bd9Sstevel@tonic-gate struct streamtab *str; 5477c478bd9Sstevel@tonic-gate cdevsw_impl_t *cdp; 5487c478bd9Sstevel@tonic-gate uint_t sqtype; 5497c478bd9Sstevel@tonic-gate uint_t qflag; 5507c478bd9Sstevel@tonic-gate uint_t flag; 5517c478bd9Sstevel@tonic-gate int err = 0; 5527c478bd9Sstevel@tonic-gate 5537c478bd9Sstevel@tonic-gate /* sanity check module */ 5547c478bd9Sstevel@tonic-gate if ((mcp = mod_getctl(modlp)) == NULL) { 5557c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "mod_install: bad module linkage data"); 5567c478bd9Sstevel@tonic-gate err = ENXIO; 5577c478bd9Sstevel@tonic-gate goto done; 5587c478bd9Sstevel@tonic-gate } 5597c478bd9Sstevel@tonic-gate modname = mcp->mod_modname; 5607c478bd9Sstevel@tonic-gate 5617c478bd9Sstevel@tonic-gate /* Sanity check modname */ 5627c478bd9Sstevel@tonic-gate if ((major = ddi_name_to_major(modname)) == (major_t)-1) { 5637c478bd9Sstevel@tonic-gate #ifdef DEBUG 5647c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, 5657c478bd9Sstevel@tonic-gate "mod_installdrv: no major number for %s", modname); 5667c478bd9Sstevel@tonic-gate #endif 5677c478bd9Sstevel@tonic-gate err = ENXIO; 5687c478bd9Sstevel@tonic-gate goto done; 5697c478bd9Sstevel@tonic-gate } 5707c478bd9Sstevel@tonic-gate 5717c478bd9Sstevel@tonic-gate /* Verify MP safety flag */ 5727c478bd9Sstevel@tonic-gate ops = modl->drv_dev_ops; 5737c478bd9Sstevel@tonic-gate if (ops->devo_bus_ops == NULL && ops->devo_cb_ops != NULL && 5747c478bd9Sstevel@tonic-gate !(ops->devo_cb_ops->cb_flag & D_MP)) { 5757c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, 5767c478bd9Sstevel@tonic-gate "mod_installdrv: MT-unsafe driver '%s' rejected", modname); 5777c478bd9Sstevel@tonic-gate err = ENXIO; 5787c478bd9Sstevel@tonic-gate goto done; 5797c478bd9Sstevel@tonic-gate } 5807c478bd9Sstevel@tonic-gate 5817c478bd9Sstevel@tonic-gate 5827c478bd9Sstevel@tonic-gate /* Is bus_map_fault signature correct (version 8 and higher)? */ 5837c478bd9Sstevel@tonic-gate if (ops->devo_bus_ops != NULL && 5847c478bd9Sstevel@tonic-gate ops->devo_bus_ops->bus_map_fault != NULL && 5857c478bd9Sstevel@tonic-gate ops->devo_bus_ops->bus_map_fault != i_ddi_map_fault && 5867c478bd9Sstevel@tonic-gate ops->devo_bus_ops->busops_rev < BUSO_REV_8) { 5877c478bd9Sstevel@tonic-gate 5887c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, 5897c478bd9Sstevel@tonic-gate "mod_installdrv: busops' revision of '%s' is too low" 5907c478bd9Sstevel@tonic-gate " (must be at least 8)", modname); 5917c478bd9Sstevel@tonic-gate err = ENXIO; 5927c478bd9Sstevel@tonic-gate goto done; 5937c478bd9Sstevel@tonic-gate } 5947c478bd9Sstevel@tonic-gate 5957c478bd9Sstevel@tonic-gate 5967c478bd9Sstevel@tonic-gate /* Make sure the driver is uninstalled */ 5977c478bd9Sstevel@tonic-gate dnp = &devnamesp[major]; 5987c478bd9Sstevel@tonic-gate LOCK_DEV_OPS(&dnp->dn_lock); 5997c478bd9Sstevel@tonic-gate dp = devopsp[major]; 6007c478bd9Sstevel@tonic-gate 6017c478bd9Sstevel@tonic-gate if (dnp->dn_flags & DN_DRIVER_REMOVED) { 6027c478bd9Sstevel@tonic-gate #ifdef DEBUG 6037c478bd9Sstevel@tonic-gate cmn_err(CE_NOTE, 6047c478bd9Sstevel@tonic-gate "mod_installdrv: driver has been removed %s", modname); 6057c478bd9Sstevel@tonic-gate #endif 6067c478bd9Sstevel@tonic-gate err = ENXIO; 6077c478bd9Sstevel@tonic-gate goto unlock; 6087c478bd9Sstevel@tonic-gate } 6097c478bd9Sstevel@tonic-gate 6107c478bd9Sstevel@tonic-gate if (dp != &nodev_ops && dp != &mod_nodev_ops) { 6117c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, 6127c478bd9Sstevel@tonic-gate "mod_installdrv: driver already installed %s", modname); 6137c478bd9Sstevel@tonic-gate err = EALREADY; 6147c478bd9Sstevel@tonic-gate goto unlock; 6157c478bd9Sstevel@tonic-gate } 6167c478bd9Sstevel@tonic-gate 6177c478bd9Sstevel@tonic-gate devopsp[major] = ops; /* setup devopsp */ 6187c478bd9Sstevel@tonic-gate 6197c478bd9Sstevel@tonic-gate if ((str = STREAMSTAB(major)) != NULL) { /* streams driver */ 6207c478bd9Sstevel@tonic-gate flag = CBFLAG(major); 6217c478bd9Sstevel@tonic-gate if ((err = devflg_to_qflag(str, flag, &qflag, &sqtype)) != 0) 6227c478bd9Sstevel@tonic-gate goto unlock; 6237c478bd9Sstevel@tonic-gate cdp = &devimpl[major]; 6247c478bd9Sstevel@tonic-gate ASSERT(cdp->d_str == NULL); 6257c478bd9Sstevel@tonic-gate cdp->d_str = str; 6267c478bd9Sstevel@tonic-gate cdp->d_qflag = qflag | QISDRV; 6277c478bd9Sstevel@tonic-gate cdp->d_sqtype = sqtype; 6287c478bd9Sstevel@tonic-gate } 6297c478bd9Sstevel@tonic-gate 6307c478bd9Sstevel@tonic-gate if (ops->devo_bus_ops == NULL) 6317c478bd9Sstevel@tonic-gate dnp->dn_flags |= DN_LEAF_DRIVER; 6327c478bd9Sstevel@tonic-gate 6337c478bd9Sstevel@tonic-gate unlock: 6347c478bd9Sstevel@tonic-gate UNLOCK_DEV_OPS(&dnp->dn_lock); 6357c478bd9Sstevel@tonic-gate done: 6367c478bd9Sstevel@tonic-gate return (err); 6377c478bd9Sstevel@tonic-gate } 6387c478bd9Sstevel@tonic-gate 6397c478bd9Sstevel@tonic-gate static int 6407c478bd9Sstevel@tonic-gate mod_removedrv(struct modldrv *modl, struct modlinkage *modlp) 6417c478bd9Sstevel@tonic-gate { 6427c478bd9Sstevel@tonic-gate struct modctl *mcp; 6437c478bd9Sstevel@tonic-gate struct dev_ops *ops; 6447c478bd9Sstevel@tonic-gate struct devnames *dnp; 6457c478bd9Sstevel@tonic-gate struct dev_ops *dp; 6467c478bd9Sstevel@tonic-gate major_t major; 6477c478bd9Sstevel@tonic-gate char *modname; 6487c478bd9Sstevel@tonic-gate extern kthread_id_t mod_aul_thread; 6497c478bd9Sstevel@tonic-gate struct streamtab *str; 6507c478bd9Sstevel@tonic-gate cdevsw_impl_t *cdp; 6517c478bd9Sstevel@tonic-gate int err = 0; 6527c478bd9Sstevel@tonic-gate 6537c478bd9Sstevel@tonic-gate /* Don't auto unload modules on if moddebug flag is set */ 6547c478bd9Sstevel@tonic-gate if ((moddebug & MODDEBUG_NOAUL_DRV) && (mod_aul_thread == curthread)) { 6557c478bd9Sstevel@tonic-gate err = EBUSY; 6567c478bd9Sstevel@tonic-gate goto done; 6577c478bd9Sstevel@tonic-gate } 6587c478bd9Sstevel@tonic-gate 6597c478bd9Sstevel@tonic-gate /* Verify modname has a driver major */ 6607c478bd9Sstevel@tonic-gate mcp = mod_getctl(modlp); 6617c478bd9Sstevel@tonic-gate ASSERT(mcp != NULL); 6627c478bd9Sstevel@tonic-gate modname = mcp->mod_modname; 6637c478bd9Sstevel@tonic-gate 6647c478bd9Sstevel@tonic-gate if ((major = ddi_name_to_major(modname)) == -1) { 6657c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, uninstall_err, modname); 6667c478bd9Sstevel@tonic-gate err = EINVAL; 6677c478bd9Sstevel@tonic-gate goto done; 6687c478bd9Sstevel@tonic-gate } 6697c478bd9Sstevel@tonic-gate 6707c478bd9Sstevel@tonic-gate ops = modl->drv_dev_ops; 6717c478bd9Sstevel@tonic-gate dnp = &(devnamesp[major]); 6727c478bd9Sstevel@tonic-gate LOCK_DEV_OPS(&(dnp->dn_lock)); 6737c478bd9Sstevel@tonic-gate 6747c478bd9Sstevel@tonic-gate dp = devopsp[major]; 6757c478bd9Sstevel@tonic-gate 6767c478bd9Sstevel@tonic-gate if (dp != ops) { 6777c478bd9Sstevel@tonic-gate cmn_err(CE_NOTE, "mod_removedrv: mismatched driver for %s", 6787c478bd9Sstevel@tonic-gate modname); 6797c478bd9Sstevel@tonic-gate err = EBUSY; 6807c478bd9Sstevel@tonic-gate goto unlock; 6817c478bd9Sstevel@tonic-gate } 6827c478bd9Sstevel@tonic-gate 6837c478bd9Sstevel@tonic-gate /* 6847c478bd9Sstevel@tonic-gate * A driver is not unloadable if its dev_ops are held 6857c478bd9Sstevel@tonic-gate */ 6867c478bd9Sstevel@tonic-gate if (!DRV_UNLOADABLE(dp)) { 6877c478bd9Sstevel@tonic-gate mod_dprintf(DRV_DBG, "Cannot unload device driver <%s>," 6887c478bd9Sstevel@tonic-gate " refcnt %d\n", modname, dp->devo_refcnt); 6897c478bd9Sstevel@tonic-gate err = EBUSY; 6907c478bd9Sstevel@tonic-gate goto unlock; 6917c478bd9Sstevel@tonic-gate } 6927c478bd9Sstevel@tonic-gate 6937c478bd9Sstevel@tonic-gate /* 6947c478bd9Sstevel@tonic-gate * OK to unload. 6957c478bd9Sstevel@tonic-gate */ 6967c478bd9Sstevel@tonic-gate if ((str = STREAMSTAB(major)) != NULL) { /* streams driver */ 6977c478bd9Sstevel@tonic-gate cdp = &devimpl[major]; 6987c478bd9Sstevel@tonic-gate ASSERT(cdp->d_str == str); 6997c478bd9Sstevel@tonic-gate cdp->d_str = NULL; 7007c478bd9Sstevel@tonic-gate 7017c478bd9Sstevel@tonic-gate /* check for reference to per-dev syncq */ 7027c478bd9Sstevel@tonic-gate if (cdp->d_dmp != NULL) { 7037c478bd9Sstevel@tonic-gate rele_dm(cdp->d_dmp); 7047c478bd9Sstevel@tonic-gate cdp->d_dmp = NULL; 7057c478bd9Sstevel@tonic-gate } 7067c478bd9Sstevel@tonic-gate } 7077c478bd9Sstevel@tonic-gate 7087c478bd9Sstevel@tonic-gate devopsp[major] = &mod_nodev_ops; 7097c478bd9Sstevel@tonic-gate dnp->dn_flags &= ~(DN_DRIVER_HELD|DN_NO_AUTODETACH); 7107c478bd9Sstevel@tonic-gate 7117c478bd9Sstevel@tonic-gate unlock: 7127c478bd9Sstevel@tonic-gate UNLOCK_DEV_OPS(&(dnp->dn_lock)); 7137c478bd9Sstevel@tonic-gate done: 7147c478bd9Sstevel@tonic-gate return (err); 7157c478bd9Sstevel@tonic-gate } 7167c478bd9Sstevel@tonic-gate 7177c478bd9Sstevel@tonic-gate /* 7187c478bd9Sstevel@tonic-gate * System call subroutines 7197c478bd9Sstevel@tonic-gate */ 7207c478bd9Sstevel@tonic-gate 7217c478bd9Sstevel@tonic-gate /* 7227c478bd9Sstevel@tonic-gate * Compute system call number for given sysent and sysent table 7237c478bd9Sstevel@tonic-gate */ 7247c478bd9Sstevel@tonic-gate static int 7257c478bd9Sstevel@tonic-gate mod_infosysnum(struct modlinkage *modlp, struct sysent table[]) 7267c478bd9Sstevel@tonic-gate { 7277c478bd9Sstevel@tonic-gate struct sysent *sysp; 7287c478bd9Sstevel@tonic-gate 7297c478bd9Sstevel@tonic-gate if ((sysp = mod_getsysent(modlp, table)) == NULL) 7307c478bd9Sstevel@tonic-gate return (-1); 7317c478bd9Sstevel@tonic-gate return ((int)(sysp - table)); 7327c478bd9Sstevel@tonic-gate } 7337c478bd9Sstevel@tonic-gate 7347c478bd9Sstevel@tonic-gate /* 7357c478bd9Sstevel@tonic-gate * Put a loadable system call entry into a sysent table. 7367c478bd9Sstevel@tonic-gate */ 7377c478bd9Sstevel@tonic-gate static int 7387c478bd9Sstevel@tonic-gate mod_installsys_sysent( 7397c478bd9Sstevel@tonic-gate struct modlsys *modl, 7407c478bd9Sstevel@tonic-gate struct modlinkage *modlp, 7417c478bd9Sstevel@tonic-gate struct sysent table[]) 7427c478bd9Sstevel@tonic-gate { 7437c478bd9Sstevel@tonic-gate struct sysent *sysp; 7447c478bd9Sstevel@tonic-gate struct sysent *mp; 7457c478bd9Sstevel@tonic-gate 7467c478bd9Sstevel@tonic-gate #ifdef DEBUG 7477c478bd9Sstevel@tonic-gate /* 7487c478bd9Sstevel@tonic-gate * Before we even play with the sysent table, sanity check the 7497c478bd9Sstevel@tonic-gate * incoming flags to make sure the entry is valid 7507c478bd9Sstevel@tonic-gate */ 7517c478bd9Sstevel@tonic-gate switch (modl->sys_sysent->sy_flags & SE_RVAL_MASK) { 7527c478bd9Sstevel@tonic-gate case SE_32RVAL1: 7537c478bd9Sstevel@tonic-gate /* only r_val1 returned */ 7547c478bd9Sstevel@tonic-gate case SE_32RVAL1 | SE_32RVAL2: 7557c478bd9Sstevel@tonic-gate /* r_val1 and r_val2 returned */ 7567c478bd9Sstevel@tonic-gate case SE_64RVAL: 7577c478bd9Sstevel@tonic-gate /* 64-bit rval returned */ 7587c478bd9Sstevel@tonic-gate break; 7597c478bd9Sstevel@tonic-gate default: 7607c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "loadable syscall: %p: bad rval flags %x", 7617c478bd9Sstevel@tonic-gate (void *)modl, modl->sys_sysent->sy_flags); 7627c478bd9Sstevel@tonic-gate return (ENOSYS); 7637c478bd9Sstevel@tonic-gate } 7647c478bd9Sstevel@tonic-gate #endif 7657c478bd9Sstevel@tonic-gate if ((sysp = mod_getsysent(modlp, table)) == NULL) 7667c478bd9Sstevel@tonic-gate return (ENOSPC); 7677c478bd9Sstevel@tonic-gate 7687c478bd9Sstevel@tonic-gate /* 7697c478bd9Sstevel@tonic-gate * We should only block here until the reader in syscall gives 7707c478bd9Sstevel@tonic-gate * up the lock. Multiple writers are prevented in the mod layer. 7717c478bd9Sstevel@tonic-gate */ 7727c478bd9Sstevel@tonic-gate rw_enter(sysp->sy_lock, RW_WRITER); 7737c478bd9Sstevel@tonic-gate mp = modl->sys_sysent; 7747c478bd9Sstevel@tonic-gate sysp->sy_narg = mp->sy_narg; 7757c478bd9Sstevel@tonic-gate sysp->sy_call = mp->sy_call; 7767c478bd9Sstevel@tonic-gate 7777c478bd9Sstevel@tonic-gate /* 7787c478bd9Sstevel@tonic-gate * clear the old call method flag, and get the new one from the module. 7797c478bd9Sstevel@tonic-gate */ 7807c478bd9Sstevel@tonic-gate sysp->sy_flags &= ~SE_ARGC; 7817c478bd9Sstevel@tonic-gate sysp->sy_flags |= SE_LOADED | 7827c478bd9Sstevel@tonic-gate (mp->sy_flags & (SE_ARGC | SE_NOUNLOAD | SE_RVAL_MASK)); 7837c478bd9Sstevel@tonic-gate 7847c478bd9Sstevel@tonic-gate /* 7857c478bd9Sstevel@tonic-gate * If the syscall doesn't need or want unloading, it can avoid 7867c478bd9Sstevel@tonic-gate * the locking overhead on each entry. Convert the sysent to a 7877c478bd9Sstevel@tonic-gate * normal non-loadable entry in that case. 7887c478bd9Sstevel@tonic-gate */ 7897c478bd9Sstevel@tonic-gate if (mp->sy_flags & SE_NOUNLOAD) { 7907c478bd9Sstevel@tonic-gate if (mp->sy_flags & SE_ARGC) { 7917c478bd9Sstevel@tonic-gate sysp->sy_callc = (int64_t (*)())mp->sy_call; 7927c478bd9Sstevel@tonic-gate } else { 7937c478bd9Sstevel@tonic-gate sysp->sy_callc = syscall_ap; 7947c478bd9Sstevel@tonic-gate } 7957c478bd9Sstevel@tonic-gate sysp->sy_flags &= ~SE_LOADABLE; 7967c478bd9Sstevel@tonic-gate } 7977c478bd9Sstevel@tonic-gate rw_exit(sysp->sy_lock); 7987c478bd9Sstevel@tonic-gate return (0); 7997c478bd9Sstevel@tonic-gate } 8007c478bd9Sstevel@tonic-gate 8017c478bd9Sstevel@tonic-gate /* 8027c478bd9Sstevel@tonic-gate * Remove a loadable system call entry from a sysent table. 8037c478bd9Sstevel@tonic-gate */ 8047c478bd9Sstevel@tonic-gate static int 8057c478bd9Sstevel@tonic-gate mod_removesys_sysent( 8067c478bd9Sstevel@tonic-gate struct modlsys *modl, 8077c478bd9Sstevel@tonic-gate struct modlinkage *modlp, 8087c478bd9Sstevel@tonic-gate struct sysent table[]) 8097c478bd9Sstevel@tonic-gate { 8107c478bd9Sstevel@tonic-gate struct sysent *sysp; 8117c478bd9Sstevel@tonic-gate 8127c478bd9Sstevel@tonic-gate if ((sysp = mod_getsysent(modlp, table)) == NULL || 8137c478bd9Sstevel@tonic-gate (sysp->sy_flags & (SE_LOADABLE | SE_NOUNLOAD)) == 0 || 8147c478bd9Sstevel@tonic-gate sysp->sy_call != modl->sys_sysent->sy_call) { 8157c478bd9Sstevel@tonic-gate 8167c478bd9Sstevel@tonic-gate struct modctl *mcp = mod_getctl(modlp); 8177c478bd9Sstevel@tonic-gate char *modname = mcp->mod_modname; 8187c478bd9Sstevel@tonic-gate 8197c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, uninstall_err, modname); 8207c478bd9Sstevel@tonic-gate return (EINVAL); 8217c478bd9Sstevel@tonic-gate } 8227c478bd9Sstevel@tonic-gate 8237c478bd9Sstevel@tonic-gate /* If we can't get the write lock, we can't unlink from the system */ 8247c478bd9Sstevel@tonic-gate 8257c478bd9Sstevel@tonic-gate if (!(moddebug & MODDEBUG_NOAUL_SYS) && 8267c478bd9Sstevel@tonic-gate rw_tryenter(sysp->sy_lock, RW_WRITER)) { 8277c478bd9Sstevel@tonic-gate /* 8287c478bd9Sstevel@tonic-gate * Check the flags to be sure the syscall is still 8297c478bd9Sstevel@tonic-gate * (un)loadable. 8307c478bd9Sstevel@tonic-gate * If SE_NOUNLOAD is set, SE_LOADABLE will not be. 8317c478bd9Sstevel@tonic-gate */ 8327c478bd9Sstevel@tonic-gate if ((sysp->sy_flags & (SE_LOADED | SE_LOADABLE)) == 8337c478bd9Sstevel@tonic-gate (SE_LOADED | SE_LOADABLE)) { 8347c478bd9Sstevel@tonic-gate sysp->sy_flags &= ~SE_LOADED; 8357c478bd9Sstevel@tonic-gate sysp->sy_callc = loadable_syscall; 8367c478bd9Sstevel@tonic-gate sysp->sy_call = (int (*)())nosys; 8377c478bd9Sstevel@tonic-gate rw_exit(sysp->sy_lock); 8387c478bd9Sstevel@tonic-gate return (0); 8397c478bd9Sstevel@tonic-gate } 8407c478bd9Sstevel@tonic-gate rw_exit(sysp->sy_lock); 8417c478bd9Sstevel@tonic-gate } 8427c478bd9Sstevel@tonic-gate return (EBUSY); 8437c478bd9Sstevel@tonic-gate } 8447c478bd9Sstevel@tonic-gate 8457c478bd9Sstevel@tonic-gate /* 8467c478bd9Sstevel@tonic-gate * System call status info 8477c478bd9Sstevel@tonic-gate */ 8487c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 8497c478bd9Sstevel@tonic-gate static int 8507c478bd9Sstevel@tonic-gate mod_infosys(struct modlsys *modl, struct modlinkage *modlp, int *p0) 8517c478bd9Sstevel@tonic-gate { 8527c478bd9Sstevel@tonic-gate *p0 = mod_infosysnum(modlp, sysent); 8537c478bd9Sstevel@tonic-gate return (0); 8547c478bd9Sstevel@tonic-gate } 8557c478bd9Sstevel@tonic-gate 8567c478bd9Sstevel@tonic-gate /* 8577c478bd9Sstevel@tonic-gate * Link a system call into the system by setting the proper sysent entry. 8587c478bd9Sstevel@tonic-gate * Called from the module's _init routine. 8597c478bd9Sstevel@tonic-gate */ 8607c478bd9Sstevel@tonic-gate static int 8617c478bd9Sstevel@tonic-gate mod_installsys(struct modlsys *modl, struct modlinkage *modlp) 8627c478bd9Sstevel@tonic-gate { 8637c478bd9Sstevel@tonic-gate return (mod_installsys_sysent(modl, modlp, sysent)); 8647c478bd9Sstevel@tonic-gate } 8657c478bd9Sstevel@tonic-gate 8667c478bd9Sstevel@tonic-gate /* 8677c478bd9Sstevel@tonic-gate * Unlink a system call from the system. 8687c478bd9Sstevel@tonic-gate * Called from a modules _fini routine. 8697c478bd9Sstevel@tonic-gate */ 8707c478bd9Sstevel@tonic-gate static int 8717c478bd9Sstevel@tonic-gate mod_removesys(struct modlsys *modl, struct modlinkage *modlp) 8727c478bd9Sstevel@tonic-gate { 8737c478bd9Sstevel@tonic-gate return (mod_removesys_sysent(modl, modlp, sysent)); 8747c478bd9Sstevel@tonic-gate } 8757c478bd9Sstevel@tonic-gate 8767c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 8777c478bd9Sstevel@tonic-gate 8787c478bd9Sstevel@tonic-gate /* 8797c478bd9Sstevel@tonic-gate * 32-bit system call status info 8807c478bd9Sstevel@tonic-gate */ 8817c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 8827c478bd9Sstevel@tonic-gate static int 8837c478bd9Sstevel@tonic-gate mod_infosys32(struct modlsys *modl, struct modlinkage *modlp, int *p0) 8847c478bd9Sstevel@tonic-gate { 8857c478bd9Sstevel@tonic-gate *p0 = mod_infosysnum(modlp, sysent32); 8867c478bd9Sstevel@tonic-gate return (0); 8877c478bd9Sstevel@tonic-gate } 8887c478bd9Sstevel@tonic-gate 8897c478bd9Sstevel@tonic-gate /* 8907c478bd9Sstevel@tonic-gate * Link the 32-bit syscall into the system by setting the proper sysent entry. 8917c478bd9Sstevel@tonic-gate * Also called from the module's _init routine. 8927c478bd9Sstevel@tonic-gate */ 8937c478bd9Sstevel@tonic-gate static int 8947c478bd9Sstevel@tonic-gate mod_installsys32(struct modlsys *modl, struct modlinkage *modlp) 8957c478bd9Sstevel@tonic-gate { 8967c478bd9Sstevel@tonic-gate return (mod_installsys_sysent(modl, modlp, sysent32)); 8977c478bd9Sstevel@tonic-gate } 8987c478bd9Sstevel@tonic-gate 8997c478bd9Sstevel@tonic-gate /* 9007c478bd9Sstevel@tonic-gate * Unlink the 32-bit flavor of a system call from the system. 9017c478bd9Sstevel@tonic-gate * Also called from a module's _fini routine. 9027c478bd9Sstevel@tonic-gate */ 9037c478bd9Sstevel@tonic-gate static int 9047c478bd9Sstevel@tonic-gate mod_removesys32(struct modlsys *modl, struct modlinkage *modlp) 9057c478bd9Sstevel@tonic-gate { 9067c478bd9Sstevel@tonic-gate return (mod_removesys_sysent(modl, modlp, sysent32)); 9077c478bd9Sstevel@tonic-gate } 9087c478bd9Sstevel@tonic-gate 9097c478bd9Sstevel@tonic-gate #endif /* _SYSCALL32_IMPL */ 9107c478bd9Sstevel@tonic-gate 9117c478bd9Sstevel@tonic-gate /* 9127c478bd9Sstevel@tonic-gate * Filesystem status info 9137c478bd9Sstevel@tonic-gate */ 9147c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 9157c478bd9Sstevel@tonic-gate static int 9167c478bd9Sstevel@tonic-gate mod_infofs(struct modlfs *modl, struct modlinkage *modlp, int *p0) 9177c478bd9Sstevel@tonic-gate { 9187c478bd9Sstevel@tonic-gate struct vfssw *vswp; 9197c478bd9Sstevel@tonic-gate 9207c478bd9Sstevel@tonic-gate RLOCK_VFSSW(); 9217c478bd9Sstevel@tonic-gate if ((vswp = vfs_getvfsswbyname(modl->fs_vfsdef->name)) == NULL) 9227c478bd9Sstevel@tonic-gate *p0 = -1; 9237c478bd9Sstevel@tonic-gate else { 9247c478bd9Sstevel@tonic-gate *p0 = vswp - vfssw; 9257c478bd9Sstevel@tonic-gate vfs_unrefvfssw(vswp); 9267c478bd9Sstevel@tonic-gate } 9277c478bd9Sstevel@tonic-gate RUNLOCK_VFSSW(); 9287c478bd9Sstevel@tonic-gate return (0); 9297c478bd9Sstevel@tonic-gate } 9307c478bd9Sstevel@tonic-gate 9317c478bd9Sstevel@tonic-gate /* 9327c478bd9Sstevel@tonic-gate * Install a filesystem. 9337c478bd9Sstevel@tonic-gate */ 9347c478bd9Sstevel@tonic-gate /*ARGSUSED1*/ 9357c478bd9Sstevel@tonic-gate static int 9367c478bd9Sstevel@tonic-gate mod_installfs(struct modlfs *modl, struct modlinkage *modlp) 9377c478bd9Sstevel@tonic-gate { 9387c478bd9Sstevel@tonic-gate struct vfssw *vswp; 9397c478bd9Sstevel@tonic-gate struct modctl *mcp; 9407c478bd9Sstevel@tonic-gate char *fsname; 9415a59a8b3Srsb char ksname[KSTAT_STRLEN + 1]; 9425a59a8b3Srsb int fstype; /* index into vfssw[] and vsanchor_fstype[] */ 9437c478bd9Sstevel@tonic-gate int allocated; 9447c478bd9Sstevel@tonic-gate int err; 9455a59a8b3Srsb int vsw_stats_enabled; 9465a59a8b3Srsb /* Not for public consumption so these aren't in a header file */ 9475a59a8b3Srsb extern int vopstats_enabled; 9485a59a8b3Srsb extern vopstats_t **vopstats_fstype; 9495a59a8b3Srsb extern kstat_t *new_vskstat(char *, vopstats_t *); 9505a59a8b3Srsb extern void initialize_vopstats(vopstats_t *); 9517c478bd9Sstevel@tonic-gate 9527c478bd9Sstevel@tonic-gate if (modl->fs_vfsdef->def_version == VFSDEF_VERSION) { 9537c478bd9Sstevel@tonic-gate /* Version matched */ 9547c478bd9Sstevel@tonic-gate fsname = modl->fs_vfsdef->name; 9557c478bd9Sstevel@tonic-gate } else { 9567c478bd9Sstevel@tonic-gate if ((modl->fs_vfsdef->def_version > 0) && 9577c478bd9Sstevel@tonic-gate (modl->fs_vfsdef->def_version < VFSDEF_VERSION)) { 9587c478bd9Sstevel@tonic-gate /* Older VFSDEF_VERSION */ 9597c478bd9Sstevel@tonic-gate fsname = modl->fs_vfsdef->name; 9607c478bd9Sstevel@tonic-gate } else if ((mcp = mod_getctl(modlp)) != NULL) { 9617c478bd9Sstevel@tonic-gate /* Pre-VFSDEF_VERSION */ 9627c478bd9Sstevel@tonic-gate fsname = mcp->mod_modname; 9637c478bd9Sstevel@tonic-gate } else { 9647c478bd9Sstevel@tonic-gate /* If all else fails... */ 9657c478bd9Sstevel@tonic-gate fsname = "<unknown file system type>"; 9667c478bd9Sstevel@tonic-gate } 9677c478bd9Sstevel@tonic-gate 9687c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "file system '%s' version mismatch", fsname); 9697c478bd9Sstevel@tonic-gate return (ENXIO); 9707c478bd9Sstevel@tonic-gate } 9717c478bd9Sstevel@tonic-gate 9727c478bd9Sstevel@tonic-gate allocated = 0; 9737c478bd9Sstevel@tonic-gate 9747c478bd9Sstevel@tonic-gate WLOCK_VFSSW(); 9757c478bd9Sstevel@tonic-gate if ((vswp = vfs_getvfsswbyname(fsname)) == NULL) { 9767c478bd9Sstevel@tonic-gate if ((vswp = allocate_vfssw(fsname)) == NULL) { 9777c478bd9Sstevel@tonic-gate WUNLOCK_VFSSW(); 9787c478bd9Sstevel@tonic-gate /* 9797c478bd9Sstevel@tonic-gate * See 1095689. If this message appears, then 9807c478bd9Sstevel@tonic-gate * we either need to make the vfssw table bigger 9817c478bd9Sstevel@tonic-gate * statically, or make it grow dynamically. 9827c478bd9Sstevel@tonic-gate */ 9837c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "no room for '%s' in vfssw!", fsname); 9847c478bd9Sstevel@tonic-gate return (ENXIO); 9857c478bd9Sstevel@tonic-gate } 9867c478bd9Sstevel@tonic-gate allocated = 1; 9877c478bd9Sstevel@tonic-gate } 9887c478bd9Sstevel@tonic-gate ASSERT(vswp != NULL); 9897c478bd9Sstevel@tonic-gate 9905a59a8b3Srsb fstype = vswp - vfssw; /* Pointer arithmetic to get the fstype */ 9915a59a8b3Srsb 9925a59a8b3Srsb /* Turn on everything by default *except* VSW_STATS */ 9935a59a8b3Srsb vswp->vsw_flag = modl->fs_vfsdef->flags & ~(VSW_STATS); 9945a59a8b3Srsb 9957c478bd9Sstevel@tonic-gate if (modl->fs_vfsdef->flags & VSW_HASPROTO) { 9967c478bd9Sstevel@tonic-gate vfs_mergeopttbl(&vfs_mntopts, modl->fs_vfsdef->optproto, 9977c478bd9Sstevel@tonic-gate &vswp->vsw_optproto); 9987c478bd9Sstevel@tonic-gate } else { 9997c478bd9Sstevel@tonic-gate vfs_copyopttbl(&vfs_mntopts, &vswp->vsw_optproto); 10007c478bd9Sstevel@tonic-gate } 10017c478bd9Sstevel@tonic-gate 10027c478bd9Sstevel@tonic-gate if (modl->fs_vfsdef->flags & VSW_CANRWRO) { 10037c478bd9Sstevel@tonic-gate /* 10047c478bd9Sstevel@tonic-gate * This obviously implies VSW_CANREMOUNT. 10057c478bd9Sstevel@tonic-gate */ 10067c478bd9Sstevel@tonic-gate vswp->vsw_flag |= VSW_CANREMOUNT; 10077c478bd9Sstevel@tonic-gate } 10085a59a8b3Srsb 10095a59a8b3Srsb /* 10105a59a8b3Srsb * If stats are enabled system wide and for this fstype, then 10115a59a8b3Srsb * set the VSW_STATS flag in the proper vfssw[] table entry. 10125a59a8b3Srsb */ 10135a59a8b3Srsb if (vopstats_enabled && modl->fs_vfsdef->flags & VSW_STATS) { 10145a59a8b3Srsb vswp->vsw_flag |= VSW_STATS; 10155a59a8b3Srsb } 10165a59a8b3Srsb 10177c478bd9Sstevel@tonic-gate if (modl->fs_vfsdef->init == NULL) 10187c478bd9Sstevel@tonic-gate err = EFAULT; 10197c478bd9Sstevel@tonic-gate else 10205a59a8b3Srsb err = (*(modl->fs_vfsdef->init))(fstype, fsname); 10217c478bd9Sstevel@tonic-gate 10227c478bd9Sstevel@tonic-gate if (err != 0) { 10237c478bd9Sstevel@tonic-gate if (allocated) { 10247c478bd9Sstevel@tonic-gate kmem_free(vswp->vsw_name, strlen(vswp->vsw_name)+1); 10257c478bd9Sstevel@tonic-gate vswp->vsw_name = ""; 10267c478bd9Sstevel@tonic-gate } 10277c478bd9Sstevel@tonic-gate vswp->vsw_flag = 0; 10287c478bd9Sstevel@tonic-gate vswp->vsw_init = NULL; 10297c478bd9Sstevel@tonic-gate } 10307c478bd9Sstevel@tonic-gate 10315a59a8b3Srsb /* We don't want to hold the vfssw[] write lock over a kmem_alloc() */ 10325a59a8b3Srsb vsw_stats_enabled = vswp->vsw_flag & VSW_STATS; 10335a59a8b3Srsb 10347c478bd9Sstevel@tonic-gate vfs_unrefvfssw(vswp); 10357c478bd9Sstevel@tonic-gate WUNLOCK_VFSSW(); 10367c478bd9Sstevel@tonic-gate 10375a59a8b3Srsb /* If everything is on, set up the per-fstype vopstats */ 10385a59a8b3Srsb if (vsw_stats_enabled && vopstats_enabled && 10395a59a8b3Srsb vopstats_fstype && vopstats_fstype[fstype] == NULL) { 10405a59a8b3Srsb (void) strlcpy(ksname, VOPSTATS_STR, sizeof (ksname)); 10415a59a8b3Srsb (void) strlcat(ksname, vfssw[fstype].vsw_name, sizeof (ksname)); 10425a59a8b3Srsb vopstats_fstype[fstype] = 10435a59a8b3Srsb kmem_alloc(sizeof (vopstats_t), KM_SLEEP); 10445a59a8b3Srsb initialize_vopstats(vopstats_fstype[fstype]); 10455a59a8b3Srsb (void) new_vskstat(ksname, vopstats_fstype[fstype]); 10465a59a8b3Srsb } 10477c478bd9Sstevel@tonic-gate return (err); 10487c478bd9Sstevel@tonic-gate } 10497c478bd9Sstevel@tonic-gate 10507c478bd9Sstevel@tonic-gate /* 10517c478bd9Sstevel@tonic-gate * Remove a filesystem 10527c478bd9Sstevel@tonic-gate */ 10537c478bd9Sstevel@tonic-gate static int 10547c478bd9Sstevel@tonic-gate mod_removefs(struct modlfs *modl, struct modlinkage *modlp) 10557c478bd9Sstevel@tonic-gate { 10567c478bd9Sstevel@tonic-gate struct vfssw *vswp; 10577c478bd9Sstevel@tonic-gate struct modctl *mcp; 10587c478bd9Sstevel@tonic-gate char *modname; 10597c478bd9Sstevel@tonic-gate 10607c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_NOAUL_FS) 10617c478bd9Sstevel@tonic-gate return (EBUSY); 10627c478bd9Sstevel@tonic-gate 10637c478bd9Sstevel@tonic-gate WLOCK_VFSSW(); 10647c478bd9Sstevel@tonic-gate if ((vswp = vfs_getvfsswbyname(modl->fs_vfsdef->name)) == NULL) { 10657c478bd9Sstevel@tonic-gate mcp = mod_getctl(modlp); 10667c478bd9Sstevel@tonic-gate ASSERT(mcp != NULL); 10677c478bd9Sstevel@tonic-gate modname = mcp->mod_modname; 10687c478bd9Sstevel@tonic-gate WUNLOCK_VFSSW(); 10697c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, uninstall_err, modname); 10707c478bd9Sstevel@tonic-gate return (EINVAL); 10717c478bd9Sstevel@tonic-gate } 10727c478bd9Sstevel@tonic-gate if (vswp->vsw_count != 1) { 10737c478bd9Sstevel@tonic-gate vfs_unrefvfssw(vswp); 10747c478bd9Sstevel@tonic-gate WUNLOCK_VFSSW(); 10757c478bd9Sstevel@tonic-gate return (EBUSY); 10767c478bd9Sstevel@tonic-gate } 10777c478bd9Sstevel@tonic-gate 10787c478bd9Sstevel@tonic-gate /* XXX - Shouldn't the refcount be sufficient? */ 10797c478bd9Sstevel@tonic-gate 10807c478bd9Sstevel@tonic-gate if (vfs_opsinuse(&vswp->vsw_vfsops)) { 1081d397866eSsp92102 vfs_unrefvfssw(vswp); 10827c478bd9Sstevel@tonic-gate WUNLOCK_VFSSW(); 10837c478bd9Sstevel@tonic-gate return (EBUSY); 10847c478bd9Sstevel@tonic-gate } 10857c478bd9Sstevel@tonic-gate 10867c478bd9Sstevel@tonic-gate vfs_freeopttbl(&vswp->vsw_optproto); 10877c478bd9Sstevel@tonic-gate vswp->vsw_optproto.mo_count = 0; 10887c478bd9Sstevel@tonic-gate 10897c478bd9Sstevel@tonic-gate vswp->vsw_flag = 0; 10907c478bd9Sstevel@tonic-gate vswp->vsw_init = NULL; 10917c478bd9Sstevel@tonic-gate vfs_unrefvfssw(vswp); 10927c478bd9Sstevel@tonic-gate WUNLOCK_VFSSW(); 10937c478bd9Sstevel@tonic-gate return (0); 10947c478bd9Sstevel@tonic-gate } 10957c478bd9Sstevel@tonic-gate 10967c478bd9Sstevel@tonic-gate /* 10977c478bd9Sstevel@tonic-gate * Get status of a streams module. 10987c478bd9Sstevel@tonic-gate */ 10997c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 11007c478bd9Sstevel@tonic-gate static int 11017c478bd9Sstevel@tonic-gate mod_infostrmod(struct modlstrmod *modl, struct modlinkage *modlp, int *p0) 11027c478bd9Sstevel@tonic-gate { 11037c478bd9Sstevel@tonic-gate *p0 = -1; /* no useful info */ 11047c478bd9Sstevel@tonic-gate return (0); 11057c478bd9Sstevel@tonic-gate } 11067c478bd9Sstevel@tonic-gate 11077c478bd9Sstevel@tonic-gate 11087c478bd9Sstevel@tonic-gate /* 11097c478bd9Sstevel@tonic-gate * Install a streams module. 11107c478bd9Sstevel@tonic-gate */ 11117c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 11127c478bd9Sstevel@tonic-gate static int 11137c478bd9Sstevel@tonic-gate mod_installstrmod(struct modlstrmod *modl, struct modlinkage *modlp) 11147c478bd9Sstevel@tonic-gate { 11157c478bd9Sstevel@tonic-gate struct fmodsw *fp = modl->strmod_fmodsw; 11167c478bd9Sstevel@tonic-gate 11177c478bd9Sstevel@tonic-gate if (!(fp->f_flag & D_MP)) { 11187c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "mod_install: MT-unsafe strmod '%s' rejected", 11197c478bd9Sstevel@tonic-gate fp->f_name); 11207c478bd9Sstevel@tonic-gate return (ENXIO); 11217c478bd9Sstevel@tonic-gate } 11227c478bd9Sstevel@tonic-gate 11237c478bd9Sstevel@tonic-gate return (fmodsw_register(fp->f_name, fp->f_str, fp->f_flag)); 11247c478bd9Sstevel@tonic-gate } 11257c478bd9Sstevel@tonic-gate 11267c478bd9Sstevel@tonic-gate /* 11277c478bd9Sstevel@tonic-gate * Remove a streams module. 11287c478bd9Sstevel@tonic-gate */ 11297c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 11307c478bd9Sstevel@tonic-gate static int 11317c478bd9Sstevel@tonic-gate mod_removestrmod(struct modlstrmod *modl, struct modlinkage *modlp) 11327c478bd9Sstevel@tonic-gate { 11337c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_NOAUL_STR) 11347c478bd9Sstevel@tonic-gate return (EBUSY); 11357c478bd9Sstevel@tonic-gate 11367c478bd9Sstevel@tonic-gate return (fmodsw_unregister(modl->strmod_fmodsw->f_name)); 11377c478bd9Sstevel@tonic-gate } 11387c478bd9Sstevel@tonic-gate 11397c478bd9Sstevel@tonic-gate /* 11407c478bd9Sstevel@tonic-gate * Get status of a scheduling class module. 11417c478bd9Sstevel@tonic-gate */ 11427c478bd9Sstevel@tonic-gate /*ARGSUSED1*/ 11437c478bd9Sstevel@tonic-gate static int 11447c478bd9Sstevel@tonic-gate mod_infosched(struct modlsched *modl, struct modlinkage *modlp, int *p0) 11457c478bd9Sstevel@tonic-gate { 11467c478bd9Sstevel@tonic-gate int status; 11477c478bd9Sstevel@tonic-gate auto id_t cid; 11487c478bd9Sstevel@tonic-gate 11497c478bd9Sstevel@tonic-gate status = getcidbyname(modl->sched_class->cl_name, &cid); 11507c478bd9Sstevel@tonic-gate 11517c478bd9Sstevel@tonic-gate if (status != 0) 11527c478bd9Sstevel@tonic-gate *p0 = -1; 11537c478bd9Sstevel@tonic-gate else 11547c478bd9Sstevel@tonic-gate *p0 = cid; 11557c478bd9Sstevel@tonic-gate 11567c478bd9Sstevel@tonic-gate return (0); 11577c478bd9Sstevel@tonic-gate } 11587c478bd9Sstevel@tonic-gate 11597c478bd9Sstevel@tonic-gate /* 11607c478bd9Sstevel@tonic-gate * Install a scheduling class module. 11617c478bd9Sstevel@tonic-gate */ 11627c478bd9Sstevel@tonic-gate /*ARGSUSED1*/ 11637c478bd9Sstevel@tonic-gate static int 11647c478bd9Sstevel@tonic-gate mod_installsched(struct modlsched *modl, struct modlinkage *modlp) 11657c478bd9Sstevel@tonic-gate { 11667c478bd9Sstevel@tonic-gate sclass_t *clp; 11677c478bd9Sstevel@tonic-gate int status; 11687c478bd9Sstevel@tonic-gate id_t cid; 11697c478bd9Sstevel@tonic-gate 11707c478bd9Sstevel@tonic-gate /* 11717c478bd9Sstevel@tonic-gate * See if module is already installed. 11727c478bd9Sstevel@tonic-gate */ 11737c478bd9Sstevel@tonic-gate mutex_enter(&class_lock); 11747c478bd9Sstevel@tonic-gate status = alloc_cid(modl->sched_class->cl_name, &cid); 11757c478bd9Sstevel@tonic-gate mutex_exit(&class_lock); 11767c478bd9Sstevel@tonic-gate ASSERT(status == 0); 11777c478bd9Sstevel@tonic-gate clp = &sclass[cid]; 11787c478bd9Sstevel@tonic-gate rw_enter(clp->cl_lock, RW_WRITER); 11797c478bd9Sstevel@tonic-gate if (SCHED_INSTALLED(clp)) { 11807c478bd9Sstevel@tonic-gate printf("scheduling class %s is already installed\n", 11817c478bd9Sstevel@tonic-gate modl->sched_class->cl_name); 11827c478bd9Sstevel@tonic-gate rw_exit(clp->cl_lock); 11837c478bd9Sstevel@tonic-gate return (EBUSY); /* it's already there */ 11847c478bd9Sstevel@tonic-gate } 11857c478bd9Sstevel@tonic-gate 11867c478bd9Sstevel@tonic-gate clp->cl_init = modl->sched_class->cl_init; 11877c478bd9Sstevel@tonic-gate clp->cl_funcs = modl->sched_class->cl_funcs; 11887c478bd9Sstevel@tonic-gate modl->sched_class = clp; 11897c478bd9Sstevel@tonic-gate disp_add(clp); 11907c478bd9Sstevel@tonic-gate loaded_classes++; /* for priocntl system call */ 11917c478bd9Sstevel@tonic-gate rw_exit(clp->cl_lock); 11927c478bd9Sstevel@tonic-gate return (0); 11937c478bd9Sstevel@tonic-gate } 11947c478bd9Sstevel@tonic-gate 11957c478bd9Sstevel@tonic-gate /* 11967c478bd9Sstevel@tonic-gate * Remove a scheduling class module. 11977c478bd9Sstevel@tonic-gate * 11987c478bd9Sstevel@tonic-gate * we only null out the init func and the class functions because 11997c478bd9Sstevel@tonic-gate * once a class has been loaded it has that slot in the class 12007c478bd9Sstevel@tonic-gate * array until the next reboot. We don't decrement loaded_classes 12017c478bd9Sstevel@tonic-gate * because this keeps count of the number of classes that have 12027c478bd9Sstevel@tonic-gate * been loaded for this session. It will have to be this way until 12037c478bd9Sstevel@tonic-gate * we implement the class array as a linked list and do true 12047c478bd9Sstevel@tonic-gate * dynamic allocation. 12057c478bd9Sstevel@tonic-gate */ 12067c478bd9Sstevel@tonic-gate static int 12077c478bd9Sstevel@tonic-gate mod_removesched(struct modlsched *modl, struct modlinkage *modlp) 12087c478bd9Sstevel@tonic-gate { 12097c478bd9Sstevel@tonic-gate int status; 12107c478bd9Sstevel@tonic-gate sclass_t *clp; 12117c478bd9Sstevel@tonic-gate struct modctl *mcp; 12127c478bd9Sstevel@tonic-gate char *modname; 12137c478bd9Sstevel@tonic-gate id_t cid; 12147c478bd9Sstevel@tonic-gate 12157c478bd9Sstevel@tonic-gate status = getcidbyname(modl->sched_class->cl_name, &cid); 12167c478bd9Sstevel@tonic-gate if (status != 0) { 12177c478bd9Sstevel@tonic-gate mcp = mod_getctl(modlp); 12187c478bd9Sstevel@tonic-gate ASSERT(mcp != NULL); 12197c478bd9Sstevel@tonic-gate modname = mcp->mod_modname; 12207c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, uninstall_err, modname); 12217c478bd9Sstevel@tonic-gate return (EINVAL); 12227c478bd9Sstevel@tonic-gate } 12237c478bd9Sstevel@tonic-gate clp = &sclass[cid]; 12247c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_NOAUL_SCHED || 12257c478bd9Sstevel@tonic-gate !rw_tryenter(clp->cl_lock, RW_WRITER)) 12267c478bd9Sstevel@tonic-gate return (EBUSY); 12277c478bd9Sstevel@tonic-gate 12287c478bd9Sstevel@tonic-gate clp->cl_init = NULL; 12297c478bd9Sstevel@tonic-gate clp->cl_funcs = NULL; 12307c478bd9Sstevel@tonic-gate rw_exit(clp->cl_lock); 12317c478bd9Sstevel@tonic-gate return (0); 12327c478bd9Sstevel@tonic-gate } 12337c478bd9Sstevel@tonic-gate 12347c478bd9Sstevel@tonic-gate /* 12357c478bd9Sstevel@tonic-gate * Get status of an exec module. 12367c478bd9Sstevel@tonic-gate */ 12377c478bd9Sstevel@tonic-gate /*ARGSUSED1*/ 12387c478bd9Sstevel@tonic-gate static int 12397c478bd9Sstevel@tonic-gate mod_infoexec(struct modlexec *modl, struct modlinkage *modlp, int *p0) 12407c478bd9Sstevel@tonic-gate { 12417c478bd9Sstevel@tonic-gate struct execsw *eswp; 12427c478bd9Sstevel@tonic-gate 12437c478bd9Sstevel@tonic-gate if ((eswp = findexecsw(modl->exec_execsw->exec_magic)) == NULL) 12447c478bd9Sstevel@tonic-gate *p0 = -1; 12457c478bd9Sstevel@tonic-gate else 12467c478bd9Sstevel@tonic-gate *p0 = eswp - execsw; 12477c478bd9Sstevel@tonic-gate 12487c478bd9Sstevel@tonic-gate return (0); 12497c478bd9Sstevel@tonic-gate } 12507c478bd9Sstevel@tonic-gate 12517c478bd9Sstevel@tonic-gate /* 12527c478bd9Sstevel@tonic-gate * Install an exec module. 12537c478bd9Sstevel@tonic-gate */ 12547c478bd9Sstevel@tonic-gate static int 12557c478bd9Sstevel@tonic-gate mod_installexec(struct modlexec *modl, struct modlinkage *modlp) 12567c478bd9Sstevel@tonic-gate { 12577c478bd9Sstevel@tonic-gate struct execsw *eswp; 12587c478bd9Sstevel@tonic-gate struct modctl *mcp; 12597c478bd9Sstevel@tonic-gate char *modname; 12607c478bd9Sstevel@tonic-gate char *magic; 12617c478bd9Sstevel@tonic-gate size_t magic_size; 12627c478bd9Sstevel@tonic-gate 12637c478bd9Sstevel@tonic-gate /* 12647c478bd9Sstevel@tonic-gate * See if execsw entry is already allocated. Can't use findexectype() 12657c478bd9Sstevel@tonic-gate * because we may get a recursive call to here. 12667c478bd9Sstevel@tonic-gate */ 12677c478bd9Sstevel@tonic-gate 12687c478bd9Sstevel@tonic-gate if ((eswp = findexecsw(modl->exec_execsw->exec_magic)) == NULL) { 12697c478bd9Sstevel@tonic-gate mcp = mod_getctl(modlp); 12707c478bd9Sstevel@tonic-gate ASSERT(mcp != NULL); 12717c478bd9Sstevel@tonic-gate modname = mcp->mod_modname; 12727c478bd9Sstevel@tonic-gate magic = modl->exec_execsw->exec_magic; 12737c478bd9Sstevel@tonic-gate magic_size = modl->exec_execsw->exec_maglen; 12747c478bd9Sstevel@tonic-gate if ((eswp = allocate_execsw(modname, magic, magic_size)) == 12757c478bd9Sstevel@tonic-gate NULL) { 12767c478bd9Sstevel@tonic-gate printf("no unused entries in 'execsw'\n"); 12777c478bd9Sstevel@tonic-gate return (ENOSPC); 12787c478bd9Sstevel@tonic-gate } 12797c478bd9Sstevel@tonic-gate } 12807c478bd9Sstevel@tonic-gate if (eswp->exec_func != NULL) { 12817c478bd9Sstevel@tonic-gate printf("exec type %x is already installed\n", 12827c478bd9Sstevel@tonic-gate *eswp->exec_magic); 12837c478bd9Sstevel@tonic-gate return (EBUSY); /* it's already there! */ 12847c478bd9Sstevel@tonic-gate } 12857c478bd9Sstevel@tonic-gate 12867c478bd9Sstevel@tonic-gate rw_enter(eswp->exec_lock, RW_WRITER); 12877c478bd9Sstevel@tonic-gate eswp->exec_func = modl->exec_execsw->exec_func; 12887c478bd9Sstevel@tonic-gate eswp->exec_core = modl->exec_execsw->exec_core; 12897c478bd9Sstevel@tonic-gate rw_exit(eswp->exec_lock); 12907c478bd9Sstevel@tonic-gate 12917c478bd9Sstevel@tonic-gate return (0); 12927c478bd9Sstevel@tonic-gate } 12937c478bd9Sstevel@tonic-gate 12947c478bd9Sstevel@tonic-gate /* 12957c478bd9Sstevel@tonic-gate * Remove an exec module. 12967c478bd9Sstevel@tonic-gate */ 12977c478bd9Sstevel@tonic-gate static int 12987c478bd9Sstevel@tonic-gate mod_removeexec(struct modlexec *modl, struct modlinkage *modlp) 12997c478bd9Sstevel@tonic-gate { 13007c478bd9Sstevel@tonic-gate struct execsw *eswp; 13017c478bd9Sstevel@tonic-gate struct modctl *mcp; 13027c478bd9Sstevel@tonic-gate char *modname; 13037c478bd9Sstevel@tonic-gate 13047c478bd9Sstevel@tonic-gate eswp = findexecsw(modl->exec_execsw->exec_magic); 13057c478bd9Sstevel@tonic-gate if (eswp == NULL) { 13067c478bd9Sstevel@tonic-gate mcp = mod_getctl(modlp); 13077c478bd9Sstevel@tonic-gate ASSERT(mcp != NULL); 13087c478bd9Sstevel@tonic-gate modname = mcp->mod_modname; 13097c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, uninstall_err, modname); 13107c478bd9Sstevel@tonic-gate return (EINVAL); 13117c478bd9Sstevel@tonic-gate } 13127c478bd9Sstevel@tonic-gate if (moddebug & MODDEBUG_NOAUL_EXEC || 13137c478bd9Sstevel@tonic-gate !rw_tryenter(eswp->exec_lock, RW_WRITER)) 13147c478bd9Sstevel@tonic-gate return (EBUSY); 13157c478bd9Sstevel@tonic-gate eswp->exec_func = NULL; 13167c478bd9Sstevel@tonic-gate eswp->exec_core = NULL; 13177c478bd9Sstevel@tonic-gate rw_exit(eswp->exec_lock); 13187c478bd9Sstevel@tonic-gate return (0); 13197c478bd9Sstevel@tonic-gate } 13207c478bd9Sstevel@tonic-gate 13217c478bd9Sstevel@tonic-gate /* 13227c478bd9Sstevel@tonic-gate * Find a free sysent entry or check if the specified one is free. 13237c478bd9Sstevel@tonic-gate */ 13247c478bd9Sstevel@tonic-gate static struct sysent * 13257c478bd9Sstevel@tonic-gate mod_getsysent(struct modlinkage *modlp, struct sysent *se) 13267c478bd9Sstevel@tonic-gate { 13277c478bd9Sstevel@tonic-gate int sysnum; 13287c478bd9Sstevel@tonic-gate struct modctl *mcp; 13297c478bd9Sstevel@tonic-gate char *mod_name; 13307c478bd9Sstevel@tonic-gate 13317c478bd9Sstevel@tonic-gate if ((mcp = mod_getctl(modlp)) == NULL) { 13327c478bd9Sstevel@tonic-gate /* 13337c478bd9Sstevel@tonic-gate * This happens when we're looking up the module 13347c478bd9Sstevel@tonic-gate * pointer as part of a stub installation. So 13357c478bd9Sstevel@tonic-gate * there's no need to whine at this point. 13367c478bd9Sstevel@tonic-gate */ 13377c478bd9Sstevel@tonic-gate return (NULL); 13387c478bd9Sstevel@tonic-gate } 13397c478bd9Sstevel@tonic-gate 13407c478bd9Sstevel@tonic-gate mod_name = mcp->mod_modname; 13417c478bd9Sstevel@tonic-gate 13427c478bd9Sstevel@tonic-gate if ((sysnum = mod_getsysnum(mod_name)) == -1) { 13437c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "system call missing from bind file"); 13447c478bd9Sstevel@tonic-gate return (NULL); 13457c478bd9Sstevel@tonic-gate } 13467c478bd9Sstevel@tonic-gate 13477c478bd9Sstevel@tonic-gate if (sysnum > 0 && sysnum < NSYSCALL && 13487c478bd9Sstevel@tonic-gate (se[sysnum].sy_flags & (SE_LOADABLE | SE_NOUNLOAD))) 13497c478bd9Sstevel@tonic-gate return (se + sysnum); 13507c478bd9Sstevel@tonic-gate 13517c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "system call entry %d is already in use", sysnum); 13527c478bd9Sstevel@tonic-gate return (NULL); 13537c478bd9Sstevel@tonic-gate } 13547c478bd9Sstevel@tonic-gate 13557c478bd9Sstevel@tonic-gate /* 13567c478bd9Sstevel@tonic-gate * IP Policy Modules. 13577c478bd9Sstevel@tonic-gate */ 13587c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 13597c478bd9Sstevel@tonic-gate static int 13607c478bd9Sstevel@tonic-gate mod_infoipp(struct modlipp *modl, struct modlinkage *modlp, int *p0) 13617c478bd9Sstevel@tonic-gate { 13627c478bd9Sstevel@tonic-gate struct modctl *mcp = mod_getctl(modlp); 13637c478bd9Sstevel@tonic-gate ipp_mod_id_t mid; 13647c478bd9Sstevel@tonic-gate 13657c478bd9Sstevel@tonic-gate if (mcp == NULL) { 13667c478bd9Sstevel@tonic-gate *p0 = -1; 13677c478bd9Sstevel@tonic-gate return (0); /* module is not yet installed */ 13687c478bd9Sstevel@tonic-gate } 13697c478bd9Sstevel@tonic-gate 13707c478bd9Sstevel@tonic-gate mid = ipp_mod_lookup(mcp->mod_modname); 13717c478bd9Sstevel@tonic-gate 13727c478bd9Sstevel@tonic-gate *p0 = mid; 13737c478bd9Sstevel@tonic-gate return (0); 13747c478bd9Sstevel@tonic-gate } 13757c478bd9Sstevel@tonic-gate 13767c478bd9Sstevel@tonic-gate static int 13777c478bd9Sstevel@tonic-gate mod_installipp(struct modlipp *modl, struct modlinkage *modlp) 13787c478bd9Sstevel@tonic-gate { 13797c478bd9Sstevel@tonic-gate struct modctl *mcp = mod_getctl(modlp); 13807c478bd9Sstevel@tonic-gate 13817c478bd9Sstevel@tonic-gate ASSERT(mcp != NULL); 13827c478bd9Sstevel@tonic-gate return (ipp_mod_register(mcp->mod_modname, modl->ipp_ops)); 13837c478bd9Sstevel@tonic-gate } 13847c478bd9Sstevel@tonic-gate 13857c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 13867c478bd9Sstevel@tonic-gate static int 13877c478bd9Sstevel@tonic-gate mod_removeipp(struct modlipp *modl, struct modlinkage *modlp) 13887c478bd9Sstevel@tonic-gate { 13897c478bd9Sstevel@tonic-gate struct modctl *mcp = mod_getctl(modlp); 13907c478bd9Sstevel@tonic-gate extern kthread_id_t mod_aul_thread; 13917c478bd9Sstevel@tonic-gate ipp_mod_id_t mid; 13927c478bd9Sstevel@tonic-gate 13937c478bd9Sstevel@tonic-gate ASSERT(mcp != NULL); 13947c478bd9Sstevel@tonic-gate 13957c478bd9Sstevel@tonic-gate if ((moddebug & MODDEBUG_NOAUL_IPP) && (mod_aul_thread == curthread)) 13967c478bd9Sstevel@tonic-gate return (EBUSY); 13977c478bd9Sstevel@tonic-gate 13987c478bd9Sstevel@tonic-gate mid = ipp_mod_lookup(mcp->mod_modname); 13997c478bd9Sstevel@tonic-gate ASSERT(mid != IPP_MOD_INVAL); 14007c478bd9Sstevel@tonic-gate 14017c478bd9Sstevel@tonic-gate return (ipp_mod_unregister(mid)); 14027c478bd9Sstevel@tonic-gate } 1403