/*
* vml_iocdata() -
* Handle the M_IOCDATA messages associated with
* a request to validate a module list.
*/
static void
vml_iocdata(
queue_t *qp, /* pointer to write queue */
mblk_t *mp) /* message pointer */
{
long i;
int nmods;
struct copyresp *csp;
struct str_mlist *lp;
STRUCT_HANDLE(str_list, slp);
struct saddev *sadp;
csp = (struct copyresp *)mp->b_rptr;
if (csp->cp_rval) { /* if there was an error */
freemsg(mp);
return;
}
ASSERT(csp->cp_cmd == SAD_VML);
sadp = (struct saddev *)qp->q_ptr;
switch ((long)csp->cp_private) {
case GETSTRUCT:
STRUCT_SET_HANDLE(slp, csp->cp_flag,
(struct str_list *)mp->b_cont->b_rptr);
nmods = STRUCT_FGET(slp, sl_nmods);
if (nmods <= 0) {
miocnak(qp, mp, 0, EINVAL);
break;
}
sadp->sa_addr = (caddr_t)(uintptr_t)nmods;
mcopyin(mp, (void *)GETLIST, nmods * sizeof (struct str_mlist),
STRUCT_FGETP(slp, sl_modlist));
qreply(qp, mp);
break;
case GETLIST:
lp = (struct str_mlist *)mp->b_cont->b_rptr;
for (i = 0; i < (long)sadp->sa_addr; i++, lp++) {
lp->l_name[FMNAMESZ] = '\0';
if (fmodsw_find(lp->l_name, FMODSW_LOAD) == NULL) {
miocack(qp, mp, 0, 1);
return;
}
}
miocack(qp, mp, 0, 0);
break;
default:
cmn_err(CE_WARN, "vml_iocdata: invalid cp_private value: %p",
(void *)csp->cp_private);
freemsg(mp);
break;
} /* switch (cp_private) */
}
/* ARGSUSED */
static int
get_soft_list(dev_t dev, caddr_t arg, int mode, int *rval)
{
STRUCT_DECL(crypto_get_soft_list, soft_list);
char *names;
size_t len;
uint_t count;
STRUCT_INIT(soft_list, mode);
if (copyin(arg, STRUCT_BUF(soft_list), STRUCT_SIZE(soft_list)) != 0)
return (EFAULT);
/* get the list from the core module */
if (crypto_get_soft_list(&count, &names, &len) != 0) {
STRUCT_FSET(soft_list, sl_return_value, CRYPTO_FAILED);
if (copyout(STRUCT_BUF(soft_list), arg,
STRUCT_SIZE(soft_list)) != 0) {
return (EFAULT);
}
return (0);
}
/* check if buffer is too small */
if (len > STRUCT_FGET(soft_list, sl_soft_len)) {
STRUCT_FSET(soft_list, sl_soft_count, count);
STRUCT_FSET(soft_list, sl_soft_len, len);
STRUCT_FSET(soft_list, sl_return_value,
CRYPTO_BUFFER_TOO_SMALL);
kmem_free(names, len);
if (copyout(STRUCT_BUF(soft_list), arg,
STRUCT_SIZE(soft_list)) != 0) {
return (EFAULT);
}
return (0);
}
STRUCT_FSET(soft_list, sl_soft_count, count);
STRUCT_FSET(soft_list, sl_soft_len, len);
STRUCT_FSET(soft_list, sl_return_value, CRYPTO_SUCCESS);
if (count > 0 && copyout(names,
STRUCT_FGETP(soft_list, sl_soft_names), len) != 0) {
kmem_free(names, len);
return (EFAULT);
}
kmem_free(names, len);
if (copyout(STRUCT_BUF(soft_list), arg, STRUCT_SIZE(soft_list)) != 0) {
return (EFAULT);
}
return (0);
}
/*ARGSUSED*/
static int
cpuid_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *cr, int *rval)
{
char areq[16];
void *ustr;
switch (cmd) {
case CPUID_GET_HWCAP: {
STRUCT_DECL(cpuid_get_hwcap, h);
STRUCT_INIT(h, mode);
if (ddi_copyin((void *)arg,
STRUCT_BUF(h), STRUCT_SIZE(h), mode))
return (EFAULT);
if ((ustr = STRUCT_FGETP(h, cgh_archname)) != NULL &&
copyinstr(ustr, areq, sizeof (areq), NULL) != 0)
return (EFAULT);
areq[sizeof (areq) - 1] = '\0';
if (strcmp(areq, architecture) == 0)
STRUCT_FSET(h, cgh_hwcap, auxv_hwcap);
#if defined(_SYSCALL32_IMPL)
else if (strcmp(areq, architecture_32) == 0)
STRUCT_FSET(h, cgh_hwcap, auxv_hwcap32);
#endif
else
STRUCT_FSET(h, cgh_hwcap, 0);
if (ddi_copyout(STRUCT_BUF(h),
(void *)arg, STRUCT_SIZE(h), mode))
return (EFAULT);
return (0);
}
default:
return (ENOTTY);
}
}
/*ARGSUSED*/
static int
kcpc_ioctl(dev_t dev, int cmd, intptr_t data, int flags, cred_t *cr, int *rvp)
{
kthread_t *t = curthread;
processorid_t cpuid;
void *udata1 = NULL;
void *udata2 = NULL;
void *udata3 = NULL;
int error;
int code;
STRUCT_DECL(__cpc_args, args);
STRUCT_INIT(args, flags);
if (curthread->t_bind_cpu != getminor(dev))
return (EAGAIN); /* someone unbound it? */
cpuid = getminor(dev);
if (cmd == CPCIO_BIND || cmd == CPCIO_SAMPLE) {
if (copyin((void *)data, STRUCT_BUF(args),
STRUCT_SIZE(args)) == -1)
return (EFAULT);
udata1 = STRUCT_FGETP(args, udata1);
udata2 = STRUCT_FGETP(args, udata2);
udata3 = STRUCT_FGETP(args, udata3);
}
switch (cmd) {
case CPCIO_BIND:
/*
* udata1 = pointer to packed nvlist buffer
* udata2 = size of packed nvlist buffer
* udata3 = User addr to return error subcode in.
*/
if (t->t_cpc_set != NULL) {
(void) kcpc_unbind(t->t_cpc_set);
ASSERT(t->t_cpc_set == NULL);
}
if ((error = kcpc_copyin_set(&t->t_cpc_set, udata1,
(size_t)udata2)) != 0) {
return (error);
}
if ((error = kcpc_verify_set(t->t_cpc_set)) != 0) {
kcpc_free_set(t->t_cpc_set);
t->t_cpc_set = NULL;
if (copyout(&error, udata3, sizeof (error)) == -1)
return (EFAULT);
return (EINVAL);
}
if ((error = kcpc_bind_cpu(t->t_cpc_set, cpuid, &code)) != 0) {
kcpc_free_set(t->t_cpc_set);
t->t_cpc_set = NULL;
/*
* Subcodes are only returned for EINVAL and EACCESS.
*/
if ((error == EINVAL || error == EACCES) &&
copyout(&code, udata3, sizeof (code)) == -1)
return (EFAULT);
return (error);
}
return (0);
case CPCIO_SAMPLE:
/*
* udata1 = pointer to user's buffer
* udata2 = pointer to user's hrtime
* udata3 = pointer to user's tick
*/
/*
* Only CPU-bound sets may be sampled via the ioctl(). If this
* set has no CPU-bound context, return an error.
*/
if (t->t_cpc_set == NULL)
return (EINVAL);
if ((error = kcpc_sample(t->t_cpc_set, udata1, udata2,
udata3)) != 0)
return (error);
return (0);
case CPCIO_RELE:
if (t->t_cpc_set == NULL)
return (EINVAL);
return (kcpc_unbind(t->t_cpc_set));
default:
return (EINVAL);
}
}
/* ARGSUSED */
int
dadk_ioctl(opaque_t objp, dev_t dev, int cmd, intptr_t arg, int flag,
cred_t *cred_p, int *rval_p)
{
struct dadk *dadkp = (struct dadk *)objp;
switch (cmd) {
case DKIOCGETDEF:
{
struct buf *bp;
int err, head;
unsigned char *secbuf;
STRUCT_DECL(defect_header, adh);
STRUCT_INIT(adh, flag & FMODELS);
/*
* copyin header ....
* yields head number and buffer address
*/
if (ddi_copyin((caddr_t)arg, STRUCT_BUF(adh), STRUCT_SIZE(adh),
flag))
return (EFAULT);
head = STRUCT_FGET(adh, head);
if (head < 0 || head >= dadkp->dad_phyg.g_head)
return (ENXIO);
secbuf = kmem_zalloc(NBPSCTR, KM_SLEEP);
if (!secbuf)
return (ENOMEM);
bp = getrbuf(KM_SLEEP);
if (!bp) {
kmem_free(secbuf, NBPSCTR);
return (ENOMEM);
}
bp->b_edev = dev;
bp->b_dev = cmpdev(dev);
bp->b_flags = B_BUSY;
bp->b_resid = 0;
bp->b_bcount = NBPSCTR;
bp->b_un.b_addr = (caddr_t)secbuf;
bp->b_blkno = head; /* I had to put it somwhere! */
bp->b_forw = (struct buf *)dadkp;
bp->b_back = (struct buf *)DCMD_GETDEF;
mutex_enter(&dadkp->dad_cmd_mutex);
dadkp->dad_cmd_count++;
mutex_exit(&dadkp->dad_cmd_mutex);
FLC_ENQUE(dadkp->dad_flcobjp, bp);
err = biowait(bp);
if (!err) {
if (ddi_copyout((caddr_t)secbuf,
STRUCT_FGETP(adh, buffer), NBPSCTR, flag))
err = ENXIO;
}
kmem_free(secbuf, NBPSCTR);
freerbuf(bp);
return (err);
}
case DIOCTL_RWCMD:
{
struct dadkio_rwcmd *rwcmdp;
int status, rw;
/*
* copied in by cmdk and, if necessary, converted to the
* correct datamodel
*/
rwcmdp = (struct dadkio_rwcmd *)(intptr_t)arg;
/*
* handle the complex cases here; we pass these
* through to the driver, which will queue them and
* handle the requests asynchronously. The simpler
* cases ,which can return immediately, fail here, and
* the request reverts to the dadk_ioctl routine, while
* will reroute them directly to the ata driver.
*/
switch (rwcmdp->cmd) {
case DADKIO_RWCMD_READ :
/*FALLTHROUGH*/
case DADKIO_RWCMD_WRITE:
rw = ((rwcmdp->cmd == DADKIO_RWCMD_WRITE) ?
B_WRITE : B_READ);
status = dadk_dk_buf_setup(dadkp,
(opaque_t)rwcmdp, dev, ((flag &FKIOCTL) ?
UIO_SYSSPACE : UIO_USERSPACE), rw);
return (status);
default:
return (EINVAL);
}
}
case DKIOC_UPDATEFW:
/*
* Require PRIV_ALL privilege to invoke DKIOC_UPDATEFW
* to protect the firmware update from malicious use
*/
if (PRIV_POLICY(cred_p, PRIV_ALL, B_FALSE, EPERM, NULL) != 0)
return (EPERM);
else
return (dadk_ctl_ioctl(dadkp, cmd, arg, flag));
case DKIOCFLUSHWRITECACHE:
{
struct buf *bp;
int err = 0;
struct dk_callback *dkc = (struct dk_callback *)arg;
struct cmpkt *pktp;
int is_sync = 1;
mutex_enter(&dadkp->dad_mutex);
if (dadkp->dad_noflush || ! dadkp->dad_wce) {
err = dadkp->dad_noflush ? ENOTSUP : 0;
mutex_exit(&dadkp->dad_mutex);
/*
* If a callback was requested: a
* callback will always be done if the
* caller saw the DKIOCFLUSHWRITECACHE
* ioctl return 0, and never done if the
* caller saw the ioctl return an error.
*/
if ((flag & FKIOCTL) && dkc != NULL &&
dkc->dkc_callback != NULL) {
(*dkc->dkc_callback)(dkc->dkc_cookie,
err);
/*
* Did callback and reported error.
* Since we did a callback, ioctl
* should return 0.
*/
err = 0;
}
return (err);
}
mutex_exit(&dadkp->dad_mutex);
bp = getrbuf(KM_SLEEP);
bp->b_edev = dev;
bp->b_dev = cmpdev(dev);
bp->b_flags = B_BUSY;
bp->b_resid = 0;
bp->b_bcount = 0;
SET_BP_SEC(bp, 0);
if ((flag & FKIOCTL) && dkc != NULL &&
dkc->dkc_callback != NULL) {
struct dk_callback *dkc2 =
(struct dk_callback *)kmem_zalloc(
sizeof (struct dk_callback), KM_SLEEP);
bcopy(dkc, dkc2, sizeof (*dkc2));
bp->b_private = dkc2;
bp->b_iodone = dadk_flushdone;
is_sync = 0;
}
/*
* Setup command pkt
* dadk_pktprep() can't fail since DDI_DMA_SLEEP set
*/
pktp = dadk_pktprep(dadkp, NULL, bp,
dadk_iodone, DDI_DMA_SLEEP, NULL);
pktp->cp_time = DADK_FLUSH_CACHE_TIME;
*((char *)(pktp->cp_cdbp)) = DCMD_FLUSH_CACHE;
pktp->cp_byteleft = 0;
pktp->cp_private = NULL;
pktp->cp_secleft = 0;
pktp->cp_srtsec = -1;
pktp->cp_bytexfer = 0;
CTL_IOSETUP(dadkp->dad_ctlobjp, pktp);
mutex_enter(&dadkp->dad_cmd_mutex);
dadkp->dad_cmd_count++;
mutex_exit(&dadkp->dad_cmd_mutex);
FLC_ENQUE(dadkp->dad_flcobjp, bp);
if (is_sync) {
err = biowait(bp);
freerbuf(bp);
}
return (err);
}
default:
if (!dadkp->dad_rmb)
return (dadk_ctl_ioctl(dadkp, cmd, arg, flag));
}
switch (cmd) {
case CDROMSTOP:
return (dadk_rmb_ioctl(dadkp, DCMD_STOP_MOTOR, 0,
0, DADK_SILENT));
case CDROMSTART:
return (dadk_rmb_ioctl(dadkp, DCMD_START_MOTOR, 0,
0, DADK_SILENT));
case DKIOCLOCK:
return (dadk_rmb_ioctl(dadkp, DCMD_LOCK, 0, 0, DADK_SILENT));
case DKIOCUNLOCK:
return (dadk_rmb_ioctl(dadkp, DCMD_UNLOCK, 0, 0, DADK_SILENT));
case DKIOCEJECT:
case CDROMEJECT:
{
int ret;
if (ret = dadk_rmb_ioctl(dadkp, DCMD_UNLOCK, 0, 0,
DADK_SILENT)) {
return (ret);
}
if (ret = dadk_rmb_ioctl(dadkp, DCMD_EJECT, 0, 0,
DADK_SILENT)) {
return (ret);
}
mutex_enter(&dadkp->dad_mutex);
dadkp->dad_iostate = DKIO_EJECTED;
cv_broadcast(&dadkp->dad_state_cv);
mutex_exit(&dadkp->dad_mutex);
return (0);
}
default:
return (ENOTTY);
/*
* cdrom audio commands
*/
case CDROMPAUSE:
cmd = DCMD_PAUSE;
break;
case CDROMRESUME:
cmd = DCMD_RESUME;
break;
case CDROMPLAYMSF:
cmd = DCMD_PLAYMSF;
break;
case CDROMPLAYTRKIND:
cmd = DCMD_PLAYTRKIND;
break;
case CDROMREADTOCHDR:
cmd = DCMD_READTOCHDR;
break;
case CDROMREADTOCENTRY:
cmd = DCMD_READTOCENT;
break;
case CDROMVOLCTRL:
cmd = DCMD_VOLCTRL;
break;
case CDROMSUBCHNL:
cmd = DCMD_SUBCHNL;
break;
case CDROMREADMODE2:
cmd = DCMD_READMODE2;
break;
case CDROMREADMODE1:
cmd = DCMD_READMODE1;
break;
case CDROMREADOFFSET:
cmd = DCMD_READOFFSET;
break;
}
return (dadk_rmb_ioctl(dadkp, cmd, arg, flag, 0));
}
