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