UIO_WRITE
uiomove(buffer, 1024, UIO_WRITE, uiop);
assert(rw == UIO_READ || rw == UIO_WRITE);
err = copy_mblks(buf, inlen, UIO_WRITE, mp);
err = copy_mblks(buf, inlen, UIO_WRITE, mp);
if (rw == UIO_WRITE && ISROFILE(vp))
if (nbl_conflict(vp, rw == UIO_WRITE ? NBL_WRITE : NBL_READ,
rw == UIO_WRITE ? V_WRITELOCK_TRUE : V_WRITELOCK_FALSE, NULL);
if (rw == UIO_WRITE) {
rw == UIO_WRITE ? V_WRITELOCK_TRUE : V_WRITELOCK_FALSE, NULL);
case UIO_WRITE:
err = uiomove(buf, inlen, UIO_WRITE, in);
err = uiomove(buf, inlen, UIO_WRITE, in);
if (error = vn_rdwr(UIO_WRITE, vp, (caddr_t)cpr_pagecopy,
if (rc = cpr_rdwr(UIO_WRITE, vp, cdef, sizeof (*cdef)))
(void) cpr_rdwr(UIO_WRITE, vp, &mini, sizeof (mini));
error = uiomove((caddr_t)bp->b_rptr, size, UIO_WRITE, uiop);
error = uiomove(base, count, UIO_WRITE, uiop);
error = uiomove(base, n, UIO_WRITE, uio);
error = uiomove(base, count, UIO_WRITE, uiop);
error = uiomove(base, n, UIO_WRITE, uio);
error = uiomove(base, count, UIO_WRITE, uiop);
error = rwpcp(pcp, uiop, UIO_WRITE, ioflag);
ASSERT(rw == UIO_READ || rw == UIO_WRITE);
if (uio->uio_loffset >= limit && rw == UIO_WRITE) {
if (rw == UIO_WRITE && uio->uio_loffset + n >= limit) {
if (rw == UIO_WRITE) {
rw == UIO_WRITE ? S_WRITE : S_READ);
if (rw == UIO_WRITE)
enum uio_rw rw = (cmd == PCREAD)? UIO_READ : UIO_WRITE;
if ((ret = uiomove(start, toread, UIO_WRITE, prwc->prwc_uiop)) != 0) {
error = pr_rdwr(p, UIO_WRITE, &argp->priovec);
case UIO_WRITE:
if ((error = uiomove(bp, len, UIO_WRITE, uiop)) != 0)
if ((error = uiomove(lwpname, THREAD_NAME_MAX, UIO_WRITE, uiop)) != 0) {
error = prusrio(p, UIO_WRITE, uiop, old);
rw = UIO_WRITE;
error = uiomove(base, n, UIO_WRITE, uio);
error = smb_rwuio(np->n_fid, UIO_WRITE,
error = smb_rwuio(np->n_fid, UIO_WRITE,
UIO_WRITE, uiop)) != 0) {
error = uiomove(base + on, n, UIO_WRITE, uiop);
(long)bytes, UIO_WRITE, uio);
error = ud_rdwri(UIO_WRITE, ioflag, ip,
if (rw == UIO_WRITE) {
error = uiomove(base + mapon, (long)n, UIO_WRITE, uio);
(void) ufs_rdwri(UIO_WRITE, FWRITE, qip,
(void) ufs_rdwri(UIO_WRITE, FWRITE | FSYNC, qip, (caddr_t)&dqp->dq_dqb,
if (((err = ufs_rdwri(UIO_WRITE, FWRITE|FSYNC, sip, acldata,
error = uiomove(copy_base, copy_resid, UIO_WRITE, uio);
error = ufs_rdwri(UIO_WRITE, ioflag, ip, target, strlen(target),
if (rw == UIO_WRITE) {
error = uiomove(base + mapon, (long)n, UIO_WRITE, uio);
if (rw == UIO_WRITE && ISROFILE(vp))
if (nbl_conflict(vp, rw == UIO_WRITE ? NBL_WRITE : NBL_READ,
rw == UIO_WRITE ? V_WRITELOCK_TRUE : V_WRITELOCK_FALSE, NULL);
if (rw == UIO_WRITE) {
rw == UIO_WRITE ? V_WRITELOCK_TRUE : V_WRITELOCK_FALSE, NULL);
if (uiomove((caddr_t)buf, size, UIO_WRITE, uiop)) {
UIO_WRITE, uio);
da->da_err = vn_rdwr(UIO_WRITE, da->da_vp, (caddr_t)&da->da_ddr,
dsp->dsa_err = vn_rdwr(UIO_WRITE, dsp->dsa_vp,
err = vn_rdwr(UIO_WRITE, vp, buf, buflen, 0, UIO_SYSSPACE,
error = vn_rdwr((bp->b_flags & B_READ) ? UIO_READ : UIO_WRITE,
error = vn_rdwr(UIO_WRITE, ZTOV(zp), data, length, offset,
UIO_WRITE, uio, &cbytes)) {
case UIO_WRITE:
ASSERT(abuf || ioflag == UIO_WRITE);
error = uiomove(mp->b_rptr, mpsize, UIO_WRITE, uiop);
error = uiomove(mp->b_rptr, size, UIO_WRITE, uiop);
if ((ret = uiomove(&arq, sizeof (arq), UIO_WRITE, uiop)) != 0) {
ret = uiomove(mp->b_wptr, copylen, UIO_WRITE, uiop);
ret = uiomove(axp->ax_ciph, AV1394_CIPSZ, UIO_WRITE, uiop);
ret = uiomove(kaddr, len, UIO_WRITE, uiop);
if (uiomove(u8_p, len, UIO_WRITE, uio_p)) {
cnt * framesz, UIO_WRITE, uio);
error = uiomove(mtod(m, void *), len, UIO_WRITE, uio);
ret = vn_rdwr(UIO_WRITE, sl->sl_data_vp, (caddr_t)buf, (ssize_t)size,
vret = vn_rdwr(UIO_WRITE, vp, (caddr_t)io_buf, (ssize_t)io_size,
error = vn_rdwr(UIO_WRITE, vp, buf, len, off,
if ((error = uiocopy((caddr_t)pollfdp, uiosize, UIO_WRITE, uiop,
if ((err = uiomove(&val, sizeof (val), UIO_WRITE, uio)) != 0)
if (error = vn_rdwr(UIO_WRITE, (cowp->cow_backfile_array)[bf_index],
ret = uiomove(&output, sizeof (output), UIO_WRITE, uiop);
ret = uiomove(at->at_buf, nbytes, UIO_WRITE, uio);
ret = uiomove((caddr_t)&uio_data, uio_data_len, UIO_WRITE, uio);
rc = uiomove(user_mad, len, UIO_WRITE, uiop);
if (uiomove(&hdr, sizeof (hdr), UIO_WRITE, uiop) != 0) {
if (uiomove(&payload, len, UIO_WRITE, uiop) != 0) {
UserBufferSize, UIO_WRITE, uiop);
ret = uiomove(mp->b_rptr, uiop->uio_resid, UIO_WRITE, uiop);
ret = uiomove(rdsv3_sg_page(sg), rdsv3_sg_len(sg), UIO_WRITE,
error = vn_rdwr(UIO_WRITE, lsp->ls_vp, iobuf, len,
error = vn_rdwr(UIO_WRITE, lsp->ls_vp, buf, DEV_BSIZE,
if (rw == UIO_WRITE)
if (rw == UIO_WRITE) {
return (mmrw(dev, uio, UIO_WRITE, cred));
if ((error = uiomove(buf, bytes, UIO_WRITE, uiop)) != 0)
return (nvf_rw(fdes, cbuf, count, UIO_WRITE));
error = vn_rdwr(UIO_WRITE, vnp, bufp, data_len, offset,
if (error = uiomove(ptr, cnt, UIO_WRITE, uiop)) {
UIO_WRITE, uiop)) != 0) {
ret = uiomove(tpm->iobuf, TPM_HEADER_SIZE, UIO_WRITE, uiop);
UIO_WRITE, uiop);
error = uiomove((caddr_t)bp->b_wptr, count, UIO_WRITE, uiop);
if (uiocopy(slot->cs_io.ci_ibuf, len, UIO_WRITE, uiop, &cbytes) != 0) {
int e = uiomove(virtio_dma_va(vnr->vnr_dma_out, 0), wsz, UIO_WRITE,
error = vn_rdwr(UIO_WRITE, vp, (caddr_t)&ag->acctbuf,
vn_rdwr(UIO_WRITE, console_vnode, cm->cm_text, strlen(cm->cm_text),
error = vn_rdwr(UIO_WRITE, vp, (caddr_t)buf, len,
err = vn_rdwr(UIO_WRITE, fp->kf_vp, buf, len, fp->kf_fpos,
err = vn_rdwr(UIO_WRITE, dumpbuf.cdev_vp != NULL ?
error = vn_rdwr(UIO_WRITE, info->ac_vnode, (caddr_t)buf,
error = vn_rdwr(UIO_WRITE, vp, buf, count, *vo,
(void) vn_rdwr(UIO_WRITE, sp->s_vp, body,
error = uiomove(bp->b_wptr, size, UIO_WRITE,
if (rw == UIO_WRITE) {
if (rw == UIO_WRITE) {
iov_len, UIO_WRITE, &auio);
iov_len, UIO_WRITE, &auio);
uiorw = (rw == S_WRITE) ? UIO_WRITE : UIO_READ;
if ((rc = uiomove(kbuf, count, UIO_WRITE, uio)) != 0)
if (uiomove(xbs->u.buffer + xbs->len, len, UIO_WRITE, uiop) != 0) {
return (sbmem_rw(dev, uio, UIO_WRITE, cred));
if ((ret = uiomove(&req_value, sizeof (req_value), UIO_WRITE,
current_xfer_len, UIO_WRITE, uiop)) != 0) {
UIO_WRITE, uiop)) != 0) {
if ((ret = uiomove(&out_value, sizeof (out_value), UIO_WRITE,
if (rc = cpr_rdwr(UIO_WRITE, vp,
len - sizeof (ds_snmp_msg_t), UIO_WRITE, uiop) != 0) {
UIO_WRITE, uiop);
return (rw == UIO_WRITE ? ENOSPC : 0);
rv = uiomove(&(buf.data), bytes, UIO_WRITE, uiop);
status = vn_rdwr((buf->b_flags & B_READ)? UIO_READ : UIO_WRITE,
status = vn_rdwr((operation == VD_OP_BREAD)? UIO_READ : UIO_WRITE,
rv = uiomove(vport->send_buf, size, UIO_WRITE, uiop);