OpenSolaris_b135/uts/common/os/driver_lyr.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Layered driver support.
*/
#include <sys/atomic.h>
#include <sys/types.h>
#include <sys/t_lock.h>
#include <sys/param.h>
#include <sys/conf.h>
#include <sys/systm.h>
#include <sys/sysmacros.h>
#include <sys/buf.h>
#include <sys/cred.h>
#include <sys/uio.h>
#include <sys/vnode.h>
#include <sys/fs/snode.h>
#include <sys/open.h>
#include <sys/kmem.h>
#include <sys/file.h>
#include <sys/bootconf.h>
#include <sys/pathname.h>
#include <sys/bitmap.h>
#include <sys/stat.h>
#include <sys/dditypes.h>
#include <sys/ddi_impldefs.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>
#include <sys/esunddi.h>
#include <sys/autoconf.h>
#include <sys/sunldi.h>
#include <sys/sunldi_impl.h>
#include <sys/errno.h>
#include <sys/debug.h>
#include <sys/modctl.h>
#include <sys/var.h>
#include <vm/seg_vn.h>
#include <sys/stropts.h>
#include <sys/strsubr.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/kstr.h>
/*
* Device contract related
*/
#include <sys/contract_impl.h>
#include <sys/contract/device_impl.h>
/*
* Define macros to manipulate snode, vnode, and open device flags
*/
#define VTYP_VALID(i) (((i) == VCHR) || ((i) == VBLK))
#define VTYP_TO_OTYP(i) (((i) == VCHR) ? OTYP_CHR : OTYP_BLK)
#define VTYP_TO_STYP(i) (((i) == VCHR) ? S_IFCHR : S_IFBLK)
#define OTYP_VALID(i) (((i) == OTYP_CHR) || ((i) == OTYP_BLK))
#define OTYP_TO_VTYP(i) (((i) == OTYP_CHR) ? VCHR : VBLK)
#define OTYP_TO_STYP(i) (((i) == OTYP_CHR) ? S_IFCHR : S_IFBLK)
#define STYP_VALID(i) (((i) == S_IFCHR) || ((i) == S_IFBLK))
#define STYP_TO_VTYP(i) (((i) == S_IFCHR) ? VCHR : VBLK)
/*
* Define macros for accessing layered driver hash structures
*/
#define LH_HASH(vp) (handle_hash_func(vp) % LH_HASH_SZ)
#define LI_HASH(mid, dip, dev) (ident_hash_func(mid, dip, dev) % LI_HASH_SZ)
/*
* Define layered handle flags used in the lh_type field
*/
#define LH_STREAM (0x1) /* handle to a streams device */
#define LH_CBDEV (0x2) /* handle to a char/block device */
/*
* Define macro for devid property lookups
*/
#define DEVID_PROP_FLAGS (DDI_PROP_DONTPASS | \
DDI_PROP_TYPE_STRING|DDI_PROP_CANSLEEP)
/*
* Dummy string for NDI events
*/
#define NDI_EVENT_SERVICE "NDI_EVENT_SERVICE"
static void ldi_ev_lock(void);
static void ldi_ev_unlock(void);
#ifdef LDI_OBSOLETE_EVENT
int ldi_remove_event_handler(ldi_handle_t lh, ldi_callback_id_t id);
#endif
/*
* globals
*/
static kmutex_t ldi_ident_hash_lock[LI_HASH_SZ];
static struct ldi_ident *ldi_ident_hash[LI_HASH_SZ];
static kmutex_t ldi_handle_hash_lock[LH_HASH_SZ];
static struct ldi_handle *ldi_handle_hash[LH_HASH_SZ];
static size_t ldi_handle_hash_count;
static struct ldi_ev_callback_list ldi_ev_callback_list;
static uint32_t ldi_ev_id_pool = 0;
struct ldi_ev_cookie {
char *ck_evname;
uint_t ck_sync;
uint_t ck_ctype;
};
static struct ldi_ev_cookie ldi_ev_cookies[] = {
{ LDI_EV_OFFLINE, 1, CT_DEV_EV_OFFLINE},
{ LDI_EV_DEGRADE, 0, CT_DEV_EV_DEGRADED},
{ NULL} /* must terminate list */
};
void
ldi_init(void)
{
int i;
ldi_handle_hash_count = 0;
for (i = 0; i < LH_HASH_SZ; i++) {
mutex_init(&ldi_handle_hash_lock[i], NULL, MUTEX_DEFAULT, NULL);
ldi_handle_hash[i] = NULL;
}
for (i = 0; i < LI_HASH_SZ; i++) {
mutex_init(&ldi_ident_hash_lock[i], NULL, MUTEX_DEFAULT, NULL);
ldi_ident_hash[i] = NULL;
}
/*
* Initialize the LDI event subsystem
*/
mutex_init(&ldi_ev_callback_list.le_lock, NULL, MUTEX_DEFAULT, NULL);
cv_init(&ldi_ev_callback_list.le_cv, NULL, CV_DEFAULT, NULL);
ldi_ev_callback_list.le_busy = 0;
ldi_ev_callback_list.le_thread = NULL;
list_create(&ldi_ev_callback_list.le_head,
sizeof (ldi_ev_callback_impl_t),
offsetof(ldi_ev_callback_impl_t, lec_list));
}
/*
* LDI ident manipulation functions
*/
static uint_t
ident_hash_func(modid_t modid, dev_info_t *dip, dev_t dev)
{
if (dip != NULL) {
uintptr_t k = (uintptr_t)dip;
k >>= (int)highbit(sizeof (struct dev_info));
return ((uint_t)k);
} else if (dev != DDI_DEV_T_NONE) {
return (modid + getminor(dev) + getmajor(dev));
} else {
return (modid);
}
}
static struct ldi_ident **
ident_find_ref_nolock(modid_t modid, dev_info_t *dip, dev_t dev, major_t major)
{
struct ldi_ident **lipp = NULL;
uint_t index = LI_HASH(modid, dip, dev);
ASSERT(MUTEX_HELD(&ldi_ident_hash_lock[index]));
for (lipp = &(ldi_ident_hash[index]);
(*lipp != NULL);
lipp = &((*lipp)->li_next)) {
if (((*lipp)->li_modid == modid) &&
((*lipp)->li_major == major) &&
((*lipp)->li_dip == dip) &&
((*lipp)->li_dev == dev))
break;
}
ASSERT(lipp != NULL);
return (lipp);
}
static struct ldi_ident *
ident_alloc(char *mod_name, dev_info_t *dip, dev_t dev, major_t major)
{
struct ldi_ident *lip, **lipp;
modid_t modid;
uint_t index;
ASSERT(mod_name != NULL);
/* get the module id */
modid = mod_name_to_modid(mod_name);
ASSERT(modid != -1);
/* allocate a new ident in case we need it */
lip = kmem_zalloc(sizeof (*lip), KM_SLEEP);
/* search the hash for a matching ident */
index = LI_HASH(modid, dip, dev);
mutex_enter(&ldi_ident_hash_lock[index]);
lipp = ident_find_ref_nolock(modid, dip, dev, major);
if (*lipp != NULL) {
/* we found an ident in the hash */
ASSERT(strcmp((*lipp)->li_modname, mod_name) == 0);
(*lipp)->li_ref++;
mutex_exit(&ldi_ident_hash_lock[index]);
kmem_free(lip, sizeof (struct ldi_ident));
return (*lipp);
}
/* initialize the new ident */
lip->li_next = NULL;
lip->li_ref = 1;
lip->li_modid = modid;
lip->li_major = major;
lip->li_dip = dip;
lip->li_dev = dev;
(void) strncpy(lip->li_modname, mod_name, sizeof (lip->li_modname) - 1);
/* add it to the ident hash */
lip->li_next = ldi_ident_hash[index];
ldi_ident_hash[index] = lip;
mutex_exit(&ldi_ident_hash_lock[index]);
return (lip);
}
static void
ident_hold(struct ldi_ident *lip)
{
uint_t index;
ASSERT(lip != NULL);
index = LI_HASH(lip->li_modid, lip->li_dip, lip->li_dev);
mutex_enter(&ldi_ident_hash_lock[index]);
ASSERT(lip->li_ref > 0);
lip->li_ref++;
mutex_exit(&ldi_ident_hash_lock[index]);
}
static void
ident_release(struct ldi_ident *lip)
{
struct ldi_ident **lipp;
uint_t index;
ASSERT(lip != NULL);
index = LI_HASH(lip->li_modid, lip->li_dip, lip->li_dev);
mutex_enter(&ldi_ident_hash_lock[index]);
ASSERT(lip->li_ref > 0);
if (--lip->li_ref > 0) {
/* there are more references to this ident */
mutex_exit(&ldi_ident_hash_lock[index]);
return;
}
/* this was the last reference/open for this ident. free it. */
lipp = ident_find_ref_nolock(
lip->li_modid, lip->li_dip, lip->li_dev, lip->li_major);
ASSERT((lipp != NULL) && (*lipp != NULL));
*lipp = lip->li_next;
mutex_exit(&ldi_ident_hash_lock[index]);
kmem_free(lip, sizeof (struct ldi_ident));
}
/*
* LDI handle manipulation functions
*/
static uint_t
handle_hash_func(void *vp)
{
uintptr_t k = (uintptr_t)vp;
k >>= (int)highbit(sizeof (vnode_t));
return ((uint_t)k);
}
static struct ldi_handle **
handle_find_ref_nolock(vnode_t *vp, struct ldi_ident *ident)
{
struct ldi_handle **lhpp = NULL;
uint_t index = LH_HASH(vp);
ASSERT(MUTEX_HELD(&ldi_handle_hash_lock[index]));
for (lhpp = &(ldi_handle_hash[index]);
(*lhpp != NULL);
lhpp = &((*lhpp)->lh_next)) {
if (((*lhpp)->lh_ident == ident) &&
((*lhpp)->lh_vp == vp))
break;
}
ASSERT(lhpp != NULL);
return (lhpp);
}
static struct ldi_handle *
handle_find(vnode_t *vp, struct ldi_ident *ident)
{
struct ldi_handle **lhpp;
int index = LH_HASH(vp);
mutex_enter(&ldi_handle_hash_lock[index]);
lhpp = handle_find_ref_nolock(vp, ident);
mutex_exit(&ldi_handle_hash_lock[index]);
ASSERT(lhpp != NULL);
return (*lhpp);
}
static struct ldi_handle *
handle_alloc(vnode_t *vp, struct ldi_ident *ident)
{
struct ldi_handle *lhp, **lhpp;
uint_t index;
ASSERT((vp != NULL) && (ident != NULL));
/* allocate a new handle in case we need it */
lhp = kmem_zalloc(sizeof (*lhp), KM_SLEEP);
/* search the hash for a matching handle */
index = LH_HASH(vp);
mutex_enter(&ldi_handle_hash_lock[index]);
lhpp = handle_find_ref_nolock(vp, ident);
if (*lhpp != NULL) {
/* we found a handle in the hash */
(*lhpp)->lh_ref++;
mutex_exit(&ldi_handle_hash_lock[index]);
LDI_ALLOCFREE((CE_WARN, "ldi handle alloc: dup "
"lh=0x%p, ident=0x%p, vp=0x%p, drv=%s, minor=0x%x",
(void *)*lhpp, (void *)ident, (void *)vp,
mod_major_to_name(getmajor(vp->v_rdev)),
getminor(vp->v_rdev)));
kmem_free(lhp, sizeof (struct ldi_handle));
return (*lhpp);
}
/* initialize the new handle */
lhp->lh_ref = 1;
lhp->lh_vp = vp;
lhp->lh_ident = ident;
#ifdef LDI_OBSOLETE_EVENT
mutex_init(lhp->lh_lock, NULL, MUTEX_DEFAULT, NULL);
#endif
/* set the device type for this handle */
lhp->lh_type = 0;
if (vp->v_stream) {
ASSERT(vp->v_type == VCHR);
lhp->lh_type |= LH_STREAM;
} else {
lhp->lh_type |= LH_CBDEV;
}
/* get holds on other objects */
ident_hold(ident);
ASSERT(vp->v_count >= 1);
VN_HOLD(vp);
/* add it to the handle hash */
lhp->lh_next = ldi_handle_hash[index];
ldi_handle_hash[index] = lhp;
atomic_add_long(&ldi_handle_hash_count, 1);
LDI_ALLOCFREE((CE_WARN, "ldi handle alloc: new "
"lh=0x%p, ident=0x%p, vp=0x%p, drv=%s, minor=0x%x",
(void *)lhp, (void *)ident, (void *)vp,
mod_major_to_name(getmajor(vp->v_rdev)),
getminor(vp->v_rdev)));
mutex_exit(&ldi_handle_hash_lock[index]);
return (lhp);
}
static void
handle_release(struct ldi_handle *lhp)
{
struct ldi_handle **lhpp;
uint_t index;
ASSERT(lhp != NULL);
index = LH_HASH(lhp->lh_vp);
mutex_enter(&ldi_handle_hash_lock[index]);
LDI_ALLOCFREE((CE_WARN, "ldi handle release: "
"lh=0x%p, ident=0x%p, vp=0x%p, drv=%s, minor=0x%x",
(void *)lhp, (void *)lhp->lh_ident, (void *)lhp->lh_vp,
mod_major_to_name(getmajor(lhp->lh_vp->v_rdev)),
getminor(lhp->lh_vp->v_rdev)));
ASSERT(lhp->lh_ref > 0);
if (--lhp->lh_ref > 0) {
/* there are more references to this handle */
mutex_exit(&ldi_handle_hash_lock[index]);
return;
}
/* this was the last reference/open for this handle. free it. */
lhpp = handle_find_ref_nolock(lhp->lh_vp, lhp->lh_ident);
ASSERT((lhpp != NULL) && (*lhpp != NULL));
*lhpp = lhp->lh_next;
atomic_add_long(&ldi_handle_hash_count, -1);
mutex_exit(&ldi_handle_hash_lock[index]);
VN_RELE(lhp->lh_vp);
ident_release(lhp->lh_ident);
#ifdef LDI_OBSOLETE_EVENT
mutex_destroy(lhp->lh_lock);
#endif
kmem_free(lhp, sizeof (struct ldi_handle));
}
#ifdef LDI_OBSOLETE_EVENT
/*
* LDI event manipulation functions
*/
static void
handle_event_add(ldi_event_t *lep)
{
struct ldi_handle *lhp = lep->le_lhp;
ASSERT(lhp != NULL);
mutex_enter(lhp->lh_lock);
if (lhp->lh_events == NULL) {
lhp->lh_events = lep;
mutex_exit(lhp->lh_lock);
return;
}
lep->le_next = lhp->lh_events;
lhp->lh_events->le_prev = lep;
lhp->lh_events = lep;
mutex_exit(lhp->lh_lock);
}
static void
handle_event_remove(ldi_event_t *lep)
{
struct ldi_handle *lhp = lep->le_lhp;
ASSERT(lhp != NULL);
mutex_enter(lhp->lh_lock);
if (lep->le_prev)
lep->le_prev->le_next = lep->le_next;
if (lep->le_next)
lep->le_next->le_prev = lep->le_prev;
if (lhp->lh_events == lep)
lhp->lh_events = lep->le_next;
mutex_exit(lhp->lh_lock);
}
static void
i_ldi_callback(dev_info_t *dip, ddi_eventcookie_t event_cookie,
void *arg, void *bus_impldata)
{
ldi_event_t *lep = (ldi_event_t *)arg;
ASSERT(lep != NULL);
LDI_EVENTCB((CE_NOTE, "%s: dip=0x%p, "
"event_cookie=0x%p, ldi_eventp=0x%p", "i_ldi_callback",
(void *)dip, (void *)event_cookie, (void *)lep));
lep->le_handler(lep->le_lhp, event_cookie, lep->le_arg, bus_impldata);
}
#endif
/*
* LDI open helper functions
*/
/* get a vnode to a device by dev_t and otyp */
static int
ldi_vp_from_dev(dev_t dev, int otyp, vnode_t **vpp)
{
dev_info_t *dip;
vnode_t *vp;
/* sanity check required input parameters */
if ((dev == DDI_DEV_T_NONE) || (!OTYP_VALID(otyp)) || (vpp == NULL))
return (EINVAL);
if ((dip = e_ddi_hold_devi_by_dev(dev, 0)) == NULL)
return (ENODEV);
vp = makespecvp(dev, OTYP_TO_VTYP(otyp));
spec_assoc_vp_with_devi(vp, dip);
ddi_release_devi(dip); /* from e_ddi_hold_devi_by_dev */
*vpp = vp;
return (0);
}
/* get a vnode to a device by pathname */
static int
ldi_vp_from_name(char *path, vnode_t **vpp)
{
vnode_t *vp = NULL;
int ret;
/* sanity check required input parameters */
if ((path == NULL) || (vpp == NULL))
return (EINVAL);
if (modrootloaded) {
cred_t *saved_cred = curthread->t_cred;
/* we don't want lookupname to fail because of credentials */
curthread->t_cred = kcred;
/*
* all lookups should be done in the global zone. but
* lookupnameat() won't actually do this if an absolute
* path is passed in. since the ldi interfaces require an
* absolute path we pass lookupnameat() a pointer to
* the character after the leading '/' and tell it to
* start searching at the current system root directory.
*/
ASSERT(*path == '/');
ret = lookupnameat(path + 1, UIO_SYSSPACE, FOLLOW, NULLVPP,
&vp, rootdir);
/* restore this threads credentials */
curthread->t_cred = saved_cred;
if (ret == 0) {
if (!vn_matchops(vp, spec_getvnodeops()) ||
!VTYP_VALID(vp->v_type)) {
VN_RELE(vp);
return (ENXIO);
}
}
}
if (vp == NULL) {
dev_info_t *dip;
dev_t dev;
int spec_type;
/*
* Root is not mounted, the minor node is not specified,
* or an OBP path has been specified.
*/
/*
* Determine if path can be pruned to produce an
* OBP or devfs path for resolve_pathname.
*/
if (strncmp(path, "/devices/", 9) == 0)
path += strlen("/devices");
/*
* if no minor node was specified the DEFAULT minor node
* will be returned. if there is no DEFAULT minor node
* one will be fabricated of type S_IFCHR with the minor
* number equal to the instance number.
*/
ret = resolve_pathname(path, &dip, &dev, &spec_type);
if (ret != 0)
return (ENODEV);
ASSERT(STYP_VALID(spec_type));
vp = makespecvp(dev, STYP_TO_VTYP(spec_type));
spec_assoc_vp_with_devi(vp, dip);
ddi_release_devi(dip);
}
*vpp = vp;
return (0);
}
static int
ldi_devid_match(ddi_devid_t devid, dev_info_t *dip, dev_t dev)
{
char *devidstr;
ddi_prop_t *propp;
/* convert devid as a string property */
if ((devidstr = ddi_devid_str_encode(devid, NULL)) == NULL)
return (0);
/*
* Search for the devid. For speed and ease in locking this
* code directly uses the property implementation. See
* ddi_common_devid_to_devlist() for a comment as to why.
*/
mutex_enter(&(DEVI(dip)->devi_lock));
/* check if there is a DDI_DEV_T_NONE devid property */
propp = i_ddi_prop_search(DDI_DEV_T_NONE,
DEVID_PROP_NAME, DEVID_PROP_FLAGS, &DEVI(dip)->devi_hw_prop_ptr);
if (propp != NULL) {
if (ddi_devid_str_compare(propp->prop_val, devidstr) == 0) {
/* a DDI_DEV_T_NONE devid exists and matchs */
mutex_exit(&(DEVI(dip)->devi_lock));
ddi_devid_str_free(devidstr);
return (1);
} else {
/* a DDI_DEV_T_NONE devid exists and doesn't match */
mutex_exit(&(DEVI(dip)->devi_lock));
ddi_devid_str_free(devidstr);
return (0);
}
}
/* check if there is a devt specific devid property */
propp = i_ddi_prop_search(dev,
DEVID_PROP_NAME, DEVID_PROP_FLAGS, &(DEVI(dip)->devi_hw_prop_ptr));
if (propp != NULL) {
if (ddi_devid_str_compare(propp->prop_val, devidstr) == 0) {
/* a devt specific devid exists and matchs */
mutex_exit(&(DEVI(dip)->devi_lock));
ddi_devid_str_free(devidstr);
return (1);
} else {
/* a devt specific devid exists and doesn't match */
mutex_exit(&(DEVI(dip)->devi_lock));
ddi_devid_str_free(devidstr);
return (0);
}
}
/* we didn't find any devids associated with the device */
mutex_exit(&(DEVI(dip)->devi_lock));
ddi_devid_str_free(devidstr);
return (0);
}
/* get a handle to a device by devid and minor name */
static int
ldi_vp_from_devid(ddi_devid_t devid, char *minor_name, vnode_t **vpp)
{
dev_info_t *dip;
vnode_t *vp;
int ret, i, ndevs, styp;
dev_t dev, *devs;
/* sanity check required input parameters */
if ((devid == NULL) || (minor_name == NULL) || (vpp == NULL))
return (EINVAL);
ret = ddi_lyr_devid_to_devlist(devid, minor_name, &ndevs, &devs);
if ((ret != DDI_SUCCESS) || (ndevs <= 0))
return (ENODEV);
for (i = 0; i < ndevs; i++) {
dev = devs[i];
if ((dip = e_ddi_hold_devi_by_dev(dev, 0)) == NULL)
continue;
/*
* now we have to verify that the devid of the disk
* still matches what was requested.
*
* we have to do this because the devid could have
* changed between the call to ddi_lyr_devid_to_devlist()
* and e_ddi_hold_devi_by_dev(). this is because when
* ddi_lyr_devid_to_devlist() returns a list of devts
* there is no kind of hold on those devts so a device
* could have been replaced out from under us in the
* interim.
*/
if ((i_ddi_minorname_to_devtspectype(dip, minor_name,
NULL, &styp) == DDI_SUCCESS) &&
ldi_devid_match(devid, dip, dev))
break;
ddi_release_devi(dip); /* from e_ddi_hold_devi_by_dev() */
}
ddi_lyr_free_devlist(devs, ndevs);
if (i == ndevs)
return (ENODEV);
ASSERT(STYP_VALID(styp));
vp = makespecvp(dev, STYP_TO_VTYP(styp));
spec_assoc_vp_with_devi(vp, dip);
ddi_release_devi(dip); /* from e_ddi_hold_devi_by_dev */
*vpp = vp;
return (0);
}
/* given a vnode, open a device */
static int
ldi_open_by_vp(vnode_t **vpp, int flag, cred_t *cr,
ldi_handle_t *lhp, struct ldi_ident *li)
{
struct ldi_handle *nlhp;
vnode_t *vp;
int err;
ASSERT((vpp != NULL) && (*vpp != NULL));
ASSERT((lhp != NULL) && (li != NULL));
vp = *vpp;
/* if the vnode passed in is not a device, then bail */
if (!vn_matchops(vp, spec_getvnodeops()) || !VTYP_VALID(vp->v_type))
return (ENXIO);
/*
* the caller may have specified a node that
* doesn't have cb_ops defined. the ldi doesn't yet
* support opening devices without a valid cb_ops.
*/
if (devopsp[getmajor(vp->v_rdev)]->devo_cb_ops == NULL)
return (ENXIO);
/* open the device */
if ((err = VOP_OPEN(&vp, flag | FKLYR, cr, NULL)) != 0)
return (err);
/* possible clone open, make sure that we still have a spec node */
ASSERT(vn_matchops(vp, spec_getvnodeops()));
nlhp = handle_alloc(vp, li);
if (vp != *vpp) {
/*
* allocating the layered handle took a new hold on the vnode
* so we can release the hold that was returned by the clone
* open
*/
LDI_OPENCLOSE((CE_WARN, "%s: lh=0x%p",
"ldi clone open", (void *)nlhp));
} else {
LDI_OPENCLOSE((CE_WARN, "%s: lh=0x%p",
"ldi open", (void *)nlhp));
}
*vpp = vp;
*lhp = (ldi_handle_t)nlhp;
return (0);
}
/* Call a drivers prop_op(9E) interface */
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)
{
struct dev_ops *ops = NULL;
int res;
ASSERT((dip != NULL) && (name != NULL));
ASSERT((prop_op == PROP_LEN) || (valuep != NULL));
ASSERT(lengthp != NULL);
/*
* we can only be invoked after a driver has been opened and
* someone has a layered handle to it, so there had better be
* a valid ops vector.
*/
ops = DEVI(dip)->devi_ops;
ASSERT(ops && ops->devo_cb_ops);
/*
* Some nexus drivers incorrectly set cb_prop_op to nodev,
* nulldev or even NULL.
*/
if ((ops->devo_cb_ops->cb_prop_op == nodev) ||
(ops->devo_cb_ops->cb_prop_op == nulldev) ||
(ops->devo_cb_ops->cb_prop_op == NULL)) {
return (DDI_PROP_NOT_FOUND);
}
/* check if this is actually DDI_DEV_T_ANY query */
if (flags & LDI_DEV_T_ANY) {
flags &= ~LDI_DEV_T_ANY;
dev = DDI_DEV_T_ANY;
}
res = cdev_prop_op(dev, dip, prop_op, flags, name, valuep, lengthp);
return (res);
}
static void
i_ldi_prop_op_free(struct prop_driver_data *pdd)
{
kmem_free(pdd, pdd->pdd_size);
}
static caddr_t
i_ldi_prop_op_alloc(int prop_len)
{
struct prop_driver_data *pdd;
int pdd_size;
pdd_size = sizeof (struct prop_driver_data) + prop_len;
pdd = kmem_alloc(pdd_size, KM_SLEEP);
pdd->pdd_size = pdd_size;
pdd->pdd_prop_free = i_ldi_prop_op_free;
return ((caddr_t)&pdd[1]);
}
/*
* i_ldi_prop_op_typed() is a wrapper for i_ldi_prop_op that is used
* by the typed ldi property lookup interfaces.
*/
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)
{
caddr_t prop_val;
int prop_len, res;
ASSERT((dip != NULL) && (name != NULL));
ASSERT((datap != NULL) && (lengthp != NULL));
/*
* first call the drivers prop_op() interface to allow it
* it to override default property values.
*/
res = i_ldi_prop_op(dev, dip, PROP_LEN,
flags | DDI_PROP_DYNAMIC, name, NULL, &prop_len);
if (res != DDI_PROP_SUCCESS)
return (DDI_PROP_NOT_FOUND);
/* sanity check the property length */
if (prop_len == 0) {
/*
* the ddi typed interfaces don't allow a drivers to
* create properties with a length of 0. so we should
* prevent drivers from returning 0 length dynamic
* properties for typed property lookups.
*/
return (DDI_PROP_NOT_FOUND);
}
/* sanity check the property length against the element size */
if (elem_size && ((prop_len % elem_size) != 0))
return (DDI_PROP_NOT_FOUND);
/*
* got it. now allocate a prop_driver_data struct so that the
* user can free the property via ddi_prop_free().
*/
prop_val = i_ldi_prop_op_alloc(prop_len);
/* lookup the property again, this time get the value */
res = i_ldi_prop_op(dev, dip, PROP_LEN_AND_VAL_BUF,
flags | DDI_PROP_DYNAMIC, name, prop_val, &prop_len);
if (res != DDI_PROP_SUCCESS) {
ddi_prop_free(prop_val);
return (DDI_PROP_NOT_FOUND);
}
/* sanity check the property length */
if (prop_len == 0) {
ddi_prop_free(prop_val);
return (DDI_PROP_NOT_FOUND);
}
/* sanity check the property length against the element size */
if (elem_size && ((prop_len % elem_size) != 0)) {
ddi_prop_free(prop_val);
return (DDI_PROP_NOT_FOUND);
}
/*
* return the prop_driver_data struct and, optionally, the length
* of the data.
*/
*datap = prop_val;
*lengthp = prop_len;
return (DDI_PROP_SUCCESS);
}
/*
* i_check_string looks at a string property and makes sure its
* a valid null terminated string
*/
static int
i_check_string(char *str, int prop_len)
{
int i;
ASSERT(str != NULL);
for (i = 0; i < prop_len; i++) {
if (str[i] == '\0')
return (0);
}
return (1);
}
/*
* i_pack_string_array takes a a string array property that is represented
* as a concatenation of strings (with the NULL character included for
* each string) and converts it into a format that can be returned by
* ldi_prop_lookup_string_array.
*/
static int
i_pack_string_array(char *str_concat, int prop_len,
char ***str_arrayp, int *nelemp)
{
int i, nelem, pack_size;
char **str_array, *strptr;
/*
* first we need to sanity check the input string array.
* in essence this can be done my making sure that the last
* character of the array passed in is null. (meaning the last
* string in the array is NULL terminated.
*/
if (str_concat[prop_len - 1] != '\0')
return (1);
/* now let's count the number of strings in the array */
for (nelem = i = 0; i < prop_len; i++)
if (str_concat[i] == '\0')
nelem++;
ASSERT(nelem >= 1);
/* now let's allocate memory for the new packed property */
pack_size = (sizeof (char *) * (nelem + 1)) + prop_len;
str_array = (char **)i_ldi_prop_op_alloc(pack_size);
/* let's copy the actual string data into the new property */
strptr = (char *)&(str_array[nelem + 1]);
bcopy(str_concat, strptr, prop_len);
/* now initialize the string array pointers */
for (i = 0; i < nelem; i++) {
str_array[i] = strptr;
strptr += strlen(strptr) + 1;
}
str_array[nelem] = NULL;
/* set the return values */
*str_arrayp = str_array;
*nelemp = nelem;
return (0);
}
/*
* LDI Project private device usage interfaces
*/
/*
* Get a count of how many devices are currentl open by different consumers
*/
int
ldi_usage_count()
{
return (ldi_handle_hash_count);
}
static void
ldi_usage_walker_tgt_helper(ldi_usage_t *ldi_usage, vnode_t *vp)
{
dev_info_t *dip;
dev_t dev;
ASSERT(STYP_VALID(VTYP_TO_STYP(vp->v_type)));
/* get the target devt */
dev = vp->v_rdev;
/* try to get the target dip */
dip = VTOCS(vp)->s_dip;
if (dip != NULL) {
e_ddi_hold_devi(dip);
} else if (dev != DDI_DEV_T_NONE) {
dip = e_ddi_hold_devi_by_dev(dev, 0);
}
/* set the target information */
ldi_usage->tgt_name = mod_major_to_name(getmajor(dev));
ldi_usage->tgt_modid = mod_name_to_modid(ldi_usage->tgt_name);
ldi_usage->tgt_devt = dev;
ldi_usage->tgt_spec_type = VTYP_TO_STYP(vp->v_type);
ldi_usage->tgt_dip = dip;
}
static int
ldi_usage_walker_helper(struct ldi_ident *lip, vnode_t *vp,
void *arg, int (*callback)(const ldi_usage_t *, void *))
{
ldi_usage_t ldi_usage;
struct devnames *dnp;
dev_info_t *dip;
major_t major;
dev_t dev;
int ret = LDI_USAGE_CONTINUE;
/* set the target device information */
ldi_usage_walker_tgt_helper(&ldi_usage, vp);
/* get the source devt */
dev = lip->li_dev;
/* try to get the source dip */
dip = lip->li_dip;
if (dip != NULL) {
e_ddi_hold_devi(dip);
} else if (dev != DDI_DEV_T_NONE) {
dip = e_ddi_hold_devi_by_dev(dev, 0);
}
/* set the valid source information */
ldi_usage.src_modid = lip->li_modid;
ldi_usage.src_name = lip->li_modname;
ldi_usage.src_devt = dev;
ldi_usage.src_dip = dip;
/*
* if the source ident represents either:
*
* - a kernel module (and not a device or device driver)
* - a device node
*
* then we currently have all the info we need to report the
* usage information so invoke the callback function.
*/
if (((lip->li_major == -1) && (dev == DDI_DEV_T_NONE)) ||
(dip != NULL)) {
ret = callback(&ldi_usage, arg);
if (dip != NULL)
ddi_release_devi(dip);
if (ldi_usage.tgt_dip != NULL)
ddi_release_devi(ldi_usage.tgt_dip);
return (ret);
}
/*
* now this is kinda gross.
*
* what we do here is attempt to associate every device instance
* of the source driver on the system with the open target driver.
* we do this because we don't know which instance of the device
* could potentially access the lower device so we assume that all
* the instances could access it.
*
* there are two ways we could have gotten here:
*
* 1) this layered ident represents one created using only a
* major number or a driver module name. this means that when
* it was created we could not associate it with a particular
* dev_t or device instance.
*
* when could this possibly happen you ask?
*
* a perfect example of this is streams persistent links.
* when a persistant streams link is formed we can't associate
* the lower device stream with any particular upper device
* stream or instance. this is because any particular upper
* device stream could be closed, then another could be
* opened with a different dev_t and device instance, and it
* would still have access to the lower linked stream.
*
* since any instance of the upper streams driver could
* potentially access the lower stream whenever it wants,
* we represent that here by associating the opened lower
* device with every existing device instance of the upper
* streams driver.
*
* 2) This case should really never happen but we'll include it
* for completeness.
*
* it's possible that we could have gotten here because we
* have a dev_t for the upper device but we couldn't find a
* dip associated with that dev_t.
*
* the only types of devices that have dev_t without an
* associated dip are unbound DLPIv2 network devices. These
* types of devices exist to be able to attach a stream to any
* instance of a hardware network device. since these types of
* devices are usually hardware devices they should never
* really have other devices open.
*/
if (dev != DDI_DEV_T_NONE)
major = getmajor(dev);
else
major = lip->li_major;
ASSERT((major >= 0) && (major < devcnt));
dnp = &devnamesp[major];
LOCK_DEV_OPS(&dnp->dn_lock);
dip = dnp->dn_head;
while ((dip) && (ret == LDI_USAGE_CONTINUE)) {
e_ddi_hold_devi(dip);
UNLOCK_DEV_OPS(&dnp->dn_lock);
/* set the source dip */
ldi_usage.src_dip = dip;
/* invoke the callback function */
ret = callback(&ldi_usage, arg);
LOCK_DEV_OPS(&dnp->dn_lock);
ddi_release_devi(dip);
dip = ddi_get_next(dip);
}
UNLOCK_DEV_OPS(&dnp->dn_lock);
/* if there was a target dip, release it */
if (ldi_usage.tgt_dip != NULL)
ddi_release_devi(ldi_usage.tgt_dip);
return (ret);
}
/*
* ldi_usage_walker() - this walker reports LDI kernel device usage
* information via the callback() callback function. the LDI keeps track
* of what devices are being accessed in its own internal data structures.
* this function walks those data structures to determine device usage.
*/
void
ldi_usage_walker(void *arg, int (*callback)(const ldi_usage_t *, void *))
{
struct ldi_handle *lhp;
struct ldi_ident *lip;
vnode_t *vp;
int i;
int ret = LDI_USAGE_CONTINUE;
for (i = 0; i < LH_HASH_SZ; i++) {
mutex_enter(&ldi_handle_hash_lock[i]);
lhp = ldi_handle_hash[i];
while ((lhp != NULL) && (ret == LDI_USAGE_CONTINUE)) {
lip = lhp->lh_ident;
vp = lhp->lh_vp;
/* invoke the devinfo callback function */
ret = ldi_usage_walker_helper(lip, vp, arg, callback);
lhp = lhp->lh_next;
}
mutex_exit(&ldi_handle_hash_lock[i]);
if (ret != LDI_USAGE_CONTINUE)
break;
}
}
/*
* LDI Project private interfaces (streams linking interfaces)
*
* Streams supports a type of built in device layering via linking.
* Certain types of streams drivers can be streams multiplexors.
* A streams multiplexor supports the I_LINK/I_PLINK operation.
* These operations allows other streams devices to be linked under the
* multiplexor. By definition all streams multiplexors are devices
* so this linking is a type of device layering where the multiplexor
* device is layered on top of the device linked below it.
*/
/*
* ldi_mlink_lh() is invoked when streams are linked using LDI handles.
* It is not used for normal I_LINKs and I_PLINKs using file descriptors.
*
* The streams framework keeps track of links via the file_t of the lower
* stream. The LDI keeps track of devices using a vnode. In the case
* of a streams link created via an LDI handle, fnk_lh() allocates
* a file_t that the streams framework can use to track the linkage.
*/
int
ldi_mlink_lh(vnode_t *vp, int cmd, intptr_t arg, cred_t *crp, int *rvalp)
{
struct ldi_handle *lhp = (struct ldi_handle *)arg;
vnode_t *vpdown;
file_t *fpdown;
int err;
if (lhp == NULL)
return (EINVAL);
vpdown = lhp->lh_vp;
ASSERT(vn_matchops(vpdown, spec_getvnodeops()));
ASSERT(cmd == _I_PLINK_LH);
/*
* create a new lower vnode and a file_t that points to it,
* streams linking requires a file_t. falloc() returns with
* fpdown locked.
*/
VN_HOLD(vpdown);
(void) falloc(vpdown, FREAD|FWRITE, &fpdown, NULL);
mutex_exit(&fpdown->f_tlock);
/* try to establish the link */
err = mlink_file(vp, I_PLINK, fpdown, crp, rvalp, 1);
if (err != 0) {
/* the link failed, free the file_t and release the vnode */
mutex_enter(&fpdown->f_tlock);
unfalloc(fpdown);
VN_RELE(vpdown);
}
return (err);
}
/*
* ldi_mlink_fp() is invoked for all successful streams linkages created
* via I_LINK and I_PLINK. ldi_mlink_fp() records the linkage information
* in its internal state so that the devinfo snapshot code has some
* observability into streams device linkage information.
*/
void
ldi_mlink_fp(struct stdata *stp, file_t *fpdown, int lhlink, int type)
{
vnode_t *vp = fpdown->f_vnode;
struct snode *sp, *csp;
ldi_ident_t li;
major_t major;
int ret;
/* if the lower stream is not a device then return */
if (!vn_matchops(vp, spec_getvnodeops()))
return;
ASSERT(!servicing_interrupt());
LDI_STREAMS_LNK((CE_NOTE, "%s: linking streams "
"stp=0x%p, fpdown=0x%p", "ldi_mlink_fp",
(void *)stp, (void *)fpdown));
sp = VTOS(vp);
csp = VTOS(sp->s_commonvp);
/* check if this was a plink via a layered handle */
if (lhlink) {
/*
* increment the common snode s_count.
*
* this is done because after the link operation there
* are two ways that s_count can be decremented.
*
* when the layered handle used to create the link is
* closed, spec_close() is called and it will decrement
* s_count in the common snode. if we don't increment
* s_count here then this could cause spec_close() to
* actually close the device while it's still linked
* under a multiplexer.
*
* also, when the lower stream is unlinked, closef() is
* called for the file_t associated with this snode.
* closef() will call spec_close(), which will decrement
* s_count. if we dont't increment s_count here then this
* could cause spec_close() to actually close the device
* while there may still be valid layered handles
* pointing to it.
*/
mutex_enter(&csp->s_lock);
ASSERT(csp->s_count >= 1);
csp->s_count++;
mutex_exit(&csp->s_lock);
/*
* decrement the f_count.
* this is done because the layered driver framework does
* not actually cache a copy of the file_t allocated to
* do the link. this is done here instead of in ldi_mlink_lh()
* because there is a window in ldi_mlink_lh() between where
* milnk_file() returns and we would decrement the f_count
* when the stream could be unlinked.
*/
mutex_enter(&fpdown->f_tlock);
fpdown->f_count--;
mutex_exit(&fpdown->f_tlock);
}
/*
* NOTE: here we rely on the streams subsystem not allowing
* a stream to be multiplexed more than once. if this
* changes, we break.
*
* mark the snode/stream as multiplexed
*/
mutex_enter(&sp->s_lock);
ASSERT(!(sp->s_flag & SMUXED));
sp->s_flag |= SMUXED;
mutex_exit(&sp->s_lock);
/* get a layered ident for the upper stream */
if (type == LINKNORMAL) {
/*
* if the link is not persistant then we can associate
* the upper stream with a dev_t. this is because the
* upper stream is associated with a vnode, which is
* associated with a dev_t and this binding can't change
* during the life of the stream. since the link isn't
* persistant once the stream is destroyed the link is
* destroyed. so the dev_t will be valid for the life
* of the link.
*/
ret = ldi_ident_from_stream(getendq(stp->sd_wrq), &li);
} else {
/*
* if the link is persistant we can only associate the
* link with a driver (and not a dev_t.) this is
* because subsequent opens of the upper device may result
* in a different stream (and dev_t) having access to
* the lower stream.
*
* for example, if the upper stream is closed after the
* persistant link operation is compleated, a subsequent
* open of the upper device will create a new stream which
* may have a different dev_t and an unlink operation
* can be performed using this new upper stream.
*/
ASSERT(type == LINKPERSIST);
major = getmajor(stp->sd_vnode->v_rdev);
ret = ldi_ident_from_major(major, &li);
}
ASSERT(ret == 0);
(void) handle_alloc(vp, (struct ldi_ident *)li);
ldi_ident_release(li);
}
void
ldi_munlink_fp(struct stdata *stp, file_t *fpdown, int type)
{
struct ldi_handle *lhp;
vnode_t *vp = (vnode_t *)fpdown->f_vnode;
struct snode *sp;
ldi_ident_t li;
major_t major;
int ret;
/* if the lower stream is not a device then return */
if (!vn_matchops(vp, spec_getvnodeops()))
return;
ASSERT(!servicing_interrupt());
ASSERT((type == LINKNORMAL) || (type == LINKPERSIST));
LDI_STREAMS_LNK((CE_NOTE, "%s: unlinking streams "
"stp=0x%p, fpdown=0x%p", "ldi_munlink_fp",
(void *)stp, (void *)fpdown));
/*
* NOTE: here we rely on the streams subsystem not allowing
* a stream to be multiplexed more than once. if this
* changes, we break.
*
* mark the snode/stream as not multiplexed
*/
sp = VTOS(vp);
mutex_enter(&sp->s_lock);
ASSERT(sp->s_flag & SMUXED);
sp->s_flag &= ~SMUXED;
mutex_exit(&sp->s_lock);
/*
* clear the owner for this snode
* see the comment in ldi_mlink_fp() for information about how
* the ident is allocated
*/
if (type == LINKNORMAL) {
ret = ldi_ident_from_stream(getendq(stp->sd_wrq), &li);
} else {
ASSERT(type == LINKPERSIST);
major = getmajor(stp->sd_vnode->v_rdev);
ret = ldi_ident_from_major(major, &li);
}
ASSERT(ret == 0);
lhp = handle_find(vp, (struct ldi_ident *)li);
handle_release(lhp);
ldi_ident_release(li);
}
/*
* LDI Consolidation private interfaces
*/
int
ldi_ident_from_mod(struct modlinkage *modlp, ldi_ident_t *lip)
{
struct modctl *modp;
major_t major;
char *name;
if ((modlp == NULL) || (lip == NULL))
return (EINVAL);
ASSERT(!servicing_interrupt());
modp = mod_getctl(modlp);
if (modp == NULL)
return (EINVAL);
name = modp->mod_modname;
if (name == NULL)
return (EINVAL);
major = mod_name_to_major(name);
*lip = (ldi_ident_t)ident_alloc(name, NULL, DDI_DEV_T_NONE, major);
LDI_ALLOCFREE((CE_WARN, "%s: li=0x%p, mod=%s",
"ldi_ident_from_mod", (void *)*lip, name));
return (0);
}
ldi_ident_t
ldi_ident_from_anon()
{
ldi_ident_t lip;
ASSERT(!servicing_interrupt());
lip = (ldi_ident_t)ident_alloc("genunix", NULL, DDI_DEV_T_NONE, -1);
LDI_ALLOCFREE((CE_WARN, "%s: li=0x%p, mod=%s",
"ldi_ident_from_anon", (void *)lip, "genunix"));
return (lip);
}
/*
* LDI Public interfaces
*/
int
ldi_ident_from_stream(struct queue *sq, ldi_ident_t *lip)
{
struct stdata *stp;
dev_t dev;
char *name;
if ((sq == NULL) || (lip == NULL))
return (EINVAL);
ASSERT(!servicing_interrupt());
stp = sq->q_stream;
if (!vn_matchops(stp->sd_vnode, spec_getvnodeops()))
return (EINVAL);
dev = stp->sd_vnode->v_rdev;
name = mod_major_to_name(getmajor(dev));
if (name == NULL)
return (EINVAL);
*lip = (ldi_ident_t)ident_alloc(name, NULL, dev, -1);
LDI_ALLOCFREE((CE_WARN,
"%s: li=0x%p, mod=%s, minor=0x%x, stp=0x%p",
"ldi_ident_from_stream", (void *)*lip, name, getminor(dev),
(void *)stp));
return (0);
}
int
ldi_ident_from_dev(dev_t dev, ldi_ident_t *lip)
{
char *name;
if (lip == NULL)
return (EINVAL);
ASSERT(!servicing_interrupt());
name = mod_major_to_name(getmajor(dev));
if (name == NULL)
return (EINVAL);
*lip = (ldi_ident_t)ident_alloc(name, NULL, dev, -1);
LDI_ALLOCFREE((CE_WARN,
"%s: li=0x%p, mod=%s, minor=0x%x",
"ldi_ident_from_dev", (void *)*lip, name, getminor(dev)));
return (0);
}
int
ldi_ident_from_dip(dev_info_t *dip, ldi_ident_t *lip)
{
struct dev_info *devi = (struct dev_info *)dip;
char *name;
if ((dip == NULL) || (lip == NULL))
return (EINVAL);
ASSERT(!servicing_interrupt());
name = mod_major_to_name(devi->devi_major);
if (name == NULL)
return (EINVAL);
*lip = (ldi_ident_t)ident_alloc(name, dip, DDI_DEV_T_NONE, -1);
LDI_ALLOCFREE((CE_WARN,
"%s: li=0x%p, mod=%s, dip=0x%p",
"ldi_ident_from_dip", (void *)*lip, name, (void *)devi));
return (0);
}
int
ldi_ident_from_major(major_t major, ldi_ident_t *lip)
{
char *name;
if (lip == NULL)
return (EINVAL);
ASSERT(!servicing_interrupt());
name = mod_major_to_name(major);
if (name == NULL)
return (EINVAL);
*lip = (ldi_ident_t)ident_alloc(name, NULL, DDI_DEV_T_NONE, major);
LDI_ALLOCFREE((CE_WARN,
"%s: li=0x%p, mod=%s",
"ldi_ident_from_major", (void *)*lip, name));
return (0);
}
void
ldi_ident_release(ldi_ident_t li)
{
struct ldi_ident *ident = (struct ldi_ident *)li;
char *name;
if (li == NULL)
return;
ASSERT(!servicing_interrupt());
name = ident->li_modname;
LDI_ALLOCFREE((CE_WARN,
"%s: li=0x%p, mod=%s",
"ldi_ident_release", (void *)li, name));
ident_release((struct ldi_ident *)li);
}
/* get a handle to a device by dev_t and otyp */
int
ldi_open_by_dev(dev_t *devp, int otyp, int flag, cred_t *cr,
ldi_handle_t *lhp, ldi_ident_t li)
{
struct ldi_ident *lip = (struct ldi_ident *)li;
int ret;
vnode_t *vp;
/* sanity check required input parameters */
if ((devp == NULL) || (!OTYP_VALID(otyp)) || (cr == NULL) ||
(lhp == NULL) || (lip == NULL))
return (EINVAL);
ASSERT(!servicing_interrupt());
if ((ret = ldi_vp_from_dev(*devp, otyp, &vp)) != 0)
return (ret);
if ((ret = ldi_open_by_vp(&vp, flag, cr, lhp, lip)) == 0) {
*devp = vp->v_rdev;
}
VN_RELE(vp);
return (ret);
}
/* get a handle to a device by pathname */
int
ldi_open_by_name(char *pathname, int flag, cred_t *cr,
ldi_handle_t *lhp, ldi_ident_t li)
{
struct ldi_ident *lip = (struct ldi_ident *)li;
int ret;
vnode_t *vp;
/* sanity check required input parameters */
if ((pathname == NULL) || (*pathname != '/') ||
(cr == NULL) || (lhp == NULL) || (lip == NULL))
return (EINVAL);
ASSERT(!servicing_interrupt());
if ((ret = ldi_vp_from_name(pathname, &vp)) != 0)
return (ret);
ret = ldi_open_by_vp(&vp, flag, cr, lhp, lip);
VN_RELE(vp);
return (ret);
}
/* get a handle to a device by devid and minor_name */
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)
{
struct ldi_ident *lip = (struct ldi_ident *)li;
int ret;
vnode_t *vp;
/* sanity check required input parameters */
if ((minor_name == NULL) || (cr == NULL) ||
(lhp == NULL) || (lip == NULL))
return (EINVAL);
ASSERT(!servicing_interrupt());
if ((ret = ldi_vp_from_devid(devid, minor_name, &vp)) != 0)
return (ret);
ret = ldi_open_by_vp(&vp, flag, cr, lhp, lip);
VN_RELE(vp);
return (ret);
}
int
ldi_close(ldi_handle_t lh, int flag, cred_t *cr)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
struct ldi_event *lep;
int err = 0;
int notify = 0;
list_t *listp;
ldi_ev_callback_impl_t *lecp;
if (lh == NULL)
return (EINVAL);
ASSERT(!servicing_interrupt());
#ifdef LDI_OBSOLETE_EVENT
/*
* Any event handlers should have been unregistered by the
* time ldi_close() is called. If they haven't then it's a
* bug.
*
* In a debug kernel we'll panic to make the problem obvious.
*/
ASSERT(handlep->lh_events == NULL);
/*
* On a production kernel we'll "do the right thing" (unregister
* the event handlers) and then complain about having to do the
* work ourselves.
*/
while ((lep = handlep->lh_events) != NULL) {
err = 1;
(void) ldi_remove_event_handler(lh, (ldi_callback_id_t)lep);
}
if (err) {
struct ldi_ident *lip = handlep->lh_ident;
ASSERT(lip != NULL);
cmn_err(CE_NOTE, "ldi err: %s "
"failed to unregister layered event handlers before "
"closing devices", lip->li_modname);
}
#endif
/* do a layered close on the device */
err = VOP_CLOSE(handlep->lh_vp, flag | FKLYR, 1, (offset_t)0, cr, NULL);
LDI_OPENCLOSE((CE_WARN, "%s: lh=0x%p", "ldi close", (void *)lh));
/*
* Search the event callback list for callbacks with this
* handle. There are 2 cases
* 1. Called in the context of a notify. The handle consumer
* is releasing its hold on the device to allow a reconfiguration
* of the device. Simply NULL out the handle and the notify callback.
* The finalize callback is still available so that the consumer
* knows of the final disposition of the device.
* 2. Not called in the context of notify. NULL out the handle as well
* as the notify and finalize callbacks. Since the consumer has
* closed the handle, we assume it is not interested in the
* notify and finalize callbacks.
*/
ldi_ev_lock();
if (handlep->lh_flags & LH_FLAGS_NOTIFY)
notify = 1;
listp = &ldi_ev_callback_list.le_head;
for (lecp = list_head(listp); lecp; lecp = list_next(listp, lecp)) {
if (lecp->lec_lhp != handlep)
continue;
lecp->lec_lhp = NULL;
lecp->lec_notify = NULL;
LDI_EVDBG((CE_NOTE, "ldi_close: NULLed lh and notify"));
if (!notify) {
LDI_EVDBG((CE_NOTE, "ldi_close: NULLed finalize"));
lecp->lec_finalize = NULL;
}
}
if (notify)
handlep->lh_flags &= ~LH_FLAGS_NOTIFY;
ldi_ev_unlock();
/*
* Free the handle even if the device close failed. why?
*
* If the device close failed we can't really make assumptions
* about the devices state so we shouldn't allow access to the
* device via this handle any more. If the device consumer wants
* to access the device again they should open it again.
*
* This is the same way file/device close failures are handled
* in other places like spec_close() and closeandsetf().
*/
handle_release(handlep);
return (err);
}
int
ldi_read(ldi_handle_t lh, struct uio *uiop, cred_t *credp)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
vnode_t *vp;
dev_t dev;
int ret;
if (lh == NULL)
return (EINVAL);
vp = handlep->lh_vp;
dev = vp->v_rdev;
if (handlep->lh_type & LH_CBDEV) {
ret = cdev_read(dev, uiop, credp);
} else if (handlep->lh_type & LH_STREAM) {
ret = strread(vp, uiop, credp);
} else {
return (ENOTSUP);
}
return (ret);
}
int
ldi_write(ldi_handle_t lh, struct uio *uiop, cred_t *credp)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
vnode_t *vp;
dev_t dev;
int ret;
if (lh == NULL)
return (EINVAL);
vp = handlep->lh_vp;
dev = vp->v_rdev;
if (handlep->lh_type & LH_CBDEV) {
ret = cdev_write(dev, uiop, credp);
} else if (handlep->lh_type & LH_STREAM) {
ret = strwrite(vp, uiop, credp);
} else {
return (ENOTSUP);
}
return (ret);
}
int
ldi_get_size(ldi_handle_t lh, uint64_t *sizep)
{
int otyp;
uint_t value;
int64_t drv_prop64;
struct ldi_handle *handlep = (struct ldi_handle *)lh;
uint_t blksize;
int blkshift;
if ((lh == NULL) || (sizep == NULL))
return (DDI_FAILURE);
if (handlep->lh_type & LH_STREAM)
return (DDI_FAILURE);
/*
* Determine device type (char or block).
* Character devices support Size/size
* property value. Block devices may support
* Nblocks/nblocks or Size/size property value.
*/
if ((ldi_get_otyp(lh, &otyp)) != 0)
return (DDI_FAILURE);
if (otyp == OTYP_BLK) {
if (ldi_prop_exists(lh,
DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "Nblocks")) {
drv_prop64 = ldi_prop_get_int64(lh,
DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
"Nblocks", 0);
blksize = ldi_prop_get_int(lh,
DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
"blksize", DEV_BSIZE);
if (blksize == DEV_BSIZE)
blksize = ldi_prop_get_int(lh, LDI_DEV_T_ANY |
DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
"device-blksize", DEV_BSIZE);
/* blksize must be a power of two */
ASSERT(BIT_ONLYONESET(blksize));
blkshift = highbit(blksize) - 1;
/*
* We don't support Nblocks values that don't have
* an accurate uint64_t byte count representation.
*/
if ((uint64_t)drv_prop64 >= (UINT64_MAX >> blkshift))
return (DDI_FAILURE);
*sizep = (uint64_t)
(((u_offset_t)drv_prop64) << blkshift);
return (DDI_SUCCESS);
}
if (ldi_prop_exists(lh,
DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "nblocks")) {
value = ldi_prop_get_int(lh,
DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
"nblocks", 0);
blksize = ldi_prop_get_int(lh,
DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
"blksize", DEV_BSIZE);
if (blksize == DEV_BSIZE)
blksize = ldi_prop_get_int(lh, LDI_DEV_T_ANY |
DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
"device-blksize", DEV_BSIZE);
/* blksize must be a power of two */
ASSERT(BIT_ONLYONESET(blksize));
blkshift = highbit(blksize) - 1;
/*
* We don't support nblocks values that don't have an
* accurate uint64_t byte count representation.
*/
if ((uint64_t)value >= (UINT64_MAX >> blkshift))
return (DDI_FAILURE);
*sizep = (uint64_t)
(((u_offset_t)value) << blkshift);
return (DDI_SUCCESS);
}
}
if (ldi_prop_exists(lh,
DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "Size")) {
drv_prop64 = ldi_prop_get_int64(lh,
DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "Size", 0);
*sizep = (uint64_t)drv_prop64;
return (DDI_SUCCESS);
}
if (ldi_prop_exists(lh,
DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "size")) {
value = ldi_prop_get_int(lh,
DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "size", 0);
*sizep = (uint64_t)value;
return (DDI_SUCCESS);
}
/* unable to determine device size */
return (DDI_FAILURE);
}
int
ldi_ioctl(ldi_handle_t lh, int cmd, intptr_t arg, int mode,
cred_t *cr, int *rvalp)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
vnode_t *vp;
dev_t dev;
int ret, copymode;
if (lh == NULL)
return (EINVAL);
/*
* if the data pointed to by arg is located in the kernel then
* make sure the FNATIVE flag is set.
*/
if (mode & FKIOCTL)
mode = (mode & ~FMODELS) | FNATIVE | FKIOCTL;
vp = handlep->lh_vp;
dev = vp->v_rdev;
if (handlep->lh_type & LH_CBDEV) {
ret = cdev_ioctl(dev, cmd, arg, mode, cr, rvalp);
} else if (handlep->lh_type & LH_STREAM) {
copymode = (mode & FKIOCTL) ? K_TO_K : U_TO_K;
/*
* if we get an I_PLINK from within the kernel the
* arg is a layered handle pointer instead of
* a file descriptor, so we translate this ioctl
* into a private one that can handle this.
*/
if ((mode & FKIOCTL) && (cmd == I_PLINK))
cmd = _I_PLINK_LH;
ret = strioctl(vp, cmd, arg, mode, copymode, cr, rvalp);
} else {
return (ENOTSUP);
}
return (ret);
}
int
ldi_poll(ldi_handle_t lh, short events, int anyyet, short *reventsp,
struct pollhead **phpp)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
vnode_t *vp;
dev_t dev;
int ret;
if (lh == NULL)
return (EINVAL);
vp = handlep->lh_vp;
dev = vp->v_rdev;
if (handlep->lh_type & LH_CBDEV) {
ret = cdev_poll(dev, events, anyyet, reventsp, phpp);
} else if (handlep->lh_type & LH_STREAM) {
ret = strpoll(vp->v_stream, events, anyyet, reventsp, phpp);
} else {
return (ENOTSUP);
}
return (ret);
}
int
ldi_prop_op(ldi_handle_t lh, ddi_prop_op_t prop_op,
int flags, char *name, caddr_t valuep, int *length)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
dev_t dev;
dev_info_t *dip;
int ret;
struct snode *csp;
if ((lh == NULL) || (name == NULL) || (strlen(name) == 0))
return (DDI_PROP_INVAL_ARG);
if ((prop_op != PROP_LEN) && (valuep == NULL))
return (DDI_PROP_INVAL_ARG);
if (length == NULL)
return (DDI_PROP_INVAL_ARG);
/*
* try to find the associated dip,
* this places a hold on the driver
*/
dev = handlep->lh_vp->v_rdev;
csp = VTOCS(handlep->lh_vp);
mutex_enter(&csp->s_lock);
if ((dip = csp->s_dip) != NULL)
e_ddi_hold_devi(dip);
mutex_exit(&csp->s_lock);
if (dip == NULL)
dip = e_ddi_hold_devi_by_dev(dev, 0);
if (dip == NULL)
return (DDI_PROP_NOT_FOUND);
ret = i_ldi_prop_op(dev, dip, prop_op, flags, name, valuep, length);
ddi_release_devi(dip);
return (ret);
}
int
ldi_strategy(ldi_handle_t lh, struct buf *bp)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
dev_t dev;
if ((lh == NULL) || (bp == NULL))
return (EINVAL);
/* this entry point is only supported for cb devices */
dev = handlep->lh_vp->v_rdev;
if (!(handlep->lh_type & LH_CBDEV))
return (ENOTSUP);
bp->b_edev = dev;
bp->b_dev = cmpdev(dev);
return (bdev_strategy(bp));
}
int
ldi_dump(ldi_handle_t lh, caddr_t addr, daddr_t blkno, int nblk)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
dev_t dev;
if (lh == NULL)
return (EINVAL);
/* this entry point is only supported for cb devices */
dev = handlep->lh_vp->v_rdev;
if (!(handlep->lh_type & LH_CBDEV))
return (ENOTSUP);
return (bdev_dump(dev, addr, blkno, nblk));
}
int
ldi_devmap(ldi_handle_t lh, devmap_cookie_t dhp, offset_t off,
size_t len, size_t *maplen, uint_t model)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
dev_t dev;
if (lh == NULL)
return (EINVAL);
/* this entry point is only supported for cb devices */
dev = handlep->lh_vp->v_rdev;
if (!(handlep->lh_type & LH_CBDEV))
return (ENOTSUP);
return (cdev_devmap(dev, dhp, off, len, maplen, model));
}
int
ldi_aread(ldi_handle_t lh, struct aio_req *aio_reqp, cred_t *cr)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
dev_t dev;
struct cb_ops *cb;
if (lh == NULL)
return (EINVAL);
/* this entry point is only supported for cb devices */
if (!(handlep->lh_type & LH_CBDEV))
return (ENOTSUP);
/*
* Kaio is only supported on block devices.
*/
dev = handlep->lh_vp->v_rdev;
cb = devopsp[getmajor(dev)]->devo_cb_ops;
if (cb->cb_strategy == nodev || cb->cb_strategy == NULL)
return (ENOTSUP);
if (cb->cb_aread == NULL)
return (ENOTSUP);
return (cb->cb_aread(dev, aio_reqp, cr));
}
int
ldi_awrite(ldi_handle_t lh, struct aio_req *aio_reqp, cred_t *cr)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
struct cb_ops *cb;
dev_t dev;
if (lh == NULL)
return (EINVAL);
/* this entry point is only supported for cb devices */
if (!(handlep->lh_type & LH_CBDEV))
return (ENOTSUP);
/*
* Kaio is only supported on block devices.
*/
dev = handlep->lh_vp->v_rdev;
cb = devopsp[getmajor(dev)]->devo_cb_ops;
if (cb->cb_strategy == nodev || cb->cb_strategy == NULL)
return (ENOTSUP);
if (cb->cb_awrite == NULL)
return (ENOTSUP);
return (cb->cb_awrite(dev, aio_reqp, cr));
}
int
ldi_putmsg(ldi_handle_t lh, mblk_t *smp)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
int ret;
if ((lh == NULL) || (smp == NULL))
return (EINVAL);
if (!(handlep->lh_type & LH_STREAM)) {
freemsg(smp);
return (ENOTSUP);
}
/*
* If we don't have db_credp, set it. Note that we can not be called
* from interrupt context.
*/
if (msg_getcred(smp, NULL) == NULL)
mblk_setcred(smp, CRED(), curproc->p_pid);
/* Send message while honoring flow control */
ret = kstrputmsg(handlep->lh_vp, smp, NULL, 0, 0,
MSG_BAND | MSG_HOLDSIG | MSG_IGNERROR, 0);
return (ret);
}
int
ldi_getmsg(ldi_handle_t lh, mblk_t **rmp, timestruc_t *timeo)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
clock_t timout; /* milliseconds */
uchar_t pri;
rval_t rval;
int ret, pflag;
if (lh == NULL)
return (EINVAL);
if (!(handlep->lh_type & LH_STREAM))
return (ENOTSUP);
/* Convert from nanoseconds to milliseconds */
if (timeo != NULL) {
timout = timeo->tv_sec * 1000 + timeo->tv_nsec / 1000000;
if (timout > INT_MAX)
return (EINVAL);
} else
timout = -1;
/* Wait for timeout millseconds for a message */
pflag = MSG_ANY;
pri = 0;
*rmp = NULL;
ret = kstrgetmsg(handlep->lh_vp,
rmp, NULL, &pri, &pflag, timout, &rval);
return (ret);
}
int
ldi_get_dev(ldi_handle_t lh, dev_t *devp)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
if ((lh == NULL) || (devp == NULL))
return (EINVAL);
*devp = handlep->lh_vp->v_rdev;
return (0);
}
int
ldi_get_otyp(ldi_handle_t lh, int *otyp)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
if ((lh == NULL) || (otyp == NULL))
return (EINVAL);
*otyp = VTYP_TO_OTYP(handlep->lh_vp->v_type);
return (0);
}
int
ldi_get_devid(ldi_handle_t lh, ddi_devid_t *devid)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
int ret;
dev_t dev;
if ((lh == NULL) || (devid == NULL))
return (EINVAL);
dev = handlep->lh_vp->v_rdev;
ret = ddi_lyr_get_devid(dev, devid);
if (ret != DDI_SUCCESS)
return (ENOTSUP);
return (0);
}
int
ldi_get_minor_name(ldi_handle_t lh, char **minor_name)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
int ret, otyp;
dev_t dev;
if ((lh == NULL) || (minor_name == NULL))
return (EINVAL);
dev = handlep->lh_vp->v_rdev;
otyp = VTYP_TO_OTYP(handlep->lh_vp->v_type);
ret = ddi_lyr_get_minor_name(dev, OTYP_TO_STYP(otyp), minor_name);
if (ret != DDI_SUCCESS)
return (ENOTSUP);
return (0);
}
int
ldi_prop_lookup_int_array(ldi_handle_t lh,
uint_t flags, char *name, int **data, uint_t *nelements)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
dev_info_t *dip;
dev_t dev;
int res;
struct snode *csp;
if ((lh == NULL) || (name == NULL) || (strlen(name) == 0))
return (DDI_PROP_INVAL_ARG);
dev = handlep->lh_vp->v_rdev;
csp = VTOCS(handlep->lh_vp);
mutex_enter(&csp->s_lock);
if ((dip = csp->s_dip) != NULL)
e_ddi_hold_devi(dip);
mutex_exit(&csp->s_lock);
if (dip == NULL)
dip = e_ddi_hold_devi_by_dev(dev, 0);
if (dip == NULL) {
flags |= DDI_UNBND_DLPI2;
} else if (flags & LDI_DEV_T_ANY) {
flags &= ~LDI_DEV_T_ANY;
dev = DDI_DEV_T_ANY;
}
if (dip != NULL) {
int *prop_val, prop_len;
res = i_ldi_prop_op_typed(dev, dip, flags, name,
(caddr_t *)&prop_val, &prop_len, sizeof (int));
/* if we got it then return it */
if (res == DDI_PROP_SUCCESS) {
*nelements = prop_len / sizeof (int);
*data = prop_val;
ddi_release_devi(dip);
return (res);
}
}
/* call the normal property interfaces */
res = ddi_prop_lookup_int_array(dev, dip, flags,
name, data, nelements);
if (dip != NULL)
ddi_release_devi(dip);
return (res);
}
int
ldi_prop_lookup_int64_array(ldi_handle_t lh,
uint_t flags, char *name, int64_t **data, uint_t *nelements)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
dev_info_t *dip;
dev_t dev;
int res;
struct snode *csp;
if ((lh == NULL) || (name == NULL) || (strlen(name) == 0))
return (DDI_PROP_INVAL_ARG);
dev = handlep->lh_vp->v_rdev;
csp = VTOCS(handlep->lh_vp);
mutex_enter(&csp->s_lock);
if ((dip = csp->s_dip) != NULL)
e_ddi_hold_devi(dip);
mutex_exit(&csp->s_lock);
if (dip == NULL)
dip = e_ddi_hold_devi_by_dev(dev, 0);
if (dip == NULL) {
flags |= DDI_UNBND_DLPI2;
} else if (flags & LDI_DEV_T_ANY) {
flags &= ~LDI_DEV_T_ANY;
dev = DDI_DEV_T_ANY;
}
if (dip != NULL) {
int64_t *prop_val;
int prop_len;
res = i_ldi_prop_op_typed(dev, dip, flags, name,
(caddr_t *)&prop_val, &prop_len, sizeof (int64_t));
/* if we got it then return it */
if (res == DDI_PROP_SUCCESS) {
*nelements = prop_len / sizeof (int64_t);
*data = prop_val;
ddi_release_devi(dip);
return (res);
}
}
/* call the normal property interfaces */
res = ddi_prop_lookup_int64_array(dev, dip, flags,
name, data, nelements);
if (dip != NULL)
ddi_release_devi(dip);
return (res);
}
int
ldi_prop_lookup_string_array(ldi_handle_t lh,
uint_t flags, char *name, char ***data, uint_t *nelements)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
dev_info_t *dip;
dev_t dev;
int res;
struct snode *csp;
if ((lh == NULL) || (name == NULL) || (strlen(name) == 0))
return (DDI_PROP_INVAL_ARG);
dev = handlep->lh_vp->v_rdev;
csp = VTOCS(handlep->lh_vp);
mutex_enter(&csp->s_lock);
if ((dip = csp->s_dip) != NULL)
e_ddi_hold_devi(dip);
mutex_exit(&csp->s_lock);
if (dip == NULL)
dip = e_ddi_hold_devi_by_dev(dev, 0);
if (dip == NULL) {
flags |= DDI_UNBND_DLPI2;
} else if (flags & LDI_DEV_T_ANY) {
flags &= ~LDI_DEV_T_ANY;
dev = DDI_DEV_T_ANY;
}
if (dip != NULL) {
char *prop_val;
int prop_len;
res = i_ldi_prop_op_typed(dev, dip, flags, name,
(caddr_t *)&prop_val, &prop_len, 0);
/* if we got it then return it */
if (res == DDI_PROP_SUCCESS) {
char **str_array;
int nelem;
/*
* pack the returned string array into the format
* our callers expect
*/
if (i_pack_string_array(prop_val, prop_len,
&str_array, &nelem) == 0) {
*data = str_array;
*nelements = nelem;
ddi_prop_free(prop_val);
ddi_release_devi(dip);
return (res);
}
/*
* the format of the returned property must have
* been bad so throw it out
*/
ddi_prop_free(prop_val);
}
}
/* call the normal property interfaces */
res = ddi_prop_lookup_string_array(dev, dip, flags,
name, data, nelements);
if (dip != NULL)
ddi_release_devi(dip);
return (res);
}
int
ldi_prop_lookup_string(ldi_handle_t lh,
uint_t flags, char *name, char **data)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
dev_info_t *dip;
dev_t dev;
int res;
struct snode *csp;
if ((lh == NULL) || (name == NULL) || (strlen(name) == 0))
return (DDI_PROP_INVAL_ARG);
dev = handlep->lh_vp->v_rdev;
csp = VTOCS(handlep->lh_vp);
mutex_enter(&csp->s_lock);
if ((dip = csp->s_dip) != NULL)
e_ddi_hold_devi(dip);
mutex_exit(&csp->s_lock);
if (dip == NULL)
dip = e_ddi_hold_devi_by_dev(dev, 0);
if (dip == NULL) {
flags |= DDI_UNBND_DLPI2;
} else if (flags & LDI_DEV_T_ANY) {
flags &= ~LDI_DEV_T_ANY;
dev = DDI_DEV_T_ANY;
}
if (dip != NULL) {
char *prop_val;
int prop_len;
res = i_ldi_prop_op_typed(dev, dip, flags, name,
(caddr_t *)&prop_val, &prop_len, 0);
/* if we got it then return it */
if (res == DDI_PROP_SUCCESS) {
/*
* sanity check the vaule returned.
*/
if (i_check_string(prop_val, prop_len)) {
ddi_prop_free(prop_val);
} else {
*data = prop_val;
ddi_release_devi(dip);
return (res);
}
}
}
/* call the normal property interfaces */
res = ddi_prop_lookup_string(dev, dip, flags, name, data);
if (dip != NULL)
ddi_release_devi(dip);
#ifdef DEBUG
if (res == DDI_PROP_SUCCESS) {
/*
* keep ourselves honest
* make sure the framework returns strings in the
* same format as we're demanding from drivers.
*/
struct prop_driver_data *pdd;
int pdd_prop_size;
pdd = ((struct prop_driver_data *)(*data)) - 1;
pdd_prop_size = pdd->pdd_size -
sizeof (struct prop_driver_data);
ASSERT(i_check_string(*data, pdd_prop_size) == 0);
}
#endif /* DEBUG */
return (res);
}
int
ldi_prop_lookup_byte_array(ldi_handle_t lh,
uint_t flags, char *name, uchar_t **data, uint_t *nelements)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
dev_info_t *dip;
dev_t dev;
int res;
struct snode *csp;
if ((lh == NULL) || (name == NULL) || (strlen(name) == 0))
return (DDI_PROP_INVAL_ARG);
dev = handlep->lh_vp->v_rdev;
csp = VTOCS(handlep->lh_vp);
mutex_enter(&csp->s_lock);
if ((dip = csp->s_dip) != NULL)
e_ddi_hold_devi(dip);
mutex_exit(&csp->s_lock);
if (dip == NULL)
dip = e_ddi_hold_devi_by_dev(dev, 0);
if (dip == NULL) {
flags |= DDI_UNBND_DLPI2;
} else if (flags & LDI_DEV_T_ANY) {
flags &= ~LDI_DEV_T_ANY;
dev = DDI_DEV_T_ANY;
}
if (dip != NULL) {
uchar_t *prop_val;
int prop_len;
res = i_ldi_prop_op_typed(dev, dip, flags, name,
(caddr_t *)&prop_val, &prop_len, sizeof (uchar_t));
/* if we got it then return it */
if (res == DDI_PROP_SUCCESS) {
*nelements = prop_len / sizeof (uchar_t);
*data = prop_val;
ddi_release_devi(dip);
return (res);
}
}
/* call the normal property interfaces */
res = ddi_prop_lookup_byte_array(dev, dip, flags,
name, data, nelements);
if (dip != NULL)
ddi_release_devi(dip);
return (res);
}
int
ldi_prop_get_int(ldi_handle_t lh,
uint_t flags, char *name, int defvalue)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
dev_info_t *dip;
dev_t dev;
int res;
struct snode *csp;
if ((lh == NULL) || (name == NULL) || (strlen(name) == 0))
return (defvalue);
dev = handlep->lh_vp->v_rdev;
csp = VTOCS(handlep->lh_vp);
mutex_enter(&csp->s_lock);
if ((dip = csp->s_dip) != NULL)
e_ddi_hold_devi(dip);
mutex_exit(&csp->s_lock);
if (dip == NULL)
dip = e_ddi_hold_devi_by_dev(dev, 0);
if (dip == NULL) {
flags |= DDI_UNBND_DLPI2;
} else if (flags & LDI_DEV_T_ANY) {
flags &= ~LDI_DEV_T_ANY;
dev = DDI_DEV_T_ANY;
}
if (dip != NULL) {
int prop_val;
int prop_len;
/*
* first call the drivers prop_op interface to allow it
* it to override default property values.
*/
prop_len = sizeof (int);
res = i_ldi_prop_op(dev, dip, PROP_LEN_AND_VAL_BUF,
flags | DDI_PROP_DYNAMIC, name,
(caddr_t)&prop_val, &prop_len);
/* if we got it then return it */
if ((res == DDI_PROP_SUCCESS) &&
(prop_len == sizeof (int))) {
res = prop_val;
ddi_release_devi(dip);
return (res);
}
}
/* call the normal property interfaces */
res = ddi_prop_get_int(dev, dip, flags, name, defvalue);
if (dip != NULL)
ddi_release_devi(dip);
return (res);
}
int64_t
ldi_prop_get_int64(ldi_handle_t lh,
uint_t flags, char *name, int64_t defvalue)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
dev_info_t *dip;
dev_t dev;
int64_t res;
struct snode *csp;
if ((lh == NULL) || (name == NULL) || (strlen(name) == 0))
return (defvalue);
dev = handlep->lh_vp->v_rdev;
csp = VTOCS(handlep->lh_vp);
mutex_enter(&csp->s_lock);
if ((dip = csp->s_dip) != NULL)
e_ddi_hold_devi(dip);
mutex_exit(&csp->s_lock);
if (dip == NULL)
dip = e_ddi_hold_devi_by_dev(dev, 0);
if (dip == NULL) {
flags |= DDI_UNBND_DLPI2;
} else if (flags & LDI_DEV_T_ANY) {
flags &= ~LDI_DEV_T_ANY;
dev = DDI_DEV_T_ANY;
}
if (dip != NULL) {
int64_t prop_val;
int prop_len;
/*
* first call the drivers prop_op interface to allow it
* it to override default property values.
*/
prop_len = sizeof (int64_t);
res = i_ldi_prop_op(dev, dip, PROP_LEN_AND_VAL_BUF,
flags | DDI_PROP_DYNAMIC, name,
(caddr_t)&prop_val, &prop_len);
/* if we got it then return it */
if ((res == DDI_PROP_SUCCESS) &&
(prop_len == sizeof (int64_t))) {
res = prop_val;
ddi_release_devi(dip);
return (res);
}
}
/* call the normal property interfaces */
res = ddi_prop_get_int64(dev, dip, flags, name, defvalue);
if (dip != NULL)
ddi_release_devi(dip);
return (res);
}
int
ldi_prop_exists(ldi_handle_t lh, uint_t flags, char *name)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
dev_info_t *dip;
dev_t dev;
int res, prop_len;
struct snode *csp;
if ((lh == NULL) || (name == NULL) || (strlen(name) == 0))
return (0);
dev = handlep->lh_vp->v_rdev;
csp = VTOCS(handlep->lh_vp);
mutex_enter(&csp->s_lock);
if ((dip = csp->s_dip) != NULL)
e_ddi_hold_devi(dip);
mutex_exit(&csp->s_lock);
if (dip == NULL)
dip = e_ddi_hold_devi_by_dev(dev, 0);
/* if NULL dip, prop does NOT exist */
if (dip == NULL)
return (0);
if (flags & LDI_DEV_T_ANY) {
flags &= ~LDI_DEV_T_ANY;
dev = DDI_DEV_T_ANY;
}
/*
* first call the drivers prop_op interface to allow it
* it to override default property values.
*/
res = i_ldi_prop_op(dev, dip, PROP_LEN,
flags | DDI_PROP_DYNAMIC, name, NULL, &prop_len);
if (res == DDI_PROP_SUCCESS) {
ddi_release_devi(dip);
return (1);
}
/* call the normal property interfaces */
res = ddi_prop_exists(dev, dip, flags, name);
ddi_release_devi(dip);
return (res);
}
#ifdef LDI_OBSOLETE_EVENT
int
ldi_get_eventcookie(ldi_handle_t lh, char *name, ddi_eventcookie_t *ecp)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
dev_info_t *dip;
dev_t dev;
int res;
struct snode *csp;
if ((lh == NULL) || (name == NULL) ||
(strlen(name) == 0) || (ecp == NULL)) {
return (DDI_FAILURE);
}
ASSERT(!servicing_interrupt());
dev = handlep->lh_vp->v_rdev;
csp = VTOCS(handlep->lh_vp);
mutex_enter(&csp->s_lock);
if ((dip = csp->s_dip) != NULL)
e_ddi_hold_devi(dip);
mutex_exit(&csp->s_lock);
if (dip == NULL)
dip = e_ddi_hold_devi_by_dev(dev, 0);
if (dip == NULL)
return (DDI_FAILURE);
LDI_EVENTCB((CE_NOTE, "%s: event_name=%s, "
"dip=0x%p, event_cookiep=0x%p", "ldi_get_eventcookie",
name, (void *)dip, (void *)ecp));
res = ddi_get_eventcookie(dip, name, ecp);
ddi_release_devi(dip);
return (res);
}
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)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
struct ldi_event *lep;
dev_info_t *dip;
dev_t dev;
int res;
struct snode *csp;
if ((lh == NULL) || (ec == NULL) || (handler == NULL) || (id == NULL))
return (DDI_FAILURE);
ASSERT(!servicing_interrupt());
dev = handlep->lh_vp->v_rdev;
csp = VTOCS(handlep->lh_vp);
mutex_enter(&csp->s_lock);
if ((dip = csp->s_dip) != NULL)
e_ddi_hold_devi(dip);
mutex_exit(&csp->s_lock);
if (dip == NULL)
dip = e_ddi_hold_devi_by_dev(dev, 0);
if (dip == NULL)
return (DDI_FAILURE);
lep = kmem_zalloc(sizeof (struct ldi_event), KM_SLEEP);
lep->le_lhp = handlep;
lep->le_arg = arg;
lep->le_handler = handler;
if ((res = ddi_add_event_handler(dip, ec, i_ldi_callback,
(void *)lep, &lep->le_id)) != DDI_SUCCESS) {
LDI_EVENTCB((CE_WARN, "%s: unable to add"
"event callback", "ldi_add_event_handler"));
ddi_release_devi(dip);
kmem_free(lep, sizeof (struct ldi_event));
return (res);
}
*id = (ldi_callback_id_t)lep;
LDI_EVENTCB((CE_NOTE, "%s: dip=0x%p, event=0x%p, "
"ldi_eventp=0x%p, cb_id=0x%p", "ldi_add_event_handler",
(void *)dip, (void *)ec, (void *)lep, (void *)id));
handle_event_add(lep);
ddi_release_devi(dip);
return (res);
}
int
ldi_remove_event_handler(ldi_handle_t lh, ldi_callback_id_t id)
{
ldi_event_t *lep = (ldi_event_t *)id;
int res;
if ((lh == NULL) || (id == NULL))
return (DDI_FAILURE);
ASSERT(!servicing_interrupt());
if ((res = ddi_remove_event_handler(lep->le_id))
!= DDI_SUCCESS) {
LDI_EVENTCB((CE_WARN, "%s: unable to remove "
"event callback", "ldi_remove_event_handler"));
return (res);
}
handle_event_remove(lep);
kmem_free(lep, sizeof (struct ldi_event));
return (res);
}
#endif
/*
* Here are some definitions of terms used in the following LDI events
* code:
*
* "LDI events" AKA "native events": These are events defined by the
* "new" LDI event framework. These events are serviced by the LDI event
* framework itself and thus are native to it.
*
* "LDI contract events": These are contract events that correspond to the
* LDI events. This mapping of LDI events to contract events is defined by
* the ldi_ev_cookies[] array above.
*
* NDI events: These are events which are serviced by the NDI event subsystem.
* LDI subsystem just provides a thin wrapper around the NDI event interfaces
* These events are therefore *not* native events.
*/
static int
ldi_native_event(const char *evname)
{
int i;
LDI_EVTRC((CE_NOTE, "ldi_native_event: entered: ev=%s", evname));
for (i = 0; ldi_ev_cookies[i].ck_evname != NULL; i++) {
if (strcmp(ldi_ev_cookies[i].ck_evname, evname) == 0)
return (1);
}
return (0);
}
static uint_t
ldi_ev_sync_event(const char *evname)
{
int i;
ASSERT(ldi_native_event(evname));
LDI_EVTRC((CE_NOTE, "ldi_ev_sync_event: entered: %s", evname));
for (i = 0; ldi_ev_cookies[i].ck_evname != NULL; i++) {
if (strcmp(ldi_ev_cookies[i].ck_evname, evname) == 0)
return (ldi_ev_cookies[i].ck_sync);
}
/*
* This should never happen until non-contract based
* LDI events are introduced. If that happens, we will
* use a "special" token to indicate that there are no
* contracts corresponding to this LDI event.
*/
cmn_err(CE_PANIC, "Unknown LDI event: %s", evname);
return (0);
}
static uint_t
ldi_contract_event(const char *evname)
{
int i;
ASSERT(ldi_native_event(evname));
LDI_EVTRC((CE_NOTE, "ldi_contract_event: entered: %s", evname));
for (i = 0; ldi_ev_cookies[i].ck_evname != NULL; i++) {
if (strcmp(ldi_ev_cookies[i].ck_evname, evname) == 0)
return (ldi_ev_cookies[i].ck_ctype);
}
/*
* This should never happen until non-contract based
* LDI events are introduced. If that happens, we will
* use a "special" token to indicate that there are no
* contracts corresponding to this LDI event.
*/
cmn_err(CE_PANIC, "Unknown LDI event: %s", evname);
return (0);
}
char *
ldi_ev_get_type(ldi_ev_cookie_t cookie)
{
int i;
struct ldi_ev_cookie *cookie_impl = (struct ldi_ev_cookie *)cookie;
for (i = 0; ldi_ev_cookies[i].ck_evname != NULL; i++) {
if (&ldi_ev_cookies[i] == cookie_impl) {
LDI_EVTRC((CE_NOTE, "ldi_ev_get_type: LDI: %s",
ldi_ev_cookies[i].ck_evname));
return (ldi_ev_cookies[i].ck_evname);
}
}
/*
* Not an LDI native event. Must be NDI event service.
* Just return a generic string
*/
LDI_EVTRC((CE_NOTE, "ldi_ev_get_type: is NDI"));
return (NDI_EVENT_SERVICE);
}
static int
ldi_native_cookie(ldi_ev_cookie_t cookie)
{
int i;
struct ldi_ev_cookie *cookie_impl = (struct ldi_ev_cookie *)cookie;
for (i = 0; ldi_ev_cookies[i].ck_evname != NULL; i++) {
if (&ldi_ev_cookies[i] == cookie_impl) {
LDI_EVTRC((CE_NOTE, "ldi_native_cookie: native LDI"));
return (1);
}
}
LDI_EVTRC((CE_NOTE, "ldi_native_cookie: is NDI"));
return (0);
}
static ldi_ev_cookie_t
ldi_get_native_cookie(const char *evname)
{
int i;
for (i = 0; ldi_ev_cookies[i].ck_evname != NULL; i++) {
if (strcmp(ldi_ev_cookies[i].ck_evname, evname) == 0) {
LDI_EVTRC((CE_NOTE, "ldi_get_native_cookie: found"));
return ((ldi_ev_cookie_t)&ldi_ev_cookies[i]);
}
}
LDI_EVTRC((CE_NOTE, "ldi_get_native_cookie: NOT found"));
return (NULL);
}
/*
* ldi_ev_lock() needs to be recursive, since layered drivers may call
* other LDI interfaces (such as ldi_close() from within the context of
* a notify callback. Since the notify callback is called with the
* ldi_ev_lock() held and ldi_close() also grabs ldi_ev_lock, the lock needs
* to be recursive.
*/
static void
ldi_ev_lock(void)
{
LDI_EVTRC((CE_NOTE, "ldi_ev_lock: entered"));
mutex_enter(&ldi_ev_callback_list.le_lock);
if (ldi_ev_callback_list.le_thread == curthread) {
ASSERT(ldi_ev_callback_list.le_busy >= 1);
ldi_ev_callback_list.le_busy++;
} else {
while (ldi_ev_callback_list.le_busy)
cv_wait(&ldi_ev_callback_list.le_cv,
&ldi_ev_callback_list.le_lock);
ASSERT(ldi_ev_callback_list.le_thread == NULL);
ldi_ev_callback_list.le_busy = 1;
ldi_ev_callback_list.le_thread = curthread;
}
mutex_exit(&ldi_ev_callback_list.le_lock);
LDI_EVTRC((CE_NOTE, "ldi_ev_lock: exit"));
}
static void
ldi_ev_unlock(void)
{
LDI_EVTRC((CE_NOTE, "ldi_ev_unlock: entered"));
mutex_enter(&ldi_ev_callback_list.le_lock);
ASSERT(ldi_ev_callback_list.le_thread == curthread);
ASSERT(ldi_ev_callback_list.le_busy >= 1);
ldi_ev_callback_list.le_busy--;
if (ldi_ev_callback_list.le_busy == 0) {
ldi_ev_callback_list.le_thread = NULL;
cv_signal(&ldi_ev_callback_list.le_cv);
}
mutex_exit(&ldi_ev_callback_list.le_lock);
LDI_EVTRC((CE_NOTE, "ldi_ev_unlock: exit"));
}
int
ldi_ev_get_cookie(ldi_handle_t lh, char *evname, ldi_ev_cookie_t *cookiep)
{
struct ldi_handle *handlep = (struct ldi_handle *)lh;
dev_info_t *dip;
dev_t dev;
int res;
struct snode *csp;
ddi_eventcookie_t ddi_cookie;
ldi_ev_cookie_t tcookie;
LDI_EVDBG((CE_NOTE, "ldi_ev_get_cookie: entered: evname=%s",
evname ? evname : "<NULL>"));
if (lh == NULL || evname == NULL ||
strlen(evname) == 0 || cookiep == NULL) {
LDI_EVDBG((CE_NOTE, "ldi_ev_get_cookie: invalid args"));
return (LDI_EV_FAILURE);
}
*cookiep = NULL;
/*
* First check if it is a LDI native event
*/
tcookie = ldi_get_native_cookie(evname);
if (tcookie) {
LDI_EVDBG((CE_NOTE, "ldi_ev_get_cookie: got native cookie"));
*cookiep = tcookie;
return (LDI_EV_SUCCESS);
}
/*
* Not a LDI native event. Try NDI event services
*/
dev = handlep->lh_vp->v_rdev;
csp = VTOCS(handlep->lh_vp);
mutex_enter(&csp->s_lock);
if ((dip = csp->s_dip) != NULL)
e_ddi_hold_devi(dip);
mutex_exit(&csp->s_lock);
if (dip == NULL)
dip = e_ddi_hold_devi_by_dev(dev, 0);
if (dip == NULL) {
cmn_err(CE_WARN, "ldi_ev_get_cookie: No devinfo node for LDI "
"handle: %p", (void *)handlep);
return (LDI_EV_FAILURE);
}
LDI_EVDBG((CE_NOTE, "Calling ddi_get_eventcookie: dip=%p, ev=%s",
(void *)dip, evname));
res = ddi_get_eventcookie(dip, evname, &ddi_cookie);
ddi_release_devi(dip);
if (res == DDI_SUCCESS) {
LDI_EVDBG((CE_NOTE, "ldi_ev_get_cookie: NDI cookie found"));
*cookiep = (ldi_ev_cookie_t)ddi_cookie;
return (LDI_EV_SUCCESS);
} else {
LDI_EVDBG((CE_WARN, "ldi_ev_get_cookie: NDI cookie: failed"));
return (LDI_EV_FAILURE);
}
}
/*ARGSUSED*/
static void
i_ldi_ev_callback(dev_info_t *dip, ddi_eventcookie_t event_cookie,
void *arg, void *ev_data)
{
ldi_ev_callback_impl_t *lecp = (ldi_ev_callback_impl_t *)arg;
ASSERT(lecp != NULL);
ASSERT(!ldi_native_cookie(lecp->lec_cookie));
ASSERT(lecp->lec_lhp);
ASSERT(lecp->lec_notify == NULL);
ASSERT(lecp->lec_finalize);
LDI_EVDBG((CE_NOTE, "i_ldi_ev_callback: ldh=%p, cookie=%p, arg=%p, "
"ev_data=%p", (void *)lecp->lec_lhp, (void *)event_cookie,
(void *)lecp->lec_arg, (void *)ev_data));
lecp->lec_finalize(lecp->lec_lhp, (ldi_ev_cookie_t)event_cookie,
lecp->lec_arg, ev_data);
}
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)
{
struct ldi_handle *lhp = (struct ldi_handle *)lh;
ldi_ev_callback_impl_t *lecp;
dev_t dev;
struct snode *csp;
dev_info_t *dip;
int ddi_event;
ASSERT(!servicing_interrupt());
if (lh == NULL || cookie == NULL || callb == NULL || id == NULL) {
LDI_EVDBG((CE_NOTE, "ldi_ev_register_callbacks: Invalid args"));
return (LDI_EV_FAILURE);
}
if (callb->cb_vers != LDI_EV_CB_VERS) {
LDI_EVDBG((CE_NOTE, "ldi_ev_register_callbacks: Invalid vers"));
return (LDI_EV_FAILURE);
}
if (callb->cb_notify == NULL && callb->cb_finalize == NULL) {
LDI_EVDBG((CE_NOTE, "ldi_ev_register_callbacks: NULL callb"));
return (LDI_EV_FAILURE);
}
*id = 0;
dev = lhp->lh_vp->v_rdev;
csp = VTOCS(lhp->lh_vp);
mutex_enter(&csp->s_lock);
if ((dip = csp->s_dip) != NULL)
e_ddi_hold_devi(dip);
mutex_exit(&csp->s_lock);
if (dip == NULL)
dip = e_ddi_hold_devi_by_dev(dev, 0);
if (dip == NULL) {
cmn_err(CE_WARN, "ldi_ev_register: No devinfo node for "
"LDI handle: %p", (void *)lhp);
return (LDI_EV_FAILURE);
}
lecp = kmem_zalloc(sizeof (ldi_ev_callback_impl_t), KM_SLEEP);
ddi_event = 0;
if (!ldi_native_cookie(cookie)) {
if (callb->cb_notify || callb->cb_finalize == NULL) {
/*
* NDI event services only accept finalize
*/
cmn_err(CE_WARN, "%s: module: %s: NDI event cookie. "
"Only finalize"
" callback supported with this cookie",
"ldi_ev_register_callbacks",
lhp->lh_ident->li_modname);
kmem_free(lecp, sizeof (ldi_ev_callback_impl_t));
ddi_release_devi(dip);
return (LDI_EV_FAILURE);
}
if (ddi_add_event_handler(dip, (ddi_eventcookie_t)cookie,
i_ldi_ev_callback, (void *)lecp,
(ddi_callback_id_t *)&lecp->lec_id)
!= DDI_SUCCESS) {
kmem_free(lecp, sizeof (ldi_ev_callback_impl_t));
ddi_release_devi(dip);
LDI_EVDBG((CE_NOTE, "ldi_ev_register_callbacks(): "
"ddi_add_event_handler failed"));
return (LDI_EV_FAILURE);
}
ddi_event = 1;
LDI_EVDBG((CE_NOTE, "ldi_ev_register_callbacks(): "
"ddi_add_event_handler success"));
}
ldi_ev_lock();
/*
* Add the notify/finalize callback to the LDI's list of callbacks.
*/
lecp->lec_lhp = lhp;
lecp->lec_dev = lhp->lh_vp->v_rdev;
lecp->lec_spec = VTYP_TO_STYP(lhp->lh_vp->v_type);
lecp->lec_notify = callb->cb_notify;
lecp->lec_finalize = callb->cb_finalize;
lecp->lec_arg = arg;
lecp->lec_cookie = cookie;
if (!ddi_event)
lecp->lec_id = (void *)(uintptr_t)(++ldi_ev_id_pool);
else
ASSERT(lecp->lec_id);
lecp->lec_dip = dip;
list_insert_tail(&ldi_ev_callback_list.le_head, lecp);
*id = (ldi_callback_id_t)lecp->lec_id;
ldi_ev_unlock();
ddi_release_devi(dip);
LDI_EVDBG((CE_NOTE, "ldi_ev_register_callbacks: registered "
"notify/finalize"));
return (LDI_EV_SUCCESS);
}
static int
ldi_ev_device_match(ldi_ev_callback_impl_t *lecp, dev_info_t *dip,
dev_t dev, int spec_type)
{
ASSERT(lecp);
ASSERT(dip);
ASSERT(dev != DDI_DEV_T_NONE);
ASSERT(dev != NODEV);
ASSERT((dev == DDI_DEV_T_ANY && spec_type == 0) ||
(spec_type == S_IFCHR || spec_type == S_IFBLK));
ASSERT(lecp->lec_dip);
ASSERT(lecp->lec_spec == S_IFCHR || lecp->lec_spec == S_IFBLK);
ASSERT(lecp->lec_dev != DDI_DEV_T_ANY);
ASSERT(lecp->lec_dev != DDI_DEV_T_NONE);
ASSERT(lecp->lec_dev != NODEV);
if (dip != lecp->lec_dip)
return (0);
if (dev != DDI_DEV_T_ANY) {
if (dev != lecp->lec_dev || spec_type != lecp->lec_spec)
return (0);
}
LDI_EVTRC((CE_NOTE, "ldi_ev_device_match: MATCH dip=%p", (void *)dip));
return (1);
}
/*
* LDI framework function to post a "notify" event to all layered drivers
* that have registered for that event
*
* Returns:
* LDI_EV_SUCCESS - registered callbacks allow event
* LDI_EV_FAILURE - registered callbacks block event
* LDI_EV_NONE - No matching LDI callbacks
*
* This function is *not* to be called by layered drivers. It is for I/O
* framework code in Solaris, such as the I/O retire code and DR code
* to call while servicing a device event such as offline or degraded.
*/
int
ldi_invoke_notify(dev_info_t *dip, dev_t dev, int spec_type, char *event,
void *ev_data)
{
ldi_ev_callback_impl_t *lecp;
list_t *listp;
int ret;
char *lec_event;
ASSERT(dip);
ASSERT(dev != DDI_DEV_T_NONE);
ASSERT(dev != NODEV);
ASSERT((dev == DDI_DEV_T_ANY && spec_type == 0) ||
(spec_type == S_IFCHR || spec_type == S_IFBLK));
ASSERT(event);
ASSERT(ldi_native_event(event));
ASSERT(ldi_ev_sync_event(event));
LDI_EVDBG((CE_NOTE, "ldi_invoke_notify(): entered: dip=%p, ev=%s",
(void *)dip, event));
ret = LDI_EV_NONE;
ldi_ev_lock();
listp = &ldi_ev_callback_list.le_head;
for (lecp = list_head(listp); lecp; lecp = list_next(listp, lecp)) {
/* Check if matching device */
if (!ldi_ev_device_match(lecp, dip, dev, spec_type))
continue;
if (lecp->lec_lhp == NULL) {
/*
* Consumer has unregistered the handle and so
* is no longer interested in notify events.
*/
LDI_EVDBG((CE_NOTE, "ldi_invoke_notify(): No LDI "
"handle, skipping"));
continue;
}
if (lecp->lec_notify == NULL) {
LDI_EVDBG((CE_NOTE, "ldi_invoke_notify(): No notify "
"callback. skipping"));
continue; /* not interested in notify */
}
/*
* Check if matching event
*/
lec_event = ldi_ev_get_type(lecp->lec_cookie);
if (strcmp(event, lec_event) != 0) {
LDI_EVDBG((CE_NOTE, "ldi_invoke_notify(): Not matching"
" event {%s,%s}. skipping", event, lec_event));
continue;
}
lecp->lec_lhp->lh_flags |= LH_FLAGS_NOTIFY;
if (lecp->lec_notify(lecp->lec_lhp, lecp->lec_cookie,
lecp->lec_arg, ev_data) != LDI_EV_SUCCESS) {
ret = LDI_EV_FAILURE;
LDI_EVDBG((CE_NOTE, "ldi_invoke_notify(): notify"
" FAILURE"));
break;
}
/* We have a matching callback that allows the event to occur */
ret = LDI_EV_SUCCESS;
LDI_EVDBG((CE_NOTE, "ldi_invoke_notify(): 1 consumer success"));
}
if (ret != LDI_EV_FAILURE)
goto out;
LDI_EVDBG((CE_NOTE, "ldi_invoke_notify(): undoing notify"));
/*
* Undo notifies already sent
*/
lecp = list_prev(listp, lecp);
for (; lecp; lecp = list_prev(listp, lecp)) {
/*
* Check if matching device
*/
if (!ldi_ev_device_match(lecp, dip, dev, spec_type))
continue;
if (lecp->lec_finalize == NULL) {
LDI_EVDBG((CE_NOTE, "ldi_invoke_notify(): no finalize, "
"skipping"));
continue; /* not interested in finalize */
}
/*
* it is possible that in response to a notify event a
* layered driver closed its LDI handle so it is ok
* to have a NULL LDI handle for finalize. The layered
* driver is expected to maintain state in its "arg"
* parameter to keep track of the closed device.
*/
/* Check if matching event */
lec_event = ldi_ev_get_type(lecp->lec_cookie);
if (strcmp(event, lec_event) != 0) {
LDI_EVDBG((CE_NOTE, "ldi_invoke_notify(): not matching "
"event: %s,%s, skipping", event, lec_event));
continue;
}
LDI_EVDBG((CE_NOTE, "ldi_invoke_notify(): calling finalize"));
lecp->lec_finalize(lecp->lec_lhp, lecp->lec_cookie,
LDI_EV_FAILURE, lecp->lec_arg, ev_data);
/*
* If LDI native event and LDI handle closed in context
* of notify, NULL out the finalize callback as we have
* already called the 1 finalize above allowed in this situation
*/
if (lecp->lec_lhp == NULL &&
ldi_native_cookie(lecp->lec_cookie)) {
LDI_EVDBG((CE_NOTE,
"ldi_invoke_notify(): NULL-ing finalize after "
"calling 1 finalize following ldi_close"));
lecp->lec_finalize = NULL;
}
}
out:
ldi_ev_unlock();
if (ret == LDI_EV_NONE) {
LDI_EVDBG((CE_NOTE, "ldi_invoke_notify(): no matching "
"LDI callbacks"));
}
return (ret);
}
/*
* Framework function to be called from a layered driver to propagate
* LDI "notify" events to exported minors.
*
* This function is a public interface exported by the LDI framework
* for use by layered drivers to propagate device events up the software
* stack.
*/
int
ldi_ev_notify(dev_info_t *dip, minor_t minor, int spec_type,
ldi_ev_cookie_t cookie, void *ev_data)
{
char *evname = ldi_ev_get_type(cookie);
uint_t ct_evtype;
dev_t dev;
major_t major;
int retc;
int retl;
ASSERT(spec_type == S_IFBLK || spec_type == S_IFCHR);
ASSERT(dip);
ASSERT(ldi_native_cookie(cookie));
LDI_EVDBG((CE_NOTE, "ldi_ev_notify(): entered: event=%s, dip=%p",
evname, (void *)dip));
if (!ldi_ev_sync_event(evname)) {
cmn_err(CE_PANIC, "ldi_ev_notify(): %s not a "
"negotiatable event", evname);
return (LDI_EV_SUCCESS);
}
major = ddi_driver_major(dip);
if (major == DDI_MAJOR_T_NONE) {
char *path = kmem_alloc(MAXPATHLEN, KM_SLEEP);
(void) ddi_pathname(dip, path);
cmn_err(CE_WARN, "ldi_ev_notify: cannot derive major number "
"for device %s", path);
kmem_free(path, MAXPATHLEN);
return (LDI_EV_FAILURE);
}
dev = makedevice(major, minor);
/*
* Generate negotiation contract events on contracts (if any) associated
* with this minor.
*/
LDI_EVDBG((CE_NOTE, "ldi_ev_notify(): calling contract nego."));
ct_evtype = ldi_contract_event(evname);
retc = contract_device_negotiate(dip, dev, spec_type, ct_evtype);
if (retc == CT_NACK) {
LDI_EVDBG((CE_NOTE, "ldi_ev_notify(): contract neg. NACK"));
return (LDI_EV_FAILURE);
}
LDI_EVDBG((CE_NOTE, "ldi_ev_notify(): LDI invoke notify"));
retl = ldi_invoke_notify(dip, dev, spec_type, evname, ev_data);
if (retl == LDI_EV_FAILURE) {
LDI_EVDBG((CE_NOTE, "ldi_ev_notify(): ldi_invoke_notify "
"returned FAILURE. Calling contract negend"));
contract_device_negend(dip, dev, spec_type, CT_EV_FAILURE);
return (LDI_EV_FAILURE);
}
/*
* The very fact that we are here indicates that there is a
* LDI callback (and hence a constraint) for the retire of the
* HW device. So we just return success even if there are no
* contracts or LDI callbacks against the minors layered on top
* of the HW minors
*/
LDI_EVDBG((CE_NOTE, "ldi_ev_notify(): returning SUCCESS"));
return (LDI_EV_SUCCESS);
}
/*
* LDI framework function to invoke "finalize" callbacks for all layered
* drivers that have registered callbacks for that event.
*
* This function is *not* to be called by layered drivers. It is for I/O
* framework code in Solaris, such as the I/O retire code and DR code
* to call while servicing a device event such as offline or degraded.
*/
void
ldi_invoke_finalize(dev_info_t *dip, dev_t dev, int spec_type, char *event,
int ldi_result, void *ev_data)
{
ldi_ev_callback_impl_t *lecp;
list_t *listp;
char *lec_event;
int found = 0;
ASSERT(dip);
ASSERT(dev != DDI_DEV_T_NONE);
ASSERT(dev != NODEV);
ASSERT((dev == DDI_DEV_T_ANY && spec_type == 0) ||
(spec_type == S_IFCHR || spec_type == S_IFBLK));
ASSERT(event);
ASSERT(ldi_native_event(event));
ASSERT(ldi_result == LDI_EV_SUCCESS || ldi_result == LDI_EV_FAILURE);
LDI_EVDBG((CE_NOTE, "ldi_invoke_finalize(): entered: dip=%p, result=%d"
" event=%s", (void *)dip, ldi_result, event));
ldi_ev_lock();
listp = &ldi_ev_callback_list.le_head;
for (lecp = list_head(listp); lecp; lecp = list_next(listp, lecp)) {
if (lecp->lec_finalize == NULL) {
LDI_EVDBG((CE_NOTE, "ldi_invoke_finalize(): No "
"finalize. Skipping"));
continue; /* Not interested in finalize */
}
/*
* Check if matching device
*/
if (!ldi_ev_device_match(lecp, dip, dev, spec_type))
continue;
/*
* It is valid for the LDI handle to be NULL during finalize.
* The layered driver may have done an LDI close in the notify
* callback.
*/
/*
* Check if matching event
*/
lec_event = ldi_ev_get_type(lecp->lec_cookie);
if (strcmp(event, lec_event) != 0) {
LDI_EVDBG((CE_NOTE, "ldi_invoke_finalize(): Not "
"matching event {%s,%s}. Skipping",
event, lec_event));
continue;
}
LDI_EVDBG((CE_NOTE, "ldi_invoke_finalize(): calling finalize"));
found = 1;
lecp->lec_finalize(lecp->lec_lhp, lecp->lec_cookie,
ldi_result, lecp->lec_arg, ev_data);
/*
* If LDI native event and LDI handle closed in context
* of notify, NULL out the finalize callback as we have
* already called the 1 finalize above allowed in this situation
*/
if (lecp->lec_lhp == NULL &&
ldi_native_cookie(lecp->lec_cookie)) {
LDI_EVDBG((CE_NOTE,
"ldi_invoke_finalize(): NULLing finalize after "
"calling 1 finalize following ldi_close"));
lecp->lec_finalize = NULL;
}
}
ldi_ev_unlock();
if (found)
return;
LDI_EVDBG((CE_NOTE, "ldi_invoke_finalize(): no matching callbacks"));
}
/*
* Framework function to be called from a layered driver to propagate
* LDI "finalize" events to exported minors.
*
* This function is a public interface exported by the LDI framework
* for use by layered drivers to propagate device events up the software
* stack.
*/
void
ldi_ev_finalize(dev_info_t *dip, minor_t minor, int spec_type, int ldi_result,
ldi_ev_cookie_t cookie, void *ev_data)
{
dev_t dev;
major_t major;
char *evname;
int ct_result = (ldi_result == LDI_EV_SUCCESS) ?
CT_EV_SUCCESS : CT_EV_FAILURE;
uint_t ct_evtype;
ASSERT(dip);
ASSERT(spec_type == S_IFBLK || spec_type == S_IFCHR);
ASSERT(ldi_result == LDI_EV_SUCCESS || ldi_result == LDI_EV_FAILURE);
ASSERT(ldi_native_cookie(cookie));
LDI_EVDBG((CE_NOTE, "ldi_ev_finalize: entered: dip=%p", (void *)dip));
major = ddi_driver_major(dip);
if (major == DDI_MAJOR_T_NONE) {
char *path = kmem_alloc(MAXPATHLEN, KM_SLEEP);
(void) ddi_pathname(dip, path);
cmn_err(CE_WARN, "ldi_ev_finalize: cannot derive major number "
"for device %s", path);
kmem_free(path, MAXPATHLEN);
return;
}
dev = makedevice(major, minor);
evname = ldi_ev_get_type(cookie);
LDI_EVDBG((CE_NOTE, "ldi_ev_finalize: calling contracts"));
ct_evtype = ldi_contract_event(evname);
contract_device_finalize(dip, dev, spec_type, ct_evtype, ct_result);
LDI_EVDBG((CE_NOTE, "ldi_ev_finalize: calling ldi_invoke_finalize"));
ldi_invoke_finalize(dip, dev, spec_type, evname, ldi_result, ev_data);
}
int
ldi_ev_remove_callbacks(ldi_callback_id_t id)
{
ldi_ev_callback_impl_t *lecp;
ldi_ev_callback_impl_t *next;
ldi_ev_callback_impl_t *found;
list_t *listp;
ASSERT(!servicing_interrupt());
if (id == 0) {
cmn_err(CE_WARN, "ldi_ev_remove_callbacks: Invalid ID 0");
return (LDI_EV_FAILURE);
}
LDI_EVDBG((CE_NOTE, "ldi_ev_remove_callbacks: entered: id=%p",
(void *)id));
ldi_ev_lock();
listp = &ldi_ev_callback_list.le_head;
next = found = NULL;
for (lecp = list_head(listp); lecp; lecp = next) {
next = list_next(listp, lecp);
if (lecp->lec_id == id) {
ASSERT(found == NULL);
list_remove(listp, lecp);
found = lecp;
}
}
ldi_ev_unlock();
if (found == NULL) {
cmn_err(CE_WARN, "No LDI event handler for id (%p)",
(void *)id);
return (LDI_EV_SUCCESS);
}
if (!ldi_native_cookie(found->lec_cookie)) {
ASSERT(found->lec_notify == NULL);
if (ddi_remove_event_handler((ddi_callback_id_t)id)
!= DDI_SUCCESS) {
cmn_err(CE_WARN, "failed to remove NDI event handler "
"for id (%p)", (void *)id);
ldi_ev_lock();
list_insert_tail(listp, found);
ldi_ev_unlock();
return (LDI_EV_FAILURE);
}
LDI_EVDBG((CE_NOTE, "ldi_ev_remove_callbacks: NDI event "
"service removal succeeded"));
} else {
LDI_EVDBG((CE_NOTE, "ldi_ev_remove_callbacks: removed "
"LDI native callbacks"));
}
kmem_free(found, sizeof (ldi_ev_callback_impl_t));
return (LDI_EV_SUCCESS);
}