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