/* open the xenevt device; this is where we clone */
int
xenevtopen(dev_t dev, int flags, int mode, struct lwp *l)
{
struct xenevt_d *d;
struct file *fp;
int fd, error;
switch(minor(dev)) {
case DEV_EVT:
/* falloc() will use the descriptor for us. */
if ((error = fd_allocfile(&fp, &fd)) != 0)
return error;
d = malloc(sizeof(*d), M_DEVBUF, M_WAITOK | M_ZERO);
d->ci = &cpu_info_primary;
mutex_init(&d->lock, MUTEX_DEFAULT, IPL_HIGH);
cv_init(&d->cv, "xenevt");
selinit(&d->sel);
return fd_clone(fp, fd, flags, &xenevt_fileops, d);
case DEV_XSD:
/* no clone for /dev/xsd_kva */
return (0);
default:
break;
}
return ENODEV;
}
static int
xen_dev_open(dev_t dev, int flags, int mode, struct lwp *l)
{
const struct xen_dev_info *xdinfo;
int fd, err;
struct file *fp;
void *fdata;
DPRINTF(("xen devsw: opening minor=%lu\n", (unsigned long)minor(dev)));
if (minor(dev) < 0 || minor(dev) >= NUM_DEV_INFOS)
return ENODEV;
xdinfo = &devs[minor(dev)];
if (!xdinfo->xd_open)
return ENODEV;
err = fd_allocfile(&fp, &fd);
if (err)
return err;
DPRINTF(("%s: opening...\n", xdinfo->path));
err = xdinfo->xd_open(fp, &fdata);
if (err) {
fd_abort(curproc, fp, fd);
return err;
}
DPRINTF(("%s: opened, fd_clone\n", xdinfo->path));
return fd_clone(fp, fd, flags, xdinfo->fo, fdata);
}
int
rndopen(dev_t dev, int flags, int fmt, struct lwp *l)
{
bool hard;
struct file *fp;
int fd;
int error;
switch (minor(dev)) {
case RND_DEV_URANDOM:
hard = false;
break;
case RND_DEV_RANDOM:
hard = true;
break;
default:
return ENXIO;
}
error = fd_allocfile(&fp, &fd);
if (error)
return error;
/*
* Allocate a context, but don't create a CPRNG yet -- do that
* lazily because it consumes entropy from the system entropy
* pool, which (currently) has the effect of depleting it and
* causing readers from /dev/random to block. If this is
* /dev/urandom and the process is about to send only short
* reads to it, then we will be using a per-CPU CPRNG anyway.
*/
struct rnd_ctx *const ctx = pool_cache_get(rnd_ctx_cache, PR_WAITOK);
ctx->rc_cprng = NULL;
ctx->rc_hard = hard;
error = fd_clone(fp, fd, flags, &rnd_fileops, ctx);
KASSERT(error == EMOVEFD);
return error;
}
static int
tap_dev_cloner(struct lwp *l)
{
struct tap_softc *sc;
file_t *fp;
int error, fd;
if ((error = fd_allocfile(&fp, &fd)) != 0)
return (error);
if ((sc = tap_clone_creator(-1)) == NULL) {
fd_abort(curproc, fp, fd);
return (ENXIO);
}
sc->sc_flags |= TAP_INUSE;
return fd_clone(fp, fd, FREAD|FWRITE, &tap_fileops,
(void *)(intptr_t)device_unit(sc->sc_dev));
}
/*
* dmoverioopen:
*
* Device switch open routine.
*/
int
dmoverioopen(dev_t dev, int flag, int mode, struct lwp *l)
{
struct dmio_state *ds;
struct file *fp;
int error, fd, s;
/* falloc() will use the descriptor for us. */
if ((error = fd_allocfile(&fp, &fd)) != 0)
return (error);
s = splsoftclock();
ds = pool_get(&dmio_state_pool, PR_WAITOK);
splx(s);
memset(ds, 0, sizeof(*ds));
simple_lock_init(&ds->ds_slock);
TAILQ_INIT(&ds->ds_pending);
TAILQ_INIT(&ds->ds_complete);
selinit(&ds->ds_selq);
return fd_clone(fp, fd, flag, &dmio_fileops, ds);
}
int
svr4_netopen(dev_t dev, int flag, int mode, struct lwp *l)
{
int type, protocol;
int fd;
file_t *fp;
struct socket *so;
int error;
int family;
DPRINTF(("netopen("));
if (curlwp->l_dupfd >= 0) /* XXX */
return ENODEV;
switch (minor(dev)) {
case dev_udp:
family = AF_INET;
type = SOCK_DGRAM;
protocol = IPPROTO_UDP;
DPRINTF(("udp, "));
break;
case dev_tcp:
family = AF_INET;
type = SOCK_STREAM;
protocol = IPPROTO_TCP;
DPRINTF(("tcp, "));
break;
case dev_ip:
case dev_rawip:
family = AF_INET;
type = SOCK_RAW;
protocol = IPPROTO_IP;
DPRINTF(("ip, "));
break;
case dev_icmp:
family = AF_INET;
type = SOCK_RAW;
protocol = IPPROTO_ICMP;
DPRINTF(("icmp, "));
break;
case dev_unix_dgram:
family = AF_LOCAL;
type = SOCK_DGRAM;
protocol = 0;
DPRINTF(("unix-dgram, "));
break;
case dev_unix_stream:
case dev_unix_ord_stream:
family = AF_LOCAL;
type = SOCK_STREAM;
protocol = 0;
DPRINTF(("unix-stream, "));
break;
default:
DPRINTF(("%d);\n", minor(dev)));
return EOPNOTSUPP;
}
if ((error = fd_allocfile(&fp, &fd)) != 0)
return error;
if ((error = socreate(family, &so, type, protocol, l, NULL)) != 0) {
DPRINTF(("socreate error %d\n", error));
fd_abort(curproc, fp, fd);
return error;
}
error = fd_clone(fp, fd, flag, &svr4_netops, so);
fp->f_type = DTYPE_SOCKET;
(void)svr4_stream_get(fp);
DPRINTF(("ok);\n"));
return error;
}
