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 /*
23 * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 /*
27 * modctl system call for loadable module support.
28 */
29
30 #include <sys/param.h>
31 #include <sys/user.h>
32 #include <sys/systm.h>
33 #include <sys/exec.h>
34 #include <sys/file.h>
35 #include <sys/stat.h>
36 #include <sys/conf.h>
37 #include <sys/time.h>
38 #include <sys/reboot.h>
39 #include <sys/fs/ufs_fsdir.h>
40 #include <sys/kmem.h>
41 #include <sys/sysconf.h>
42 #include <sys/cmn_err.h>
43 #include <sys/ddi.h>
44 #include <sys/sunddi.h>
45 #include <sys/sunndi.h>
46 #include <sys/ndi_impldefs.h>
47 #include <sys/ddi_impldefs.h>
48 #include <sys/ddi_implfuncs.h>
49 #include <sys/bootconf.h>
50 #include <sys/dc_ki.h>
51 #include <sys/cladm.h>
52 #include <sys/dtrace.h>
53 #include <sys/kdi.h>
54
55 #include <sys/devpolicy.h>
56 #include <sys/modctl.h>
57 #include <sys/kobj.h>
58 #include <sys/devops.h>
59 #include <sys/autoconf.h>
60 #include <sys/hwconf.h>
61 #include <sys/callb.h>
62 #include <sys/debug.h>
63 #include <sys/cpuvar.h>
64 #include <sys/sysmacros.h>
65 #include <sys/sysevent.h>
66 #include <sys/sysevent_impl.h>
67 #include <sys/instance.h>
68 #include <sys/modhash.h>
69 #include <sys/modhash_impl.h>
70 #include <sys/dacf_impl.h>
71 #include <sys/vfs.h>
72 #include <sys/pathname.h>
73 #include <sys/console.h>
74 #include <sys/policy.h>
75 #include <ipp/ipp_impl.h>
76 #include <sys/fs/dv_node.h>
77 #include <sys/strsubr.h>
78 #include <sys/fs/sdev_impl.h>
79
80 static int mod_circdep(struct modctl *);
81 static int modinfo(modid_t, struct modinfo *);
82
83 static void mod_uninstall_all(void);
84 static int mod_getinfo(struct modctl *, struct modinfo *);
85 static struct modctl *allocate_modp(const char *, const char *);
86
87 static int mod_load(struct modctl *, int);
88 static void mod_unload(struct modctl *);
89 static int modinstall(struct modctl *);
90 static int moduninstall(struct modctl *);
91
92 static struct modctl *mod_hold_by_name_common(struct modctl *, const char *);
93 static struct modctl *mod_hold_next_by_id(modid_t);
94 static struct modctl *mod_hold_loaded_mod(struct modctl *, char *, int *);
95 static struct modctl *mod_hold_installed_mod(char *, int, int, int *);
96
97 static void mod_release(struct modctl *);
98 static void mod_make_requisite(struct modctl *, struct modctl *);
99 static int mod_install_requisites(struct modctl *);
100 static void check_esc_sequences(char *, char *);
101 static struct modctl *mod_hold_by_name_requisite(struct modctl *, char *);
102
103 /*
104 * module loading thread control structure. Calls to kobj_load_module()() are
105 * handled off to a separate thead using this structure.
106 */
107 struct loadmt {
108 ksema_t sema;
109 struct modctl *mp;
110 int usepath;
111 kthread_t *owner;
112 int retval;
113 };
114
115 static void modload_thread(struct loadmt *);
116
117 kcondvar_t mod_cv;
118 kcondvar_t mod_uninstall_cv; /* Communication between swapper */
119 /* and the uninstall daemon. */
120 kmutex_t mod_lock; /* protects &modules insert linkage, */
121 /* mod_busy, mod_want, and mod_ref. */
122 /* blocking operations while holding */
123 /* mod_lock should be avoided */
124 kmutex_t mod_uninstall_lock; /* protects mod_uninstall_cv */
125 kthread_id_t mod_aul_thread;
126
127 int modunload_wait;
128 kmutex_t modunload_wait_mutex;
129 kcondvar_t modunload_wait_cv;
130 int modunload_active_count;
131 int modunload_disable_count;
132
133 int isminiroot; /* set if running as miniroot */
134 int modrootloaded; /* set after root driver and fs are loaded */
135 int moddebug = 0x0; /* debug flags for module writers */
136 int swaploaded; /* set after swap driver and fs are loaded */
137 int bop_io_quiesced = 0; /* set when BOP I/O can no longer be used */
138 int last_module_id;
139 clock_t mod_uninstall_interval = 0;
140 int mod_uninstall_pass_max = 6;
141 int mod_uninstall_ref_zero; /* # modules that went mod_ref == 0 */
142 int mod_uninstall_pass_exc; /* mod_uninstall_all left new stuff */
143
144 int ddi_modclose_unload = 1; /* 0 -> just decrement reference */
145
146 int devcnt_incr = 256; /* allow for additional drivers */
147 int devcnt_min = 512; /* and always at least this number */
148
149 struct devnames *devnamesp;
150 struct devnames orphanlist;
151
152 krwlock_t devinfo_tree_lock; /* obsolete, to be removed */
153
154 #define MAJBINDFILE "/etc/name_to_major"
155 #define SYSBINDFILE "/etc/name_to_sysnum"
156
157 static char majbind[] = MAJBINDFILE;
158 static char sysbind[] = SYSBINDFILE;
159 static uint_t mod_autounload_key; /* for module autounload detection */
160
161 extern int obpdebug;
162
163 #define DEBUGGER_PRESENT ((boothowto & RB_DEBUG) || (obpdebug != 0))
164
165 static int minorperm_loaded = 0;
166
167 void
168 mod_setup(void)
169 {
170 struct sysent *callp;
171 int callnum, exectype;
172 int num_devs;
173 int i;
174
175 /*
176 * Initialize the list of loaded driver dev_ops.
177 * XXX - This must be done before reading the system file so that
178 * forceloads of drivers will work.
179 */
180 num_devs = read_binding_file(majbind, mb_hashtab, make_mbind);
181 /*
182 * Since read_binding_file is common code, it doesn't enforce that all
183 * of the binding file entries have major numbers <= MAXMAJ32. Thus,
184 * ensure that we don't allocate some massive amount of space due to a
185 * bad entry. We can't have major numbers bigger than MAXMAJ32
186 * until file system support for larger major numbers exists.
187 */
188
189 /*
190 * Leave space for expansion, but not more than L_MAXMAJ32
191 */
192 devcnt = MIN(num_devs + devcnt_incr, L_MAXMAJ32);
193 devcnt = MAX(devcnt, devcnt_min);
194 devopsp = kmem_alloc(devcnt * sizeof (struct dev_ops *), KM_SLEEP);
195 for (i = 0; i < devcnt; i++)
196 devopsp[i] = &mod_nodev_ops;
197
198 init_devnamesp(devcnt);
199
200 /*
201 * Sync up with the work that the stand-alone linker has already done.
202 */
203 (void) kobj_sync();
204
205 if (boothowto & RB_DEBUG)
206 kdi_dvec_modavail();
207
208 make_aliases(mb_hashtab);
209
210 /*
211 * Initialize streams device implementation structures.
212 */
213 devimpl = kmem_zalloc(devcnt * sizeof (cdevsw_impl_t), KM_SLEEP);
214
215 /*
216 * If the cl_bootstrap module is present,
217 * we should be configured as a cluster. Loading this module
218 * will set "cluster_bootflags" to non-zero.
219 */
220 (void) modload("misc", "cl_bootstrap");
221
222 (void) read_binding_file(sysbind, sb_hashtab, make_mbind);
223 init_syscallnames(NSYSCALL);
224
225 /*
226 * Start up dynamic autoconfiguration framework (dacf).
227 */
228 mod_hash_init();
229 dacf_init();
230
231 /*
232 * Start up IP policy framework (ipp).
233 */
234 ipp_init();
235
236 /*
237 * Allocate loadable native system call locks.
238 */
239 for (callnum = 0, callp = sysent; callnum < NSYSCALL;
240 callnum++, callp++) {
241 if (LOADABLE_SYSCALL(callp)) {
242 if (mod_getsysname(callnum) != NULL) {
243 callp->sy_lock =
244 kobj_zalloc(sizeof (krwlock_t), KM_SLEEP);
245 rw_init(callp->sy_lock, NULL, RW_DEFAULT, NULL);
246 } else {
247 callp->sy_flags &= ~SE_LOADABLE;
248 callp->sy_callc = nosys;
249 }
250 #ifdef DEBUG
251 } else {
252 /*
253 * Do some sanity checks on the sysent table
254 */
255 switch (callp->sy_flags & SE_RVAL_MASK) {
256 case SE_32RVAL1:
257 /* only r_val1 returned */
258 case SE_32RVAL1 | SE_32RVAL2:
259 /* r_val1 and r_val2 returned */
260 case SE_64RVAL:
261 /* 64-bit rval returned */
262 break;
263 default:
264 cmn_err(CE_WARN, "sysent[%d]: bad flags %x",
265 callnum, callp->sy_flags);
266 }
267 #endif
268 }
269 }
270
271 #ifdef _SYSCALL32_IMPL
272 /*
273 * Allocate loadable system call locks for 32-bit compat syscalls
274 */
275 for (callnum = 0, callp = sysent32; callnum < NSYSCALL;
276 callnum++, callp++) {
277 if (LOADABLE_SYSCALL(callp)) {
278 if (mod_getsysname(callnum) != NULL) {
279 callp->sy_lock =
280 kobj_zalloc(sizeof (krwlock_t), KM_SLEEP);
281 rw_init(callp->sy_lock, NULL, RW_DEFAULT, NULL);
282 } else {
283 callp->sy_flags &= ~SE_LOADABLE;
284 callp->sy_callc = nosys;
285 }
286 #ifdef DEBUG
287 } else {
288 /*
289 * Do some sanity checks on the sysent table
290 */
291 switch (callp->sy_flags & SE_RVAL_MASK) {
292 case SE_32RVAL1:
293 /* only r_val1 returned */
294 case SE_32RVAL1 | SE_32RVAL2:
295 /* r_val1 and r_val2 returned */
296 case SE_64RVAL:
297 /* 64-bit rval returned */
298 break;
299 default:
300 cmn_err(CE_WARN, "sysent32[%d]: bad flags %x",
301 callnum, callp->sy_flags);
302 goto skip;
303 }
304
305 /*
306 * Cross-check the native and compatibility tables.
307 */
308 if (callp->sy_callc == nosys ||
309 sysent[callnum].sy_callc == nosys)
310 continue;
311 /*
312 * If only one or the other slot is loadable, then
313 * there's an error -- they should match!
314 */
315 if ((callp->sy_callc == loadable_syscall) ^
316 (sysent[callnum].sy_callc == loadable_syscall)) {
317 cmn_err(CE_WARN, "sysent[%d] loadable?",
318 callnum);
319 }
320 /*
321 * This is more of a heuristic test -- if the
322 * system call returns two values in the 32-bit
323 * world, it should probably return two 32-bit
324 * values in the 64-bit world too.
325 */
326 if (((callp->sy_flags & SE_32RVAL2) == 0) ^
327 ((sysent[callnum].sy_flags & SE_32RVAL2) == 0)) {
328 cmn_err(CE_WARN, "sysent[%d] rval2 mismatch!",
329 callnum);
330 }
331 skip:;
332 #endif /* DEBUG */
333 }
334 }
335 #endif /* _SYSCALL32_IMPL */
336
337 /*
338 * Allocate loadable exec locks. (Assumes all execs are loadable)
339 */
340 for (exectype = 0; exectype < nexectype; exectype++) {
341 execsw[exectype].exec_lock =
342 kobj_zalloc(sizeof (krwlock_t), KM_SLEEP);
343 rw_init(execsw[exectype].exec_lock, NULL, RW_DEFAULT, NULL);
344 }
345
346 read_class_file();
347
348 /* init thread specific structure for mod_uninstall_all */
349 tsd_create(&mod_autounload_key, NULL);
350 }
351
352 static int
353 modctl_modload(int use_path, char *filename, int *rvp)
354 {
355 struct modctl *modp;
356 int retval = 0;
357 char *filenamep;
358 int modid;
359
360 filenamep = kmem_zalloc(MOD_MAXPATH, KM_SLEEP);
361
362 if (copyinstr(filename, filenamep, MOD_MAXPATH, 0)) {
363 retval = EFAULT;
364 goto out;
365 }
366
367 filenamep[MOD_MAXPATH - 1] = 0;
368 modp = mod_hold_installed_mod(filenamep, use_path, 0, &retval);
369
370 if (modp == NULL)
371 goto out;
372
373 modp->mod_loadflags |= MOD_NOAUTOUNLOAD;
374 modid = modp->mod_id;
375 mod_release_mod(modp);
376 CPU_STATS_ADDQ(CPU, sys, modload, 1);
377 if (rvp != NULL && copyout(&modid, rvp, sizeof (modid)) != 0)
378 retval = EFAULT;
379 out:
380 kmem_free(filenamep, MOD_MAXPATH);
381
382 return (retval);
383 }
384
385 static int
386 modctl_modunload(modid_t id)
387 {
388 int rval = 0;
389
390 if (id == 0) {
391 #ifdef DEBUG
392 /*
393 * Turn on mod_uninstall_daemon
394 */
395 if (mod_uninstall_interval == 0) {
396 mod_uninstall_interval = 60;
397 modreap();
398 return (rval);
399 }
400 #endif
401 mod_uninstall_all();
402 } else {
403 rval = modunload(id);
404 }
405 return (rval);
406 }
407
408 static int
409 modctl_modinfo(modid_t id, struct modinfo *umodi)
410 {
411 int retval;
412 struct modinfo modi;
413 #if defined(_SYSCALL32_IMPL)
414 int nobase;
415 struct modinfo32 modi32;
416 #endif
417
418 nobase = 0;
419 if (get_udatamodel() == DATAMODEL_NATIVE) {
420 if (copyin(umodi, &modi, sizeof (struct modinfo)) != 0)
421 return (EFAULT);
422 }
423 #ifdef _SYSCALL32_IMPL
424 else {
425 bzero(&modi, sizeof (modi));
426 if (copyin(umodi, &modi32, sizeof (struct modinfo32)) != 0)
427 return (EFAULT);
428 modi.mi_info = modi32.mi_info;
429 modi.mi_id = modi32.mi_id;
430 modi.mi_nextid = modi32.mi_nextid;
431 nobase = modi.mi_info & MI_INFO_NOBASE;
432 }
433 #endif
434 /*
435 * This flag is -only- for the kernels use.
436 */
437 modi.mi_info &= ~MI_INFO_LINKAGE;
438
439 retval = modinfo(id, &modi);
440 if (retval)
441 return (retval);
442
443 if (get_udatamodel() == DATAMODEL_NATIVE) {
444 if (copyout(&modi, umodi, sizeof (struct modinfo)) != 0)
445 retval = EFAULT;
446 #ifdef _SYSCALL32_IMPL
447 } else {
448 int i;
449
450 if (!nobase && (uintptr_t)modi.mi_base > UINT32_MAX)
451 return (EOVERFLOW);
452
453 modi32.mi_info = modi.mi_info;
454 modi32.mi_state = modi.mi_state;
455 modi32.mi_id = modi.mi_id;
456 modi32.mi_nextid = modi.mi_nextid;
457 modi32.mi_base = (caddr32_t)(uintptr_t)modi.mi_base;
458 modi32.mi_size = modi.mi_size;
459 modi32.mi_rev = modi.mi_rev;
460 modi32.mi_loadcnt = modi.mi_loadcnt;
461 bcopy(modi.mi_name, modi32.mi_name, sizeof (modi32.mi_name));
462 for (i = 0; i < MODMAXLINK32; i++) {
463 modi32.mi_msinfo[i].msi_p0 = modi.mi_msinfo[i].msi_p0;
464 bcopy(modi.mi_msinfo[i].msi_linkinfo,
465 modi32.mi_msinfo[i].msi_linkinfo,
466 sizeof (modi32.mi_msinfo[0].msi_linkinfo));
467 }
468 if (copyout(&modi32, umodi, sizeof (struct modinfo32)) != 0)
469 retval = EFAULT;
470 #endif
471 }
472
473 return (retval);
474 }
475
476 /*
477 * Return the last major number in the range of permissible major numbers.
478 */
479 /*ARGSUSED*/
480 static int
481 modctl_modreserve(modid_t id, int *data)
482 {
483 if (copyout(&devcnt, data, sizeof (devcnt)) != 0)
484 return (EFAULT);
485 return (0);
486 }
487
488 /* Add/Remove driver and binding aliases */
489 static int
490 modctl_update_driver_aliases(int add, int *data)
491 {
492 struct modconfig mc;
493 int i, n, rv = 0;
494 struct aliases alias;
495 struct aliases *ap;
496 char name[MAXMODCONFNAME];
497 char cname[MAXMODCONFNAME];
498 char *drvname;
499 int resid;
500 struct alias_info {
501 char *alias_name;
502 int alias_resid;
503 } *aliases, *aip;
504
505 aliases = NULL;
506 bzero(&mc, sizeof (struct modconfig));
507 if (get_udatamodel() == DATAMODEL_NATIVE) {
508 if (copyin(data, &mc, sizeof (struct modconfig)) != 0)
509 return (EFAULT);
510 }
511 #ifdef _SYSCALL32_IMPL
512 else {
513 struct modconfig32 modc32;
514 if (copyin(data, &modc32, sizeof (struct modconfig32)) != 0)
515 return (EFAULT);
516 else {
517 bcopy(modc32.drvname, mc.drvname,
518 sizeof (modc32.drvname));
519 bcopy(modc32.drvclass, mc.drvclass,
520 sizeof (modc32.drvclass));
521 mc.major = modc32.major;
522 mc.flags = modc32.flags;
523 mc.num_aliases = modc32.num_aliases;
524 mc.ap = (struct aliases *)(uintptr_t)modc32.ap;
525 }
526 }
527 #endif
528
529 /*
530 * If the driver is already in the mb_hashtab, and the name given
531 * doesn't match that driver's name, fail. Otherwise, pass, since
532 * we may be adding aliases.
533 */
534 drvname = mod_major_to_name(mc.major);
535 if ((drvname != NULL) && strcmp(drvname, mc.drvname) != 0)
536 return (EINVAL);
537
538 /*
539 * Precede alias removal by unbinding as many devices as possible.
540 */
541 if (add == 0) {
542 (void) i_ddi_unload_drvconf(mc.major);
543 i_ddi_unbind_devs(mc.major);
544 }
545
546 /*
547 * Add/remove each supplied driver alias to/from mb_hashtab
548 */
549 ap = mc.ap;
550 if (mc.num_aliases > 0)
551 aliases = kmem_zalloc(
552 mc.num_aliases * sizeof (struct alias_info), KM_SLEEP);
553 aip = aliases;
554 for (i = 0; i < mc.num_aliases; i++) {
555 bzero(&alias, sizeof (struct aliases));
556 if (get_udatamodel() == DATAMODEL_NATIVE) {
557 if (copyin(ap, &alias, sizeof (struct aliases)) != 0) {
558 rv = EFAULT;
559 goto error;
560 }
561 if (alias.a_len > MAXMODCONFNAME) {
562 rv = EINVAL;
563 goto error;
564 }
565 if (copyin(alias.a_name, name, alias.a_len) != 0) {
566 rv = EFAULT;
567 goto error;
568 }
569 if (name[alias.a_len - 1] != '\0') {
570 rv = EINVAL;
571 goto error;
572 }
573 }
574 #ifdef _SYSCALL32_IMPL
575 else {
576 struct aliases32 al32;
577 bzero(&al32, sizeof (struct aliases32));
578 if (copyin(ap, &al32, sizeof (struct aliases32)) != 0) {
579 rv = EFAULT;
580 goto error;
581 }
582 if (al32.a_len > MAXMODCONFNAME) {
583 rv = EINVAL;
584 goto error;
585 }
586 if (copyin((void *)(uintptr_t)al32.a_name,
587 name, al32.a_len) != 0) {
588 rv = EFAULT;
589 goto error;
590 }
591 if (name[al32.a_len - 1] != '\0') {
592 rv = EINVAL;
593 goto error;
594 }
595 alias.a_next = (void *)(uintptr_t)al32.a_next;
596 }
597 #endif
598 check_esc_sequences(name, cname);
599 aip->alias_name = strdup(cname);
600 ap = alias.a_next;
601 aip++;
602 }
603
604 if (add == 0) {
605 ap = mc.ap;
606 resid = 0;
607 aip = aliases;
608 /* attempt to unbind all devices bound to each alias */
609 for (i = 0; i < mc.num_aliases; i++) {
610 n = i_ddi_unbind_devs_by_alias(
611 mc.major, aip->alias_name);
612 resid += n;
613 aip->alias_resid = n;
614 }
615
616 /*
617 * If some device bound to an alias remains in use,
618 * and override wasn't specified, no change is made to
619 * the binding state and we fail the operation.
620 */
621 if (resid > 0 && ((mc.flags & MOD_UNBIND_OVERRIDE) == 0)) {
622 rv = EBUSY;
623 goto error;
624 }
625
626 /*
627 * No device remains bound of any of the aliases,
628 * or force was requested. Mark each alias as
629 * inactive via delete_mbind so no future binds
630 * to this alias take place and that a new
631 * binding can be established.
632 */
633 aip = aliases;
634 for (i = 0; i < mc.num_aliases; i++) {
635 if (moddebug & MODDEBUG_BINDING)
636 cmn_err(CE_CONT, "Removing binding for %s "
637 "(%d active references)\n",
638 aip->alias_name, aip->alias_resid);
639 delete_mbind(aip->alias_name, mb_hashtab);
640 aip++;
641 }
642 rv = 0;
643 } else {
644 aip = aliases;
645 for (i = 0; i < mc.num_aliases; i++) {
646 if (moddebug & MODDEBUG_BINDING)
647 cmn_err(CE_NOTE, "Adding binding for '%s'\n",
648 aip->alias_name);
649 (void) make_mbind(aip->alias_name,
650 mc.major, NULL, mb_hashtab);
651 aip++;
652 }
653 /*
654 * Try to establish an mbinding for mc.drvname, and add it to
655 * devnames. Add class if any after establishing the major
656 * number.
657 */
658 (void) make_mbind(mc.drvname, mc.major, NULL, mb_hashtab);
659 if ((rv = make_devname(mc.drvname, mc.major,
660 (mc.flags & MOD_ADDMAJBIND_UPDATE) ?
661 DN_DRIVER_INACTIVE : 0)) != 0) {
662 goto error;
663 }
664
665 if (mc.drvclass[0] != '\0')
666 add_class(mc.drvname, mc.drvclass);
667 if ((mc.flags & MOD_ADDMAJBIND_UPDATE) == 0) {
668 (void) i_ddi_load_drvconf(mc.major);
669 }
670 }
671
672 /*
673 * Ensure that all nodes are bound to the most appropriate driver
674 * possible, attempting demotion and rebind when a more appropriate
675 * driver now exists. But not when adding a driver update-only.
676 */
677 if ((add == 0) || ((mc.flags & MOD_ADDMAJBIND_UPDATE) == 0)) {
678 i_ddi_bind_devs();
679 i_ddi_di_cache_invalidate();
680 }
681
682 error:
683 if (mc.num_aliases > 0) {
684 aip = aliases;
685 for (i = 0; i < mc.num_aliases; i++) {
686 if (aip->alias_name != NULL)
687 strfree(aip->alias_name);
688 aip++;
689 }
690 kmem_free(aliases, mc.num_aliases * sizeof (struct alias_info));
691 }
692 return (rv);
693 }
694
695 static int
696 modctl_add_driver_aliases(int *data)
697 {
698 return (modctl_update_driver_aliases(1, data));
699 }
700
701 static int
702 modctl_remove_driver_aliases(int *data)
703 {
704 return (modctl_update_driver_aliases(0, data));
705 }
706
707 static int
708 modctl_rem_major(major_t major)
709 {
710 struct devnames *dnp;
711
712 if (major >= devcnt)
713 return (EINVAL);
714
715 /* mark devnames as removed */
716 dnp = &devnamesp[major];
717 LOCK_DEV_OPS(&dnp->dn_lock);
718 if (dnp->dn_name == NULL ||
719 (dnp->dn_flags & (DN_DRIVER_REMOVED | DN_TAKEN_GETUDEV))) {
720 UNLOCK_DEV_OPS(&dnp->dn_lock);
721 return (EINVAL);
722 }
723 dnp->dn_flags |= DN_DRIVER_REMOVED;
724 pm_driver_removed(major);
725 UNLOCK_DEV_OPS(&dnp->dn_lock);
726
727 (void) i_ddi_unload_drvconf(major);
728 i_ddi_unbind_devs(major);
729 i_ddi_bind_devs();
730 i_ddi_di_cache_invalidate();
731
732 /* purge all the bindings to this driver */
733 purge_mbind(major, mb_hashtab);
734 return (0);
735 }
736
737 static struct vfs *
738 path_to_vfs(char *name)
739 {
740 vnode_t *vp;
741 struct vfs *vfsp;
742
743 if (lookupname(name, UIO_SYSSPACE, FOLLOW, NULLVPP, &vp))
744 return (NULL);
745
746 vfsp = vp->v_vfsp;
747 VN_RELE(vp);
748 return (vfsp);
749 }
750
751 static int
752 new_vfs_in_modpath()
753 {
754 static int n_modpath = 0;
755 static char *modpath_copy;
756 static struct pathvfs {
757 char *path;
758 struct vfs *vfsp;
759 } *pathvfs;
760
761 int i, new_vfs = 0;
762 char *tmp, *tmp1;
763 struct vfs *vfsp;
764
765 if (n_modpath != 0) {
766 for (i = 0; i < n_modpath; i++) {
767 vfsp = path_to_vfs(pathvfs[i].path);
768 if (vfsp != pathvfs[i].vfsp) {
769 pathvfs[i].vfsp = vfsp;
770 if (vfsp)
771 new_vfs = 1;
772 }
773 }
774 return (new_vfs);
775 }
776
777 /*
778 * First call, initialize the pathvfs structure
779 */
780 modpath_copy = i_ddi_strdup(default_path, KM_SLEEP);
781 tmp = modpath_copy;
782 n_modpath = 1;
783 tmp1 = strchr(tmp, ' ');
784 while (tmp1) {
785 *tmp1 = '\0';
786 n_modpath++;
787 tmp = tmp1 + 1;
788 tmp1 = strchr(tmp, ' ');
789 }
790
791 pathvfs = kmem_zalloc(n_modpath * sizeof (struct pathvfs), KM_SLEEP);
792 tmp = modpath_copy;
793 for (i = 0; i < n_modpath; i++) {
794 pathvfs[i].path = tmp;
795 vfsp = path_to_vfs(tmp);
796 pathvfs[i].vfsp = vfsp;
797 tmp += strlen(tmp) + 1;
798 }
799 return (1); /* always reread driver.conf the first time */
800 }
801
802 static int
803 modctl_load_drvconf(major_t major, int flags)
804 {
805 int ret;
806
807 /*
808 * devfsadm -u - read all new driver.conf files
809 * and bind and configure devices for new drivers.
810 */
811 if (flags & MOD_LOADDRVCONF_RECONF) {
812 (void) i_ddi_load_drvconf(DDI_MAJOR_T_NONE);
813 i_ddi_bind_devs();
814 i_ddi_di_cache_invalidate();
815 return (0);
816 }
817
818 /*
819 * update_drv <drv> - reload driver.conf for the specified driver
820 */
821 if (major != DDI_MAJOR_T_NONE) {
822 ret = i_ddi_load_drvconf(major);
823 if (ret == 0)
824 i_ddi_bind_devs();
825 return (ret);
826 }
827
828 /*
829 * We are invoked to rescan new driver.conf files. It is
830 * only necessary if a new file system was mounted in the
831 * module_path. Because rescanning driver.conf files can
832 * take some time on older platforms (sun4m), the following
833 * code skips unnecessary driver.conf rescans to optimize
834 * boot performance.
835 */
836 if (new_vfs_in_modpath()) {
837 (void) i_ddi_load_drvconf(DDI_MAJOR_T_NONE);
838 /*
839 * If we are still initializing io subsystem,
840 * load drivers with ddi-forceattach property
841 */
842 if (!i_ddi_io_initialized())
843 i_ddi_forceattach_drivers();
844 }
845 return (0);
846 }
847
848 /*
849 * Unload driver.conf file and follow up by attempting
850 * to rebind devices to more appropriate driver.
851 */
852 static int
853 modctl_unload_drvconf(major_t major)
854 {
855 int ret;
856
857 if (major >= devcnt)
858 return (EINVAL);
859
860 ret = i_ddi_unload_drvconf(major);
861 if (ret != 0)
862 return (ret);
863 (void) i_ddi_unbind_devs(major);
864 i_ddi_bind_devs();
865
866 return (0);
867 }
868
869 static void
870 check_esc_sequences(char *str, char *cstr)
871 {
872 int i;
873 size_t len;
874 char *p;
875
876 len = strlen(str);
877 for (i = 0; i < len; i++, str++, cstr++) {
878 if (*str != '\\') {
879 *cstr = *str;
880 } else {
881 p = str + 1;
882 /*
883 * we only handle octal escape sequences for SPACE
884 */
885 if (*p++ == '0' && *p++ == '4' && *p == '0') {
886 *cstr = ' ';
887 str += 3;
888 } else {
889 *cstr = *str;
890 }
891 }
892 }
893 *cstr = 0;
894 }
895
896 static int
897 modctl_getmodpathlen(int *data)
898 {
899 int len;
900 len = strlen(default_path);
901 if (copyout(&len, data, sizeof (len)) != 0)
902 return (EFAULT);
903 return (0);
904 }
905
906 static int
907 modctl_getmodpath(char *data)
908 {
909 if (copyout(default_path, data, strlen(default_path) + 1) != 0)
910 return (EFAULT);
911 return (0);
912 }
913
914 static int
915 modctl_read_sysbinding_file(void)
916 {
917 (void) read_binding_file(sysbind, sb_hashtab, make_mbind);
918 return (0);
919 }
920
921 static int
922 modctl_getmaj(char *uname, uint_t ulen, int *umajorp)
923 {
924 char name[256];
925 int retval;
926 major_t major;
927
928 if (ulen == 0)
929 return (EINVAL);
930 if ((retval = copyinstr(uname, name,
931 (ulen < 256) ? ulen : 256, 0)) != 0)
932 return (retval);
933 if ((major = mod_name_to_major(name)) == DDI_MAJOR_T_NONE)
934 return (ENODEV);
935 if (copyout(&major, umajorp, sizeof (major_t)) != 0)
936 return (EFAULT);
937 return (0);
938 }
939
940 static char **
941 convert_constraint_string(char *constraints, size_t len)
942 {
943 int i;
944 int n;
945 char *p;
946 char **array;
947
948 ASSERT(constraints != NULL);
949 ASSERT(len > 0);
950
951 for (i = 0, p = constraints; strlen(p) > 0; i++, p += strlen(p) + 1)
952 ;
953
954 n = i;
955
956 if (n == 0) {
957 kmem_free(constraints, len);
958 return (NULL);
959 }
960
961 array = kmem_alloc((n + 1) * sizeof (char *), KM_SLEEP);
962
963 for (i = 0, p = constraints; i < n; i++, p += strlen(p) + 1) {
964 array[i] = i_ddi_strdup(p, KM_SLEEP);
965 }
966 array[n] = NULL;
967
968 kmem_free(constraints, len);
969
970 return (array);
971 }
972 /*ARGSUSED*/
973 static int
974 modctl_retire(char *path, char *uconstraints, size_t ulen)
975 {
976 char *pathbuf;
977 char *devpath;
978 size_t pathsz;
979 int retval;
980 char *constraints;
981 char **cons_array;
982
983 if (path == NULL)
984 return (EINVAL);
985
986 if ((uconstraints == NULL) ^ (ulen == 0))
987 return (EINVAL);
988
989 pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP);
990 retval = copyinstr(path, pathbuf, MAXPATHLEN, &pathsz);
991 if (retval != 0) {
992 kmem_free(pathbuf, MAXPATHLEN);
993 return (retval);
994 }
995 devpath = i_ddi_strdup(pathbuf, KM_SLEEP);
996 kmem_free(pathbuf, MAXPATHLEN);
997
998 /*
999 * First check if the device is already retired.
1000 * If it is, then persist the retire anyway, just in case the retire
1001 * store has got out of sync with the boot archive.
1002 */
1003 if (e_ddi_device_retired(devpath)) {
1004 cmn_err(CE_NOTE, "Device: already retired: %s", devpath);
1005 (void) e_ddi_retire_persist(devpath);
1006 kmem_free(devpath, strlen(devpath) + 1);
1007 return (0);
1008 }
1009
1010 cons_array = NULL;
1011 if (uconstraints) {
1012 constraints = kmem_alloc(ulen, KM_SLEEP);
1013 if (copyin(uconstraints, constraints, ulen)) {
1014 kmem_free(constraints, ulen);
1015 kmem_free(devpath, strlen(devpath) + 1);
1016 return (EFAULT);
1017 }
1018 cons_array = convert_constraint_string(constraints, ulen);
1019 }
1020
1021 /*
1022 * Try to retire the device first. The following
1023 * routine will return an error only if the device
1024 * is not retireable i.e. retire constraints forbid
1025 * a retire. A return of success from this routine
1026 * indicates that device is retireable.
1027 */
1028 retval = e_ddi_retire_device(devpath, cons_array);
1029 if (retval != DDI_SUCCESS) {
1030 cmn_err(CE_WARN, "constraints forbid retire: %s", devpath);
1031 kmem_free(devpath, strlen(devpath) + 1);
1032 return (ENOTSUP);
1033 }
1034
1035 /*
1036 * Ok, the retire succeeded. Persist the retire.
1037 * If retiring a nexus, we need to only persist the
1038 * nexus retire. Any children of a retired nexus
1039 * are automatically covered by the retire store
1040 * code.
1041 */
1042 retval = e_ddi_retire_persist(devpath);
1043 if (retval != 0) {
1044 cmn_err(CE_WARN, "Failed to persist device retire: error %d: "
1045 "%s", retval, devpath);
1046 kmem_free(devpath, strlen(devpath) + 1);
1047 return (retval);
1048 }
1049 if (moddebug & MODDEBUG_RETIRE)
1050 cmn_err(CE_NOTE, "Persisted retire of device: %s", devpath);
1051
1052 kmem_free(devpath, strlen(devpath) + 1);
1053 return (0);
1054 }
1055
1056 static int
1057 modctl_is_retired(char *path, int *statep)
1058 {
1059 char *pathbuf;
1060 char *devpath;
1061 size_t pathsz;
1062 int error;
1063 int status;
1064
1065 if (path == NULL || statep == NULL)
1066 return (EINVAL);
1067
1068 pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP);
1069 error = copyinstr(path, pathbuf, MAXPATHLEN, &pathsz);
1070 if (error != 0) {
1071 kmem_free(pathbuf, MAXPATHLEN);
1072 return (error);
1073 }
1074 devpath = i_ddi_strdup(pathbuf, KM_SLEEP);
1075 kmem_free(pathbuf, MAXPATHLEN);
1076
1077 if (e_ddi_device_retired(devpath))
1078 status = 1;
1079 else
1080 status = 0;
1081 kmem_free(devpath, strlen(devpath) + 1);
1082
1083 return (copyout(&status, statep, sizeof (status)) ? EFAULT : 0);
1084 }
1085
1086 static int
1087 modctl_unretire(char *path)
1088 {
1089 char *pathbuf;
1090 char *devpath;
1091 size_t pathsz;
1092 int retired;
1093 int retval;
1094
1095 if (path == NULL)
1096 return (EINVAL);
1097
1098 pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP);
1099 retval = copyinstr(path, pathbuf, MAXPATHLEN, &pathsz);
1100 if (retval != 0) {
1101 kmem_free(pathbuf, MAXPATHLEN);
1102 return (retval);
1103 }
1104 devpath = i_ddi_strdup(pathbuf, KM_SLEEP);
1105 kmem_free(pathbuf, MAXPATHLEN);
1106
1107 /*
1108 * We check if a device is retired (first) before
1109 * unpersisting the retire, because we use the
1110 * retire store to determine if a device is retired.
1111 * If we unpersist first, the device will always appear
1112 * to be unretired. For the rationale behind unpersisting
1113 * a device that is not retired, see the next comment.
1114 */
1115 retired = e_ddi_device_retired(devpath);
1116
1117 /*
1118 * We call unpersist unconditionally because the lookup
1119 * for retired devices (e_ddi_device_retired()), skips "bypassed"
1120 * devices. We still want to be able remove "bypassed" entries
1121 * from the persistent store, so we unpersist unconditionally
1122 * i.e. whether or not the entry is found on a lookup.
1123 *
1124 * e_ddi_retire_unpersist() returns 1 if it found and cleared
1125 * an entry from the retire store or 0 otherwise.
1126 */
1127 if (e_ddi_retire_unpersist(devpath))
1128 if (moddebug & MODDEBUG_RETIRE) {
1129 cmn_err(CE_NOTE, "Unpersisted retire of device: %s",
1130 devpath);
1131 }
1132
1133 /*
1134 * Check if the device is already unretired. If so,
1135 * the unretire becomes a NOP
1136 */
1137 if (!retired) {
1138 cmn_err(CE_NOTE, "Not retired: %s", devpath);
1139 kmem_free(devpath, strlen(devpath) + 1);
1140 return (0);
1141 }
1142
1143 retval = e_ddi_unretire_device(devpath);
1144 if (retval != 0) {
1145 cmn_err(CE_WARN, "cannot unretire device: error %d, path %s\n",
1146 retval, devpath);
1147 }
1148
1149 kmem_free(devpath, strlen(devpath) + 1);
1150
1151 return (retval);
1152 }
1153
1154 static int
1155 modctl_getname(char *uname, uint_t ulen, int *umajorp)
1156 {
1157 char *name;
1158 major_t major;
1159
1160 if (copyin(umajorp, &major, sizeof (major)) != 0)
1161 return (EFAULT);
1162 if ((name = mod_major_to_name(major)) == NULL)
1163 return (ENODEV);
1164 if ((strlen(name) + 1) > ulen)
1165 return (ENOSPC);
1166 return (copyoutstr(name, uname, ulen, NULL));
1167 }
1168
1169 static int
1170 modctl_devt2instance(dev_t dev, int *uinstancep)
1171 {
1172 int instance;
1173
1174 if ((instance = dev_to_instance(dev)) == -1)
1175 return (EINVAL);
1176
1177 return (copyout(&instance, uinstancep, sizeof (int)));
1178 }
1179
1180 /*
1181 * Return the sizeof of the device id.
1182 */
1183 static int
1184 modctl_sizeof_devid(dev_t dev, uint_t *len)
1185 {
1186 uint_t sz;
1187 ddi_devid_t devid;
1188
1189 /* get device id */
1190 if (ddi_lyr_get_devid(dev, &devid) == DDI_FAILURE)
1191 return (EINVAL);
1192
1193 sz = ddi_devid_sizeof(devid);
1194 ddi_devid_free(devid);
1195
1196 /* copyout device id size */
1197 if (copyout(&sz, len, sizeof (sz)) != 0)
1198 return (EFAULT);
1199
1200 return (0);
1201 }
1202
1203 /*
1204 * Return a copy of the device id.
1205 */
1206 static int
1207 modctl_get_devid(dev_t dev, uint_t len, ddi_devid_t udevid)
1208 {
1209 uint_t sz;
1210 ddi_devid_t devid;
1211 int err = 0;
1212
1213 /* get device id */
1214 if (ddi_lyr_get_devid(dev, &devid) == DDI_FAILURE)
1215 return (EINVAL);
1216
1217 sz = ddi_devid_sizeof(devid);
1218
1219 /* Error if device id is larger than space allocated */
1220 if (sz > len) {
1221 ddi_devid_free(devid);
1222 return (ENOSPC);
1223 }
1224
1225 /* copy out device id */
1226 if (copyout(devid, udevid, sz) != 0)
1227 err = EFAULT;
1228 ddi_devid_free(devid);
1229 return (err);
1230 }
1231
1232 /*
1233 * return the /devices paths associated with the specified devid and
1234 * minor name.
1235 */
1236 /*ARGSUSED*/
1237 static int
1238 modctl_devid2paths(ddi_devid_t udevid, char *uminor_name, uint_t flag,
1239 size_t *ulensp, char *upaths)
1240 {
1241 ddi_devid_t devid = NULL;
1242 int devid_len;
1243 char *minor_name = NULL;
1244 dev_info_t *dip = NULL;
1245 int circ;
1246 struct ddi_minor_data *dmdp;
1247 char *path = NULL;
1248 int ulens;
1249 int lens;
1250 int len;
1251 dev_t *devlist = NULL;
1252 int ndevs;
1253 int i;
1254 int ret = 0;
1255
1256 /*
1257 * If upaths is NULL then we are only computing the amount of space
1258 * needed to hold the paths and returning the value in *ulensp. If we
1259 * are copying out paths then we get the amount of space allocated by
1260 * the caller. If the actual space needed for paths is larger, or
1261 * things are changing out from under us, then we return EAGAIN.
1262 */
1263 if (upaths) {
1264 if (ulensp == NULL)
1265 return (EINVAL);
1266 if (copyin(ulensp, &ulens, sizeof (ulens)) != 0)
1267 return (EFAULT);
1268 }
1269
1270 /*
1271 * copyin enough of the devid to determine the length then
1272 * reallocate and copy in the entire devid.
1273 */
1274 devid_len = ddi_devid_sizeof(NULL);
1275 devid = kmem_alloc(devid_len, KM_SLEEP);
1276 if (copyin(udevid, devid, devid_len)) {
1277 ret = EFAULT;
1278 goto out;
1279 }
1280 len = devid_len;
1281 devid_len = ddi_devid_sizeof(devid);
1282 kmem_free(devid, len);
1283 devid = kmem_alloc(devid_len, KM_SLEEP);
1284 if (copyin(udevid, devid, devid_len)) {
1285 ret = EFAULT;
1286 goto out;
1287 }
1288
1289 /* copyin the minor name if specified. */
1290 minor_name = uminor_name;
1291 if ((minor_name != DEVID_MINOR_NAME_ALL) &&
1292 (minor_name != DEVID_MINOR_NAME_ALL_CHR) &&
1293 (minor_name != DEVID_MINOR_NAME_ALL_BLK)) {
1294 minor_name = kmem_alloc(MAXPATHLEN, KM_SLEEP);
1295 if (copyinstr(uminor_name, minor_name, MAXPATHLEN, 0)) {
1296 ret = EFAULT;
1297 goto out;
1298 }
1299 }
1300
1301 /*
1302 * Use existing function to resolve the devid into a devlist.
1303 *
1304 * NOTE: there is a loss of spectype information in the current
1305 * ddi_lyr_devid_to_devlist implementation. We work around this by not
1306 * passing down DEVID_MINOR_NAME_ALL here, but reproducing all minor
1307 * node forms in the loop processing the devlist below. It would be
1308 * best if at some point the use of this interface here was replaced
1309 * with a path oriented call.
1310 */
1311 if (ddi_lyr_devid_to_devlist(devid,
1312 (minor_name == DEVID_MINOR_NAME_ALL) ?
1313 DEVID_MINOR_NAME_ALL_CHR : minor_name,
1314 &ndevs, &devlist) != DDI_SUCCESS) {
1315 ret = EINVAL;
1316 goto out;
1317 }
1318
1319 /*
1320 * loop over the devlist, converting each devt to a path and doing
1321 * a copyout of the path and computation of the amount of space
1322 * needed to hold all the paths
1323 */
1324 path = kmem_alloc(MAXPATHLEN, KM_SLEEP);
1325 for (i = 0, lens = 0; i < ndevs; i++) {
1326
1327 /* find the dip associated with the dev_t */
1328 if ((dip = e_ddi_hold_devi_by_dev(devlist[i], 0)) == NULL)
1329 continue;
1330
1331 /* loop over all the minor nodes, skipping ones we don't want */
1332 ndi_devi_enter(dip, &circ);
1333 for (dmdp = DEVI(dip)->devi_minor; dmdp; dmdp = dmdp->next) {
1334 if ((dmdp->ddm_dev != devlist[i]) ||
1335 (dmdp->type != DDM_MINOR))
1336 continue;
1337
1338 if ((minor_name != DEVID_MINOR_NAME_ALL) &&
1339 (minor_name != DEVID_MINOR_NAME_ALL_CHR) &&
1340 (minor_name != DEVID_MINOR_NAME_ALL_BLK) &&
1341 strcmp(minor_name, dmdp->ddm_name))
1342 continue;
1343 else {
1344 if ((minor_name == DEVID_MINOR_NAME_ALL_CHR) &&
1345 (dmdp->ddm_spec_type != S_IFCHR))
1346 continue;
1347 if ((minor_name == DEVID_MINOR_NAME_ALL_BLK) &&
1348 (dmdp->ddm_spec_type != S_IFBLK))
1349 continue;
1350 }
1351
1352 (void) ddi_pathname_minor(dmdp, path);
1353 len = strlen(path) + 1;
1354 *(path + len) = '\0'; /* set double termination */
1355 lens += len;
1356
1357 /* copyout the path with double terminations */
1358 if (upaths) {
1359 if (lens > ulens) {
1360 ret = EAGAIN;
1361 goto out;
1362 }
1363 if (copyout(path, upaths, len + 1)) {
1364 ret = EFAULT;
1365 goto out;
1366 }
1367 upaths += len;
1368 }
1369 }
1370 ndi_devi_exit(dip, circ);
1371 ddi_release_devi(dip);
1372 dip = NULL;
1373 }
1374 lens++; /* add one for double termination */
1375
1376 /* copy out the amount of space needed to hold the paths */
1377 if (ulensp && copyout(&lens, ulensp, sizeof (lens))) {
1378 ret = EFAULT;
1379 goto out;
1380 }
1381 ret = 0;
1382
1383 out: if (dip) {
1384 ndi_devi_exit(dip, circ);
1385 ddi_release_devi(dip);
1386 }
1387 if (path)
1388 kmem_free(path, MAXPATHLEN);
1389 if (devlist)
1390 ddi_lyr_free_devlist(devlist, ndevs);
1391 if (minor_name &&
1392 (minor_name != DEVID_MINOR_NAME_ALL) &&
1393 (minor_name != DEVID_MINOR_NAME_ALL_CHR) &&
1394 (minor_name != DEVID_MINOR_NAME_ALL_BLK))
1395 kmem_free(minor_name, MAXPATHLEN);
1396 if (devid)
1397 kmem_free(devid, devid_len);
1398 return (ret);
1399 }
1400
1401 /*
1402 * Return the size of the minor name.
1403 */
1404 static int
1405 modctl_sizeof_minorname(dev_t dev, int spectype, uint_t *len)
1406 {
1407 uint_t sz;
1408 char *name;
1409
1410 /* get the minor name */
1411 if (ddi_lyr_get_minor_name(dev, spectype, &name) == DDI_FAILURE)
1412 return (EINVAL);
1413
1414 sz = strlen(name) + 1;
1415 kmem_free(name, sz);
1416
1417 /* copy out the size of the minor name */
1418 if (copyout(&sz, len, sizeof (sz)) != 0)
1419 return (EFAULT);
1420
1421 return (0);
1422 }
1423
1424 /*
1425 * Return the minor name.
1426 */
1427 static int
1428 modctl_get_minorname(dev_t dev, int spectype, uint_t len, char *uname)
1429 {
1430 uint_t sz;
1431 char *name;
1432 int err = 0;
1433
1434 /* get the minor name */
1435 if (ddi_lyr_get_minor_name(dev, spectype, &name) == DDI_FAILURE)
1436 return (EINVAL);
1437
1438 sz = strlen(name) + 1;
1439
1440 /* Error if the minor name is larger than the space allocated */
1441 if (sz > len) {
1442 kmem_free(name, sz);
1443 return (ENOSPC);
1444 }
1445
1446 /* copy out the minor name */
1447 if (copyout(name, uname, sz) != 0)
1448 err = EFAULT;
1449 kmem_free(name, sz);
1450 return (err);
1451 }
1452
1453 /*
1454 * Return the size of the (dev_t,spectype) devfspath name.
1455 */
1456 static int
1457 modctl_devfspath_len(dev_t dev, int spectype, uint_t *len)
1458 {
1459 uint_t sz;
1460 char *name;
1461
1462 /* get the path name */
1463 name = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
1464 if (ddi_dev_pathname(dev, spectype, name) == DDI_FAILURE) {
1465 kmem_free(name, MAXPATHLEN);
1466 return (EINVAL);
1467 }
1468
1469 sz = strlen(name) + 1;
1470 kmem_free(name, MAXPATHLEN);
1471
1472 /* copy out the size of the path name */
1473 if (copyout(&sz, len, sizeof (sz)) != 0)
1474 return (EFAULT);
1475
1476 return (0);
1477 }
1478
1479 /*
1480 * Return the (dev_t,spectype) devfspath name.
1481 */
1482 static int
1483 modctl_devfspath(dev_t dev, int spectype, uint_t len, char *uname)
1484 {
1485 uint_t sz;
1486 char *name;
1487 int err = 0;
1488
1489 /* get the path name */
1490 name = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
1491 if (ddi_dev_pathname(dev, spectype, name) == DDI_FAILURE) {
1492 kmem_free(name, MAXPATHLEN);
1493 return (EINVAL);
1494 }
1495
1496 sz = strlen(name) + 1;
1497
1498 /* Error if the path name is larger than the space allocated */
1499 if (sz > len) {
1500 kmem_free(name, MAXPATHLEN);
1501 return (ENOSPC);
1502 }
1503
1504 /* copy out the path name */
1505 if (copyout(name, uname, sz) != 0)
1506 err = EFAULT;
1507 kmem_free(name, MAXPATHLEN);
1508 return (err);
1509 }
1510
1511 /*
1512 * Return the size of the (major,instance) devfspath name.
1513 */
1514 static int
1515 modctl_devfspath_mi_len(major_t major, int instance, uint_t *len)
1516 {
1517 uint_t sz;
1518 char *name;
1519
1520 /* get the path name */
1521 name = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
1522 if (e_ddi_majorinstance_to_path(major, instance, name) != DDI_SUCCESS) {
1523 kmem_free(name, MAXPATHLEN);
1524 return (EINVAL);
1525 }
1526
1527 sz = strlen(name) + 1;
1528 kmem_free(name, MAXPATHLEN);
1529
1530 /* copy out the size of the path name */
1531 if (copyout(&sz, len, sizeof (sz)) != 0)
1532 return (EFAULT);
1533
1534 return (0);
1535 }
1536
1537 /*
1538 * Return the (major_instance) devfspath name.
1539 * NOTE: e_ddi_majorinstance_to_path does not require the device to attach to
1540 * return a path - it uses the instance tree.
1541 */
1542 static int
1543 modctl_devfspath_mi(major_t major, int instance, uint_t len, char *uname)
1544 {
1545 uint_t sz;
1546 char *name;
1547 int err = 0;
1548
1549 /* get the path name */
1550 name = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
1551 if (e_ddi_majorinstance_to_path(major, instance, name) != DDI_SUCCESS) {
1552 kmem_free(name, MAXPATHLEN);
1553 return (EINVAL);
1554 }
1555
1556 sz = strlen(name) + 1;
1557
1558 /* Error if the path name is larger than the space allocated */
1559 if (sz > len) {
1560 kmem_free(name, MAXPATHLEN);
1561 return (ENOSPC);
1562 }
1563
1564 /* copy out the path name */
1565 if (copyout(name, uname, sz) != 0)
1566 err = EFAULT;
1567 kmem_free(name, MAXPATHLEN);
1568 return (err);
1569 }
1570
1571 static int
1572 modctl_get_fbname(char *path)
1573 {
1574 extern dev_t fbdev;
1575 char *pathname = NULL;
1576 int rval = 0;
1577
1578 /* make sure fbdev is set before we plunge in */
1579 if (fbdev == NODEV)
1580 return (ENODEV);
1581
1582 pathname = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
1583 if ((rval = ddi_dev_pathname(fbdev, S_IFCHR,
1584 pathname)) == DDI_SUCCESS) {
1585 if (copyout(pathname, path, strlen(pathname)+1) != 0) {
1586 rval = EFAULT;
1587 }
1588 }
1589 kmem_free(pathname, MAXPATHLEN);
1590 return (rval);
1591 }
1592
1593 /*
1594 * modctl_reread_dacf()
1595 * Reread the dacf rules database from the named binding file.
1596 * If NULL is specified, pass along the NULL, it means 'use the default'.
1597 */
1598 static int
1599 modctl_reread_dacf(char *path)
1600 {
1601 int rval = 0;
1602 char *filename, *filenamep;
1603
1604 filename = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
1605
1606 if (path == NULL) {
1607 filenamep = NULL;
1608 } else {
1609 if (copyinstr(path, filename, MAXPATHLEN, 0) != 0) {
1610 rval = EFAULT;
1611 goto out;
1612 }
1613 filenamep = filename;
1614 filenamep[MAXPATHLEN - 1] = '\0';
1615 }
1616
1617 rval = read_dacf_binding_file(filenamep);
1618 out:
1619 kmem_free(filename, MAXPATHLEN);
1620 return (rval);
1621 }
1622
1623 /*ARGSUSED*/
1624 static int
1625 modctl_modevents(int subcmd, uintptr_t a2, uintptr_t a3, uintptr_t a4,
1626 uint_t flag)
1627 {
1628 int error = 0;
1629 char *filenamep;
1630
1631 switch (subcmd) {
1632
1633 case MODEVENTS_FLUSH:
1634 /* flush all currently queued events */
1635 log_sysevent_flushq(subcmd, flag);
1636 break;
1637
1638 case MODEVENTS_SET_DOOR_UPCALL_FILENAME:
1639 /*
1640 * bind door_upcall to filename
1641 * this should only be done once per invocation
1642 * of the event daemon.
1643 */
1644
1645 filenamep = kmem_zalloc(MOD_MAXPATH, KM_SLEEP);
1646
1647 if (copyinstr((char *)a2, filenamep, MOD_MAXPATH, 0)) {
1648 error = EFAULT;
1649 } else {
1650 error = log_sysevent_filename(filenamep);
1651 }
1652 kmem_free(filenamep, MOD_MAXPATH);
1653 break;
1654
1655 case MODEVENTS_GETDATA:
1656 error = log_sysevent_copyout_data((sysevent_id_t *)a2,
1657 (size_t)a3, (caddr_t)a4);
1658 break;
1659
1660 case MODEVENTS_FREEDATA:
1661 error = log_sysevent_free_data((sysevent_id_t *)a2);
1662 break;
1663 case MODEVENTS_POST_EVENT:
1664 error = log_usr_sysevent((sysevent_t *)a2, (uint32_t)a3,
1665 (sysevent_id_t *)a4);
1666 break;
1667 case MODEVENTS_REGISTER_EVENT:
1668 error = log_sysevent_register((char *)a2, (char *)a3,
1669 (se_pubsub_t *)a4);
1670 break;
1671 default:
1672 error = EINVAL;
1673 }
1674
1675 return (error);
1676 }
1677
1678 static void
1679 free_mperm(mperm_t *mp)
1680 {
1681 int len;
1682
1683 if (mp->mp_minorname) {
1684 len = strlen(mp->mp_minorname) + 1;
1685 kmem_free(mp->mp_minorname, len);
1686 }
1687 kmem_free(mp, sizeof (mperm_t));
1688 }
1689
1690 #define MP_NO_DRV_ERR \
1691 "/etc/minor_perm: no driver for %s\n"
1692
1693 #define MP_EMPTY_MINOR \
1694 "/etc/minor_perm: empty minor name for driver %s\n"
1695
1696 #define MP_NO_MINOR \
1697 "/etc/minor_perm: no minor matching %s for driver %s\n"
1698
1699 /*
1700 * Remove mperm entry with matching minorname
1701 */
1702 static void
1703 rem_minorperm(major_t major, char *drvname, mperm_t *mp, int is_clone)
1704 {
1705 mperm_t **mp_head;
1706 mperm_t *freemp = NULL;
1707 struct devnames *dnp = &devnamesp[major];
1708 mperm_t **wildmp;
1709
1710 ASSERT(mp->mp_minorname && strlen(mp->mp_minorname) > 0);
1711
1712 LOCK_DEV_OPS(&dnp->dn_lock);
1713 if (strcmp(mp->mp_minorname, "*") == 0) {
1714 wildmp = ((is_clone == 0) ?
1715 &dnp->dn_mperm_wild : &dnp->dn_mperm_clone);
1716 if (*wildmp)
1717 freemp = *wildmp;
1718 *wildmp = NULL;
1719 } else {
1720 mp_head = &dnp->dn_mperm;
1721 while (*mp_head) {
1722 if (strcmp((*mp_head)->mp_minorname,
1723 mp->mp_minorname) != 0) {
1724 mp_head = &(*mp_head)->mp_next;
1725 continue;
1726 }
1727 /* remove the entry */
1728 freemp = *mp_head;
1729 *mp_head = freemp->mp_next;
1730 break;
1731 }
1732 }
1733 if (freemp) {
1734 if (moddebug & MODDEBUG_MINORPERM) {
1735 cmn_err(CE_CONT, "< %s %s 0%o %d %d\n",
1736 drvname, freemp->mp_minorname,
1737 freemp->mp_mode & 0777,
1738 freemp->mp_uid, freemp->mp_gid);
1739 }
1740 free_mperm(freemp);
1741 } else {
1742 if (moddebug & MODDEBUG_MINORPERM) {
1743 cmn_err(CE_CONT, MP_NO_MINOR,
1744 drvname, mp->mp_minorname);
1745 }
1746 }
1747
1748 UNLOCK_DEV_OPS(&dnp->dn_lock);
1749 }
1750
1751 /*
1752 * Add minor perm entry
1753 */
1754 static void
1755 add_minorperm(major_t major, char *drvname, mperm_t *mp, int is_clone)
1756 {
1757 mperm_t **mp_head;
1758 mperm_t *freemp = NULL;
1759 struct devnames *dnp = &devnamesp[major];
1760 mperm_t **wildmp;
1761
1762 ASSERT(mp->mp_minorname && strlen(mp->mp_minorname) > 0);
1763
1764 /*
1765 * Note that update_drv replace semantics require
1766 * replacing matching entries with the new permissions.
1767 */
1768 LOCK_DEV_OPS(&dnp->dn_lock);
1769 if (strcmp(mp->mp_minorname, "*") == 0) {
1770 wildmp = ((is_clone == 0) ?
1771 &dnp->dn_mperm_wild : &dnp->dn_mperm_clone);
1772 if (*wildmp)
1773 freemp = *wildmp;
1774 *wildmp = mp;
1775 } else {
1776 mperm_t *p, *v = NULL;
1777 for (p = dnp->dn_mperm; p; v = p, p = p->mp_next) {
1778 if (strcmp(p->mp_minorname, mp->mp_minorname) == 0) {
1779 if (v == NULL)
1780 dnp->dn_mperm = mp;
1781 else
1782 v->mp_next = mp;
1783 mp->mp_next = p->mp_next;
1784 freemp = p;
1785 goto replaced;
1786 }
1787 }
1788 if (p == NULL) {
1789 mp_head = &dnp->dn_mperm;
1790 if (*mp_head == NULL) {
1791 *mp_head = mp;
1792 } else {
1793 mp->mp_next = *mp_head;
1794 *mp_head = mp;
1795 }
1796 }
1797 }
1798 replaced:
1799 if (freemp) {
1800 if (moddebug & MODDEBUG_MINORPERM) {
1801 cmn_err(CE_CONT, "< %s %s 0%o %d %d\n",
1802 drvname, freemp->mp_minorname,
1803 freemp->mp_mode & 0777,
1804 freemp->mp_uid, freemp->mp_gid);
1805 }
1806 free_mperm(freemp);
1807 }
1808 if (moddebug & MODDEBUG_MINORPERM) {
1809 cmn_err(CE_CONT, "> %s %s 0%o %d %d\n",
1810 drvname, mp->mp_minorname, mp->mp_mode & 0777,
1811 mp->mp_uid, mp->mp_gid);
1812 }
1813 UNLOCK_DEV_OPS(&dnp->dn_lock);
1814 }
1815
1816
1817 static int
1818 process_minorperm(int cmd, nvlist_t *nvl)
1819 {
1820 char *minor;
1821 major_t major;
1822 mperm_t *mp;
1823 nvpair_t *nvp;
1824 char *name;
1825 int is_clone;
1826 major_t minmaj;
1827
1828 ASSERT(cmd == MODLOADMINORPERM ||
1829 cmd == MODADDMINORPERM || cmd == MODREMMINORPERM);
1830
1831 nvp = NULL;
1832 while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
1833 name = nvpair_name(nvp);
1834
1835 is_clone = 0;
1836 (void) nvpair_value_string(nvp, &minor);
1837 major = ddi_name_to_major(name);
1838 if (major != DDI_MAJOR_T_NONE) {
1839 mp = kmem_zalloc(sizeof (*mp), KM_SLEEP);
1840 if (minor == NULL || strlen(minor) == 0) {
1841 if (moddebug & MODDEBUG_MINORPERM) {
1842 cmn_err(CE_CONT, MP_EMPTY_MINOR, name);
1843 }
1844 minor = "*";
1845 }
1846
1847 /*
1848 * The minor name of a node using the clone
1849 * driver must be the driver name. To avoid
1850 * multiple searches, we map entries in the form
1851 * clone:<driver> to <driver>:*. This also allows us
1852 * to filter out some of the litter in /etc/minor_perm.
1853 * Minor perm alias entries where the name is not
1854 * the driver kept on the clone list itself.
1855 * This all seems very fragile as a driver could
1856 * be introduced with an existing alias name.
1857 */
1858 if (strcmp(name, "clone") == 0) {
1859 minmaj = ddi_name_to_major(minor);
1860 if (minmaj != DDI_MAJOR_T_NONE) {
1861 if (moddebug & MODDEBUG_MINORPERM) {
1862 cmn_err(CE_CONT,
1863 "mapping %s:%s to %s:*\n",
1864 name, minor, minor);
1865 }
1866 major = minmaj;
1867 name = minor;
1868 minor = "*";
1869 is_clone = 1;
1870 }
1871 }
1872
1873 if (mp) {
1874 mp->mp_minorname =
1875 i_ddi_strdup(minor, KM_SLEEP);
1876 }
1877 } else {
1878 mp = NULL;
1879 if (moddebug & MODDEBUG_MINORPERM) {
1880 cmn_err(CE_CONT, MP_NO_DRV_ERR, name);
1881 }
1882 }
1883
1884 /* mode */
1885 nvp = nvlist_next_nvpair(nvl, nvp);
1886 ASSERT(strcmp(nvpair_name(nvp), "mode") == 0);
1887 if (mp)
1888 (void) nvpair_value_int32(nvp, (int *)&mp->mp_mode);
1889 /* uid */
1890 nvp = nvlist_next_nvpair(nvl, nvp);
1891 ASSERT(strcmp(nvpair_name(nvp), "uid") == 0);
1892 if (mp)
1893 (void) nvpair_value_uint32(nvp, &mp->mp_uid);
1894 /* gid */
1895 nvp = nvlist_next_nvpair(nvl, nvp);
1896 ASSERT(strcmp(nvpair_name(nvp), "gid") == 0);
1897 if (mp) {
1898 (void) nvpair_value_uint32(nvp, &mp->mp_gid);
1899
1900 if (cmd == MODREMMINORPERM) {
1901 rem_minorperm(major, name, mp, is_clone);
1902 free_mperm(mp);
1903 } else {
1904 add_minorperm(major, name, mp, is_clone);
1905 }
1906 }
1907 }
1908
1909 if (cmd == MODLOADMINORPERM)
1910 minorperm_loaded = 1;
1911
1912 /*
1913 * Reset permissions of cached dv_nodes
1914 */
1915 (void) devfs_reset_perm(DV_RESET_PERM);
1916
1917 return (0);
1918 }
1919
1920 static int
1921 modctl_minorperm(int cmd, char *usrbuf, size_t buflen)
1922 {
1923 int error;
1924 nvlist_t *nvl;
1925 char *buf = kmem_alloc(buflen, KM_SLEEP);
1926
1927 if ((error = ddi_copyin(usrbuf, buf, buflen, 0)) != 0) {
1928 kmem_free(buf, buflen);
1929 return (error);
1930 }
1931
1932 error = nvlist_unpack(buf, buflen, &nvl, KM_SLEEP);
1933 kmem_free(buf, buflen);
1934 if (error)
1935 return (error);
1936
1937 error = process_minorperm(cmd, nvl);
1938 nvlist_free(nvl);
1939 return (error);
1940 }
1941
1942 struct walk_args {
1943 char *wa_drvname;
1944 list_t wa_pathlist;
1945 };
1946
1947 struct path_elem {
1948 char *pe_dir;
1949 char *pe_nodename;
1950 list_node_t pe_node;
1951 int pe_dirlen;
1952 };
1953
1954 /*ARGSUSED*/
1955 static int
1956 modctl_inst_walker(const char *path, in_node_t *np, in_drv_t *dp, void *arg)
1957 {
1958 struct walk_args *wargs = (struct walk_args *)arg;
1959 struct path_elem *pe;
1960 char *nodename;
1961
1962 /*
1963 * Search may be restricted to a single driver in the case of rem_drv
1964 */
1965 if (wargs->wa_drvname &&
1966 strcmp(dp->ind_driver_name, wargs->wa_drvname) != 0)
1967 return (INST_WALK_CONTINUE);
1968
1969 pe = kmem_zalloc(sizeof (*pe), KM_SLEEP);
1970 pe->pe_dir = i_ddi_strdup((char *)path, KM_SLEEP);
1971 pe->pe_dirlen = strlen(pe->pe_dir) + 1;
1972 ASSERT(strrchr(pe->pe_dir, '/') != NULL);
1973 nodename = strrchr(pe->pe_dir, '/');
1974 *nodename++ = 0;
1975 pe->pe_nodename = nodename;
1976 list_insert_tail(&wargs->wa_pathlist, pe);
1977
1978 return (INST_WALK_CONTINUE);
1979 }
1980
1981 /*
1982 * /devices attribute nodes clean-up optionally performed
1983 * when removing a driver (rem_drv -C).
1984 *
1985 * Removing attribute nodes allows a machine to be reprovisioned
1986 * without the side-effect of inadvertently picking up stale
1987 * device node ownership or permissions.
1988 *
1989 * Preserving attributes (not performing cleanup) allows devices
1990 * attribute changes to be preserved across upgrades, as
1991 * upgrade rather heavy-handedly does a rem_drv/add_drv cycle.
1992 */
1993 static int
1994 modctl_remdrv_cleanup(const char *u_drvname)
1995 {
1996 struct walk_args *wargs;
1997 struct path_elem *pe;
1998 char *drvname;
1999 int err, rval = 0;
2000
2001 drvname = kmem_alloc(MAXMODCONFNAME, KM_SLEEP);
2002 if ((err = copyinstr(u_drvname, drvname, MAXMODCONFNAME, 0))) {
2003 kmem_free(drvname, MAXMODCONFNAME);
2004 return (err);
2005 }
2006
2007 /*
2008 * First go through the instance database. For each
2009 * instance of a device bound to the driver being
2010 * removed, remove any underlying devfs attribute nodes.
2011 *
2012 * This is a two-step process. First we go through
2013 * the instance data itself, constructing a list of
2014 * the nodes discovered. The second step is then
2015 * to find and remove any devfs attribute nodes
2016 * for the instances discovered in the first step.
2017 * The two-step process avoids any difficulties
2018 * which could arise by holding the instance data
2019 * lock with simultaneous devfs operations.
2020 */
2021 wargs = kmem_zalloc(sizeof (*wargs), KM_SLEEP);
2022
2023 wargs->wa_drvname = drvname;
2024 list_create(&wargs->wa_pathlist,
2025 sizeof (struct path_elem), offsetof(struct path_elem, pe_node));
2026
2027 (void) e_ddi_walk_instances(modctl_inst_walker, (void *)wargs);
2028
2029 for (pe = list_head(&wargs->wa_pathlist); pe != NULL;
2030 pe = list_next(&wargs->wa_pathlist, pe)) {
2031 err = devfs_remdrv_cleanup((const char *)pe->pe_dir,
2032 (const char *)pe->pe_nodename);
2033 if (rval == 0)
2034 rval = err;
2035 }
2036
2037 while ((pe = list_head(&wargs->wa_pathlist)) != NULL) {
2038 list_remove(&wargs->wa_pathlist, pe);
2039 kmem_free(pe->pe_dir, pe->pe_dirlen);
2040 kmem_free(pe, sizeof (*pe));
2041 }
2042 kmem_free(wargs, sizeof (*wargs));
2043
2044 /*
2045 * Pseudo nodes aren't recorded in the instance database
2046 * so any such nodes need to be handled separately.
2047 */
2048 err = devfs_remdrv_cleanup("pseudo", (const char *)drvname);
2049 if (rval == 0)
2050 rval = err;
2051
2052 kmem_free(drvname, MAXMODCONFNAME);
2053 return (rval);
2054 }
2055
2056 /*
2057 * Perform a cleanup of non-existent /devices attribute nodes,
2058 * similar to rem_drv -C, but for all drivers/devices.
2059 * This is also optional, performed as part of devfsadm -C.
2060 */
2061 void
2062 dev_devices_cleanup()
2063 {
2064 struct walk_args *wargs;
2065 struct path_elem *pe;
2066 dev_info_t *devi;
2067 char *path;
2068 int err;
2069
2070 /*
2071 * It's expected that all drivers have been loaded and
2072 * module unloading disabled while performing cleanup.
2073 */
2074 ASSERT(modunload_disable_count > 0);
2075
2076 wargs = kmem_zalloc(sizeof (*wargs), KM_SLEEP);
2077 wargs->wa_drvname = NULL;
2078 list_create(&wargs->wa_pathlist,
2079 sizeof (struct path_elem), offsetof(struct path_elem, pe_node));
2080
2081 (void) e_ddi_walk_instances(modctl_inst_walker, (void *)wargs);
2082
2083 path = kmem_alloc(MAXPATHLEN, KM_SLEEP);
2084
2085 for (pe = list_head(&wargs->wa_pathlist); pe != NULL;
2086 pe = list_next(&wargs->wa_pathlist, pe)) {
2087 (void) snprintf(path, MAXPATHLEN, "%s/%s",
2088 pe->pe_dir, pe->pe_nodename);
2089 devi = e_ddi_hold_devi_by_path(path, 0);
2090 if (devi != NULL) {
2091 ddi_release_devi(devi);
2092 } else {
2093 err = devfs_remdrv_cleanup((const char *)pe->pe_dir,
2094 (const char *)pe->pe_nodename);
2095 if (err) {
2096 cmn_err(CE_CONT,
2097 "devfs: %s: clean-up error %d\n",
2098 path, err);
2099 }
2100 }
2101 }
2102
2103 while ((pe = list_head(&wargs->wa_pathlist)) != NULL) {
2104 list_remove(&wargs->wa_pathlist, pe);
2105 kmem_free(pe->pe_dir, pe->pe_dirlen);
2106 kmem_free(pe, sizeof (*pe));
2107 }
2108 kmem_free(wargs, sizeof (*wargs));
2109 kmem_free(path, MAXPATHLEN);
2110 }
2111
2112 static int
2113 modctl_allocpriv(const char *name)
2114 {
2115 char *pstr = kmem_alloc(PRIVNAME_MAX, KM_SLEEP);
2116 int error;
2117
2118 if ((error = copyinstr(name, pstr, PRIVNAME_MAX, 0))) {
2119 kmem_free(pstr, PRIVNAME_MAX);
2120 return (error);
2121 }
2122 error = priv_getbyname(pstr, PRIV_ALLOC);
2123 if (error < 0)
2124 error = -error;
2125 else
2126 error = 0;
2127 kmem_free(pstr, PRIVNAME_MAX);
2128 return (error);
2129 }
2130
2131 static int
2132 modctl_devexists(const char *upath, int pathlen)
2133 {
2134 char *path;
2135 int ret;
2136
2137 /*
2138 * copy in the path, including the terminating null
2139 */
2140 pathlen++;
2141 if (pathlen <= 1 || pathlen > MAXPATHLEN)
2142 return (EINVAL);
2143 path = kmem_zalloc(pathlen + 1, KM_SLEEP);
2144 if ((ret = copyinstr(upath, path, pathlen, NULL)) == 0) {
2145 ret = sdev_modctl_devexists(path);
2146 }
2147
2148 kmem_free(path, pathlen + 1);
2149 return (ret);
2150 }
2151
2152 static int
2153 modctl_devreaddir(const char *udir, int udirlen,
2154 char *upaths, int64_t *ulensp)
2155 {
2156 char *paths = NULL;
2157 char **dirlist = NULL;
2158 char *dir;
2159 int64_t ulens;
2160 int64_t lens;
2161 int i, n;
2162 int ret = 0;
2163 char *p;
2164 int npaths;
2165 int npaths_alloc;
2166
2167 /*
2168 * If upaths is NULL then we are only computing the amount of space
2169 * needed to return the paths, with the value returned in *ulensp. If we
2170 * are copying out paths then we get the amount of space allocated by
2171 * the caller. If the actual space needed for paths is larger, or
2172 * things are changing out from under us, then we return EAGAIN.
2173 */
2174 if (upaths) {
2175 if (ulensp == NULL)
2176 return (EINVAL);
2177 if (copyin(ulensp, &ulens, sizeof (ulens)) != 0)
2178 return (EFAULT);
2179 }
2180
2181 /*
2182 * copyin the /dev path including terminating null
2183 */
2184 udirlen++;
2185 if (udirlen <= 1 || udirlen > MAXPATHLEN)
2186 return (EINVAL);
2187 dir = kmem_zalloc(udirlen + 1, KM_SLEEP);
2188 if ((ret = copyinstr(udir, dir, udirlen, NULL)) != 0)
2189 goto err;
2190
2191 if ((ret = sdev_modctl_readdir(dir, &dirlist,
2192 &npaths, &npaths_alloc, 0)) != 0) {
2193 ASSERT(dirlist == NULL);
2194 goto err;
2195 }
2196
2197 lens = 0;
2198 for (i = 0; i < npaths; i++) {
2199 lens += strlen(dirlist[i]) + 1;
2200 }
2201 lens++; /* add one for double termination */
2202
2203 if (upaths) {
2204 if (lens > ulens) {
2205 ret = EAGAIN;
2206 goto out;
2207 }
2208
2209 paths = kmem_alloc(lens, KM_SLEEP);
2210
2211 p = paths;
2212 for (i = 0; i < npaths; i++) {
2213 n = strlen(dirlist[i]) + 1;
2214 bcopy(dirlist[i], p, n);
2215 p += n;
2216 }
2217 *p = 0;
2218
2219 if (copyout(paths, upaths, lens)) {
2220 ret = EFAULT;
2221 goto err;
2222 }
2223 }
2224
2225 out:
2226 /* copy out the amount of space needed to hold the paths */
2227 if (copyout(&lens, ulensp, sizeof (lens)))
2228 ret = EFAULT;
2229
2230 err:
2231 if (dirlist)
2232 sdev_modctl_readdir_free(dirlist, npaths, npaths_alloc);
2233 if (paths)
2234 kmem_free(paths, lens);
2235 kmem_free(dir, udirlen + 1);
2236 return (ret);
2237 }
2238
2239 static int
2240 modctl_devemptydir(const char *udir, int udirlen, int *uempty)
2241 {
2242 char *dir;
2243 int ret;
2244 char **dirlist = NULL;
2245 int npaths;
2246 int npaths_alloc;
2247 int empty;
2248
2249 /*
2250 * copyin the /dev path including terminating null
2251 */
2252 udirlen++;
2253 if (udirlen <= 1 || udirlen > MAXPATHLEN)
2254 return (EINVAL);
2255 dir = kmem_zalloc(udirlen + 1, KM_SLEEP);
2256 if ((ret = copyinstr(udir, dir, udirlen, NULL)) != 0)
2257 goto err;
2258
2259 if ((ret = sdev_modctl_readdir(dir, &dirlist,
2260 &npaths, &npaths_alloc, 1)) != 0) {
2261 goto err;
2262 }
2263
2264 empty = npaths ? 0 : 1;
2265 if (copyout(&empty, uempty, sizeof (empty)))
2266 ret = EFAULT;
2267
2268 err:
2269 if (dirlist)
2270 sdev_modctl_readdir_free(dirlist, npaths, npaths_alloc);
2271 kmem_free(dir, udirlen + 1);
2272 return (ret);
2273 }
2274
2275 static int
2276 modctl_hp(int subcmd, const char *path, char *cn_name, uintptr_t arg,
2277 uintptr_t rval)
2278 {
2279 int error = 0;
2280 size_t pathsz, namesz;
2281 char *devpath, *cn_name_str;
2282
2283 if (path == NULL)
2284 return (EINVAL);
2285
2286 devpath = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
2287 error = copyinstr(path, devpath, MAXPATHLEN, &pathsz);
2288 if (error != 0) {
2289 kmem_free(devpath, MAXPATHLEN);
2290 return (EFAULT);
2291 }
2292
2293 cn_name_str = kmem_zalloc(MAXNAMELEN, KM_SLEEP);
2294 error = copyinstr(cn_name, cn_name_str, MAXNAMELEN, &namesz);
2295 if (error != 0) {
2296 kmem_free(devpath, MAXPATHLEN);
2297 kmem_free(cn_name_str, MAXNAMELEN);
2298
2299 return (EFAULT);
2300 }
2301
2302 switch (subcmd) {
2303 case MODHPOPS_CHANGE_STATE:
2304 error = ddihp_modctl(DDI_HPOP_CN_CHANGE_STATE, devpath,
2305 cn_name_str, arg, 0);
2306 break;
2307 case MODHPOPS_CREATE_PORT:
2308 /* Create an empty PORT */
2309 error = ddihp_modctl(DDI_HPOP_CN_CREATE_PORT, devpath,
2310 cn_name_str, 0, 0);
2311 break;
2312 case MODHPOPS_REMOVE_PORT:
2313 /* Remove an empty PORT */
2314 error = ddihp_modctl(DDI_HPOP_CN_REMOVE_PORT, devpath,
2315 cn_name_str, 0, 0);
2316 break;
2317 case MODHPOPS_BUS_GET:
2318 error = ddihp_modctl(DDI_HPOP_CN_GET_PROPERTY, devpath,
2319 cn_name_str, arg, rval);
2320 break;
2321 case MODHPOPS_BUS_SET:
2322 error = ddihp_modctl(DDI_HPOP_CN_SET_PROPERTY, devpath,
2323 cn_name_str, arg, rval);
2324 break;
2325 default:
2326 error = ENOTSUP;
2327 break;
2328 }
2329
2330 kmem_free(devpath, MAXPATHLEN);
2331 kmem_free(cn_name_str, MAXNAMELEN);
2332
2333 return (error);
2334 }
2335
2336 int
2337 modctl_moddevname(int subcmd, uintptr_t a1, uintptr_t a2)
2338 {
2339 int error = 0;
2340
2341 switch (subcmd) {
2342 case MODDEVNAME_LOOKUPDOOR:
2343 error = devname_filename_register((char *)a1);
2344 break;
2345 case MODDEVNAME_PROFILE:
2346 error = devname_profile_update((char *)a1, (size_t)a2);
2347 break;
2348 case MODDEVNAME_RECONFIG:
2349 i_ddi_set_reconfig();
2350 break;
2351 case MODDEVNAME_SYSAVAIL:
2352 i_ddi_set_sysavail();
2353 break;
2354 default:
2355 error = EINVAL;
2356 break;
2357 }
2358
2359 return (error);
2360 }
2361
2362 /*ARGSUSED5*/
2363 int
2364 modctl(int cmd, uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4,
2365 uintptr_t a5)
2366 {
2367 int error = EINVAL;
2368 dev_t dev;
2369
2370 if (secpolicy_modctl(CRED(), cmd) != 0)
2371 return (set_errno(EPERM));
2372
2373 switch (cmd) {
2374 case MODLOAD: /* load a module */
2375 error = modctl_modload((int)a1, (char *)a2, (int *)a3);
2376 break;
2377
2378 case MODUNLOAD: /* unload a module */
2379 error = modctl_modunload((modid_t)a1);
2380 break;
2381
2382 case MODINFO: /* get module status */
2383 error = modctl_modinfo((modid_t)a1, (struct modinfo *)a2);
2384 break;
2385
2386 case MODRESERVED: /* get last major number in range */
2387 error = modctl_modreserve((modid_t)a1, (int *)a2);
2388 break;
2389
2390 case MODSETMINIROOT: /* we are running in miniroot */
2391 isminiroot = 1;
2392 error = 0;
2393 break;
2394
2395 case MODADDMAJBIND: /* add major / driver alias bindings */
2396 error = modctl_add_driver_aliases((int *)a2);
2397 break;
2398
2399 case MODGETPATHLEN: /* get modpath length */
2400 error = modctl_getmodpathlen((int *)a2);
2401 break;
2402
2403 case MODGETPATH: /* get modpath */
2404 error = modctl_getmodpath((char *)a2);
2405 break;
2406
2407 case MODREADSYSBIND: /* read system call binding file */
2408 error = modctl_read_sysbinding_file();
2409 break;
2410
2411 case MODGETMAJBIND: /* get major number for named device */
2412 error = modctl_getmaj((char *)a1, (uint_t)a2, (int *)a3);
2413 break;
2414
2415 case MODGETNAME: /* get name of device given major number */
2416 error = modctl_getname((char *)a1, (uint_t)a2, (int *)a3);
2417 break;
2418
2419 case MODDEVT2INSTANCE:
2420 if (get_udatamodel() == DATAMODEL_NATIVE) {
2421 dev = (dev_t)a1;
2422 }
2423 #ifdef _SYSCALL32_IMPL
2424 else {
2425 dev = expldev(a1);
2426 }
2427 #endif
2428 error = modctl_devt2instance(dev, (int *)a2);
2429 break;
2430
2431 case MODSIZEOF_DEVID: /* sizeof device id of device given dev_t */
2432 if (get_udatamodel() == DATAMODEL_NATIVE) {
2433 dev = (dev_t)a1;
2434 }
2435 #ifdef _SYSCALL32_IMPL
2436 else {
2437 dev = expldev(a1);
2438 }
2439 #endif
2440 error = modctl_sizeof_devid(dev, (uint_t *)a2);
2441 break;
2442
2443 case MODGETDEVID: /* get device id of device given dev_t */
2444 if (get_udatamodel() == DATAMODEL_NATIVE) {
2445 dev = (dev_t)a1;
2446 }
2447 #ifdef _SYSCALL32_IMPL
2448 else {
2449 dev = expldev(a1);
2450 }
2451 #endif
2452 error = modctl_get_devid(dev, (uint_t)a2, (ddi_devid_t)a3);
2453 break;
2454
2455 case MODSIZEOF_MINORNAME: /* sizeof minor nm (dev_t,spectype) */
2456 if (get_udatamodel() == DATAMODEL_NATIVE) {
2457 error = modctl_sizeof_minorname((dev_t)a1, (int)a2,
2458 (uint_t *)a3);
2459 }
2460 #ifdef _SYSCALL32_IMPL
2461 else {
2462 error = modctl_sizeof_minorname(expldev(a1), (int)a2,
2463 (uint_t *)a3);
2464 }
2465
2466 #endif
2467 break;
2468
2469 case MODGETMINORNAME: /* get minor name of (dev_t,spectype) */
2470 if (get_udatamodel() == DATAMODEL_NATIVE) {
2471 error = modctl_get_minorname((dev_t)a1, (int)a2,
2472 (uint_t)a3, (char *)a4);
2473 }
2474 #ifdef _SYSCALL32_IMPL
2475 else {
2476 error = modctl_get_minorname(expldev(a1), (int)a2,
2477 (uint_t)a3, (char *)a4);
2478 }
2479 #endif
2480 break;
2481
2482 case MODGETDEVFSPATH_LEN: /* sizeof path nm of (dev_t,spectype) */
2483 if (get_udatamodel() == DATAMODEL_NATIVE) {
2484 error = modctl_devfspath_len((dev_t)a1, (int)a2,
2485 (uint_t *)a3);
2486 }
2487 #ifdef _SYSCALL32_IMPL
2488 else {
2489 error = modctl_devfspath_len(expldev(a1), (int)a2,
2490 (uint_t *)a3);
2491 }
2492
2493 #endif
2494 break;
2495
2496 case MODGETDEVFSPATH: /* get path name of (dev_t,spec) type */
2497 if (get_udatamodel() == DATAMODEL_NATIVE) {
2498 error = modctl_devfspath((dev_t)a1, (int)a2,
2499 (uint_t)a3, (char *)a4);
2500 }
2501 #ifdef _SYSCALL32_IMPL
2502 else {
2503 error = modctl_devfspath(expldev(a1), (int)a2,
2504 (uint_t)a3, (char *)a4);
2505 }
2506 #endif
2507 break;
2508
2509 case MODGETDEVFSPATH_MI_LEN: /* sizeof path nm of (major,instance) */
2510 error = modctl_devfspath_mi_len((major_t)a1, (int)a2,
2511 (uint_t *)a3);
2512 break;
2513
2514 case MODGETDEVFSPATH_MI: /* get path name of (major,instance) */
2515 error = modctl_devfspath_mi((major_t)a1, (int)a2,
2516 (uint_t)a3, (char *)a4);
2517 break;
2518
2519
2520 case MODEVENTS:
2521 error = modctl_modevents((int)a1, a2, a3, a4, (uint_t)a5);
2522 break;
2523
2524 case MODGETFBNAME: /* get the framebuffer name */
2525 error = modctl_get_fbname((char *)a1);
2526 break;
2527
2528 case MODREREADDACF: /* reread dacf rule database from given file */
2529 error = modctl_reread_dacf((char *)a1);
2530 break;
2531
2532 case MODLOADDRVCONF: /* load driver.conf file for major */
2533 error = modctl_load_drvconf((major_t)a1, (int)a2);
2534 break;
2535
2536 case MODUNLOADDRVCONF: /* unload driver.conf file for major */
2537 error = modctl_unload_drvconf((major_t)a1);
2538 break;
2539
2540 case MODREMMAJBIND: /* remove a major binding */
2541 error = modctl_rem_major((major_t)a1);
2542 break;
2543
2544 case MODREMDRVALIAS: /* remove a major/alias binding */
2545 error = modctl_remove_driver_aliases((int *)a2);
2546 break;
2547
2548 case MODDEVID2PATHS: /* get paths given devid */
2549 error = modctl_devid2paths((ddi_devid_t)a1, (char *)a2,
2550 (uint_t)a3, (size_t *)a4, (char *)a5);
2551 break;
2552
2553 case MODSETDEVPOLICY: /* establish device policy */
2554 error = devpolicy_load((int)a1, (size_t)a2, (devplcysys_t *)a3);
2555 break;
2556
2557 case MODGETDEVPOLICY: /* get device policy */
2558 error = devpolicy_get((int *)a1, (size_t)a2,
2559 (devplcysys_t *)a3);
2560 break;
2561
2562 case MODALLOCPRIV:
2563 error = modctl_allocpriv((const char *)a1);
2564 break;
2565
2566 case MODGETDEVPOLICYBYNAME:
2567 error = devpolicy_getbyname((size_t)a1,
2568 (devplcysys_t *)a2, (char *)a3);
2569 break;
2570
2571 case MODLOADMINORPERM:
2572 case MODADDMINORPERM:
2573 case MODREMMINORPERM:
2574 error = modctl_minorperm(cmd, (char *)a1, (size_t)a2);
2575 break;
2576
2577 case MODREMDRVCLEANUP:
2578 error = modctl_remdrv_cleanup((const char *)a1);
2579 break;
2580
2581 case MODDEVEXISTS: /* non-reconfiguring /dev lookup */
2582 error = modctl_devexists((const char *)a1, (size_t)a2);
2583 break;
2584
2585 case MODDEVREADDIR: /* non-reconfiguring /dev readdir */
2586 error = modctl_devreaddir((const char *)a1, (size_t)a2,
2587 (char *)a3, (int64_t *)a4);
2588 break;
2589
2590 case MODDEVEMPTYDIR: /* non-reconfiguring /dev emptydir */
2591 error = modctl_devemptydir((const char *)a1, (size_t)a2,
2592 (int *)a3);
2593 break;
2594
2595 case MODDEVNAME:
2596 error = modctl_moddevname((int)a1, a2, a3);
2597 break;
2598
2599 case MODRETIRE: /* retire device named by physpath a1 */
2600 error = modctl_retire((char *)a1, (char *)a2, (size_t)a3);
2601 break;
2602
2603 case MODISRETIRED: /* check if a device is retired. */
2604 error = modctl_is_retired((char *)a1, (int *)a2);
2605 break;
2606
2607 case MODUNRETIRE: /* unretire device named by physpath a1 */
2608 error = modctl_unretire((char *)a1);
2609 break;
2610
2611 case MODHPOPS: /* hotplug operations */
2612 /* device named by physpath a2 and Connection name a3 */
2613 error = modctl_hp((int)a1, (char *)a2, (char *)a3, a4, a5);
2614 break;
2615
2616 default:
2617 error = EINVAL;
2618 break;
2619 }
2620
2621 return (error ? set_errno(error) : 0);
2622 }
2623
2624 /*
2625 * Calls to kobj_load_module()() are handled off to this routine in a
2626 * separate thread.
2627 */
2628 static void
2629 modload_thread(struct loadmt *ltp)
2630 {
2631 /* load the module and signal the creator of this thread */
2632 kmutex_t cpr_lk;
2633 callb_cpr_t cpr_i;
2634
2635 mutex_init(&cpr_lk, NULL, MUTEX_DEFAULT, NULL);
2636 CALLB_CPR_INIT(&cpr_i, &cpr_lk, callb_generic_cpr, "modload");
2637 /* borrow the devi lock from thread which invoked us */
2638 pm_borrow_lock(ltp->owner);
2639 ltp->retval = kobj_load_module(ltp->mp, ltp->usepath);
2640 pm_return_lock();
2641 sema_v(<p->sema);
2642 mutex_enter(&cpr_lk);
2643 CALLB_CPR_EXIT(&cpr_i);
2644 mutex_destroy(&cpr_lk);
2645 thread_exit();
2646 }
2647
2648 /*
2649 * load a module, adding a reference if caller specifies rmodp. If rmodp
2650 * is specified then an errno is returned, otherwise a module index is
2651 * returned (-1 on error).
2652 */
2653 static int
2654 modrload(const char *subdir, const char *filename, struct modctl **rmodp)
2655 {
2656 struct modctl *modp;
2657 size_t size;
2658 char *fullname;
2659 int retval = EINVAL;
2660 int id = -1;
2661
2662 if (rmodp)
2663 *rmodp = NULL; /* avoid garbage */
2664
2665 if (subdir != NULL) {
2666 /*
2667 * refuse / in filename to prevent "../" escapes.
2668 */
2669 if (strchr(filename, '/') != NULL)
2670 return (rmodp ? retval : id);
2671
2672 /*
2673 * allocate enough space for <subdir>/<filename><NULL>
2674 */
2675 size = strlen(subdir) + strlen(filename) + 2;
2676 fullname = kmem_zalloc(size, KM_SLEEP);
2677 (void) sprintf(fullname, "%s/%s", subdir, filename);
2678 } else {
2679 fullname = (char *)filename;
2680 }
2681
2682 modp = mod_hold_installed_mod(fullname, 1, 0, &retval);
2683 if (modp != NULL) {
2684 id = modp->mod_id;
2685 if (rmodp) {
2686 /* add mod_ref and return *rmodp */
2687 mutex_enter(&mod_lock);
2688 modp->mod_ref++;
2689 mutex_exit(&mod_lock);
2690 *rmodp = modp;
2691 }
2692 mod_release_mod(modp);
2693 CPU_STATS_ADDQ(CPU, sys, modload, 1);
2694 }
2695
2696 done: if (subdir != NULL)
2697 kmem_free(fullname, size);
2698 return (rmodp ? retval : id);
2699 }
2700
2701 /*
2702 * This is the primary kernel interface to load a module. It loads and
2703 * installs the named module. It does not hold mod_ref of the module, so
2704 * a module unload attempt can occur at any time - it is up to the
2705 * _fini/mod_remove implementation to determine if unload will succeed.
2706 */
2707 int
2708 modload(const char *subdir, const char *filename)
2709 {
2710 return (modrload(subdir, filename, NULL));
2711 }
2712
2713 /*
2714 * Load a module using a series of qualified names from most specific to least
2715 * specific, e.g. for subdir "foo", p1 "bar", p2 "baz", we might try:
2716 * Value returned in *chosen
2717 * foo/bar.baz.1.2.3 3
2718 * foo/bar.baz.1.2 2
2719 * foo/bar.baz.1 1
2720 * foo/bar.baz 0
2721 *
2722 * Return the module ID on success; -1 if no module was loaded. On success
2723 * and if 'chosen' is not NULL we also return the number of suffices that
2724 * were in the module we chose to load.
2725 */
2726 int
2727 modload_qualified(const char *subdir, const char *p1,
2728 const char *p2, const char *delim, uint_t suffv[], int suffc, int *chosen)
2729 {
2730 char path[MOD_MAXPATH];
2731 size_t n, resid = sizeof (path);
2732 char *p = path;
2733
2734 char **dotv;
2735 int i, rc, id;
2736 modctl_t *mp;
2737
2738 if (p2 != NULL)
2739 n = snprintf(p, resid, "%s/%s%s%s", subdir, p1, delim, p2);
2740 else
2741 n = snprintf(p, resid, "%s/%s", subdir, p1);
2742
2743 if (n >= resid)
2744 return (-1);
2745
2746 p += n;
2747 resid -= n;
2748 dotv = kmem_alloc(sizeof (char *) * (suffc + 1), KM_SLEEP);
2749
2750 for (i = 0; i < suffc; i++) {
2751 dotv[i] = p;
2752 n = snprintf(p, resid, "%s%u", delim, suffv[i]);
2753
2754 if (n >= resid) {
2755 kmem_free(dotv, sizeof (char *) * (suffc + 1));
2756 return (-1);
2757 }
2758
2759 p += n;
2760 resid -= n;
2761 }
2762
2763 dotv[suffc] = p;
2764
2765 for (i = suffc; i >= 0; i--) {
2766 dotv[i][0] = '\0';
2767 mp = mod_hold_installed_mod(path, 1, 1, &rc);
2768
2769 if (mp != NULL) {
2770 kmem_free(dotv, sizeof (char *) * (suffc + 1));
2771 id = mp->mod_id;
2772 mod_release_mod(mp);
2773 if (chosen != NULL)
2774 *chosen = i;
2775 return (id);
2776 }
2777 }
2778
2779 kmem_free(dotv, sizeof (char *) * (suffc + 1));
2780 return (-1);
2781 }
2782
2783 /*
2784 * Load a module.
2785 */
2786 int
2787 modloadonly(const char *subdir, const char *filename)
2788 {
2789 struct modctl *modp;
2790 char *fullname;
2791 size_t size;
2792 int id, retval;
2793
2794 if (subdir != NULL) {
2795 /*
2796 * allocate enough space for <subdir>/<filename><NULL>
2797 */
2798 size = strlen(subdir) + strlen(filename) + 2;
2799 fullname = kmem_zalloc(size, KM_SLEEP);
2800 (void) sprintf(fullname, "%s/%s", subdir, filename);
2801 } else {
2802 fullname = (char *)filename;
2803 }
2804
2805 id = -1;
2806 modp = mod_hold_loaded_mod(NULL, fullname, &retval);
2807 if (modp) {
2808 id = modp->mod_id;
2809 mod_release_mod(modp);
2810 }
2811
2812 if (subdir != NULL)
2813 kmem_free(fullname, size);
2814
2815 if (retval == 0)
2816 return (id);
2817 return (-1);
2818 }
2819
2820 /*
2821 * Try to uninstall and unload a module, removing a reference if caller
2822 * specifies rmodp.
2823 */
2824 static int
2825 modunrload(modid_t id, struct modctl **rmodp, int unload)
2826 {
2827 struct modctl *modp;
2828 int retval;
2829
2830 if (rmodp)
2831 *rmodp = NULL; /* avoid garbage */
2832
2833 if ((modp = mod_hold_by_id((modid_t)id)) == NULL)
2834 return (EINVAL);
2835
2836 if (rmodp) {
2837 mutex_enter(&mod_lock);
2838 modp->mod_ref--;
2839 if (modp->mod_ref == 0)
2840 mod_uninstall_ref_zero++;
2841 mutex_exit(&mod_lock);
2842 *rmodp = modp;
2843 }
2844
2845 if (unload) {
2846 retval = moduninstall(modp);
2847 if (retval == 0) {
2848 mod_unload(modp);
2849 CPU_STATS_ADDQ(CPU, sys, modunload, 1);
2850 } else if (retval == EALREADY)
2851 retval = 0; /* already unloaded, not an error */
2852 } else
2853 retval = 0;
2854
2855 mod_release_mod(modp);
2856 return (retval);
2857 }
2858
2859 /*
2860 * Uninstall and unload a module.
2861 */
2862 int
2863 modunload(modid_t id)
2864 {
2865 int retval;
2866
2867 /* synchronize with any active modunload_disable() */
2868 modunload_begin();
2869 if (ddi_root_node())
2870 (void) devfs_clean(ddi_root_node(), NULL, 0);
2871 retval = modunrload(id, NULL, 1);
2872 modunload_end();
2873 return (retval);
2874 }
2875
2876 /*
2877 * Return status of a loaded module.
2878 */
2879 static int
2880 modinfo(modid_t id, struct modinfo *modinfop)
2881 {
2882 struct modctl *modp;
2883 modid_t mid;
2884 int i;
2885
2886 mid = modinfop->mi_id;
2887 if (modinfop->mi_info & MI_INFO_ALL) {
2888 while ((modp = mod_hold_next_by_id(mid++)) != NULL) {
2889 if ((modinfop->mi_info & MI_INFO_CNT) ||
2890 modp->mod_installed)
2891 break;
2892 mod_release_mod(modp);
2893 }
2894 if (modp == NULL)
2895 return (EINVAL);
2896 } else {
2897 modp = mod_hold_by_id(id);
2898 if (modp == NULL)
2899 return (EINVAL);
2900 if (!(modinfop->mi_info & MI_INFO_CNT) &&
2901 (modp->mod_installed == 0)) {
2902 mod_release_mod(modp);
2903 return (EINVAL);
2904 }
2905 }
2906
2907 modinfop->mi_rev = 0;
2908 modinfop->mi_state = 0;
2909 for (i = 0; i < MODMAXLINK; i++) {
2910 modinfop->mi_msinfo[i].msi_p0 = -1;
2911 modinfop->mi_msinfo[i].msi_linkinfo[0] = 0;
2912 }
2913 if (modp->mod_loaded) {
2914 modinfop->mi_state = MI_LOADED;
2915 kobj_getmodinfo(modp->mod_mp, modinfop);
2916 }
2917 if (modp->mod_installed) {
2918 modinfop->mi_state |= MI_INSTALLED;
2919
2920 (void) mod_getinfo(modp, modinfop);
2921 }
2922
2923 modinfop->mi_id = modp->mod_id;
2924 modinfop->mi_loadcnt = modp->mod_loadcnt;
2925 (void) strcpy(modinfop->mi_name, modp->mod_modname);
2926
2927 mod_release_mod(modp);
2928 return (0);
2929 }
2930
2931 static char mod_stub_err[] = "mod_hold_stub: Couldn't load stub module %s";
2932 static char no_err[] = "No error function for weak stub %s";
2933
2934 /*
2935 * used by the stubs themselves to load and hold a module.
2936 * Returns 0 if the module is successfully held;
2937 * the stub needs to call mod_release_stub().
2938 * -1 if the stub should just call the err_fcn.
2939 * Note that this code is stretched out so that we avoid subroutine calls
2940 * and optimize for the most likely case. That is, the case where the
2941 * module is loaded and installed and not held. In that case we just inc
2942 * the mod_ref count and continue.
2943 */
2944 int
2945 mod_hold_stub(struct mod_stub_info *stub)
2946 {
2947 struct modctl *mp;
2948 struct mod_modinfo *mip;
2949
2950 mip = stub->mods_modinfo;
2951
2952 mutex_enter(&mod_lock);
2953
2954 /* we do mod_hold_by_modctl inline for speed */
2955
2956 mod_check_again:
2957 if ((mp = mip->mp) != NULL) {
2958 if (mp->mod_busy == 0) {
2959 if (mp->mod_installed) {
2960 /* increment the reference count */
2961 mp->mod_ref++;
2962 ASSERT(mp->mod_ref && mp->mod_installed);
2963 mutex_exit(&mod_lock);
2964 return (0);
2965 } else {
2966 mp->mod_busy = 1;
2967 mp->mod_inprogress_thread =
2968 (curthread == NULL ?
2969 (kthread_id_t)-1 : curthread);
2970 }
2971 } else {
2972 /*
2973 * wait one time and then go see if someone
2974 * else has resolved the stub (set mip->mp).
2975 */
2976 if (mod_hold_by_modctl(mp,
2977 MOD_WAIT_ONCE | MOD_LOCK_HELD))
2978 goto mod_check_again;
2979
2980 /*
2981 * what we have now may have been unloaded!, in
2982 * that case, mip->mp will be NULL, we'll hit this
2983 * module and load again..
2984 */
2985 cmn_err(CE_PANIC, "mod_hold_stub should have blocked");
2986 }
2987 mutex_exit(&mod_lock);
2988 } else {
2989 /* first time we've hit this module */
2990 mutex_exit(&mod_lock);
2991 mp = mod_hold_by_name(mip->modm_module_name);
2992 mip->mp = mp;
2993 }
2994
2995 /*
2996 * If we are here, it means that the following conditions
2997 * are satisfied.
2998 *
2999 * mip->mp != NULL
3000 * this thread has set the mp->mod_busy = 1
3001 * mp->mod_installed = 0
3002 *
3003 */
3004 ASSERT(mp != NULL);
3005 ASSERT(mp->mod_busy == 1);
3006
3007 if (mp->mod_installed == 0) {
3008 /* Module not loaded, if weak stub don't load it */
3009 if (stub->mods_flag & MODS_WEAK) {
3010 if (stub->mods_errfcn == NULL) {
3011 mod_release_mod(mp);
3012 cmn_err(CE_PANIC, no_err,
3013 mip->modm_module_name);
3014 }
3015 } else {
3016 /* Not a weak stub so load the module */
3017
3018 if (mod_load(mp, 1) != 0 || modinstall(mp) != 0) {
3019 /*
3020 * If mod_load() was successful
3021 * and modinstall() failed, then
3022 * unload the module.
3023 */
3024 if (mp->mod_loaded)
3025 mod_unload(mp);
3026
3027 mod_release_mod(mp);
3028 if (stub->mods_errfcn == NULL) {
3029 cmn_err(CE_PANIC, mod_stub_err,
3030 mip->modm_module_name);
3031 } else {
3032 return (-1);
3033 }
3034 }
3035 }
3036 }
3037
3038 /*
3039 * At this point module is held and loaded. Release
3040 * the mod_busy and mod_inprogress_thread before
3041 * returning. We actually call mod_release() here so
3042 * that if another stub wants to access this module,
3043 * it can do so. mod_ref is incremented before mod_release()
3044 * is called to prevent someone else from snatching the
3045 * module from this thread.
3046 */
3047 mutex_enter(&mod_lock);
3048 mp->mod_ref++;
3049 ASSERT(mp->mod_ref &&
3050 (mp->mod_loaded || (stub->mods_flag & MODS_WEAK)));
3051 mod_release(mp);
3052 mutex_exit(&mod_lock);
3053 return (0);
3054 }
3055
3056 void
3057 mod_release_stub(struct mod_stub_info *stub)
3058 {
3059 struct modctl *mp = stub->mods_modinfo->mp;
3060
3061 /* inline mod_release_mod */
3062 mutex_enter(&mod_lock);
3063 ASSERT(mp->mod_ref &&
3064 (mp->mod_loaded || (stub->mods_flag & MODS_WEAK)));
3065 mp->mod_ref--;
3066 if (mp->mod_ref == 0)
3067 mod_uninstall_ref_zero++;
3068 if (mp->mod_want) {
3069 mp->mod_want = 0;
3070 cv_broadcast(&mod_cv);
3071 }
3072 mutex_exit(&mod_lock);
3073 }
3074
3075 static struct modctl *
3076 mod_hold_loaded_mod(struct modctl *dep, char *filename, int *status)
3077 {
3078 struct modctl *modp;
3079 int retval;
3080
3081 /*
3082 * Hold the module.
3083 */
3084 modp = mod_hold_by_name_requisite(dep, filename);
3085 if (modp) {
3086 retval = mod_load(modp, 1);
3087 if (retval != 0) {
3088 mod_release_mod(modp);
3089 modp = NULL;
3090 }
3091 *status = retval;
3092 } else {
3093 *status = ENOSPC;
3094 }
3095
3096 /*
3097 * if dep is not NULL, clear the module dependency information.
3098 * This information is set in mod_hold_by_name_common().
3099 */
3100 if (dep != NULL && dep->mod_requisite_loading != NULL) {
3101 ASSERT(dep->mod_busy);
3102 dep->mod_requisite_loading = NULL;
3103 }
3104
3105 return (modp);
3106 }
3107
3108 /*
3109 * hold, load, and install the named module
3110 */
3111 static struct modctl *
3112 mod_hold_installed_mod(char *name, int usepath, int forcecheck, int *r)
3113 {
3114 struct modctl *modp;
3115 int retval;
3116
3117 /*
3118 * Verify that that module in question actually exists on disk
3119 * before allocation of module structure by mod_hold_by_name.
3120 */
3121 if (modrootloaded && swaploaded || forcecheck) {
3122 if (!kobj_path_exists(name, usepath)) {
3123 *r = ENOENT;
3124 return (NULL);
3125 }
3126 }
3127
3128 /*
3129 * Hold the module.
3130 */
3131 modp = mod_hold_by_name(name);
3132 if (modp) {
3133 retval = mod_load(modp, usepath);
3134 if (retval != 0) {
3135 mod_release_mod(modp);
3136 modp = NULL;
3137 *r = retval;
3138 } else {
3139 if ((*r = modinstall(modp)) != 0) {
3140 /*
3141 * We loaded it, but failed to _init() it.
3142 * Be kind to developers -- force it
3143 * out of memory now so that the next
3144 * attempt to use the module will cause
3145 * a reload. See 1093793.
3146 */
3147 mod_unload(modp);
3148 mod_release_mod(modp);
3149 modp = NULL;
3150 }
3151 }
3152 } else {
3153 *r = ENOSPC;
3154 }
3155 return (modp);
3156 }
3157
3158 static char mod_excl_msg[] =
3159 "module %s(%s) is EXCLUDED and will not be loaded\n";
3160 static char mod_init_msg[] = "loadmodule:%s(%s): _init() error %d\n";
3161
3162 /*
3163 * This routine is needed for dependencies. Users specify dependencies
3164 * by declaring a character array initialized to filenames of dependents.
3165 * So the code that handles dependents deals with filenames (and not
3166 * module names) because that's all it has. We load by filename and once
3167 * we've loaded a file we can get the module name.
3168 * Unfortunately there isn't a single unified filename/modulename namespace.
3169 * C'est la vie.
3170 *
3171 * We allow the name being looked up to be prepended by an optional
3172 * subdirectory e.g. we can lookup (NULL, "fs/ufs") or ("fs", "ufs")
3173 */
3174 struct modctl *
3175 mod_find_by_filename(char *subdir, char *filename)
3176 {
3177 struct modctl *mp;
3178 size_t sublen;
3179
3180 ASSERT(!MUTEX_HELD(&mod_lock));
3181 if (subdir != NULL)
3182 sublen = strlen(subdir);
3183 else
3184 sublen = 0;
3185
3186 mutex_enter(&mod_lock);
3187 mp = &modules;
3188 do {
3189 if (sublen) {
3190 char *mod_filename = mp->mod_filename;
3191
3192 if (strncmp(subdir, mod_filename, sublen) == 0 &&
3193 mod_filename[sublen] == '/' &&
3194 strcmp(filename, &mod_filename[sublen + 1]) == 0) {
3195 mutex_exit(&mod_lock);
3196 return (mp);
3197 }
3198 } else if (strcmp(filename, mp->mod_filename) == 0) {
3199 mutex_exit(&mod_lock);
3200 return (mp);
3201 }
3202 } while ((mp = mp->mod_next) != &modules);
3203 mutex_exit(&mod_lock);
3204 return (NULL);
3205 }
3206
3207 /*
3208 * Check for circular dependencies. This is called from do_dependents()
3209 * in kobj.c. If we are the thread already loading this module, then
3210 * we're trying to load a dependent that we're already loading which
3211 * means the user specified circular dependencies.
3212 */
3213 static int
3214 mod_circdep(struct modctl *modp)
3215 {
3216 struct modctl *rmod;
3217
3218 ASSERT(MUTEX_HELD(&mod_lock));
3219
3220 /*
3221 * Check the mod_inprogress_thread first.
3222 * mod_inprogress_thread is used in mod_hold_stub()
3223 * directly to improve performance.
3224 */
3225 if (modp->mod_inprogress_thread == curthread)
3226 return (1);
3227
3228 /*
3229 * Check the module circular dependencies.
3230 */
3231 for (rmod = modp; rmod != NULL; rmod = rmod->mod_requisite_loading) {
3232 /*
3233 * Check if there is a module circular dependency.
3234 */
3235 if (rmod->mod_requisite_loading == modp)
3236 return (1);
3237 }
3238 return (0);
3239 }
3240
3241 static int
3242 mod_getinfo(struct modctl *modp, struct modinfo *modinfop)
3243 {
3244 int (*func)(struct modinfo *);
3245 int retval;
3246
3247 ASSERT(modp->mod_busy);
3248
3249 /* primary modules don't do getinfo */
3250 if (modp->mod_prim)
3251 return (0);
3252
3253 func = (int (*)(struct modinfo *))kobj_lookup(modp->mod_mp, "_info");
3254
3255 if (kobj_addrcheck(modp->mod_mp, (caddr_t)func)) {
3256 cmn_err(CE_WARN, "_info() not defined properly in %s",
3257 modp->mod_filename);
3258 /*
3259 * The semantics of mod_info(9F) are that 0 is failure
3260 * and non-zero is success.
3261 */
3262 retval = 0;
3263 } else
3264 retval = (*func)(modinfop); /* call _info() function */
3265
3266 if (moddebug & MODDEBUG_USERDEBUG)
3267 printf("Returned from _info, retval = %x\n", retval);
3268
3269 return (retval);
3270 }
3271
3272 static void
3273 modadd(struct modctl *mp)
3274 {
3275 ASSERT(MUTEX_HELD(&mod_lock));
3276
3277 mp->mod_id = last_module_id++;
3278 mp->mod_next = &modules;
3279 mp->mod_prev = modules.mod_prev;
3280 modules.mod_prev->mod_next = mp;
3281 modules.mod_prev = mp;
3282 }
3283
3284 /*ARGSUSED*/
3285 static struct modctl *
3286 allocate_modp(const char *filename, const char *modname)
3287 {
3288 struct modctl *mp;
3289
3290 mp = kobj_zalloc(sizeof (*mp), KM_SLEEP);
3291 mp->mod_modname = kobj_zalloc(strlen(modname) + 1, KM_SLEEP);
3292 (void) strcpy(mp->mod_modname, modname);
3293 return (mp);
3294 }
3295
3296 /*
3297 * Get the value of a symbol. This is a wrapper routine that
3298 * calls kobj_getsymvalue(). kobj_getsymvalue() may go away but this
3299 * wrapper will prevent callers from noticing.
3300 */
3301 uintptr_t
3302 modgetsymvalue(char *name, int kernelonly)
3303 {
3304 return (kobj_getsymvalue(name, kernelonly));
3305 }
3306
3307 /*
3308 * Get the symbol nearest an address. This is a wrapper routine that
3309 * calls kobj_getsymname(). kobj_getsymname() may go away but this
3310 * wrapper will prevent callers from noticing.
3311 */
3312 char *
3313 modgetsymname(uintptr_t value, ulong_t *offset)
3314 {
3315 return (kobj_getsymname(value, offset));
3316 }
3317
3318 /*
3319 * Lookup a symbol in a specified module. These are wrapper routines that
3320 * call kobj_lookup(). kobj_lookup() may go away but these wrappers will
3321 * prevent callers from noticing.
3322 */
3323 uintptr_t
3324 modlookup(const char *modname, const char *symname)
3325 {
3326 struct modctl *modp;
3327 uintptr_t val;
3328
3329 if ((modp = mod_hold_by_name(modname)) == NULL)
3330 return (0);
3331 val = kobj_lookup(modp->mod_mp, symname);
3332 mod_release_mod(modp);
3333 return (val);
3334 }
3335
3336 uintptr_t
3337 modlookup_by_modctl(modctl_t *modp, const char *symname)
3338 {
3339 ASSERT(modp->mod_ref > 0 || modp->mod_busy);
3340
3341 return (kobj_lookup(modp->mod_mp, symname));
3342 }
3343
3344 /*
3345 * Ask the user for the name of the system file and the default path
3346 * for modules.
3347 */
3348 void
3349 mod_askparams()
3350 {
3351 static char s0[64];
3352 intptr_t fd;
3353
3354 if ((fd = kobj_open(systemfile)) != -1L)
3355 kobj_close(fd);
3356 else
3357 systemfile = self_assembly = NULL;
3358
3359 /*CONSTANTCONDITION*/
3360 while (1) {
3361 printf("Name of system file [%s]: ",
3362 systemfile ? systemfile : "/dev/null");
3363
3364 console_gets(s0, sizeof (s0));
3365
3366 if (s0[0] == '\0')
3367 break;
3368 else if (strcmp(s0, "/dev/null") == 0) {
3369 systemfile = self_assembly = NULL;
3370 break;
3371 } else {
3372 if ((fd = kobj_open(s0)) != -1L) {
3373 kobj_close(fd);
3374 systemfile = s0;
3375 self_assembly = NULL;
3376 break;
3377 }
3378 }
3379 printf("can't find file %s\n", s0);
3380 }
3381 }
3382
3383 static char loading_msg[] = "loading '%s' id %d\n";
3384 static char load_msg[] = "load '%s' id %d loaded @ 0x%p/0x%p size %d/%d\n";
3385
3386 /*
3387 * Common code for loading a module (but not installing it).
3388 * Handoff the task of module loading to a separate thread
3389 * with a large stack if possible, since this code may recurse a few times.
3390 * Return zero if there are no errors or an errno value.
3391 */
3392 static int
3393 mod_load(struct modctl *mp, int usepath)
3394 {
3395 int retval;
3396 struct modinfo *modinfop = NULL;
3397 struct loadmt lt;
3398
3399 ASSERT(MUTEX_NOT_HELD(&mod_lock));
3400 ASSERT(mp->mod_busy);
3401
3402 if (mp->mod_loaded)
3403 return (0);
3404
3405 if (mod_sysctl(SYS_CHECK_EXCLUDE, mp->mod_modname) != 0 ||
3406 mod_sysctl(SYS_CHECK_EXCLUDE, mp->mod_filename) != 0) {
3407 if (moddebug & MODDEBUG_LOADMSG) {
3408 printf(mod_excl_msg, mp->mod_filename,
3409 mp->mod_modname);
3410 }
3411 return (ENXIO);
3412 }
3413 if (moddebug & MODDEBUG_LOADMSG2)
3414 printf(loading_msg, mp->mod_filename, mp->mod_id);
3415
3416 if (curthread != &t0) {
3417 lt.mp = mp;
3418 lt.usepath = usepath;
3419 lt.owner = curthread;
3420 sema_init(<.sema, 0, NULL, SEMA_DEFAULT, NULL);
3421
3422 /* create thread to hand of call to */
3423 (void) thread_create(NULL, DEFAULTSTKSZ * 2,
3424 modload_thread, <, 0, &p0, TS_RUN, maxclsyspri);
3425
3426 /* wait for thread to complete kobj_load_module */
3427 sema_p(<.sema);
3428
3429 sema_destroy(<.sema);
3430 retval = lt.retval;
3431 } else
3432 retval = kobj_load_module(mp, usepath);
3433
3434 if (mp->mod_mp) {
3435 ASSERT(retval == 0);
3436 mp->mod_loaded = 1;
3437 mp->mod_loadcnt++;
3438 if (moddebug & MODDEBUG_LOADMSG) {
3439 printf(load_msg, mp->mod_filename, mp->mod_id,
3440 (void *)((struct module *)mp->mod_mp)->text,
3441 (void *)((struct module *)mp->mod_mp)->data,
3442 ((struct module *)mp->mod_mp)->text_size,
3443 ((struct module *)mp->mod_mp)->data_size);
3444 }
3445
3446 /*
3447 * XXX - There should be a better way to get this.
3448 */
3449 modinfop = kmem_zalloc(sizeof (struct modinfo), KM_SLEEP);
3450 modinfop->mi_info = MI_INFO_LINKAGE;
3451 if (mod_getinfo(mp, modinfop) == 0)
3452 mp->mod_linkage = NULL;
3453 else {
3454 mp->mod_linkage = (void *)modinfop->mi_base;
3455 ASSERT(mp->mod_linkage->ml_rev == MODREV_1);
3456 }
3457
3458 /*
3459 * DCS: bootstrapping code. If the driver is loaded
3460 * before root mount, it is assumed that the driver
3461 * may be used before mounting root. In order to
3462 * access mappings of global to local minor no.'s
3463 * during installation/open of the driver, we load
3464 * them into memory here while the BOP_interfaces
3465 * are still up.
3466 */
3467 if ((cluster_bootflags & CLUSTER_BOOTED) && !modrootloaded) {
3468 retval = clboot_modload(mp);
3469 }
3470
3471 kmem_free(modinfop, sizeof (struct modinfo));
3472 (void) mod_sysctl(SYS_SET_MVAR, (void *)mp);
3473 retval = install_stubs_by_name(mp, mp->mod_modname);
3474
3475 /*
3476 * Now that the module is loaded, we need to give DTrace
3477 * a chance to notify its providers. This is done via
3478 * the dtrace_modload function pointer.
3479 */
3480 if (strcmp(mp->mod_modname, "dtrace") != 0) {
3481 struct modctl *dmp = mod_hold_by_name("dtrace");
3482
3483 if (dmp != NULL && dtrace_modload != NULL)
3484 (*dtrace_modload)(mp);
3485
3486 mod_release_mod(dmp);
3487 }
3488
3489 } else {
3490 /*
3491 * If load failed then we need to release any requisites
3492 * that we had established.
3493 */
3494 ASSERT(retval);
3495 mod_release_requisites(mp);
3496
3497 if (moddebug & MODDEBUG_ERRMSG)
3498 printf("error loading '%s', error %d\n",
3499 mp->mod_filename, retval);
3500 }
3501 return (retval);
3502 }
3503
3504 static char unload_msg[] = "unloading %s, module id %d, loadcnt %d.\n";
3505
3506 static void
3507 mod_unload(struct modctl *mp)
3508 {
3509 ASSERT(MUTEX_NOT_HELD(&mod_lock));
3510 ASSERT(mp->mod_busy);
3511 ASSERT((mp->mod_loaded && (mp->mod_installed == 0)) &&
3512 ((mp->mod_prim == 0) && (mp->mod_ref >= 0)));
3513
3514 if (moddebug & MODDEBUG_LOADMSG)
3515 printf(unload_msg, mp->mod_modname,
3516 mp->mod_id, mp->mod_loadcnt);
3517
3518 /*
3519 * If mod_ref is not zero, it means some modules might still refer
3520 * to this module. Then you can't unload this module right now.
3521 * Instead, set 1 to mod_delay_unload to notify the system of
3522 * unloading this module later when it's not required any more.
3523 */
3524 if (mp->mod_ref > 0) {
3525 mp->mod_delay_unload = 1;
3526 if (moddebug & MODDEBUG_LOADMSG2) {
3527 printf("module %s not unloaded,"
3528 " non-zero reference count (%d)",
3529 mp->mod_modname, mp->mod_ref);
3530 }
3531 return;
3532 }
3533
3534 if (((mp->mod_loaded == 0) || mp->mod_installed) ||
3535 (mp->mod_ref || mp->mod_prim)) {
3536 /*
3537 * A DEBUG kernel would ASSERT panic above, the code is broken
3538 * if we get this warning.
3539 */
3540 cmn_err(CE_WARN, "mod_unload: %s in incorrect state: %d %d %d",
3541 mp->mod_filename, mp->mod_installed, mp->mod_loaded,
3542 mp->mod_ref);
3543 return;
3544 }
3545
3546 /* reset stub functions to call the binder again */
3547 reset_stubs(mp);
3548
3549 /*
3550 * mark module as unloaded before the modctl structure is freed.
3551 * This is required not to reuse the modctl structure before
3552 * the module is marked as unloaded.
3553 */
3554 mp->mod_loaded = 0;
3555 mp->mod_linkage = NULL;
3556
3557 /* free the memory */
3558 kobj_unload_module(mp);
3559
3560 if (mp->mod_delay_unload) {
3561 mp->mod_delay_unload = 0;
3562 if (moddebug & MODDEBUG_LOADMSG2) {
3563 printf("deferred unload of module %s"
3564 " (id %d) successful",
3565 mp->mod_modname, mp->mod_id);
3566 }
3567 }
3568
3569 /* release hold on requisites */
3570 mod_release_requisites(mp);
3571
3572 /*
3573 * Now that the module is gone, we need to give DTrace a chance to
3574 * remove any probes that it may have had in the module. This is
3575 * done via the dtrace_modunload function pointer.
3576 */
3577 if (strcmp(mp->mod_modname, "dtrace") != 0) {
3578 struct modctl *dmp = mod_hold_by_name("dtrace");
3579
3580 if (dmp != NULL && dtrace_modunload != NULL)
3581 (*dtrace_modunload)(mp);
3582
3583 mod_release_mod(dmp);
3584 }
3585 }
3586
3587 static int
3588 modinstall(struct modctl *mp)
3589 {
3590 int val;
3591 int (*func)(void);
3592
3593 ASSERT(MUTEX_NOT_HELD(&mod_lock));
3594 ASSERT(mp->mod_busy && mp->mod_loaded);
3595
3596 if (mp->mod_installed)
3597 return (0);
3598 /*
3599 * If mod_delay_unload is on, it means the system chose the deferred
3600 * unload for this module. Then you can't install this module until
3601 * it's unloaded from the system.
3602 */
3603 if (mp->mod_delay_unload)
3604 return (ENXIO);
3605
3606 if (moddebug & MODDEBUG_LOADMSG)
3607 printf("installing %s, module id %d.\n",
3608 mp->mod_modname, mp->mod_id);
3609
3610 ASSERT(mp->mod_mp != NULL);
3611 if (mod_install_requisites(mp) != 0) {
3612 /*
3613 * Note that we can't call mod_unload(mp) here since
3614 * if modinstall() was called by mod_install_requisites(),
3615 * we won't be able to hold the dependent modules
3616 * (otherwise there would be a deadlock).
3617 */
3618 return (ENXIO);
3619 }
3620
3621 if (moddebug & MODDEBUG_ERRMSG) {
3622 printf("init '%s' id %d loaded @ 0x%p/0x%p size %lu/%lu\n",
3623 mp->mod_filename, mp->mod_id,
3624 (void *)((struct module *)mp->mod_mp)->text,
3625 (void *)((struct module *)mp->mod_mp)->data,
3626 ((struct module *)mp->mod_mp)->text_size,
3627 ((struct module *)mp->mod_mp)->data_size);
3628 }
3629
3630 func = (int (*)())kobj_lookup(mp->mod_mp, "_init");
3631
3632 if (kobj_addrcheck(mp->mod_mp, (caddr_t)func)) {
3633 cmn_err(CE_WARN, "_init() not defined properly in %s",
3634 mp->mod_filename);
3635 return (EFAULT);
3636 }
3637
3638 if (moddebug & MODDEBUG_USERDEBUG) {
3639 printf("breakpoint before calling %s:_init()\n",
3640 mp->mod_modname);
3641 if (DEBUGGER_PRESENT)
3642 debug_enter("_init");
3643 }
3644
3645 ASSERT(MUTEX_NOT_HELD(&mod_lock));
3646 ASSERT(mp->mod_busy && mp->mod_loaded);
3647 val = (*func)(); /* call _init */
3648
3649 if (moddebug & MODDEBUG_USERDEBUG)
3650 printf("Returned from _init, val = %x\n", val);
3651
3652 if (val == 0) {
3653 /*
3654 * Set the MODS_INSTALLED flag to enable this module
3655 * being called now.
3656 */
3657 install_stubs(mp);
3658 mp->mod_installed = 1;
3659 } else if (moddebug & MODDEBUG_ERRMSG)
3660 printf(mod_init_msg, mp->mod_filename, mp->mod_modname, val);
3661
3662 return (val);
3663 }
3664
3665 int detach_driver_unconfig = 0;
3666
3667 static int
3668 detach_driver(char *name)
3669 {
3670 major_t major;
3671 int error;
3672
3673 /*
3674 * If being called from mod_uninstall_all() then the appropriate
3675 * driver detaches (leaf only) have already been done.
3676 */
3677 if (mod_in_autounload())
3678 return (0);
3679
3680 major = ddi_name_to_major(name);
3681 if (major == DDI_MAJOR_T_NONE)
3682 return (0);
3683
3684 error = ndi_devi_unconfig_driver(ddi_root_node(),
3685 NDI_DETACH_DRIVER | detach_driver_unconfig, major);
3686 return (error == NDI_SUCCESS ? 0 : -1);
3687 }
3688
3689 static char finiret_msg[] = "Returned from _fini for %s, status = %x\n";
3690
3691 static int
3692 moduninstall(struct modctl *mp)
3693 {
3694 int status = 0;
3695 int (*func)(void);
3696
3697 ASSERT(MUTEX_NOT_HELD(&mod_lock));
3698 ASSERT(mp->mod_busy);
3699
3700 /*
3701 * Verify that we need to do something and can uninstall the module.
3702 *
3703 * If we should not uninstall the module or if the module is not in
3704 * the correct state to start an uninstall we return EBUSY to prevent
3705 * us from progressing to mod_unload. If the module has already been
3706 * uninstalled and unloaded we return EALREADY.
3707 */
3708 if (mp->mod_prim || mp->mod_ref || mp->mod_nenabled != 0)
3709 return (EBUSY);
3710 if ((mp->mod_installed == 0) || (mp->mod_loaded == 0))
3711 return (EALREADY);
3712
3713 /*
3714 * To avoid devinfo / module deadlock we must release this module
3715 * prior to initiating the detach_driver, otherwise the detach_driver
3716 * might deadlock on a devinfo node held by another thread
3717 * coming top down and involving the module we have locked.
3718 *
3719 * When we regrab the module we must reverify that it is OK
3720 * to proceed with the uninstall operation.
3721 */
3722 mod_release_mod(mp);
3723 status = detach_driver(mp->mod_modname);
3724 (void) mod_hold_by_modctl(mp, MOD_WAIT_FOREVER | MOD_LOCK_NOT_HELD);
3725
3726 /* check detach status and reverify state with lock */
3727 mutex_enter(&mod_lock);
3728 if ((status != 0) || mp->mod_prim || mp->mod_ref) {
3729 mutex_exit(&mod_lock);
3730 return (EBUSY);
3731 }
3732 if ((mp->mod_installed == 0) || (mp->mod_loaded == 0)) {
3733 mutex_exit(&mod_lock);
3734 return (EALREADY);
3735 }
3736 mutex_exit(&mod_lock);
3737
3738 if (moddebug & MODDEBUG_LOADMSG2)
3739 printf("uninstalling %s\n", mp->mod_modname);
3740
3741 /*
3742 * lookup _fini, return EBUSY if not defined.
3743 *
3744 * The MODDEBUG_FINI_EBUSY is usefull in resolving leaks in
3745 * detach(9E) - it allows bufctl addresses to be resolved.
3746 */
3747 func = (int (*)())kobj_lookup(mp->mod_mp, "_fini");
3748 if ((func == NULL) || (mp->mod_loadflags & MOD_NOUNLOAD) ||
3749 (moddebug & MODDEBUG_FINI_EBUSY))
3750 return (EBUSY);
3751
3752 /* verify that _fini is in this module */
3753 if (kobj_addrcheck(mp->mod_mp, (caddr_t)func)) {
3754 cmn_err(CE_WARN, "_fini() not defined properly in %s",
3755 mp->mod_filename);
3756 return (EFAULT);
3757 }
3758
3759 /* call _fini() */
3760 ASSERT(MUTEX_NOT_HELD(&mod_lock));
3761 ASSERT(mp->mod_busy && mp->mod_loaded && mp->mod_installed);
3762
3763 status = (*func)();
3764
3765 if (status == 0) {
3766 /* _fini returned success, the module is no longer installed */
3767 if (moddebug & MODDEBUG_LOADMSG)
3768 printf("uninstalled %s\n", mp->mod_modname);
3769
3770 /*
3771 * Even though we only set mod_installed to zero here, a zero
3772 * return value means we are committed to a code path were
3773 * mod_loaded will also end up as zero - we have no other
3774 * way to get the module data and bss back to the pre _init
3775 * state except a reload. To ensure this, after return,
3776 * mod_busy must stay set until mod_loaded is cleared.
3777 */
3778 mp->mod_installed = 0;
3779
3780 /*
3781 * Clear the MODS_INSTALLED flag not to call functions
3782 * in the module directly from now on.
3783 */
3784 uninstall_stubs(mp);
3785 } else {
3786 if (moddebug & MODDEBUG_USERDEBUG)
3787 printf(finiret_msg, mp->mod_filename, status);
3788 /*
3789 * By definition _fini is only allowed to return EBUSY or the
3790 * result of mod_remove (EBUSY or EINVAL). In the off chance
3791 * that a driver returns EALREADY we convert this to EINVAL
3792 * since to our caller EALREADY means module was already
3793 * removed.
3794 */
3795 if (status == EALREADY)
3796 status = EINVAL;
3797 }
3798
3799 return (status);
3800 }
3801
3802 /*
3803 * Uninstall all modules.
3804 */
3805 static void
3806 mod_uninstall_all(void)
3807 {
3808 struct modctl *mp;
3809 int pass;
3810 modid_t modid;
3811
3812 /* synchronize with any active modunload_disable() */
3813 modunload_begin();
3814
3815 /* mark this thread as doing autounloading */
3816 (void) tsd_set(mod_autounload_key, (void *)1);
3817
3818 (void) devfs_clean(ddi_root_node(), NULL, 0);
3819 (void) ndi_devi_unconfig(ddi_root_node(), NDI_AUTODETACH);
3820
3821 /*
3822 * Loop up to max times if we keep producing unreferenced modules.
3823 * A new unreferenced module is an opportunity to unload.
3824 */
3825 for (pass = 0; pass < mod_uninstall_pass_max; pass++) {
3826
3827 /* zero count of modules that go unreferenced during pass */
3828 mod_uninstall_ref_zero = 0;
3829
3830 modid = 0;
3831 while ((mp = mod_hold_next_by_id(modid)) != NULL) {
3832 modid = mp->mod_id;
3833
3834 /*
3835 * Skip modules with the MOD_NOAUTOUNLOAD flag set
3836 */
3837 if (mp->mod_loadflags & MOD_NOAUTOUNLOAD) {
3838 mod_release_mod(mp);
3839 continue;
3840 }
3841
3842 if (moduninstall(mp) == 0) {
3843 mod_unload(mp);
3844 CPU_STATS_ADDQ(CPU, sys, modunload, 1);
3845 }
3846 mod_release_mod(mp);
3847 }
3848
3849 /* break if no modules went unreferenced during pass */
3850 if (mod_uninstall_ref_zero == 0)
3851 break;
3852 }
3853 if (pass >= mod_uninstall_pass_max)
3854 mod_uninstall_pass_exc++;
3855
3856 (void) tsd_set(mod_autounload_key, NULL);
3857 modunload_end();
3858 }
3859
3860 /* wait for unloads that have begun before registering disable */
3861 void
3862 modunload_disable(void)
3863 {
3864 mutex_enter(&modunload_wait_mutex);
3865 while (modunload_active_count) {
3866 modunload_wait++;
3867 cv_wait(&modunload_wait_cv, &modunload_wait_mutex);
3868 modunload_wait--;
3869 }
3870 modunload_disable_count++;
3871 mutex_exit(&modunload_wait_mutex);
3872 }
3873
3874 /* mark end of disable and signal waiters */
3875 void
3876 modunload_enable(void)
3877 {
3878 mutex_enter(&modunload_wait_mutex);
3879 modunload_disable_count--;
3880 if ((modunload_disable_count == 0) && modunload_wait)
3881 cv_broadcast(&modunload_wait_cv);
3882 mutex_exit(&modunload_wait_mutex);
3883 }
3884
3885 /* wait for disables to complete before begining unload */
3886 void
3887 modunload_begin()
3888 {
3889 mutex_enter(&modunload_wait_mutex);
3890 while (modunload_disable_count) {
3891 modunload_wait++;
3892 cv_wait(&modunload_wait_cv, &modunload_wait_mutex);
3893 modunload_wait--;
3894 }
3895 modunload_active_count++;
3896 mutex_exit(&modunload_wait_mutex);
3897 }
3898
3899 /* mark end of unload and signal waiters */
3900 void
3901 modunload_end()
3902 {
3903 mutex_enter(&modunload_wait_mutex);
3904 modunload_active_count--;
3905 if ((modunload_active_count == 0) && modunload_wait)
3906 cv_broadcast(&modunload_wait_cv);
3907 mutex_exit(&modunload_wait_mutex);
3908 }
3909
3910 void
3911 mod_uninstall_daemon(void)
3912 {
3913 callb_cpr_t cprinfo;
3914 clock_t ticks;
3915
3916 mod_aul_thread = curthread;
3917
3918 CALLB_CPR_INIT(&cprinfo, &mod_uninstall_lock, callb_generic_cpr, "mud");
3919 for (;;) {
3920 mutex_enter(&mod_uninstall_lock);
3921 CALLB_CPR_SAFE_BEGIN(&cprinfo);
3922 /*
3923 * In DEBUG kernels, unheld drivers are uninstalled periodically
3924 * every mod_uninstall_interval seconds. Periodic uninstall can
3925 * be disabled by setting mod_uninstall_interval to 0 which is
3926 * the default for a non-DEBUG kernel.
3927 */
3928 if (mod_uninstall_interval) {
3929 ticks = drv_usectohz(mod_uninstall_interval * 1000000);
3930 (void) cv_reltimedwait(&mod_uninstall_cv,
3931 &mod_uninstall_lock, ticks, TR_CLOCK_TICK);
3932 } else {
3933 cv_wait(&mod_uninstall_cv, &mod_uninstall_lock);
3934 }
3935 /*
3936 * The whole daemon is safe for CPR except we don't want
3937 * the daemon to run if FREEZE is issued and this daemon
3938 * wakes up from the cv_wait above. In this case, it'll be
3939 * blocked in CALLB_CPR_SAFE_END until THAW is issued.
3940 *
3941 * The reason of calling CALLB_CPR_SAFE_BEGIN twice is that
3942 * mod_uninstall_lock is used to protect cprinfo and
3943 * CALLB_CPR_SAFE_BEGIN assumes that this lock is held when
3944 * called.
3945 */
3946 CALLB_CPR_SAFE_END(&cprinfo, &mod_uninstall_lock);
3947 CALLB_CPR_SAFE_BEGIN(&cprinfo);
3948 mutex_exit(&mod_uninstall_lock);
3949 if ((modunload_disable_count == 0) &&
3950 ((moddebug & MODDEBUG_NOAUTOUNLOAD) == 0)) {
3951 mod_uninstall_all();
3952 }
3953 }
3954 }
3955
3956 /*
3957 * Unload all uninstalled modules.
3958 */
3959 void
3960 modreap(void)
3961 {
3962 mutex_enter(&mod_uninstall_lock);
3963 cv_broadcast(&mod_uninstall_cv);
3964 mutex_exit(&mod_uninstall_lock);
3965 }
3966
3967 /*
3968 * Hold the specified module. This is the module holding primitive.
3969 *
3970 * If MOD_LOCK_HELD then the caller already holds the mod_lock.
3971 *
3972 * Return values:
3973 * 0 ==> the module is held
3974 * 1 ==> the module is not held and the MOD_WAIT_ONCE caller needs
3975 * to determine how to retry.
3976 */
3977 int
3978 mod_hold_by_modctl(struct modctl *mp, int f)
3979 {
3980 ASSERT((f & (MOD_WAIT_ONCE | MOD_WAIT_FOREVER)) &&
3981 ((f & (MOD_WAIT_ONCE | MOD_WAIT_FOREVER)) !=
3982 (MOD_WAIT_ONCE | MOD_WAIT_FOREVER)));
3983 ASSERT((f & (MOD_LOCK_HELD | MOD_LOCK_NOT_HELD)) &&
3984 ((f & (MOD_LOCK_HELD | MOD_LOCK_NOT_HELD)) !=
3985 (MOD_LOCK_HELD | MOD_LOCK_NOT_HELD)));
3986 ASSERT((f & MOD_LOCK_NOT_HELD) || MUTEX_HELD(&mod_lock));
3987
3988 if (f & MOD_LOCK_NOT_HELD)
3989 mutex_enter(&mod_lock);
3990
3991 while (mp->mod_busy) {
3992 mp->mod_want = 1;
3993 cv_wait(&mod_cv, &mod_lock);
3994 /*
3995 * Module may be unloaded by daemon.
3996 * Nevertheless, modctl structure is still in linked list
3997 * (i.e., off &modules), not freed!
3998 * Caller is not supposed to assume "mp" is valid, but there
3999 * is no reasonable way to detect this but using
4000 * mp->mod_modinfo->mp == NULL check (follow the back pointer)
4001 * (or similar check depending on calling context)
4002 * DON'T free modctl structure, it will be very very
4003 * problematic.
4004 */
4005 if (f & MOD_WAIT_ONCE) {
4006 if (f & MOD_LOCK_NOT_HELD)
4007 mutex_exit(&mod_lock);
4008 return (1); /* caller decides how to retry */
4009 }
4010 }
4011
4012 mp->mod_busy = 1;
4013 mp->mod_inprogress_thread =
4014 (curthread == NULL ? (kthread_id_t)-1 : curthread);
4015
4016 if (f & MOD_LOCK_NOT_HELD)
4017 mutex_exit(&mod_lock);
4018 return (0);
4019 }
4020
4021 static struct modctl *
4022 mod_hold_by_name_common(struct modctl *dep, const char *filename)
4023 {
4024 const char *modname;
4025 struct modctl *mp;
4026 char *curname, *newname;
4027 int found = 0;
4028
4029 mutex_enter(&mod_lock);
4030
4031 if ((modname = strrchr(filename, '/')) == NULL)
4032 modname = filename;
4033 else
4034 modname++;
4035
4036 mp = &modules;
4037 do {
4038 if (strcmp(modname, mp->mod_modname) == 0) {
4039 found = 1;
4040 break;
4041 }
4042 } while ((mp = mp->mod_next) != &modules);
4043
4044 if (found == 0) {
4045 mp = allocate_modp(filename, modname);
4046 modadd(mp);
4047 }
4048
4049 /*
4050 * if dep is not NULL, set the mp in mod_requisite_loading for
4051 * the module circular dependency check. This field is used in
4052 * mod_circdep(), but it's cleard in mod_hold_loaded_mod().
4053 */
4054 if (dep != NULL) {
4055 ASSERT(dep->mod_busy && dep->mod_requisite_loading == NULL);
4056 dep->mod_requisite_loading = mp;
4057 }
4058
4059 /*
4060 * If the module was held, then it must be us who has it held.
4061 */
4062 if (mod_circdep(mp))
4063 mp = NULL;
4064 else {
4065 (void) mod_hold_by_modctl(mp, MOD_WAIT_FOREVER | MOD_LOCK_HELD);
4066
4067 /*
4068 * If the name hadn't been set or has changed, allocate
4069 * space and set it. Free space used by previous name.
4070 *
4071 * Do not change the name of primary modules, for primary
4072 * modules the mod_filename was allocated in standalone mode:
4073 * it is illegal to kobj_alloc in standalone mode and kobj_free
4074 * in non-standalone mode.
4075 */
4076 curname = mp->mod_filename;
4077 if (curname == NULL ||
4078 ((mp->mod_prim == 0) &&
4079 (curname != filename) &&
4080 (modname != filename) &&
4081 (strcmp(curname, filename) != 0))) {
4082 newname = kobj_zalloc(strlen(filename) + 1, KM_SLEEP);
4083 (void) strcpy(newname, filename);
4084 mp->mod_filename = newname;
4085 if (curname != NULL)
4086 kobj_free(curname, strlen(curname) + 1);
4087 }
4088 }
4089
4090 mutex_exit(&mod_lock);
4091 if (mp && moddebug & MODDEBUG_LOADMSG2)
4092 printf("Holding %s\n", mp->mod_filename);
4093 if (mp == NULL && moddebug & MODDEBUG_LOADMSG2)
4094 printf("circular dependency loading %s\n", filename);
4095 return (mp);
4096 }
4097
4098 static struct modctl *
4099 mod_hold_by_name_requisite(struct modctl *dep, char *filename)
4100 {
4101 return (mod_hold_by_name_common(dep, filename));
4102 }
4103
4104 struct modctl *
4105 mod_hold_by_name(const char *filename)
4106 {
4107 return (mod_hold_by_name_common(NULL, filename));
4108 }
4109
4110 struct modctl *
4111 mod_hold_by_id(modid_t modid)
4112 {
4113 struct modctl *mp;
4114 int found = 0;
4115
4116 mutex_enter(&mod_lock);
4117 mp = &modules;
4118 do {
4119 if (mp->mod_id == modid) {
4120 found = 1;
4121 break;
4122 }
4123 } while ((mp = mp->mod_next) != &modules);
4124
4125 if ((found == 0) || mod_circdep(mp))
4126 mp = NULL;
4127 else
4128 (void) mod_hold_by_modctl(mp, MOD_WAIT_FOREVER | MOD_LOCK_HELD);
4129
4130 mutex_exit(&mod_lock);
4131 return (mp);
4132 }
4133
4134 static struct modctl *
4135 mod_hold_next_by_id(modid_t modid)
4136 {
4137 struct modctl *mp;
4138 int found = 0;
4139
4140 if (modid < -1)
4141 return (NULL);
4142
4143 mutex_enter(&mod_lock);
4144
4145 mp = &modules;
4146 do {
4147 if (mp->mod_id > modid) {
4148 found = 1;
4149 break;
4150 }
4151 } while ((mp = mp->mod_next) != &modules);
4152
4153 if ((found == 0) || mod_circdep(mp))
4154 mp = NULL;
4155 else
4156 (void) mod_hold_by_modctl(mp, MOD_WAIT_FOREVER | MOD_LOCK_HELD);
4157
4158 mutex_exit(&mod_lock);
4159 return (mp);
4160 }
4161
4162 static void
4163 mod_release(struct modctl *mp)
4164 {
4165 ASSERT(MUTEX_HELD(&mod_lock));
4166 ASSERT(mp->mod_busy);
4167
4168 mp->mod_busy = 0;
4169 mp->mod_inprogress_thread = NULL;
4170 if (mp->mod_want) {
4171 mp->mod_want = 0;
4172 cv_broadcast(&mod_cv);
4173 }
4174 }
4175
4176 void
4177 mod_release_mod(struct modctl *mp)
4178 {
4179 if (moddebug & MODDEBUG_LOADMSG2)
4180 printf("Releasing %s\n", mp->mod_filename);
4181 mutex_enter(&mod_lock);
4182 mod_release(mp);
4183 mutex_exit(&mod_lock);
4184 }
4185
4186 modid_t
4187 mod_name_to_modid(char *filename)
4188 {
4189 char *modname;
4190 struct modctl *mp;
4191
4192 mutex_enter(&mod_lock);
4193
4194 if ((modname = strrchr(filename, '/')) == NULL)
4195 modname = filename;
4196 else
4197 modname++;
4198
4199 mp = &modules;
4200 do {
4201 if (strcmp(modname, mp->mod_modname) == 0) {
4202 mutex_exit(&mod_lock);
4203 return (mp->mod_id);
4204 }
4205 } while ((mp = mp->mod_next) != &modules);
4206
4207 mutex_exit(&mod_lock);
4208 return (-1);
4209 }
4210
4211
4212 int
4213 mod_remove_by_name(char *name)
4214 {
4215 struct modctl *mp;
4216 int retval;
4217
4218 mp = mod_hold_by_name(name);
4219
4220 if (mp == NULL)
4221 return (EINVAL);
4222
4223 if (mp->mod_loadflags & MOD_NOAUTOUNLOAD) {
4224 /*
4225 * Do not unload forceloaded modules
4226 */
4227 mod_release_mod(mp);
4228 return (0);
4229 }
4230
4231 if ((retval = moduninstall(mp)) == 0) {
4232 mod_unload(mp);
4233 CPU_STATS_ADDQ(CPU, sys, modunload, 1);
4234 } else if (retval == EALREADY)
4235 retval = 0; /* already unloaded, not an error */
4236 mod_release_mod(mp);
4237 return (retval);
4238 }
4239
4240 /*
4241 * Record that module "dep" is dependent on module "on_mod."
4242 */
4243 static void
4244 mod_make_requisite(struct modctl *dependent, struct modctl *on_mod)
4245 {
4246 struct modctl_list **pmlnp; /* previous next pointer */
4247 struct modctl_list *mlp;
4248 struct modctl_list *new;
4249
4250 ASSERT(dependent->mod_busy && on_mod->mod_busy);
4251 mutex_enter(&mod_lock);
4252
4253 /*
4254 * Search dependent's requisite list to see if on_mod is recorded.
4255 * List is ordered by id.
4256 */
4257 for (pmlnp = &dependent->mod_requisites, mlp = *pmlnp;
4258 mlp; pmlnp = &mlp->modl_next, mlp = *pmlnp)
4259 if (mlp->modl_modp->mod_id >= on_mod->mod_id)
4260 break;
4261
4262 /* Create and insert if not already recorded */
4263 if ((mlp == NULL) || (mlp->modl_modp->mod_id != on_mod->mod_id)) {
4264 new = kobj_zalloc(sizeof (*new), KM_SLEEP);
4265 new->modl_modp = on_mod;
4266 new->modl_next = mlp;
4267 *pmlnp = new;
4268
4269 /*
4270 * Increment the mod_ref count in our new requisite module.
4271 * This is what keeps a module that has other modules
4272 * which are dependent on it from being uninstalled and
4273 * unloaded. "on_mod"'s mod_ref count decremented in
4274 * mod_release_requisites when the "dependent" module
4275 * unload is complete. "on_mod" must be loaded, but may not
4276 * yet be installed.
4277 */
4278 on_mod->mod_ref++;
4279 ASSERT(on_mod->mod_ref && on_mod->mod_loaded);
4280 }
4281
4282 mutex_exit(&mod_lock);
4283 }
4284
4285 /*
4286 * release the hold associated with mod_make_requisite mod_ref++
4287 * as part of unload.
4288 */
4289 void
4290 mod_release_requisites(struct modctl *modp)
4291 {
4292 struct modctl_list *modl;
4293 struct modctl_list *next;
4294 struct modctl *req;
4295 struct modctl_list *start = NULL, *mod_garbage;
4296
4297 ASSERT(!quiesce_active);
4298 ASSERT(modp->mod_busy);
4299 ASSERT(MUTEX_NOT_HELD(&mod_lock));
4300
4301 mutex_enter(&mod_lock); /* needed for manipulation of req */
4302 for (modl = modp->mod_requisites; modl; modl = next) {
4303 next = modl->modl_next;
4304 req = modl->modl_modp;
4305 ASSERT(req->mod_ref >= 1 && req->mod_loaded);
4306 req->mod_ref--;
4307 if (req->mod_ref == 0)
4308 mod_uninstall_ref_zero++;
4309
4310 /*
4311 * Check if the module has to be unloaded or not.
4312 */
4313 if (req->mod_ref == 0 && req->mod_delay_unload) {
4314 struct modctl_list *new;
4315 /*
4316 * Allocate the modclt_list holding the garbage
4317 * module which should be unloaded later.
4318 */
4319 new = kobj_zalloc(sizeof (struct modctl_list),
4320 KM_SLEEP);
4321 new->modl_modp = req;
4322
4323 if (start == NULL)
4324 mod_garbage = start = new;
4325 else {
4326 mod_garbage->modl_next = new;
4327 mod_garbage = new;
4328 }
4329 }
4330
4331 /* free the list as we go */
4332 kobj_free(modl, sizeof (*modl));
4333 }
4334 modp->mod_requisites = NULL;
4335 mutex_exit(&mod_lock);
4336
4337 /*
4338 * Unload the garbage modules.
4339 */
4340 for (mod_garbage = start; mod_garbage != NULL; /* nothing */) {
4341 struct modctl_list *old = mod_garbage;
4342 struct modctl *mp = mod_garbage->modl_modp;
4343 ASSERT(mp != NULL);
4344
4345 /*
4346 * Hold this module until it's unloaded completely.
4347 */
4348 (void) mod_hold_by_modctl(mp,
4349 MOD_WAIT_FOREVER | MOD_LOCK_NOT_HELD);
4350 /*
4351 * Check if the module is not unloaded yet and nobody requires
4352 * the module. If it's unloaded already or somebody still
4353 * requires the module, don't unload it now.
4354 */
4355 if (mp->mod_loaded && mp->mod_ref == 0)
4356 mod_unload(mp);
4357 ASSERT((mp->mod_loaded == 0 && mp->mod_delay_unload == 0) ||
4358 (mp->mod_ref > 0));
4359 mod_release_mod(mp);
4360
4361 mod_garbage = mod_garbage->modl_next;
4362 kobj_free(old, sizeof (struct modctl_list));
4363 }
4364 }
4365
4366 /*
4367 * Process dependency of the module represented by "dep" on the
4368 * module named by "on."
4369 *
4370 * Called from kobj_do_dependents() to load a module "on" on which
4371 * "dep" depends.
4372 */
4373 struct modctl *
4374 mod_load_requisite(struct modctl *dep, char *on)
4375 {
4376 struct modctl *on_mod;
4377 int retval;
4378
4379 if ((on_mod = mod_hold_loaded_mod(dep, on, &retval)) != NULL) {
4380 mod_make_requisite(dep, on_mod);
4381 } else if (moddebug & MODDEBUG_ERRMSG) {
4382 printf("error processing %s on which module %s depends\n",
4383 on, dep->mod_modname);
4384 }
4385 return (on_mod);
4386 }
4387
4388 static int
4389 mod_install_requisites(struct modctl *modp)
4390 {
4391 struct modctl_list *modl;
4392 struct modctl *req;
4393 int status = 0;
4394
4395 ASSERT(MUTEX_NOT_HELD(&mod_lock));
4396 ASSERT(modp->mod_busy);
4397
4398 for (modl = modp->mod_requisites; modl; modl = modl->modl_next) {
4399 req = modl->modl_modp;
4400 (void) mod_hold_by_modctl(req,
4401 MOD_WAIT_FOREVER | MOD_LOCK_NOT_HELD);
4402 status = modinstall(req);
4403 mod_release_mod(req);
4404
4405 if (status != 0)
4406 break;
4407 }
4408 return (status);
4409 }
4410
4411 /*
4412 * returns 1 if this thread is doing autounload, 0 otherwise.
4413 * see mod_uninstall_all.
4414 */
4415 int
4416 mod_in_autounload()
4417 {
4418 return ((int)(uintptr_t)tsd_get(mod_autounload_key));
4419 }
4420
4421 /*
4422 * gmatch adapted from libc, stripping the wchar stuff
4423 */
4424 #define popchar(p, c) { \
4425 c = *p++; \
4426 if (c == 0) { \
4427 return (0); \
4428 } \
4429 }
4430
4431 int
4432 gmatch(const char *s, const char *p)
4433 {
4434 int c, sc;
4435 int ok, lc, notflag;
4436
4437 sc = *s++;
4438 c = *p++;
4439 if (c == 0)
4440 return (sc == c); /* nothing matches nothing */
4441
4442 switch (c) {
4443 case '\\':
4444 /* skip to quoted character */
4445 popchar(p, c);
4446 /*FALLTHRU*/
4447
4448 default:
4449 /* straight comparison */
4450 if (c != sc)
4451 return (0);
4452 /*FALLTHRU*/
4453
4454 case '?':
4455 /* first char matches, move to remainder */
4456 return (sc != '\0' ? gmatch(s, p) : 0);
4457
4458
4459 case '*':
4460 while (*p == '*')
4461 p++;
4462
4463 /* * matches everything */
4464 if (*p == 0)
4465 return (1);
4466
4467 /* undo skip at the beginning & iterate over substrings */
4468 --s;
4469 while (*s) {
4470 if (gmatch(s, p))
4471 return (1);
4472 s++;
4473 }
4474 return (0);
4475
4476 case '[':
4477 /* match any char within [] */
4478 if (sc == 0)
4479 return (0);
4480
4481 ok = lc = notflag = 0;
4482
4483 if (*p == '!') {
4484 notflag = 1;
4485 p++;
4486 }
4487 popchar(p, c);
4488
4489 do {
4490 if (c == '-' && lc && *p != ']') {
4491 /* test sc against range [c1-c2] */
4492 popchar(p, c);
4493 if (c == '\\') {
4494 popchar(p, c);
4495 }
4496
4497 if (notflag) {
4498 /* return 0 on mismatch */
4499 if (lc <= sc && sc <= c)
4500 return (0);
4501 ok++;
4502 } else if (lc <= sc && sc <= c) {
4503 ok++;
4504 }
4505 /* keep going, may get a match next */
4506 } else if (c == '\\') {
4507 /* skip to quoted character */
4508 popchar(p, c);
4509 }
4510 lc = c;
4511 if (notflag) {
4512 if (sc == lc)
4513 return (0);
4514 ok++;
4515 } else if (sc == lc) {
4516 ok++;
4517 }
4518 popchar(p, c);
4519 } while (c != ']');
4520
4521 /* recurse on remainder of string */
4522 return (ok ? gmatch(s, p) : 0);
4523 }
4524 /*NOTREACHED*/
4525 }
4526
4527
4528 /*
4529 * Get default perm for device from /etc/minor_perm. Return 0 if match found.
4530 *
4531 * Pure wild-carded patterns are handled separately so the ordering of
4532 * these patterns doesn't matter. We're still dependent on ordering
4533 * however as the first matching entry is the one returned.
4534 * Not ideal but all existing examples and usage do imply this
4535 * ordering implicitly.
4536 *
4537 * Drivers using the clone driver are always good for some entertainment.
4538 * Clone nodes under pseudo have the form clone@0:<driver>. Some minor
4539 * perm entries have the form clone:<driver>, others use <driver>:*
4540 * Examples are clone:llc1 vs. llc2:*, for example.
4541 *
4542 * Minor perms in the clone:<driver> form are mapped to the drivers's
4543 * mperm list, not the clone driver, as wildcard entries for clone
4544 * reference only. In other words, a clone wildcard will match
4545 * references for clone@0:<driver> but never <driver>@<minor>.
4546 *
4547 * Additional minor perms in the standard form are also supported,
4548 * for mixed usage, ie a node with an entry clone:<driver> could
4549 * provide further entries <driver>:<minor>.
4550 *
4551 * Finally, some uses of clone use an alias as the minor name rather
4552 * than the driver name, with the alias as the minor perm entry.
4553 * This case is handled by attaching the driver to bring its
4554 * minor list into existence, then discover the alias via DDI_ALIAS.
4555 * The clone device's minor perm list can then be searched for
4556 * that alias.
4557 */
4558
4559 static int
4560 dev_alias_minorperm(dev_info_t *dip, char *minor_name, mperm_t *rmp)
4561 {
4562 major_t major;
4563 struct devnames *dnp;
4564 mperm_t *mp;
4565 char *alias = NULL;
4566 dev_info_t *cdevi;
4567 int circ;
4568 struct ddi_minor_data *dmd;
4569
4570 major = ddi_name_to_major(minor_name);
4571
4572 ASSERT(dip == clone_dip);
4573 ASSERT(major != DDI_MAJOR_T_NONE);
4574
4575 /*
4576 * Attach the driver named by the minor node, then
4577 * search its first instance's minor list for an
4578 * alias node.
4579 */
4580 if (ddi_hold_installed_driver(major) == NULL)
4581 return (1);
4582
4583 dnp = &devnamesp[major];
4584 LOCK_DEV_OPS(&dnp->dn_lock);
4585
4586 if ((cdevi = dnp->dn_head) != NULL) {
4587 ndi_devi_enter(cdevi, &circ);
4588 for (dmd = DEVI(cdevi)->devi_minor; dmd; dmd = dmd->next) {
4589 if (dmd->type == DDM_ALIAS) {
4590 alias = i_ddi_strdup(dmd->ddm_name, KM_SLEEP);
4591 break;
4592 }
4593 }
4594 ndi_devi_exit(cdevi, circ);
4595 }
4596
4597 UNLOCK_DEV_OPS(&dnp->dn_lock);
4598 ddi_rele_driver(major);
4599
4600 if (alias == NULL) {
4601 if (moddebug & MODDEBUG_MINORPERM)
4602 cmn_err(CE_CONT, "dev_minorperm: "
4603 "no alias for %s\n", minor_name);
4604 return (1);
4605 }
4606
4607 major = ddi_driver_major(clone_dip);
4608 dnp = &devnamesp[major];
4609 LOCK_DEV_OPS(&dnp->dn_lock);
4610
4611 /*
4612 * Go through the clone driver's mperm list looking
4613 * for a match for the specified alias.
4614 */
4615 for (mp = dnp->dn_mperm; mp; mp = mp->mp_next) {
4616 if (strcmp(alias, mp->mp_minorname) == 0) {
4617 break;
4618 }
4619 }
4620
4621 if (mp) {
4622 if (moddebug & MODDEBUG_MP_MATCH) {
4623 cmn_err(CE_CONT,
4624 "minor perm defaults: %s %s 0%o %d %d (aliased)\n",
4625 minor_name, alias, mp->mp_mode,
4626 mp->mp_uid, mp->mp_gid);
4627 }
4628 rmp->mp_uid = mp->mp_uid;
4629 rmp->mp_gid = mp->mp_gid;
4630 rmp->mp_mode = mp->mp_mode;
4631 }
4632 UNLOCK_DEV_OPS(&dnp->dn_lock);
4633
4634 kmem_free(alias, strlen(alias)+1);
4635
4636 return (mp == NULL);
4637 }
4638
4639 int
4640 dev_minorperm(dev_info_t *dip, char *name, mperm_t *rmp)
4641 {
4642 major_t major;
4643 char *minor_name;
4644 struct devnames *dnp;
4645 mperm_t *mp;
4646 int is_clone = 0;
4647
4648 if (!minorperm_loaded) {
4649 if (moddebug & MODDEBUG_MINORPERM)
4650 cmn_err(CE_CONT,
4651 "%s: minor perm not yet loaded\n", name);
4652 return (1);
4653 }
4654
4655 minor_name = strchr(name, ':');
4656 if (minor_name == NULL)
4657 return (1);
4658 minor_name++;
4659
4660 /*
4661 * If it's the clone driver, search the driver as named
4662 * by the minor. All clone minor perm entries other than
4663 * alias nodes are actually installed on the real driver's list.
4664 */
4665 if (dip == clone_dip) {
4666 major = ddi_name_to_major(minor_name);
4667 if (major == DDI_MAJOR_T_NONE) {
4668 if (moddebug & MODDEBUG_MINORPERM)
4669 cmn_err(CE_CONT, "dev_minorperm: "
4670 "%s: no such driver\n", minor_name);
4671 return (1);
4672 }
4673 is_clone = 1;
4674 } else {
4675 major = ddi_driver_major(dip);
4676 ASSERT(major != DDI_MAJOR_T_NONE);
4677 }
4678
4679 dnp = &devnamesp[major];
4680 LOCK_DEV_OPS(&dnp->dn_lock);
4681
4682 /*
4683 * Go through the driver's mperm list looking for
4684 * a match for the specified minor. If there's
4685 * no matching pattern, use the wild card.
4686 * Defer to the clone wild for clone if specified,
4687 * otherwise fall back to the normal form.
4688 */
4689 for (mp = dnp->dn_mperm; mp; mp = mp->mp_next) {
4690 if (gmatch(minor_name, mp->mp_minorname) != 0) {
4691 break;
4692 }
4693 }
4694 if (mp == NULL) {
4695 if (is_clone)
4696 mp = dnp->dn_mperm_clone;
4697 if (mp == NULL)
4698 mp = dnp->dn_mperm_wild;
4699 }
4700
4701 if (mp) {
4702 if (moddebug & MODDEBUG_MP_MATCH) {
4703 cmn_err(CE_CONT,
4704 "minor perm defaults: %s %s 0%o %d %d\n",
4705 name, mp->mp_minorname, mp->mp_mode,
4706 mp->mp_uid, mp->mp_gid);
4707 }
4708 rmp->mp_uid = mp->mp_uid;
4709 rmp->mp_gid = mp->mp_gid;
4710 rmp->mp_mode = mp->mp_mode;
4711 }
4712 UNLOCK_DEV_OPS(&dnp->dn_lock);
4713
4714 /*
4715 * If no match can be found for a clone node,
4716 * search for a possible match for an alias.
4717 * One such example is /dev/ptmx -> /devices/pseudo/clone@0:ptm,
4718 * with minor perm entry clone:ptmx.
4719 */
4720 if (mp == NULL && is_clone) {
4721 return (dev_alias_minorperm(dip, minor_name, rmp));
4722 }
4723
4724 return (mp == NULL);
4725 }
4726
4727 /*
4728 * dynamicaly reference load a dl module/library, returning handle
4729 */
4730 /*ARGSUSED*/
4731 ddi_modhandle_t
4732 ddi_modopen(const char *modname, int mode, int *errnop)
4733 {
4734 char *subdir;
4735 char *mod;
4736 int subdirlen;
4737 struct modctl *hmodp = NULL;
4738 int retval = EINVAL;
4739
4740 ASSERT(modname && (mode == KRTLD_MODE_FIRST));
4741 if ((modname == NULL) || (mode != KRTLD_MODE_FIRST))
4742 goto out;
4743
4744 /* find last '/' in modname */
4745 mod = strrchr(modname, '/');
4746
4747 if (mod) {
4748 /* for subdir string without modification to argument */
4749 mod++;
4750 subdirlen = mod - modname;
4751 subdir = kmem_alloc(subdirlen, KM_SLEEP);
4752 (void) strlcpy(subdir, modname, subdirlen);
4753 } else {
4754 subdirlen = 0;
4755 subdir = "misc";
4756 mod = (char *)modname;
4757 }
4758
4759 /* reference load with errno return value */
4760 retval = modrload(subdir, mod, &hmodp);
4761
4762 if (subdirlen)
4763 kmem_free(subdir, subdirlen);
4764
4765 out: if (errnop)
4766 *errnop = retval;
4767
4768 if (moddebug & MODDEBUG_DDI_MOD)
4769 printf("ddi_modopen %s mode %x: %s %p %d\n",
4770 modname ? modname : "<unknown>", mode,
4771 hmodp ? hmodp->mod_filename : "<unknown>",
4772 (void *)hmodp, retval);
4773
4774 return ((ddi_modhandle_t)hmodp);
4775 }
4776
4777 /* lookup "name" in open dl module/library */
4778 void *
4779 ddi_modsym(ddi_modhandle_t h, const char *name, int *errnop)
4780 {
4781 struct modctl *hmodp = (struct modctl *)h;
4782 void *f;
4783 int retval;
4784
4785 ASSERT(hmodp && name && hmodp->mod_installed && (hmodp->mod_ref >= 1));
4786 if ((hmodp == NULL) || (name == NULL) ||
4787 (hmodp->mod_installed == 0) || (hmodp->mod_ref < 1)) {
4788 f = NULL;
4789 retval = EINVAL;
4790 } else {
4791 f = (void *)kobj_lookup(hmodp->mod_mp, (char *)name);
4792 if (f)
4793 retval = 0;
4794 else
4795 retval = ENOTSUP;
4796 }
4797
4798 if (moddebug & MODDEBUG_DDI_MOD)
4799 printf("ddi_modsym in %s of %s: %d %p\n",
4800 hmodp ? hmodp->mod_modname : "<unknown>",
4801 name ? name : "<unknown>", retval, f);
4802
4803 if (errnop)
4804 *errnop = retval;
4805 return (f);
4806 }
4807
4808 /* dynamic (un)reference unload of an open dl module/library */
4809 int
4810 ddi_modclose(ddi_modhandle_t h)
4811 {
4812 struct modctl *hmodp = (struct modctl *)h;
4813 struct modctl *modp = NULL;
4814 int retval;
4815
4816 ASSERT(hmodp && hmodp->mod_installed && (hmodp->mod_ref >= 1));
4817 if ((hmodp == NULL) ||
4818 (hmodp->mod_installed == 0) || (hmodp->mod_ref < 1)) {
4819 retval = EINVAL;
4820 goto out;
4821 }
4822
4823 retval = modunrload(hmodp->mod_id, &modp, ddi_modclose_unload);
4824 if (retval == EBUSY)
4825 retval = 0; /* EBUSY is not an error */
4826
4827 if (retval == 0) {
4828 ASSERT(hmodp == modp);
4829 if (hmodp != modp)
4830 retval = EINVAL;
4831 }
4832
4833 out: if (moddebug & MODDEBUG_DDI_MOD)
4834 printf("ddi_modclose %s: %d\n",
4835 hmodp ? hmodp->mod_modname : "<unknown>", retval);
4836
4837 return (retval);
4838 }