1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 /* 25 * Copyright 2019 Joyent, Inc. 26 */ 27 28 /* 29 * Layered driver support. 30 */ 31 32 #include <sys/atomic.h> 33 #include <sys/types.h> 34 #include <sys/t_lock.h> 35 #include <sys/param.h> 36 #include <sys/conf.h> 37 #include <sys/systm.h> 38 #include <sys/sysmacros.h> 39 #include <sys/buf.h> 40 #include <sys/cred.h> 41 #include <sys/uio.h> 42 #include <sys/vnode.h> 43 #include <sys/fs/snode.h> 44 #include <sys/open.h> 45 #include <sys/kmem.h> 46 #include <sys/file.h> 47 #include <sys/bootconf.h> 48 #include <sys/pathname.h> 49 #include <sys/bitmap.h> 50 #include <sys/stat.h> 51 #include <sys/dditypes.h> 52 #include <sys/ddi_impldefs.h> 53 #include <sys/ddi.h> 54 #include <sys/sunddi.h> 55 #include <sys/sunndi.h> 56 #include <sys/esunddi.h> 57 #include <sys/autoconf.h> 58 #include <sys/sunldi.h> 59 #include <sys/sunldi_impl.h> 60 #include <sys/errno.h> 61 #include <sys/debug.h> 62 #include <sys/modctl.h> 63 #include <sys/var.h> 64 #include <vm/seg_vn.h> 65 66 #include <sys/stropts.h> 67 #include <sys/strsubr.h> 68 #include <sys/socket.h> 69 #include <sys/socketvar.h> 70 #include <sys/kstr.h> 71 72 /* 73 * Device contract related 74 */ 75 #include <sys/contract_impl.h> 76 #include <sys/contract/device_impl.h> 77 78 /* 79 * Define macros to manipulate snode, vnode, and open device flags 80 */ 81 #define VTYP_VALID(i) (((i) == VCHR) || ((i) == VBLK)) 82 #define VTYP_TO_OTYP(i) (((i) == VCHR) ? OTYP_CHR : OTYP_BLK) 83 #define VTYP_TO_STYP(i) (((i) == VCHR) ? S_IFCHR : S_IFBLK) 84 85 #define OTYP_VALID(i) (((i) == OTYP_CHR) || ((i) == OTYP_BLK)) 86 #define OTYP_TO_VTYP(i) (((i) == OTYP_CHR) ? VCHR : VBLK) 87 #define OTYP_TO_STYP(i) (((i) == OTYP_CHR) ? S_IFCHR : S_IFBLK) 88 89 #define STYP_VALID(i) (((i) == S_IFCHR) || ((i) == S_IFBLK)) 90 #define STYP_TO_VTYP(i) (((i) == S_IFCHR) ? VCHR : VBLK) 91 92 /* 93 * Define macros for accessing layered driver hash structures 94 */ 95 #define LH_HASH(vp) (handle_hash_func(vp) % LH_HASH_SZ) 96 #define LI_HASH(mid, dip, dev) (ident_hash_func(mid, dip, dev) % LI_HASH_SZ) 97 98 /* 99 * Define layered handle flags used in the lh_type field 100 */ 101 #define LH_STREAM (0x1) /* handle to a streams device */ 102 #define LH_CBDEV (0x2) /* handle to a char/block device */ 103 104 /* 105 * Define macro for devid property lookups 106 */ 107 #define DEVID_PROP_FLAGS (DDI_PROP_DONTPASS | \ 108 DDI_PROP_TYPE_STRING|DDI_PROP_CANSLEEP) 109 110 /* 111 * Dummy string for NDI events 112 */ 113 #define NDI_EVENT_SERVICE "NDI_EVENT_SERVICE" 114 115 static void ldi_ev_lock(void); 116 static void ldi_ev_unlock(void); 117 118 #ifdef LDI_OBSOLETE_EVENT 119 int ldi_remove_event_handler(ldi_handle_t lh, ldi_callback_id_t id); 120 #endif 121 122 123 /* 124 * globals 125 */ 126 static kmutex_t ldi_ident_hash_lock[LI_HASH_SZ]; 127 static struct ldi_ident *ldi_ident_hash[LI_HASH_SZ]; 128 129 static kmutex_t ldi_handle_hash_lock[LH_HASH_SZ]; 130 static struct ldi_handle *ldi_handle_hash[LH_HASH_SZ]; 131 static size_t ldi_handle_hash_count; 132 133 /* 134 * Use of "ldi_ev_callback_list" must be protected by ldi_ev_lock() 135 * and ldi_ev_unlock(). 136 */ 137 static struct ldi_ev_callback_list ldi_ev_callback_list; 138 139 static uint32_t ldi_ev_id_pool = 0; 140 141 struct ldi_ev_cookie { 142 char *ck_evname; 143 uint_t ck_sync; 144 uint_t ck_ctype; 145 }; 146 147 static struct ldi_ev_cookie ldi_ev_cookies[] = { 148 { LDI_EV_OFFLINE, 1, CT_DEV_EV_OFFLINE}, 149 { LDI_EV_DEGRADE, 0, CT_DEV_EV_DEGRADED}, 150 { LDI_EV_DEVICE_REMOVE, 0, 0}, 151 { NULL} /* must terminate list */ 152 }; 153 154 void 155 ldi_init(void) 156 { 157 int i; 158 159 ldi_handle_hash_count = 0; 160 for (i = 0; i < LH_HASH_SZ; i++) { 161 mutex_init(&ldi_handle_hash_lock[i], NULL, MUTEX_DEFAULT, NULL); 162 ldi_handle_hash[i] = NULL; 163 } 164 for (i = 0; i < LI_HASH_SZ; i++) { 165 mutex_init(&ldi_ident_hash_lock[i], NULL, MUTEX_DEFAULT, NULL); 166 ldi_ident_hash[i] = NULL; 167 } 168 169 /* 170 * Initialize the LDI event subsystem 171 */ 172 mutex_init(&ldi_ev_callback_list.le_lock, NULL, MUTEX_DEFAULT, NULL); 173 cv_init(&ldi_ev_callback_list.le_cv, NULL, CV_DEFAULT, NULL); 174 ldi_ev_callback_list.le_busy = 0; 175 ldi_ev_callback_list.le_thread = NULL; 176 ldi_ev_callback_list.le_walker_next = NULL; 177 ldi_ev_callback_list.le_walker_prev = NULL; 178 list_create(&ldi_ev_callback_list.le_head, 179 sizeof (ldi_ev_callback_impl_t), 180 offsetof(ldi_ev_callback_impl_t, lec_list)); 181 } 182 183 /* 184 * LDI ident manipulation functions 185 */ 186 static uint_t 187 ident_hash_func(modid_t modid, dev_info_t *dip, dev_t dev) 188 { 189 if (dip != NULL) { 190 uintptr_t k = (uintptr_t)dip; 191 k >>= (int)highbit(sizeof (struct dev_info)); 192 return ((uint_t)k); 193 } else if (dev != DDI_DEV_T_NONE) { 194 return (modid + getminor(dev) + getmajor(dev)); 195 } else { 196 return (modid); 197 } 198 } 199 200 static struct ldi_ident ** 201 ident_find_ref_nolock(modid_t modid, dev_info_t *dip, dev_t dev, major_t major) 202 { 203 struct ldi_ident **lipp = NULL; 204 uint_t index = LI_HASH(modid, dip, dev); 205 206 ASSERT(MUTEX_HELD(&ldi_ident_hash_lock[index])); 207 208 for (lipp = &(ldi_ident_hash[index]); 209 (*lipp != NULL); 210 lipp = &((*lipp)->li_next)) { 211 if (((*lipp)->li_modid == modid) && 212 ((*lipp)->li_major == major) && 213 ((*lipp)->li_dip == dip) && 214 ((*lipp)->li_dev == dev)) 215 break; 216 } 217 218 ASSERT(lipp != NULL); 219 return (lipp); 220 } 221 222 static struct ldi_ident * 223 ident_alloc(char *mod_name, dev_info_t *dip, dev_t dev, major_t major) 224 { 225 struct ldi_ident *lip, **lipp, *retlip; 226 modid_t modid; 227 uint_t index; 228 229 ASSERT(mod_name != NULL); 230 231 /* get the module id */ 232 modid = mod_name_to_modid(mod_name); 233 ASSERT(modid != -1); 234 235 /* allocate a new ident in case we need it */ 236 lip = kmem_zalloc(sizeof (*lip), KM_SLEEP); 237 238 /* search the hash for a matching ident */ 239 index = LI_HASH(modid, dip, dev); 240 mutex_enter(&ldi_ident_hash_lock[index]); 241 lipp = ident_find_ref_nolock(modid, dip, dev, major); 242 243 if (*lipp != NULL) { 244 /* we found an ident in the hash */ 245 ASSERT(strcmp((*lipp)->li_modname, mod_name) == 0); 246 (*lipp)->li_ref++; 247 retlip = *lipp; 248 mutex_exit(&ldi_ident_hash_lock[index]); 249 kmem_free(lip, sizeof (struct ldi_ident)); 250 return (retlip); 251 } 252 253 /* initialize the new ident */ 254 lip->li_next = NULL; 255 lip->li_ref = 1; 256 lip->li_modid = modid; 257 lip->li_major = major; 258 lip->li_dip = dip; 259 lip->li_dev = dev; 260 (void) strncpy(lip->li_modname, mod_name, sizeof (lip->li_modname) - 1); 261 262 /* add it to the ident hash */ 263 lip->li_next = ldi_ident_hash[index]; 264 ldi_ident_hash[index] = lip; 265 266 mutex_exit(&ldi_ident_hash_lock[index]); 267 return (lip); 268 } 269 270 static void 271 ident_hold(struct ldi_ident *lip) 272 { 273 uint_t index; 274 275 ASSERT(lip != NULL); 276 index = LI_HASH(lip->li_modid, lip->li_dip, lip->li_dev); 277 mutex_enter(&ldi_ident_hash_lock[index]); 278 ASSERT(lip->li_ref > 0); 279 lip->li_ref++; 280 mutex_exit(&ldi_ident_hash_lock[index]); 281 } 282 283 static void 284 ident_release(struct ldi_ident *lip) 285 { 286 struct ldi_ident **lipp; 287 uint_t index; 288 289 ASSERT(lip != NULL); 290 index = LI_HASH(lip->li_modid, lip->li_dip, lip->li_dev); 291 mutex_enter(&ldi_ident_hash_lock[index]); 292 293 ASSERT(lip->li_ref > 0); 294 if (--lip->li_ref > 0) { 295 /* there are more references to this ident */ 296 mutex_exit(&ldi_ident_hash_lock[index]); 297 return; 298 } 299 300 /* this was the last reference/open for this ident. free it. */ 301 lipp = ident_find_ref_nolock( 302 lip->li_modid, lip->li_dip, lip->li_dev, lip->li_major); 303 304 ASSERT((lipp != NULL) && (*lipp != NULL)); 305 *lipp = lip->li_next; 306 mutex_exit(&ldi_ident_hash_lock[index]); 307 kmem_free(lip, sizeof (struct ldi_ident)); 308 } 309 310 /* 311 * LDI handle manipulation functions 312 */ 313 static uint_t 314 handle_hash_func(void *vp) 315 { 316 uintptr_t k = (uintptr_t)vp; 317 k >>= (int)highbit(sizeof (vnode_t)); 318 return ((uint_t)k); 319 } 320 321 static struct ldi_handle ** 322 handle_find_ref_nolock(vnode_t *vp, struct ldi_ident *ident) 323 { 324 struct ldi_handle **lhpp = NULL; 325 uint_t index = LH_HASH(vp); 326 327 ASSERT(MUTEX_HELD(&ldi_handle_hash_lock[index])); 328 329 for (lhpp = &(ldi_handle_hash[index]); 330 (*lhpp != NULL); 331 lhpp = &((*lhpp)->lh_next)) { 332 if (((*lhpp)->lh_ident == ident) && 333 ((*lhpp)->lh_vp == vp)) 334 break; 335 } 336 337 ASSERT(lhpp != NULL); 338 return (lhpp); 339 } 340 341 static struct ldi_handle * 342 handle_find(vnode_t *vp, struct ldi_ident *ident) 343 { 344 struct ldi_handle **lhpp, *retlhp; 345 int index = LH_HASH(vp); 346 347 mutex_enter(&ldi_handle_hash_lock[index]); 348 lhpp = handle_find_ref_nolock(vp, ident); 349 retlhp = *lhpp; 350 mutex_exit(&ldi_handle_hash_lock[index]); 351 return (retlhp); 352 } 353 354 static struct ldi_handle * 355 handle_alloc(vnode_t *vp, struct ldi_ident *ident) 356 { 357 struct ldi_handle *lhp, **lhpp, *retlhp; 358 uint_t index; 359 360 ASSERT((vp != NULL) && (ident != NULL)); 361 362 /* allocate a new handle in case we need it */ 363 lhp = kmem_zalloc(sizeof (*lhp), KM_SLEEP); 364 365 /* search the hash for a matching handle */ 366 index = LH_HASH(vp); 367 mutex_enter(&ldi_handle_hash_lock[index]); 368 lhpp = handle_find_ref_nolock(vp, ident); 369 370 if (*lhpp != NULL) { 371 /* we found a handle in the hash */ 372 (*lhpp)->lh_ref++; 373 retlhp = *lhpp; 374 mutex_exit(&ldi_handle_hash_lock[index]); 375 376 LDI_ALLOCFREE((CE_WARN, "ldi handle alloc: dup " 377 "lh=0x%p, ident=0x%p, vp=0x%p, drv=%s, minor=0x%x", 378 (void *)retlhp, (void *)ident, (void *)vp, 379 mod_major_to_name(getmajor(vp->v_rdev)), 380 getminor(vp->v_rdev))); 381 382 kmem_free(lhp, sizeof (struct ldi_handle)); 383 return (retlhp); 384 } 385 386 /* initialize the new handle */ 387 lhp->lh_ref = 1; 388 lhp->lh_vp = vp; 389 lhp->lh_ident = ident; 390 #ifdef LDI_OBSOLETE_EVENT 391 mutex_init(lhp->lh_lock, NULL, MUTEX_DEFAULT, NULL); 392 #endif 393 394 /* set the device type for this handle */ 395 lhp->lh_type = 0; 396 if (vp->v_stream) { 397 ASSERT(vp->v_type == VCHR); 398 lhp->lh_type |= LH_STREAM; 399 } else { 400 lhp->lh_type |= LH_CBDEV; 401 } 402 403 /* get holds on other objects */ 404 ident_hold(ident); 405 ASSERT(vp->v_count >= 1); 406 VN_HOLD(vp); 407 408 /* add it to the handle hash */ 409 lhp->lh_next = ldi_handle_hash[index]; 410 ldi_handle_hash[index] = lhp; 411 atomic_inc_ulong(&ldi_handle_hash_count); 412 413 LDI_ALLOCFREE((CE_WARN, "ldi handle alloc: new " 414 "lh=0x%p, ident=0x%p, vp=0x%p, drv=%s, minor=0x%x", 415 (void *)lhp, (void *)ident, (void *)vp, 416 mod_major_to_name(getmajor(vp->v_rdev)), 417 getminor(vp->v_rdev))); 418 419 mutex_exit(&ldi_handle_hash_lock[index]); 420 return (lhp); 421 } 422 423 static void 424 handle_release(struct ldi_handle *lhp) 425 { 426 struct ldi_handle **lhpp; 427 uint_t index; 428 429 ASSERT(lhp != NULL); 430 431 index = LH_HASH(lhp->lh_vp); 432 mutex_enter(&ldi_handle_hash_lock[index]); 433 434 LDI_ALLOCFREE((CE_WARN, "ldi handle release: " 435 "lh=0x%p, ident=0x%p, vp=0x%p, drv=%s, minor=0x%x", 436 (void *)lhp, (void *)lhp->lh_ident, (void *)lhp->lh_vp, 437 mod_major_to_name(getmajor(lhp->lh_vp->v_rdev)), 438 getminor(lhp->lh_vp->v_rdev))); 439 440 ASSERT(lhp->lh_ref > 0); 441 if (--lhp->lh_ref > 0) { 442 /* there are more references to this handle */ 443 mutex_exit(&ldi_handle_hash_lock[index]); 444 return; 445 } 446 447 /* this was the last reference/open for this handle. free it. */ 448 lhpp = handle_find_ref_nolock(lhp->lh_vp, lhp->lh_ident); 449 ASSERT((lhpp != NULL) && (*lhpp != NULL)); 450 *lhpp = lhp->lh_next; 451 atomic_dec_ulong(&ldi_handle_hash_count); 452 mutex_exit(&ldi_handle_hash_lock[index]); 453 454 VN_RELE(lhp->lh_vp); 455 ident_release(lhp->lh_ident); 456 #ifdef LDI_OBSOLETE_EVENT 457 mutex_destroy(lhp->lh_lock); 458 #endif 459 kmem_free(lhp, sizeof (struct ldi_handle)); 460 } 461 462 #ifdef LDI_OBSOLETE_EVENT 463 /* 464 * LDI event manipulation functions 465 */ 466 static void 467 handle_event_add(ldi_event_t *lep) 468 { 469 struct ldi_handle *lhp = lep->le_lhp; 470 471 ASSERT(lhp != NULL); 472 473 mutex_enter(lhp->lh_lock); 474 if (lhp->lh_events == NULL) { 475 lhp->lh_events = lep; 476 mutex_exit(lhp->lh_lock); 477 return; 478 } 479 480 lep->le_next = lhp->lh_events; 481 lhp->lh_events->le_prev = lep; 482 lhp->lh_events = lep; 483 mutex_exit(lhp->lh_lock); 484 } 485 486 static void 487 handle_event_remove(ldi_event_t *lep) 488 { 489 struct ldi_handle *lhp = lep->le_lhp; 490 491 ASSERT(lhp != NULL); 492 493 mutex_enter(lhp->lh_lock); 494 if (lep->le_prev) 495 lep->le_prev->le_next = lep->le_next; 496 if (lep->le_next) 497 lep->le_next->le_prev = lep->le_prev; 498 if (lhp->lh_events == lep) 499 lhp->lh_events = lep->le_next; 500 mutex_exit(lhp->lh_lock); 501 502 } 503 504 static void 505 i_ldi_callback(dev_info_t *dip, ddi_eventcookie_t event_cookie, 506 void *arg, void *bus_impldata) 507 { 508 ldi_event_t *lep = (ldi_event_t *)arg; 509 510 ASSERT(lep != NULL); 511 512 LDI_EVENTCB((CE_NOTE, "%s: dip=0x%p, " 513 "event_cookie=0x%p, ldi_eventp=0x%p", "i_ldi_callback", 514 (void *)dip, (void *)event_cookie, (void *)lep)); 515 516 lep->le_handler(lep->le_lhp, event_cookie, lep->le_arg, bus_impldata); 517 } 518 #endif 519 520 /* 521 * LDI open helper functions 522 */ 523 524 /* get a vnode to a device by dev_t and otyp */ 525 static int 526 ldi_vp_from_dev(dev_t dev, int otyp, vnode_t **vpp) 527 { 528 dev_info_t *dip; 529 vnode_t *vp; 530 531 /* sanity check required input parameters */ 532 if ((dev == DDI_DEV_T_NONE) || (!OTYP_VALID(otyp)) || (vpp == NULL)) 533 return (EINVAL); 534 535 if ((dip = e_ddi_hold_devi_by_dev(dev, 0)) == NULL) 536 return (ENODEV); 537 538 vp = makespecvp(dev, OTYP_TO_VTYP(otyp)); 539 spec_assoc_vp_with_devi(vp, dip); 540 ddi_release_devi(dip); /* from e_ddi_hold_devi_by_dev */ 541 542 *vpp = vp; 543 return (0); 544 } 545 546 /* get a vnode to a device by pathname */ 547 int 548 ldi_vp_from_name(char *path, vnode_t **vpp) 549 { 550 vnode_t *vp = NULL; 551 int ret; 552 553 /* sanity check required input parameters */ 554 if ((path == NULL) || (vpp == NULL)) 555 return (EINVAL); 556 557 if (modrootloaded) { 558 cred_t *saved_cred = curthread->t_cred; 559 560 /* we don't want lookupname to fail because of credentials */ 561 curthread->t_cred = kcred; 562 563 /* 564 * all lookups should be done in the global zone. but 565 * lookupnameat() won't actually do this if an absolute 566 * path is passed in. since the ldi interfaces require an 567 * absolute path we pass lookupnameat() a pointer to 568 * the character after the leading '/' and tell it to 569 * start searching at the current system root directory. 570 */ 571 ASSERT(*path == '/'); 572 ret = lookupnameat(path + 1, UIO_SYSSPACE, FOLLOW, NULLVPP, 573 &vp, rootdir); 574 575 /* restore this threads credentials */ 576 curthread->t_cred = saved_cred; 577 578 if (ret == 0) { 579 if (!vn_matchops(vp, spec_getvnodeops()) || 580 !VTYP_VALID(vp->v_type)) { 581 VN_RELE(vp); 582 return (ENXIO); 583 } 584 } 585 } 586 587 if (vp == NULL) { 588 dev_info_t *dip; 589 dev_t dev; 590 int spec_type; 591 592 /* 593 * Root is not mounted, the minor node is not specified, 594 * or an OBP path has been specified. 595 */ 596 597 /* 598 * Determine if path can be pruned to produce an 599 * OBP or devfs path for resolve_pathname. 600 */ 601 if (strncmp(path, "/devices/", 9) == 0) 602 path += strlen("/devices"); 603 604 /* 605 * if no minor node was specified the DEFAULT minor node 606 * will be returned. if there is no DEFAULT minor node 607 * one will be fabricated of type S_IFCHR with the minor 608 * number equal to the instance number. 609 */ 610 ret = resolve_pathname(path, &dip, &dev, &spec_type); 611 if (ret != 0) 612 return (ENODEV); 613 614 ASSERT(STYP_VALID(spec_type)); 615 vp = makespecvp(dev, STYP_TO_VTYP(spec_type)); 616 spec_assoc_vp_with_devi(vp, dip); 617 ddi_release_devi(dip); 618 } 619 620 *vpp = vp; 621 return (0); 622 } 623 624 static int 625 ldi_devid_match(ddi_devid_t devid, dev_info_t *dip, dev_t dev) 626 { 627 char *devidstr; 628 ddi_prop_t *propp; 629 630 /* convert devid as a string property */ 631 if ((devidstr = ddi_devid_str_encode(devid, NULL)) == NULL) 632 return (0); 633 634 /* 635 * Search for the devid. For speed and ease in locking this 636 * code directly uses the property implementation. See 637 * ddi_common_devid_to_devlist() for a comment as to why. 638 */ 639 mutex_enter(&(DEVI(dip)->devi_lock)); 640 641 /* check if there is a DDI_DEV_T_NONE devid property */ 642 propp = i_ddi_prop_search(DDI_DEV_T_NONE, 643 DEVID_PROP_NAME, DEVID_PROP_FLAGS, &DEVI(dip)->devi_hw_prop_ptr); 644 if (propp != NULL) { 645 if (ddi_devid_str_compare(propp->prop_val, devidstr) == 0) { 646 /* a DDI_DEV_T_NONE devid exists and matchs */ 647 mutex_exit(&(DEVI(dip)->devi_lock)); 648 ddi_devid_str_free(devidstr); 649 return (1); 650 } else { 651 /* a DDI_DEV_T_NONE devid exists and doesn't match */ 652 mutex_exit(&(DEVI(dip)->devi_lock)); 653 ddi_devid_str_free(devidstr); 654 return (0); 655 } 656 } 657 658 /* check if there is a devt specific devid property */ 659 propp = i_ddi_prop_search(dev, 660 DEVID_PROP_NAME, DEVID_PROP_FLAGS, &(DEVI(dip)->devi_hw_prop_ptr)); 661 if (propp != NULL) { 662 if (ddi_devid_str_compare(propp->prop_val, devidstr) == 0) { 663 /* a devt specific devid exists and matchs */ 664 mutex_exit(&(DEVI(dip)->devi_lock)); 665 ddi_devid_str_free(devidstr); 666 return (1); 667 } else { 668 /* a devt specific devid exists and doesn't match */ 669 mutex_exit(&(DEVI(dip)->devi_lock)); 670 ddi_devid_str_free(devidstr); 671 return (0); 672 } 673 } 674 675 /* we didn't find any devids associated with the device */ 676 mutex_exit(&(DEVI(dip)->devi_lock)); 677 ddi_devid_str_free(devidstr); 678 return (0); 679 } 680 681 /* get a handle to a device by devid and minor name */ 682 int 683 ldi_vp_from_devid(ddi_devid_t devid, char *minor_name, vnode_t **vpp) 684 { 685 dev_info_t *dip; 686 vnode_t *vp; 687 int ret, i, ndevs, styp; 688 dev_t dev, *devs; 689 690 /* sanity check required input parameters */ 691 if ((devid == NULL) || (minor_name == NULL) || (vpp == NULL)) 692 return (EINVAL); 693 694 ret = ddi_lyr_devid_to_devlist(devid, minor_name, &ndevs, &devs); 695 if ((ret != DDI_SUCCESS) || (ndevs <= 0)) 696 return (ENODEV); 697 698 for (i = 0; i < ndevs; i++) { 699 dev = devs[i]; 700 701 if ((dip = e_ddi_hold_devi_by_dev(dev, 0)) == NULL) 702 continue; 703 704 /* 705 * now we have to verify that the devid of the disk 706 * still matches what was requested. 707 * 708 * we have to do this because the devid could have 709 * changed between the call to ddi_lyr_devid_to_devlist() 710 * and e_ddi_hold_devi_by_dev(). this is because when 711 * ddi_lyr_devid_to_devlist() returns a list of devts 712 * there is no kind of hold on those devts so a device 713 * could have been replaced out from under us in the 714 * interim. 715 */ 716 if ((i_ddi_minorname_to_devtspectype(dip, minor_name, 717 NULL, &styp) == DDI_SUCCESS) && 718 ldi_devid_match(devid, dip, dev)) 719 break; 720 721 ddi_release_devi(dip); /* from e_ddi_hold_devi_by_dev() */ 722 } 723 724 ddi_lyr_free_devlist(devs, ndevs); 725 726 if (i == ndevs) 727 return (ENODEV); 728 729 ASSERT(STYP_VALID(styp)); 730 vp = makespecvp(dev, STYP_TO_VTYP(styp)); 731 spec_assoc_vp_with_devi(vp, dip); 732 ddi_release_devi(dip); /* from e_ddi_hold_devi_by_dev */ 733 734 *vpp = vp; 735 return (0); 736 } 737 738 /* given a vnode, open a device */ 739 static int 740 ldi_open_by_vp(vnode_t **vpp, int flag, cred_t *cr, 741 ldi_handle_t *lhp, struct ldi_ident *li) 742 { 743 struct ldi_handle *nlhp; 744 vnode_t *vp; 745 int err; 746 747 ASSERT((vpp != NULL) && (*vpp != NULL)); 748 ASSERT((lhp != NULL) && (li != NULL)); 749 750 vp = *vpp; 751 /* if the vnode passed in is not a device, then bail */ 752 if (!vn_matchops(vp, spec_getvnodeops()) || !VTYP_VALID(vp->v_type)) 753 return (ENXIO); 754 755 /* 756 * the caller may have specified a node that 757 * doesn't have cb_ops defined. the ldi doesn't yet 758 * support opening devices without a valid cb_ops. 759 */ 760 if (devopsp[getmajor(vp->v_rdev)]->devo_cb_ops == NULL) 761 return (ENXIO); 762 763 /* open the device */ 764 if ((err = VOP_OPEN(&vp, flag | FKLYR, cr, NULL)) != 0) 765 return (err); 766 767 /* possible clone open, make sure that we still have a spec node */ 768 ASSERT(vn_matchops(vp, spec_getvnodeops())); 769 770 nlhp = handle_alloc(vp, li); 771 772 if (vp != *vpp) { 773 /* 774 * allocating the layered handle took a new hold on the vnode 775 * so we can release the hold that was returned by the clone 776 * open 777 */ 778 LDI_OPENCLOSE((CE_WARN, "%s: lh=0x%p", 779 "ldi clone open", (void *)nlhp)); 780 } else { 781 LDI_OPENCLOSE((CE_WARN, "%s: lh=0x%p", 782 "ldi open", (void *)nlhp)); 783 } 784 785 *vpp = vp; 786 *lhp = (ldi_handle_t)nlhp; 787 return (0); 788 } 789 790 /* Call a drivers prop_op(9E) interface */ 791 static int 792 i_ldi_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, 793 int flags, char *name, caddr_t valuep, int *lengthp) 794 { 795 struct dev_ops *ops = NULL; 796 int res; 797 798 ASSERT((dip != NULL) && (name != NULL)); 799 ASSERT((prop_op == PROP_LEN) || (valuep != NULL)); 800 ASSERT(lengthp != NULL); 801 802 /* 803 * we can only be invoked after a driver has been opened and 804 * someone has a layered handle to it, so there had better be 805 * a valid ops vector. 806 */ 807 ops = DEVI(dip)->devi_ops; 808 ASSERT(ops && ops->devo_cb_ops); 809 810 /* 811 * Some nexus drivers incorrectly set cb_prop_op to nodev, 812 * nulldev or even NULL. 813 */ 814 if ((ops->devo_cb_ops->cb_prop_op == nodev) || 815 (ops->devo_cb_ops->cb_prop_op == nulldev) || 816 (ops->devo_cb_ops->cb_prop_op == NULL)) { 817 return (DDI_PROP_NOT_FOUND); 818 } 819 820 /* check if this is actually DDI_DEV_T_ANY query */ 821 if (flags & LDI_DEV_T_ANY) { 822 flags &= ~LDI_DEV_T_ANY; 823 dev = DDI_DEV_T_ANY; 824 } 825 826 res = cdev_prop_op(dev, dip, prop_op, flags, name, valuep, lengthp); 827 return (res); 828 } 829 830 static void 831 i_ldi_prop_op_free(struct prop_driver_data *pdd) 832 { 833 kmem_free(pdd, pdd->pdd_size); 834 } 835 836 static caddr_t 837 i_ldi_prop_op_alloc(int prop_len) 838 { 839 struct prop_driver_data *pdd; 840 int pdd_size; 841 842 pdd_size = sizeof (struct prop_driver_data) + prop_len; 843 pdd = kmem_alloc(pdd_size, KM_SLEEP); 844 pdd->pdd_size = pdd_size; 845 pdd->pdd_prop_free = i_ldi_prop_op_free; 846 return ((caddr_t)&pdd[1]); 847 } 848 849 /* 850 * i_ldi_prop_op_typed() is a wrapper for i_ldi_prop_op that is used 851 * by the typed ldi property lookup interfaces. 852 */ 853 static int 854 i_ldi_prop_op_typed(dev_t dev, dev_info_t *dip, int flags, char *name, 855 caddr_t *datap, int *lengthp, int elem_size) 856 { 857 caddr_t prop_val; 858 int prop_len, res; 859 860 ASSERT((dip != NULL) && (name != NULL)); 861 ASSERT((datap != NULL) && (lengthp != NULL)); 862 863 /* 864 * first call the drivers prop_op() interface to allow it 865 * it to override default property values. 866 */ 867 res = i_ldi_prop_op(dev, dip, PROP_LEN, 868 flags | DDI_PROP_DYNAMIC, name, NULL, &prop_len); 869 if (res != DDI_PROP_SUCCESS) 870 return (DDI_PROP_NOT_FOUND); 871 872 /* sanity check the property length */ 873 if (prop_len == 0) { 874 /* 875 * the ddi typed interfaces don't allow a drivers to 876 * create properties with a length of 0. so we should 877 * prevent drivers from returning 0 length dynamic 878 * properties for typed property lookups. 879 */ 880 return (DDI_PROP_NOT_FOUND); 881 } 882 883 /* sanity check the property length against the element size */ 884 if (elem_size && ((prop_len % elem_size) != 0)) 885 return (DDI_PROP_NOT_FOUND); 886 887 /* 888 * got it. now allocate a prop_driver_data struct so that the 889 * user can free the property via ddi_prop_free(). 890 */ 891 prop_val = i_ldi_prop_op_alloc(prop_len); 892 893 /* lookup the property again, this time get the value */ 894 res = i_ldi_prop_op(dev, dip, PROP_LEN_AND_VAL_BUF, 895 flags | DDI_PROP_DYNAMIC, name, prop_val, &prop_len); 896 if (res != DDI_PROP_SUCCESS) { 897 ddi_prop_free(prop_val); 898 return (DDI_PROP_NOT_FOUND); 899 } 900 901 /* sanity check the property length */ 902 if (prop_len == 0) { 903 ddi_prop_free(prop_val); 904 return (DDI_PROP_NOT_FOUND); 905 } 906 907 /* sanity check the property length against the element size */ 908 if (elem_size && ((prop_len % elem_size) != 0)) { 909 ddi_prop_free(prop_val); 910 return (DDI_PROP_NOT_FOUND); 911 } 912 913 /* 914 * return the prop_driver_data struct and, optionally, the length 915 * of the data. 916 */ 917 *datap = prop_val; 918 *lengthp = prop_len; 919 920 return (DDI_PROP_SUCCESS); 921 } 922 923 /* 924 * i_check_string looks at a string property and makes sure its 925 * a valid null terminated string 926 */ 927 static int 928 i_check_string(char *str, int prop_len) 929 { 930 int i; 931 932 ASSERT(str != NULL); 933 934 for (i = 0; i < prop_len; i++) { 935 if (str[i] == '\0') 936 return (0); 937 } 938 return (1); 939 } 940 941 /* 942 * i_pack_string_array takes a a string array property that is represented 943 * as a concatenation of strings (with the NULL character included for 944 * each string) and converts it into a format that can be returned by 945 * ldi_prop_lookup_string_array. 946 */ 947 static int 948 i_pack_string_array(char *str_concat, int prop_len, 949 char ***str_arrayp, int *nelemp) 950 { 951 int i, nelem, pack_size; 952 char **str_array, *strptr; 953 954 /* 955 * first we need to sanity check the input string array. 956 * in essence this can be done my making sure that the last 957 * character of the array passed in is null. (meaning the last 958 * string in the array is NULL terminated. 959 */ 960 if (str_concat[prop_len - 1] != '\0') 961 return (1); 962 963 /* now let's count the number of strings in the array */ 964 for (nelem = i = 0; i < prop_len; i++) 965 if (str_concat[i] == '\0') 966 nelem++; 967 ASSERT(nelem >= 1); 968 969 /* now let's allocate memory for the new packed property */ 970 pack_size = (sizeof (char *) * (nelem + 1)) + prop_len; 971 str_array = (char **)i_ldi_prop_op_alloc(pack_size); 972 973 /* let's copy the actual string data into the new property */ 974 strptr = (char *)&(str_array[nelem + 1]); 975 bcopy(str_concat, strptr, prop_len); 976 977 /* now initialize the string array pointers */ 978 for (i = 0; i < nelem; i++) { 979 str_array[i] = strptr; 980 strptr += strlen(strptr) + 1; 981 } 982 str_array[nelem] = NULL; 983 984 /* set the return values */ 985 *str_arrayp = str_array; 986 *nelemp = nelem; 987 988 return (0); 989 } 990 991 992 /* 993 * LDI Project private device usage interfaces 994 */ 995 996 /* 997 * Get a count of how many devices are currentl open by different consumers 998 */ 999 int 1000 ldi_usage_count() 1001 { 1002 return (ldi_handle_hash_count); 1003 } 1004 1005 static void 1006 ldi_usage_walker_tgt_helper(ldi_usage_t *ldi_usage, vnode_t *vp) 1007 { 1008 dev_info_t *dip; 1009 dev_t dev; 1010 1011 ASSERT(STYP_VALID(VTYP_TO_STYP(vp->v_type))); 1012 1013 /* get the target devt */ 1014 dev = vp->v_rdev; 1015 1016 /* try to get the target dip */ 1017 dip = VTOCS(vp)->s_dip; 1018 if (dip != NULL) { 1019 e_ddi_hold_devi(dip); 1020 } else if (dev != DDI_DEV_T_NONE) { 1021 dip = e_ddi_hold_devi_by_dev(dev, 0); 1022 } 1023 1024 /* set the target information */ 1025 ldi_usage->tgt_name = mod_major_to_name(getmajor(dev)); 1026 ldi_usage->tgt_modid = mod_name_to_modid(ldi_usage->tgt_name); 1027 ldi_usage->tgt_devt = dev; 1028 ldi_usage->tgt_spec_type = VTYP_TO_STYP(vp->v_type); 1029 ldi_usage->tgt_dip = dip; 1030 } 1031 1032 1033 static int 1034 ldi_usage_walker_helper(struct ldi_ident *lip, vnode_t *vp, 1035 void *arg, int (*callback)(const ldi_usage_t *, void *)) 1036 { 1037 ldi_usage_t ldi_usage; 1038 struct devnames *dnp; 1039 dev_info_t *dip; 1040 major_t major; 1041 dev_t dev; 1042 int ret = LDI_USAGE_CONTINUE; 1043 1044 /* set the target device information */ 1045 ldi_usage_walker_tgt_helper(&ldi_usage, vp); 1046 1047 /* get the source devt */ 1048 dev = lip->li_dev; 1049 1050 /* try to get the source dip */ 1051 dip = lip->li_dip; 1052 if (dip != NULL) { 1053 e_ddi_hold_devi(dip); 1054 } else if (dev != DDI_DEV_T_NONE) { 1055 dip = e_ddi_hold_devi_by_dev(dev, 0); 1056 } 1057 1058 /* set the valid source information */ 1059 ldi_usage.src_modid = lip->li_modid; 1060 ldi_usage.src_name = lip->li_modname; 1061 ldi_usage.src_devt = dev; 1062 ldi_usage.src_dip = dip; 1063 1064 /* 1065 * if the source ident represents either: 1066 * 1067 * - a kernel module (and not a device or device driver) 1068 * - a device node 1069 * 1070 * then we currently have all the info we need to report the 1071 * usage information so invoke the callback function. 1072 */ 1073 if (((lip->li_major == -1) && (dev == DDI_DEV_T_NONE)) || 1074 (dip != NULL)) { 1075 ret = callback(&ldi_usage, arg); 1076 if (dip != NULL) 1077 ddi_release_devi(dip); 1078 if (ldi_usage.tgt_dip != NULL) 1079 ddi_release_devi(ldi_usage.tgt_dip); 1080 return (ret); 1081 } 1082 1083 /* 1084 * now this is kinda gross. 1085 * 1086 * what we do here is attempt to associate every device instance 1087 * of the source driver on the system with the open target driver. 1088 * we do this because we don't know which instance of the device 1089 * could potentially access the lower device so we assume that all 1090 * the instances could access it. 1091 * 1092 * there are two ways we could have gotten here: 1093 * 1094 * 1) this layered ident represents one created using only a 1095 * major number or a driver module name. this means that when 1096 * it was created we could not associate it with a particular 1097 * dev_t or device instance. 1098 * 1099 * when could this possibly happen you ask? 1100 * 1101 * a perfect example of this is streams persistent links. 1102 * when a persistant streams link is formed we can't associate 1103 * the lower device stream with any particular upper device 1104 * stream or instance. this is because any particular upper 1105 * device stream could be closed, then another could be 1106 * opened with a different dev_t and device instance, and it 1107 * would still have access to the lower linked stream. 1108 * 1109 * since any instance of the upper streams driver could 1110 * potentially access the lower stream whenever it wants, 1111 * we represent that here by associating the opened lower 1112 * device with every existing device instance of the upper 1113 * streams driver. 1114 * 1115 * 2) This case should really never happen but we'll include it 1116 * for completeness. 1117 * 1118 * it's possible that we could have gotten here because we 1119 * have a dev_t for the upper device but we couldn't find a 1120 * dip associated with that dev_t. 1121 * 1122 * the only types of devices that have dev_t without an 1123 * associated dip are unbound DLPIv2 network devices. These 1124 * types of devices exist to be able to attach a stream to any 1125 * instance of a hardware network device. since these types of 1126 * devices are usually hardware devices they should never 1127 * really have other devices open. 1128 */ 1129 if (dev != DDI_DEV_T_NONE) 1130 major = getmajor(dev); 1131 else 1132 major = lip->li_major; 1133 1134 ASSERT3U(major, <, devcnt); 1135 1136 dnp = &devnamesp[major]; 1137 LOCK_DEV_OPS(&dnp->dn_lock); 1138 dip = dnp->dn_head; 1139 while ((dip) && (ret == LDI_USAGE_CONTINUE)) { 1140 e_ddi_hold_devi(dip); 1141 UNLOCK_DEV_OPS(&dnp->dn_lock); 1142 1143 /* set the source dip */ 1144 ldi_usage.src_dip = dip; 1145 1146 /* invoke the callback function */ 1147 ret = callback(&ldi_usage, arg); 1148 1149 LOCK_DEV_OPS(&dnp->dn_lock); 1150 ddi_release_devi(dip); 1151 dip = ddi_get_next(dip); 1152 } 1153 UNLOCK_DEV_OPS(&dnp->dn_lock); 1154 1155 /* if there was a target dip, release it */ 1156 if (ldi_usage.tgt_dip != NULL) 1157 ddi_release_devi(ldi_usage.tgt_dip); 1158 1159 return (ret); 1160 } 1161 1162 /* 1163 * ldi_usage_walker() - this walker reports LDI kernel device usage 1164 * information via the callback() callback function. the LDI keeps track 1165 * of what devices are being accessed in its own internal data structures. 1166 * this function walks those data structures to determine device usage. 1167 */ 1168 void 1169 ldi_usage_walker(void *arg, int (*callback)(const ldi_usage_t *, void *)) 1170 { 1171 struct ldi_handle *lhp; 1172 struct ldi_ident *lip; 1173 vnode_t *vp; 1174 int i; 1175 int ret = LDI_USAGE_CONTINUE; 1176 1177 for (i = 0; i < LH_HASH_SZ; i++) { 1178 mutex_enter(&ldi_handle_hash_lock[i]); 1179 1180 lhp = ldi_handle_hash[i]; 1181 while ((lhp != NULL) && (ret == LDI_USAGE_CONTINUE)) { 1182 lip = lhp->lh_ident; 1183 vp = lhp->lh_vp; 1184 1185 /* invoke the devinfo callback function */ 1186 ret = ldi_usage_walker_helper(lip, vp, arg, callback); 1187 1188 lhp = lhp->lh_next; 1189 } 1190 mutex_exit(&ldi_handle_hash_lock[i]); 1191 1192 if (ret != LDI_USAGE_CONTINUE) 1193 break; 1194 } 1195 } 1196 1197 /* 1198 * LDI Project private interfaces (streams linking interfaces) 1199 * 1200 * Streams supports a type of built in device layering via linking. 1201 * Certain types of streams drivers can be streams multiplexors. 1202 * A streams multiplexor supports the I_LINK/I_PLINK operation. 1203 * These operations allows other streams devices to be linked under the 1204 * multiplexor. By definition all streams multiplexors are devices 1205 * so this linking is a type of device layering where the multiplexor 1206 * device is layered on top of the device linked below it. 1207 */ 1208 1209 /* 1210 * ldi_mlink_lh() is invoked when streams are linked using LDI handles. 1211 * It is not used for normal I_LINKs and I_PLINKs using file descriptors. 1212 * 1213 * The streams framework keeps track of links via the file_t of the lower 1214 * stream. The LDI keeps track of devices using a vnode. In the case 1215 * of a streams link created via an LDI handle, fnk_lh() allocates 1216 * a file_t that the streams framework can use to track the linkage. 1217 */ 1218 int 1219 ldi_mlink_lh(vnode_t *vp, int cmd, intptr_t arg, cred_t *crp, int *rvalp) 1220 { 1221 struct ldi_handle *lhp = (struct ldi_handle *)arg; 1222 vnode_t *vpdown; 1223 file_t *fpdown; 1224 int err; 1225 1226 if (lhp == NULL) 1227 return (EINVAL); 1228 1229 vpdown = lhp->lh_vp; 1230 ASSERT(vn_matchops(vpdown, spec_getvnodeops())); 1231 ASSERT(cmd == _I_PLINK_LH); 1232 1233 /* 1234 * create a new lower vnode and a file_t that points to it, 1235 * streams linking requires a file_t. falloc() returns with 1236 * fpdown locked. 1237 */ 1238 VN_HOLD(vpdown); 1239 (void) falloc(vpdown, FREAD|FWRITE, &fpdown, NULL); 1240 mutex_exit(&fpdown->f_tlock); 1241 1242 /* try to establish the link */ 1243 err = mlink_file(vp, I_PLINK, fpdown, crp, rvalp, 1); 1244 1245 if (err != 0) { 1246 /* the link failed, free the file_t and release the vnode */ 1247 mutex_enter(&fpdown->f_tlock); 1248 unfalloc(fpdown); 1249 VN_RELE(vpdown); 1250 } 1251 1252 return (err); 1253 } 1254 1255 /* 1256 * ldi_mlink_fp() is invoked for all successful streams linkages created 1257 * via I_LINK and I_PLINK. ldi_mlink_fp() records the linkage information 1258 * in its internal state so that the devinfo snapshot code has some 1259 * observability into streams device linkage information. 1260 */ 1261 int 1262 ldi_mlink_fp(struct stdata *stp, file_t *fpdown, int lhlink, int type) 1263 { 1264 vnode_t *vp = fpdown->f_vnode; 1265 struct snode *sp, *csp; 1266 ldi_ident_t li; 1267 major_t major; 1268 int ret; 1269 1270 /* 1271 * If the lower stream is not a device then return but claim to have 1272 * succeeded, which matches our historical behaviour of just not 1273 * setting up LDI in this case. 1274 */ 1275 if (!vn_matchops(vp, spec_getvnodeops())) 1276 return (0); 1277 1278 ASSERT(!servicing_interrupt()); 1279 1280 LDI_STREAMS_LNK((CE_NOTE, "%s: linking streams " 1281 "stp=0x%p, fpdown=0x%p", "ldi_mlink_fp", 1282 (void *)stp, (void *)fpdown)); 1283 1284 sp = VTOS(vp); 1285 csp = VTOS(sp->s_commonvp); 1286 1287 /* get a layered ident for the upper stream */ 1288 if (type == LINKNORMAL) { 1289 /* 1290 * if the link is not persistant then we can associate 1291 * the upper stream with a dev_t. this is because the 1292 * upper stream is associated with a vnode, which is 1293 * associated with a dev_t and this binding can't change 1294 * during the life of the stream. since the link isn't 1295 * persistant once the stream is destroyed the link is 1296 * destroyed. so the dev_t will be valid for the life 1297 * of the link. 1298 */ 1299 ret = ldi_ident_from_stream(getendq(stp->sd_wrq), &li); 1300 } else { 1301 /* 1302 * if the link is persistant we can only associate the 1303 * link with a driver (and not a dev_t.) this is 1304 * because subsequent opens of the upper device may result 1305 * in a different stream (and dev_t) having access to 1306 * the lower stream. 1307 * 1308 * for example, if the upper stream is closed after the 1309 * persistant link operation is completed, a subsequent 1310 * open of the upper device will create a new stream which 1311 * may have a different dev_t and an unlink operation 1312 * can be performed using this new upper stream. 1313 */ 1314 VERIFY3S(type, ==, LINKPERSIST); 1315 major = getmajor(stp->sd_vnode->v_rdev); 1316 ret = ldi_ident_from_major(major, &li); 1317 } 1318 1319 if (ret != 0) 1320 return (ret); 1321 1322 /* check if this was a plink via a layered handle */ 1323 if (lhlink) { 1324 /* 1325 * increment the common snode s_count. 1326 * 1327 * this is done because after the link operation there 1328 * are two ways that s_count can be decremented. 1329 * 1330 * when the layered handle used to create the link is 1331 * closed, spec_close() is called and it will decrement 1332 * s_count in the common snode. if we don't increment 1333 * s_count here then this could cause spec_close() to 1334 * actually close the device while it's still linked 1335 * under a multiplexer. 1336 * 1337 * also, when the lower stream is unlinked, closef() is 1338 * called for the file_t associated with this snode. 1339 * closef() will call spec_close(), which will decrement 1340 * s_count. if we dont't increment s_count here then this 1341 * could cause spec_close() to actually close the device 1342 * while there may still be valid layered handles 1343 * pointing to it. 1344 */ 1345 VERIFY3S(type, ==, LINKPERSIST); 1346 1347 mutex_enter(&csp->s_lock); 1348 VERIFY(csp->s_count >= 1); 1349 csp->s_count++; 1350 mutex_exit(&csp->s_lock); 1351 1352 /* 1353 * decrement the f_count. 1354 * this is done because the layered driver framework does 1355 * not actually cache a copy of the file_t allocated to 1356 * do the link. this is done here instead of in ldi_mlink_lh() 1357 * because there is a window in ldi_mlink_lh() between where 1358 * milnk_file() returns and we would decrement the f_count 1359 * when the stream could be unlinked. 1360 */ 1361 mutex_enter(&fpdown->f_tlock); 1362 fpdown->f_count--; 1363 mutex_exit(&fpdown->f_tlock); 1364 } 1365 1366 /* 1367 * NOTE: here we rely on the streams subsystem not allowing 1368 * a stream to be multiplexed more than once. if this 1369 * changes, we break. 1370 * 1371 * mark the snode/stream as multiplexed 1372 */ 1373 mutex_enter(&sp->s_lock); 1374 VERIFY(!(sp->s_flag & SMUXED)); 1375 sp->s_flag |= SMUXED; 1376 mutex_exit(&sp->s_lock); 1377 1378 (void) handle_alloc(vp, (struct ldi_ident *)li); 1379 ldi_ident_release(li); 1380 1381 return (0); 1382 } 1383 1384 int 1385 ldi_munlink_fp(struct stdata *stp, file_t *fpdown, int type) 1386 { 1387 struct ldi_handle *lhp; 1388 vnode_t *vp = (vnode_t *)fpdown->f_vnode; 1389 struct snode *sp; 1390 ldi_ident_t li; 1391 major_t major; 1392 int ret; 1393 1394 /* 1395 * If the lower stream is not a device then return but claim to have 1396 * succeeded, which matches our historical behaviour of just not 1397 * setting up LDI in this case. 1398 */ 1399 if (!vn_matchops(vp, spec_getvnodeops())) 1400 return (0); 1401 1402 ASSERT(!servicing_interrupt()); 1403 1404 LDI_STREAMS_LNK((CE_NOTE, "%s: unlinking streams " 1405 "stp=0x%p, fpdown=0x%p", "ldi_munlink_fp", 1406 (void *)stp, (void *)fpdown)); 1407 1408 /* 1409 * clear the owner for this snode 1410 * see the comment in ldi_mlink_fp() for information about how 1411 * the ident is allocated 1412 */ 1413 if (type == LINKNORMAL) { 1414 ret = ldi_ident_from_stream(getendq(stp->sd_wrq), &li); 1415 } else { 1416 VERIFY3S(type, ==, LINKPERSIST); 1417 major = getmajor(stp->sd_vnode->v_rdev); 1418 ret = ldi_ident_from_major(major, &li); 1419 } 1420 1421 if (ret != 0) 1422 return (ret); 1423 1424 /* 1425 * NOTE: here we rely on the streams subsystem not allowing 1426 * a stream to be multiplexed more than once. if this 1427 * changes, we break. 1428 * 1429 * mark the snode/stream as not multiplexed 1430 */ 1431 sp = VTOS(vp); 1432 mutex_enter(&sp->s_lock); 1433 VERIFY(sp->s_flag & SMUXED); 1434 sp->s_flag &= ~SMUXED; 1435 mutex_exit(&sp->s_lock); 1436 1437 lhp = handle_find(vp, (struct ldi_ident *)li); 1438 handle_release(lhp); 1439 ldi_ident_release(li); 1440 1441 return (0); 1442 } 1443 1444 /* 1445 * LDI Consolidation private interfaces 1446 */ 1447 int 1448 ldi_ident_from_mod(struct modlinkage *modlp, ldi_ident_t *lip) 1449 { 1450 struct modctl *modp; 1451 major_t major; 1452 char *name; 1453 1454 if ((modlp == NULL) || (lip == NULL)) 1455 return (EINVAL); 1456 1457 ASSERT(!servicing_interrupt()); 1458 1459 modp = mod_getctl(modlp); 1460 if (modp == NULL) 1461 return (EINVAL); 1462 name = modp->mod_modname; 1463 if (name == NULL) 1464 return (EINVAL); 1465 major = mod_name_to_major(name); 1466 1467 *lip = (ldi_ident_t)ident_alloc(name, NULL, DDI_DEV_T_NONE, major); 1468 1469 LDI_ALLOCFREE((CE_WARN, "%s: li=0x%p, mod=%s", 1470 "ldi_ident_from_mod", (void *)*lip, name)); 1471 1472 return (0); 1473 } 1474 1475 ldi_ident_t 1476 ldi_ident_from_anon() 1477 { 1478 ldi_ident_t lip; 1479 1480 ASSERT(!servicing_interrupt()); 1481 1482 lip = (ldi_ident_t)ident_alloc("genunix", NULL, DDI_DEV_T_NONE, -1); 1483 1484 LDI_ALLOCFREE((CE_WARN, "%s: li=0x%p, mod=%s", 1485 "ldi_ident_from_anon", (void *)lip, "genunix")); 1486 1487 return (lip); 1488 } 1489 1490 1491 /* 1492 * LDI Public interfaces 1493 */ 1494 int 1495 ldi_ident_from_stream(struct queue *sq, ldi_ident_t *lip) 1496 { 1497 struct stdata *stp; 1498 dev_t dev; 1499 char *name; 1500 1501 if ((sq == NULL) || (lip == NULL)) 1502 return (EINVAL); 1503 1504 ASSERT(!servicing_interrupt()); 1505 1506 stp = sq->q_stream; 1507 if (!vn_matchops(stp->sd_vnode, spec_getvnodeops())) 1508 return (EINVAL); 1509 1510 dev = stp->sd_vnode->v_rdev; 1511 name = mod_major_to_name(getmajor(dev)); 1512 if (name == NULL) 1513 return (EINVAL); 1514 *lip = (ldi_ident_t)ident_alloc(name, NULL, dev, -1); 1515 1516 LDI_ALLOCFREE((CE_WARN, 1517 "%s: li=0x%p, mod=%s, minor=0x%x, stp=0x%p", 1518 "ldi_ident_from_stream", (void *)*lip, name, getminor(dev), 1519 (void *)stp)); 1520 1521 return (0); 1522 } 1523 1524 int 1525 ldi_ident_from_dev(dev_t dev, ldi_ident_t *lip) 1526 { 1527 char *name; 1528 1529 if (lip == NULL) 1530 return (EINVAL); 1531 1532 ASSERT(!servicing_interrupt()); 1533 1534 name = mod_major_to_name(getmajor(dev)); 1535 if (name == NULL) 1536 return (EINVAL); 1537 *lip = (ldi_ident_t)ident_alloc(name, NULL, dev, -1); 1538 1539 LDI_ALLOCFREE((CE_WARN, 1540 "%s: li=0x%p, mod=%s, minor=0x%x", 1541 "ldi_ident_from_dev", (void *)*lip, name, getminor(dev))); 1542 1543 return (0); 1544 } 1545 1546 int 1547 ldi_ident_from_dip(dev_info_t *dip, ldi_ident_t *lip) 1548 { 1549 struct dev_info *devi = (struct dev_info *)dip; 1550 char *name; 1551 1552 if ((dip == NULL) || (lip == NULL)) 1553 return (EINVAL); 1554 1555 ASSERT(!servicing_interrupt()); 1556 1557 name = mod_major_to_name(devi->devi_major); 1558 if (name == NULL) 1559 return (EINVAL); 1560 *lip = (ldi_ident_t)ident_alloc(name, dip, DDI_DEV_T_NONE, -1); 1561 1562 LDI_ALLOCFREE((CE_WARN, 1563 "%s: li=0x%p, mod=%s, dip=0x%p", 1564 "ldi_ident_from_dip", (void *)*lip, name, (void *)devi)); 1565 1566 return (0); 1567 } 1568 1569 int 1570 ldi_ident_from_major(major_t major, ldi_ident_t *lip) 1571 { 1572 char *name; 1573 1574 if (lip == NULL) 1575 return (EINVAL); 1576 1577 ASSERT(!servicing_interrupt()); 1578 1579 name = mod_major_to_name(major); 1580 if (name == NULL) 1581 return (EINVAL); 1582 *lip = (ldi_ident_t)ident_alloc(name, NULL, DDI_DEV_T_NONE, major); 1583 1584 LDI_ALLOCFREE((CE_WARN, 1585 "%s: li=0x%p, mod=%s", 1586 "ldi_ident_from_major", (void *)*lip, name)); 1587 1588 return (0); 1589 } 1590 1591 void 1592 ldi_ident_release(ldi_ident_t li) 1593 { 1594 struct ldi_ident *ident = (struct ldi_ident *)li; 1595 char *name; 1596 1597 if (li == NULL) 1598 return; 1599 1600 ASSERT(!servicing_interrupt()); 1601 1602 name = ident->li_modname; 1603 1604 LDI_ALLOCFREE((CE_WARN, 1605 "%s: li=0x%p, mod=%s", 1606 "ldi_ident_release", (void *)li, name)); 1607 1608 ident_release((struct ldi_ident *)li); 1609 } 1610 1611 /* get a handle to a device by dev_t and otyp */ 1612 int 1613 ldi_open_by_dev(dev_t *devp, int otyp, int flag, cred_t *cr, 1614 ldi_handle_t *lhp, ldi_ident_t li) 1615 { 1616 struct ldi_ident *lip = (struct ldi_ident *)li; 1617 int ret; 1618 vnode_t *vp; 1619 1620 /* sanity check required input parameters */ 1621 if ((devp == NULL) || (!OTYP_VALID(otyp)) || (cr == NULL) || 1622 (lhp == NULL) || (lip == NULL)) 1623 return (EINVAL); 1624 1625 ASSERT(!servicing_interrupt()); 1626 1627 if ((ret = ldi_vp_from_dev(*devp, otyp, &vp)) != 0) 1628 return (ret); 1629 1630 if ((ret = ldi_open_by_vp(&vp, flag, cr, lhp, lip)) == 0) { 1631 *devp = vp->v_rdev; 1632 } 1633 VN_RELE(vp); 1634 1635 return (ret); 1636 } 1637 1638 /* get a handle to a device by pathname */ 1639 int 1640 ldi_open_by_name(char *pathname, int flag, cred_t *cr, 1641 ldi_handle_t *lhp, ldi_ident_t li) 1642 { 1643 struct ldi_ident *lip = (struct ldi_ident *)li; 1644 int ret; 1645 vnode_t *vp; 1646 1647 /* sanity check required input parameters */ 1648 if ((pathname == NULL) || (*pathname != '/') || 1649 (cr == NULL) || (lhp == NULL) || (lip == NULL)) 1650 return (EINVAL); 1651 1652 ASSERT(!servicing_interrupt()); 1653 1654 if ((ret = ldi_vp_from_name(pathname, &vp)) != 0) 1655 return (ret); 1656 1657 ret = ldi_open_by_vp(&vp, flag, cr, lhp, lip); 1658 VN_RELE(vp); 1659 1660 return (ret); 1661 } 1662 1663 /* get a handle to a device by devid and minor_name */ 1664 int 1665 ldi_open_by_devid(ddi_devid_t devid, char *minor_name, 1666 int flag, cred_t *cr, ldi_handle_t *lhp, ldi_ident_t li) 1667 { 1668 struct ldi_ident *lip = (struct ldi_ident *)li; 1669 int ret; 1670 vnode_t *vp; 1671 1672 /* sanity check required input parameters */ 1673 if ((minor_name == NULL) || (cr == NULL) || 1674 (lhp == NULL) || (lip == NULL)) 1675 return (EINVAL); 1676 1677 ASSERT(!servicing_interrupt()); 1678 1679 if ((ret = ldi_vp_from_devid(devid, minor_name, &vp)) != 0) 1680 return (ret); 1681 1682 ret = ldi_open_by_vp(&vp, flag, cr, lhp, lip); 1683 VN_RELE(vp); 1684 1685 return (ret); 1686 } 1687 1688 int 1689 ldi_close(ldi_handle_t lh, int flag, cred_t *cr) 1690 { 1691 struct ldi_handle *handlep = (struct ldi_handle *)lh; 1692 struct ldi_event *lep; 1693 int err = 0; 1694 int notify = 0; 1695 list_t *listp; 1696 ldi_ev_callback_impl_t *lecp; 1697 1698 if (lh == NULL) 1699 return (EINVAL); 1700 1701 ASSERT(!servicing_interrupt()); 1702 1703 #ifdef LDI_OBSOLETE_EVENT 1704 1705 /* 1706 * Any event handlers should have been unregistered by the 1707 * time ldi_close() is called. If they haven't then it's a 1708 * bug. 1709 * 1710 * In a debug kernel we'll panic to make the problem obvious. 1711 */ 1712 ASSERT(handlep->lh_events == NULL); 1713 1714 /* 1715 * On a production kernel we'll "do the right thing" (unregister 1716 * the event handlers) and then complain about having to do the 1717 * work ourselves. 1718 */ 1719 while ((lep = handlep->lh_events) != NULL) { 1720 err = 1; 1721 (void) ldi_remove_event_handler(lh, (ldi_callback_id_t)lep); 1722 } 1723 if (err) { 1724 struct ldi_ident *lip = handlep->lh_ident; 1725 ASSERT(lip != NULL); 1726 cmn_err(CE_NOTE, "ldi err: %s " 1727 "failed to unregister layered event handlers before " 1728 "closing devices", lip->li_modname); 1729 } 1730 #endif 1731 1732 /* do a layered close on the device */ 1733 err = VOP_CLOSE(handlep->lh_vp, flag | FKLYR, 1, (offset_t)0, cr, NULL); 1734 1735 LDI_OPENCLOSE((CE_WARN, "%s: lh=0x%p", "ldi close", (void *)lh)); 1736 1737 /* 1738 * Search the event callback list for callbacks with this 1739 * handle. There are 2 cases 1740 * 1. Called in the context of a notify. The handle consumer 1741 * is releasing its hold on the device to allow a reconfiguration 1742 * of the device. Simply NULL out the handle and the notify callback. 1743 * The finalize callback is still available so that the consumer 1744 * knows of the final disposition of the device. 1745 * 2. Not called in the context of notify. NULL out the handle as well 1746 * as the notify and finalize callbacks. Since the consumer has 1747 * closed the handle, we assume it is not interested in the 1748 * notify and finalize callbacks. 1749 */ 1750 ldi_ev_lock(); 1751 1752 if (handlep->lh_flags & LH_FLAGS_NOTIFY) 1753 notify = 1; 1754 listp = &ldi_ev_callback_list.le_head; 1755 for (lecp = list_head(listp); lecp; lecp = list_next(listp, lecp)) { 1756 if (lecp->lec_lhp != handlep) 1757 continue; 1758 lecp->lec_lhp = NULL; 1759 lecp->lec_notify = NULL; 1760 LDI_EVDBG((CE_NOTE, "ldi_close: NULLed lh and notify")); 1761 if (!notify) { 1762 LDI_EVDBG((CE_NOTE, "ldi_close: NULLed finalize")); 1763 lecp->lec_finalize = NULL; 1764 } 1765 } 1766 1767 if (notify) 1768 handlep->lh_flags &= ~LH_FLAGS_NOTIFY; 1769 ldi_ev_unlock(); 1770 1771 /* 1772 * Free the handle even if the device close failed. why? 1773 * 1774 * If the device close failed we can't really make assumptions 1775 * about the devices state so we shouldn't allow access to the 1776 * device via this handle any more. If the device consumer wants 1777 * to access the device again they should open it again. 1778 * 1779 * This is the same way file/device close failures are handled 1780 * in other places like spec_close() and closeandsetf(). 1781 */ 1782 handle_release(handlep); 1783 return (err); 1784 } 1785 1786 int 1787 ldi_read(ldi_handle_t lh, struct uio *uiop, cred_t *credp) 1788 { 1789 struct ldi_handle *handlep = (struct ldi_handle *)lh; 1790 vnode_t *vp; 1791 dev_t dev; 1792 int ret; 1793 1794 if (lh == NULL) 1795 return (EINVAL); 1796 1797 vp = handlep->lh_vp; 1798 dev = vp->v_rdev; 1799 if (handlep->lh_type & LH_CBDEV) { 1800 ret = cdev_read(dev, uiop, credp); 1801 } else if (handlep->lh_type & LH_STREAM) { 1802 ret = strread(vp, uiop, credp); 1803 } else { 1804 return (ENOTSUP); 1805 } 1806 return (ret); 1807 } 1808 1809 int 1810 ldi_write(ldi_handle_t lh, struct uio *uiop, cred_t *credp) 1811 { 1812 struct ldi_handle *handlep = (struct ldi_handle *)lh; 1813 vnode_t *vp; 1814 dev_t dev; 1815 int ret; 1816 1817 if (lh == NULL) 1818 return (EINVAL); 1819 1820 vp = handlep->lh_vp; 1821 dev = vp->v_rdev; 1822 if (handlep->lh_type & LH_CBDEV) { 1823 ret = cdev_write(dev, uiop, credp); 1824 } else if (handlep->lh_type & LH_STREAM) { 1825 ret = strwrite(vp, uiop, credp); 1826 } else { 1827 return (ENOTSUP); 1828 } 1829 return (ret); 1830 } 1831 1832 int 1833 ldi_get_size(ldi_handle_t lh, uint64_t *sizep) 1834 { 1835 int otyp; 1836 uint_t value; 1837 int64_t drv_prop64; 1838 struct ldi_handle *handlep = (struct ldi_handle *)lh; 1839 uint_t blksize; 1840 int blkshift; 1841 1842 1843 if ((lh == NULL) || (sizep == NULL)) 1844 return (DDI_FAILURE); 1845 1846 if (handlep->lh_type & LH_STREAM) 1847 return (DDI_FAILURE); 1848 1849 /* 1850 * Determine device type (char or block). 1851 * Character devices support Size/size 1852 * property value. Block devices may support 1853 * Nblocks/nblocks or Size/size property value. 1854 */ 1855 if ((ldi_get_otyp(lh, &otyp)) != 0) 1856 return (DDI_FAILURE); 1857 1858 if (otyp == OTYP_BLK) { 1859 if (ldi_prop_exists(lh, 1860 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "Nblocks")) { 1861 1862 drv_prop64 = ldi_prop_get_int64(lh, 1863 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 1864 "Nblocks", 0); 1865 blksize = ldi_prop_get_int(lh, 1866 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 1867 "blksize", DEV_BSIZE); 1868 if (blksize == DEV_BSIZE) 1869 blksize = ldi_prop_get_int(lh, LDI_DEV_T_ANY | 1870 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 1871 "device-blksize", DEV_BSIZE); 1872 1873 /* blksize must be a power of two */ 1874 ASSERT(BIT_ONLYONESET(blksize)); 1875 blkshift = highbit(blksize) - 1; 1876 1877 /* 1878 * We don't support Nblocks values that don't have 1879 * an accurate uint64_t byte count representation. 1880 */ 1881 if ((uint64_t)drv_prop64 >= (UINT64_MAX >> blkshift)) 1882 return (DDI_FAILURE); 1883 1884 *sizep = (uint64_t) 1885 (((u_offset_t)drv_prop64) << blkshift); 1886 return (DDI_SUCCESS); 1887 } 1888 1889 if (ldi_prop_exists(lh, 1890 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "nblocks")) { 1891 1892 value = ldi_prop_get_int(lh, 1893 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 1894 "nblocks", 0); 1895 blksize = ldi_prop_get_int(lh, 1896 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 1897 "blksize", DEV_BSIZE); 1898 if (blksize == DEV_BSIZE) 1899 blksize = ldi_prop_get_int(lh, LDI_DEV_T_ANY | 1900 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 1901 "device-blksize", DEV_BSIZE); 1902 1903 /* blksize must be a power of two */ 1904 ASSERT(BIT_ONLYONESET(blksize)); 1905 blkshift = highbit(blksize) - 1; 1906 1907 /* 1908 * We don't support nblocks values that don't have an 1909 * accurate uint64_t byte count representation. 1910 */ 1911 if ((uint64_t)value >= (UINT64_MAX >> blkshift)) 1912 return (DDI_FAILURE); 1913 1914 *sizep = (uint64_t) 1915 (((u_offset_t)value) << blkshift); 1916 return (DDI_SUCCESS); 1917 } 1918 } 1919 1920 if (ldi_prop_exists(lh, 1921 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "Size")) { 1922 1923 drv_prop64 = ldi_prop_get_int64(lh, 1924 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "Size", 0); 1925 *sizep = (uint64_t)drv_prop64; 1926 return (DDI_SUCCESS); 1927 } 1928 1929 if (ldi_prop_exists(lh, 1930 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "size")) { 1931 1932 value = ldi_prop_get_int(lh, 1933 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "size", 0); 1934 *sizep = (uint64_t)value; 1935 return (DDI_SUCCESS); 1936 } 1937 1938 /* unable to determine device size */ 1939 return (DDI_FAILURE); 1940 } 1941 1942 int 1943 ldi_ioctl(ldi_handle_t lh, int cmd, intptr_t arg, int mode, 1944 cred_t *cr, int *rvalp) 1945 { 1946 struct ldi_handle *handlep = (struct ldi_handle *)lh; 1947 vnode_t *vp; 1948 dev_t dev; 1949 int ret, copymode, unused; 1950 1951 if (lh == NULL) 1952 return (EINVAL); 1953 1954 /* 1955 * if the data pointed to by arg is located in the kernel then 1956 * make sure the FNATIVE flag is set. 1957 */ 1958 if (mode & FKIOCTL) 1959 mode = (mode & ~FMODELS) | FNATIVE | FKIOCTL; 1960 1961 /* 1962 * Some drivers assume that rvalp will always be non-NULL, so in 1963 * an attempt to avoid panics if the caller passed in a NULL 1964 * value, update rvalp to point to a temporary variable. 1965 */ 1966 if (rvalp == NULL) 1967 rvalp = &unused; 1968 vp = handlep->lh_vp; 1969 dev = vp->v_rdev; 1970 if (handlep->lh_type & LH_CBDEV) { 1971 ret = cdev_ioctl(dev, cmd, arg, mode, cr, rvalp); 1972 } else if (handlep->lh_type & LH_STREAM) { 1973 copymode = (mode & FKIOCTL) ? K_TO_K : U_TO_K; 1974 1975 /* 1976 * if we get an I_PLINK from within the kernel the 1977 * arg is a layered handle pointer instead of 1978 * a file descriptor, so we translate this ioctl 1979 * into a private one that can handle this. 1980 */ 1981 if ((mode & FKIOCTL) && (cmd == I_PLINK)) 1982 cmd = _I_PLINK_LH; 1983 1984 ret = strioctl(vp, cmd, arg, mode, copymode, cr, rvalp); 1985 } else { 1986 return (ENOTSUP); 1987 } 1988 1989 return (ret); 1990 } 1991 1992 int 1993 ldi_poll(ldi_handle_t lh, short events, int anyyet, short *reventsp, 1994 struct pollhead **phpp) 1995 { 1996 struct ldi_handle *handlep = (struct ldi_handle *)lh; 1997 vnode_t *vp; 1998 dev_t dev; 1999 int ret; 2000 2001 if (lh == NULL) 2002 return (EINVAL); 2003 2004 vp = handlep->lh_vp; 2005 dev = vp->v_rdev; 2006 if (handlep->lh_type & LH_CBDEV) { 2007 ret = cdev_poll(dev, events, anyyet, reventsp, phpp); 2008 } else if (handlep->lh_type & LH_STREAM) { 2009 ret = strpoll(vp->v_stream, events, anyyet, reventsp, phpp); 2010 } else { 2011 return (ENOTSUP); 2012 } 2013 2014 return (ret); 2015 } 2016 2017 int 2018 ldi_prop_op(ldi_handle_t lh, ddi_prop_op_t prop_op, 2019 int flags, char *name, caddr_t valuep, int *length) 2020 { 2021 struct ldi_handle *handlep = (struct ldi_handle *)lh; 2022 dev_t dev; 2023 dev_info_t *dip; 2024 int ret; 2025 struct snode *csp; 2026 2027 if ((lh == NULL) || (name == NULL) || (strlen(name) == 0)) 2028 return (DDI_PROP_INVAL_ARG); 2029 2030 if ((prop_op != PROP_LEN) && (valuep == NULL)) 2031 return (DDI_PROP_INVAL_ARG); 2032 2033 if (length == NULL) 2034 return (DDI_PROP_INVAL_ARG); 2035 2036 /* 2037 * try to find the associated dip, 2038 * this places a hold on the driver 2039 */ 2040 dev = handlep->lh_vp->v_rdev; 2041 2042 csp = VTOCS(handlep->lh_vp); 2043 mutex_enter(&csp->s_lock); 2044 if ((dip = csp->s_dip) != NULL) 2045 e_ddi_hold_devi(dip); 2046 mutex_exit(&csp->s_lock); 2047 if (dip == NULL) 2048 dip = e_ddi_hold_devi_by_dev(dev, 0); 2049 2050 if (dip == NULL) 2051 return (DDI_PROP_NOT_FOUND); 2052 2053 ret = i_ldi_prop_op(dev, dip, prop_op, flags, name, valuep, length); 2054 ddi_release_devi(dip); 2055 2056 return (ret); 2057 } 2058 2059 int 2060 ldi_strategy(ldi_handle_t lh, struct buf *bp) 2061 { 2062 struct ldi_handle *handlep = (struct ldi_handle *)lh; 2063 dev_t dev; 2064 2065 if ((lh == NULL) || (bp == NULL)) 2066 return (EINVAL); 2067 2068 /* this entry point is only supported for cb devices */ 2069 dev = handlep->lh_vp->v_rdev; 2070 if (!(handlep->lh_type & LH_CBDEV)) 2071 return (ENOTSUP); 2072 2073 bp->b_edev = dev; 2074 bp->b_dev = cmpdev(dev); 2075 return (bdev_strategy(bp)); 2076 } 2077 2078 int 2079 ldi_dump(ldi_handle_t lh, caddr_t addr, daddr_t blkno, int nblk) 2080 { 2081 struct ldi_handle *handlep = (struct ldi_handle *)lh; 2082 dev_t dev; 2083 2084 if (lh == NULL) 2085 return (EINVAL); 2086 2087 /* this entry point is only supported for cb devices */ 2088 dev = handlep->lh_vp->v_rdev; 2089 if (!(handlep->lh_type & LH_CBDEV)) 2090 return (ENOTSUP); 2091 2092 return (bdev_dump(dev, addr, blkno, nblk)); 2093 } 2094 2095 int 2096 ldi_devmap(ldi_handle_t lh, devmap_cookie_t dhp, offset_t off, 2097 size_t len, size_t *maplen, uint_t model) 2098 { 2099 struct ldi_handle *handlep = (struct ldi_handle *)lh; 2100 dev_t dev; 2101 2102 if (lh == NULL) 2103 return (EINVAL); 2104 2105 /* this entry point is only supported for cb devices */ 2106 dev = handlep->lh_vp->v_rdev; 2107 if (!(handlep->lh_type & LH_CBDEV)) 2108 return (ENOTSUP); 2109 2110 return (cdev_devmap(dev, dhp, off, len, maplen, model)); 2111 } 2112 2113 int 2114 ldi_aread(ldi_handle_t lh, struct aio_req *aio_reqp, cred_t *cr) 2115 { 2116 struct ldi_handle *handlep = (struct ldi_handle *)lh; 2117 dev_t dev; 2118 struct cb_ops *cb; 2119 2120 if (lh == NULL) 2121 return (EINVAL); 2122 2123 /* this entry point is only supported for cb devices */ 2124 if (!(handlep->lh_type & LH_CBDEV)) 2125 return (ENOTSUP); 2126 2127 /* 2128 * Kaio is only supported on block devices. 2129 */ 2130 dev = handlep->lh_vp->v_rdev; 2131 cb = devopsp[getmajor(dev)]->devo_cb_ops; 2132 if (cb->cb_strategy == nodev || cb->cb_strategy == NULL) 2133 return (ENOTSUP); 2134 2135 if (cb->cb_aread == NULL) 2136 return (ENOTSUP); 2137 2138 return (cb->cb_aread(dev, aio_reqp, cr)); 2139 } 2140 2141 int 2142 ldi_awrite(ldi_handle_t lh, struct aio_req *aio_reqp, cred_t *cr) 2143 { 2144 struct ldi_handle *handlep = (struct ldi_handle *)lh; 2145 struct cb_ops *cb; 2146 dev_t dev; 2147 2148 if (lh == NULL) 2149 return (EINVAL); 2150 2151 /* this entry point is only supported for cb devices */ 2152 if (!(handlep->lh_type & LH_CBDEV)) 2153 return (ENOTSUP); 2154 2155 /* 2156 * Kaio is only supported on block devices. 2157 */ 2158 dev = handlep->lh_vp->v_rdev; 2159 cb = devopsp[getmajor(dev)]->devo_cb_ops; 2160 if (cb->cb_strategy == nodev || cb->cb_strategy == NULL) 2161 return (ENOTSUP); 2162 2163 if (cb->cb_awrite == NULL) 2164 return (ENOTSUP); 2165 2166 return (cb->cb_awrite(dev, aio_reqp, cr)); 2167 } 2168 2169 int 2170 ldi_putmsg(ldi_handle_t lh, mblk_t *smp) 2171 { 2172 struct ldi_handle *handlep = (struct ldi_handle *)lh; 2173 int ret; 2174 2175 if ((lh == NULL) || (smp == NULL)) 2176 return (EINVAL); 2177 2178 if (!(handlep->lh_type & LH_STREAM)) { 2179 freemsg(smp); 2180 return (ENOTSUP); 2181 } 2182 2183 /* 2184 * If we don't have db_credp, set it. Note that we can not be called 2185 * from interrupt context. 2186 */ 2187 if (msg_getcred(smp, NULL) == NULL) 2188 mblk_setcred(smp, CRED(), curproc->p_pid); 2189 2190 /* Send message while honoring flow control */ 2191 ret = kstrputmsg(handlep->lh_vp, smp, NULL, 0, 0, 2192 MSG_BAND | MSG_HOLDSIG | MSG_IGNERROR, 0); 2193 2194 return (ret); 2195 } 2196 2197 int 2198 ldi_getmsg(ldi_handle_t lh, mblk_t **rmp, timestruc_t *timeo) 2199 { 2200 struct ldi_handle *handlep = (struct ldi_handle *)lh; 2201 clock_t timout; /* milliseconds */ 2202 uchar_t pri; 2203 rval_t rval; 2204 int ret, pflag; 2205 2206 2207 if (lh == NULL) 2208 return (EINVAL); 2209 2210 if (!(handlep->lh_type & LH_STREAM)) 2211 return (ENOTSUP); 2212 2213 /* Convert from nanoseconds to milliseconds */ 2214 if (timeo != NULL) { 2215 timout = timeo->tv_sec * 1000 + timeo->tv_nsec / 1000000; 2216 if (timout > INT_MAX) 2217 return (EINVAL); 2218 } else 2219 timout = -1; 2220 2221 /* Wait for timeout millseconds for a message */ 2222 pflag = MSG_ANY; 2223 pri = 0; 2224 *rmp = NULL; 2225 ret = kstrgetmsg(handlep->lh_vp, 2226 rmp, NULL, &pri, &pflag, timout, &rval); 2227 return (ret); 2228 } 2229 2230 int 2231 ldi_get_dev(ldi_handle_t lh, dev_t *devp) 2232 { 2233 struct ldi_handle *handlep = (struct ldi_handle *)lh; 2234 2235 if ((lh == NULL) || (devp == NULL)) 2236 return (EINVAL); 2237 2238 *devp = handlep->lh_vp->v_rdev; 2239 return (0); 2240 } 2241 2242 int 2243 ldi_get_otyp(ldi_handle_t lh, int *otyp) 2244 { 2245 struct ldi_handle *handlep = (struct ldi_handle *)lh; 2246 2247 if ((lh == NULL) || (otyp == NULL)) 2248 return (EINVAL); 2249 2250 *otyp = VTYP_TO_OTYP(handlep->lh_vp->v_type); 2251 return (0); 2252 } 2253 2254 int 2255 ldi_get_devid(ldi_handle_t lh, ddi_devid_t *devid) 2256 { 2257 struct ldi_handle *handlep = (struct ldi_handle *)lh; 2258 int ret; 2259 dev_t dev; 2260 2261 if ((lh == NULL) || (devid == NULL)) 2262 return (EINVAL); 2263 2264 dev = handlep->lh_vp->v_rdev; 2265 2266 ret = ddi_lyr_get_devid(dev, devid); 2267 if (ret != DDI_SUCCESS) 2268 return (ENOTSUP); 2269 2270 return (0); 2271 } 2272 2273 int 2274 ldi_get_minor_name(ldi_handle_t lh, char **minor_name) 2275 { 2276 struct ldi_handle *handlep = (struct ldi_handle *)lh; 2277 int ret, otyp; 2278 dev_t dev; 2279 2280 if ((lh == NULL) || (minor_name == NULL)) 2281 return (EINVAL); 2282 2283 dev = handlep->lh_vp->v_rdev; 2284 otyp = VTYP_TO_OTYP(handlep->lh_vp->v_type); 2285 2286 ret = ddi_lyr_get_minor_name(dev, OTYP_TO_STYP(otyp), minor_name); 2287 if (ret != DDI_SUCCESS) 2288 return (ENOTSUP); 2289 2290 return (0); 2291 } 2292 2293 int 2294 ldi_prop_lookup_int_array(ldi_handle_t lh, 2295 uint_t flags, char *name, int **data, uint_t *nelements) 2296 { 2297 struct ldi_handle *handlep = (struct ldi_handle *)lh; 2298 dev_info_t *dip; 2299 dev_t dev; 2300 int res; 2301 struct snode *csp; 2302 2303 if ((lh == NULL) || (name == NULL) || (strlen(name) == 0)) 2304 return (DDI_PROP_INVAL_ARG); 2305 2306 dev = handlep->lh_vp->v_rdev; 2307 2308 csp = VTOCS(handlep->lh_vp); 2309 mutex_enter(&csp->s_lock); 2310 if ((dip = csp->s_dip) != NULL) 2311 e_ddi_hold_devi(dip); 2312 mutex_exit(&csp->s_lock); 2313 if (dip == NULL) 2314 dip = e_ddi_hold_devi_by_dev(dev, 0); 2315 2316 if (dip == NULL) { 2317 flags |= DDI_UNBND_DLPI2; 2318 } else if (flags & LDI_DEV_T_ANY) { 2319 flags &= ~LDI_DEV_T_ANY; 2320 dev = DDI_DEV_T_ANY; 2321 } 2322 2323 if (dip != NULL) { 2324 int *prop_val, prop_len; 2325 2326 res = i_ldi_prop_op_typed(dev, dip, flags, name, 2327 (caddr_t *)&prop_val, &prop_len, sizeof (int)); 2328 2329 /* if we got it then return it */ 2330 if (res == DDI_PROP_SUCCESS) { 2331 *nelements = prop_len / sizeof (int); 2332 *data = prop_val; 2333 2334 ddi_release_devi(dip); 2335 return (res); 2336 } 2337 } 2338 2339 /* call the normal property interfaces */ 2340 res = ddi_prop_lookup_int_array(dev, dip, flags, 2341 name, data, nelements); 2342 2343 if (dip != NULL) 2344 ddi_release_devi(dip); 2345 2346 return (res); 2347 } 2348 2349 int 2350 ldi_prop_lookup_int64_array(ldi_handle_t lh, 2351 uint_t flags, char *name, int64_t **data, uint_t *nelements) 2352 { 2353 struct ldi_handle *handlep = (struct ldi_handle *)lh; 2354 dev_info_t *dip; 2355 dev_t dev; 2356 int res; 2357 struct snode *csp; 2358 2359 if ((lh == NULL) || (name == NULL) || (strlen(name) == 0)) 2360 return (DDI_PROP_INVAL_ARG); 2361 2362 dev = handlep->lh_vp->v_rdev; 2363 2364 csp = VTOCS(handlep->lh_vp); 2365 mutex_enter(&csp->s_lock); 2366 if ((dip = csp->s_dip) != NULL) 2367 e_ddi_hold_devi(dip); 2368 mutex_exit(&csp->s_lock); 2369 if (dip == NULL) 2370 dip = e_ddi_hold_devi_by_dev(dev, 0); 2371 2372 if (dip == NULL) { 2373 flags |= DDI_UNBND_DLPI2; 2374 } else if (flags & LDI_DEV_T_ANY) { 2375 flags &= ~LDI_DEV_T_ANY; 2376 dev = DDI_DEV_T_ANY; 2377 } 2378 2379 if (dip != NULL) { 2380 int64_t *prop_val; 2381 int prop_len; 2382 2383 res = i_ldi_prop_op_typed(dev, dip, flags, name, 2384 (caddr_t *)&prop_val, &prop_len, sizeof (int64_t)); 2385 2386 /* if we got it then return it */ 2387 if (res == DDI_PROP_SUCCESS) { 2388 *nelements = prop_len / sizeof (int64_t); 2389 *data = prop_val; 2390 2391 ddi_release_devi(dip); 2392 return (res); 2393 } 2394 } 2395 2396 /* call the normal property interfaces */ 2397 res = ddi_prop_lookup_int64_array(dev, dip, flags, 2398 name, data, nelements); 2399 2400 if (dip != NULL) 2401 ddi_release_devi(dip); 2402 2403 return (res); 2404 } 2405 2406 int 2407 ldi_prop_lookup_string_array(ldi_handle_t lh, 2408 uint_t flags, char *name, char ***data, uint_t *nelements) 2409 { 2410 struct ldi_handle *handlep = (struct ldi_handle *)lh; 2411 dev_info_t *dip; 2412 dev_t dev; 2413 int res; 2414 struct snode *csp; 2415 2416 if ((lh == NULL) || (name == NULL) || (strlen(name) == 0)) 2417 return (DDI_PROP_INVAL_ARG); 2418 2419 dev = handlep->lh_vp->v_rdev; 2420 2421 csp = VTOCS(handlep->lh_vp); 2422 mutex_enter(&csp->s_lock); 2423 if ((dip = csp->s_dip) != NULL) 2424 e_ddi_hold_devi(dip); 2425 mutex_exit(&csp->s_lock); 2426 if (dip == NULL) 2427 dip = e_ddi_hold_devi_by_dev(dev, 0); 2428 2429 if (dip == NULL) { 2430 flags |= DDI_UNBND_DLPI2; 2431 } else if (flags & LDI_DEV_T_ANY) { 2432 flags &= ~LDI_DEV_T_ANY; 2433 dev = DDI_DEV_T_ANY; 2434 } 2435 2436 if (dip != NULL) { 2437 char *prop_val; 2438 int prop_len; 2439 2440 res = i_ldi_prop_op_typed(dev, dip, flags, name, 2441 (caddr_t *)&prop_val, &prop_len, 0); 2442 2443 /* if we got it then return it */ 2444 if (res == DDI_PROP_SUCCESS) { 2445 char **str_array; 2446 int nelem; 2447 2448 /* 2449 * pack the returned string array into the format 2450 * our callers expect 2451 */ 2452 if (i_pack_string_array(prop_val, prop_len, 2453 &str_array, &nelem) == 0) { 2454 2455 *data = str_array; 2456 *nelements = nelem; 2457 2458 ddi_prop_free(prop_val); 2459 ddi_release_devi(dip); 2460 return (res); 2461 } 2462 2463 /* 2464 * the format of the returned property must have 2465 * been bad so throw it out 2466 */ 2467 ddi_prop_free(prop_val); 2468 } 2469 } 2470 2471 /* call the normal property interfaces */ 2472 res = ddi_prop_lookup_string_array(dev, dip, flags, 2473 name, data, nelements); 2474 2475 if (dip != NULL) 2476 ddi_release_devi(dip); 2477 2478 return (res); 2479 } 2480 2481 int 2482 ldi_prop_lookup_string(ldi_handle_t lh, 2483 uint_t flags, char *name, char **data) 2484 { 2485 struct ldi_handle *handlep = (struct ldi_handle *)lh; 2486 dev_info_t *dip; 2487 dev_t dev; 2488 int res; 2489 struct snode *csp; 2490 2491 if ((lh == NULL) || (name == NULL) || (strlen(name) == 0)) 2492 return (DDI_PROP_INVAL_ARG); 2493 2494 dev = handlep->lh_vp->v_rdev; 2495 2496 csp = VTOCS(handlep->lh_vp); 2497 mutex_enter(&csp->s_lock); 2498 if ((dip = csp->s_dip) != NULL) 2499 e_ddi_hold_devi(dip); 2500 mutex_exit(&csp->s_lock); 2501 if (dip == NULL) 2502 dip = e_ddi_hold_devi_by_dev(dev, 0); 2503 2504 if (dip == NULL) { 2505 flags |= DDI_UNBND_DLPI2; 2506 } else if (flags & LDI_DEV_T_ANY) { 2507 flags &= ~LDI_DEV_T_ANY; 2508 dev = DDI_DEV_T_ANY; 2509 } 2510 2511 if (dip != NULL) { 2512 char *prop_val; 2513 int prop_len; 2514 2515 res = i_ldi_prop_op_typed(dev, dip, flags, name, 2516 (caddr_t *)&prop_val, &prop_len, 0); 2517 2518 /* if we got it then return it */ 2519 if (res == DDI_PROP_SUCCESS) { 2520 /* 2521 * sanity check the vaule returned. 2522 */ 2523 if (i_check_string(prop_val, prop_len)) { 2524 ddi_prop_free(prop_val); 2525 } else { 2526 *data = prop_val; 2527 ddi_release_devi(dip); 2528 return (res); 2529 } 2530 } 2531 } 2532 2533 /* call the normal property interfaces */ 2534 res = ddi_prop_lookup_string(dev, dip, flags, name, data); 2535 2536 if (dip != NULL) 2537 ddi_release_devi(dip); 2538 2539 #ifdef DEBUG 2540 if (res == DDI_PROP_SUCCESS) { 2541 /* 2542 * keep ourselves honest 2543 * make sure the framework returns strings in the 2544 * same format as we're demanding from drivers. 2545 */ 2546 struct prop_driver_data *pdd; 2547 int pdd_prop_size; 2548 2549 pdd = ((struct prop_driver_data *)(*data)) - 1; 2550 pdd_prop_size = pdd->pdd_size - 2551 sizeof (struct prop_driver_data); 2552 ASSERT(i_check_string(*data, pdd_prop_size) == 0); 2553 } 2554 #endif /* DEBUG */ 2555 2556 return (res); 2557 } 2558 2559 int 2560 ldi_prop_lookup_byte_array(ldi_handle_t lh, 2561 uint_t flags, char *name, uchar_t **data, uint_t *nelements) 2562 { 2563 struct ldi_handle *handlep = (struct ldi_handle *)lh; 2564 dev_info_t *dip; 2565 dev_t dev; 2566 int res; 2567 struct snode *csp; 2568 2569 if ((lh == NULL) || (name == NULL) || (strlen(name) == 0)) 2570 return (DDI_PROP_INVAL_ARG); 2571 2572 dev = handlep->lh_vp->v_rdev; 2573 2574 csp = VTOCS(handlep->lh_vp); 2575 mutex_enter(&csp->s_lock); 2576 if ((dip = csp->s_dip) != NULL) 2577 e_ddi_hold_devi(dip); 2578 mutex_exit(&csp->s_lock); 2579 if (dip == NULL) 2580 dip = e_ddi_hold_devi_by_dev(dev, 0); 2581 2582 if (dip == NULL) { 2583 flags |= DDI_UNBND_DLPI2; 2584 } else if (flags & LDI_DEV_T_ANY) { 2585 flags &= ~LDI_DEV_T_ANY; 2586 dev = DDI_DEV_T_ANY; 2587 } 2588 2589 if (dip != NULL) { 2590 uchar_t *prop_val; 2591 int prop_len; 2592 2593 res = i_ldi_prop_op_typed(dev, dip, flags, name, 2594 (caddr_t *)&prop_val, &prop_len, sizeof (uchar_t)); 2595 2596 /* if we got it then return it */ 2597 if (res == DDI_PROP_SUCCESS) { 2598 *nelements = prop_len / sizeof (uchar_t); 2599 *data = prop_val; 2600 2601 ddi_release_devi(dip); 2602 return (res); 2603 } 2604 } 2605 2606 /* call the normal property interfaces */ 2607 res = ddi_prop_lookup_byte_array(dev, dip, flags, 2608 name, data, nelements); 2609 2610 if (dip != NULL) 2611 ddi_release_devi(dip); 2612 2613 return (res); 2614 } 2615 2616 int 2617 ldi_prop_get_int(ldi_handle_t lh, 2618 uint_t flags, char *name, int defvalue) 2619 { 2620 struct ldi_handle *handlep = (struct ldi_handle *)lh; 2621 dev_info_t *dip; 2622 dev_t dev; 2623 int res; 2624 struct snode *csp; 2625 2626 if ((lh == NULL) || (name == NULL) || (strlen(name) == 0)) 2627 return (defvalue); 2628 2629 dev = handlep->lh_vp->v_rdev; 2630 2631 csp = VTOCS(handlep->lh_vp); 2632 mutex_enter(&csp->s_lock); 2633 if ((dip = csp->s_dip) != NULL) 2634 e_ddi_hold_devi(dip); 2635 mutex_exit(&csp->s_lock); 2636 if (dip == NULL) 2637 dip = e_ddi_hold_devi_by_dev(dev, 0); 2638 2639 if (dip == NULL) { 2640 flags |= DDI_UNBND_DLPI2; 2641 } else if (flags & LDI_DEV_T_ANY) { 2642 flags &= ~LDI_DEV_T_ANY; 2643 dev = DDI_DEV_T_ANY; 2644 } 2645 2646 if (dip != NULL) { 2647 int prop_val; 2648 int prop_len; 2649 2650 /* 2651 * first call the drivers prop_op interface to allow it 2652 * it to override default property values. 2653 */ 2654 prop_len = sizeof (int); 2655 res = i_ldi_prop_op(dev, dip, PROP_LEN_AND_VAL_BUF, 2656 flags | DDI_PROP_DYNAMIC, name, 2657 (caddr_t)&prop_val, &prop_len); 2658 2659 /* if we got it then return it */ 2660 if ((res == DDI_PROP_SUCCESS) && 2661 (prop_len == sizeof (int))) { 2662 res = prop_val; 2663 ddi_release_devi(dip); 2664 return (res); 2665 } 2666 } 2667 2668 /* call the normal property interfaces */ 2669 res = ddi_prop_get_int(dev, dip, flags, name, defvalue); 2670 2671 if (dip != NULL) 2672 ddi_release_devi(dip); 2673 2674 return (res); 2675 } 2676 2677 int64_t 2678 ldi_prop_get_int64(ldi_handle_t lh, 2679 uint_t flags, char *name, int64_t defvalue) 2680 { 2681 struct ldi_handle *handlep = (struct ldi_handle *)lh; 2682 dev_info_t *dip; 2683 dev_t dev; 2684 int64_t res; 2685 struct snode *csp; 2686 2687 if ((lh == NULL) || (name == NULL) || (strlen(name) == 0)) 2688 return (defvalue); 2689 2690 dev = handlep->lh_vp->v_rdev; 2691 2692 csp = VTOCS(handlep->lh_vp); 2693 mutex_enter(&csp->s_lock); 2694 if ((dip = csp->s_dip) != NULL) 2695 e_ddi_hold_devi(dip); 2696 mutex_exit(&csp->s_lock); 2697 if (dip == NULL) 2698 dip = e_ddi_hold_devi_by_dev(dev, 0); 2699 2700 if (dip == NULL) { 2701 flags |= DDI_UNBND_DLPI2; 2702 } else if (flags & LDI_DEV_T_ANY) { 2703 flags &= ~LDI_DEV_T_ANY; 2704 dev = DDI_DEV_T_ANY; 2705 } 2706 2707 if (dip != NULL) { 2708 int64_t prop_val; 2709 int prop_len; 2710 2711 /* 2712 * first call the drivers prop_op interface to allow it 2713 * it to override default property values. 2714 */ 2715 prop_len = sizeof (int64_t); 2716 res = i_ldi_prop_op(dev, dip, PROP_LEN_AND_VAL_BUF, 2717 flags | DDI_PROP_DYNAMIC, name, 2718 (caddr_t)&prop_val, &prop_len); 2719 2720 /* if we got it then return it */ 2721 if ((res == DDI_PROP_SUCCESS) && 2722 (prop_len == sizeof (int64_t))) { 2723 res = prop_val; 2724 ddi_release_devi(dip); 2725 return (res); 2726 } 2727 } 2728 2729 /* call the normal property interfaces */ 2730 res = ddi_prop_get_int64(dev, dip, flags, name, defvalue); 2731 2732 if (dip != NULL) 2733 ddi_release_devi(dip); 2734 2735 return (res); 2736 } 2737 2738 int 2739 ldi_prop_exists(ldi_handle_t lh, uint_t flags, char *name) 2740 { 2741 struct ldi_handle *handlep = (struct ldi_handle *)lh; 2742 dev_info_t *dip; 2743 dev_t dev; 2744 int res, prop_len; 2745 struct snode *csp; 2746 2747 if ((lh == NULL) || (name == NULL) || (strlen(name) == 0)) 2748 return (0); 2749 2750 dev = handlep->lh_vp->v_rdev; 2751 2752 csp = VTOCS(handlep->lh_vp); 2753 mutex_enter(&csp->s_lock); 2754 if ((dip = csp->s_dip) != NULL) 2755 e_ddi_hold_devi(dip); 2756 mutex_exit(&csp->s_lock); 2757 if (dip == NULL) 2758 dip = e_ddi_hold_devi_by_dev(dev, 0); 2759 2760 /* if NULL dip, prop does NOT exist */ 2761 if (dip == NULL) 2762 return (0); 2763 2764 if (flags & LDI_DEV_T_ANY) { 2765 flags &= ~LDI_DEV_T_ANY; 2766 dev = DDI_DEV_T_ANY; 2767 } 2768 2769 /* 2770 * first call the drivers prop_op interface to allow it 2771 * it to override default property values. 2772 */ 2773 res = i_ldi_prop_op(dev, dip, PROP_LEN, 2774 flags | DDI_PROP_DYNAMIC, name, NULL, &prop_len); 2775 2776 if (res == DDI_PROP_SUCCESS) { 2777 ddi_release_devi(dip); 2778 return (1); 2779 } 2780 2781 /* call the normal property interfaces */ 2782 res = ddi_prop_exists(dev, dip, flags, name); 2783 2784 ddi_release_devi(dip); 2785 return (res); 2786 } 2787 2788 #ifdef LDI_OBSOLETE_EVENT 2789 2790 int 2791 ldi_get_eventcookie(ldi_handle_t lh, char *name, ddi_eventcookie_t *ecp) 2792 { 2793 struct ldi_handle *handlep = (struct ldi_handle *)lh; 2794 dev_info_t *dip; 2795 dev_t dev; 2796 int res; 2797 struct snode *csp; 2798 2799 if ((lh == NULL) || (name == NULL) || 2800 (strlen(name) == 0) || (ecp == NULL)) { 2801 return (DDI_FAILURE); 2802 } 2803 2804 ASSERT(!servicing_interrupt()); 2805 2806 dev = handlep->lh_vp->v_rdev; 2807 2808 csp = VTOCS(handlep->lh_vp); 2809 mutex_enter(&csp->s_lock); 2810 if ((dip = csp->s_dip) != NULL) 2811 e_ddi_hold_devi(dip); 2812 mutex_exit(&csp->s_lock); 2813 if (dip == NULL) 2814 dip = e_ddi_hold_devi_by_dev(dev, 0); 2815 2816 if (dip == NULL) 2817 return (DDI_FAILURE); 2818 2819 LDI_EVENTCB((CE_NOTE, "%s: event_name=%s, " 2820 "dip=0x%p, event_cookiep=0x%p", "ldi_get_eventcookie", 2821 name, (void *)dip, (void *)ecp)); 2822 2823 res = ddi_get_eventcookie(dip, name, ecp); 2824 2825 ddi_release_devi(dip); 2826 return (res); 2827 } 2828 2829 int 2830 ldi_add_event_handler(ldi_handle_t lh, ddi_eventcookie_t ec, 2831 void (*handler)(ldi_handle_t, ddi_eventcookie_t, void *, void *), 2832 void *arg, ldi_callback_id_t *id) 2833 { 2834 struct ldi_handle *handlep = (struct ldi_handle *)lh; 2835 struct ldi_event *lep; 2836 dev_info_t *dip; 2837 dev_t dev; 2838 int res; 2839 struct snode *csp; 2840 2841 if ((lh == NULL) || (ec == NULL) || (handler == NULL) || (id == NULL)) 2842 return (DDI_FAILURE); 2843 2844 ASSERT(!servicing_interrupt()); 2845 2846 dev = handlep->lh_vp->v_rdev; 2847 2848 csp = VTOCS(handlep->lh_vp); 2849 mutex_enter(&csp->s_lock); 2850 if ((dip = csp->s_dip) != NULL) 2851 e_ddi_hold_devi(dip); 2852 mutex_exit(&csp->s_lock); 2853 if (dip == NULL) 2854 dip = e_ddi_hold_devi_by_dev(dev, 0); 2855 2856 if (dip == NULL) 2857 return (DDI_FAILURE); 2858 2859 lep = kmem_zalloc(sizeof (struct ldi_event), KM_SLEEP); 2860 lep->le_lhp = handlep; 2861 lep->le_arg = arg; 2862 lep->le_handler = handler; 2863 2864 if ((res = ddi_add_event_handler(dip, ec, i_ldi_callback, 2865 (void *)lep, &lep->le_id)) != DDI_SUCCESS) { 2866 LDI_EVENTCB((CE_WARN, "%s: unable to add" 2867 "event callback", "ldi_add_event_handler")); 2868 ddi_release_devi(dip); 2869 kmem_free(lep, sizeof (struct ldi_event)); 2870 return (res); 2871 } 2872 2873 *id = (ldi_callback_id_t)lep; 2874 2875 LDI_EVENTCB((CE_NOTE, "%s: dip=0x%p, event=0x%p, " 2876 "ldi_eventp=0x%p, cb_id=0x%p", "ldi_add_event_handler", 2877 (void *)dip, (void *)ec, (void *)lep, (void *)id)); 2878 2879 handle_event_add(lep); 2880 ddi_release_devi(dip); 2881 return (res); 2882 } 2883 2884 int 2885 ldi_remove_event_handler(ldi_handle_t lh, ldi_callback_id_t id) 2886 { 2887 ldi_event_t *lep = (ldi_event_t *)id; 2888 int res; 2889 2890 if ((lh == NULL) || (id == NULL)) 2891 return (DDI_FAILURE); 2892 2893 ASSERT(!servicing_interrupt()); 2894 2895 if ((res = ddi_remove_event_handler(lep->le_id)) 2896 != DDI_SUCCESS) { 2897 LDI_EVENTCB((CE_WARN, "%s: unable to remove " 2898 "event callback", "ldi_remove_event_handler")); 2899 return (res); 2900 } 2901 2902 handle_event_remove(lep); 2903 kmem_free(lep, sizeof (struct ldi_event)); 2904 return (res); 2905 } 2906 2907 #endif 2908 2909 /* 2910 * Here are some definitions of terms used in the following LDI events 2911 * code: 2912 * 2913 * "LDI events" AKA "native events": These are events defined by the 2914 * "new" LDI event framework. These events are serviced by the LDI event 2915 * framework itself and thus are native to it. 2916 * 2917 * "LDI contract events": These are contract events that correspond to the 2918 * LDI events. This mapping of LDI events to contract events is defined by 2919 * the ldi_ev_cookies[] array above. 2920 * 2921 * NDI events: These are events which are serviced by the NDI event subsystem. 2922 * LDI subsystem just provides a thin wrapper around the NDI event interfaces 2923 * These events are therefore *not* native events. 2924 */ 2925 2926 static int 2927 ldi_native_event(const char *evname) 2928 { 2929 int i; 2930 2931 LDI_EVTRC((CE_NOTE, "ldi_native_event: entered: ev=%s", evname)); 2932 2933 for (i = 0; ldi_ev_cookies[i].ck_evname != NULL; i++) { 2934 if (strcmp(ldi_ev_cookies[i].ck_evname, evname) == 0) 2935 return (1); 2936 } 2937 2938 return (0); 2939 } 2940 2941 static uint_t 2942 ldi_ev_sync_event(const char *evname) 2943 { 2944 int i; 2945 2946 ASSERT(ldi_native_event(evname)); 2947 2948 LDI_EVTRC((CE_NOTE, "ldi_ev_sync_event: entered: %s", evname)); 2949 2950 for (i = 0; ldi_ev_cookies[i].ck_evname != NULL; i++) { 2951 if (strcmp(ldi_ev_cookies[i].ck_evname, evname) == 0) 2952 return (ldi_ev_cookies[i].ck_sync); 2953 } 2954 2955 /* 2956 * This should never happen until non-contract based 2957 * LDI events are introduced. If that happens, we will 2958 * use a "special" token to indicate that there are no 2959 * contracts corresponding to this LDI event. 2960 */ 2961 cmn_err(CE_PANIC, "Unknown LDI event: %s", evname); 2962 2963 return (0); 2964 } 2965 2966 static uint_t 2967 ldi_contract_event(const char *evname) 2968 { 2969 int i; 2970 2971 ASSERT(ldi_native_event(evname)); 2972 2973 LDI_EVTRC((CE_NOTE, "ldi_contract_event: entered: %s", evname)); 2974 2975 for (i = 0; ldi_ev_cookies[i].ck_evname != NULL; i++) { 2976 if (strcmp(ldi_ev_cookies[i].ck_evname, evname) == 0) 2977 return (ldi_ev_cookies[i].ck_ctype); 2978 } 2979 2980 /* 2981 * This should never happen until non-contract based 2982 * LDI events are introduced. If that happens, we will 2983 * use a "special" token to indicate that there are no 2984 * contracts corresponding to this LDI event. 2985 */ 2986 cmn_err(CE_PANIC, "Unknown LDI event: %s", evname); 2987 2988 return (0); 2989 } 2990 2991 char * 2992 ldi_ev_get_type(ldi_ev_cookie_t cookie) 2993 { 2994 int i; 2995 struct ldi_ev_cookie *cookie_impl = (struct ldi_ev_cookie *)cookie; 2996 2997 for (i = 0; ldi_ev_cookies[i].ck_evname != NULL; i++) { 2998 if (&ldi_ev_cookies[i] == cookie_impl) { 2999 LDI_EVTRC((CE_NOTE, "ldi_ev_get_type: LDI: %s", 3000 ldi_ev_cookies[i].ck_evname)); 3001 return (ldi_ev_cookies[i].ck_evname); 3002 } 3003 } 3004 3005 /* 3006 * Not an LDI native event. Must be NDI event service. 3007 * Just return a generic string 3008 */ 3009 LDI_EVTRC((CE_NOTE, "ldi_ev_get_type: is NDI")); 3010 return (NDI_EVENT_SERVICE); 3011 } 3012 3013 static int 3014 ldi_native_cookie(ldi_ev_cookie_t cookie) 3015 { 3016 int i; 3017 struct ldi_ev_cookie *cookie_impl = (struct ldi_ev_cookie *)cookie; 3018 3019 for (i = 0; ldi_ev_cookies[i].ck_evname != NULL; i++) { 3020 if (&ldi_ev_cookies[i] == cookie_impl) { 3021 LDI_EVTRC((CE_NOTE, "ldi_native_cookie: native LDI")); 3022 return (1); 3023 } 3024 } 3025 3026 LDI_EVTRC((CE_NOTE, "ldi_native_cookie: is NDI")); 3027 return (0); 3028 } 3029 3030 static ldi_ev_cookie_t 3031 ldi_get_native_cookie(const char *evname) 3032 { 3033 int i; 3034 3035 for (i = 0; ldi_ev_cookies[i].ck_evname != NULL; i++) { 3036 if (strcmp(ldi_ev_cookies[i].ck_evname, evname) == 0) { 3037 LDI_EVTRC((CE_NOTE, "ldi_get_native_cookie: found")); 3038 return ((ldi_ev_cookie_t)&ldi_ev_cookies[i]); 3039 } 3040 } 3041 3042 LDI_EVTRC((CE_NOTE, "ldi_get_native_cookie: NOT found")); 3043 return (NULL); 3044 } 3045 3046 /* 3047 * ldi_ev_lock() needs to be recursive, since layered drivers may call 3048 * other LDI interfaces (such as ldi_close() from within the context of 3049 * a notify callback. Since the notify callback is called with the 3050 * ldi_ev_lock() held and ldi_close() also grabs ldi_ev_lock, the lock needs 3051 * to be recursive. 3052 */ 3053 static void 3054 ldi_ev_lock(void) 3055 { 3056 LDI_EVTRC((CE_NOTE, "ldi_ev_lock: entered")); 3057 3058 mutex_enter(&ldi_ev_callback_list.le_lock); 3059 if (ldi_ev_callback_list.le_thread == curthread) { 3060 ASSERT(ldi_ev_callback_list.le_busy >= 1); 3061 ldi_ev_callback_list.le_busy++; 3062 } else { 3063 while (ldi_ev_callback_list.le_busy) 3064 cv_wait(&ldi_ev_callback_list.le_cv, 3065 &ldi_ev_callback_list.le_lock); 3066 ASSERT(ldi_ev_callback_list.le_thread == NULL); 3067 ldi_ev_callback_list.le_busy = 1; 3068 ldi_ev_callback_list.le_thread = curthread; 3069 } 3070 mutex_exit(&ldi_ev_callback_list.le_lock); 3071 3072 LDI_EVTRC((CE_NOTE, "ldi_ev_lock: exit")); 3073 } 3074 3075 static void 3076 ldi_ev_unlock(void) 3077 { 3078 LDI_EVTRC((CE_NOTE, "ldi_ev_unlock: entered")); 3079 mutex_enter(&ldi_ev_callback_list.le_lock); 3080 ASSERT(ldi_ev_callback_list.le_thread == curthread); 3081 ASSERT(ldi_ev_callback_list.le_busy >= 1); 3082 3083 ldi_ev_callback_list.le_busy--; 3084 if (ldi_ev_callback_list.le_busy == 0) { 3085 ldi_ev_callback_list.le_thread = NULL; 3086 cv_signal(&ldi_ev_callback_list.le_cv); 3087 } 3088 mutex_exit(&ldi_ev_callback_list.le_lock); 3089 LDI_EVTRC((CE_NOTE, "ldi_ev_unlock: exit")); 3090 } 3091 3092 int 3093 ldi_ev_get_cookie(ldi_handle_t lh, char *evname, ldi_ev_cookie_t *cookiep) 3094 { 3095 struct ldi_handle *handlep = (struct ldi_handle *)lh; 3096 dev_info_t *dip; 3097 dev_t dev; 3098 int res; 3099 struct snode *csp; 3100 ddi_eventcookie_t ddi_cookie; 3101 ldi_ev_cookie_t tcookie; 3102 3103 LDI_EVDBG((CE_NOTE, "ldi_ev_get_cookie: entered: evname=%s", 3104 evname ? evname : "<NULL>")); 3105 3106 if (lh == NULL || evname == NULL || 3107 strlen(evname) == 0 || cookiep == NULL) { 3108 LDI_EVDBG((CE_NOTE, "ldi_ev_get_cookie: invalid args")); 3109 return (LDI_EV_FAILURE); 3110 } 3111 3112 *cookiep = NULL; 3113 3114 /* 3115 * First check if it is a LDI native event 3116 */ 3117 tcookie = ldi_get_native_cookie(evname); 3118 if (tcookie) { 3119 LDI_EVDBG((CE_NOTE, "ldi_ev_get_cookie: got native cookie")); 3120 *cookiep = tcookie; 3121 return (LDI_EV_SUCCESS); 3122 } 3123 3124 /* 3125 * Not a LDI native event. Try NDI event services 3126 */ 3127 3128 dev = handlep->lh_vp->v_rdev; 3129 3130 csp = VTOCS(handlep->lh_vp); 3131 mutex_enter(&csp->s_lock); 3132 if ((dip = csp->s_dip) != NULL) 3133 e_ddi_hold_devi(dip); 3134 mutex_exit(&csp->s_lock); 3135 if (dip == NULL) 3136 dip = e_ddi_hold_devi_by_dev(dev, 0); 3137 3138 if (dip == NULL) { 3139 cmn_err(CE_WARN, "ldi_ev_get_cookie: No devinfo node for LDI " 3140 "handle: %p", (void *)handlep); 3141 return (LDI_EV_FAILURE); 3142 } 3143 3144 LDI_EVDBG((CE_NOTE, "Calling ddi_get_eventcookie: dip=%p, ev=%s", 3145 (void *)dip, evname)); 3146 3147 res = ddi_get_eventcookie(dip, evname, &ddi_cookie); 3148 3149 ddi_release_devi(dip); 3150 3151 if (res == DDI_SUCCESS) { 3152 LDI_EVDBG((CE_NOTE, "ldi_ev_get_cookie: NDI cookie found")); 3153 *cookiep = (ldi_ev_cookie_t)ddi_cookie; 3154 return (LDI_EV_SUCCESS); 3155 } else { 3156 LDI_EVDBG((CE_WARN, "ldi_ev_get_cookie: NDI cookie: failed")); 3157 return (LDI_EV_FAILURE); 3158 } 3159 } 3160 3161 /*ARGSUSED*/ 3162 static void 3163 i_ldi_ev_callback(dev_info_t *dip, ddi_eventcookie_t event_cookie, 3164 void *arg, void *ev_data) 3165 { 3166 ldi_ev_callback_impl_t *lecp = (ldi_ev_callback_impl_t *)arg; 3167 3168 ASSERT(lecp != NULL); 3169 ASSERT(!ldi_native_cookie(lecp->lec_cookie)); 3170 ASSERT(lecp->lec_lhp); 3171 ASSERT(lecp->lec_notify == NULL); 3172 ASSERT(lecp->lec_finalize); 3173 3174 LDI_EVDBG((CE_NOTE, "i_ldi_ev_callback: ldh=%p, cookie=%p, arg=%p, " 3175 "ev_data=%p", (void *)lecp->lec_lhp, (void *)event_cookie, 3176 (void *)lecp->lec_arg, (void *)ev_data)); 3177 3178 lecp->lec_finalize(lecp->lec_lhp, (ldi_ev_cookie_t)event_cookie, 3179 lecp->lec_arg, ev_data); 3180 } 3181 3182 int 3183 ldi_ev_register_callbacks(ldi_handle_t lh, ldi_ev_cookie_t cookie, 3184 ldi_ev_callback_t *callb, void *arg, ldi_callback_id_t *id) 3185 { 3186 struct ldi_handle *lhp = (struct ldi_handle *)lh; 3187 ldi_ev_callback_impl_t *lecp; 3188 dev_t dev; 3189 struct snode *csp; 3190 dev_info_t *dip; 3191 int ddi_event; 3192 3193 ASSERT(!servicing_interrupt()); 3194 3195 if (lh == NULL || cookie == NULL || callb == NULL || id == NULL) { 3196 LDI_EVDBG((CE_NOTE, "ldi_ev_register_callbacks: Invalid args")); 3197 return (LDI_EV_FAILURE); 3198 } 3199 3200 if (callb->cb_vers != LDI_EV_CB_VERS) { 3201 LDI_EVDBG((CE_NOTE, "ldi_ev_register_callbacks: Invalid vers")); 3202 return (LDI_EV_FAILURE); 3203 } 3204 3205 if (callb->cb_notify == NULL && callb->cb_finalize == NULL) { 3206 LDI_EVDBG((CE_NOTE, "ldi_ev_register_callbacks: NULL callb")); 3207 return (LDI_EV_FAILURE); 3208 } 3209 3210 *id = 0; 3211 3212 dev = lhp->lh_vp->v_rdev; 3213 csp = VTOCS(lhp->lh_vp); 3214 mutex_enter(&csp->s_lock); 3215 if ((dip = csp->s_dip) != NULL) 3216 e_ddi_hold_devi(dip); 3217 mutex_exit(&csp->s_lock); 3218 if (dip == NULL) 3219 dip = e_ddi_hold_devi_by_dev(dev, 0); 3220 3221 if (dip == NULL) { 3222 cmn_err(CE_WARN, "ldi_ev_register: No devinfo node for " 3223 "LDI handle: %p", (void *)lhp); 3224 return (LDI_EV_FAILURE); 3225 } 3226 3227 lecp = kmem_zalloc(sizeof (ldi_ev_callback_impl_t), KM_SLEEP); 3228 3229 ddi_event = 0; 3230 if (!ldi_native_cookie(cookie)) { 3231 if (callb->cb_notify || callb->cb_finalize == NULL) { 3232 /* 3233 * NDI event services only accept finalize 3234 */ 3235 cmn_err(CE_WARN, "%s: module: %s: NDI event cookie. " 3236 "Only finalize" 3237 " callback supported with this cookie", 3238 "ldi_ev_register_callbacks", 3239 lhp->lh_ident->li_modname); 3240 kmem_free(lecp, sizeof (ldi_ev_callback_impl_t)); 3241 ddi_release_devi(dip); 3242 return (LDI_EV_FAILURE); 3243 } 3244 3245 if (ddi_add_event_handler(dip, (ddi_eventcookie_t)cookie, 3246 i_ldi_ev_callback, (void *)lecp, 3247 (ddi_callback_id_t *)&lecp->lec_id) 3248 != DDI_SUCCESS) { 3249 kmem_free(lecp, sizeof (ldi_ev_callback_impl_t)); 3250 ddi_release_devi(dip); 3251 LDI_EVDBG((CE_NOTE, "ldi_ev_register_callbacks(): " 3252 "ddi_add_event_handler failed")); 3253 return (LDI_EV_FAILURE); 3254 } 3255 ddi_event = 1; 3256 LDI_EVDBG((CE_NOTE, "ldi_ev_register_callbacks(): " 3257 "ddi_add_event_handler success")); 3258 } 3259 3260 3261 3262 ldi_ev_lock(); 3263 3264 /* 3265 * Add the notify/finalize callback to the LDI's list of callbacks. 3266 */ 3267 lecp->lec_lhp = lhp; 3268 lecp->lec_dev = lhp->lh_vp->v_rdev; 3269 lecp->lec_spec = VTYP_TO_STYP(lhp->lh_vp->v_type); 3270 lecp->lec_notify = callb->cb_notify; 3271 lecp->lec_finalize = callb->cb_finalize; 3272 lecp->lec_arg = arg; 3273 lecp->lec_cookie = cookie; 3274 if (!ddi_event) 3275 lecp->lec_id = (void *)(uintptr_t)(++ldi_ev_id_pool); 3276 else 3277 ASSERT(lecp->lec_id); 3278 lecp->lec_dip = dip; 3279 list_insert_tail(&ldi_ev_callback_list.le_head, lecp); 3280 3281 *id = (ldi_callback_id_t)lecp->lec_id; 3282 3283 ldi_ev_unlock(); 3284 3285 ddi_release_devi(dip); 3286 3287 LDI_EVDBG((CE_NOTE, "ldi_ev_register_callbacks: registered " 3288 "notify/finalize")); 3289 3290 return (LDI_EV_SUCCESS); 3291 } 3292 3293 static int 3294 ldi_ev_device_match(ldi_ev_callback_impl_t *lecp, dev_info_t *dip, 3295 dev_t dev, int spec_type) 3296 { 3297 ASSERT(lecp); 3298 ASSERT(dip); 3299 ASSERT(dev != DDI_DEV_T_NONE); 3300 ASSERT(dev != NODEV); 3301 ASSERT((dev == DDI_DEV_T_ANY && spec_type == 0) || 3302 (spec_type == S_IFCHR || spec_type == S_IFBLK)); 3303 ASSERT(lecp->lec_dip); 3304 ASSERT(lecp->lec_spec == S_IFCHR || lecp->lec_spec == S_IFBLK); 3305 ASSERT(lecp->lec_dev != DDI_DEV_T_ANY); 3306 ASSERT(lecp->lec_dev != DDI_DEV_T_NONE); 3307 ASSERT(lecp->lec_dev != NODEV); 3308 3309 if (dip != lecp->lec_dip) 3310 return (0); 3311 3312 if (dev != DDI_DEV_T_ANY) { 3313 if (dev != lecp->lec_dev || spec_type != lecp->lec_spec) 3314 return (0); 3315 } 3316 3317 LDI_EVTRC((CE_NOTE, "ldi_ev_device_match: MATCH dip=%p", (void *)dip)); 3318 3319 return (1); 3320 } 3321 3322 /* 3323 * LDI framework function to post a "notify" event to all layered drivers 3324 * that have registered for that event 3325 * 3326 * Returns: 3327 * LDI_EV_SUCCESS - registered callbacks allow event 3328 * LDI_EV_FAILURE - registered callbacks block event 3329 * LDI_EV_NONE - No matching LDI callbacks 3330 * 3331 * This function is *not* to be called by layered drivers. It is for I/O 3332 * framework code in Solaris, such as the I/O retire code and DR code 3333 * to call while servicing a device event such as offline or degraded. 3334 */ 3335 int 3336 ldi_invoke_notify(dev_info_t *dip, dev_t dev, int spec_type, char *event, 3337 void *ev_data) 3338 { 3339 ldi_ev_callback_impl_t *lecp; 3340 list_t *listp; 3341 int ret; 3342 char *lec_event; 3343 3344 ASSERT(dip); 3345 ASSERT(dev != DDI_DEV_T_NONE); 3346 ASSERT(dev != NODEV); 3347 ASSERT((dev == DDI_DEV_T_ANY && spec_type == 0) || 3348 (spec_type == S_IFCHR || spec_type == S_IFBLK)); 3349 ASSERT(event); 3350 ASSERT(ldi_native_event(event)); 3351 ASSERT(ldi_ev_sync_event(event)); 3352 3353 LDI_EVDBG((CE_NOTE, "ldi_invoke_notify(): entered: dip=%p, ev=%s", 3354 (void *)dip, event)); 3355 3356 ret = LDI_EV_NONE; 3357 ldi_ev_lock(); 3358 3359 VERIFY(ldi_ev_callback_list.le_walker_next == NULL); 3360 listp = &ldi_ev_callback_list.le_head; 3361 for (lecp = list_head(listp); lecp; lecp = 3362 ldi_ev_callback_list.le_walker_next) { 3363 ldi_ev_callback_list.le_walker_next = list_next(listp, lecp); 3364 3365 /* Check if matching device */ 3366 if (!ldi_ev_device_match(lecp, dip, dev, spec_type)) 3367 continue; 3368 3369 if (lecp->lec_lhp == NULL) { 3370 /* 3371 * Consumer has unregistered the handle and so 3372 * is no longer interested in notify events. 3373 */ 3374 LDI_EVDBG((CE_NOTE, "ldi_invoke_notify(): No LDI " 3375 "handle, skipping")); 3376 continue; 3377 } 3378 3379 if (lecp->lec_notify == NULL) { 3380 LDI_EVDBG((CE_NOTE, "ldi_invoke_notify(): No notify " 3381 "callback. skipping")); 3382 continue; /* not interested in notify */ 3383 } 3384 3385 /* 3386 * Check if matching event 3387 */ 3388 lec_event = ldi_ev_get_type(lecp->lec_cookie); 3389 if (strcmp(event, lec_event) != 0) { 3390 LDI_EVDBG((CE_NOTE, "ldi_invoke_notify(): Not matching" 3391 " event {%s,%s}. skipping", event, lec_event)); 3392 continue; 3393 } 3394 3395 lecp->lec_lhp->lh_flags |= LH_FLAGS_NOTIFY; 3396 if (lecp->lec_notify(lecp->lec_lhp, lecp->lec_cookie, 3397 lecp->lec_arg, ev_data) != LDI_EV_SUCCESS) { 3398 ret = LDI_EV_FAILURE; 3399 LDI_EVDBG((CE_NOTE, "ldi_invoke_notify(): notify" 3400 " FAILURE")); 3401 break; 3402 } 3403 3404 /* We have a matching callback that allows the event to occur */ 3405 ret = LDI_EV_SUCCESS; 3406 3407 LDI_EVDBG((CE_NOTE, "ldi_invoke_notify(): 1 consumer success")); 3408 } 3409 3410 if (ret != LDI_EV_FAILURE) 3411 goto out; 3412 3413 LDI_EVDBG((CE_NOTE, "ldi_invoke_notify(): undoing notify")); 3414 3415 /* 3416 * Undo notifies already sent 3417 */ 3418 lecp = list_prev(listp, lecp); 3419 VERIFY(ldi_ev_callback_list.le_walker_prev == NULL); 3420 for (; lecp; lecp = ldi_ev_callback_list.le_walker_prev) { 3421 ldi_ev_callback_list.le_walker_prev = list_prev(listp, lecp); 3422 3423 /* 3424 * Check if matching device 3425 */ 3426 if (!ldi_ev_device_match(lecp, dip, dev, spec_type)) 3427 continue; 3428 3429 3430 if (lecp->lec_finalize == NULL) { 3431 LDI_EVDBG((CE_NOTE, "ldi_invoke_notify(): no finalize, " 3432 "skipping")); 3433 continue; /* not interested in finalize */ 3434 } 3435 3436 /* 3437 * it is possible that in response to a notify event a 3438 * layered driver closed its LDI handle so it is ok 3439 * to have a NULL LDI handle for finalize. The layered 3440 * driver is expected to maintain state in its "arg" 3441 * parameter to keep track of the closed device. 3442 */ 3443 3444 /* Check if matching event */ 3445 lec_event = ldi_ev_get_type(lecp->lec_cookie); 3446 if (strcmp(event, lec_event) != 0) { 3447 LDI_EVDBG((CE_NOTE, "ldi_invoke_notify(): not matching " 3448 "event: %s,%s, skipping", event, lec_event)); 3449 continue; 3450 } 3451 3452 LDI_EVDBG((CE_NOTE, "ldi_invoke_notify(): calling finalize")); 3453 3454 lecp->lec_finalize(lecp->lec_lhp, lecp->lec_cookie, 3455 LDI_EV_FAILURE, lecp->lec_arg, ev_data); 3456 3457 /* 3458 * If LDI native event and LDI handle closed in context 3459 * of notify, NULL out the finalize callback as we have 3460 * already called the 1 finalize above allowed in this situation 3461 */ 3462 if (lecp->lec_lhp == NULL && 3463 ldi_native_cookie(lecp->lec_cookie)) { 3464 LDI_EVDBG((CE_NOTE, 3465 "ldi_invoke_notify(): NULL-ing finalize after " 3466 "calling 1 finalize following ldi_close")); 3467 lecp->lec_finalize = NULL; 3468 } 3469 } 3470 3471 out: 3472 ldi_ev_callback_list.le_walker_next = NULL; 3473 ldi_ev_callback_list.le_walker_prev = NULL; 3474 ldi_ev_unlock(); 3475 3476 if (ret == LDI_EV_NONE) { 3477 LDI_EVDBG((CE_NOTE, "ldi_invoke_notify(): no matching " 3478 "LDI callbacks")); 3479 } 3480 3481 return (ret); 3482 } 3483 3484 /* 3485 * Framework function to be called from a layered driver to propagate 3486 * LDI "notify" events to exported minors. 3487 * 3488 * This function is a public interface exported by the LDI framework 3489 * for use by layered drivers to propagate device events up the software 3490 * stack. 3491 */ 3492 int 3493 ldi_ev_notify(dev_info_t *dip, minor_t minor, int spec_type, 3494 ldi_ev_cookie_t cookie, void *ev_data) 3495 { 3496 char *evname = ldi_ev_get_type(cookie); 3497 uint_t ct_evtype; 3498 dev_t dev; 3499 major_t major; 3500 int retc; 3501 int retl; 3502 3503 ASSERT(spec_type == S_IFBLK || spec_type == S_IFCHR); 3504 ASSERT(dip); 3505 ASSERT(ldi_native_cookie(cookie)); 3506 3507 LDI_EVDBG((CE_NOTE, "ldi_ev_notify(): entered: event=%s, dip=%p", 3508 evname, (void *)dip)); 3509 3510 if (!ldi_ev_sync_event(evname)) { 3511 cmn_err(CE_PANIC, "ldi_ev_notify(): %s not a " 3512 "negotiatable event", evname); 3513 } 3514 3515 major = ddi_driver_major(dip); 3516 if (major == DDI_MAJOR_T_NONE) { 3517 char *path = kmem_alloc(MAXPATHLEN, KM_SLEEP); 3518 (void) ddi_pathname(dip, path); 3519 cmn_err(CE_WARN, "ldi_ev_notify: cannot derive major number " 3520 "for device %s", path); 3521 kmem_free(path, MAXPATHLEN); 3522 return (LDI_EV_FAILURE); 3523 } 3524 dev = makedevice(major, minor); 3525 3526 /* 3527 * Generate negotiation contract events on contracts (if any) associated 3528 * with this minor. 3529 */ 3530 LDI_EVDBG((CE_NOTE, "ldi_ev_notify(): calling contract nego.")); 3531 ct_evtype = ldi_contract_event(evname); 3532 retc = contract_device_negotiate(dip, dev, spec_type, ct_evtype); 3533 if (retc == CT_NACK) { 3534 LDI_EVDBG((CE_NOTE, "ldi_ev_notify(): contract neg. NACK")); 3535 return (LDI_EV_FAILURE); 3536 } 3537 3538 LDI_EVDBG((CE_NOTE, "ldi_ev_notify(): LDI invoke notify")); 3539 retl = ldi_invoke_notify(dip, dev, spec_type, evname, ev_data); 3540 if (retl == LDI_EV_FAILURE) { 3541 LDI_EVDBG((CE_NOTE, "ldi_ev_notify(): ldi_invoke_notify " 3542 "returned FAILURE. Calling contract negend")); 3543 contract_device_negend(dip, dev, spec_type, CT_EV_FAILURE); 3544 return (LDI_EV_FAILURE); 3545 } 3546 3547 /* 3548 * The very fact that we are here indicates that there is a 3549 * LDI callback (and hence a constraint) for the retire of the 3550 * HW device. So we just return success even if there are no 3551 * contracts or LDI callbacks against the minors layered on top 3552 * of the HW minors 3553 */ 3554 LDI_EVDBG((CE_NOTE, "ldi_ev_notify(): returning SUCCESS")); 3555 return (LDI_EV_SUCCESS); 3556 } 3557 3558 /* 3559 * LDI framework function to invoke "finalize" callbacks for all layered 3560 * drivers that have registered callbacks for that event. 3561 * 3562 * This function is *not* to be called by layered drivers. It is for I/O 3563 * framework code in Solaris, such as the I/O retire code and DR code 3564 * to call while servicing a device event such as offline or degraded. 3565 */ 3566 void 3567 ldi_invoke_finalize(dev_info_t *dip, dev_t dev, int spec_type, char *event, 3568 int ldi_result, void *ev_data) 3569 { 3570 ldi_ev_callback_impl_t *lecp; 3571 list_t *listp; 3572 char *lec_event; 3573 int found = 0; 3574 3575 ASSERT(dip); 3576 ASSERT(dev != DDI_DEV_T_NONE); 3577 ASSERT(dev != NODEV); 3578 ASSERT((dev == DDI_DEV_T_ANY && spec_type == 0) || 3579 (spec_type == S_IFCHR || spec_type == S_IFBLK)); 3580 ASSERT(event); 3581 ASSERT(ldi_native_event(event)); 3582 ASSERT(ldi_result == LDI_EV_SUCCESS || ldi_result == LDI_EV_FAILURE); 3583 3584 LDI_EVDBG((CE_NOTE, "ldi_invoke_finalize(): entered: dip=%p, result=%d" 3585 " event=%s", (void *)dip, ldi_result, event)); 3586 3587 ldi_ev_lock(); 3588 VERIFY(ldi_ev_callback_list.le_walker_next == NULL); 3589 listp = &ldi_ev_callback_list.le_head; 3590 for (lecp = list_head(listp); lecp; lecp = 3591 ldi_ev_callback_list.le_walker_next) { 3592 ldi_ev_callback_list.le_walker_next = list_next(listp, lecp); 3593 3594 if (lecp->lec_finalize == NULL) { 3595 LDI_EVDBG((CE_NOTE, "ldi_invoke_finalize(): No " 3596 "finalize. Skipping")); 3597 continue; /* Not interested in finalize */ 3598 } 3599 3600 /* 3601 * Check if matching device 3602 */ 3603 if (!ldi_ev_device_match(lecp, dip, dev, spec_type)) 3604 continue; 3605 3606 /* 3607 * It is valid for the LDI handle to be NULL during finalize. 3608 * The layered driver may have done an LDI close in the notify 3609 * callback. 3610 */ 3611 3612 /* 3613 * Check if matching event 3614 */ 3615 lec_event = ldi_ev_get_type(lecp->lec_cookie); 3616 if (strcmp(event, lec_event) != 0) { 3617 LDI_EVDBG((CE_NOTE, "ldi_invoke_finalize(): Not " 3618 "matching event {%s,%s}. Skipping", 3619 event, lec_event)); 3620 continue; 3621 } 3622 3623 LDI_EVDBG((CE_NOTE, "ldi_invoke_finalize(): calling finalize")); 3624 3625 found = 1; 3626 3627 lecp->lec_finalize(lecp->lec_lhp, lecp->lec_cookie, 3628 ldi_result, lecp->lec_arg, ev_data); 3629 3630 /* 3631 * If LDI native event and LDI handle closed in context 3632 * of notify, NULL out the finalize callback as we have 3633 * already called the 1 finalize above allowed in this situation 3634 */ 3635 if (lecp->lec_lhp == NULL && 3636 ldi_native_cookie(lecp->lec_cookie)) { 3637 LDI_EVDBG((CE_NOTE, 3638 "ldi_invoke_finalize(): NULLing finalize after " 3639 "calling 1 finalize following ldi_close")); 3640 lecp->lec_finalize = NULL; 3641 } 3642 } 3643 ldi_ev_callback_list.le_walker_next = NULL; 3644 ldi_ev_unlock(); 3645 3646 if (found) 3647 return; 3648 3649 LDI_EVDBG((CE_NOTE, "ldi_invoke_finalize(): no matching callbacks")); 3650 } 3651 3652 /* 3653 * Framework function to be called from a layered driver to propagate 3654 * LDI "finalize" events to exported minors. 3655 * 3656 * This function is a public interface exported by the LDI framework 3657 * for use by layered drivers to propagate device events up the software 3658 * stack. 3659 */ 3660 void 3661 ldi_ev_finalize(dev_info_t *dip, minor_t minor, int spec_type, int ldi_result, 3662 ldi_ev_cookie_t cookie, void *ev_data) 3663 { 3664 dev_t dev; 3665 major_t major; 3666 char *evname; 3667 int ct_result = (ldi_result == LDI_EV_SUCCESS) ? 3668 CT_EV_SUCCESS : CT_EV_FAILURE; 3669 uint_t ct_evtype; 3670 3671 ASSERT(dip); 3672 ASSERT(spec_type == S_IFBLK || spec_type == S_IFCHR); 3673 ASSERT(ldi_result == LDI_EV_SUCCESS || ldi_result == LDI_EV_FAILURE); 3674 ASSERT(ldi_native_cookie(cookie)); 3675 3676 LDI_EVDBG((CE_NOTE, "ldi_ev_finalize: entered: dip=%p", (void *)dip)); 3677 3678 major = ddi_driver_major(dip); 3679 if (major == DDI_MAJOR_T_NONE) { 3680 char *path = kmem_alloc(MAXPATHLEN, KM_SLEEP); 3681 (void) ddi_pathname(dip, path); 3682 cmn_err(CE_WARN, "ldi_ev_finalize: cannot derive major number " 3683 "for device %s", path); 3684 kmem_free(path, MAXPATHLEN); 3685 return; 3686 } 3687 dev = makedevice(major, minor); 3688 3689 evname = ldi_ev_get_type(cookie); 3690 3691 LDI_EVDBG((CE_NOTE, "ldi_ev_finalize: calling contracts")); 3692 ct_evtype = ldi_contract_event(evname); 3693 contract_device_finalize(dip, dev, spec_type, ct_evtype, ct_result); 3694 3695 LDI_EVDBG((CE_NOTE, "ldi_ev_finalize: calling ldi_invoke_finalize")); 3696 ldi_invoke_finalize(dip, dev, spec_type, evname, ldi_result, ev_data); 3697 } 3698 3699 int 3700 ldi_ev_remove_callbacks(ldi_callback_id_t id) 3701 { 3702 ldi_ev_callback_impl_t *lecp; 3703 ldi_ev_callback_impl_t *next; 3704 ldi_ev_callback_impl_t *found; 3705 list_t *listp; 3706 3707 ASSERT(!servicing_interrupt()); 3708 3709 if (id == 0) { 3710 cmn_err(CE_WARN, "ldi_ev_remove_callbacks: Invalid ID 0"); 3711 return (LDI_EV_FAILURE); 3712 } 3713 3714 LDI_EVDBG((CE_NOTE, "ldi_ev_remove_callbacks: entered: id=%p", 3715 (void *)id)); 3716 3717 ldi_ev_lock(); 3718 3719 listp = &ldi_ev_callback_list.le_head; 3720 next = found = NULL; 3721 for (lecp = list_head(listp); lecp; lecp = next) { 3722 next = list_next(listp, lecp); 3723 if (lecp->lec_id == id) { 3724 VERIFY(found == NULL); 3725 3726 /* 3727 * If there is a walk in progress, shift that walk 3728 * along to the next element so that we can remove 3729 * this one. This allows us to unregister an arbitrary 3730 * number of callbacks from within a callback. 3731 * 3732 * See the struct definition (in sunldi_impl.h) for 3733 * more information. 3734 */ 3735 if (ldi_ev_callback_list.le_walker_next == lecp) 3736 ldi_ev_callback_list.le_walker_next = next; 3737 if (ldi_ev_callback_list.le_walker_prev == lecp) 3738 ldi_ev_callback_list.le_walker_prev = list_prev( 3739 listp, ldi_ev_callback_list.le_walker_prev); 3740 3741 list_remove(listp, lecp); 3742 found = lecp; 3743 } 3744 } 3745 ldi_ev_unlock(); 3746 3747 if (found == NULL) { 3748 cmn_err(CE_WARN, "No LDI event handler for id (%p)", 3749 (void *)id); 3750 return (LDI_EV_SUCCESS); 3751 } 3752 3753 if (!ldi_native_cookie(found->lec_cookie)) { 3754 ASSERT(found->lec_notify == NULL); 3755 if (ddi_remove_event_handler((ddi_callback_id_t)id) 3756 != DDI_SUCCESS) { 3757 cmn_err(CE_WARN, "failed to remove NDI event handler " 3758 "for id (%p)", (void *)id); 3759 ldi_ev_lock(); 3760 list_insert_tail(listp, found); 3761 ldi_ev_unlock(); 3762 return (LDI_EV_FAILURE); 3763 } 3764 LDI_EVDBG((CE_NOTE, "ldi_ev_remove_callbacks: NDI event " 3765 "service removal succeeded")); 3766 } else { 3767 LDI_EVDBG((CE_NOTE, "ldi_ev_remove_callbacks: removed " 3768 "LDI native callbacks")); 3769 } 3770 kmem_free(found, sizeof (ldi_ev_callback_impl_t)); 3771 3772 return (LDI_EV_SUCCESS); 3773 } 3774