1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <sys/types.h>
27 #include <sys/systm.h>
28 #include <sys/param.h>
29 #include <sys/user.h>
30 #include <sys/vm.h>
31 #include <sys/conf.h>
32 #include <sys/class.h>
33 #include <sys/vfs.h>
34 #include <sys/vnode.h>
35 #include <sys/mount.h>
36 #include <sys/systm.h>
37 #include <sys/modctl.h>
38 #include <sys/exec.h>
39 #include <sys/exechdr.h>
40 #include <sys/devops.h>
41 #include <sys/ddi.h>
42 #include <sys/sunddi.h>
43 #include <sys/cmn_err.h>
44 #include <sys/hwconf.h>
45 #include <sys/ddi_impldefs.h>
46 #include <sys/autoconf.h>
47 #include <sys/disp.h>
48 #include <sys/kmem.h>
49 #include <sys/instance.h>
50 #include <sys/modhash.h>
51 #include <sys/dacf.h>
52 #include <sys/debug.h>
53 #include <ipp/ipp.h>
54 #include <sys/strsubr.h>
55 #include <sys/kcpc.h>
56 #include <sys/brand.h>
57 #include <sys/cpc_pcbe.h>
58 #include <sys/kstat.h>
59 #include <sys/socketvar.h>
60 #include <sys/kiconv.h>
61
62 extern int moddebug;
63
64 extern struct cb_ops no_cb_ops;
65 extern struct dev_ops nodev_ops;
66 extern struct dev_ops mod_nodev_ops;
67
68 extern struct modctl *mod_getctl(struct modlinkage *);
69 extern int errsys(), nodev(), nulldev();
70
71 extern int findmodbyname(char *);
72 extern int mod_getsysnum(char *);
73
74 extern struct execsw execsw[];
75
76 /*
77 * Define dev_ops for unused devopsp entry.
78 */
79 struct dev_ops mod_nodev_ops = {
80 DEVO_REV, /* devo_rev */
81 0, /* refcnt */
82 ddi_no_info, /* info */
83 nulldev, /* identify */
84 nulldev, /* probe */
85 ddifail, /* attach */
86 nodev, /* detach */
87 nulldev, /* reset */
88 &no_cb_ops, /* character/block driver operations */
89 (struct bus_ops *)0 /* bus operations for nexus drivers */
90 };
91
92 /*
93 * Define mod_ops for each supported module type
94 */
95
96 /*
97 * Null operations; used for uninitialized and "misc" modules.
98 */
99 static int mod_null(struct modldrv *, struct modlinkage *);
100 static int mod_infonull(void *, struct modlinkage *, int *);
101
102 struct mod_ops mod_miscops = {
103 mod_null, mod_null, mod_infonull
104 };
105
106 /* CPU Modules */
107 struct mod_ops mod_cpuops = {
108 mod_null, mod_null, mod_infonull
109 };
110
111 /*
112 * Cryptographic Modules
113 */
114 struct mod_ops mod_cryptoops = {
115 mod_null, mod_null, mod_infonull
116 };
117
118 /*
119 * IP Policy Modules
120 */
121 static int mod_installipp(struct modlipp *, struct modlinkage *);
122 static int mod_removeipp(struct modlipp *, struct modlinkage *);
123 static int mod_infoipp(struct modlipp *, struct modlinkage *, int *);
124
125 struct mod_ops mod_ippops = {
126 mod_installipp, mod_removeipp, mod_infoipp
127 };
128
129 /*
130 * Device drivers
131 */
132 static int mod_infodrv(struct modldrv *, struct modlinkage *, int *);
133 static int mod_installdrv(struct modldrv *, struct modlinkage *);
134 static int mod_removedrv(struct modldrv *, struct modlinkage *);
135
136 struct mod_ops mod_driverops = {
137 mod_installdrv, mod_removedrv, mod_infodrv
138 };
139
140 /*
141 * System calls (new interface)
142 */
143 static int mod_infosys(struct modlsys *, struct modlinkage *, int *);
144 static int mod_installsys(struct modlsys *, struct modlinkage *);
145 static int mod_removesys(struct modlsys *, struct modlinkage *);
146
147 struct mod_ops mod_syscallops = {
148 mod_installsys, mod_removesys, mod_infosys
149 };
150
151 #ifdef _SYSCALL32_IMPL
152 /*
153 * 32-bit system calls in 64-bit kernel
154 */
155 static int mod_infosys32(struct modlsys *, struct modlinkage *, int *);
156 static int mod_installsys32(struct modlsys *, struct modlinkage *);
157 static int mod_removesys32(struct modlsys *, struct modlinkage *);
158
159 struct mod_ops mod_syscallops32 = {
160 mod_installsys32, mod_removesys32, mod_infosys32
161 };
162 #endif /* _SYSCALL32_IMPL */
163
164 /*
165 * Filesystems
166 */
167 static int mod_infofs(struct modlfs *, struct modlinkage *, int *);
168 static int mod_installfs(struct modlfs *, struct modlinkage *);
169 static int mod_removefs(struct modlfs *, struct modlinkage *);
170
171 struct mod_ops mod_fsops = {
172 mod_installfs, mod_removefs, mod_infofs
173 };
174
175 /*
176 * Streams modules.
177 */
178 static int mod_infostrmod(struct modlstrmod *, struct modlinkage *, int *);
179 static int mod_installstrmod(struct modlstrmod *, struct modlinkage *);
180 static int mod_removestrmod(struct modlstrmod *, struct modlinkage *);
181
182 struct mod_ops mod_strmodops = {
183 mod_installstrmod, mod_removestrmod, mod_infostrmod
184 };
185
186 /*
187 * Socket modules.
188 */
189 static int mod_infosockmod(struct modlsockmod *, struct modlinkage *, int *);
190 static int mod_installsockmod(struct modlsockmod *, struct modlinkage *);
191 static int mod_removesockmod(struct modlsockmod *, struct modlinkage *);
192
193 struct mod_ops mod_sockmodops = {
194 mod_installsockmod, mod_removesockmod, mod_infosockmod
195 };
196
197 /*
198 * Scheduling classes.
199 */
200 static int mod_infosched(struct modlsched *, struct modlinkage *, int *);
201 static int mod_installsched(struct modlsched *, struct modlinkage *);
202 static int mod_removesched(struct modlsched *, struct modlinkage *);
203
204 struct mod_ops mod_schedops = {
205 mod_installsched, mod_removesched, mod_infosched
206 };
207
208 /*
209 * Exec file type (like ELF, ...).
210 */
211 static int mod_infoexec(struct modlexec *, struct modlinkage *, int *);
212 static int mod_installexec(struct modlexec *, struct modlinkage *);
213 static int mod_removeexec(struct modlexec *, struct modlinkage *);
214
215 struct mod_ops mod_execops = {
216 mod_installexec, mod_removeexec, mod_infoexec
217 };
218
219 /*
220 * Dacf (Dynamic Autoconfiguration) modules.
221 */
222 static int mod_infodacf(struct modldacf *, struct modlinkage *, int *);
223 static int mod_installdacf(struct modldacf *, struct modlinkage *);
224 static int mod_removedacf(struct modldacf *, struct modlinkage *);
225
226 struct mod_ops mod_dacfops = {
227 mod_installdacf, mod_removedacf, mod_infodacf
228 };
229
230 /*
231 * PCBE (Performance Counter BackEnd) modules.
232 */
233 static int mod_installpcbe(struct modlpcbe *, struct modlinkage *);
234 static int mod_removepcbe(struct modlpcbe *, struct modlinkage *);
235
236 struct mod_ops mod_pcbeops = {
237 mod_installpcbe, mod_removepcbe, mod_infonull
238 };
239
240 /*
241 * Brand modules.
242 */
243 static int mod_installbrand(struct modlbrand *, struct modlinkage *);
244 static int mod_removebrand(struct modlbrand *, struct modlinkage *);
245
246 struct mod_ops mod_brandops = {
247 mod_installbrand, mod_removebrand, mod_infonull
248 };
249
250 /*
251 * kiconv modules.
252 */
253 static int mod_installkiconv(struct modlkiconv *, struct modlinkage *);
254 static int mod_removekiconv(struct modlkiconv *, struct modlinkage *);
255
256 struct mod_ops mod_kiconvops = {
257 mod_installkiconv, mod_removekiconv, mod_infonull
258 };
259
260 static struct sysent *mod_getsysent(struct modlinkage *, struct sysent *);
261
262 static char uninstall_err[] = "Cannot uninstall %s; not installed";
263
264 /*
265 * Debugging support
266 */
267 #define DRV_DBG MODDEBUG_LOADMSG2
268
269 /*PRINTFLIKE2*/
270 static void mod_dprintf(int flag, const char *format, ...) __KPRINTFLIKE(2);
271
272 static void
273 mod_dprintf(int flag, const char *format, ...)
274 {
275 va_list alist;
276
277 if ((moddebug & flag) != 0) {
278 va_start(alist, format);
279 (void) vprintf(format, alist);
280 va_end(alist);
281 }
282 }
283
284 /*
285 * Install a module.
286 * (This routine is in the Solaris SPARC DDI/DKI)
287 */
288 int
289 mod_install(struct modlinkage *modlp)
290 {
291 int retval = -1; /* No linkage structures */
292 struct modlmisc **linkpp;
293 struct modlmisc **linkpp1;
294
295 if (modlp->ml_rev != MODREV_1) {
296 printf("mod_install: modlinkage structure is not MODREV_1\n");
297 return (EINVAL);
298 }
299 linkpp = (struct modlmisc **)&modlp->ml_linkage[0];
300
301 while (*linkpp != NULL) {
302 if ((retval = MODL_INSTALL(*linkpp, modlp)) != 0) {
303 linkpp1 = (struct modlmisc **)&modlp->ml_linkage[0];
304
305 while (linkpp1 != linkpp) {
306 MODL_REMOVE(*linkpp1, modlp); /* clean up */
307 linkpp1++;
308 }
309 break;
310 }
311 linkpp++;
312 }
313 return (retval);
314 }
315
316 static char *reins_err =
317 "Could not reinstall %s\nReboot to correct the problem";
318
319 /*
320 * Remove a module. This is called by the module wrapper routine.
321 * (This routine is in the Solaris SPARC DDI/DKI)
322 */
323 int
324 mod_remove(struct modlinkage *modlp)
325 {
326 int retval = 0;
327 struct modlmisc **linkpp, *last_linkp;
328
329 linkpp = (struct modlmisc **)&modlp->ml_linkage[0];
330
331 while (*linkpp != NULL) {
332 if ((retval = MODL_REMOVE(*linkpp, modlp)) != 0) {
333 last_linkp = *linkpp;
334 linkpp = (struct modlmisc **)&modlp->ml_linkage[0];
335 while (*linkpp != last_linkp) {
336 if (MODL_INSTALL(*linkpp, modlp) != 0) {
337 cmn_err(CE_WARN, reins_err,
338 (*linkpp)->misc_linkinfo);
339 break;
340 }
341 linkpp++;
342 }
343 break;
344 }
345 linkpp++;
346 }
347 return (retval);
348 }
349
350 /*
351 * Get module status.
352 * (This routine is in the Solaris SPARC DDI/DKI)
353 */
354 int
355 mod_info(struct modlinkage *modlp, struct modinfo *modinfop)
356 {
357 int i;
358 int retval = 0;
359 struct modspecific_info *msip;
360 struct modlmisc **linkpp;
361
362 modinfop->mi_rev = modlp->ml_rev;
363
364 linkpp = (struct modlmisc **)modlp->ml_linkage;
365 msip = &modinfop->mi_msinfo[0];
366
367 for (i = 0; i < MODMAXLINK; i++) {
368 if (*linkpp == NULL) {
369 msip->msi_linkinfo[0] = '\0';
370 } else {
371 (void) strncpy(msip->msi_linkinfo,
372 (*linkpp)->misc_linkinfo, MODMAXLINKINFOLEN);
373 retval = MODL_INFO(*linkpp, modlp, &msip->msi_p0);
374 if (retval != 0)
375 break;
376 linkpp++;
377 }
378 msip++;
379 }
380
381 if (modinfop->mi_info == MI_INFO_LINKAGE) {
382 /*
383 * Slight kludge used to extract the address of the
384 * modlinkage structure from the module (just after
385 * loading a module for the very first time)
386 */
387 modinfop->mi_base = (void *)modlp;
388 }
389
390 if (retval == 0)
391 return (1);
392 return (0);
393 }
394
395 /*
396 * Get module name.
397 */
398 const char *
399 mod_modname(struct modlinkage *modlp)
400 {
401 struct modctl *mcp;
402
403 if ((mcp = mod_getctl(modlp)) == NULL)
404 return (NULL);
405
406 return (mcp->mod_modname);
407 }
408
409 /*
410 * Null operation; return 0.
411 */
412 /*ARGSUSED*/
413 static int
414 mod_null(struct modldrv *modl, struct modlinkage *modlp)
415 {
416 return (0);
417 }
418
419 /*
420 * Status for User modules.
421 */
422 /*ARGSUSED*/
423 static int
424 mod_infonull(void *modl, struct modlinkage *modlp, int *p0)
425 {
426 *p0 = -1; /* for modinfo display */
427 return (0);
428 }
429
430 /*
431 * Driver status info
432 */
433 /*ARGSUSED*/
434 static int
435 mod_infodrv(struct modldrv *modl, struct modlinkage *modlp, int *p0)
436 {
437 struct modctl *mcp;
438 char *mod_name;
439
440 if ((mcp = mod_getctl(modlp)) == NULL) {
441 *p0 = -1;
442 return (0); /* driver is not yet installed */
443 }
444
445 mod_name = mcp->mod_modname;
446
447 *p0 = ddi_name_to_major(mod_name);
448 return (0);
449 }
450
451 /*
452 * Manage dacf (device autoconfiguration) modules
453 */
454
455 /*ARGSUSED*/
456 static int
457 mod_infodacf(struct modldacf *modl, struct modlinkage *modlp, int *p0)
458 {
459 if (mod_getctl(modlp) == NULL) {
460 *p0 = -1;
461 return (0); /* module is not yet installed */
462 }
463
464 *p0 = 0;
465 return (0);
466 }
467
468 static int
469 mod_installdacf(struct modldacf *modl, struct modlinkage *modlp)
470 {
471 struct modctl *mcp;
472
473 if ((mcp = mod_getctl(modlp)) == NULL)
474 return (EINVAL);
475 return (dacf_module_register(mcp->mod_modname, modl->dacf_dacfsw));
476 }
477
478 /*ARGSUSED*/
479 static int
480 mod_removedacf(struct modldacf *modl, struct modlinkage *modlp)
481 {
482 struct modctl *mcp;
483
484 if ((mcp = mod_getctl(modlp)) == NULL)
485 return (EINVAL);
486 return (dacf_module_unregister(mcp->mod_modname));
487 }
488
489 /*
490 * Manage PCBE (Performance Counter BackEnd) modules.
491 */
492 /*ARGSUSED*/
493 static int
494 mod_installpcbe(struct modlpcbe *modl, struct modlinkage *modlp)
495 {
496 if (modl->pcbe_ops->pcbe_ver != PCBE_VER_1) {
497 cmn_err(CE_WARN, "pcbe '%s' version mismatch",
498 modl->pcbe_linkinfo);
499 return (EINVAL);
500 }
501
502 kcpc_register_pcbe(modl->pcbe_ops);
503 return (0);
504 }
505
506 /*
507 * PCBEs may not be unloaded. It would make CPC locking too complex, and since
508 * PCBEs are loaded once and used for life, there is no harm done in leaving
509 * them in the system.
510 */
511 /*ARGSUSED*/
512 static int
513 mod_removepcbe(struct modlpcbe *modl, struct modlinkage *modlp)
514 {
515 return (EBUSY);
516 }
517
518 /*
519 * Manage BrandZ modules.
520 */
521 /*ARGSUSED*/
522 static int
523 mod_installbrand(struct modlbrand *modl, struct modlinkage *modlp)
524 {
525 return (brand_register(modl->brand_branddef));
526 }
527
528 /*ARGSUSED*/
529 static int
530 mod_removebrand(struct modlbrand *modl, struct modlinkage *modlp)
531 {
532 return (brand_unregister(modl->brand_branddef));
533 }
534
535 /*
536 * Install a new driver
537 */
538 static int
539 mod_installdrv(struct modldrv *modl, struct modlinkage *modlp)
540 {
541 struct modctl *mcp;
542 struct dev_ops *ops;
543 char *modname;
544 major_t major;
545 struct dev_ops *dp;
546 struct devnames *dnp;
547 struct streamtab *str;
548 cdevsw_impl_t *cdp;
549 uint_t sqtype;
550 uint_t qflag;
551 uint_t flag;
552 int err = 0;
553
554 /* sanity check module */
555 if ((mcp = mod_getctl(modlp)) == NULL) {
556 cmn_err(CE_WARN, "mod_install: bad module linkage data");
557 err = ENXIO;
558 goto done;
559 }
560 modname = mcp->mod_modname;
561
562 /* Sanity check modname */
563 if ((major = ddi_name_to_major(modname)) == DDI_MAJOR_T_NONE) {
564 #ifdef DEBUG
565 cmn_err(CE_WARN,
566 "mod_installdrv: no major number for %s", modname);
567 #endif
568 err = ENXIO;
569 goto done;
570 }
571
572 /* Verify MP safety flag */
573 ops = modl->drv_dev_ops;
574 if (ops->devo_bus_ops == NULL && ops->devo_cb_ops != NULL &&
575 !(ops->devo_cb_ops->cb_flag & D_MP)) {
576 cmn_err(CE_WARN,
577 "mod_installdrv: MT-unsafe driver '%s' rejected", modname);
578 err = ENXIO;
579 goto done;
580 }
581
582
583 /* Is bus_map_fault signature correct (version 8 and higher)? */
584 if (ops->devo_bus_ops != NULL &&
585 ops->devo_bus_ops->bus_map_fault != NULL &&
586 ops->devo_bus_ops->bus_map_fault != i_ddi_map_fault &&
587 ops->devo_bus_ops->busops_rev < BUSO_REV_8) {
588
589 cmn_err(CE_WARN,
590 "mod_installdrv: busops' revision of '%s' is too low"
591 " (must be at least 8)", modname);
592 err = ENXIO;
593 goto done;
594 }
595
596
597 /* Make sure the driver is uninstalled */
598 dnp = &devnamesp[major];
599 LOCK_DEV_OPS(&dnp->dn_lock);
600 dp = devopsp[major];
601
602 if (dnp->dn_flags & (DN_DRIVER_REMOVED|DN_DRIVER_INACTIVE)) {
603 #ifdef DEBUG
604 cmn_err(CE_CONT,
605 "mod_installdrv: driver %s not installed", modname);
606 #endif
607 err = ENXIO;
608 goto unlock;
609 }
610
611 if (dp != &nodev_ops && dp != &mod_nodev_ops) {
612 cmn_err(CE_WARN,
613 "mod_installdrv: driver already installed %s", modname);
614 err = EALREADY;
615 goto unlock;
616 }
617
618 devopsp[major] = ops; /* setup devopsp */
619
620 if ((str = STREAMSTAB(major)) != NULL) { /* streams driver */
621 flag = CBFLAG(major);
622 if ((err = devflg_to_qflag(str, flag, &qflag, &sqtype)) != 0)
623 goto unlock;
624 cdp = &devimpl[major];
625 ASSERT(cdp->d_str == NULL);
626 cdp->d_str = str;
627 cdp->d_qflag = qflag | QISDRV;
628 cdp->d_sqtype = sqtype;
629 }
630
631 if (ops->devo_bus_ops == NULL)
632 dnp->dn_flags |= DN_LEAF_DRIVER;
633
634 unlock:
635 UNLOCK_DEV_OPS(&dnp->dn_lock);
636 done:
637 return (err);
638 }
639
640 static int
641 mod_removedrv(struct modldrv *modl, struct modlinkage *modlp)
642 {
643 struct modctl *mcp;
644 struct dev_ops *ops;
645 struct devnames *dnp;
646 struct dev_ops *dp;
647 major_t major;
648 char *modname;
649 extern kthread_id_t mod_aul_thread;
650 struct streamtab *str;
651 cdevsw_impl_t *cdp;
652 int err = 0;
653
654 /* Don't auto unload modules on if moddebug flag is set */
655 if ((moddebug & MODDEBUG_NOAUL_DRV) && (mod_aul_thread == curthread)) {
656 err = EBUSY;
657 goto done;
658 }
659
660 /* Verify modname has a driver major */
661 mcp = mod_getctl(modlp);
662 ASSERT(mcp != NULL);
663 modname = mcp->mod_modname;
664
665 if ((major = ddi_name_to_major(modname)) == -1) {
666 cmn_err(CE_WARN, uninstall_err, modname);
667 err = EINVAL;
668 goto done;
669 }
670
671 ops = modl->drv_dev_ops;
672 dnp = &(devnamesp[major]);
673 LOCK_DEV_OPS(&(dnp->dn_lock));
674
675 dp = devopsp[major];
676
677 if (dp != ops) {
678 cmn_err(CE_NOTE, "mod_removedrv: mismatched driver for %s",
679 modname);
680 err = EBUSY;
681 goto unlock;
682 }
683
684 /*
685 * A driver is not unloadable if its dev_ops are held
686 */
687 if (!DRV_UNLOADABLE(dp)) {
688 mod_dprintf(DRV_DBG, "Cannot unload device driver <%s>,"
689 " refcnt %d\n", modname, dp->devo_refcnt);
690 err = EBUSY;
691 goto unlock;
692 }
693
694 /*
695 * OK to unload.
696 */
697 if ((str = STREAMSTAB(major)) != NULL) { /* streams driver */
698 cdp = &devimpl[major];
699 ASSERT(cdp->d_str == str);
700 cdp->d_str = NULL;
701
702 /* check for reference to per-dev syncq */
703 if (cdp->d_dmp != NULL) {
704 rele_dm(cdp->d_dmp);
705 cdp->d_dmp = NULL;
706 }
707 }
708
709 devopsp[major] = &mod_nodev_ops;
710 dnp->dn_flags &= ~(DN_DRIVER_HELD|DN_NO_AUTODETACH);
711
712 unlock:
713 UNLOCK_DEV_OPS(&(dnp->dn_lock));
714 done:
715 return (err);
716 }
717
718 /*
719 * System call subroutines
720 */
721
722 /*
723 * Compute system call number for given sysent and sysent table
724 */
725 static int
726 mod_infosysnum(struct modlinkage *modlp, struct sysent table[])
727 {
728 struct sysent *sysp;
729
730 if ((sysp = mod_getsysent(modlp, table)) == NULL)
731 return (-1);
732 return ((int)(sysp - table));
733 }
734
735 /*
736 * Put a loadable system call entry into a sysent table.
737 */
738 static int
739 mod_installsys_sysent(
740 struct modlsys *modl,
741 struct modlinkage *modlp,
742 struct sysent table[])
743 {
744 struct sysent *sysp;
745 struct sysent *mp;
746
747 #ifdef DEBUG
748 /*
749 * Before we even play with the sysent table, sanity check the
750 * incoming flags to make sure the entry is valid
751 */
752 switch (modl->sys_sysent->sy_flags & SE_RVAL_MASK) {
753 case SE_32RVAL1:
754 /* only r_val1 returned */
755 case SE_32RVAL1 | SE_32RVAL2:
756 /* r_val1 and r_val2 returned */
757 case SE_64RVAL:
758 /* 64-bit rval returned */
759 break;
760 default:
761 cmn_err(CE_WARN, "loadable syscall: %p: bad rval flags %x",
762 (void *)modl, modl->sys_sysent->sy_flags);
763 return (ENOSYS);
764 }
765 #endif
766 if ((sysp = mod_getsysent(modlp, table)) == NULL)
767 return (ENOSPC);
768
769 /*
770 * We should only block here until the reader in syscall gives
771 * up the lock. Multiple writers are prevented in the mod layer.
772 */
773 rw_enter(sysp->sy_lock, RW_WRITER);
774 mp = modl->sys_sysent;
775 sysp->sy_narg = mp->sy_narg;
776 sysp->sy_call = mp->sy_call;
777
778 /*
779 * clear the old call method flag, and get the new one from the module.
780 */
781 sysp->sy_flags &= ~SE_ARGC;
782 sysp->sy_flags |= SE_LOADED |
783 (mp->sy_flags & (SE_ARGC | SE_NOUNLOAD | SE_RVAL_MASK));
784
785 /*
786 * If the syscall doesn't need or want unloading, it can avoid
787 * the locking overhead on each entry. Convert the sysent to a
788 * normal non-loadable entry in that case.
789 */
790 if (mp->sy_flags & SE_NOUNLOAD) {
791 if (mp->sy_flags & SE_ARGC) {
792 sysp->sy_callc = (int64_t (*)())mp->sy_call;
793 } else {
794 sysp->sy_callc = syscall_ap;
795 }
796 sysp->sy_flags &= ~SE_LOADABLE;
797 }
798 rw_exit(sysp->sy_lock);
799 return (0);
800 }
801
802 /*
803 * Remove a loadable system call entry from a sysent table.
804 */
805 static int
806 mod_removesys_sysent(
807 struct modlsys *modl,
808 struct modlinkage *modlp,
809 struct sysent table[])
810 {
811 struct sysent *sysp;
812
813 if ((sysp = mod_getsysent(modlp, table)) == NULL ||
814 (sysp->sy_flags & (SE_LOADABLE | SE_NOUNLOAD)) == 0 ||
815 sysp->sy_call != modl->sys_sysent->sy_call) {
816
817 struct modctl *mcp = mod_getctl(modlp);
818 char *modname = mcp->mod_modname;
819
820 cmn_err(CE_WARN, uninstall_err, modname);
821 return (EINVAL);
822 }
823
824 /* If we can't get the write lock, we can't unlink from the system */
825
826 if (!(moddebug & MODDEBUG_NOAUL_SYS) &&
827 rw_tryenter(sysp->sy_lock, RW_WRITER)) {
828 /*
829 * Check the flags to be sure the syscall is still
830 * (un)loadable.
831 * If SE_NOUNLOAD is set, SE_LOADABLE will not be.
832 */
833 if ((sysp->sy_flags & (SE_LOADED | SE_LOADABLE)) ==
834 (SE_LOADED | SE_LOADABLE)) {
835 sysp->sy_flags &= ~SE_LOADED;
836 sysp->sy_callc = loadable_syscall;
837 sysp->sy_call = (int (*)())nosys;
838 rw_exit(sysp->sy_lock);
839 return (0);
840 }
841 rw_exit(sysp->sy_lock);
842 }
843 return (EBUSY);
844 }
845
846 /*
847 * System call status info
848 */
849 /*ARGSUSED*/
850 static int
851 mod_infosys(struct modlsys *modl, struct modlinkage *modlp, int *p0)
852 {
853 *p0 = mod_infosysnum(modlp, sysent);
854 return (0);
855 }
856
857 /*
858 * Link a system call into the system by setting the proper sysent entry.
859 * Called from the module's _init routine.
860 */
861 static int
862 mod_installsys(struct modlsys *modl, struct modlinkage *modlp)
863 {
864 return (mod_installsys_sysent(modl, modlp, sysent));
865 }
866
867 /*
868 * Unlink a system call from the system.
869 * Called from a modules _fini routine.
870 */
871 static int
872 mod_removesys(struct modlsys *modl, struct modlinkage *modlp)
873 {
874 return (mod_removesys_sysent(modl, modlp, sysent));
875 }
876
877 #ifdef _SYSCALL32_IMPL
878
879 /*
880 * 32-bit system call status info
881 */
882 /*ARGSUSED*/
883 static int
884 mod_infosys32(struct modlsys *modl, struct modlinkage *modlp, int *p0)
885 {
886 *p0 = mod_infosysnum(modlp, sysent32);
887 return (0);
888 }
889
890 /*
891 * Link the 32-bit syscall into the system by setting the proper sysent entry.
892 * Also called from the module's _init routine.
893 */
894 static int
895 mod_installsys32(struct modlsys *modl, struct modlinkage *modlp)
896 {
897 return (mod_installsys_sysent(modl, modlp, sysent32));
898 }
899
900 /*
901 * Unlink the 32-bit flavor of a system call from the system.
902 * Also called from a module's _fini routine.
903 */
904 static int
905 mod_removesys32(struct modlsys *modl, struct modlinkage *modlp)
906 {
907 return (mod_removesys_sysent(modl, modlp, sysent32));
908 }
909
910 #endif /* _SYSCALL32_IMPL */
911
912 /*
913 * Filesystem status info
914 */
915 /*ARGSUSED*/
916 static int
917 mod_infofs(struct modlfs *modl, struct modlinkage *modlp, int *p0)
918 {
919 struct vfssw *vswp;
920
921 RLOCK_VFSSW();
922 if ((vswp = vfs_getvfsswbyname(modl->fs_vfsdef->name)) == NULL)
923 *p0 = -1;
924 else {
925 *p0 = vswp - vfssw;
926 vfs_unrefvfssw(vswp);
927 }
928 RUNLOCK_VFSSW();
929 return (0);
930 }
931
932 /*
933 * Install a filesystem.
934 */
935 /*ARGSUSED1*/
936 static int
937 mod_installfs(struct modlfs *modl, struct modlinkage *modlp)
938 {
939 struct vfssw *vswp;
940 struct modctl *mcp;
941 char *fsname;
942 char ksname[KSTAT_STRLEN + 1];
943 int fstype; /* index into vfssw[] and vsanchor_fstype[] */
944 int allocated;
945 int err;
946 int vsw_stats_enabled;
947 /* Not for public consumption so these aren't in a header file */
948 extern int vopstats_enabled;
949 extern vopstats_t **vopstats_fstype;
950 extern kstat_t *new_vskstat(char *, vopstats_t *);
951 extern void initialize_vopstats(vopstats_t *);
952
953 if (modl->fs_vfsdef->def_version == VFSDEF_VERSION) {
954 /* Version matched */
955 fsname = modl->fs_vfsdef->name;
956 } else {
957 if ((modl->fs_vfsdef->def_version > 0) &&
958 (modl->fs_vfsdef->def_version < VFSDEF_VERSION)) {
959 /* Older VFSDEF_VERSION */
960 fsname = modl->fs_vfsdef->name;
961 } else if ((mcp = mod_getctl(modlp)) != NULL) {
962 /* Pre-VFSDEF_VERSION */
963 fsname = mcp->mod_modname;
964 } else {
965 /* If all else fails... */
966 fsname = "<unknown file system type>";
967 }
968
969 cmn_err(CE_WARN, "file system '%s' version mismatch", fsname);
970 return (ENXIO);
971 }
972
973 allocated = 0;
974
975 WLOCK_VFSSW();
976 if ((vswp = vfs_getvfsswbyname(fsname)) == NULL) {
977 if ((vswp = allocate_vfssw(fsname)) == NULL) {
978 WUNLOCK_VFSSW();
979 /*
980 * See 1095689. If this message appears, then
981 * we either need to make the vfssw table bigger
982 * statically, or make it grow dynamically.
983 */
984 cmn_err(CE_WARN, "no room for '%s' in vfssw!", fsname);
985 return (ENXIO);
986 }
987 allocated = 1;
988 }
989 ASSERT(vswp != NULL);
990
991 fstype = vswp - vfssw; /* Pointer arithmetic to get the fstype */
992
993 /* Turn on everything by default *except* VSW_STATS */
994 vswp->vsw_flag = modl->fs_vfsdef->flags & ~(VSW_STATS);
995
996 if (modl->fs_vfsdef->flags & VSW_HASPROTO) {
997 vfs_mergeopttbl(&vfs_mntopts, modl->fs_vfsdef->optproto,
998 &vswp->vsw_optproto);
999 } else {
1000 vfs_copyopttbl(&vfs_mntopts, &vswp->vsw_optproto);
1001 }
1002
1003 if (modl->fs_vfsdef->flags & VSW_CANRWRO) {
1004 /*
1005 * This obviously implies VSW_CANREMOUNT.
1006 */
1007 vswp->vsw_flag |= VSW_CANREMOUNT;
1008 }
1009
1010 /*
1011 * If stats are enabled system wide and for this fstype, then
1012 * set the VSW_STATS flag in the proper vfssw[] table entry.
1013 */
1014 if (vopstats_enabled && modl->fs_vfsdef->flags & VSW_STATS) {
1015 vswp->vsw_flag |= VSW_STATS;
1016 }
1017
1018 if (modl->fs_vfsdef->init == NULL)
1019 err = EFAULT;
1020 else
1021 err = (*(modl->fs_vfsdef->init))(fstype, fsname);
1022
1023 if (err != 0) {
1024 if (allocated) {
1025 kmem_free(vswp->vsw_name, strlen(vswp->vsw_name)+1);
1026 vswp->vsw_name = "";
1027 }
1028 vswp->vsw_flag = 0;
1029 vswp->vsw_init = NULL;
1030 }
1031
1032 /* We don't want to hold the vfssw[] write lock over a kmem_alloc() */
1033 vsw_stats_enabled = vswp->vsw_flag & VSW_STATS;
1034
1035 vfs_unrefvfssw(vswp);
1036 WUNLOCK_VFSSW();
1037
1038 /* If everything is on, set up the per-fstype vopstats */
1039 if (vsw_stats_enabled && vopstats_enabled &&
1040 vopstats_fstype && vopstats_fstype[fstype] == NULL) {
1041 (void) strlcpy(ksname, VOPSTATS_STR, sizeof (ksname));
1042 (void) strlcat(ksname, vfssw[fstype].vsw_name, sizeof (ksname));
1043 vopstats_fstype[fstype] =
1044 kmem_alloc(sizeof (vopstats_t), KM_SLEEP);
1045 initialize_vopstats(vopstats_fstype[fstype]);
1046 (void) new_vskstat(ksname, vopstats_fstype[fstype]);
1047 }
1048 return (err);
1049 }
1050
1051 /*
1052 * Remove a filesystem
1053 */
1054 static int
1055 mod_removefs(struct modlfs *modl, struct modlinkage *modlp)
1056 {
1057 struct vfssw *vswp;
1058 struct modctl *mcp;
1059 char *modname;
1060
1061 if (moddebug & MODDEBUG_NOAUL_FS)
1062 return (EBUSY);
1063
1064 WLOCK_VFSSW();
1065 if ((vswp = vfs_getvfsswbyname(modl->fs_vfsdef->name)) == NULL) {
1066 mcp = mod_getctl(modlp);
1067 ASSERT(mcp != NULL);
1068 modname = mcp->mod_modname;
1069 WUNLOCK_VFSSW();
1070 cmn_err(CE_WARN, uninstall_err, modname);
1071 return (EINVAL);
1072 }
1073 if (vswp->vsw_count != 1) {
1074 vfs_unrefvfssw(vswp);
1075 WUNLOCK_VFSSW();
1076 return (EBUSY);
1077 }
1078
1079 /*
1080 * A mounted filesystem could still have vsw_count = 0
1081 * so we must check whether anyone is actually using our ops
1082 */
1083 if (vfs_opsinuse(&vswp->vsw_vfsops)) {
1084 vfs_unrefvfssw(vswp);
1085 WUNLOCK_VFSSW();
1086 return (EBUSY);
1087 }
1088
1089 vfs_freeopttbl(&vswp->vsw_optproto);
1090 vswp->vsw_optproto.mo_count = 0;
1091
1092 vswp->vsw_flag = 0;
1093 vswp->vsw_init = NULL;
1094 vfs_unrefvfssw(vswp);
1095 WUNLOCK_VFSSW();
1096 return (0);
1097 }
1098
1099 /*
1100 * Get status of a streams module.
1101 */
1102 /*ARGSUSED*/
1103 static int
1104 mod_infostrmod(struct modlstrmod *modl, struct modlinkage *modlp, int *p0)
1105 {
1106 *p0 = -1; /* no useful info */
1107 return (0);
1108 }
1109
1110
1111 /*
1112 * Install a streams module.
1113 */
1114 /*ARGSUSED*/
1115 static int
1116 mod_installstrmod(struct modlstrmod *modl, struct modlinkage *modlp)
1117 {
1118 struct fmodsw *fp = modl->strmod_fmodsw;
1119
1120 if (!(fp->f_flag & D_MP)) {
1121 cmn_err(CE_WARN, "mod_install: MT-unsafe strmod '%s' rejected",
1122 fp->f_name);
1123 return (ENXIO);
1124 }
1125
1126 return (fmodsw_register(fp->f_name, fp->f_str, fp->f_flag));
1127 }
1128
1129 /*
1130 * Remove a streams module.
1131 */
1132 /*ARGSUSED*/
1133 static int
1134 mod_removestrmod(struct modlstrmod *modl, struct modlinkage *modlp)
1135 {
1136 if (moddebug & MODDEBUG_NOAUL_STR)
1137 return (EBUSY);
1138
1139 return (fmodsw_unregister(modl->strmod_fmodsw->f_name));
1140 }
1141
1142 /*
1143 * Get status of a socket module.
1144 */
1145 /*ARGSUSED*/
1146 static int
1147 mod_infosockmod(struct modlsockmod *modl, struct modlinkage *modlp, int *p0)
1148 {
1149 *p0 = -1; /* no useful info */
1150 return (0);
1151 }
1152
1153 /*
1154 * Install a socket module.
1155 */
1156 /*ARGSUSED*/
1157 static int
1158 mod_installsockmod(struct modlsockmod *modl, struct modlinkage *modlp)
1159 {
1160 struct modctl *mcp;
1161 char *mod_name;
1162
1163 mcp = mod_getctl(modlp);
1164 ASSERT(mcp != NULL);
1165 mod_name = mcp->mod_modname;
1166 if (strcmp(mod_name, modl->sockmod_reg_info->smod_name) != 0) {
1167 #ifdef DEBUG
1168 cmn_err(CE_CONT, "mod_installsockmod: different names"
1169 " %s != %s \n", mod_name,
1170 modl->sockmod_reg_info->smod_name);
1171 #endif
1172 return (EINVAL);
1173 }
1174
1175 /*
1176 * Register module.
1177 */
1178 return (smod_register(modl->sockmod_reg_info));
1179 }
1180
1181 /*
1182 * Remove a socket module.
1183 */
1184 /*ARGSUSED*/
1185 static int
1186 mod_removesockmod(struct modlsockmod *modl, struct modlinkage *modlp)
1187 {
1188 /*
1189 * unregister from the global socket creation table
1190 * check the refcnt in the lookup table
1191 */
1192 return (smod_unregister(modl->sockmod_reg_info->smod_name));
1193 }
1194
1195 /*
1196 * Get status of a scheduling class module.
1197 */
1198 /*ARGSUSED1*/
1199 static int
1200 mod_infosched(struct modlsched *modl, struct modlinkage *modlp, int *p0)
1201 {
1202 int status;
1203 auto id_t cid;
1204
1205 status = getcidbyname(modl->sched_class->cl_name, &cid);
1206
1207 if (status != 0)
1208 *p0 = -1;
1209 else
1210 *p0 = cid;
1211
1212 return (0);
1213 }
1214
1215 /*
1216 * Install a scheduling class module.
1217 */
1218 /*ARGSUSED1*/
1219 static int
1220 mod_installsched(struct modlsched *modl, struct modlinkage *modlp)
1221 {
1222 sclass_t *clp;
1223 int status;
1224 id_t cid;
1225
1226 /*
1227 * See if module is already installed.
1228 */
1229 mutex_enter(&class_lock);
1230 status = alloc_cid(modl->sched_class->cl_name, &cid);
1231 mutex_exit(&class_lock);
1232 ASSERT(status == 0);
1233 clp = &sclass[cid];
1234 rw_enter(clp->cl_lock, RW_WRITER);
1235 if (SCHED_INSTALLED(clp)) {
1236 printf("scheduling class %s is already installed\n",
1237 modl->sched_class->cl_name);
1238 rw_exit(clp->cl_lock);
1239 return (EBUSY); /* it's already there */
1240 }
1241
1242 clp->cl_init = modl->sched_class->cl_init;
1243 clp->cl_funcs = modl->sched_class->cl_funcs;
1244 modl->sched_class = clp;
1245 disp_add(clp);
1246 loaded_classes++; /* for priocntl system call */
1247 rw_exit(clp->cl_lock);
1248 return (0);
1249 }
1250
1251 /*
1252 * Remove a scheduling class module.
1253 *
1254 * we only null out the init func and the class functions because
1255 * once a class has been loaded it has that slot in the class
1256 * array until the next reboot. We don't decrement loaded_classes
1257 * because this keeps count of the number of classes that have
1258 * been loaded for this session. It will have to be this way until
1259 * we implement the class array as a linked list and do true
1260 * dynamic allocation.
1261 */
1262 static int
1263 mod_removesched(struct modlsched *modl, struct modlinkage *modlp)
1264 {
1265 int status;
1266 sclass_t *clp;
1267 struct modctl *mcp;
1268 char *modname;
1269 id_t cid;
1270
1271 status = getcidbyname(modl->sched_class->cl_name, &cid);
1272 if (status != 0) {
1273 mcp = mod_getctl(modlp);
1274 ASSERT(mcp != NULL);
1275 modname = mcp->mod_modname;
1276 cmn_err(CE_WARN, uninstall_err, modname);
1277 return (EINVAL);
1278 }
1279 clp = &sclass[cid];
1280 if (moddebug & MODDEBUG_NOAUL_SCHED ||
1281 !rw_tryenter(clp->cl_lock, RW_WRITER))
1282 return (EBUSY);
1283
1284 clp->cl_init = NULL;
1285 clp->cl_funcs = NULL;
1286 rw_exit(clp->cl_lock);
1287 return (0);
1288 }
1289
1290 /*
1291 * Get status of an exec module.
1292 */
1293 /*ARGSUSED1*/
1294 static int
1295 mod_infoexec(struct modlexec *modl, struct modlinkage *modlp, int *p0)
1296 {
1297 struct execsw *eswp;
1298
1299 if ((eswp = findexecsw(modl->exec_execsw->exec_magic)) == NULL)
1300 *p0 = -1;
1301 else
1302 *p0 = eswp - execsw;
1303
1304 return (0);
1305 }
1306
1307 /*
1308 * Install an exec module.
1309 */
1310 static int
1311 mod_installexec(struct modlexec *modl, struct modlinkage *modlp)
1312 {
1313 struct execsw *eswp;
1314 struct modctl *mcp;
1315 char *modname;
1316 char *magic;
1317 size_t magic_size;
1318
1319 /*
1320 * See if execsw entry is already allocated. Can't use findexectype()
1321 * because we may get a recursive call to here.
1322 */
1323
1324 if ((eswp = findexecsw(modl->exec_execsw->exec_magic)) == NULL) {
1325 mcp = mod_getctl(modlp);
1326 ASSERT(mcp != NULL);
1327 modname = mcp->mod_modname;
1328 magic = modl->exec_execsw->exec_magic;
1329 magic_size = modl->exec_execsw->exec_maglen;
1330 if ((eswp = allocate_execsw(modname, magic, magic_size)) ==
1331 NULL) {
1332 printf("no unused entries in 'execsw'\n");
1333 return (ENOSPC);
1334 }
1335 }
1336 if (eswp->exec_func != NULL) {
1337 printf("exec type %x is already installed\n",
1338 *eswp->exec_magic);
1339 return (EBUSY); /* it's already there! */
1340 }
1341
1342 rw_enter(eswp->exec_lock, RW_WRITER);
1343 eswp->exec_func = modl->exec_execsw->exec_func;
1344 eswp->exec_core = modl->exec_execsw->exec_core;
1345 rw_exit(eswp->exec_lock);
1346
1347 return (0);
1348 }
1349
1350 /*
1351 * Remove an exec module.
1352 */
1353 static int
1354 mod_removeexec(struct modlexec *modl, struct modlinkage *modlp)
1355 {
1356 struct execsw *eswp;
1357 struct modctl *mcp;
1358 char *modname;
1359
1360 eswp = findexecsw(modl->exec_execsw->exec_magic);
1361 if (eswp == NULL) {
1362 mcp = mod_getctl(modlp);
1363 ASSERT(mcp != NULL);
1364 modname = mcp->mod_modname;
1365 cmn_err(CE_WARN, uninstall_err, modname);
1366 return (EINVAL);
1367 }
1368 if (moddebug & MODDEBUG_NOAUL_EXEC ||
1369 !rw_tryenter(eswp->exec_lock, RW_WRITER))
1370 return (EBUSY);
1371 eswp->exec_func = NULL;
1372 eswp->exec_core = NULL;
1373 rw_exit(eswp->exec_lock);
1374 return (0);
1375 }
1376
1377 /*
1378 * Find a free sysent entry or check if the specified one is free.
1379 */
1380 static struct sysent *
1381 mod_getsysent(struct modlinkage *modlp, struct sysent *se)
1382 {
1383 int sysnum;
1384 struct modctl *mcp;
1385 char *mod_name;
1386
1387 if ((mcp = mod_getctl(modlp)) == NULL) {
1388 /*
1389 * This happens when we're looking up the module
1390 * pointer as part of a stub installation. So
1391 * there's no need to whine at this point.
1392 */
1393 return (NULL);
1394 }
1395
1396 mod_name = mcp->mod_modname;
1397
1398 if ((sysnum = mod_getsysnum(mod_name)) == -1) {
1399 cmn_err(CE_WARN, "system call missing from bind file");
1400 return (NULL);
1401 }
1402
1403 if (sysnum > 0 && sysnum < NSYSCALL &&
1404 (se[sysnum].sy_flags & (SE_LOADABLE | SE_NOUNLOAD)))
1405 return (se + sysnum);
1406
1407 cmn_err(CE_WARN, "system call entry %d is already in use", sysnum);
1408 return (NULL);
1409 }
1410
1411 /*
1412 * IP Policy Modules.
1413 */
1414 /*ARGSUSED*/
1415 static int
1416 mod_infoipp(struct modlipp *modl, struct modlinkage *modlp, int *p0)
1417 {
1418 struct modctl *mcp = mod_getctl(modlp);
1419 ipp_mod_id_t mid;
1420
1421 if (mcp == NULL) {
1422 *p0 = -1;
1423 return (0); /* module is not yet installed */
1424 }
1425
1426 mid = ipp_mod_lookup(mcp->mod_modname);
1427
1428 *p0 = mid;
1429 return (0);
1430 }
1431
1432 static int
1433 mod_installipp(struct modlipp *modl, struct modlinkage *modlp)
1434 {
1435 struct modctl *mcp = mod_getctl(modlp);
1436
1437 ASSERT(mcp != NULL);
1438 return (ipp_mod_register(mcp->mod_modname, modl->ipp_ops));
1439 }
1440
1441 /*ARGSUSED*/
1442 static int
1443 mod_removeipp(struct modlipp *modl, struct modlinkage *modlp)
1444 {
1445 struct modctl *mcp = mod_getctl(modlp);
1446 extern kthread_id_t mod_aul_thread;
1447 ipp_mod_id_t mid;
1448
1449 ASSERT(mcp != NULL);
1450
1451 if ((moddebug & MODDEBUG_NOAUL_IPP) && (mod_aul_thread == curthread))
1452 return (EBUSY);
1453
1454 mid = ipp_mod_lookup(mcp->mod_modname);
1455 ASSERT(mid != IPP_MOD_INVAL);
1456
1457 return (ipp_mod_unregister(mid));
1458 }
1459
1460 /*
1461 * Manage kiconv modules.
1462 */
1463 /*ARGSUSED*/
1464 static int
1465 mod_installkiconv(struct modlkiconv *modl, struct modlinkage *modlp)
1466 {
1467 return (kiconv_register_module(modl->kiconv_moddef));
1468 }
1469
1470 /*ARGSUSED*/
1471 static int
1472 mod_removekiconv(struct modlkiconv *modl, struct modlinkage *modlp)
1473 {
1474 return (kiconv_unregister_module(modl->kiconv_moddef));
1475 }