Sample Multithreaded Device Driver
Example 12-1 is a sample multithreaded, loadable, STREAMS pseudo-driver. The driver MT design is the simplest possible based on using a per module inner perimeter. Thus, only one thread can execute in the driver at any time. In addition, a quntimeout(9F) synchronous callback routine is used. The driver cancels an outstanding qtimeout(9F) by calling quntimeout(9F) in the close routine. See "Close Race Conditions".
Example 12-1 Sample Multithreaded, Loadable, STREAMS Pseudo-Driver
/*
* Example SunOS 5 multithreaded STREAMS pseudo device driver.
* Using a D_MTPERMOD inner perimeter.
*/
#include <sys/types.h>
#include <sys/errno.h>
#include <sys/stropts.h>
#include <sys/stream.h>
#include <sys/strlog.h>
#include <sys/cmn_err.h>
#include <sys/modctl.h>
#include <sys/kmem.h>
#include <sys/conf.h>
#include <sys/ksynch.h>
#include <sys/stat.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
/*
* Function prototypes.
*/
static int xxidentify(dev_info_t *);
static int xxattach(dev_info_t *, ddi_attach_cmd_t);
static int xxdetach(dev_info_t *, ddi_detach_cmd_t);
static int xxgetinfo(dev_info_t *,ddi_info_cmd_t,void *,void**);
static int xxopen(queue_t *, dev_t *, int, int, cred_t *);
static int xxclose(queue_t *, int, cred_t *);
static int xxwput(queue_t *, mblk_t *);
static int xxwsrv(queue_t *);
static void xxtick(caddr_t);
/*
* Streams Declarations
*/
static struct module_info xxm_info = {
99, /* mi_idnum */
"xx", /* mi_idname */
0, /* mi_minpsz */
INFPSZ, /* mi_maxpsz */
0, /* mi_hiwat */
0 /* mi_lowat */
};
static struct qinit xxrinit = {
NULL, /* qi_putp */
NULL, /* qi_srvp */
xxopen, /* qi_qopen */
xxclose, /* qi_qclose */
NULL, /* qi_qadmin */
&xxm_info, /* qi_minfo */
NULL /* qi_mstat */
};
static struct qinit xxwinit = {
xxwput, /* qi_putp */
xxwsrv, /* qi_srvp */
NULL, /* qi_qopen */
NULL, /* qi_qclose */
NULL, /* qi_qadmin */
&xxm_info, /* qi_minfo */
NULL /* qi_mstat */
};
static struct streamtab xxstrtab = {
&xxrinit, /* st_rdinit */
&xxwinit, /* st_wrinit */
NULL, /* st_muxrinit */
NULL /* st_muxwrinit */
};
/*
* define the xx_ops structure.
*/
static struct cb_ops cb_xx_ops = {
nodev, /* cb_open */
nodev, /* cb_close */
nodev, /* cb_strategy */
nodev, /* cb_print */
nodev, /* cb_dump */
nodev, /* cb_read */
nodev, /* cb_write */
nodev, /* cb_ioctl */
nodev, /* cb_devmap */
nodev, /* cb_mmap */
nodev, /* cb_segmap */
nochpoll, /* cb_chpoll */
ddi_prop_op, /* cb_prop_op */
&xxstrtab, /* cb_stream */
(D_NEW|D_MP|D_MTPERMOD) /* cb_flag */
};
static struct dev_ops xx_ops = {
DEVO_REV, /* devo_rev */
0, /* devo_refcnt */
xxgetinfo, /* devo_getinfo */
xxidentify, /* devo_identify */
nodev, /* devo_probe */
xxattach, /* devo_attach */
xxdetach, /* devo_detach */
nodev, /* devo_reset */
&cb_xx_ops, /* devo_cb_ops */
(struct bus_ops *)NULL /* devo_bus_ops */
};
/*
* Module linkage information for the kernel.
*/
static struct modldrv modldrv = {
&mod_driverops, /* Type of module. This one is a driver */
"xx", /* Driver name */
&xx_ops, /* driver ops */
};
static struct modlinkage modlinkage = {
MODREV_1,
&modldrv,
NULL
};
/*
* Driver private data structure. One is allocated per Stream.
*/
struct xxstr {
struct xxstr *xx_next; /* pointer to next in list */
queue_t *xx_rq; /* read side queue pointer */
minor_t xx_minor; /* minor device # (for clone) */
int xx_timeoutid; /* id returned from timeout() */
};
/*
* Linked list of opened Stream xxstr structures.
* No need for locks protecting it since the whole module is
* single threaded using the D_MTPERMOD perimeter.
*/
static struct xxstr *xxup = NULL;
/*
* Module Config entry points
*/
_init(void)
{
return (mod_install(&modlinkage));
}
_fini(void)
{
return (mod_remove(&modlinkage));
}
_info(struct modinfo *modinfop)
{
return (mod_info(&modlinkage, modinfop));
}
/*
* Auto Configuration entry points
*/
/* Identify device. */
static int
xxidentify(dev_info_t *dip)
{
if (strcmp(ddi_get_name(dip), "xx") == 0)
return (DDI_IDENTIFIED);
else
return (DDI_NOT_IDENTIFIED);
}
/* Attach device. */
static int
xxattach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
/* This creates the device node. */
if (ddi_create_minor_node(dip, "xx", S_IFCHR, ddi_get_instance(dip),
DDI_PSEUDO, CLONE_DEV) == DDI_FAILURE) {
return (DDI_FAILURE);
}
ddi_report_dev(dip);
return (DDI_SUCCESS);
}
/* Detach device. */
static int
xxdetach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
ddi_remove_minor_node(dip, NULL);
return (DDI_SUCCESS);
}
/* ARGSUSED */
static int
xxgetinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **resultp)
{
dev_t dev = (dev_t) arg;
int instance, ret = DDI_FAILURE;
devstate_t *sp;
state *statep;
instance = getminor(dev);
switch (infocmd) {
case DDI_INFO_DEVT2DEVINFO:
if ((sp = ddi_get_soft_state(statep,
getminor((dev_t) arg))) != NULL) {
*resultp = sp->devi;
ret = DDI_SUCCESS;
} else
*result = NULL;
break;
case DDI_INFO_DEVT2INSTANCE:
*resultp = (void *)instance;
ret = DDI_SUCCESS;
break;
default:
break;
}
return (ret);
}
static
xxopen(rq, devp, flag, sflag, credp)
queue_t *rq;
dev_t *devp;
int flag;
int sflag;
cred_t *credp;
{
struct xxstr *xxp;
struct xxstr **prevxxp;
minor_t minordev;
/* If this Stream already open - we're done. */
if (rq->q_ptr)
return (0);
/* Determine minor device number. */
prevxxp = & xxup;
if (sflag == CLONEOPEN) {
minordev = 0;
while ((xxp = *prevxxp) != NULL) {
if (minordev < xxp->xx_minor)
break;
minordev++;
prevxxp = &xxp->xx_next;
}
*devp = makedevice(getmajor(*devp), minordev)
} else
minordev = getminor(*devp);
/* Allocate our private per-Stream data structure. */
if ((xxp = kmem_alloc(sizeof (struct xxstr), KM_SLEEP)) == NULL)
return (ENOMEM);
/* Point q_ptr at it. */
rq->q_ptr = WR(rq)->q_ptr = (char *) xxp;
/* Initialize it. */
xxp->xx_minor = minordev;
xxp->xx_timeoutid = 0;
xxp->xx_rq = rq;
/* Link new entry into the list of active entries. */
xxp->xx_next = *prevxxp;
*prevxxp = xxp;
/* Enable xxput() and xxsrv() procedures on this queue. */
qprocson(rq);
return (0);
}
static
xxclose(rq, flag, credp)
queue_t *rq;
int flag;
cred_t *credp;
{
struct xxstr *xxp;
struct xxstr **prevxxp;
/* Disable xxput() and xxsrv() procedures on this queue. */
qprocsoff(rq);
/* Cancel any pending timeout. */
xxp = (struct xxstr *) rq->q_ptr;
if (xxp->xx_timeoutid != 0) {
(void) quntimeout(rq, xxp->xx_timeoutid);
xxp->xx_timeoutid = 0;
}
/* Unlink per-Stream entry from the active list and free it. */
for (prevxxp = &xxup; (xxp = *prevxxp) != NULL; prevxxp = &xxp->xx_next)
if (xxp == (struct xxstr *) rq->q_ptr)
break;
*prevxxp = xxp->xx_next;
kmem_free (xxp, sizeof (struct xxstr));
rq->q_ptr = WR(rq)->q_ptr = NULL;
return (0);
}
static
xxwput(wq, mp)
queue_t *wq;
mblk_t *mp;
{
struct xxstr *xxp = (struct xxstr *)wq->q_ptr;
/* do stuff here */
freemsg(mp);
mp = NULL;
if (mp != NULL)
putnext(wq, mp);
}
static
xxwsrv(wq)
queue_t *wq;
{
mblk_t *mp;
struct xxstr *xxp;
xxp = (struct xxstr *) wq->q_ptr;
while (mp = getq(wq)) {
/* do stuff here */
freemsg(mp);
/* for example, start a timeout */
if (xxp->xx_timeoutid != 0) {
/* cancel running timeout */
(void) quntimeout(wq, xxp->xx_timeoutid);
}
xxp->xx_timeoutid = qtimeout(wq, xxtick, (char *)xxp, 10);
}
}
static void
xxtick(arg)
caddr_t arg;
{
struct xxstr *xxp = (struct xxstr *)arg;
xxp->xx_timeoutid = 0; /* timeout has run */
/* do stuff */
}
- © 2010, Oracle Corporation and/or its affiliates