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