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