17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate * CDDL HEADER START
37c478bd9Sstevel@tonic-gate *
47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the
517169044Sbrutus * Common Development and Distribution License (the "License").
617169044Sbrutus * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate *
87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate * and limitations under the License.
127c478bd9Sstevel@tonic-gate *
137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate *
197c478bd9Sstevel@tonic-gate * CDDL HEADER END
207c478bd9Sstevel@tonic-gate */
217c478bd9Sstevel@tonic-gate /*
222fdbea25SAleksandr Guzovskiy * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
237c478bd9Sstevel@tonic-gate * Use is subject to license terms.
247c478bd9Sstevel@tonic-gate */
257c478bd9Sstevel@tonic-gate
267c478bd9Sstevel@tonic-gate /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
277c478bd9Sstevel@tonic-gate /* All Rights Reserved */
287c478bd9Sstevel@tonic-gate
297c478bd9Sstevel@tonic-gate /*
307c478bd9Sstevel@tonic-gate * University Copyright- Copyright (c) 1982, 1986, 1988
317c478bd9Sstevel@tonic-gate * The Regents of the University of California
327c478bd9Sstevel@tonic-gate * All Rights Reserved
337c478bd9Sstevel@tonic-gate *
347c478bd9Sstevel@tonic-gate * University Acknowledgment- Portions of this document are derived from
357c478bd9Sstevel@tonic-gate * software developed by the University of California, Berkeley, and its
367c478bd9Sstevel@tonic-gate * contributors.
377c478bd9Sstevel@tonic-gate */
387c478bd9Sstevel@tonic-gate
397c478bd9Sstevel@tonic-gate #include <sys/types.h>
407c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
417c478bd9Sstevel@tonic-gate #include <sys/param.h>
427c478bd9Sstevel@tonic-gate #include <sys/systm.h>
437c478bd9Sstevel@tonic-gate #include <sys/uio.h>
447c478bd9Sstevel@tonic-gate #include <sys/errno.h>
4517169044Sbrutus #include <sys/vmsystm.h>
4617169044Sbrutus #include <sys/cmn_err.h>
4717169044Sbrutus #include <vm/as.h>
4817169044Sbrutus #include <vm/page.h>
4917169044Sbrutus
5017169044Sbrutus #include <sys/dcopy.h>
5117169044Sbrutus
5217169044Sbrutus int64_t uioa_maxpoll = -1; /* <0 = noblock, 0 = block, >0 = block after */
5317169044Sbrutus #define UIO_DCOPY_CHANNEL 0
5417169044Sbrutus #define UIO_DCOPY_CMD 1
557c478bd9Sstevel@tonic-gate
567c478bd9Sstevel@tonic-gate /*
577c478bd9Sstevel@tonic-gate * Move "n" bytes at byte address "p"; "rw" indicates the direction
587c478bd9Sstevel@tonic-gate * of the move, and the I/O parameters are provided in "uio", which is
597c478bd9Sstevel@tonic-gate * update to reflect the data which was moved. Returns 0 on success or
607c478bd9Sstevel@tonic-gate * a non-zero errno on failure.
617c478bd9Sstevel@tonic-gate */
627c478bd9Sstevel@tonic-gate int
uiomove(void * p,size_t n,enum uio_rw rw,struct uio * uio)637c478bd9Sstevel@tonic-gate uiomove(void *p, size_t n, enum uio_rw rw, struct uio *uio)
647c478bd9Sstevel@tonic-gate {
657c478bd9Sstevel@tonic-gate struct iovec *iov;
667c478bd9Sstevel@tonic-gate ulong_t cnt;
677c478bd9Sstevel@tonic-gate int error;
687c478bd9Sstevel@tonic-gate
697c478bd9Sstevel@tonic-gate while (n && uio->uio_resid) {
707c478bd9Sstevel@tonic-gate iov = uio->uio_iov;
717c478bd9Sstevel@tonic-gate cnt = MIN(iov->iov_len, n);
727c478bd9Sstevel@tonic-gate if (cnt == 0l) {
737c478bd9Sstevel@tonic-gate uio->uio_iov++;
747c478bd9Sstevel@tonic-gate uio->uio_iovcnt--;
757c478bd9Sstevel@tonic-gate continue;
767c478bd9Sstevel@tonic-gate }
777c478bd9Sstevel@tonic-gate switch (uio->uio_segflg) {
787c478bd9Sstevel@tonic-gate
797c478bd9Sstevel@tonic-gate case UIO_USERSPACE:
807c478bd9Sstevel@tonic-gate case UIO_USERISPACE:
817c478bd9Sstevel@tonic-gate if (rw == UIO_READ) {
827c478bd9Sstevel@tonic-gate error = xcopyout_nta(p, iov->iov_base, cnt,
837c478bd9Sstevel@tonic-gate (uio->uio_extflg & UIO_COPY_CACHED));
847c478bd9Sstevel@tonic-gate } else {
857c478bd9Sstevel@tonic-gate error = xcopyin_nta(iov->iov_base, p, cnt,
867c478bd9Sstevel@tonic-gate (uio->uio_extflg & UIO_COPY_CACHED));
877c478bd9Sstevel@tonic-gate }
887c478bd9Sstevel@tonic-gate
897c478bd9Sstevel@tonic-gate if (error)
907c478bd9Sstevel@tonic-gate return (error);
917c478bd9Sstevel@tonic-gate break;
927c478bd9Sstevel@tonic-gate
937c478bd9Sstevel@tonic-gate case UIO_SYSSPACE:
947c478bd9Sstevel@tonic-gate if (rw == UIO_READ)
957c478bd9Sstevel@tonic-gate error = kcopy_nta(p, iov->iov_base, cnt,
967c478bd9Sstevel@tonic-gate (uio->uio_extflg & UIO_COPY_CACHED));
977c478bd9Sstevel@tonic-gate else
987c478bd9Sstevel@tonic-gate error = kcopy_nta(iov->iov_base, p, cnt,
997c478bd9Sstevel@tonic-gate (uio->uio_extflg & UIO_COPY_CACHED));
1007c478bd9Sstevel@tonic-gate if (error)
1017c478bd9Sstevel@tonic-gate return (error);
1027c478bd9Sstevel@tonic-gate break;
1037c478bd9Sstevel@tonic-gate }
1047c478bd9Sstevel@tonic-gate iov->iov_base += cnt;
1057c478bd9Sstevel@tonic-gate iov->iov_len -= cnt;
1067c478bd9Sstevel@tonic-gate uio->uio_resid -= cnt;
1077c478bd9Sstevel@tonic-gate uio->uio_loffset += cnt;
1087c478bd9Sstevel@tonic-gate p = (caddr_t)p + cnt;
1097c478bd9Sstevel@tonic-gate n -= cnt;
1107c478bd9Sstevel@tonic-gate }
1117c478bd9Sstevel@tonic-gate return (0);
1127c478bd9Sstevel@tonic-gate }
1137c478bd9Sstevel@tonic-gate
1146f5f1c63SDonghai Qiao /*
1156f5f1c63SDonghai Qiao * Fault in the pages of the first n bytes specified by the uio structure.
1166f5f1c63SDonghai Qiao * 1 byte in each page is touched and the uio struct is unmodified. Any
1176f5f1c63SDonghai Qiao * error will terminate the process as this is only a best attempt to get
1186f5f1c63SDonghai Qiao * the pages resident.
1196f5f1c63SDonghai Qiao */
1206f5f1c63SDonghai Qiao void
uio_prefaultpages(ssize_t n,struct uio * uio)1216f5f1c63SDonghai Qiao uio_prefaultpages(ssize_t n, struct uio *uio)
1226f5f1c63SDonghai Qiao {
1236f5f1c63SDonghai Qiao struct iovec *iov;
1246f5f1c63SDonghai Qiao ulong_t cnt, incr;
1256f5f1c63SDonghai Qiao caddr_t p;
1266f5f1c63SDonghai Qiao uint8_t tmp;
1276f5f1c63SDonghai Qiao int iovcnt;
1286f5f1c63SDonghai Qiao
1296f5f1c63SDonghai Qiao iov = uio->uio_iov;
1306f5f1c63SDonghai Qiao iovcnt = uio->uio_iovcnt;
1316f5f1c63SDonghai Qiao
1326f5f1c63SDonghai Qiao while ((n > 0) && (iovcnt > 0)) {
1336f5f1c63SDonghai Qiao cnt = MIN(iov->iov_len, n);
1346f5f1c63SDonghai Qiao if (cnt == 0) {
1356f5f1c63SDonghai Qiao /* empty iov entry */
1366f5f1c63SDonghai Qiao iov++;
1376f5f1c63SDonghai Qiao iovcnt--;
1386f5f1c63SDonghai Qiao continue;
1396f5f1c63SDonghai Qiao }
1406f5f1c63SDonghai Qiao n -= cnt;
1416f5f1c63SDonghai Qiao /*
1426f5f1c63SDonghai Qiao * touch each page in this segment.
1436f5f1c63SDonghai Qiao */
1446f5f1c63SDonghai Qiao p = iov->iov_base;
1456f5f1c63SDonghai Qiao while (cnt) {
1466f5f1c63SDonghai Qiao switch (uio->uio_segflg) {
1476f5f1c63SDonghai Qiao case UIO_USERSPACE:
1486f5f1c63SDonghai Qiao case UIO_USERISPACE:
1496f5f1c63SDonghai Qiao if (fuword8(p, &tmp))
1506f5f1c63SDonghai Qiao return;
1516f5f1c63SDonghai Qiao break;
1526f5f1c63SDonghai Qiao case UIO_SYSSPACE:
1536f5f1c63SDonghai Qiao if (kcopy(p, &tmp, 1))
1546f5f1c63SDonghai Qiao return;
1556f5f1c63SDonghai Qiao break;
1566f5f1c63SDonghai Qiao }
1576f5f1c63SDonghai Qiao incr = MIN(cnt, PAGESIZE);
1586f5f1c63SDonghai Qiao p += incr;
1596f5f1c63SDonghai Qiao cnt -= incr;
1606f5f1c63SDonghai Qiao }
1616f5f1c63SDonghai Qiao /*
1626f5f1c63SDonghai Qiao * touch the last byte in case it straddles a page.
1636f5f1c63SDonghai Qiao */
1646f5f1c63SDonghai Qiao p--;
1656f5f1c63SDonghai Qiao switch (uio->uio_segflg) {
1666f5f1c63SDonghai Qiao case UIO_USERSPACE:
1676f5f1c63SDonghai Qiao case UIO_USERISPACE:
1686f5f1c63SDonghai Qiao if (fuword8(p, &tmp))
1696f5f1c63SDonghai Qiao return;
1706f5f1c63SDonghai Qiao break;
1716f5f1c63SDonghai Qiao case UIO_SYSSPACE:
1726f5f1c63SDonghai Qiao if (kcopy(p, &tmp, 1))
1736f5f1c63SDonghai Qiao return;
1746f5f1c63SDonghai Qiao break;
1756f5f1c63SDonghai Qiao }
1766f5f1c63SDonghai Qiao iov++;
1776f5f1c63SDonghai Qiao iovcnt--;
1786f5f1c63SDonghai Qiao }
1796f5f1c63SDonghai Qiao }
1806f5f1c63SDonghai Qiao
1812fdbea25SAleksandr Guzovskiy /*
1822fdbea25SAleksandr Guzovskiy * same as uiomove() but doesn't modify uio structure.
1832fdbea25SAleksandr Guzovskiy * return in cbytes how many bytes were copied.
1842fdbea25SAleksandr Guzovskiy */
1852fdbea25SAleksandr Guzovskiy int
uiocopy(void * p,size_t n,enum uio_rw rw,struct uio * uio,size_t * cbytes)1862fdbea25SAleksandr Guzovskiy uiocopy(void *p, size_t n, enum uio_rw rw, struct uio *uio, size_t *cbytes)
1872fdbea25SAleksandr Guzovskiy {
1882fdbea25SAleksandr Guzovskiy struct iovec *iov;
1892fdbea25SAleksandr Guzovskiy ulong_t cnt;
1902fdbea25SAleksandr Guzovskiy int error;
1912fdbea25SAleksandr Guzovskiy int iovcnt;
1922fdbea25SAleksandr Guzovskiy
1932fdbea25SAleksandr Guzovskiy iovcnt = uio->uio_iovcnt;
1942fdbea25SAleksandr Guzovskiy *cbytes = 0;
1952fdbea25SAleksandr Guzovskiy
1962fdbea25SAleksandr Guzovskiy for (iov = uio->uio_iov; n && iovcnt; iov++, iovcnt--) {
1972fdbea25SAleksandr Guzovskiy cnt = MIN(iov->iov_len, n);
1982fdbea25SAleksandr Guzovskiy if (cnt == 0)
1992fdbea25SAleksandr Guzovskiy continue;
2002fdbea25SAleksandr Guzovskiy
2012fdbea25SAleksandr Guzovskiy switch (uio->uio_segflg) {
2022fdbea25SAleksandr Guzovskiy
2032fdbea25SAleksandr Guzovskiy case UIO_USERSPACE:
2042fdbea25SAleksandr Guzovskiy case UIO_USERISPACE:
2052fdbea25SAleksandr Guzovskiy if (rw == UIO_READ) {
2062fdbea25SAleksandr Guzovskiy error = xcopyout_nta(p, iov->iov_base, cnt,
2072fdbea25SAleksandr Guzovskiy (uio->uio_extflg & UIO_COPY_CACHED));
2082fdbea25SAleksandr Guzovskiy } else {
2092fdbea25SAleksandr Guzovskiy error = xcopyin_nta(iov->iov_base, p, cnt,
2102fdbea25SAleksandr Guzovskiy (uio->uio_extflg & UIO_COPY_CACHED));
2112fdbea25SAleksandr Guzovskiy }
2122fdbea25SAleksandr Guzovskiy
2132fdbea25SAleksandr Guzovskiy if (error)
2142fdbea25SAleksandr Guzovskiy return (error);
2152fdbea25SAleksandr Guzovskiy break;
2162fdbea25SAleksandr Guzovskiy
2172fdbea25SAleksandr Guzovskiy case UIO_SYSSPACE:
2182fdbea25SAleksandr Guzovskiy if (rw == UIO_READ)
2192fdbea25SAleksandr Guzovskiy error = kcopy_nta(p, iov->iov_base, cnt,
2202fdbea25SAleksandr Guzovskiy (uio->uio_extflg & UIO_COPY_CACHED));
2212fdbea25SAleksandr Guzovskiy else
2222fdbea25SAleksandr Guzovskiy error = kcopy_nta(iov->iov_base, p, cnt,
2232fdbea25SAleksandr Guzovskiy (uio->uio_extflg & UIO_COPY_CACHED));
2242fdbea25SAleksandr Guzovskiy if (error)
2252fdbea25SAleksandr Guzovskiy return (error);
2262fdbea25SAleksandr Guzovskiy break;
2272fdbea25SAleksandr Guzovskiy }
2282fdbea25SAleksandr Guzovskiy p = (caddr_t)p + cnt;
2292fdbea25SAleksandr Guzovskiy n -= cnt;
2302fdbea25SAleksandr Guzovskiy *cbytes += cnt;
2312fdbea25SAleksandr Guzovskiy }
2322fdbea25SAleksandr Guzovskiy return (0);
2332fdbea25SAleksandr Guzovskiy }
2342fdbea25SAleksandr Guzovskiy
2357c478bd9Sstevel@tonic-gate /*
2367c478bd9Sstevel@tonic-gate * transfer a character value into the address space
2377c478bd9Sstevel@tonic-gate * delineated by a uio and update fields within the
2387c478bd9Sstevel@tonic-gate * uio for next character. Return 0 for success, EFAULT
2397c478bd9Sstevel@tonic-gate * for error.
2407c478bd9Sstevel@tonic-gate */
2417c478bd9Sstevel@tonic-gate int
ureadc(int val,struct uio * uiop)2427c478bd9Sstevel@tonic-gate ureadc(int val, struct uio *uiop)
2437c478bd9Sstevel@tonic-gate {
2447c478bd9Sstevel@tonic-gate struct iovec *iovp;
2457c478bd9Sstevel@tonic-gate unsigned char c;
2467c478bd9Sstevel@tonic-gate
2477c478bd9Sstevel@tonic-gate /*
2487c478bd9Sstevel@tonic-gate * first determine if uio is valid. uiop should be
2497c478bd9Sstevel@tonic-gate * non-NULL and the resid count > 0.
2507c478bd9Sstevel@tonic-gate */
2517c478bd9Sstevel@tonic-gate if (!(uiop && uiop->uio_resid > 0))
2527c478bd9Sstevel@tonic-gate return (EFAULT);
2537c478bd9Sstevel@tonic-gate
2547c478bd9Sstevel@tonic-gate /*
2557c478bd9Sstevel@tonic-gate * scan through iovecs until one is found that is non-empty.
2567c478bd9Sstevel@tonic-gate * Return EFAULT if none found.
2577c478bd9Sstevel@tonic-gate */
2587c478bd9Sstevel@tonic-gate while (uiop->uio_iovcnt > 0) {
2597c478bd9Sstevel@tonic-gate iovp = uiop->uio_iov;
2607c478bd9Sstevel@tonic-gate if (iovp->iov_len <= 0) {
2617c478bd9Sstevel@tonic-gate uiop->uio_iovcnt--;
2627c478bd9Sstevel@tonic-gate uiop->uio_iov++;
2637c478bd9Sstevel@tonic-gate } else
2647c478bd9Sstevel@tonic-gate break;
2657c478bd9Sstevel@tonic-gate }
2667c478bd9Sstevel@tonic-gate
2677c478bd9Sstevel@tonic-gate if (uiop->uio_iovcnt <= 0)
2687c478bd9Sstevel@tonic-gate return (EFAULT);
2697c478bd9Sstevel@tonic-gate
2707c478bd9Sstevel@tonic-gate /*
2717c478bd9Sstevel@tonic-gate * Transfer character to uio space.
2727c478bd9Sstevel@tonic-gate */
2737c478bd9Sstevel@tonic-gate
2747c478bd9Sstevel@tonic-gate c = (unsigned char) (val & 0xFF);
2757c478bd9Sstevel@tonic-gate
2767c478bd9Sstevel@tonic-gate switch (uiop->uio_segflg) {
2777c478bd9Sstevel@tonic-gate
2787c478bd9Sstevel@tonic-gate case UIO_USERISPACE:
2797c478bd9Sstevel@tonic-gate case UIO_USERSPACE:
2807c478bd9Sstevel@tonic-gate if (copyout(&c, iovp->iov_base, sizeof (unsigned char)))
2817c478bd9Sstevel@tonic-gate return (EFAULT);
2827c478bd9Sstevel@tonic-gate break;
2837c478bd9Sstevel@tonic-gate
2847c478bd9Sstevel@tonic-gate case UIO_SYSSPACE: /* can do direct copy since kernel-kernel */
2857c478bd9Sstevel@tonic-gate *iovp->iov_base = c;
2867c478bd9Sstevel@tonic-gate break;
2877c478bd9Sstevel@tonic-gate
2887c478bd9Sstevel@tonic-gate default:
2897c478bd9Sstevel@tonic-gate return (EFAULT); /* invalid segflg value */
2907c478bd9Sstevel@tonic-gate }
2917c478bd9Sstevel@tonic-gate
2927c478bd9Sstevel@tonic-gate /*
2937c478bd9Sstevel@tonic-gate * bump up/down iovec and uio members to reflect transfer.
2947c478bd9Sstevel@tonic-gate */
2957c478bd9Sstevel@tonic-gate iovp->iov_base++;
2967c478bd9Sstevel@tonic-gate iovp->iov_len--;
2977c478bd9Sstevel@tonic-gate uiop->uio_resid--;
2987c478bd9Sstevel@tonic-gate uiop->uio_loffset++;
2997c478bd9Sstevel@tonic-gate return (0); /* success */
3007c478bd9Sstevel@tonic-gate }
3017c478bd9Sstevel@tonic-gate
3027c478bd9Sstevel@tonic-gate /*
3037c478bd9Sstevel@tonic-gate * return a character value from the address space
3047c478bd9Sstevel@tonic-gate * delineated by a uio and update fields within the
3057c478bd9Sstevel@tonic-gate * uio for next character. Return the character for success,
3067c478bd9Sstevel@tonic-gate * -1 for error.
3077c478bd9Sstevel@tonic-gate */
3087c478bd9Sstevel@tonic-gate int
uwritec(struct uio * uiop)3097c478bd9Sstevel@tonic-gate uwritec(struct uio *uiop)
3107c478bd9Sstevel@tonic-gate {
3117c478bd9Sstevel@tonic-gate struct iovec *iovp;
3127c478bd9Sstevel@tonic-gate unsigned char c;
3137c478bd9Sstevel@tonic-gate
3147c478bd9Sstevel@tonic-gate /*
3157c478bd9Sstevel@tonic-gate * verify we were passed a valid uio structure.
3167c478bd9Sstevel@tonic-gate * (1) non-NULL uiop, (2) positive resid count
3177c478bd9Sstevel@tonic-gate * (3) there is an iovec with positive length
3187c478bd9Sstevel@tonic-gate */
3197c478bd9Sstevel@tonic-gate
3207c478bd9Sstevel@tonic-gate if (!(uiop && uiop->uio_resid > 0))
3217c478bd9Sstevel@tonic-gate return (-1);
3227c478bd9Sstevel@tonic-gate
3237c478bd9Sstevel@tonic-gate while (uiop->uio_iovcnt > 0) {
3247c478bd9Sstevel@tonic-gate iovp = uiop->uio_iov;
3257c478bd9Sstevel@tonic-gate if (iovp->iov_len <= 0) {
3267c478bd9Sstevel@tonic-gate uiop->uio_iovcnt--;
3277c478bd9Sstevel@tonic-gate uiop->uio_iov++;
3287c478bd9Sstevel@tonic-gate } else
3297c478bd9Sstevel@tonic-gate break;
3307c478bd9Sstevel@tonic-gate }
3317c478bd9Sstevel@tonic-gate
3327c478bd9Sstevel@tonic-gate if (uiop->uio_iovcnt <= 0)
3337c478bd9Sstevel@tonic-gate return (-1);
3347c478bd9Sstevel@tonic-gate
3357c478bd9Sstevel@tonic-gate /*
3367c478bd9Sstevel@tonic-gate * Get the character from the uio address space.
3377c478bd9Sstevel@tonic-gate */
3387c478bd9Sstevel@tonic-gate switch (uiop->uio_segflg) {
3397c478bd9Sstevel@tonic-gate
3407c478bd9Sstevel@tonic-gate case UIO_USERISPACE:
3417c478bd9Sstevel@tonic-gate case UIO_USERSPACE:
3427c478bd9Sstevel@tonic-gate if (copyin(iovp->iov_base, &c, sizeof (unsigned char)))
3437c478bd9Sstevel@tonic-gate return (-1);
3447c478bd9Sstevel@tonic-gate break;
3457c478bd9Sstevel@tonic-gate
3467c478bd9Sstevel@tonic-gate case UIO_SYSSPACE:
3477c478bd9Sstevel@tonic-gate c = *iovp->iov_base;
3487c478bd9Sstevel@tonic-gate break;
3497c478bd9Sstevel@tonic-gate
3507c478bd9Sstevel@tonic-gate default:
3517c478bd9Sstevel@tonic-gate return (-1); /* invalid segflg */
3527c478bd9Sstevel@tonic-gate }
3537c478bd9Sstevel@tonic-gate
3547c478bd9Sstevel@tonic-gate /*
3557c478bd9Sstevel@tonic-gate * Adjust fields of iovec and uio appropriately.
3567c478bd9Sstevel@tonic-gate */
3577c478bd9Sstevel@tonic-gate iovp->iov_base++;
3587c478bd9Sstevel@tonic-gate iovp->iov_len--;
3597c478bd9Sstevel@tonic-gate uiop->uio_resid--;
3607c478bd9Sstevel@tonic-gate uiop->uio_loffset++;
3617c478bd9Sstevel@tonic-gate return ((int)c & 0xFF); /* success */
3627c478bd9Sstevel@tonic-gate }
3637c478bd9Sstevel@tonic-gate
3647c478bd9Sstevel@tonic-gate /*
3657c478bd9Sstevel@tonic-gate * Drop the next n chars out of *uiop.
3667c478bd9Sstevel@tonic-gate */
3677c478bd9Sstevel@tonic-gate void
uioskip(uio_t * uiop,size_t n)3687c478bd9Sstevel@tonic-gate uioskip(uio_t *uiop, size_t n)
3697c478bd9Sstevel@tonic-gate {
3707c478bd9Sstevel@tonic-gate if (n > uiop->uio_resid)
3717c478bd9Sstevel@tonic-gate return;
3727c478bd9Sstevel@tonic-gate while (n != 0) {
3737c478bd9Sstevel@tonic-gate register iovec_t *iovp = uiop->uio_iov;
3747c478bd9Sstevel@tonic-gate register size_t niovb = MIN(iovp->iov_len, n);
3757c478bd9Sstevel@tonic-gate
3767c478bd9Sstevel@tonic-gate if (niovb == 0) {
3777c478bd9Sstevel@tonic-gate uiop->uio_iov++;
3787c478bd9Sstevel@tonic-gate uiop->uio_iovcnt--;
3797c478bd9Sstevel@tonic-gate continue;
3807c478bd9Sstevel@tonic-gate }
3817c478bd9Sstevel@tonic-gate iovp->iov_base += niovb;
3827c478bd9Sstevel@tonic-gate uiop->uio_loffset += niovb;
3837c478bd9Sstevel@tonic-gate iovp->iov_len -= niovb;
3847c478bd9Sstevel@tonic-gate uiop->uio_resid -= niovb;
3857c478bd9Sstevel@tonic-gate n -= niovb;
3867c478bd9Sstevel@tonic-gate }
3877c478bd9Sstevel@tonic-gate }
3887c478bd9Sstevel@tonic-gate
3897c478bd9Sstevel@tonic-gate /*
3907c478bd9Sstevel@tonic-gate * Dup the suio into the duio and diovec of size diov_cnt. If diov
3917c478bd9Sstevel@tonic-gate * is too small to dup suio then an error will be returned, else 0.
3927c478bd9Sstevel@tonic-gate */
3937c478bd9Sstevel@tonic-gate int
uiodup(uio_t * suio,uio_t * duio,iovec_t * diov,int diov_cnt)3947c478bd9Sstevel@tonic-gate uiodup(uio_t *suio, uio_t *duio, iovec_t *diov, int diov_cnt)
3957c478bd9Sstevel@tonic-gate {
3967c478bd9Sstevel@tonic-gate int ix;
3977c478bd9Sstevel@tonic-gate iovec_t *siov = suio->uio_iov;
3987c478bd9Sstevel@tonic-gate
3997c478bd9Sstevel@tonic-gate *duio = *suio;
4007c478bd9Sstevel@tonic-gate for (ix = 0; ix < suio->uio_iovcnt; ix++) {
4017c478bd9Sstevel@tonic-gate diov[ix] = siov[ix];
4027c478bd9Sstevel@tonic-gate if (ix >= diov_cnt)
4037c478bd9Sstevel@tonic-gate return (1);
4047c478bd9Sstevel@tonic-gate }
4057c478bd9Sstevel@tonic-gate duio->uio_iov = diov;
4067c478bd9Sstevel@tonic-gate return (0);
4077c478bd9Sstevel@tonic-gate }
40817169044Sbrutus
40917169044Sbrutus /*
41017169044Sbrutus * Shadow state for checking if a platform has hardware asynchronous
41117169044Sbrutus * copy capability and minimum copy size, e.g. Intel's I/OAT dma engine,
41217169044Sbrutus *
41317169044Sbrutus * Dcopy does a call-back to uioa_dcopy_enable() when a dma device calls
41417169044Sbrutus * into dcopy to register and uioa_dcopy_disable() when the device calls
41517169044Sbrutus * into dcopy to unregister.
41617169044Sbrutus */
41717169044Sbrutus uioasync_t uioasync = {B_FALSE, 1024};
41817169044Sbrutus
41917169044Sbrutus void
uioa_dcopy_enable()42017169044Sbrutus uioa_dcopy_enable()
42117169044Sbrutus {
42217169044Sbrutus uioasync.enabled = B_TRUE;
42317169044Sbrutus }
42417169044Sbrutus
42517169044Sbrutus void
uioa_dcopy_disable()42617169044Sbrutus uioa_dcopy_disable()
42717169044Sbrutus {
42817169044Sbrutus uioasync.enabled = B_FALSE;
42917169044Sbrutus }
43017169044Sbrutus
43117169044Sbrutus /*
43217169044Sbrutus * Schedule an asynchronous move of "n" bytes at byte address "p",
43317169044Sbrutus * "rw" indicates the direction of the move, I/O parameters and
43417169044Sbrutus * async state are provided in "uioa" which is update to reflect
43517169044Sbrutus * the data which is to be moved.
43617169044Sbrutus *
43717169044Sbrutus * Returns 0 on success or a non-zero errno on failure.
43817169044Sbrutus *
43917169044Sbrutus * Note, while the uioasync APIs are general purpose in design
44017169044Sbrutus * the current implementation is Intel I/OAT specific.
44117169044Sbrutus */
44217169044Sbrutus int
uioamove(void * p,size_t n,enum uio_rw rw,uioa_t * uioa)44317169044Sbrutus uioamove(void *p, size_t n, enum uio_rw rw, uioa_t *uioa)
44417169044Sbrutus {
44517169044Sbrutus int soff, doff;
44617169044Sbrutus uint64_t pa;
44717169044Sbrutus int cnt;
44817169044Sbrutus iovec_t *iov;
44917169044Sbrutus dcopy_handle_t channel;
45017169044Sbrutus dcopy_cmd_t cmd;
45117169044Sbrutus int ret = 0;
45217169044Sbrutus int dcopy_flags;
45317169044Sbrutus
45417169044Sbrutus if (!(uioa->uioa_state & UIOA_ENABLED)) {
45517169044Sbrutus /* The uioa_t isn't enabled */
45617169044Sbrutus return (ENXIO);
45717169044Sbrutus }
45817169044Sbrutus
45917169044Sbrutus if (uioa->uio_segflg != UIO_USERSPACE || rw != UIO_READ) {
46017169044Sbrutus /* Only support to user-land from kernel */
46117169044Sbrutus return (ENOTSUP);
46217169044Sbrutus }
46317169044Sbrutus
46417169044Sbrutus
46517169044Sbrutus channel = uioa->uioa_hwst[UIO_DCOPY_CHANNEL];
46617169044Sbrutus cmd = uioa->uioa_hwst[UIO_DCOPY_CMD];
46717169044Sbrutus dcopy_flags = DCOPY_NOSLEEP;
46817169044Sbrutus
46917169044Sbrutus /*
47017169044Sbrutus * While source bytes and destination bytes.
47117169044Sbrutus */
47217169044Sbrutus while (n > 0 && uioa->uio_resid > 0) {
47317169044Sbrutus iov = uioa->uio_iov;
47417169044Sbrutus if (iov->iov_len == 0l) {
47517169044Sbrutus uioa->uio_iov++;
47617169044Sbrutus uioa->uio_iovcnt--;
47717169044Sbrutus uioa->uioa_lcur++;
47817169044Sbrutus uioa->uioa_lppp = uioa->uioa_lcur->uioa_ppp;
47917169044Sbrutus continue;
48017169044Sbrutus }
48117169044Sbrutus /*
48217169044Sbrutus * While source bytes schedule an async
48317169044Sbrutus * dma for destination page by page.
48417169044Sbrutus */
48517169044Sbrutus while (n > 0) {
48617169044Sbrutus /* Addr offset in page src/dst */
48717169044Sbrutus soff = (uintptr_t)p & PAGEOFFSET;
48817169044Sbrutus doff = (uintptr_t)iov->iov_base & PAGEOFFSET;
48917169044Sbrutus /* Min copy count src and dst and page sized */
49017169044Sbrutus cnt = MIN(n, iov->iov_len);
49117169044Sbrutus cnt = MIN(cnt, PAGESIZE - soff);
49217169044Sbrutus cnt = MIN(cnt, PAGESIZE - doff);
49317169044Sbrutus /* XXX if next page(s) contiguous could use multipage */
49417169044Sbrutus
49517169044Sbrutus /*
49617169044Sbrutus * if we have an old command, we want to link all
49717169044Sbrutus * other commands to the next command we alloced so
49817169044Sbrutus * we only need to track the last command but can
49917169044Sbrutus * still free them all.
50017169044Sbrutus */
50117169044Sbrutus if (cmd != NULL) {
50217169044Sbrutus dcopy_flags |= DCOPY_ALLOC_LINK;
50317169044Sbrutus }
50417169044Sbrutus ret = dcopy_cmd_alloc(channel, dcopy_flags, &cmd);
50517169044Sbrutus if (ret != DCOPY_SUCCESS) {
50617169044Sbrutus /* Error of some sort */
50717169044Sbrutus return (EIO);
50817169044Sbrutus }
50917169044Sbrutus uioa->uioa_hwst[UIO_DCOPY_CMD] = cmd;
51017169044Sbrutus
51117169044Sbrutus ASSERT(cmd->dp_version == DCOPY_CMD_V0);
51217169044Sbrutus if (uioa_maxpoll >= 0) {
51317169044Sbrutus /* Blocking (>0 may be) used in uioafini() */
51417169044Sbrutus cmd->dp_flags = DCOPY_CMD_INTR;
51517169044Sbrutus } else {
51617169044Sbrutus /* Non blocking uioafini() so no intr */
51717169044Sbrutus cmd->dp_flags = DCOPY_CMD_NOFLAGS;
51817169044Sbrutus }
51917169044Sbrutus cmd->dp_cmd = DCOPY_CMD_COPY;
52017169044Sbrutus pa = ptob((uint64_t)hat_getpfnum(kas.a_hat, p));
52117169044Sbrutus cmd->dp.copy.cc_source = pa + soff;
52217169044Sbrutus if (uioa->uioa_lcur->uioa_pfncnt == 0) {
52317169044Sbrutus /* Have a (page_t **) */
52417169044Sbrutus pa = ptob((uint64_t)(
52517169044Sbrutus *(page_t **)uioa->uioa_lppp)->p_pagenum);
52617169044Sbrutus } else {
52717169044Sbrutus /* Have a (pfn_t *) */
52817169044Sbrutus pa = ptob((uint64_t)(
52917169044Sbrutus *(pfn_t *)uioa->uioa_lppp));
53017169044Sbrutus }
53117169044Sbrutus cmd->dp.copy.cc_dest = pa + doff;
53217169044Sbrutus cmd->dp.copy.cc_size = cnt;
53317169044Sbrutus ret = dcopy_cmd_post(cmd);
53417169044Sbrutus if (ret != DCOPY_SUCCESS) {
53517169044Sbrutus /* Error of some sort */
53617169044Sbrutus return (EIO);
53717169044Sbrutus }
53817169044Sbrutus ret = 0;
53917169044Sbrutus
54017169044Sbrutus /* If UIOA_POLL not set, set it */
54117169044Sbrutus if (!(uioa->uioa_state & UIOA_POLL))
54217169044Sbrutus uioa->uioa_state |= UIOA_POLL;
54317169044Sbrutus
54417169044Sbrutus /* Update iov, uio, and local pointers/counters */
54517169044Sbrutus iov->iov_base += cnt;
54617169044Sbrutus iov->iov_len -= cnt;
54717169044Sbrutus uioa->uio_resid -= cnt;
54896e0e3daSYu Xiangning uioa->uioa_mbytes += cnt;
54917169044Sbrutus uioa->uio_loffset += cnt;
55017169044Sbrutus p = (caddr_t)p + cnt;
55117169044Sbrutus n -= cnt;
55217169044Sbrutus
55317169044Sbrutus /* End of iovec? */
55417169044Sbrutus if (iov->iov_len == 0) {
55517169044Sbrutus /* Yup, next iovec */
55617169044Sbrutus break;
55717169044Sbrutus }
55817169044Sbrutus
55917169044Sbrutus /* Next dst addr page? */
56017169044Sbrutus if (doff + cnt == PAGESIZE) {
56117169044Sbrutus /* Yup, next page_t */
56217169044Sbrutus uioa->uioa_lppp++;
56317169044Sbrutus }
56417169044Sbrutus }
56517169044Sbrutus }
56617169044Sbrutus
56717169044Sbrutus return (ret);
56817169044Sbrutus }
56917169044Sbrutus
57017169044Sbrutus /*
57117169044Sbrutus * Initialize a uioa_t for a given uio_t for the current user context,
57217169044Sbrutus * copy the common uio_t to the uioa_t, walk the shared iovec_t and
57317169044Sbrutus * lock down the user-land page(s) containing iovec_t data, then mapin
57417169044Sbrutus * user-land pages using segkpm.
57517169044Sbrutus */
57617169044Sbrutus int
uioainit(uio_t * uiop,uioa_t * uioap)57717169044Sbrutus uioainit(uio_t *uiop, uioa_t *uioap)
57817169044Sbrutus {
57917169044Sbrutus caddr_t addr;
58017169044Sbrutus page_t **pages;
58117169044Sbrutus int off;
58217169044Sbrutus int len;
58317169044Sbrutus proc_t *procp = ttoproc(curthread);
58417169044Sbrutus struct as *as = procp->p_as;
58517169044Sbrutus iovec_t *iov = uiop->uio_iov;
58617169044Sbrutus int32_t iovcnt = uiop->uio_iovcnt;
58717169044Sbrutus uioa_page_t *locked = uioap->uioa_locked;
58817169044Sbrutus dcopy_handle_t channel;
58917169044Sbrutus int error;
59017169044Sbrutus
59117169044Sbrutus if (! (uioap->uioa_state & UIOA_ALLOC)) {
59217169044Sbrutus /* Can only init() a freshly allocated uioa_t */
59317169044Sbrutus return (EINVAL);
59417169044Sbrutus }
59517169044Sbrutus
59617169044Sbrutus error = dcopy_alloc(DCOPY_NOSLEEP, &channel);
59717169044Sbrutus if (error == DCOPY_NORESOURCES) {
59817169044Sbrutus /* Turn off uioa */
59917169044Sbrutus uioasync.enabled = B_FALSE;
60017169044Sbrutus return (ENODEV);
60117169044Sbrutus }
60217169044Sbrutus if (error != DCOPY_SUCCESS) {
60317169044Sbrutus /* Alloc failed */
60417169044Sbrutus return (EIO);
60517169044Sbrutus }
60617169044Sbrutus
60717169044Sbrutus uioap->uioa_hwst[UIO_DCOPY_CHANNEL] = channel;
60817169044Sbrutus uioap->uioa_hwst[UIO_DCOPY_CMD] = NULL;
60917169044Sbrutus
61017169044Sbrutus /* Indicate uioa_t (will be) initialized */
61117169044Sbrutus uioap->uioa_state = UIOA_INIT;
61217169044Sbrutus
61396e0e3daSYu Xiangning uioap->uioa_mbytes = 0;
61496e0e3daSYu Xiangning
61517169044Sbrutus /* uio_t/uioa_t uio_t common struct copy */
61617169044Sbrutus *((uio_t *)uioap) = *uiop;
61717169044Sbrutus
61817169044Sbrutus /* initialize *uiop->uio_iov */
61917169044Sbrutus if (iovcnt > UIOA_IOV_MAX) {
62017169044Sbrutus /* Too big? */
62117169044Sbrutus return (E2BIG);
62217169044Sbrutus }
62317169044Sbrutus uioap->uio_iov = iov;
62417169044Sbrutus uioap->uio_iovcnt = iovcnt;
62517169044Sbrutus
62617169044Sbrutus /* Mark the uioap as such */
62717169044Sbrutus uioap->uio_extflg |= UIO_ASYNC;
62817169044Sbrutus
62917169044Sbrutus /*
63017169044Sbrutus * For each iovec_t, lock-down the page(s) backing the iovec_t
63117169044Sbrutus * and save the page_t list for phys addr use in uioamove().
63217169044Sbrutus */
63317169044Sbrutus iov = uiop->uio_iov;
63417169044Sbrutus iovcnt = uiop->uio_iovcnt;
63517169044Sbrutus while (iovcnt > 0) {
63617169044Sbrutus addr = iov->iov_base;
63717169044Sbrutus off = (uintptr_t)addr & PAGEOFFSET;
63817169044Sbrutus addr = (caddr_t)((uintptr_t)addr & (uintptr_t)PAGEMASK);
63917169044Sbrutus len = iov->iov_len + off;
64017169044Sbrutus
64117169044Sbrutus /* Lock down page(s) for the iov span */
64217169044Sbrutus if ((error = as_pagelock(as, &pages,
64317169044Sbrutus iov->iov_base, iov->iov_len, S_WRITE)) != 0) {
64417169044Sbrutus /* Error */
64517169044Sbrutus goto cleanup;
64617169044Sbrutus }
64717169044Sbrutus
64817169044Sbrutus if (pages == NULL) {
64917169044Sbrutus /*
65017169044Sbrutus * Need page_t list, really only need
65117169044Sbrutus * a pfn list so build one.
65217169044Sbrutus */
65317169044Sbrutus pfn_t *pfnp;
65417169044Sbrutus int pcnt = len >> PAGESHIFT;
65517169044Sbrutus
65617169044Sbrutus if (off)
65717169044Sbrutus pcnt++;
65817169044Sbrutus if ((pfnp = kmem_alloc(pcnt * sizeof (pfnp),
65917169044Sbrutus KM_NOSLEEP)) == NULL) {
66017169044Sbrutus error = ENOMEM;
66117169044Sbrutus goto cleanup;
66217169044Sbrutus }
66317169044Sbrutus locked->uioa_ppp = (void **)pfnp;
66417169044Sbrutus locked->uioa_pfncnt = pcnt;
665*dc32d872SJosef 'Jeff' Sipek AS_LOCK_ENTER(as, RW_READER);
66617169044Sbrutus while (pcnt-- > 0) {
66717169044Sbrutus *pfnp++ = hat_getpfnum(as->a_hat, addr);
66817169044Sbrutus addr += PAGESIZE;
66917169044Sbrutus }
670*dc32d872SJosef 'Jeff' Sipek AS_LOCK_EXIT(as);
67117169044Sbrutus } else {
67217169044Sbrutus /* Have a page_t list, save it */
67317169044Sbrutus locked->uioa_ppp = (void **)pages;
67417169044Sbrutus locked->uioa_pfncnt = 0;
67517169044Sbrutus }
67617169044Sbrutus /* Save for as_pageunlock() in uioafini() */
67717169044Sbrutus locked->uioa_base = iov->iov_base;
67817169044Sbrutus locked->uioa_len = iov->iov_len;
67917169044Sbrutus locked++;
68017169044Sbrutus
68117169044Sbrutus /* Next iovec_t */
68217169044Sbrutus iov++;
68317169044Sbrutus iovcnt--;
68417169044Sbrutus }
68517169044Sbrutus /* Initialize curret pointer into uioa_locked[] and it's uioa_ppp */
68617169044Sbrutus uioap->uioa_lcur = uioap->uioa_locked;
68717169044Sbrutus uioap->uioa_lppp = uioap->uioa_lcur->uioa_ppp;
68817169044Sbrutus return (0);
68917169044Sbrutus
69017169044Sbrutus cleanup:
69117169044Sbrutus /* Unlock any previously locked page_t(s) */
69217169044Sbrutus while (locked > uioap->uioa_locked) {
69317169044Sbrutus locked--;
69417169044Sbrutus as_pageunlock(as, (page_t **)locked->uioa_ppp,
69517169044Sbrutus locked->uioa_base, locked->uioa_len, S_WRITE);
69617169044Sbrutus }
69717169044Sbrutus
69817169044Sbrutus /* Last indicate uioa_t still in alloc state */
69917169044Sbrutus uioap->uioa_state = UIOA_ALLOC;
70096e0e3daSYu Xiangning uioap->uioa_mbytes = 0;
70117169044Sbrutus
70217169044Sbrutus return (error);
70317169044Sbrutus }
70417169044Sbrutus
70517169044Sbrutus /*
70617169044Sbrutus * Finish processing of a uioa_t by cleanup any pending "uioap" actions.
70717169044Sbrutus */
70817169044Sbrutus int
uioafini(uio_t * uiop,uioa_t * uioap)70917169044Sbrutus uioafini(uio_t *uiop, uioa_t *uioap)
71017169044Sbrutus {
71117169044Sbrutus int32_t iovcnt = uiop->uio_iovcnt;
71217169044Sbrutus uioa_page_t *locked = uioap->uioa_locked;
71317169044Sbrutus struct as *as = ttoproc(curthread)->p_as;
71417169044Sbrutus dcopy_handle_t channel;
71517169044Sbrutus dcopy_cmd_t cmd;
71617169044Sbrutus int ret = 0;
71717169044Sbrutus
71817169044Sbrutus ASSERT(uioap->uio_extflg & UIO_ASYNC);
71917169044Sbrutus
72017169044Sbrutus if (!(uioap->uioa_state & (UIOA_ENABLED|UIOA_FINI))) {
72117169044Sbrutus /* Must be an active uioa_t */
72217169044Sbrutus return (EINVAL);
72317169044Sbrutus }
72417169044Sbrutus
72517169044Sbrutus channel = uioap->uioa_hwst[UIO_DCOPY_CHANNEL];
72617169044Sbrutus cmd = uioap->uioa_hwst[UIO_DCOPY_CMD];
72717169044Sbrutus
72817169044Sbrutus /* XXX - why do we get cmd == NULL sometimes? */
72917169044Sbrutus if (cmd != NULL) {
73017169044Sbrutus if (uioap->uioa_state & UIOA_POLL) {
73117169044Sbrutus /* Wait for last dcopy() to finish */
73217169044Sbrutus int64_t poll = 1;
73317169044Sbrutus int poll_flag = DCOPY_POLL_NOFLAGS;
73417169044Sbrutus
73517169044Sbrutus do {
73617169044Sbrutus if (uioa_maxpoll == 0 ||
73717169044Sbrutus (uioa_maxpoll > 0 &&
73817169044Sbrutus poll >= uioa_maxpoll)) {
73917169044Sbrutus /* Always block or after maxpoll */
74017169044Sbrutus poll_flag = DCOPY_POLL_BLOCK;
74117169044Sbrutus } else {
74217169044Sbrutus /* No block, poll */
74317169044Sbrutus poll++;
74417169044Sbrutus }
74517169044Sbrutus ret = dcopy_cmd_poll(cmd, poll_flag);
74617169044Sbrutus } while (ret == DCOPY_PENDING);
74717169044Sbrutus
74817169044Sbrutus if (ret == DCOPY_COMPLETED) {
74917169044Sbrutus /* Poll/block succeeded */
75017169044Sbrutus ret = 0;
75117169044Sbrutus } else {
75217169044Sbrutus /* Poll/block failed */
75317169044Sbrutus ret = EIO;
75417169044Sbrutus }
75517169044Sbrutus }
75617169044Sbrutus dcopy_cmd_free(&cmd);
75717169044Sbrutus }
75817169044Sbrutus
75917169044Sbrutus dcopy_free(&channel);
76017169044Sbrutus
76117169044Sbrutus /* Unlock all page(s) iovec_t by iovec_t */
76217169044Sbrutus while (iovcnt-- > 0) {
76317169044Sbrutus page_t **pages;
76417169044Sbrutus
76517169044Sbrutus if (locked->uioa_pfncnt == 0) {
76617169044Sbrutus /* A as_pagelock() returned (page_t **) */
76717169044Sbrutus pages = (page_t **)locked->uioa_ppp;
76817169044Sbrutus } else {
76917169044Sbrutus /* Our pfn_t array */
77017169044Sbrutus pages = NULL;
77117169044Sbrutus kmem_free(locked->uioa_ppp, locked->uioa_pfncnt *
77217169044Sbrutus sizeof (pfn_t *));
77317169044Sbrutus }
77417169044Sbrutus as_pageunlock(as, pages, locked->uioa_base, locked->uioa_len,
77517169044Sbrutus S_WRITE);
77617169044Sbrutus
77717169044Sbrutus locked++;
77817169044Sbrutus }
77917169044Sbrutus /* uioa_t->uio_t common struct copy */
78017169044Sbrutus *uiop = *((uio_t *)uioap);
78117169044Sbrutus
78217169044Sbrutus /*
78317169044Sbrutus * Last, reset uioa state to alloc.
78417169044Sbrutus *
78517169044Sbrutus * Note, we only initialize the state here, all other members
78617169044Sbrutus * will be initialized in a subsequent uioainit().
78717169044Sbrutus */
78817169044Sbrutus uioap->uioa_state = UIOA_ALLOC;
78996e0e3daSYu Xiangning uioap->uioa_mbytes = 0;
79017169044Sbrutus
79117169044Sbrutus uioap->uioa_hwst[UIO_DCOPY_CMD] = NULL;
79217169044Sbrutus uioap->uioa_hwst[UIO_DCOPY_CHANNEL] = NULL;
79317169044Sbrutus
79417169044Sbrutus return (ret);
79517169044Sbrutus }
796