/*
* 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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* The driver portion of kmdb, which manages /dev/kmdb and passes requests along
* to the kmdb misc module (kmdbmod).
*/
#include <sys/conf.h>
#include <sys/stat.h>
#include <sys/modctl.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/open.h>
#include <sys/kobj.h>
#include <sys/kdi.h>
#include <sys/policy.h>
#include <sys/kobj_impl.h>
#include <sys/kmdb.h>
#include <sys/sysmacros.h>
#include <sys/consdev.h>
#define KDRV_CFG_MAXLEN 2048
static dev_info_t *kdrv_dip;
/*ARGSUSED*/
static int
kdrv_open(dev_t *dev, int openflags, int otyp, cred_t *credp)
{
if (otyp != OTYP_CHR)
return (EINVAL);
if (secpolicy_kmdb(credp) != 0)
return (EPERM);
return (0);
}
/*ARGSUSED*/
static int
kdrv_close(dev_t dev, int openflags, int otyp, cred_t *credp)
{
return (0);
}
typedef struct kdrv_flags_map {
const char *fm_name;
int fm_defval;
uint_t fm_flag;
} kdrv_flags_map_t;
static const kdrv_flags_map_t kdrv_flags_map[] = {
{ "kmdb-auto-entry", 1, KMDB_F_AUTO_ENTRY },
{ "kmdb-trap-noswitch", 0, KMDB_F_TRAP_NOSWITCH },
{ "kmdb-driver-debug", 0, KMDB_F_DRV_DEBUG },
{ NULL }
};
static int
kdrv_activate(intptr_t arg)
{
uint_t flags;
size_t memsz;
char *cfg;
size_t got;
int i, rc;
#if defined(__x86)
if (cons_polledio == NULL) {
cmn_err(CE_NOTE, "kmdb not supported: no console polled I/O");
return (ENOTSUP);
}
#endif
memsz = ddi_prop_get_int(DDI_DEV_T_ANY, kdrv_dip,
DDI_PROP_DONTPASS, "kmdb-memseg-size", 0);
for (flags = 0, i = 0; kdrv_flags_map[i].fm_name != NULL; i++) {
const kdrv_flags_map_t *fm = &kdrv_flags_map[i];
if (ddi_prop_get_int(DDI_DEV_T_ANY, kdrv_dip, DDI_PROP_DONTPASS,
(char *)fm->fm_name, fm->fm_defval))
flags |= fm->fm_flag;
}
cfg = kmem_alloc(KDRV_CFG_MAXLEN, KM_SLEEP);
if ((rc = copyinstr((caddr_t)arg, cfg, KDRV_CFG_MAXLEN, &got)) != 0) {
kmem_free(cfg, KDRV_CFG_MAXLEN);
return (rc == ENAMETOOLONG ? E2BIG : EFAULT);
}
rc = kctl_modload_activate(memsz, cfg, flags);
kmem_free(cfg, KDRV_CFG_MAXLEN);
return (rc);
}
static int
kdrv_deactivate(void)
{
return (kctl_deactivate());
}
/*ARGSUSED*/
static int
kdrv_ioctl(dev_t dev, int cmd, intptr_t arg, int flags, cred_t *credp,
int *rvalp)
{
switch (cmd) {
case KMDB_IOC_START:
return (kdrv_activate(arg));
case KMDB_IOC_STOP:
return (kdrv_deactivate());
default:
return (EINVAL);
}
}
/*ARGSUSED*/
static int
kdrv_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
int error = DDI_SUCCESS;
switch (infocmd) {
case DDI_INFO_DEVT2DEVINFO:
*result = kdrv_dip;
break;
case DDI_INFO_DEVT2INSTANCE:
*result = (void *)(uintptr_t)getminor((dev_t)arg);
break;
default:
*result = NULL;
error = DDI_FAILURE;
}
return (error);
}
static int
kdrv_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
if (cmd != DDI_ATTACH)
return (DDI_FAILURE);
if (ddi_create_minor_node(dip, ddi_get_name(dip), S_IFCHR,
ddi_get_instance(dip), DDI_PSEUDO, 0) != DDI_SUCCESS)
return (DDI_FAILURE);
kdrv_dip = dip;
if (kctl_attach(dip) != 0)
return (DDI_FAILURE);
return (DDI_SUCCESS);
}
static int
kdrv_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
if (cmd != DDI_DETACH)
return (DDI_FAILURE);
if (kctl_detach() == EBUSY)
return (DDI_FAILURE);
ddi_remove_minor_node(dip, NULL);
return (DDI_SUCCESS);
}
static struct cb_ops kdrv_cb_ops = {
kdrv_open,
kdrv_close,
nodev, /* not a block driver */
nodev, /* no print routine */
nodev, /* no dump routine */
nodev, /* no read routine */
nodev, /* no write routine */
kdrv_ioctl,
nodev, /* no devmap routine */
nodev, /* no mmap routine */
nodev, /* no segmap routine */
nochpoll, /* no chpoll routine */
ddi_prop_op,
0, /* not a STREAMS driver */
D_NEW | D_MP, /* safe for multi-thread/multi-processor */
};
static struct dev_ops kdrv_ops = {
DEVO_REV, /* devo_rev */
0, /* devo_refcnt */
kdrv_getinfo, /* devo_getinfo */
nulldev, /* devo_identify */
nulldev, /* devo_probe */
kdrv_attach, /* devo_attach */
kdrv_detach, /* devo_detach */
nodev, /* devo_reset */
&kdrv_cb_ops, /* devo_cb_ops */
(struct bus_ops *)0, /* devo_bus_ops */
NULL, /* devo_power */
ddi_quiesce_not_needed, /* devo_quiesce */
};
static struct modldrv modldrv = {
&mod_driverops,
"kmdb driver",
&kdrv_ops
};
static struct modlinkage modlinkage = {
MODREV_1,
(void *)&modldrv,
NULL
};
int
_init(void)
{
return (mod_install(&modlinkage));
}
int
_info(struct modinfo *modinfop)
{
return (mod_info(&modlinkage, modinfop));
}
int
_fini(void)
{
return (mod_remove(&modlinkage));
}