xref: /illumos-gate/usr/src/uts/common/os/driver_lyr.c (revision 3df2e8b2)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved.
23  */
24 /*
25  * Copyright 2019 Joyent, Inc.
26  */
27 
28 /*
29  * Layered driver support.
30  */
31 
32 #include <sys/atomic.h>
33 #include <sys/types.h>
34 #include <sys/t_lock.h>
35 #include <sys/param.h>
36 #include <sys/conf.h>
37 #include <sys/systm.h>
38 #include <sys/sysmacros.h>
39 #include <sys/buf.h>
40 #include <sys/cred.h>
41 #include <sys/uio.h>
42 #include <sys/vnode.h>
43 #include <sys/fs/snode.h>
44 #include <sys/open.h>
45 #include <sys/kmem.h>
46 #include <sys/file.h>
47 #include <sys/bootconf.h>
48 #include <sys/pathname.h>
49 #include <sys/bitmap.h>
50 #include <sys/stat.h>
51 #include <sys/dditypes.h>
52 #include <sys/ddi_impldefs.h>
53 #include <sys/ddi.h>
54 #include <sys/sunddi.h>
55 #include <sys/sunndi.h>
56 #include <sys/esunddi.h>
57 #include <sys/autoconf.h>
58 #include <sys/sunldi.h>
59 #include <sys/sunldi_impl.h>
60 #include <sys/errno.h>
61 #include <sys/debug.h>
62 #include <sys/modctl.h>
63 #include <sys/var.h>
64 #include <vm/seg_vn.h>
65 
66 #include <sys/stropts.h>
67 #include <sys/strsubr.h>
68 #include <sys/socket.h>
69 #include <sys/socketvar.h>
70 #include <sys/kstr.h>
71 
72 /*
73  * Device contract related
74  */
75 #include <sys/contract_impl.h>
76 #include <sys/contract/device_impl.h>
77 
78 /*
79  * Define macros to manipulate snode, vnode, and open device flags
80  */
81 #define	VTYP_VALID(i)	(((i) == VCHR) || ((i) == VBLK))
82 #define	VTYP_TO_OTYP(i)	(((i) == VCHR) ? OTYP_CHR : OTYP_BLK)
83 #define	VTYP_TO_STYP(i)	(((i) == VCHR) ? S_IFCHR : S_IFBLK)
84 
85 #define	OTYP_VALID(i)	(((i) == OTYP_CHR) || ((i) == OTYP_BLK))
86 #define	OTYP_TO_VTYP(i)	(((i) == OTYP_CHR) ? VCHR : VBLK)
87 #define	OTYP_TO_STYP(i)	(((i) == OTYP_CHR) ? S_IFCHR : S_IFBLK)
88 
89 #define	STYP_VALID(i)	(((i) == S_IFCHR) || ((i) == S_IFBLK))
90 #define	STYP_TO_VTYP(i)	(((i) == S_IFCHR) ? VCHR : VBLK)
91 
92 /*
93  * Define macros for accessing layered driver hash structures
94  */
95 #define	LH_HASH(vp)		(handle_hash_func(vp) % LH_HASH_SZ)
96 #define	LI_HASH(mid, dip, dev)	(ident_hash_func(mid, dip, dev) % LI_HASH_SZ)
97 
98 /*
99  * Define layered handle flags used in the lh_type field
100  */
101 #define	LH_STREAM	(0x1)	/* handle to a streams device */
102 #define	LH_CBDEV	(0x2)	/* handle to a char/block device */
103 
104 /*
105  * Define macro for devid property lookups
106  */
107 #define	DEVID_PROP_FLAGS	(DDI_PROP_DONTPASS | \
108 				DDI_PROP_TYPE_STRING|DDI_PROP_CANSLEEP)
109 
110 /*
111  * Dummy string for NDI events
112  */
113 #define	NDI_EVENT_SERVICE	"NDI_EVENT_SERVICE"
114 
115 static void ldi_ev_lock(void);
116 static void ldi_ev_unlock(void);
117 
118 #ifdef	LDI_OBSOLETE_EVENT
119 int ldi_remove_event_handler(ldi_handle_t lh, ldi_callback_id_t id);
120 #endif
121 
122 
123 /*
124  * globals
125  */
126 static kmutex_t			ldi_ident_hash_lock[LI_HASH_SZ];
127 static struct ldi_ident		*ldi_ident_hash[LI_HASH_SZ];
128 
129 static kmutex_t			ldi_handle_hash_lock[LH_HASH_SZ];
130 static struct ldi_handle	*ldi_handle_hash[LH_HASH_SZ];
131 static size_t			ldi_handle_hash_count;
132 
133 /*
134  * Use of "ldi_ev_callback_list" must be protected by ldi_ev_lock()
135  * and ldi_ev_unlock().
136  */
137 static struct ldi_ev_callback_list ldi_ev_callback_list;
138 
139 static uint32_t ldi_ev_id_pool = 0;
140 
141 struct ldi_ev_cookie {
142 	char *ck_evname;
143 	uint_t ck_sync;
144 	uint_t ck_ctype;
145 };
146 
147 static struct ldi_ev_cookie ldi_ev_cookies[] = {
148 	{ LDI_EV_OFFLINE, 1, CT_DEV_EV_OFFLINE},
149 	{ LDI_EV_DEGRADE, 0, CT_DEV_EV_DEGRADED},
150 	{ LDI_EV_DEVICE_REMOVE, 0, 0},
151 	{ NULL}			/* must terminate list */
152 };
153 
154 void
ldi_init(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
ident_hash_func(modid_t modid,dev_info_t * dip,dev_t dev)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 **
ident_find_ref_nolock(modid_t modid,dev_info_t * dip,dev_t dev,major_t major)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 *
ident_alloc(char * mod_name,dev_info_t * dip,dev_t dev,major_t major)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
ident_hold(struct ldi_ident * lip)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
ident_release(struct ldi_ident * lip)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
handle_hash_func(void * vp)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 **
handle_find_ref_nolock(vnode_t * vp,struct ldi_ident * ident)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 *
handle_find(vnode_t * vp,struct ldi_ident * ident)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 *
handle_alloc(vnode_t * vp,struct ldi_ident * ident)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
handle_release(struct ldi_handle * lhp)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
handle_event_add(ldi_event_t * lep)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
handle_event_remove(ldi_event_t * lep)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
i_ldi_callback(dev_info_t * dip,ddi_eventcookie_t event_cookie,void * arg,void * bus_impldata)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
ldi_vp_from_dev(dev_t dev,int otyp,vnode_t ** vpp)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
ldi_vp_from_name(char * path,vnode_t ** vpp)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
ldi_devid_match(ddi_devid_t devid,dev_info_t * dip,dev_t dev)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
ldi_vp_from_devid(ddi_devid_t devid,char * minor_name,vnode_t ** vpp)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
ldi_open_by_vp(vnode_t ** vpp,int flag,cred_t * cr,ldi_handle_t * lhp,struct ldi_ident * li)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
i_ldi_prop_op(dev_t dev,dev_info_t * dip,ddi_prop_op_t prop_op,int flags,char * name,caddr_t valuep,int * lengthp)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
i_ldi_prop_op_free(struct prop_driver_data * pdd)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
i_ldi_prop_op_alloc(int prop_len)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
i_ldi_prop_op_typed(dev_t dev,dev_info_t * dip,int flags,char * name,caddr_t * datap,int * lengthp,int elem_size)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
i_check_string(char * str,int prop_len)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
i_pack_string_array(char * str_concat,int prop_len,char *** str_arrayp,int * nelemp)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
ldi_usage_count()1000 ldi_usage_count()
1001 {
1002 	return (ldi_handle_hash_count);
1003 }
1004 
1005 static void
ldi_usage_walker_tgt_helper(ldi_usage_t * ldi_usage,vnode_t * vp)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
ldi_usage_walker_helper(struct ldi_ident * lip,vnode_t * vp,void * arg,int (* callback)(const ldi_usage_t *,void *))1034 ldi_usage_walker_helper(struct ldi_ident *lip, vnode_t *vp,
1035     void *arg, int (*callback)(const ldi_usage_t *, void *))
1036 {
1037 	ldi_usage_t	ldi_usage;
1038 	struct devnames	*dnp;
1039 	dev_info_t	*dip;
1040 	major_t		major;
1041 	dev_t		dev;
1042 	int		ret = LDI_USAGE_CONTINUE;
1043 
1044 	/* set the target device information */
1045 	ldi_usage_walker_tgt_helper(&ldi_usage, vp);
1046 
1047 	/* get the source devt */
1048 	dev = lip->li_dev;
1049 
1050 	/* try to get the source dip */
1051 	dip = lip->li_dip;
1052 	if (dip != NULL) {
1053 		e_ddi_hold_devi(dip);
1054 	} else if (dev != DDI_DEV_T_NONE) {
1055 		dip = e_ddi_hold_devi_by_dev(dev, 0);
1056 	}
1057 
1058 	/* set the valid source information */
1059 	ldi_usage.src_modid = lip->li_modid;
1060 	ldi_usage.src_name = lip->li_modname;
1061 	ldi_usage.src_devt = dev;
1062 	ldi_usage.src_dip = dip;
1063 
1064 	/*
1065 	 * if the source ident represents either:
1066 	 *
1067 	 * - a kernel module (and not a device or device driver)
1068 	 * - a device node
1069 	 *
1070 	 * then we currently have all the info we need to report the
1071 	 * usage information so invoke the callback function.
1072 	 */
1073 	if (((lip->li_major == -1) && (dev == DDI_DEV_T_NONE)) ||
1074 	    (dip != NULL)) {
1075 		ret = callback(&ldi_usage, arg);
1076 		if (dip != NULL)
1077 			ddi_release_devi(dip);
1078 		if (ldi_usage.tgt_dip != NULL)
1079 			ddi_release_devi(ldi_usage.tgt_dip);
1080 		return (ret);
1081 	}
1082 
1083 	/*
1084 	 * now this is kinda gross.
1085 	 *
1086 	 * what we do here is attempt to associate every device instance
1087 	 * of the source driver on the system with the open target driver.
1088 	 * we do this because we don't know which instance of the device
1089 	 * could potentially access the lower device so we assume that all
1090 	 * the instances could access it.
1091 	 *
1092 	 * there are two ways we could have gotten here:
1093 	 *
1094 	 * 1) this layered ident represents one created using only a
1095 	 *    major number or a driver module name.  this means that when
1096 	 *    it was created we could not associate it with a particular
1097 	 *    dev_t or device instance.
1098 	 *
1099 	 *    when could this possibly happen you ask?
1100 	 *
1101 	 *    a perfect example of this is streams persistent links.
1102 	 *    when a persistant streams link is formed we can't associate
1103 	 *    the lower device stream with any particular upper device
1104 	 *    stream or instance.  this is because any particular upper
1105 	 *    device stream could be closed, then another could be
1106 	 *    opened with a different dev_t and device instance, and it
1107 	 *    would still have access to the lower linked stream.
1108 	 *
1109 	 *    since any instance of the upper streams driver could
1110 	 *    potentially access the lower stream whenever it wants,
1111 	 *    we represent that here by associating the opened lower
1112 	 *    device with every existing device instance of the upper
1113 	 *    streams driver.
1114 	 *
1115 	 * 2) This case should really never happen but we'll include it
1116 	 *    for completeness.
1117 	 *
1118 	 *    it's possible that we could have gotten here because we
1119 	 *    have a dev_t for the upper device but we couldn't find a
1120 	 *    dip associated with that dev_t.
1121 	 *
1122 	 *    the only types of devices that have dev_t without an
1123 	 *    associated dip are unbound DLPIv2 network devices.  These
1124 	 *    types of devices exist to be able to attach a stream to any
1125 	 *    instance of a hardware network device.  since these types of
1126 	 *    devices are usually hardware devices they should never
1127 	 *    really have other devices open.
1128 	 */
1129 	if (dev != DDI_DEV_T_NONE)
1130 		major = getmajor(dev);
1131 	else
1132 		major = lip->li_major;
1133 
1134 	ASSERT3U(major, <, devcnt);
1135 
1136 	dnp = &devnamesp[major];
1137 	LOCK_DEV_OPS(&dnp->dn_lock);
1138 	dip = dnp->dn_head;
1139 	while ((dip) && (ret == LDI_USAGE_CONTINUE)) {
1140 		e_ddi_hold_devi(dip);
1141 		UNLOCK_DEV_OPS(&dnp->dn_lock);
1142 
1143 		/* set the source dip */
1144 		ldi_usage.src_dip = dip;
1145 
1146 		/* invoke the callback function */
1147 		ret = callback(&ldi_usage, arg);
1148 
1149 		LOCK_DEV_OPS(&dnp->dn_lock);
1150 		ddi_release_devi(dip);
1151 		dip = ddi_get_next(dip);
1152 	}
1153 	UNLOCK_DEV_OPS(&dnp->dn_lock);
1154 
1155 	/* if there was a target dip, release it */
1156 	if (ldi_usage.tgt_dip != NULL)
1157 		ddi_release_devi(ldi_usage.tgt_dip);
1158 
1159 	return (ret);
1160 }
1161 
1162 /*
1163  * ldi_usage_walker() - this walker reports LDI kernel device usage
1164  * information via the callback() callback function.  the LDI keeps track
1165  * of what devices are being accessed in its own internal data structures.
1166  * this function walks those data structures to determine device usage.
1167  */
1168 void
ldi_usage_walker(void * arg,int (* callback)(const ldi_usage_t *,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
ldi_mlink_lh(vnode_t * vp,int cmd,intptr_t arg,cred_t * crp,int * rvalp)1219 ldi_mlink_lh(vnode_t *vp, int cmd, intptr_t arg, cred_t *crp, int *rvalp)
1220 {
1221 	struct ldi_handle	*lhp = (struct ldi_handle *)arg;
1222 	vnode_t			*vpdown;
1223 	file_t			*fpdown;
1224 	int			err;
1225 
1226 	if (lhp == NULL)
1227 		return (EINVAL);
1228 
1229 	vpdown = lhp->lh_vp;
1230 	ASSERT(vn_matchops(vpdown, spec_getvnodeops()));
1231 	ASSERT(cmd == _I_PLINK_LH);
1232 
1233 	/*
1234 	 * create a new lower vnode and a file_t that points to it,
1235 	 * streams linking requires a file_t.  falloc() returns with
1236 	 * fpdown locked.
1237 	 */
1238 	VN_HOLD(vpdown);
1239 	(void) falloc(vpdown, FREAD|FWRITE, &fpdown, NULL);
1240 	mutex_exit(&fpdown->f_tlock);
1241 
1242 	/* try to establish the link */
1243 	err = mlink_file(vp, I_PLINK, fpdown, crp, rvalp, 1);
1244 
1245 	if (err != 0) {
1246 		/* the link failed, free the file_t and release the vnode */
1247 		mutex_enter(&fpdown->f_tlock);
1248 		unfalloc(fpdown);
1249 		VN_RELE(vpdown);
1250 	}
1251 
1252 	return (err);
1253 }
1254 
1255 /*
1256  * ldi_mlink_fp() is invoked for all successful streams linkages created
1257  * via I_LINK and I_PLINK.  ldi_mlink_fp() records the linkage information
1258  * in its internal state so that the devinfo snapshot code has some
1259  * observability into streams device linkage information.
1260  */
1261 int
ldi_mlink_fp(struct stdata * stp,file_t * fpdown,int lhlink,int type)1262 ldi_mlink_fp(struct stdata *stp, file_t *fpdown, int lhlink, int type)
1263 {
1264 	vnode_t			*vp = fpdown->f_vnode;
1265 	struct snode		*sp, *csp;
1266 	ldi_ident_t		li;
1267 	major_t			major;
1268 	int			ret;
1269 
1270 	/*
1271 	 * If the lower stream is not a device then return but claim to have
1272 	 * succeeded, which matches our historical behaviour of just not
1273 	 * setting up LDI in this case.
1274 	 */
1275 	if (!vn_matchops(vp, spec_getvnodeops()))
1276 		return (0);
1277 
1278 	ASSERT(!servicing_interrupt());
1279 
1280 	LDI_STREAMS_LNK((CE_NOTE, "%s: linking streams "
1281 	    "stp=0x%p, fpdown=0x%p", "ldi_mlink_fp",
1282 	    (void *)stp, (void *)fpdown));
1283 
1284 	sp = VTOS(vp);
1285 	csp = VTOS(sp->s_commonvp);
1286 
1287 	/* get a layered ident for the upper stream */
1288 	if (type == LINKNORMAL) {
1289 		/*
1290 		 * if the link is not persistant then we can associate
1291 		 * the upper stream with a dev_t.  this is because the
1292 		 * upper stream is associated with a vnode, which is
1293 		 * associated with a dev_t and this binding can't change
1294 		 * during the life of the stream.  since the link isn't
1295 		 * persistant once the stream is destroyed the link is
1296 		 * destroyed.  so the dev_t will be valid for the life
1297 		 * of the link.
1298 		 */
1299 		ret = ldi_ident_from_stream(getendq(stp->sd_wrq), &li);
1300 	} else {
1301 		/*
1302 		 * if the link is persistant we can only associate the
1303 		 * link with a driver (and not a dev_t.)  this is
1304 		 * because subsequent opens of the upper device may result
1305 		 * in a different stream (and dev_t) having access to
1306 		 * the lower stream.
1307 		 *
1308 		 * for example, if the upper stream is closed after the
1309 		 * persistant link operation is completed, a subsequent
1310 		 * open of the upper device will create a new stream which
1311 		 * may have a different dev_t and an unlink operation
1312 		 * can be performed using this new upper stream.
1313 		 */
1314 		VERIFY3S(type, ==, LINKPERSIST);
1315 		major = getmajor(stp->sd_vnode->v_rdev);
1316 		ret = ldi_ident_from_major(major, &li);
1317 	}
1318 
1319 	if (ret != 0)
1320 		return (ret);
1321 
1322 	/* check if this was a plink via a layered handle */
1323 	if (lhlink) {
1324 		/*
1325 		 * increment the common snode s_count.
1326 		 *
1327 		 * this is done because after the link operation there
1328 		 * are two ways that s_count can be decremented.
1329 		 *
1330 		 * when the layered handle used to create the link is
1331 		 * closed, spec_close() is called and it will decrement
1332 		 * s_count in the common snode.  if we don't increment
1333 		 * s_count here then this could cause spec_close() to
1334 		 * actually close the device while it's still linked
1335 		 * under a multiplexer.
1336 		 *
1337 		 * also, when the lower stream is unlinked, closef() is
1338 		 * called for the file_t associated with this snode.
1339 		 * closef() will call spec_close(), which will decrement
1340 		 * s_count.  if we dont't increment s_count here then this
1341 		 * could cause spec_close() to actually close the device
1342 		 * while there may still be valid layered handles
1343 		 * pointing to it.
1344 		 */
1345 		VERIFY3S(type, ==, LINKPERSIST);
1346 
1347 		mutex_enter(&csp->s_lock);
1348 		VERIFY(csp->s_count >= 1);
1349 		csp->s_count++;
1350 		mutex_exit(&csp->s_lock);
1351 
1352 		/*
1353 		 * decrement the f_count.
1354 		 * this is done because the layered driver framework does
1355 		 * not actually cache a copy of the file_t allocated to
1356 		 * do the link.  this is done here instead of in ldi_mlink_lh()
1357 		 * because there is a window in ldi_mlink_lh() between where
1358 		 * milnk_file() returns and we would decrement the f_count
1359 		 * when the stream could be unlinked.
1360 		 */
1361 		mutex_enter(&fpdown->f_tlock);
1362 		fpdown->f_count--;
1363 		mutex_exit(&fpdown->f_tlock);
1364 	}
1365 
1366 	/*
1367 	 * NOTE: here we rely on the streams subsystem not allowing
1368 	 * a stream to be multiplexed more than once.  if this
1369 	 * changes, we break.
1370 	 *
1371 	 * mark the snode/stream as multiplexed
1372 	 */
1373 	mutex_enter(&sp->s_lock);
1374 	VERIFY(!(sp->s_flag & SMUXED));
1375 	sp->s_flag |= SMUXED;
1376 	mutex_exit(&sp->s_lock);
1377 
1378 	(void) handle_alloc(vp, (struct ldi_ident *)li);
1379 	ldi_ident_release(li);
1380 
1381 	return (0);
1382 }
1383 
1384 int
ldi_munlink_fp(struct stdata * stp,file_t * fpdown,int type)1385 ldi_munlink_fp(struct stdata *stp, file_t *fpdown, int type)
1386 {
1387 	struct ldi_handle	*lhp;
1388 	vnode_t			*vp = (vnode_t *)fpdown->f_vnode;
1389 	struct snode		*sp;
1390 	ldi_ident_t		li;
1391 	major_t			major;
1392 	int			ret;
1393 
1394 	/*
1395 	 * If the lower stream is not a device then return but claim to have
1396 	 * succeeded, which matches our historical behaviour of just not
1397 	 * setting up LDI in this case.
1398 	 */
1399 	if (!vn_matchops(vp, spec_getvnodeops()))
1400 		return (0);
1401 
1402 	ASSERT(!servicing_interrupt());
1403 
1404 	LDI_STREAMS_LNK((CE_NOTE, "%s: unlinking streams "
1405 	    "stp=0x%p, fpdown=0x%p", "ldi_munlink_fp",
1406 	    (void *)stp, (void *)fpdown));
1407 
1408 	/*
1409 	 * clear the owner for this snode
1410 	 * see the comment in ldi_mlink_fp() for information about how
1411 	 * the ident is allocated
1412 	 */
1413 	if (type == LINKNORMAL) {
1414 		ret = ldi_ident_from_stream(getendq(stp->sd_wrq), &li);
1415 	} else {
1416 		VERIFY3S(type, ==, LINKPERSIST);
1417 		major = getmajor(stp->sd_vnode->v_rdev);
1418 		ret = ldi_ident_from_major(major, &li);
1419 	}
1420 
1421 	if (ret != 0)
1422 		return (ret);
1423 
1424 	/*
1425 	 * NOTE: here we rely on the streams subsystem not allowing
1426 	 * a stream to be multiplexed more than once.  if this
1427 	 * changes, we break.
1428 	 *
1429 	 * mark the snode/stream as not multiplexed
1430 	 */
1431 	sp = VTOS(vp);
1432 	mutex_enter(&sp->s_lock);
1433 	VERIFY(sp->s_flag & SMUXED);
1434 	sp->s_flag &= ~SMUXED;
1435 	mutex_exit(&sp->s_lock);
1436 
1437 	lhp = handle_find(vp, (struct ldi_ident *)li);
1438 	handle_release(lhp);
1439 	ldi_ident_release(li);
1440 
1441 	return (0);
1442 }
1443 
1444 /*
1445  * LDI Consolidation private interfaces
1446  */
1447 int
ldi_ident_from_mod(struct modlinkage * modlp,ldi_ident_t * lip)1448 ldi_ident_from_mod(struct modlinkage *modlp, ldi_ident_t *lip)
1449 {
1450 	struct modctl		*modp;
1451 	major_t			major;
1452 	char			*name;
1453 
1454 	if ((modlp == NULL) || (lip == NULL))
1455 		return (EINVAL);
1456 
1457 	ASSERT(!servicing_interrupt());
1458 
1459 	modp = mod_getctl(modlp);
1460 	if (modp == NULL)
1461 		return (EINVAL);
1462 	name = modp->mod_modname;
1463 	if (name == NULL)
1464 		return (EINVAL);
1465 	major = mod_name_to_major(name);
1466 
1467 	*lip = (ldi_ident_t)ident_alloc(name, NULL, DDI_DEV_T_NONE, major);
1468 
1469 	LDI_ALLOCFREE((CE_WARN, "%s: li=0x%p, mod=%s",
1470 	    "ldi_ident_from_mod", (void *)*lip, name));
1471 
1472 	return (0);
1473 }
1474 
1475 ldi_ident_t
ldi_ident_from_anon()1476 ldi_ident_from_anon()
1477 {
1478 	ldi_ident_t	lip;
1479 
1480 	ASSERT(!servicing_interrupt());
1481 
1482 	lip = (ldi_ident_t)ident_alloc("genunix", NULL, DDI_DEV_T_NONE, -1);
1483 
1484 	LDI_ALLOCFREE((CE_WARN, "%s: li=0x%p, mod=%s",
1485 	    "ldi_ident_from_anon", (void *)lip, "genunix"));
1486 
1487 	return (lip);
1488 }
1489 
1490 
1491 /*
1492  * LDI Public interfaces
1493  */
1494 int
ldi_ident_from_stream(struct queue * sq,ldi_ident_t * lip)1495 ldi_ident_from_stream(struct queue *sq, ldi_ident_t *lip)
1496 {
1497 	struct stdata		*stp;
1498 	dev_t			dev;
1499 	char			*name;
1500 
1501 	if ((sq == NULL) || (lip == NULL))
1502 		return (EINVAL);
1503 
1504 	ASSERT(!servicing_interrupt());
1505 
1506 	stp = sq->q_stream;
1507 	if (!vn_matchops(stp->sd_vnode, spec_getvnodeops()))
1508 		return (EINVAL);
1509 
1510 	dev = stp->sd_vnode->v_rdev;
1511 	name = mod_major_to_name(getmajor(dev));
1512 	if (name == NULL)
1513 		return (EINVAL);
1514 	*lip = (ldi_ident_t)ident_alloc(name, NULL, dev, -1);
1515 
1516 	LDI_ALLOCFREE((CE_WARN,
1517 	    "%s: li=0x%p, mod=%s, minor=0x%x, stp=0x%p",
1518 	    "ldi_ident_from_stream", (void *)*lip, name, getminor(dev),
1519 	    (void *)stp));
1520 
1521 	return (0);
1522 }
1523 
1524 int
ldi_ident_from_dev(dev_t dev,ldi_ident_t * lip)1525 ldi_ident_from_dev(dev_t dev, ldi_ident_t *lip)
1526 {
1527 	char			*name;
1528 
1529 	if (lip == NULL)
1530 		return (EINVAL);
1531 
1532 	ASSERT(!servicing_interrupt());
1533 
1534 	name = mod_major_to_name(getmajor(dev));
1535 	if (name == NULL)
1536 		return (EINVAL);
1537 	*lip = (ldi_ident_t)ident_alloc(name, NULL, dev, -1);
1538 
1539 	LDI_ALLOCFREE((CE_WARN,
1540 	    "%s: li=0x%p, mod=%s, minor=0x%x",
1541 	    "ldi_ident_from_dev", (void *)*lip, name, getminor(dev)));
1542 
1543 	return (0);
1544 }
1545 
1546 int
ldi_ident_from_dip(dev_info_t * dip,ldi_ident_t * lip)1547 ldi_ident_from_dip(dev_info_t *dip, ldi_ident_t *lip)
1548 {
1549 	struct dev_info		*devi = (struct dev_info *)dip;
1550 	char			*name;
1551 
1552 	if ((dip == NULL) || (lip == NULL))
1553 		return (EINVAL);
1554 
1555 	ASSERT(!servicing_interrupt());
1556 
1557 	name = mod_major_to_name(devi->devi_major);
1558 	if (name == NULL)
1559 		return (EINVAL);
1560 	*lip = (ldi_ident_t)ident_alloc(name, dip, DDI_DEV_T_NONE, -1);
1561 
1562 	LDI_ALLOCFREE((CE_WARN,
1563 	    "%s: li=0x%p, mod=%s, dip=0x%p",
1564 	    "ldi_ident_from_dip", (void *)*lip, name, (void *)devi));
1565 
1566 	return (0);
1567 }
1568 
1569 int
ldi_ident_from_major(major_t major,ldi_ident_t * lip)1570 ldi_ident_from_major(major_t major, ldi_ident_t *lip)
1571 {
1572 	char			*name;
1573 
1574 	if (lip == NULL)
1575 		return (EINVAL);
1576 
1577 	ASSERT(!servicing_interrupt());
1578 
1579 	name = mod_major_to_name(major);
1580 	if (name == NULL)
1581 		return (EINVAL);
1582 	*lip = (ldi_ident_t)ident_alloc(name, NULL, DDI_DEV_T_NONE, major);
1583 
1584 	LDI_ALLOCFREE((CE_WARN,
1585 	    "%s: li=0x%p, mod=%s",
1586 	    "ldi_ident_from_major", (void *)*lip, name));
1587 
1588 	return (0);
1589 }
1590 
1591 void
ldi_ident_release(ldi_ident_t li)1592 ldi_ident_release(ldi_ident_t li)
1593 {
1594 	struct ldi_ident	*ident = (struct ldi_ident *)li;
1595 	char			*name;
1596 
1597 	if (li == NULL)
1598 		return;
1599 
1600 	ASSERT(!servicing_interrupt());
1601 
1602 	name = ident->li_modname;
1603 
1604 	LDI_ALLOCFREE((CE_WARN,
1605 	    "%s: li=0x%p, mod=%s",
1606 	    "ldi_ident_release", (void *)li, name));
1607 
1608 	ident_release((struct ldi_ident *)li);
1609 }
1610 
1611 /* get a handle to a device by dev_t and otyp */
1612 int
ldi_open_by_dev(dev_t * devp,int otyp,int flag,cred_t * cr,ldi_handle_t * lhp,ldi_ident_t li)1613 ldi_open_by_dev(dev_t *devp, int otyp, int flag, cred_t *cr,
1614     ldi_handle_t *lhp, ldi_ident_t li)
1615 {
1616 	struct ldi_ident	*lip = (struct ldi_ident *)li;
1617 	int			ret;
1618 	vnode_t			*vp;
1619 
1620 	/* sanity check required input parameters */
1621 	if ((devp == NULL) || (!OTYP_VALID(otyp)) || (cr == NULL) ||
1622 	    (lhp == NULL) || (lip == NULL))
1623 		return (EINVAL);
1624 
1625 	ASSERT(!servicing_interrupt());
1626 
1627 	if ((ret = ldi_vp_from_dev(*devp, otyp, &vp)) != 0)
1628 		return (ret);
1629 
1630 	if ((ret = ldi_open_by_vp(&vp, flag, cr, lhp, lip)) == 0) {
1631 		*devp = vp->v_rdev;
1632 	}
1633 	VN_RELE(vp);
1634 
1635 	return (ret);
1636 }
1637 
1638 /* get a handle to a device by pathname */
1639 int
ldi_open_by_name(char * pathname,int flag,cred_t * cr,ldi_handle_t * lhp,ldi_ident_t li)1640 ldi_open_by_name(char *pathname, int flag, cred_t *cr,
1641     ldi_handle_t *lhp, ldi_ident_t li)
1642 {
1643 	struct ldi_ident	*lip = (struct ldi_ident *)li;
1644 	int			ret;
1645 	vnode_t			*vp;
1646 
1647 	/* sanity check required input parameters */
1648 	if ((pathname == NULL) || (*pathname != '/') ||
1649 	    (cr == NULL) || (lhp == NULL) || (lip == NULL))
1650 		return (EINVAL);
1651 
1652 	ASSERT(!servicing_interrupt());
1653 
1654 	if ((ret = ldi_vp_from_name(pathname, &vp)) != 0)
1655 		return (ret);
1656 
1657 	ret = ldi_open_by_vp(&vp, flag, cr, lhp, lip);
1658 	VN_RELE(vp);
1659 
1660 	return (ret);
1661 }
1662 
1663 /* get a handle to a device by devid and minor_name */
1664 int
ldi_open_by_devid(ddi_devid_t devid,char * minor_name,int flag,cred_t * cr,ldi_handle_t * lhp,ldi_ident_t li)1665 ldi_open_by_devid(ddi_devid_t devid, char *minor_name,
1666     int flag, cred_t *cr, ldi_handle_t *lhp, ldi_ident_t li)
1667 {
1668 	struct ldi_ident	*lip = (struct ldi_ident *)li;
1669 	int			ret;
1670 	vnode_t			*vp;
1671 
1672 	/* sanity check required input parameters */
1673 	if ((minor_name == NULL) || (cr == NULL) ||
1674 	    (lhp == NULL) || (lip == NULL))
1675 		return (EINVAL);
1676 
1677 	ASSERT(!servicing_interrupt());
1678 
1679 	if ((ret = ldi_vp_from_devid(devid, minor_name, &vp)) != 0)
1680 		return (ret);
1681 
1682 	ret = ldi_open_by_vp(&vp, flag, cr, lhp, lip);
1683 	VN_RELE(vp);
1684 
1685 	return (ret);
1686 }
1687 
1688 int
ldi_close(ldi_handle_t lh,int flag,cred_t * cr)1689 ldi_close(ldi_handle_t lh, int flag, cred_t *cr)
1690 {
1691 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
1692 	struct ldi_event	*lep;
1693 	int			err = 0;
1694 	int			notify = 0;
1695 	list_t			*listp;
1696 	ldi_ev_callback_impl_t	*lecp;
1697 
1698 	if (lh == NULL)
1699 		return (EINVAL);
1700 
1701 	ASSERT(!servicing_interrupt());
1702 
1703 #ifdef	LDI_OBSOLETE_EVENT
1704 
1705 	/*
1706 	 * Any event handlers should have been unregistered by the
1707 	 * time ldi_close() is called.  If they haven't then it's a
1708 	 * bug.
1709 	 *
1710 	 * In a debug kernel we'll panic to make the problem obvious.
1711 	 */
1712 	ASSERT(handlep->lh_events == NULL);
1713 
1714 	/*
1715 	 * On a production kernel we'll "do the right thing" (unregister
1716 	 * the event handlers) and then complain about having to do the
1717 	 * work ourselves.
1718 	 */
1719 	while ((lep = handlep->lh_events) != NULL) {
1720 		err = 1;
1721 		(void) ldi_remove_event_handler(lh, (ldi_callback_id_t)lep);
1722 	}
1723 	if (err) {
1724 		struct ldi_ident *lip = handlep->lh_ident;
1725 		ASSERT(lip != NULL);
1726 		cmn_err(CE_NOTE, "ldi err: %s "
1727 		    "failed to unregister layered event handlers before "
1728 		    "closing devices", lip->li_modname);
1729 	}
1730 #endif
1731 
1732 	/* do a layered close on the device */
1733 	err = VOP_CLOSE(handlep->lh_vp, flag | FKLYR, 1, (offset_t)0, cr, NULL);
1734 
1735 	LDI_OPENCLOSE((CE_WARN, "%s: lh=0x%p", "ldi close", (void *)lh));
1736 
1737 	/*
1738 	 * Search the event callback list for callbacks with this
1739 	 * handle. There are 2 cases
1740 	 * 1. Called in the context of a notify. The handle consumer
1741 	 *    is releasing its hold on the device to allow a reconfiguration
1742 	 *    of the device. Simply NULL out the handle and the notify callback.
1743 	 *    The finalize callback is still available so that the consumer
1744 	 *    knows of the final disposition of the device.
1745 	 * 2. Not called in the context of notify. NULL out the handle as well
1746 	 *    as the notify and finalize callbacks. Since the consumer has
1747 	 *    closed the handle, we assume it is not interested in the
1748 	 *    notify and finalize callbacks.
1749 	 */
1750 	ldi_ev_lock();
1751 
1752 	if (handlep->lh_flags & LH_FLAGS_NOTIFY)
1753 		notify = 1;
1754 	listp = &ldi_ev_callback_list.le_head;
1755 	for (lecp = list_head(listp); lecp; lecp = list_next(listp, lecp)) {
1756 		if (lecp->lec_lhp != handlep)
1757 			continue;
1758 		lecp->lec_lhp = NULL;
1759 		lecp->lec_notify = NULL;
1760 		LDI_EVDBG((CE_NOTE, "ldi_close: NULLed lh and notify"));
1761 		if (!notify) {
1762 			LDI_EVDBG((CE_NOTE, "ldi_close: NULLed finalize"));
1763 			lecp->lec_finalize = NULL;
1764 		}
1765 	}
1766 
1767 	if (notify)
1768 		handlep->lh_flags &= ~LH_FLAGS_NOTIFY;
1769 	ldi_ev_unlock();
1770 
1771 	/*
1772 	 * Free the handle even if the device close failed.  why?
1773 	 *
1774 	 * If the device close failed we can't really make assumptions
1775 	 * about the devices state so we shouldn't allow access to the
1776 	 * device via this handle any more.  If the device consumer wants
1777 	 * to access the device again they should open it again.
1778 	 *
1779 	 * This is the same way file/device close failures are handled
1780 	 * in other places like spec_close() and closeandsetf().
1781 	 */
1782 	handle_release(handlep);
1783 	return (err);
1784 }
1785 
1786 int
ldi_read(ldi_handle_t lh,struct uio * uiop,cred_t * credp)1787 ldi_read(ldi_handle_t lh, struct uio *uiop, cred_t *credp)
1788 {
1789 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
1790 	vnode_t			*vp;
1791 	dev_t			dev;
1792 	int			ret;
1793 
1794 	if (lh == NULL)
1795 		return (EINVAL);
1796 
1797 	vp = handlep->lh_vp;
1798 	dev = vp->v_rdev;
1799 	if (handlep->lh_type & LH_CBDEV) {
1800 		ret = cdev_read(dev, uiop, credp);
1801 	} else if (handlep->lh_type & LH_STREAM) {
1802 		ret = strread(vp, uiop, credp);
1803 	} else {
1804 		return (ENOTSUP);
1805 	}
1806 	return (ret);
1807 }
1808 
1809 int
ldi_write(ldi_handle_t lh,struct uio * uiop,cred_t * credp)1810 ldi_write(ldi_handle_t lh, struct uio *uiop, cred_t *credp)
1811 {
1812 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
1813 	vnode_t			*vp;
1814 	dev_t			dev;
1815 	int			ret;
1816 
1817 	if (lh == NULL)
1818 		return (EINVAL);
1819 
1820 	vp = handlep->lh_vp;
1821 	dev = vp->v_rdev;
1822 	if (handlep->lh_type & LH_CBDEV) {
1823 		ret = cdev_write(dev, uiop, credp);
1824 	} else if (handlep->lh_type & LH_STREAM) {
1825 		ret = strwrite(vp, uiop, credp);
1826 	} else {
1827 		return (ENOTSUP);
1828 	}
1829 	return (ret);
1830 }
1831 
1832 int
ldi_get_size(ldi_handle_t lh,uint64_t * sizep)1833 ldi_get_size(ldi_handle_t lh, uint64_t *sizep)
1834 {
1835 	int			otyp;
1836 	uint_t			value;
1837 	int64_t			drv_prop64;
1838 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
1839 	uint_t			blksize;
1840 	int			blkshift;
1841 
1842 
1843 	if ((lh == NULL) || (sizep == NULL))
1844 		return (DDI_FAILURE);
1845 
1846 	if (handlep->lh_type & LH_STREAM)
1847 		return (DDI_FAILURE);
1848 
1849 	/*
1850 	 * Determine device type (char or block).
1851 	 * Character devices support Size/size
1852 	 * property value. Block devices may support
1853 	 * Nblocks/nblocks or Size/size property value.
1854 	 */
1855 	if ((ldi_get_otyp(lh, &otyp)) != 0)
1856 		return (DDI_FAILURE);
1857 
1858 	if (otyp == OTYP_BLK) {
1859 		if (ldi_prop_exists(lh,
1860 		    DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "Nblocks")) {
1861 
1862 			drv_prop64 = ldi_prop_get_int64(lh,
1863 			    DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
1864 			    "Nblocks", 0);
1865 			blksize = ldi_prop_get_int(lh,
1866 			    DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
1867 			    "blksize", DEV_BSIZE);
1868 			if (blksize == DEV_BSIZE)
1869 				blksize = ldi_prop_get_int(lh, LDI_DEV_T_ANY |
1870 				    DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
1871 				    "device-blksize", DEV_BSIZE);
1872 
1873 			/* blksize must be a power of two */
1874 			ASSERT(BIT_ONLYONESET(blksize));
1875 			blkshift = highbit(blksize) - 1;
1876 
1877 			/*
1878 			 * We don't support Nblocks values that don't have
1879 			 * an accurate uint64_t byte count representation.
1880 			 */
1881 			if ((uint64_t)drv_prop64 >= (UINT64_MAX >> blkshift))
1882 				return (DDI_FAILURE);
1883 
1884 			*sizep = (uint64_t)
1885 			    (((u_offset_t)drv_prop64) << blkshift);
1886 			return (DDI_SUCCESS);
1887 		}
1888 
1889 		if (ldi_prop_exists(lh,
1890 		    DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "nblocks")) {
1891 
1892 			value = ldi_prop_get_int(lh,
1893 			    DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
1894 			    "nblocks", 0);
1895 			blksize = ldi_prop_get_int(lh,
1896 			    DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
1897 			    "blksize", DEV_BSIZE);
1898 			if (blksize == DEV_BSIZE)
1899 				blksize = ldi_prop_get_int(lh, LDI_DEV_T_ANY |
1900 				    DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
1901 				    "device-blksize", DEV_BSIZE);
1902 
1903 			/* blksize must be a power of two */
1904 			ASSERT(BIT_ONLYONESET(blksize));
1905 			blkshift = highbit(blksize) - 1;
1906 
1907 			/*
1908 			 * We don't support nblocks values that don't have an
1909 			 * accurate uint64_t byte count representation.
1910 			 */
1911 			if ((uint64_t)value >= (UINT64_MAX >> blkshift))
1912 				return (DDI_FAILURE);
1913 
1914 			*sizep = (uint64_t)
1915 			    (((u_offset_t)value) << blkshift);
1916 			return (DDI_SUCCESS);
1917 		}
1918 	}
1919 
1920 	if (ldi_prop_exists(lh,
1921 	    DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "Size")) {
1922 
1923 		drv_prop64 = ldi_prop_get_int64(lh,
1924 		    DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "Size", 0);
1925 		*sizep = (uint64_t)drv_prop64;
1926 		return (DDI_SUCCESS);
1927 	}
1928 
1929 	if (ldi_prop_exists(lh,
1930 	    DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "size")) {
1931 
1932 		value = ldi_prop_get_int(lh,
1933 		    DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "size", 0);
1934 		*sizep = (uint64_t)value;
1935 		return (DDI_SUCCESS);
1936 	}
1937 
1938 	/* unable to determine device size */
1939 	return (DDI_FAILURE);
1940 }
1941 
1942 int
ldi_ioctl(ldi_handle_t lh,int cmd,intptr_t arg,int mode,cred_t * cr,int * rvalp)1943 ldi_ioctl(ldi_handle_t lh, int cmd, intptr_t arg, int mode,
1944     cred_t *cr, int *rvalp)
1945 {
1946 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
1947 	vnode_t			*vp;
1948 	dev_t			dev;
1949 	int			ret, copymode, unused;
1950 
1951 	if (lh == NULL)
1952 		return (EINVAL);
1953 
1954 	/*
1955 	 * if the data pointed to by arg is located in the kernel then
1956 	 * make sure the FNATIVE flag is set.
1957 	 */
1958 	if (mode & FKIOCTL)
1959 		mode = (mode & ~FMODELS) | FNATIVE | FKIOCTL;
1960 
1961 	/*
1962 	 * Some drivers assume that rvalp will always be non-NULL, so in
1963 	 * an attempt to avoid panics if the caller passed in a NULL
1964 	 * value, update rvalp to point to a temporary variable.
1965 	 */
1966 	if (rvalp == NULL)
1967 		rvalp = &unused;
1968 	vp = handlep->lh_vp;
1969 	dev = vp->v_rdev;
1970 	if (handlep->lh_type & LH_CBDEV) {
1971 		ret = cdev_ioctl(dev, cmd, arg, mode, cr, rvalp);
1972 	} else if (handlep->lh_type & LH_STREAM) {
1973 		copymode = (mode & FKIOCTL) ? K_TO_K : U_TO_K;
1974 
1975 		/*
1976 		 * if we get an I_PLINK from within the kernel the
1977 		 * arg is a layered handle pointer instead of
1978 		 * a file descriptor, so we translate this ioctl
1979 		 * into a private one that can handle this.
1980 		 */
1981 		if ((mode & FKIOCTL) && (cmd == I_PLINK))
1982 			cmd = _I_PLINK_LH;
1983 
1984 		ret = strioctl(vp, cmd, arg, mode, copymode, cr, rvalp);
1985 	} else {
1986 		return (ENOTSUP);
1987 	}
1988 
1989 	return (ret);
1990 }
1991 
1992 int
ldi_poll(ldi_handle_t lh,short events,int anyyet,short * reventsp,struct pollhead ** phpp)1993 ldi_poll(ldi_handle_t lh, short events, int anyyet, short *reventsp,
1994     struct pollhead **phpp)
1995 {
1996 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
1997 	vnode_t			*vp;
1998 	dev_t			dev;
1999 	int			ret;
2000 
2001 	if (lh == NULL)
2002 		return (EINVAL);
2003 
2004 	vp = handlep->lh_vp;
2005 	dev = vp->v_rdev;
2006 	if (handlep->lh_type & LH_CBDEV) {
2007 		ret = cdev_poll(dev, events, anyyet, reventsp, phpp);
2008 	} else if (handlep->lh_type & LH_STREAM) {
2009 		ret = strpoll(vp->v_stream, events, anyyet, reventsp, phpp);
2010 	} else {
2011 		return (ENOTSUP);
2012 	}
2013 
2014 	return (ret);
2015 }
2016 
2017 int
ldi_prop_op(ldi_handle_t lh,ddi_prop_op_t prop_op,int flags,char * name,caddr_t valuep,int * length)2018 ldi_prop_op(ldi_handle_t lh, ddi_prop_op_t prop_op,
2019     int flags, char *name, caddr_t valuep, int *length)
2020 {
2021 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
2022 	dev_t			dev;
2023 	dev_info_t		*dip;
2024 	int			ret;
2025 	struct snode		*csp;
2026 
2027 	if ((lh == NULL) || (name == NULL) || (strlen(name) == 0))
2028 		return (DDI_PROP_INVAL_ARG);
2029 
2030 	if ((prop_op != PROP_LEN) && (valuep == NULL))
2031 		return (DDI_PROP_INVAL_ARG);
2032 
2033 	if (length == NULL)
2034 		return (DDI_PROP_INVAL_ARG);
2035 
2036 	/*
2037 	 * try to find the associated dip,
2038 	 * this places a hold on the driver
2039 	 */
2040 	dev = handlep->lh_vp->v_rdev;
2041 
2042 	csp = VTOCS(handlep->lh_vp);
2043 	mutex_enter(&csp->s_lock);
2044 	if ((dip = csp->s_dip) != NULL)
2045 		e_ddi_hold_devi(dip);
2046 	mutex_exit(&csp->s_lock);
2047 	if (dip == NULL)
2048 		dip = e_ddi_hold_devi_by_dev(dev, 0);
2049 
2050 	if (dip == NULL)
2051 		return (DDI_PROP_NOT_FOUND);
2052 
2053 	ret = i_ldi_prop_op(dev, dip, prop_op, flags, name, valuep, length);
2054 	ddi_release_devi(dip);
2055 
2056 	return (ret);
2057 }
2058 
2059 int
ldi_strategy(ldi_handle_t lh,struct buf * bp)2060 ldi_strategy(ldi_handle_t lh, struct buf *bp)
2061 {
2062 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
2063 	dev_t			dev;
2064 
2065 	if ((lh == NULL) || (bp == NULL))
2066 		return (EINVAL);
2067 
2068 	/* this entry point is only supported for cb devices */
2069 	dev = handlep->lh_vp->v_rdev;
2070 	if (!(handlep->lh_type & LH_CBDEV))
2071 		return (ENOTSUP);
2072 
2073 	bp->b_edev = dev;
2074 	bp->b_dev = cmpdev(dev);
2075 	return (bdev_strategy(bp));
2076 }
2077 
2078 int
ldi_dump(ldi_handle_t lh,caddr_t addr,daddr_t blkno,int nblk)2079 ldi_dump(ldi_handle_t lh, caddr_t addr, daddr_t blkno, int nblk)
2080 {
2081 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
2082 	dev_t			dev;
2083 
2084 	if (lh == NULL)
2085 		return (EINVAL);
2086 
2087 	/* this entry point is only supported for cb devices */
2088 	dev = handlep->lh_vp->v_rdev;
2089 	if (!(handlep->lh_type & LH_CBDEV))
2090 		return (ENOTSUP);
2091 
2092 	return (bdev_dump(dev, addr, blkno, nblk));
2093 }
2094 
2095 int
ldi_devmap(ldi_handle_t lh,devmap_cookie_t dhp,offset_t off,size_t len,size_t * maplen,uint_t model)2096 ldi_devmap(ldi_handle_t lh, devmap_cookie_t dhp, offset_t off,
2097     size_t len, size_t *maplen, uint_t model)
2098 {
2099 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
2100 	dev_t			dev;
2101 
2102 	if (lh == NULL)
2103 		return (EINVAL);
2104 
2105 	/* this entry point is only supported for cb devices */
2106 	dev = handlep->lh_vp->v_rdev;
2107 	if (!(handlep->lh_type & LH_CBDEV))
2108 		return (ENOTSUP);
2109 
2110 	return (cdev_devmap(dev, dhp, off, len, maplen, model));
2111 }
2112 
2113 int
ldi_aread(ldi_handle_t lh,struct aio_req * aio_reqp,cred_t * cr)2114 ldi_aread(ldi_handle_t lh, struct aio_req *aio_reqp, cred_t *cr)
2115 {
2116 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
2117 	dev_t			dev;
2118 	struct cb_ops		*cb;
2119 
2120 	if (lh == NULL)
2121 		return (EINVAL);
2122 
2123 	/* this entry point is only supported for cb devices */
2124 	if (!(handlep->lh_type & LH_CBDEV))
2125 		return (ENOTSUP);
2126 
2127 	/*
2128 	 * Kaio is only supported on block devices.
2129 	 */
2130 	dev = handlep->lh_vp->v_rdev;
2131 	cb = devopsp[getmajor(dev)]->devo_cb_ops;
2132 	if (cb->cb_strategy == nodev || cb->cb_strategy == NULL)
2133 		return (ENOTSUP);
2134 
2135 	if (cb->cb_aread == NULL)
2136 		return (ENOTSUP);
2137 
2138 	return (cb->cb_aread(dev, aio_reqp, cr));
2139 }
2140 
2141 int
ldi_awrite(ldi_handle_t lh,struct aio_req * aio_reqp,cred_t * cr)2142 ldi_awrite(ldi_handle_t lh, struct aio_req *aio_reqp, cred_t *cr)
2143 {
2144 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
2145 	struct cb_ops		*cb;
2146 	dev_t			dev;
2147 
2148 	if (lh == NULL)
2149 		return (EINVAL);
2150 
2151 	/* this entry point is only supported for cb devices */
2152 	if (!(handlep->lh_type & LH_CBDEV))
2153 		return (ENOTSUP);
2154 
2155 	/*
2156 	 * Kaio is only supported on block devices.
2157 	 */
2158 	dev = handlep->lh_vp->v_rdev;
2159 	cb = devopsp[getmajor(dev)]->devo_cb_ops;
2160 	if (cb->cb_strategy == nodev || cb->cb_strategy == NULL)
2161 		return (ENOTSUP);
2162 
2163 	if (cb->cb_awrite == NULL)
2164 		return (ENOTSUP);
2165 
2166 	return (cb->cb_awrite(dev, aio_reqp, cr));
2167 }
2168 
2169 int
ldi_putmsg(ldi_handle_t lh,mblk_t * smp)2170 ldi_putmsg(ldi_handle_t lh, mblk_t *smp)
2171 {
2172 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
2173 	int			ret;
2174 
2175 	if ((lh == NULL) || (smp == NULL))
2176 		return (EINVAL);
2177 
2178 	if (!(handlep->lh_type & LH_STREAM)) {
2179 		freemsg(smp);
2180 		return (ENOTSUP);
2181 	}
2182 
2183 	/*
2184 	 * If we don't have db_credp, set it. Note that we can not be called
2185 	 * from interrupt context.
2186 	 */
2187 	if (msg_getcred(smp, NULL) == NULL)
2188 		mblk_setcred(smp, CRED(), curproc->p_pid);
2189 
2190 	/* Send message while honoring flow control */
2191 	ret = kstrputmsg(handlep->lh_vp, smp, NULL, 0, 0,
2192 	    MSG_BAND | MSG_HOLDSIG | MSG_IGNERROR, 0);
2193 
2194 	return (ret);
2195 }
2196 
2197 int
ldi_getmsg(ldi_handle_t lh,mblk_t ** rmp,timestruc_t * timeo)2198 ldi_getmsg(ldi_handle_t lh, mblk_t **rmp, timestruc_t *timeo)
2199 {
2200 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
2201 	clock_t			timout; /* milliseconds */
2202 	uchar_t			pri;
2203 	rval_t			rval;
2204 	int			ret, pflag;
2205 
2206 
2207 	if (lh == NULL)
2208 		return (EINVAL);
2209 
2210 	if (!(handlep->lh_type & LH_STREAM))
2211 		return (ENOTSUP);
2212 
2213 	/* Convert from nanoseconds to milliseconds */
2214 	if (timeo != NULL) {
2215 		timout = timeo->tv_sec * 1000 + timeo->tv_nsec / 1000000;
2216 		if (timout > INT_MAX)
2217 			return (EINVAL);
2218 	} else
2219 		timout = -1;
2220 
2221 	/* Wait for timeout millseconds for a message */
2222 	pflag = MSG_ANY;
2223 	pri = 0;
2224 	*rmp = NULL;
2225 	ret = kstrgetmsg(handlep->lh_vp,
2226 	    rmp, NULL, &pri, &pflag, timout, &rval);
2227 	return (ret);
2228 }
2229 
2230 int
ldi_get_dev(ldi_handle_t lh,dev_t * devp)2231 ldi_get_dev(ldi_handle_t lh, dev_t *devp)
2232 {
2233 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
2234 
2235 	if ((lh == NULL) || (devp == NULL))
2236 		return (EINVAL);
2237 
2238 	*devp = handlep->lh_vp->v_rdev;
2239 	return (0);
2240 }
2241 
2242 int
ldi_get_otyp(ldi_handle_t lh,int * otyp)2243 ldi_get_otyp(ldi_handle_t lh, int *otyp)
2244 {
2245 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
2246 
2247 	if ((lh == NULL) || (otyp == NULL))
2248 		return (EINVAL);
2249 
2250 	*otyp = VTYP_TO_OTYP(handlep->lh_vp->v_type);
2251 	return (0);
2252 }
2253 
2254 int
ldi_get_devid(ldi_handle_t lh,ddi_devid_t * devid)2255 ldi_get_devid(ldi_handle_t lh, ddi_devid_t *devid)
2256 {
2257 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
2258 	int			ret;
2259 	dev_t			dev;
2260 
2261 	if ((lh == NULL) || (devid == NULL))
2262 		return (EINVAL);
2263 
2264 	dev = handlep->lh_vp->v_rdev;
2265 
2266 	ret = ddi_lyr_get_devid(dev, devid);
2267 	if (ret != DDI_SUCCESS)
2268 		return (ENOTSUP);
2269 
2270 	return (0);
2271 }
2272 
2273 int
ldi_get_minor_name(ldi_handle_t lh,char ** minor_name)2274 ldi_get_minor_name(ldi_handle_t lh, char **minor_name)
2275 {
2276 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
2277 	int			ret, otyp;
2278 	dev_t			dev;
2279 
2280 	if ((lh == NULL) || (minor_name == NULL))
2281 		return (EINVAL);
2282 
2283 	dev = handlep->lh_vp->v_rdev;
2284 	otyp = VTYP_TO_OTYP(handlep->lh_vp->v_type);
2285 
2286 	ret = ddi_lyr_get_minor_name(dev, OTYP_TO_STYP(otyp), minor_name);
2287 	if (ret != DDI_SUCCESS)
2288 		return (ENOTSUP);
2289 
2290 	return (0);
2291 }
2292 
2293 int
ldi_prop_lookup_int_array(ldi_handle_t lh,uint_t flags,char * name,int ** data,uint_t * nelements)2294 ldi_prop_lookup_int_array(ldi_handle_t lh,
2295     uint_t flags, char *name, int **data, uint_t *nelements)
2296 {
2297 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
2298 	dev_info_t		*dip;
2299 	dev_t			dev;
2300 	int			res;
2301 	struct snode		*csp;
2302 
2303 	if ((lh == NULL) || (name == NULL) || (strlen(name) == 0))
2304 		return (DDI_PROP_INVAL_ARG);
2305 
2306 	dev = handlep->lh_vp->v_rdev;
2307 
2308 	csp = VTOCS(handlep->lh_vp);
2309 	mutex_enter(&csp->s_lock);
2310 	if ((dip = csp->s_dip) != NULL)
2311 		e_ddi_hold_devi(dip);
2312 	mutex_exit(&csp->s_lock);
2313 	if (dip == NULL)
2314 		dip = e_ddi_hold_devi_by_dev(dev, 0);
2315 
2316 	if (dip == NULL) {
2317 		flags |= DDI_UNBND_DLPI2;
2318 	} else if (flags & LDI_DEV_T_ANY) {
2319 		flags &= ~LDI_DEV_T_ANY;
2320 		dev = DDI_DEV_T_ANY;
2321 	}
2322 
2323 	if (dip != NULL) {
2324 		int *prop_val, prop_len;
2325 
2326 		res = i_ldi_prop_op_typed(dev, dip, flags, name,
2327 		    (caddr_t *)&prop_val, &prop_len, sizeof (int));
2328 
2329 		/* if we got it then return it */
2330 		if (res == DDI_PROP_SUCCESS) {
2331 			*nelements = prop_len / sizeof (int);
2332 			*data = prop_val;
2333 
2334 			ddi_release_devi(dip);
2335 			return (res);
2336 		}
2337 	}
2338 
2339 	/* call the normal property interfaces */
2340 	res = ddi_prop_lookup_int_array(dev, dip, flags,
2341 	    name, data, nelements);
2342 
2343 	if (dip != NULL)
2344 		ddi_release_devi(dip);
2345 
2346 	return (res);
2347 }
2348 
2349 int
ldi_prop_lookup_int64_array(ldi_handle_t lh,uint_t flags,char * name,int64_t ** data,uint_t * nelements)2350 ldi_prop_lookup_int64_array(ldi_handle_t lh,
2351     uint_t flags, char *name, int64_t **data, uint_t *nelements)
2352 {
2353 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
2354 	dev_info_t		*dip;
2355 	dev_t			dev;
2356 	int			res;
2357 	struct snode		*csp;
2358 
2359 	if ((lh == NULL) || (name == NULL) || (strlen(name) == 0))
2360 		return (DDI_PROP_INVAL_ARG);
2361 
2362 	dev = handlep->lh_vp->v_rdev;
2363 
2364 	csp = VTOCS(handlep->lh_vp);
2365 	mutex_enter(&csp->s_lock);
2366 	if ((dip = csp->s_dip) != NULL)
2367 		e_ddi_hold_devi(dip);
2368 	mutex_exit(&csp->s_lock);
2369 	if (dip == NULL)
2370 		dip = e_ddi_hold_devi_by_dev(dev, 0);
2371 
2372 	if (dip == NULL) {
2373 		flags |= DDI_UNBND_DLPI2;
2374 	} else if (flags & LDI_DEV_T_ANY) {
2375 		flags &= ~LDI_DEV_T_ANY;
2376 		dev = DDI_DEV_T_ANY;
2377 	}
2378 
2379 	if (dip != NULL) {
2380 		int64_t	*prop_val;
2381 		int	prop_len;
2382 
2383 		res = i_ldi_prop_op_typed(dev, dip, flags, name,
2384 		    (caddr_t *)&prop_val, &prop_len, sizeof (int64_t));
2385 
2386 		/* if we got it then return it */
2387 		if (res == DDI_PROP_SUCCESS) {
2388 			*nelements = prop_len / sizeof (int64_t);
2389 			*data = prop_val;
2390 
2391 			ddi_release_devi(dip);
2392 			return (res);
2393 		}
2394 	}
2395 
2396 	/* call the normal property interfaces */
2397 	res = ddi_prop_lookup_int64_array(dev, dip, flags,
2398 	    name, data, nelements);
2399 
2400 	if (dip != NULL)
2401 		ddi_release_devi(dip);
2402 
2403 	return (res);
2404 }
2405 
2406 int
ldi_prop_lookup_string_array(ldi_handle_t lh,uint_t flags,char * name,char *** data,uint_t * nelements)2407 ldi_prop_lookup_string_array(ldi_handle_t lh,
2408     uint_t flags, char *name, char ***data, uint_t *nelements)
2409 {
2410 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
2411 	dev_info_t		*dip;
2412 	dev_t			dev;
2413 	int			res;
2414 	struct snode		*csp;
2415 
2416 	if ((lh == NULL) || (name == NULL) || (strlen(name) == 0))
2417 		return (DDI_PROP_INVAL_ARG);
2418 
2419 	dev = handlep->lh_vp->v_rdev;
2420 
2421 	csp = VTOCS(handlep->lh_vp);
2422 	mutex_enter(&csp->s_lock);
2423 	if ((dip = csp->s_dip) != NULL)
2424 		e_ddi_hold_devi(dip);
2425 	mutex_exit(&csp->s_lock);
2426 	if (dip == NULL)
2427 		dip = e_ddi_hold_devi_by_dev(dev, 0);
2428 
2429 	if (dip == NULL) {
2430 		flags |= DDI_UNBND_DLPI2;
2431 	} else if (flags & LDI_DEV_T_ANY) {
2432 		flags &= ~LDI_DEV_T_ANY;
2433 		dev = DDI_DEV_T_ANY;
2434 	}
2435 
2436 	if (dip != NULL) {
2437 		char	*prop_val;
2438 		int	prop_len;
2439 
2440 		res = i_ldi_prop_op_typed(dev, dip, flags, name,
2441 		    (caddr_t *)&prop_val, &prop_len, 0);
2442 
2443 		/* if we got it then return it */
2444 		if (res == DDI_PROP_SUCCESS) {
2445 			char	**str_array;
2446 			int	nelem;
2447 
2448 			/*
2449 			 * pack the returned string array into the format
2450 			 * our callers expect
2451 			 */
2452 			if (i_pack_string_array(prop_val, prop_len,
2453 			    &str_array, &nelem) == 0) {
2454 
2455 				*data = str_array;
2456 				*nelements = nelem;
2457 
2458 				ddi_prop_free(prop_val);
2459 				ddi_release_devi(dip);
2460 				return (res);
2461 			}
2462 
2463 			/*
2464 			 * the format of the returned property must have
2465 			 * been bad so throw it out
2466 			 */
2467 			ddi_prop_free(prop_val);
2468 		}
2469 	}
2470 
2471 	/* call the normal property interfaces */
2472 	res = ddi_prop_lookup_string_array(dev, dip, flags,
2473 	    name, data, nelements);
2474 
2475 	if (dip != NULL)
2476 		ddi_release_devi(dip);
2477 
2478 	return (res);
2479 }
2480 
2481 int
ldi_prop_lookup_string(ldi_handle_t lh,uint_t flags,char * name,char ** data)2482 ldi_prop_lookup_string(ldi_handle_t lh,
2483     uint_t flags, char *name, char **data)
2484 {
2485 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
2486 	dev_info_t		*dip;
2487 	dev_t			dev;
2488 	int			res;
2489 	struct snode		*csp;
2490 
2491 	if ((lh == NULL) || (name == NULL) || (strlen(name) == 0))
2492 		return (DDI_PROP_INVAL_ARG);
2493 
2494 	dev = handlep->lh_vp->v_rdev;
2495 
2496 	csp = VTOCS(handlep->lh_vp);
2497 	mutex_enter(&csp->s_lock);
2498 	if ((dip = csp->s_dip) != NULL)
2499 		e_ddi_hold_devi(dip);
2500 	mutex_exit(&csp->s_lock);
2501 	if (dip == NULL)
2502 		dip = e_ddi_hold_devi_by_dev(dev, 0);
2503 
2504 	if (dip == NULL) {
2505 		flags |= DDI_UNBND_DLPI2;
2506 	} else if (flags & LDI_DEV_T_ANY) {
2507 		flags &= ~LDI_DEV_T_ANY;
2508 		dev = DDI_DEV_T_ANY;
2509 	}
2510 
2511 	if (dip != NULL) {
2512 		char	*prop_val;
2513 		int	prop_len;
2514 
2515 		res = i_ldi_prop_op_typed(dev, dip, flags, name,
2516 		    (caddr_t *)&prop_val, &prop_len, 0);
2517 
2518 		/* if we got it then return it */
2519 		if (res == DDI_PROP_SUCCESS) {
2520 			/*
2521 			 * sanity check the vaule returned.
2522 			 */
2523 			if (i_check_string(prop_val, prop_len)) {
2524 				ddi_prop_free(prop_val);
2525 			} else {
2526 				*data = prop_val;
2527 				ddi_release_devi(dip);
2528 				return (res);
2529 			}
2530 		}
2531 	}
2532 
2533 	/* call the normal property interfaces */
2534 	res = ddi_prop_lookup_string(dev, dip, flags, name, data);
2535 
2536 	if (dip != NULL)
2537 		ddi_release_devi(dip);
2538 
2539 #ifdef DEBUG
2540 	if (res == DDI_PROP_SUCCESS) {
2541 		/*
2542 		 * keep ourselves honest
2543 		 * make sure the framework returns strings in the
2544 		 * same format as we're demanding from drivers.
2545 		 */
2546 		struct prop_driver_data	*pdd;
2547 		int			pdd_prop_size;
2548 
2549 		pdd = ((struct prop_driver_data *)(*data)) - 1;
2550 		pdd_prop_size = pdd->pdd_size -
2551 		    sizeof (struct prop_driver_data);
2552 		ASSERT(i_check_string(*data, pdd_prop_size) == 0);
2553 	}
2554 #endif /* DEBUG */
2555 
2556 	return (res);
2557 }
2558 
2559 int
ldi_prop_lookup_byte_array(ldi_handle_t lh,uint_t flags,char * name,uchar_t ** data,uint_t * nelements)2560 ldi_prop_lookup_byte_array(ldi_handle_t lh,
2561     uint_t flags, char *name, uchar_t **data, uint_t *nelements)
2562 {
2563 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
2564 	dev_info_t		*dip;
2565 	dev_t			dev;
2566 	int			res;
2567 	struct snode		*csp;
2568 
2569 	if ((lh == NULL) || (name == NULL) || (strlen(name) == 0))
2570 		return (DDI_PROP_INVAL_ARG);
2571 
2572 	dev = handlep->lh_vp->v_rdev;
2573 
2574 	csp = VTOCS(handlep->lh_vp);
2575 	mutex_enter(&csp->s_lock);
2576 	if ((dip = csp->s_dip) != NULL)
2577 		e_ddi_hold_devi(dip);
2578 	mutex_exit(&csp->s_lock);
2579 	if (dip == NULL)
2580 		dip = e_ddi_hold_devi_by_dev(dev, 0);
2581 
2582 	if (dip == NULL) {
2583 		flags |= DDI_UNBND_DLPI2;
2584 	} else if (flags & LDI_DEV_T_ANY) {
2585 		flags &= ~LDI_DEV_T_ANY;
2586 		dev = DDI_DEV_T_ANY;
2587 	}
2588 
2589 	if (dip != NULL) {
2590 		uchar_t	*prop_val;
2591 		int	prop_len;
2592 
2593 		res = i_ldi_prop_op_typed(dev, dip, flags, name,
2594 		    (caddr_t *)&prop_val, &prop_len, sizeof (uchar_t));
2595 
2596 		/* if we got it then return it */
2597 		if (res == DDI_PROP_SUCCESS) {
2598 			*nelements = prop_len / sizeof (uchar_t);
2599 			*data = prop_val;
2600 
2601 			ddi_release_devi(dip);
2602 			return (res);
2603 		}
2604 	}
2605 
2606 	/* call the normal property interfaces */
2607 	res = ddi_prop_lookup_byte_array(dev, dip, flags,
2608 	    name, data, nelements);
2609 
2610 	if (dip != NULL)
2611 		ddi_release_devi(dip);
2612 
2613 	return (res);
2614 }
2615 
2616 int
ldi_prop_get_int(ldi_handle_t lh,uint_t flags,char * name,int defvalue)2617 ldi_prop_get_int(ldi_handle_t lh,
2618     uint_t flags, char *name, int defvalue)
2619 {
2620 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
2621 	dev_info_t		*dip;
2622 	dev_t			dev;
2623 	int			res;
2624 	struct snode		*csp;
2625 
2626 	if ((lh == NULL) || (name == NULL) || (strlen(name) == 0))
2627 		return (defvalue);
2628 
2629 	dev = handlep->lh_vp->v_rdev;
2630 
2631 	csp = VTOCS(handlep->lh_vp);
2632 	mutex_enter(&csp->s_lock);
2633 	if ((dip = csp->s_dip) != NULL)
2634 		e_ddi_hold_devi(dip);
2635 	mutex_exit(&csp->s_lock);
2636 	if (dip == NULL)
2637 		dip = e_ddi_hold_devi_by_dev(dev, 0);
2638 
2639 	if (dip == NULL) {
2640 		flags |= DDI_UNBND_DLPI2;
2641 	} else if (flags & LDI_DEV_T_ANY) {
2642 		flags &= ~LDI_DEV_T_ANY;
2643 		dev = DDI_DEV_T_ANY;
2644 	}
2645 
2646 	if (dip != NULL) {
2647 		int	prop_val;
2648 		int	prop_len;
2649 
2650 		/*
2651 		 * first call the drivers prop_op interface to allow it
2652 		 * it to override default property values.
2653 		 */
2654 		prop_len = sizeof (int);
2655 		res = i_ldi_prop_op(dev, dip, PROP_LEN_AND_VAL_BUF,
2656 		    flags | DDI_PROP_DYNAMIC, name,
2657 		    (caddr_t)&prop_val, &prop_len);
2658 
2659 		/* if we got it then return it */
2660 		if ((res == DDI_PROP_SUCCESS) &&
2661 		    (prop_len == sizeof (int))) {
2662 			res = prop_val;
2663 			ddi_release_devi(dip);
2664 			return (res);
2665 		}
2666 	}
2667 
2668 	/* call the normal property interfaces */
2669 	res = ddi_prop_get_int(dev, dip, flags, name, defvalue);
2670 
2671 	if (dip != NULL)
2672 		ddi_release_devi(dip);
2673 
2674 	return (res);
2675 }
2676 
2677 int64_t
ldi_prop_get_int64(ldi_handle_t lh,uint_t flags,char * name,int64_t defvalue)2678 ldi_prop_get_int64(ldi_handle_t lh,
2679     uint_t flags, char *name, int64_t defvalue)
2680 {
2681 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
2682 	dev_info_t		*dip;
2683 	dev_t			dev;
2684 	int64_t			res;
2685 	struct snode		*csp;
2686 
2687 	if ((lh == NULL) || (name == NULL) || (strlen(name) == 0))
2688 		return (defvalue);
2689 
2690 	dev = handlep->lh_vp->v_rdev;
2691 
2692 	csp = VTOCS(handlep->lh_vp);
2693 	mutex_enter(&csp->s_lock);
2694 	if ((dip = csp->s_dip) != NULL)
2695 		e_ddi_hold_devi(dip);
2696 	mutex_exit(&csp->s_lock);
2697 	if (dip == NULL)
2698 		dip = e_ddi_hold_devi_by_dev(dev, 0);
2699 
2700 	if (dip == NULL) {
2701 		flags |= DDI_UNBND_DLPI2;
2702 	} else if (flags & LDI_DEV_T_ANY) {
2703 		flags &= ~LDI_DEV_T_ANY;
2704 		dev = DDI_DEV_T_ANY;
2705 	}
2706 
2707 	if (dip != NULL) {
2708 		int64_t	prop_val;
2709 		int	prop_len;
2710 
2711 		/*
2712 		 * first call the drivers prop_op interface to allow it
2713 		 * it to override default property values.
2714 		 */
2715 		prop_len = sizeof (int64_t);
2716 		res = i_ldi_prop_op(dev, dip, PROP_LEN_AND_VAL_BUF,
2717 		    flags | DDI_PROP_DYNAMIC, name,
2718 		    (caddr_t)&prop_val, &prop_len);
2719 
2720 		/* if we got it then return it */
2721 		if ((res == DDI_PROP_SUCCESS) &&
2722 		    (prop_len == sizeof (int64_t))) {
2723 			res = prop_val;
2724 			ddi_release_devi(dip);
2725 			return (res);
2726 		}
2727 	}
2728 
2729 	/* call the normal property interfaces */
2730 	res = ddi_prop_get_int64(dev, dip, flags, name, defvalue);
2731 
2732 	if (dip != NULL)
2733 		ddi_release_devi(dip);
2734 
2735 	return (res);
2736 }
2737 
2738 int
ldi_prop_exists(ldi_handle_t lh,uint_t flags,char * name)2739 ldi_prop_exists(ldi_handle_t lh, uint_t flags, char *name)
2740 {
2741 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
2742 	dev_info_t		*dip;
2743 	dev_t			dev;
2744 	int			res, prop_len;
2745 	struct snode		*csp;
2746 
2747 	if ((lh == NULL) || (name == NULL) || (strlen(name) == 0))
2748 		return (0);
2749 
2750 	dev = handlep->lh_vp->v_rdev;
2751 
2752 	csp = VTOCS(handlep->lh_vp);
2753 	mutex_enter(&csp->s_lock);
2754 	if ((dip = csp->s_dip) != NULL)
2755 		e_ddi_hold_devi(dip);
2756 	mutex_exit(&csp->s_lock);
2757 	if (dip == NULL)
2758 		dip = e_ddi_hold_devi_by_dev(dev, 0);
2759 
2760 	/* if NULL dip, prop does NOT exist */
2761 	if (dip == NULL)
2762 		return (0);
2763 
2764 	if (flags & LDI_DEV_T_ANY) {
2765 		flags &= ~LDI_DEV_T_ANY;
2766 		dev = DDI_DEV_T_ANY;
2767 	}
2768 
2769 	/*
2770 	 * first call the drivers prop_op interface to allow it
2771 	 * it to override default property values.
2772 	 */
2773 	res = i_ldi_prop_op(dev, dip, PROP_LEN,
2774 	    flags | DDI_PROP_DYNAMIC, name, NULL, &prop_len);
2775 
2776 	if (res == DDI_PROP_SUCCESS) {
2777 		ddi_release_devi(dip);
2778 		return (1);
2779 	}
2780 
2781 	/* call the normal property interfaces */
2782 	res = ddi_prop_exists(dev, dip, flags, name);
2783 
2784 	ddi_release_devi(dip);
2785 	return (res);
2786 }
2787 
2788 #ifdef	LDI_OBSOLETE_EVENT
2789 
2790 int
ldi_get_eventcookie(ldi_handle_t lh,char * name,ddi_eventcookie_t * ecp)2791 ldi_get_eventcookie(ldi_handle_t lh, char *name, ddi_eventcookie_t *ecp)
2792 {
2793 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
2794 	dev_info_t		*dip;
2795 	dev_t			dev;
2796 	int			res;
2797 	struct snode		*csp;
2798 
2799 	if ((lh == NULL) || (name == NULL) ||
2800 	    (strlen(name) == 0) || (ecp == NULL)) {
2801 		return (DDI_FAILURE);
2802 	}
2803 
2804 	ASSERT(!servicing_interrupt());
2805 
2806 	dev = handlep->lh_vp->v_rdev;
2807 
2808 	csp = VTOCS(handlep->lh_vp);
2809 	mutex_enter(&csp->s_lock);
2810 	if ((dip = csp->s_dip) != NULL)
2811 		e_ddi_hold_devi(dip);
2812 	mutex_exit(&csp->s_lock);
2813 	if (dip == NULL)
2814 		dip = e_ddi_hold_devi_by_dev(dev, 0);
2815 
2816 	if (dip == NULL)
2817 		return (DDI_FAILURE);
2818 
2819 	LDI_EVENTCB((CE_NOTE, "%s: event_name=%s, "
2820 	    "dip=0x%p, event_cookiep=0x%p", "ldi_get_eventcookie",
2821 	    name, (void *)dip, (void *)ecp));
2822 
2823 	res = ddi_get_eventcookie(dip, name, ecp);
2824 
2825 	ddi_release_devi(dip);
2826 	return (res);
2827 }
2828 
2829 int
ldi_add_event_handler(ldi_handle_t lh,ddi_eventcookie_t ec,void (* handler)(ldi_handle_t,ddi_eventcookie_t,void *,void *),void * arg,ldi_callback_id_t * id)2830 ldi_add_event_handler(ldi_handle_t lh, ddi_eventcookie_t ec,
2831     void (*handler)(ldi_handle_t, ddi_eventcookie_t, void *, void *),
2832     void *arg, ldi_callback_id_t *id)
2833 {
2834 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
2835 	struct ldi_event	*lep;
2836 	dev_info_t		*dip;
2837 	dev_t			dev;
2838 	int			res;
2839 	struct snode		*csp;
2840 
2841 	if ((lh == NULL) || (ec == NULL) || (handler == NULL) || (id == NULL))
2842 		return (DDI_FAILURE);
2843 
2844 	ASSERT(!servicing_interrupt());
2845 
2846 	dev = handlep->lh_vp->v_rdev;
2847 
2848 	csp = VTOCS(handlep->lh_vp);
2849 	mutex_enter(&csp->s_lock);
2850 	if ((dip = csp->s_dip) != NULL)
2851 		e_ddi_hold_devi(dip);
2852 	mutex_exit(&csp->s_lock);
2853 	if (dip == NULL)
2854 		dip = e_ddi_hold_devi_by_dev(dev, 0);
2855 
2856 	if (dip == NULL)
2857 		return (DDI_FAILURE);
2858 
2859 	lep = kmem_zalloc(sizeof (struct ldi_event), KM_SLEEP);
2860 	lep->le_lhp = handlep;
2861 	lep->le_arg = arg;
2862 	lep->le_handler = handler;
2863 
2864 	if ((res = ddi_add_event_handler(dip, ec, i_ldi_callback,
2865 	    (void *)lep, &lep->le_id)) != DDI_SUCCESS) {
2866 		LDI_EVENTCB((CE_WARN, "%s: unable to add"
2867 		    "event callback", "ldi_add_event_handler"));
2868 		ddi_release_devi(dip);
2869 		kmem_free(lep, sizeof (struct ldi_event));
2870 		return (res);
2871 	}
2872 
2873 	*id = (ldi_callback_id_t)lep;
2874 
2875 	LDI_EVENTCB((CE_NOTE, "%s: dip=0x%p, event=0x%p, "
2876 	    "ldi_eventp=0x%p, cb_id=0x%p", "ldi_add_event_handler",
2877 	    (void *)dip, (void *)ec, (void *)lep, (void *)id));
2878 
2879 	handle_event_add(lep);
2880 	ddi_release_devi(dip);
2881 	return (res);
2882 }
2883 
2884 int
ldi_remove_event_handler(ldi_handle_t lh,ldi_callback_id_t id)2885 ldi_remove_event_handler(ldi_handle_t lh, ldi_callback_id_t id)
2886 {
2887 	ldi_event_t		*lep = (ldi_event_t *)id;
2888 	int			res;
2889 
2890 	if ((lh == NULL) || (id == NULL))
2891 		return (DDI_FAILURE);
2892 
2893 	ASSERT(!servicing_interrupt());
2894 
2895 	if ((res = ddi_remove_event_handler(lep->le_id))
2896 	    != DDI_SUCCESS) {
2897 		LDI_EVENTCB((CE_WARN, "%s: unable to remove "
2898 		    "event callback", "ldi_remove_event_handler"));
2899 		return (res);
2900 	}
2901 
2902 	handle_event_remove(lep);
2903 	kmem_free(lep, sizeof (struct ldi_event));
2904 	return (res);
2905 }
2906 
2907 #endif
2908 
2909 /*
2910  * Here are some definitions of terms used in the following LDI events
2911  * code:
2912  *
2913  * "LDI events" AKA "native events": These are events defined by the
2914  * "new" LDI event framework. These events are serviced by the LDI event
2915  * framework itself and thus are native to it.
2916  *
2917  * "LDI contract events": These are contract events that correspond to the
2918  *  LDI events. This mapping of LDI events to contract events is defined by
2919  * the ldi_ev_cookies[] array above.
2920  *
2921  * NDI events: These are events which are serviced by the NDI event subsystem.
2922  * LDI subsystem just provides a thin wrapper around the NDI event interfaces
2923  * These events are therefore *not* native events.
2924  */
2925 
2926 static int
ldi_native_event(const char * evname)2927 ldi_native_event(const char *evname)
2928 {
2929 	int i;
2930 
2931 	LDI_EVTRC((CE_NOTE, "ldi_native_event: entered: ev=%s", evname));
2932 
2933 	for (i = 0; ldi_ev_cookies[i].ck_evname != NULL; i++) {
2934 		if (strcmp(ldi_ev_cookies[i].ck_evname, evname) == 0)
2935 			return (1);
2936 	}
2937 
2938 	return (0);
2939 }
2940 
2941 static uint_t
ldi_ev_sync_event(const char * evname)2942 ldi_ev_sync_event(const char *evname)
2943 {
2944 	int i;
2945 
2946 	ASSERT(ldi_native_event(evname));
2947 
2948 	LDI_EVTRC((CE_NOTE, "ldi_ev_sync_event: entered: %s", evname));
2949 
2950 	for (i = 0; ldi_ev_cookies[i].ck_evname != NULL; i++) {
2951 		if (strcmp(ldi_ev_cookies[i].ck_evname, evname) == 0)
2952 			return (ldi_ev_cookies[i].ck_sync);
2953 	}
2954 
2955 	/*
2956 	 * This should never happen until non-contract based
2957 	 * LDI events are introduced. If that happens, we will
2958 	 * use a "special" token to indicate that there are no
2959 	 * contracts corresponding to this LDI event.
2960 	 */
2961 	cmn_err(CE_PANIC, "Unknown LDI event: %s", evname);
2962 
2963 	return (0);
2964 }
2965 
2966 static uint_t
ldi_contract_event(const char * evname)2967 ldi_contract_event(const char *evname)
2968 {
2969 	int i;
2970 
2971 	ASSERT(ldi_native_event(evname));
2972 
2973 	LDI_EVTRC((CE_NOTE, "ldi_contract_event: entered: %s", evname));
2974 
2975 	for (i = 0; ldi_ev_cookies[i].ck_evname != NULL; i++) {
2976 		if (strcmp(ldi_ev_cookies[i].ck_evname, evname) == 0)
2977 			return (ldi_ev_cookies[i].ck_ctype);
2978 	}
2979 
2980 	/*
2981 	 * This should never happen until non-contract based
2982 	 * LDI events are introduced. If that happens, we will
2983 	 * use a "special" token to indicate that there are no
2984 	 * contracts corresponding to this LDI event.
2985 	 */
2986 	cmn_err(CE_PANIC, "Unknown LDI event: %s", evname);
2987 
2988 	return (0);
2989 }
2990 
2991 char *
ldi_ev_get_type(ldi_ev_cookie_t cookie)2992 ldi_ev_get_type(ldi_ev_cookie_t cookie)
2993 {
2994 	int i;
2995 	struct ldi_ev_cookie *cookie_impl = (struct ldi_ev_cookie *)cookie;
2996 
2997 	for (i = 0; ldi_ev_cookies[i].ck_evname != NULL; i++) {
2998 		if (&ldi_ev_cookies[i] == cookie_impl) {
2999 			LDI_EVTRC((CE_NOTE, "ldi_ev_get_type: LDI: %s",
3000 			    ldi_ev_cookies[i].ck_evname));
3001 			return (ldi_ev_cookies[i].ck_evname);
3002 		}
3003 	}
3004 
3005 	/*
3006 	 * Not an LDI native event. Must be NDI event service.
3007 	 * Just return a generic string
3008 	 */
3009 	LDI_EVTRC((CE_NOTE, "ldi_ev_get_type: is NDI"));
3010 	return (NDI_EVENT_SERVICE);
3011 }
3012 
3013 static int
ldi_native_cookie(ldi_ev_cookie_t cookie)3014 ldi_native_cookie(ldi_ev_cookie_t cookie)
3015 {
3016 	int i;
3017 	struct ldi_ev_cookie *cookie_impl = (struct ldi_ev_cookie *)cookie;
3018 
3019 	for (i = 0; ldi_ev_cookies[i].ck_evname != NULL; i++) {
3020 		if (&ldi_ev_cookies[i] == cookie_impl) {
3021 			LDI_EVTRC((CE_NOTE, "ldi_native_cookie: native LDI"));
3022 			return (1);
3023 		}
3024 	}
3025 
3026 	LDI_EVTRC((CE_NOTE, "ldi_native_cookie: is NDI"));
3027 	return (0);
3028 }
3029 
3030 static ldi_ev_cookie_t
ldi_get_native_cookie(const char * evname)3031 ldi_get_native_cookie(const char *evname)
3032 {
3033 	int i;
3034 
3035 	for (i = 0; ldi_ev_cookies[i].ck_evname != NULL; i++) {
3036 		if (strcmp(ldi_ev_cookies[i].ck_evname, evname) == 0) {
3037 			LDI_EVTRC((CE_NOTE, "ldi_get_native_cookie: found"));
3038 			return ((ldi_ev_cookie_t)&ldi_ev_cookies[i]);
3039 		}
3040 	}
3041 
3042 	LDI_EVTRC((CE_NOTE, "ldi_get_native_cookie: NOT found"));
3043 	return (NULL);
3044 }
3045 
3046 /*
3047  * ldi_ev_lock() needs to be recursive, since layered drivers may call
3048  * other LDI interfaces (such as ldi_close() from within the context of
3049  * a notify callback. Since the notify callback is called with the
3050  * ldi_ev_lock() held and ldi_close() also grabs ldi_ev_lock, the lock needs
3051  * to be recursive.
3052  */
3053 static void
ldi_ev_lock(void)3054 ldi_ev_lock(void)
3055 {
3056 	LDI_EVTRC((CE_NOTE, "ldi_ev_lock: entered"));
3057 
3058 	mutex_enter(&ldi_ev_callback_list.le_lock);
3059 	if (ldi_ev_callback_list.le_thread == curthread) {
3060 		ASSERT(ldi_ev_callback_list.le_busy >= 1);
3061 		ldi_ev_callback_list.le_busy++;
3062 	} else {
3063 		while (ldi_ev_callback_list.le_busy)
3064 			cv_wait(&ldi_ev_callback_list.le_cv,
3065 			    &ldi_ev_callback_list.le_lock);
3066 		ASSERT(ldi_ev_callback_list.le_thread == NULL);
3067 		ldi_ev_callback_list.le_busy = 1;
3068 		ldi_ev_callback_list.le_thread = curthread;
3069 	}
3070 	mutex_exit(&ldi_ev_callback_list.le_lock);
3071 
3072 	LDI_EVTRC((CE_NOTE, "ldi_ev_lock: exit"));
3073 }
3074 
3075 static void
ldi_ev_unlock(void)3076 ldi_ev_unlock(void)
3077 {
3078 	LDI_EVTRC((CE_NOTE, "ldi_ev_unlock: entered"));
3079 	mutex_enter(&ldi_ev_callback_list.le_lock);
3080 	ASSERT(ldi_ev_callback_list.le_thread == curthread);
3081 	ASSERT(ldi_ev_callback_list.le_busy >= 1);
3082 
3083 	ldi_ev_callback_list.le_busy--;
3084 	if (ldi_ev_callback_list.le_busy == 0) {
3085 		ldi_ev_callback_list.le_thread = NULL;
3086 		cv_signal(&ldi_ev_callback_list.le_cv);
3087 	}
3088 	mutex_exit(&ldi_ev_callback_list.le_lock);
3089 	LDI_EVTRC((CE_NOTE, "ldi_ev_unlock: exit"));
3090 }
3091 
3092 int
ldi_ev_get_cookie(ldi_handle_t lh,char * evname,ldi_ev_cookie_t * cookiep)3093 ldi_ev_get_cookie(ldi_handle_t lh, char *evname, ldi_ev_cookie_t *cookiep)
3094 {
3095 	struct ldi_handle	*handlep = (struct ldi_handle *)lh;
3096 	dev_info_t		*dip;
3097 	dev_t			dev;
3098 	int			res;
3099 	struct snode		*csp;
3100 	ddi_eventcookie_t	ddi_cookie;
3101 	ldi_ev_cookie_t		tcookie;
3102 
3103 	LDI_EVDBG((CE_NOTE, "ldi_ev_get_cookie: entered: evname=%s",
3104 	    evname ? evname : "<NULL>"));
3105 
3106 	if (lh == NULL || evname == NULL ||
3107 	    strlen(evname) == 0 || cookiep == NULL) {
3108 		LDI_EVDBG((CE_NOTE, "ldi_ev_get_cookie: invalid args"));
3109 		return (LDI_EV_FAILURE);
3110 	}
3111 
3112 	*cookiep = NULL;
3113 
3114 	/*
3115 	 * First check if it is a LDI native event
3116 	 */
3117 	tcookie = ldi_get_native_cookie(evname);
3118 	if (tcookie) {
3119 		LDI_EVDBG((CE_NOTE, "ldi_ev_get_cookie: got native cookie"));
3120 		*cookiep = tcookie;
3121 		return (LDI_EV_SUCCESS);
3122 	}
3123 
3124 	/*
3125 	 * Not a LDI native event. Try NDI event services
3126 	 */
3127 
3128 	dev = handlep->lh_vp->v_rdev;
3129 
3130 	csp = VTOCS(handlep->lh_vp);
3131 	mutex_enter(&csp->s_lock);
3132 	if ((dip = csp->s_dip) != NULL)
3133 		e_ddi_hold_devi(dip);
3134 	mutex_exit(&csp->s_lock);
3135 	if (dip == NULL)
3136 		dip = e_ddi_hold_devi_by_dev(dev, 0);
3137 
3138 	if (dip == NULL) {
3139 		cmn_err(CE_WARN, "ldi_ev_get_cookie: No devinfo node for LDI "
3140 		    "handle: %p", (void *)handlep);
3141 		return (LDI_EV_FAILURE);
3142 	}
3143 
3144 	LDI_EVDBG((CE_NOTE, "Calling ddi_get_eventcookie: dip=%p, ev=%s",
3145 	    (void *)dip, evname));
3146 
3147 	res = ddi_get_eventcookie(dip, evname, &ddi_cookie);
3148 
3149 	ddi_release_devi(dip);
3150 
3151 	if (res == DDI_SUCCESS) {
3152 		LDI_EVDBG((CE_NOTE, "ldi_ev_get_cookie: NDI cookie found"));
3153 		*cookiep = (ldi_ev_cookie_t)ddi_cookie;
3154 		return (LDI_EV_SUCCESS);
3155 	} else {
3156 		LDI_EVDBG((CE_WARN, "ldi_ev_get_cookie: NDI cookie: failed"));
3157 		return (LDI_EV_FAILURE);
3158 	}
3159 }
3160 
3161 /*ARGSUSED*/
3162 static void
i_ldi_ev_callback(dev_info_t * dip,ddi_eventcookie_t event_cookie,void * arg,void * ev_data)3163 i_ldi_ev_callback(dev_info_t *dip, ddi_eventcookie_t event_cookie,
3164     void *arg, void *ev_data)
3165 {
3166 	ldi_ev_callback_impl_t *lecp = (ldi_ev_callback_impl_t *)arg;
3167 
3168 	ASSERT(lecp != NULL);
3169 	ASSERT(!ldi_native_cookie(lecp->lec_cookie));
3170 	ASSERT(lecp->lec_lhp);
3171 	ASSERT(lecp->lec_notify == NULL);
3172 	ASSERT(lecp->lec_finalize);
3173 
3174 	LDI_EVDBG((CE_NOTE, "i_ldi_ev_callback: ldh=%p, cookie=%p, arg=%p, "
3175 	    "ev_data=%p", (void *)lecp->lec_lhp, (void *)event_cookie,
3176 	    (void *)lecp->lec_arg, (void *)ev_data));
3177 
3178 	lecp->lec_finalize(lecp->lec_lhp, (ldi_ev_cookie_t)event_cookie,
3179 	    lecp->lec_arg, ev_data);
3180 }
3181 
3182 int
ldi_ev_register_callbacks(ldi_handle_t lh,ldi_ev_cookie_t cookie,ldi_ev_callback_t * callb,void * arg,ldi_callback_id_t * id)3183 ldi_ev_register_callbacks(ldi_handle_t lh, ldi_ev_cookie_t cookie,
3184     ldi_ev_callback_t *callb, void *arg, ldi_callback_id_t *id)
3185 {
3186 	struct ldi_handle	*lhp = (struct ldi_handle *)lh;
3187 	ldi_ev_callback_impl_t	*lecp;
3188 	dev_t			dev;
3189 	struct snode		*csp;
3190 	dev_info_t		*dip;
3191 	int			ddi_event;
3192 
3193 	ASSERT(!servicing_interrupt());
3194 
3195 	if (lh == NULL || cookie == NULL || callb == NULL || id == NULL) {
3196 		LDI_EVDBG((CE_NOTE, "ldi_ev_register_callbacks: Invalid args"));
3197 		return (LDI_EV_FAILURE);
3198 	}
3199 
3200 	if (callb->cb_vers != LDI_EV_CB_VERS) {
3201 		LDI_EVDBG((CE_NOTE, "ldi_ev_register_callbacks: Invalid vers"));
3202 		return (LDI_EV_FAILURE);
3203 	}
3204 
3205 	if (callb->cb_notify == NULL && callb->cb_finalize == NULL) {
3206 		LDI_EVDBG((CE_NOTE, "ldi_ev_register_callbacks: NULL callb"));
3207 		return (LDI_EV_FAILURE);
3208 	}
3209 
3210 	*id = 0;
3211 
3212 	dev = lhp->lh_vp->v_rdev;
3213 	csp = VTOCS(lhp->lh_vp);
3214 	mutex_enter(&csp->s_lock);
3215 	if ((dip = csp->s_dip) != NULL)
3216 		e_ddi_hold_devi(dip);
3217 	mutex_exit(&csp->s_lock);
3218 	if (dip == NULL)
3219 		dip = e_ddi_hold_devi_by_dev(dev, 0);
3220 
3221 	if (dip == NULL) {
3222 		cmn_err(CE_WARN, "ldi_ev_register: No devinfo node for "
3223 		    "LDI handle: %p", (void *)lhp);
3224 		return (LDI_EV_FAILURE);
3225 	}
3226 
3227 	lecp = kmem_zalloc(sizeof (ldi_ev_callback_impl_t), KM_SLEEP);
3228 
3229 	ddi_event = 0;
3230 	if (!ldi_native_cookie(cookie)) {
3231 		if (callb->cb_notify || callb->cb_finalize == NULL) {
3232 			/*
3233 			 * NDI event services only accept finalize
3234 			 */
3235 			cmn_err(CE_WARN, "%s: module: %s: NDI event cookie. "
3236 			    "Only finalize"
3237 			    " callback supported with this cookie",
3238 			    "ldi_ev_register_callbacks",
3239 			    lhp->lh_ident->li_modname);
3240 			kmem_free(lecp, sizeof (ldi_ev_callback_impl_t));
3241 			ddi_release_devi(dip);
3242 			return (LDI_EV_FAILURE);
3243 		}
3244 
3245 		if (ddi_add_event_handler(dip, (ddi_eventcookie_t)cookie,
3246 		    i_ldi_ev_callback, (void *)lecp,
3247 		    (ddi_callback_id_t *)&lecp->lec_id)
3248 		    != DDI_SUCCESS) {
3249 			kmem_free(lecp, sizeof (ldi_ev_callback_impl_t));
3250 			ddi_release_devi(dip);
3251 			LDI_EVDBG((CE_NOTE, "ldi_ev_register_callbacks(): "
3252 			    "ddi_add_event_handler failed"));
3253 			return (LDI_EV_FAILURE);
3254 		}
3255 		ddi_event = 1;
3256 		LDI_EVDBG((CE_NOTE, "ldi_ev_register_callbacks(): "
3257 		    "ddi_add_event_handler success"));
3258 	}
3259 
3260 
3261 
3262 	ldi_ev_lock();
3263 
3264 	/*
3265 	 * Add the notify/finalize callback to the LDI's list of callbacks.
3266 	 */
3267 	lecp->lec_lhp = lhp;
3268 	lecp->lec_dev = lhp->lh_vp->v_rdev;
3269 	lecp->lec_spec = VTYP_TO_STYP(lhp->lh_vp->v_type);
3270 	lecp->lec_notify = callb->cb_notify;
3271 	lecp->lec_finalize = callb->cb_finalize;
3272 	lecp->lec_arg = arg;
3273 	lecp->lec_cookie = cookie;
3274 	if (!ddi_event)
3275 		lecp->lec_id = (void *)(uintptr_t)(++ldi_ev_id_pool);
3276 	else
3277 		ASSERT(lecp->lec_id);
3278 	lecp->lec_dip = dip;
3279 	list_insert_tail(&ldi_ev_callback_list.le_head, lecp);
3280 
3281 	*id = (ldi_callback_id_t)lecp->lec_id;
3282 
3283 	ldi_ev_unlock();
3284 
3285 	ddi_release_devi(dip);
3286 
3287 	LDI_EVDBG((CE_NOTE, "ldi_ev_register_callbacks: registered "
3288 	    "notify/finalize"));
3289 
3290 	return (LDI_EV_SUCCESS);
3291 }
3292 
3293 static int
ldi_ev_device_match(ldi_ev_callback_impl_t * lecp,dev_info_t * dip,dev_t dev,int spec_type)3294 ldi_ev_device_match(ldi_ev_callback_impl_t *lecp, dev_info_t *dip,
3295     dev_t dev, int spec_type)
3296 {
3297 	ASSERT(lecp);
3298 	ASSERT(dip);
3299 	ASSERT(dev != DDI_DEV_T_NONE);
3300 	ASSERT(dev != NODEV);
3301 	ASSERT((dev == DDI_DEV_T_ANY && spec_type == 0) ||
3302 	    (spec_type == S_IFCHR || spec_type == S_IFBLK));
3303 	ASSERT(lecp->lec_dip);
3304 	ASSERT(lecp->lec_spec == S_IFCHR || lecp->lec_spec == S_IFBLK);
3305 	ASSERT(lecp->lec_dev != DDI_DEV_T_ANY);
3306 	ASSERT(lecp->lec_dev != DDI_DEV_T_NONE);
3307 	ASSERT(lecp->lec_dev != NODEV);
3308 
3309 	if (dip != lecp->lec_dip)
3310 		return (0);
3311 
3312 	if (dev != DDI_DEV_T_ANY) {
3313 		if (dev != lecp->lec_dev || spec_type != lecp->lec_spec)
3314 			return (0);
3315 	}
3316 
3317 	LDI_EVTRC((CE_NOTE, "ldi_ev_device_match: MATCH dip=%p", (void *)dip));
3318 
3319 	return (1);
3320 }
3321 
3322 /*
3323  * LDI framework function to post a "notify" event to all layered drivers
3324  * that have registered for that event
3325  *
3326  * Returns:
3327  *		LDI_EV_SUCCESS - registered callbacks allow event
3328  *		LDI_EV_FAILURE - registered callbacks block event
3329  *		LDI_EV_NONE    - No matching LDI callbacks
3330  *
3331  * This function is *not* to be called by layered drivers. It is for I/O
3332  * framework code in Solaris, such as the I/O retire code and DR code
3333  * to call while servicing a device event such as offline or degraded.
3334  */
3335 int
ldi_invoke_notify(dev_info_t * dip,dev_t dev,int spec_type,char * event,void * ev_data)3336 ldi_invoke_notify(dev_info_t *dip, dev_t dev, int spec_type, char *event,
3337     void *ev_data)
3338 {
3339 	ldi_ev_callback_impl_t *lecp;
3340 	list_t	*listp;
3341 	int	ret;
3342 	char	*lec_event;
3343 
3344 	ASSERT(dip);
3345 	ASSERT(dev != DDI_DEV_T_NONE);
3346 	ASSERT(dev != NODEV);
3347 	ASSERT((dev == DDI_DEV_T_ANY && spec_type == 0) ||
3348 	    (spec_type == S_IFCHR || spec_type == S_IFBLK));
3349