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 52caf0dcdSrshoaib * Common Development and Distribution License (the "License"). 62caf0dcdSrshoaib * 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 */ 212caf0dcdSrshoaib 227c478bd9Sstevel@tonic-gate /* 23b3528faeSVasumathi Sundaram - Sun Microsystems * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate #include <sys/types.h> 287c478bd9Sstevel@tonic-gate #include <sys/t_lock.h> 297c478bd9Sstevel@tonic-gate #include <sys/param.h> 307c478bd9Sstevel@tonic-gate #include <sys/systm.h> 317c478bd9Sstevel@tonic-gate #include <sys/buf.h> 327c478bd9Sstevel@tonic-gate #include <sys/conf.h> 337c478bd9Sstevel@tonic-gate #include <sys/cred.h> 347c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 357c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 367c478bd9Sstevel@tonic-gate #include <sys/vfs.h> 377c478bd9Sstevel@tonic-gate #include <sys/vnode.h> 387c478bd9Sstevel@tonic-gate #include <sys/debug.h> 397c478bd9Sstevel@tonic-gate #include <sys/errno.h> 407c478bd9Sstevel@tonic-gate #include <sys/time.h> 417c478bd9Sstevel@tonic-gate #include <sys/file.h> 427c478bd9Sstevel@tonic-gate #include <sys/open.h> 437c478bd9Sstevel@tonic-gate #include <sys/user.h> 447c478bd9Sstevel@tonic-gate #include <sys/termios.h> 457c478bd9Sstevel@tonic-gate #include <sys/stream.h> 467c478bd9Sstevel@tonic-gate #include <sys/strsubr.h> 4774024373Spr #include <sys/sunddi.h> 487c478bd9Sstevel@tonic-gate #include <sys/esunddi.h> 497c478bd9Sstevel@tonic-gate #include <sys/flock.h> 507c478bd9Sstevel@tonic-gate #include <sys/modctl.h> 517c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 527c478bd9Sstevel@tonic-gate #include <sys/vmsystm.h> 537c478bd9Sstevel@tonic-gate 547c478bd9Sstevel@tonic-gate #include <sys/socket.h> 557c478bd9Sstevel@tonic-gate #include <sys/socketvar.h> 560f1702c5SYu Xiangning #include <fs/sockfs/sockcommon.h> 570f1702c5SYu Xiangning #include <fs/sockfs/socktpi.h> 5845916cd2Sjpk 597c478bd9Sstevel@tonic-gate #include <netinet/in.h> 607c478bd9Sstevel@tonic-gate #include <sys/sendfile.h> 617c478bd9Sstevel@tonic-gate #include <sys/un.h> 627c478bd9Sstevel@tonic-gate #include <sys/tihdr.h> 637c478bd9Sstevel@tonic-gate #include <sys/atomic.h> 647c478bd9Sstevel@tonic-gate 657c478bd9Sstevel@tonic-gate #include <inet/common.h> 667c478bd9Sstevel@tonic-gate #include <inet/ip.h> 677c478bd9Sstevel@tonic-gate #include <inet/ip6.h> 687c478bd9Sstevel@tonic-gate #include <inet/tcp.h> 697c478bd9Sstevel@tonic-gate 707c478bd9Sstevel@tonic-gate extern int sosendfile64(file_t *, file_t *, const struct ksendfilevec64 *, 717c478bd9Sstevel@tonic-gate ssize32_t *); 722c9e429eSbrutus extern int nl7c_sendfilev(struct sonode *, u_offset_t *, struct sendfilevec *, 732c9e429eSbrutus int, ssize_t *); 743b3d24f3SJayakara Kini extern int snf_segmap(file_t *, vnode_t *, u_offset_t, u_offset_t, ssize_t *, 753b3d24f3SJayakara Kini boolean_t); 760f1702c5SYu Xiangning extern sotpi_info_t *sotpi_sototpi(struct sonode *); 7774024373Spr 787c478bd9Sstevel@tonic-gate #define SEND_MAX_CHUNK 16 797c478bd9Sstevel@tonic-gate 807c478bd9Sstevel@tonic-gate #if defined(_SYSCALL32_IMPL) || defined(_ILP32) 817c478bd9Sstevel@tonic-gate /* 827c478bd9Sstevel@tonic-gate * 64 bit offsets for 32 bit applications only running either on 837c478bd9Sstevel@tonic-gate * 64 bit kernel or 32 bit kernel. For 32 bit apps, we can't transfer 847c478bd9Sstevel@tonic-gate * more than 2GB of data. 857c478bd9Sstevel@tonic-gate */ 867c478bd9Sstevel@tonic-gate int 877c478bd9Sstevel@tonic-gate sendvec_chunk64(file_t *fp, u_offset_t *fileoff, struct ksendfilevec64 *sfv, 887c478bd9Sstevel@tonic-gate int copy_cnt, ssize32_t *count) 897c478bd9Sstevel@tonic-gate { 907c478bd9Sstevel@tonic-gate struct vnode *vp; 917c478bd9Sstevel@tonic-gate ushort_t fflag; 927c478bd9Sstevel@tonic-gate int ioflag; 937c478bd9Sstevel@tonic-gate size32_t cnt; 947c478bd9Sstevel@tonic-gate ssize32_t sfv_len; 957c478bd9Sstevel@tonic-gate ssize32_t tmpcount; 967c478bd9Sstevel@tonic-gate u_offset_t sfv_off; 977c478bd9Sstevel@tonic-gate struct uio auio; 987c478bd9Sstevel@tonic-gate struct iovec aiov; 997c478bd9Sstevel@tonic-gate int i, error; 1007c478bd9Sstevel@tonic-gate 1017c478bd9Sstevel@tonic-gate fflag = fp->f_flag; 1027c478bd9Sstevel@tonic-gate vp = fp->f_vnode; 1037c478bd9Sstevel@tonic-gate for (i = 0; i < copy_cnt; i++) { 1047c478bd9Sstevel@tonic-gate 1057c478bd9Sstevel@tonic-gate if (ISSIG(curthread, JUSTLOOKING)) 1067c478bd9Sstevel@tonic-gate return (EINTR); 1077c478bd9Sstevel@tonic-gate 1087c478bd9Sstevel@tonic-gate /* 1097c478bd9Sstevel@tonic-gate * Do similar checks as "write" as we are writing 1107c478bd9Sstevel@tonic-gate * sfv_len bytes into "vp". 1117c478bd9Sstevel@tonic-gate */ 1127c478bd9Sstevel@tonic-gate sfv_len = (ssize32_t)sfv->sfv_len; 1137c478bd9Sstevel@tonic-gate 114e116a42fSPrakash Jalan if (sfv_len == 0) { 115e116a42fSPrakash Jalan sfv++; 1167c478bd9Sstevel@tonic-gate continue; 117e116a42fSPrakash Jalan } 1187c478bd9Sstevel@tonic-gate 1197c478bd9Sstevel@tonic-gate if (sfv_len < 0) 1207c478bd9Sstevel@tonic-gate return (EINVAL); 1217c478bd9Sstevel@tonic-gate 1227c478bd9Sstevel@tonic-gate if (vp->v_type == VREG) { 1237c478bd9Sstevel@tonic-gate if (*fileoff >= curproc->p_fsz_ctl) { 1247c478bd9Sstevel@tonic-gate mutex_enter(&curproc->p_lock); 1257c478bd9Sstevel@tonic-gate (void) rctl_action( 1267c478bd9Sstevel@tonic-gate rctlproc_legacy[RLIMIT_FSIZE], 1277c478bd9Sstevel@tonic-gate curproc->p_rctls, curproc, RCA_SAFE); 1287c478bd9Sstevel@tonic-gate mutex_exit(&curproc->p_lock); 1297c478bd9Sstevel@tonic-gate return (EFBIG); 1307c478bd9Sstevel@tonic-gate } 1317c478bd9Sstevel@tonic-gate 1327c478bd9Sstevel@tonic-gate if (*fileoff >= OFFSET_MAX(fp)) 1337c478bd9Sstevel@tonic-gate return (EFBIG); 1347c478bd9Sstevel@tonic-gate 1357c478bd9Sstevel@tonic-gate if (*fileoff + sfv_len > OFFSET_MAX(fp)) 1367c478bd9Sstevel@tonic-gate return (EINVAL); 1377c478bd9Sstevel@tonic-gate } 1387c478bd9Sstevel@tonic-gate 1397c478bd9Sstevel@tonic-gate tmpcount = *count + sfv_len; 1407c478bd9Sstevel@tonic-gate if (tmpcount < 0) 1417c478bd9Sstevel@tonic-gate return (EINVAL); 1427c478bd9Sstevel@tonic-gate 1437c478bd9Sstevel@tonic-gate sfv_off = sfv->sfv_off; 1447c478bd9Sstevel@tonic-gate 1457c478bd9Sstevel@tonic-gate auio.uio_extflg = UIO_COPY_DEFAULT; 1467c478bd9Sstevel@tonic-gate if (sfv->sfv_fd == SFV_FD_SELF) { 1477c478bd9Sstevel@tonic-gate aiov.iov_len = sfv_len; 1487c478bd9Sstevel@tonic-gate aiov.iov_base = (caddr_t)(uintptr_t)sfv_off; 1497c478bd9Sstevel@tonic-gate auio.uio_loffset = *fileoff; 1507c478bd9Sstevel@tonic-gate auio.uio_iovcnt = 1; 1517c478bd9Sstevel@tonic-gate auio.uio_resid = sfv_len; 1527c478bd9Sstevel@tonic-gate auio.uio_iov = &aiov; 1537c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_USERSPACE; 1547c478bd9Sstevel@tonic-gate auio.uio_llimit = curproc->p_fsz_ctl; 1557c478bd9Sstevel@tonic-gate auio.uio_fmode = fflag; 1567c478bd9Sstevel@tonic-gate ioflag = auio.uio_fmode & (FAPPEND|FSYNC|FDSYNC|FRSYNC); 1577c478bd9Sstevel@tonic-gate while (sfv_len > 0) { 1587c478bd9Sstevel@tonic-gate error = VOP_WRITE(vp, &auio, ioflag, 1597c478bd9Sstevel@tonic-gate fp->f_cred, NULL); 1607c478bd9Sstevel@tonic-gate cnt = sfv_len - auio.uio_resid; 1617c478bd9Sstevel@tonic-gate sfv_len -= cnt; 1627c478bd9Sstevel@tonic-gate ttolwp(curthread)->lwp_ru.ioch += (ulong_t)cnt; 1637c478bd9Sstevel@tonic-gate if (vp->v_type == VREG) 1647c478bd9Sstevel@tonic-gate *fileoff += cnt; 1657c478bd9Sstevel@tonic-gate *count += cnt; 1667c478bd9Sstevel@tonic-gate if (error != 0) 1677c478bd9Sstevel@tonic-gate return (error); 1687c478bd9Sstevel@tonic-gate } 1697c478bd9Sstevel@tonic-gate } else { 1707c478bd9Sstevel@tonic-gate file_t *ffp; 1717c478bd9Sstevel@tonic-gate vnode_t *readvp; 1727c478bd9Sstevel@tonic-gate size_t size; 1737c478bd9Sstevel@tonic-gate caddr_t ptr; 1747c478bd9Sstevel@tonic-gate 1757c478bd9Sstevel@tonic-gate if ((ffp = getf(sfv->sfv_fd)) == NULL) 1767c478bd9Sstevel@tonic-gate return (EBADF); 1777c478bd9Sstevel@tonic-gate 1787c478bd9Sstevel@tonic-gate if ((ffp->f_flag & FREAD) == 0) { 1797c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 1807c478bd9Sstevel@tonic-gate return (EBADF); 1817c478bd9Sstevel@tonic-gate } 1827c478bd9Sstevel@tonic-gate 1837c478bd9Sstevel@tonic-gate readvp = ffp->f_vnode; 1847c478bd9Sstevel@tonic-gate if (readvp->v_type != VREG) { 1857c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 1867c478bd9Sstevel@tonic-gate return (EINVAL); 1877c478bd9Sstevel@tonic-gate } 1887c478bd9Sstevel@tonic-gate 1897c478bd9Sstevel@tonic-gate /* 1907c478bd9Sstevel@tonic-gate * No point reading and writing to same vp, 1917c478bd9Sstevel@tonic-gate * as long as both are regular files. readvp is not 1927c478bd9Sstevel@tonic-gate * locked; but since we got it from an open file the 1937c478bd9Sstevel@tonic-gate * contents will be valid during the time of access. 1947c478bd9Sstevel@tonic-gate */ 195bfb244baSpr if (vn_compare(vp, readvp)) { 1967c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 1977c478bd9Sstevel@tonic-gate return (EINVAL); 1987c478bd9Sstevel@tonic-gate } 1997c478bd9Sstevel@tonic-gate 200b3528faeSVasumathi Sundaram - Sun Microsystems /* 201b3528faeSVasumathi Sundaram - Sun Microsystems * Optimize the regular file over 202b3528faeSVasumathi Sundaram - Sun Microsystems * the socket case. 203b3528faeSVasumathi Sundaram - Sun Microsystems */ 204b3528faeSVasumathi Sundaram - Sun Microsystems if (vp->v_type == VSOCK) { 205*7baf8047SVasumathi Sundaram - Sun Microsystems error = sosendfile64(fp, ffp, sfv, 206*7baf8047SVasumathi Sundaram - Sun Microsystems (ssize32_t *)&cnt); 207*7baf8047SVasumathi Sundaram - Sun Microsystems *count += cnt; 208b3528faeSVasumathi Sundaram - Sun Microsystems if (error) 209b3528faeSVasumathi Sundaram - Sun Microsystems return (error); 210b3528faeSVasumathi Sundaram - Sun Microsystems sfv++; 211b3528faeSVasumathi Sundaram - Sun Microsystems continue; 212b3528faeSVasumathi Sundaram - Sun Microsystems } 213b3528faeSVasumathi Sundaram - Sun Microsystems 2147c478bd9Sstevel@tonic-gate /* 2157c478bd9Sstevel@tonic-gate * Note: we assume readvp != vp. "vp" is already 2167c478bd9Sstevel@tonic-gate * locked, and "readvp" must not be. 2177c478bd9Sstevel@tonic-gate */ 218b3528faeSVasumathi Sundaram - Sun Microsystems if (readvp < vp) { 219b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, NULL); 220b3528faeSVasumathi Sundaram - Sun Microsystems (void) VOP_RWLOCK(readvp, V_WRITELOCK_FALSE, 221b3528faeSVasumathi Sundaram - Sun Microsystems NULL); 222b3528faeSVasumathi Sundaram - Sun Microsystems (void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, NULL); 223b3528faeSVasumathi Sundaram - Sun Microsystems } else { 224b3528faeSVasumathi Sundaram - Sun Microsystems (void) VOP_RWLOCK(readvp, V_WRITELOCK_FALSE, 225b3528faeSVasumathi Sundaram - Sun Microsystems NULL); 226b3528faeSVasumathi Sundaram - Sun Microsystems } 2277c478bd9Sstevel@tonic-gate 2287c478bd9Sstevel@tonic-gate /* 2297c478bd9Sstevel@tonic-gate * Same checks as in pread64. 2307c478bd9Sstevel@tonic-gate */ 2317c478bd9Sstevel@tonic-gate if (sfv_off > MAXOFFSET_T) { 232b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(readvp, V_WRITELOCK_FALSE, NULL); 2337c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 2347c478bd9Sstevel@tonic-gate return (EINVAL); 2357c478bd9Sstevel@tonic-gate } 2367c478bd9Sstevel@tonic-gate 2377c478bd9Sstevel@tonic-gate if (sfv_off + sfv_len > MAXOFFSET_T) 2387c478bd9Sstevel@tonic-gate sfv_len = (ssize32_t)(MAXOFFSET_T - sfv_off); 2397c478bd9Sstevel@tonic-gate 2407c478bd9Sstevel@tonic-gate /* Find the native blocksize to transfer data */ 2417c478bd9Sstevel@tonic-gate size = MIN(vp->v_vfsp->vfs_bsize, 2427c478bd9Sstevel@tonic-gate readvp->v_vfsp->vfs_bsize); 2437c478bd9Sstevel@tonic-gate size = sfv_len < size ? sfv_len : size; 244b3528faeSVasumathi Sundaram - Sun Microsystems ptr = kmem_alloc(size, KM_NOSLEEP); 245b3528faeSVasumathi Sundaram - Sun Microsystems if (ptr == NULL) { 246b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(readvp, V_WRITELOCK_FALSE, NULL); 247b3528faeSVasumathi Sundaram - Sun Microsystems releasef(sfv->sfv_fd); 248b3528faeSVasumathi Sundaram - Sun Microsystems return (ENOMEM); 249b3528faeSVasumathi Sundaram - Sun Microsystems } 2507c478bd9Sstevel@tonic-gate 2517c478bd9Sstevel@tonic-gate while (sfv_len > 0) { 2527c478bd9Sstevel@tonic-gate size_t iov_len; 2537c478bd9Sstevel@tonic-gate 2547c478bd9Sstevel@tonic-gate iov_len = MIN(size, sfv_len); 2557c478bd9Sstevel@tonic-gate aiov.iov_base = ptr; 2567c478bd9Sstevel@tonic-gate aiov.iov_len = iov_len; 2577c478bd9Sstevel@tonic-gate auio.uio_loffset = sfv_off; 2587c478bd9Sstevel@tonic-gate auio.uio_iov = &aiov; 2597c478bd9Sstevel@tonic-gate auio.uio_iovcnt = 1; 2607c478bd9Sstevel@tonic-gate auio.uio_resid = iov_len; 2617c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_SYSSPACE; 2627c478bd9Sstevel@tonic-gate auio.uio_llimit = MAXOFFSET_T; 2637c478bd9Sstevel@tonic-gate auio.uio_fmode = ffp->f_flag; 2647c478bd9Sstevel@tonic-gate ioflag = auio.uio_fmode & 2657c478bd9Sstevel@tonic-gate (FAPPEND|FSYNC|FDSYNC|FRSYNC); 2667c478bd9Sstevel@tonic-gate 2677c478bd9Sstevel@tonic-gate /* 2687c478bd9Sstevel@tonic-gate * If read sync is not asked for, 2697c478bd9Sstevel@tonic-gate * filter sync flags 2707c478bd9Sstevel@tonic-gate */ 2717c478bd9Sstevel@tonic-gate if ((ioflag & FRSYNC) == 0) 2727c478bd9Sstevel@tonic-gate ioflag &= ~(FSYNC|FDSYNC); 2737c478bd9Sstevel@tonic-gate error = VOP_READ(readvp, &auio, ioflag, 2747c478bd9Sstevel@tonic-gate fp->f_cred, NULL); 2757c478bd9Sstevel@tonic-gate if (error) { 2767c478bd9Sstevel@tonic-gate kmem_free(ptr, size); 277b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(readvp, V_WRITELOCK_FALSE, 278b3528faeSVasumathi Sundaram - Sun Microsystems NULL); 2797c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 2807c478bd9Sstevel@tonic-gate return (error); 2817c478bd9Sstevel@tonic-gate } 2827c478bd9Sstevel@tonic-gate 2837c478bd9Sstevel@tonic-gate /* 2847c478bd9Sstevel@tonic-gate * Check how must data was really read. 2857c478bd9Sstevel@tonic-gate * Decrement the 'len' and increment the 2867c478bd9Sstevel@tonic-gate * 'off' appropriately. 2877c478bd9Sstevel@tonic-gate */ 2887c478bd9Sstevel@tonic-gate cnt = iov_len - auio.uio_resid; 2897c478bd9Sstevel@tonic-gate if (cnt == 0) { 2907c478bd9Sstevel@tonic-gate /* 2917c478bd9Sstevel@tonic-gate * If we were reading a pipe (currently 2927c478bd9Sstevel@tonic-gate * not implemented), we may now lose 2937c478bd9Sstevel@tonic-gate * data. 2947c478bd9Sstevel@tonic-gate */ 2957c478bd9Sstevel@tonic-gate kmem_free(ptr, size); 296b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(readvp, V_WRITELOCK_FALSE, 297b3528faeSVasumathi Sundaram - Sun Microsystems NULL); 2987c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 2997c478bd9Sstevel@tonic-gate return (EINVAL); 3007c478bd9Sstevel@tonic-gate } 3017c478bd9Sstevel@tonic-gate sfv_len -= cnt; 3027c478bd9Sstevel@tonic-gate sfv_off += cnt; 3037c478bd9Sstevel@tonic-gate 3047c478bd9Sstevel@tonic-gate aiov.iov_base = ptr; 3057c478bd9Sstevel@tonic-gate aiov.iov_len = cnt; 3067c478bd9Sstevel@tonic-gate auio.uio_loffset = *fileoff; 307a490cd42SPrakash Jalan auio.uio_iov = &aiov; 308a490cd42SPrakash Jalan auio.uio_iovcnt = 1; 3097c478bd9Sstevel@tonic-gate auio.uio_resid = cnt; 3107c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_SYSSPACE; 3117c478bd9Sstevel@tonic-gate auio.uio_llimit = curproc->p_fsz_ctl; 3127c478bd9Sstevel@tonic-gate auio.uio_fmode = fflag; 3137c478bd9Sstevel@tonic-gate ioflag = auio.uio_fmode & 3147c478bd9Sstevel@tonic-gate (FAPPEND|FSYNC|FDSYNC|FRSYNC); 3157c478bd9Sstevel@tonic-gate error = VOP_WRITE(vp, &auio, ioflag, 3167c478bd9Sstevel@tonic-gate fp->f_cred, NULL); 3177c478bd9Sstevel@tonic-gate 3187c478bd9Sstevel@tonic-gate /* 3197c478bd9Sstevel@tonic-gate * Check how much data was written. Increment 3207c478bd9Sstevel@tonic-gate * the 'len' and decrement the 'off' if all 3217c478bd9Sstevel@tonic-gate * the data was not written. 3227c478bd9Sstevel@tonic-gate */ 3237c478bd9Sstevel@tonic-gate cnt -= auio.uio_resid; 3247c478bd9Sstevel@tonic-gate sfv_len += auio.uio_resid; 3257c478bd9Sstevel@tonic-gate sfv_off -= auio.uio_resid; 3267c478bd9Sstevel@tonic-gate ttolwp(curthread)->lwp_ru.ioch += (ulong_t)cnt; 3277c478bd9Sstevel@tonic-gate if (vp->v_type == VREG) 3287c478bd9Sstevel@tonic-gate *fileoff += cnt; 3297c478bd9Sstevel@tonic-gate *count += cnt; 3307c478bd9Sstevel@tonic-gate if (error != 0) { 3317c478bd9Sstevel@tonic-gate kmem_free(ptr, size); 332b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(readvp, V_WRITELOCK_FALSE, 333b3528faeSVasumathi Sundaram - Sun Microsystems NULL); 3347c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 3357c478bd9Sstevel@tonic-gate return (error); 3367c478bd9Sstevel@tonic-gate } 3377c478bd9Sstevel@tonic-gate } 338b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(readvp, V_WRITELOCK_FALSE, NULL); 3397c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 3407c478bd9Sstevel@tonic-gate kmem_free(ptr, size); 3417c478bd9Sstevel@tonic-gate } 3427c478bd9Sstevel@tonic-gate sfv++; 3437c478bd9Sstevel@tonic-gate } 3447c478bd9Sstevel@tonic-gate return (0); 3457c478bd9Sstevel@tonic-gate } 3467c478bd9Sstevel@tonic-gate 3477c478bd9Sstevel@tonic-gate ssize32_t 3487c478bd9Sstevel@tonic-gate sendvec64(file_t *fp, const struct ksendfilevec64 *vec, int sfvcnt, 3497c478bd9Sstevel@tonic-gate size32_t *xferred, int fildes) 3507c478bd9Sstevel@tonic-gate { 3517c478bd9Sstevel@tonic-gate u_offset_t fileoff; 3527c478bd9Sstevel@tonic-gate int copy_cnt; 3537c478bd9Sstevel@tonic-gate const struct ksendfilevec64 *copy_vec; 3547c478bd9Sstevel@tonic-gate struct ksendfilevec64 sfv[SEND_MAX_CHUNK]; 3557c478bd9Sstevel@tonic-gate struct vnode *vp; 3567c478bd9Sstevel@tonic-gate int error; 3577c478bd9Sstevel@tonic-gate ssize32_t count = 0; 3587c478bd9Sstevel@tonic-gate 3597c478bd9Sstevel@tonic-gate vp = fp->f_vnode; 360b3528faeSVasumathi Sundaram - Sun Microsystems (void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, NULL); 3617c478bd9Sstevel@tonic-gate 3627c478bd9Sstevel@tonic-gate copy_vec = vec; 3637c478bd9Sstevel@tonic-gate fileoff = fp->f_offset; 3647c478bd9Sstevel@tonic-gate 3657c478bd9Sstevel@tonic-gate do { 3667c478bd9Sstevel@tonic-gate copy_cnt = MIN(sfvcnt, SEND_MAX_CHUNK); 3677c478bd9Sstevel@tonic-gate if (copyin(copy_vec, sfv, copy_cnt * 3687c478bd9Sstevel@tonic-gate sizeof (struct ksendfilevec64))) { 3697c478bd9Sstevel@tonic-gate error = EFAULT; 3707c478bd9Sstevel@tonic-gate break; 3717c478bd9Sstevel@tonic-gate } 3727c478bd9Sstevel@tonic-gate 3737c478bd9Sstevel@tonic-gate error = sendvec_chunk64(fp, &fileoff, sfv, copy_cnt, &count); 3747c478bd9Sstevel@tonic-gate if (error != 0) 3757c478bd9Sstevel@tonic-gate break; 3767c478bd9Sstevel@tonic-gate 3777c478bd9Sstevel@tonic-gate copy_vec += copy_cnt; 3787c478bd9Sstevel@tonic-gate sfvcnt -= copy_cnt; 3797c478bd9Sstevel@tonic-gate } while (sfvcnt > 0); 3807c478bd9Sstevel@tonic-gate 3817c478bd9Sstevel@tonic-gate if (vp->v_type == VREG) 3827c478bd9Sstevel@tonic-gate fp->f_offset += count; 3837c478bd9Sstevel@tonic-gate 384b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, NULL); 3857c478bd9Sstevel@tonic-gate if (copyout(&count, xferred, sizeof (count))) 3867c478bd9Sstevel@tonic-gate error = EFAULT; 3877c478bd9Sstevel@tonic-gate releasef(fildes); 3887c478bd9Sstevel@tonic-gate if (error != 0) 3897c478bd9Sstevel@tonic-gate return (set_errno(error)); 3907c478bd9Sstevel@tonic-gate return (count); 3917c478bd9Sstevel@tonic-gate } 3927c478bd9Sstevel@tonic-gate #endif 3937c478bd9Sstevel@tonic-gate 3947c478bd9Sstevel@tonic-gate int 3957c478bd9Sstevel@tonic-gate sendvec_small_chunk(file_t *fp, u_offset_t *fileoff, struct sendfilevec *sfv, 3967c478bd9Sstevel@tonic-gate int copy_cnt, ssize_t total_size, int maxblk, ssize_t *count) 3977c478bd9Sstevel@tonic-gate { 3987c478bd9Sstevel@tonic-gate struct vnode *vp; 3997c478bd9Sstevel@tonic-gate struct uio auio; 4007c478bd9Sstevel@tonic-gate struct iovec aiov; 4017c478bd9Sstevel@tonic-gate ushort_t fflag; 4027c478bd9Sstevel@tonic-gate int ioflag; 4037c478bd9Sstevel@tonic-gate int i, error; 4047c478bd9Sstevel@tonic-gate size_t cnt; 4057c478bd9Sstevel@tonic-gate ssize_t sfv_len; 4067c478bd9Sstevel@tonic-gate u_offset_t sfv_off; 4077c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 4087c478bd9Sstevel@tonic-gate model_t model = get_udatamodel(); 4097c478bd9Sstevel@tonic-gate u_offset_t maxoff = (model == DATAMODEL_ILP32) ? 410311e3d4cSgeorges MAXOFF32_T : MAXOFFSET_T; 4117c478bd9Sstevel@tonic-gate #else 4127c478bd9Sstevel@tonic-gate const u_offset_t maxoff = MAXOFF32_T; 4137c478bd9Sstevel@tonic-gate #endif 4147c478bd9Sstevel@tonic-gate mblk_t *dmp = NULL; 4157c478bd9Sstevel@tonic-gate int wroff; 4167c478bd9Sstevel@tonic-gate int buf_left = 0; 4177c478bd9Sstevel@tonic-gate size_t iov_len; 4187c478bd9Sstevel@tonic-gate mblk_t *head, *tmp; 4197c478bd9Sstevel@tonic-gate size_t size = total_size; 420c28749e9Skais size_t extra; 421c28749e9Skais int tail_len; 4220f1702c5SYu Xiangning struct nmsghdr msg; 4237c478bd9Sstevel@tonic-gate 4247c478bd9Sstevel@tonic-gate fflag = fp->f_flag; 4257c478bd9Sstevel@tonic-gate vp = fp->f_vnode; 4267c478bd9Sstevel@tonic-gate 4277c478bd9Sstevel@tonic-gate ASSERT(vp->v_type == VSOCK); 4287c478bd9Sstevel@tonic-gate ASSERT(maxblk > 0); 4297c478bd9Sstevel@tonic-gate 430e116a42fSPrakash Jalan /* If nothing to send, return */ 431e116a42fSPrakash Jalan if (total_size == 0) 432e116a42fSPrakash Jalan return (0); 433e116a42fSPrakash Jalan 4340f1702c5SYu Xiangning if (vp->v_stream != NULL) { 4350f1702c5SYu Xiangning wroff = (int)vp->v_stream->sd_wroff; 4360f1702c5SYu Xiangning tail_len = (int)vp->v_stream->sd_tail; 4370f1702c5SYu Xiangning } else { 4380f1702c5SYu Xiangning struct sonode *so; 4390f1702c5SYu Xiangning 4400f1702c5SYu Xiangning so = VTOSO(vp); 4410f1702c5SYu Xiangning wroff = so->so_proto_props.sopp_wroff; 4420f1702c5SYu Xiangning tail_len = so->so_proto_props.sopp_tail; 4430f1702c5SYu Xiangning } 4440f1702c5SYu Xiangning 445c28749e9Skais extra = wroff + tail_len; 446c28749e9Skais 4477c478bd9Sstevel@tonic-gate buf_left = MIN(total_size, maxblk); 448c28749e9Skais head = dmp = allocb(buf_left + extra, BPRI_HI); 4497c478bd9Sstevel@tonic-gate if (head == NULL) 4507c478bd9Sstevel@tonic-gate return (ENOMEM); 4517c478bd9Sstevel@tonic-gate head->b_wptr = head->b_rptr = head->b_rptr + wroff; 4520f1702c5SYu Xiangning bzero(&msg, sizeof (msg)); 4537c478bd9Sstevel@tonic-gate 4547c478bd9Sstevel@tonic-gate auio.uio_extflg = UIO_COPY_DEFAULT; 4557c478bd9Sstevel@tonic-gate for (i = 0; i < copy_cnt; i++) { 456311e3d4cSgeorges if (ISSIG(curthread, JUSTLOOKING)) { 457311e3d4cSgeorges freemsg(head); 4587c478bd9Sstevel@tonic-gate return (EINTR); 459311e3d4cSgeorges } 4607c478bd9Sstevel@tonic-gate 4617c478bd9Sstevel@tonic-gate /* 4627c478bd9Sstevel@tonic-gate * Do similar checks as "write" as we are writing 4637c478bd9Sstevel@tonic-gate * sfv_len bytes into "vp". 4647c478bd9Sstevel@tonic-gate */ 4657c478bd9Sstevel@tonic-gate sfv_len = (ssize_t)sfv->sfv_len; 4667c478bd9Sstevel@tonic-gate 4677c478bd9Sstevel@tonic-gate if (sfv_len == 0) { 4687c478bd9Sstevel@tonic-gate sfv++; 4697c478bd9Sstevel@tonic-gate continue; 4707c478bd9Sstevel@tonic-gate } 4717c478bd9Sstevel@tonic-gate 4727c478bd9Sstevel@tonic-gate /* Check for overflow */ 4737c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 4747c478bd9Sstevel@tonic-gate if (model == DATAMODEL_ILP32) { 475311e3d4cSgeorges if (((ssize32_t)(*count + sfv_len)) < 0) { 476311e3d4cSgeorges freemsg(head); 4777c478bd9Sstevel@tonic-gate return (EINVAL); 478311e3d4cSgeorges } 4797c478bd9Sstevel@tonic-gate } else 4807c478bd9Sstevel@tonic-gate #endif 481311e3d4cSgeorges if ((*count + sfv_len) < 0) { 482311e3d4cSgeorges freemsg(head); 4837c478bd9Sstevel@tonic-gate return (EINVAL); 484311e3d4cSgeorges } 4857c478bd9Sstevel@tonic-gate 4867c478bd9Sstevel@tonic-gate sfv_off = (u_offset_t)(ulong_t)sfv->sfv_off; 4877c478bd9Sstevel@tonic-gate 4887c478bd9Sstevel@tonic-gate if (sfv->sfv_fd == SFV_FD_SELF) { 4897c478bd9Sstevel@tonic-gate while (sfv_len > 0) { 4907c478bd9Sstevel@tonic-gate if (buf_left == 0) { 4917c478bd9Sstevel@tonic-gate tmp = dmp; 4927c478bd9Sstevel@tonic-gate buf_left = MIN(total_size, maxblk); 4937c478bd9Sstevel@tonic-gate iov_len = MIN(buf_left, sfv_len); 494c28749e9Skais dmp = allocb(buf_left + extra, BPRI_HI); 4957c478bd9Sstevel@tonic-gate if (dmp == NULL) { 4967c478bd9Sstevel@tonic-gate freemsg(head); 4977c478bd9Sstevel@tonic-gate return (ENOMEM); 4987c478bd9Sstevel@tonic-gate } 4997c478bd9Sstevel@tonic-gate dmp->b_wptr = dmp->b_rptr = 5007c478bd9Sstevel@tonic-gate dmp->b_rptr + wroff; 5017c478bd9Sstevel@tonic-gate tmp->b_cont = dmp; 5027c478bd9Sstevel@tonic-gate } else { 5037c478bd9Sstevel@tonic-gate iov_len = MIN(buf_left, sfv_len); 5047c478bd9Sstevel@tonic-gate } 5057c478bd9Sstevel@tonic-gate 5067c478bd9Sstevel@tonic-gate aiov.iov_len = iov_len; 5077c478bd9Sstevel@tonic-gate aiov.iov_base = (caddr_t)(uintptr_t)sfv_off; 5087c478bd9Sstevel@tonic-gate auio.uio_loffset = *fileoff; 5097c478bd9Sstevel@tonic-gate auio.uio_iovcnt = 1; 5107c478bd9Sstevel@tonic-gate auio.uio_resid = iov_len; 5117c478bd9Sstevel@tonic-gate auio.uio_iov = &aiov; 5127c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_USERSPACE; 5137c478bd9Sstevel@tonic-gate auio.uio_llimit = curproc->p_fsz_ctl; 5147c478bd9Sstevel@tonic-gate auio.uio_fmode = fflag; 5157c478bd9Sstevel@tonic-gate 5167c478bd9Sstevel@tonic-gate buf_left -= iov_len; 5177c478bd9Sstevel@tonic-gate total_size -= iov_len; 5187c478bd9Sstevel@tonic-gate sfv_len -= iov_len; 5197c478bd9Sstevel@tonic-gate sfv_off += iov_len; 5207c478bd9Sstevel@tonic-gate 5217c478bd9Sstevel@tonic-gate error = uiomove((caddr_t)dmp->b_wptr, 5227c478bd9Sstevel@tonic-gate iov_len, UIO_WRITE, &auio); 5237c478bd9Sstevel@tonic-gate if (error != 0) { 5247c478bd9Sstevel@tonic-gate freemsg(head); 5257c478bd9Sstevel@tonic-gate return (error); 5267c478bd9Sstevel@tonic-gate } 5277c478bd9Sstevel@tonic-gate dmp->b_wptr += iov_len; 5287c478bd9Sstevel@tonic-gate } 5297c478bd9Sstevel@tonic-gate } else { 5307c478bd9Sstevel@tonic-gate file_t *ffp; 5317c478bd9Sstevel@tonic-gate vnode_t *readvp; 5327c478bd9Sstevel@tonic-gate 5337c478bd9Sstevel@tonic-gate if ((ffp = getf(sfv->sfv_fd)) == NULL) { 5347c478bd9Sstevel@tonic-gate freemsg(head); 5357c478bd9Sstevel@tonic-gate return (EBADF); 5367c478bd9Sstevel@tonic-gate } 5377c478bd9Sstevel@tonic-gate 5387c478bd9Sstevel@tonic-gate if ((ffp->f_flag & FREAD) == 0) { 5397c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 5407c478bd9Sstevel@tonic-gate freemsg(head); 5417c478bd9Sstevel@tonic-gate return (EACCES); 5427c478bd9Sstevel@tonic-gate } 5437c478bd9Sstevel@tonic-gate 5447c478bd9Sstevel@tonic-gate readvp = ffp->f_vnode; 5457c478bd9Sstevel@tonic-gate if (readvp->v_type != VREG) { 5467c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 5477c478bd9Sstevel@tonic-gate freemsg(head); 5487c478bd9Sstevel@tonic-gate return (EINVAL); 5497c478bd9Sstevel@tonic-gate } 5507c478bd9Sstevel@tonic-gate 5517c478bd9Sstevel@tonic-gate /* 5527c478bd9Sstevel@tonic-gate * No point reading and writing to same vp, 5537c478bd9Sstevel@tonic-gate * as long as both are regular files. readvp is not 5547c478bd9Sstevel@tonic-gate * locked; but since we got it from an open file the 5557c478bd9Sstevel@tonic-gate * contents will be valid during the time of access. 5567c478bd9Sstevel@tonic-gate */ 5577c478bd9Sstevel@tonic-gate 558bfb244baSpr if (vn_compare(vp, readvp)) { 5597c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 5607c478bd9Sstevel@tonic-gate freemsg(head); 5617c478bd9Sstevel@tonic-gate return (EINVAL); 5627c478bd9Sstevel@tonic-gate } 5637c478bd9Sstevel@tonic-gate 5647c478bd9Sstevel@tonic-gate /* 5657c478bd9Sstevel@tonic-gate * Note: we assume readvp != vp. "vp" is already 5667c478bd9Sstevel@tonic-gate * locked, and "readvp" must not be. 5677c478bd9Sstevel@tonic-gate */ 5687c478bd9Sstevel@tonic-gate 569b3528faeSVasumathi Sundaram - Sun Microsystems if (readvp < vp) { 570b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, NULL); 571b3528faeSVasumathi Sundaram - Sun Microsystems (void) VOP_RWLOCK(readvp, V_WRITELOCK_FALSE, 572b3528faeSVasumathi Sundaram - Sun Microsystems NULL); 573b3528faeSVasumathi Sundaram - Sun Microsystems (void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, NULL); 574b3528faeSVasumathi Sundaram - Sun Microsystems } else { 575b3528faeSVasumathi Sundaram - Sun Microsystems (void) VOP_RWLOCK(readvp, V_WRITELOCK_FALSE, 576b3528faeSVasumathi Sundaram - Sun Microsystems NULL); 577b3528faeSVasumathi Sundaram - Sun Microsystems } 5787c478bd9Sstevel@tonic-gate 5797c478bd9Sstevel@tonic-gate /* Same checks as in pread */ 5807c478bd9Sstevel@tonic-gate if (sfv_off > maxoff) { 581b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(readvp, V_WRITELOCK_FALSE, NULL); 5827c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 5837c478bd9Sstevel@tonic-gate freemsg(head); 5847c478bd9Sstevel@tonic-gate return (EINVAL); 5857c478bd9Sstevel@tonic-gate } 5867c478bd9Sstevel@tonic-gate if (sfv_off + sfv_len > maxoff) { 5870a8433caSrshoaib total_size -= (sfv_off + sfv_len - maxoff); 5887c478bd9Sstevel@tonic-gate sfv_len = (ssize_t)((offset_t)maxoff - 5897c478bd9Sstevel@tonic-gate sfv_off); 5907c478bd9Sstevel@tonic-gate } 5917c478bd9Sstevel@tonic-gate 5927c478bd9Sstevel@tonic-gate while (sfv_len > 0) { 5937c478bd9Sstevel@tonic-gate if (buf_left == 0) { 5947c478bd9Sstevel@tonic-gate tmp = dmp; 5957c478bd9Sstevel@tonic-gate buf_left = MIN(total_size, maxblk); 5967c478bd9Sstevel@tonic-gate iov_len = MIN(buf_left, sfv_len); 597c28749e9Skais dmp = allocb(buf_left + extra, BPRI_HI); 5987c478bd9Sstevel@tonic-gate if (dmp == NULL) { 599b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(readvp, 600b3528faeSVasumathi Sundaram - Sun Microsystems V_WRITELOCK_FALSE, NULL); 6017c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 6027c478bd9Sstevel@tonic-gate freemsg(head); 6037c478bd9Sstevel@tonic-gate return (ENOMEM); 6047c478bd9Sstevel@tonic-gate } 6057c478bd9Sstevel@tonic-gate dmp->b_wptr = dmp->b_rptr = 6067c478bd9Sstevel@tonic-gate dmp->b_rptr + wroff; 6077c478bd9Sstevel@tonic-gate tmp->b_cont = dmp; 6087c478bd9Sstevel@tonic-gate } else { 6097c478bd9Sstevel@tonic-gate iov_len = MIN(buf_left, sfv_len); 6107c478bd9Sstevel@tonic-gate } 6117c478bd9Sstevel@tonic-gate aiov.iov_base = (caddr_t)dmp->b_wptr; 6127c478bd9Sstevel@tonic-gate aiov.iov_len = iov_len; 6137c478bd9Sstevel@tonic-gate auio.uio_loffset = sfv_off; 6147c478bd9Sstevel@tonic-gate auio.uio_iov = &aiov; 6157c478bd9Sstevel@tonic-gate auio.uio_iovcnt = 1; 6167c478bd9Sstevel@tonic-gate auio.uio_resid = iov_len; 6177c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_SYSSPACE; 6187c478bd9Sstevel@tonic-gate auio.uio_llimit = MAXOFFSET_T; 6197c478bd9Sstevel@tonic-gate auio.uio_fmode = ffp->f_flag; 6207c478bd9Sstevel@tonic-gate ioflag = auio.uio_fmode & 6217c478bd9Sstevel@tonic-gate (FAPPEND|FSYNC|FDSYNC|FRSYNC); 6227c478bd9Sstevel@tonic-gate 6237c478bd9Sstevel@tonic-gate /* 6247c478bd9Sstevel@tonic-gate * If read sync is not asked for, 6257c478bd9Sstevel@tonic-gate * filter sync flags 6267c478bd9Sstevel@tonic-gate */ 6277c478bd9Sstevel@tonic-gate if ((ioflag & FRSYNC) == 0) 6287c478bd9Sstevel@tonic-gate ioflag &= ~(FSYNC|FDSYNC); 6297c478bd9Sstevel@tonic-gate error = VOP_READ(readvp, &auio, ioflag, 6307c478bd9Sstevel@tonic-gate fp->f_cred, NULL); 6317c478bd9Sstevel@tonic-gate if (error != 0) { 6327c478bd9Sstevel@tonic-gate /* 6337c478bd9Sstevel@tonic-gate * If we were reading a pipe (currently 6347c478bd9Sstevel@tonic-gate * not implemented), we may now loose 6357c478bd9Sstevel@tonic-gate * data. 6367c478bd9Sstevel@tonic-gate */ 637b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(readvp, V_WRITELOCK_FALSE, 638b3528faeSVasumathi Sundaram - Sun Microsystems NULL); 6397c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 6407c478bd9Sstevel@tonic-gate freemsg(head); 6417c478bd9Sstevel@tonic-gate return (error); 6427c478bd9Sstevel@tonic-gate } 6437c478bd9Sstevel@tonic-gate 6447c478bd9Sstevel@tonic-gate /* 6457c478bd9Sstevel@tonic-gate * Check how much data was really read. 6467c478bd9Sstevel@tonic-gate * Decrement the 'len' and increment the 6477c478bd9Sstevel@tonic-gate * 'off' appropriately. 6487c478bd9Sstevel@tonic-gate */ 6497c478bd9Sstevel@tonic-gate cnt = iov_len - auio.uio_resid; 6507c478bd9Sstevel@tonic-gate if (cnt == 0) { 651b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(readvp, V_WRITELOCK_FALSE, 652b3528faeSVasumathi Sundaram - Sun Microsystems NULL); 6537c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 6547c478bd9Sstevel@tonic-gate freemsg(head); 6557c478bd9Sstevel@tonic-gate return (EINVAL); 6567c478bd9Sstevel@tonic-gate } 6577c478bd9Sstevel@tonic-gate sfv_len -= cnt; 6587c478bd9Sstevel@tonic-gate sfv_off += cnt; 6597c478bd9Sstevel@tonic-gate total_size -= cnt; 6607c478bd9Sstevel@tonic-gate buf_left -= cnt; 6617c478bd9Sstevel@tonic-gate 6627c478bd9Sstevel@tonic-gate dmp->b_wptr += cnt; 6637c478bd9Sstevel@tonic-gate } 664b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(readvp, V_WRITELOCK_FALSE, NULL); 6657c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 6667c478bd9Sstevel@tonic-gate } 6677c478bd9Sstevel@tonic-gate sfv++; 6687c478bd9Sstevel@tonic-gate } 6697c478bd9Sstevel@tonic-gate 6707c478bd9Sstevel@tonic-gate ASSERT(total_size == 0); 6710f1702c5SYu Xiangning error = socket_sendmblk(VTOSO(vp), &msg, fflag, CRED(), &head); 6727c478bd9Sstevel@tonic-gate if (error != 0) { 6730f1702c5SYu Xiangning if (head != NULL) 6740f1702c5SYu Xiangning freemsg(head); 6757c478bd9Sstevel@tonic-gate return (error); 6767c478bd9Sstevel@tonic-gate } 6777c478bd9Sstevel@tonic-gate ttolwp(curthread)->lwp_ru.ioch += (ulong_t)size; 6787c478bd9Sstevel@tonic-gate *count += size; 6797c478bd9Sstevel@tonic-gate 6807c478bd9Sstevel@tonic-gate return (0); 6817c478bd9Sstevel@tonic-gate } 6827c478bd9Sstevel@tonic-gate 6837c478bd9Sstevel@tonic-gate 6847c478bd9Sstevel@tonic-gate int 6857c478bd9Sstevel@tonic-gate sendvec_chunk(file_t *fp, u_offset_t *fileoff, struct sendfilevec *sfv, 6867c478bd9Sstevel@tonic-gate int copy_cnt, ssize_t *count) 6877c478bd9Sstevel@tonic-gate { 6887c478bd9Sstevel@tonic-gate struct vnode *vp; 6897c478bd9Sstevel@tonic-gate struct uio auio; 6907c478bd9Sstevel@tonic-gate struct iovec aiov; 6917c478bd9Sstevel@tonic-gate ushort_t fflag; 6927c478bd9Sstevel@tonic-gate int ioflag; 6937c478bd9Sstevel@tonic-gate int i, error; 6947c478bd9Sstevel@tonic-gate size_t cnt; 6957c478bd9Sstevel@tonic-gate ssize_t sfv_len; 6967c478bd9Sstevel@tonic-gate u_offset_t sfv_off; 6977c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 6987c478bd9Sstevel@tonic-gate model_t model = get_udatamodel(); 6997c478bd9Sstevel@tonic-gate u_offset_t maxoff = (model == DATAMODEL_ILP32) ? 700311e3d4cSgeorges MAXOFF32_T : MAXOFFSET_T; 7017c478bd9Sstevel@tonic-gate #else 7027c478bd9Sstevel@tonic-gate const u_offset_t maxoff = MAXOFF32_T; 7037c478bd9Sstevel@tonic-gate #endif 7041574ae68Sjohansen mblk_t *dmp = NULL; 7051574ae68Sjohansen char *buf = NULL; 706c28749e9Skais size_t extra; 707c28749e9Skais int maxblk, wroff, tail_len; 708c28749e9Skais struct sonode *so; 709c28749e9Skais stdata_t *stp; 7100f1702c5SYu Xiangning struct nmsghdr msg; 7117c478bd9Sstevel@tonic-gate 7127c478bd9Sstevel@tonic-gate fflag = fp->f_flag; 7137c478bd9Sstevel@tonic-gate vp = fp->f_vnode; 7147c478bd9Sstevel@tonic-gate 715c28749e9Skais if (vp->v_type == VSOCK) { 716c28749e9Skais so = VTOSO(vp); 7170f1702c5SYu Xiangning if (vp->v_stream != NULL) { 7180f1702c5SYu Xiangning stp = vp->v_stream; 7190f1702c5SYu Xiangning wroff = (int)stp->sd_wroff; 7200f1702c5SYu Xiangning tail_len = (int)stp->sd_tail; 7210f1702c5SYu Xiangning maxblk = (int)stp->sd_maxblk; 7220f1702c5SYu Xiangning } else { 7230f1702c5SYu Xiangning stp = NULL; 7240f1702c5SYu Xiangning wroff = so->so_proto_props.sopp_wroff; 7250f1702c5SYu Xiangning tail_len = so->so_proto_props.sopp_tail; 7260f1702c5SYu Xiangning maxblk = so->so_proto_props.sopp_maxblk; 7270f1702c5SYu Xiangning } 728c28749e9Skais extra = wroff + tail_len; 729c28749e9Skais } 730c28749e9Skais 7310f1702c5SYu Xiangning bzero(&msg, sizeof (msg)); 7327c478bd9Sstevel@tonic-gate auio.uio_extflg = UIO_COPY_DEFAULT; 7337c478bd9Sstevel@tonic-gate for (i = 0; i < copy_cnt; i++) { 7347c478bd9Sstevel@tonic-gate if (ISSIG(curthread, JUSTLOOKING)) 7357c478bd9Sstevel@tonic-gate return (EINTR); 7367c478bd9Sstevel@tonic-gate 7377c478bd9Sstevel@tonic-gate /* 7387c478bd9Sstevel@tonic-gate * Do similar checks as "write" as we are writing 7397c478bd9Sstevel@tonic-gate * sfv_len bytes into "vp". 7407c478bd9Sstevel@tonic-gate */ 7417c478bd9Sstevel@tonic-gate sfv_len = (ssize_t)sfv->sfv_len; 7427c478bd9Sstevel@tonic-gate 7437c478bd9Sstevel@tonic-gate if (sfv_len == 0) { 7447c478bd9Sstevel@tonic-gate sfv++; 7457c478bd9Sstevel@tonic-gate continue; 7467c478bd9Sstevel@tonic-gate } 7477c478bd9Sstevel@tonic-gate 7487c478bd9Sstevel@tonic-gate if (vp->v_type == VREG) { 7497c478bd9Sstevel@tonic-gate if (*fileoff >= curproc->p_fsz_ctl) { 7507c478bd9Sstevel@tonic-gate mutex_enter(&curproc->p_lock); 7517c478bd9Sstevel@tonic-gate (void) rctl_action( 7527c478bd9Sstevel@tonic-gate rctlproc_legacy[RLIMIT_FSIZE], 7537c478bd9Sstevel@tonic-gate curproc->p_rctls, curproc, RCA_SAFE); 7547c478bd9Sstevel@tonic-gate mutex_exit(&curproc->p_lock); 7557c478bd9Sstevel@tonic-gate 7567c478bd9Sstevel@tonic-gate return (EFBIG); 7577c478bd9Sstevel@tonic-gate } 7587c478bd9Sstevel@tonic-gate 7597c478bd9Sstevel@tonic-gate if (*fileoff >= maxoff) 7607c478bd9Sstevel@tonic-gate return (EFBIG); 7617c478bd9Sstevel@tonic-gate 7627c478bd9Sstevel@tonic-gate if (*fileoff + sfv_len > maxoff) 7637c478bd9Sstevel@tonic-gate return (EINVAL); 7647c478bd9Sstevel@tonic-gate } 7657c478bd9Sstevel@tonic-gate 7667c478bd9Sstevel@tonic-gate /* Check for overflow */ 7677c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 7687c478bd9Sstevel@tonic-gate if (model == DATAMODEL_ILP32) { 7697c478bd9Sstevel@tonic-gate if (((ssize32_t)(*count + sfv_len)) < 0) 7707c478bd9Sstevel@tonic-gate return (EINVAL); 7717c478bd9Sstevel@tonic-gate } else 7727c478bd9Sstevel@tonic-gate #endif 7737c478bd9Sstevel@tonic-gate if ((*count + sfv_len) < 0) 7747c478bd9Sstevel@tonic-gate return (EINVAL); 7757c478bd9Sstevel@tonic-gate 7767c478bd9Sstevel@tonic-gate sfv_off = (u_offset_t)(ulong_t)sfv->sfv_off; 7777c478bd9Sstevel@tonic-gate 7787c478bd9Sstevel@tonic-gate if (sfv->sfv_fd == SFV_FD_SELF) { 7797c478bd9Sstevel@tonic-gate if (vp->v_type == VSOCK) { 780e116a42fSPrakash Jalan while (sfv_len > 0) { 781e116a42fSPrakash Jalan size_t iov_len; 782e116a42fSPrakash Jalan 783e116a42fSPrakash Jalan iov_len = sfv_len; 7840f1702c5SYu Xiangning if (!SOCK_IS_NONSTR(so) && 7850f1702c5SYu Xiangning SOTOTPI(so)->sti_kssl_ctx != NULL) 786e116a42fSPrakash Jalan iov_len = MIN(iov_len, maxblk); 787e116a42fSPrakash Jalan 788e116a42fSPrakash Jalan aiov.iov_len = iov_len; 789e116a42fSPrakash Jalan aiov.iov_base = 790e116a42fSPrakash Jalan (caddr_t)(uintptr_t)sfv_off; 791e116a42fSPrakash Jalan 792e116a42fSPrakash Jalan auio.uio_iov = &aiov; 793e116a42fSPrakash Jalan auio.uio_iovcnt = 1; 794e116a42fSPrakash Jalan auio.uio_loffset = *fileoff; 795e116a42fSPrakash Jalan auio.uio_segflg = UIO_USERSPACE; 796e116a42fSPrakash Jalan auio.uio_fmode = fflag; 797e116a42fSPrakash Jalan auio.uio_llimit = curproc->p_fsz_ctl; 798e116a42fSPrakash Jalan auio.uio_resid = iov_len; 799e116a42fSPrakash Jalan 800e116a42fSPrakash Jalan dmp = allocb(iov_len + extra, BPRI_HI); 801e116a42fSPrakash Jalan if (dmp == NULL) 802e116a42fSPrakash Jalan return (ENOMEM); 803e116a42fSPrakash Jalan dmp->b_wptr = dmp->b_rptr = 804e116a42fSPrakash Jalan dmp->b_rptr + wroff; 805e116a42fSPrakash Jalan error = uiomove((caddr_t)dmp->b_wptr, 806e116a42fSPrakash Jalan iov_len, UIO_WRITE, &auio); 807e116a42fSPrakash Jalan if (error != 0) { 808e116a42fSPrakash Jalan freeb(dmp); 809e116a42fSPrakash Jalan return (error); 810e116a42fSPrakash Jalan } 811e116a42fSPrakash Jalan dmp->b_wptr += iov_len; 8120f1702c5SYu Xiangning error = socket_sendmblk(VTOSO(vp), 8130f1702c5SYu Xiangning &msg, fflag, CRED(), &dmp); 8140f1702c5SYu Xiangning 815e116a42fSPrakash Jalan if (error != 0) { 8160f1702c5SYu Xiangning if (dmp != NULL) 8170f1702c5SYu Xiangning freeb(dmp); 818e116a42fSPrakash Jalan return (error); 819e116a42fSPrakash Jalan } 820e116a42fSPrakash Jalan ttolwp(curthread)->lwp_ru.ioch += 821e116a42fSPrakash Jalan (ulong_t)iov_len; 822e116a42fSPrakash Jalan *count += iov_len; 823e116a42fSPrakash Jalan sfv_len -= iov_len; 824e116a42fSPrakash Jalan sfv_off += iov_len; 8257c478bd9Sstevel@tonic-gate } 8267c478bd9Sstevel@tonic-gate } else { 827e116a42fSPrakash Jalan aiov.iov_len = sfv_len; 828e116a42fSPrakash Jalan aiov.iov_base = (caddr_t)(uintptr_t)sfv_off; 829e116a42fSPrakash Jalan 830e116a42fSPrakash Jalan auio.uio_iov = &aiov; 831e116a42fSPrakash Jalan auio.uio_iovcnt = 1; 832e116a42fSPrakash Jalan auio.uio_loffset = *fileoff; 833e116a42fSPrakash Jalan auio.uio_segflg = UIO_USERSPACE; 834e116a42fSPrakash Jalan auio.uio_fmode = fflag; 835e116a42fSPrakash Jalan auio.uio_llimit = curproc->p_fsz_ctl; 836e116a42fSPrakash Jalan auio.uio_resid = sfv_len; 837e116a42fSPrakash Jalan 8387c478bd9Sstevel@tonic-gate ioflag = auio.uio_fmode & 8397c478bd9Sstevel@tonic-gate (FAPPEND|FSYNC|FDSYNC|FRSYNC); 8407c478bd9Sstevel@tonic-gate while (sfv_len > 0) { 8417c478bd9Sstevel@tonic-gate error = VOP_WRITE(vp, &auio, ioflag, 8427c478bd9Sstevel@tonic-gate fp->f_cred, NULL); 8437c478bd9Sstevel@tonic-gate cnt = sfv_len - auio.uio_resid; 8447c478bd9Sstevel@tonic-gate sfv_len -= cnt; 8457c478bd9Sstevel@tonic-gate ttolwp(curthread)->lwp_ru.ioch += 8467c478bd9Sstevel@tonic-gate (ulong_t)cnt; 8477c478bd9Sstevel@tonic-gate *fileoff += cnt; 8487c478bd9Sstevel@tonic-gate *count += cnt; 8497c478bd9Sstevel@tonic-gate if (error != 0) 8507c478bd9Sstevel@tonic-gate return (error); 8517c478bd9Sstevel@tonic-gate } 8527c478bd9Sstevel@tonic-gate } 8537c478bd9Sstevel@tonic-gate } else { 8547f9ee850Sblu int segmapit = 0; 8557c478bd9Sstevel@tonic-gate file_t *ffp; 8567c478bd9Sstevel@tonic-gate vnode_t *readvp; 857bfb244baSpr struct vnode *realvp; 8587c478bd9Sstevel@tonic-gate size_t size; 8597c478bd9Sstevel@tonic-gate caddr_t ptr; 8607c478bd9Sstevel@tonic-gate 8617c478bd9Sstevel@tonic-gate if ((ffp = getf(sfv->sfv_fd)) == NULL) 8627c478bd9Sstevel@tonic-gate return (EBADF); 8637c478bd9Sstevel@tonic-gate 8647c478bd9Sstevel@tonic-gate if ((ffp->f_flag & FREAD) == 0) { 8657c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 8667c478bd9Sstevel@tonic-gate return (EBADF); 8677c478bd9Sstevel@tonic-gate } 8687c478bd9Sstevel@tonic-gate 8697c478bd9Sstevel@tonic-gate readvp = ffp->f_vnode; 870da6c28aaSamw if (VOP_REALVP(readvp, &realvp, NULL) == 0) 871bfb244baSpr readvp = realvp; 8727c478bd9Sstevel@tonic-gate if (readvp->v_type != VREG) { 8737c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 8747c478bd9Sstevel@tonic-gate return (EINVAL); 8757c478bd9Sstevel@tonic-gate } 8767c478bd9Sstevel@tonic-gate 8777c478bd9Sstevel@tonic-gate /* 8787c478bd9Sstevel@tonic-gate * No point reading and writing to same vp, 8797c478bd9Sstevel@tonic-gate * as long as both are regular files. readvp is not 8807c478bd9Sstevel@tonic-gate * locked; but since we got it from an open file the 8817c478bd9Sstevel@tonic-gate * contents will be valid during the time of access. 8827c478bd9Sstevel@tonic-gate */ 883bfb244baSpr if (vn_compare(vp, readvp)) { 8847c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 8857c478bd9Sstevel@tonic-gate return (EINVAL); 8867c478bd9Sstevel@tonic-gate } 8877c478bd9Sstevel@tonic-gate 8887c478bd9Sstevel@tonic-gate /* 8897c478bd9Sstevel@tonic-gate * Note: we assume readvp != vp. "vp" is already 8907c478bd9Sstevel@tonic-gate * locked, and "readvp" must not be. 8917c478bd9Sstevel@tonic-gate */ 892b3528faeSVasumathi Sundaram - Sun Microsystems if (readvp < vp) { 893b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, NULL); 894b3528faeSVasumathi Sundaram - Sun Microsystems (void) VOP_RWLOCK(readvp, V_WRITELOCK_FALSE, 895b3528faeSVasumathi Sundaram - Sun Microsystems NULL); 896b3528faeSVasumathi Sundaram - Sun Microsystems (void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, NULL); 897b3528faeSVasumathi Sundaram - Sun Microsystems } else { 898b3528faeSVasumathi Sundaram - Sun Microsystems (void) VOP_RWLOCK(readvp, V_WRITELOCK_FALSE, 899b3528faeSVasumathi Sundaram - Sun Microsystems NULL); 900b3528faeSVasumathi Sundaram - Sun Microsystems } 9017c478bd9Sstevel@tonic-gate 9027c478bd9Sstevel@tonic-gate /* Same checks as in pread */ 9037c478bd9Sstevel@tonic-gate if (sfv_off > maxoff) { 904b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(readvp, V_WRITELOCK_FALSE, NULL); 9057c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 9067c478bd9Sstevel@tonic-gate return (EINVAL); 9077c478bd9Sstevel@tonic-gate } 9087c478bd9Sstevel@tonic-gate if (sfv_off + sfv_len > maxoff) { 9097c478bd9Sstevel@tonic-gate sfv_len = (ssize_t)((offset_t)maxoff - 9107c478bd9Sstevel@tonic-gate sfv_off); 9117c478bd9Sstevel@tonic-gate } 9127c478bd9Sstevel@tonic-gate /* Find the native blocksize to transfer data */ 9137c478bd9Sstevel@tonic-gate size = MIN(vp->v_vfsp->vfs_bsize, 9147c478bd9Sstevel@tonic-gate readvp->v_vfsp->vfs_bsize); 9157c478bd9Sstevel@tonic-gate size = sfv_len < size ? sfv_len : size; 9167c478bd9Sstevel@tonic-gate 9171574ae68Sjohansen if (vp->v_type != VSOCK) { 91874024373Spr segmapit = 0; 9191574ae68Sjohansen buf = kmem_alloc(size, KM_NOSLEEP); 9201574ae68Sjohansen if (buf == NULL) { 921b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(readvp, V_WRITELOCK_FALSE, 922b3528faeSVasumathi Sundaram - Sun Microsystems NULL); 9231574ae68Sjohansen releasef(sfv->sfv_fd); 9241574ae68Sjohansen return (ENOMEM); 9251574ae68Sjohansen } 926c28749e9Skais } else { 9270f1702c5SYu Xiangning uint_t copyflag; 9280f1702c5SYu Xiangning 9290f1702c5SYu Xiangning copyflag = stp != NULL ? stp->sd_copyflag : 9300f1702c5SYu Xiangning so->so_proto_props.sopp_zcopyflag; 931c28749e9Skais /* 932c28749e9Skais * For sockets acting as an SSL proxy, we 933c28749e9Skais * need to adjust the size to the maximum 934c28749e9Skais * SSL record size set in the stream head. 935c28749e9Skais */ 9360f1702c5SYu Xiangning if (!SOCK_IS_NONSTR(so) && 9370f1702c5SYu Xiangning _SOTOTPI(so)->sti_kssl_ctx != NULL) 938c28749e9Skais size = MIN(size, maxblk); 93974024373Spr 94074024373Spr if (vn_has_flocks(readvp) || 94174024373Spr readvp->v_flag & VNOMAP || 9420f1702c5SYu Xiangning copyflag & STZCVMUNSAFE) { 94374024373Spr segmapit = 0; 9440f1702c5SYu Xiangning } else if (copyflag & STZCVMSAFE) { 94574024373Spr segmapit = 1; 94674024373Spr } else { 94774024373Spr int on = 1; 9480f1702c5SYu Xiangning if (socket_setsockopt(VTOSO(vp), 94974024373Spr SOL_SOCKET, SO_SND_COPYAVOID, 9500f1702c5SYu Xiangning &on, sizeof (on), CRED()) == 0) 95174024373Spr segmapit = 1; 95274024373Spr } 95374024373Spr } 95474024373Spr 95574024373Spr if (segmapit) { 95674024373Spr boolean_t nowait; 95774024373Spr 95874024373Spr nowait = (sfv->sfv_flag & SFV_NOWAIT) != 0; 95974024373Spr error = snf_segmap(fp, readvp, sfv_off, 9603b3d24f3SJayakara Kini (u_offset_t)sfv_len, (ssize_t *)&cnt, 9613b3d24f3SJayakara Kini nowait); 96274024373Spr releasef(sfv->sfv_fd); 96374024373Spr *count += cnt; 96474024373Spr if (error) 96574024373Spr return (error); 96674024373Spr sfv++; 96774024373Spr continue; 9681574ae68Sjohansen } 9691574ae68Sjohansen 9707c478bd9Sstevel@tonic-gate while (sfv_len > 0) { 9717c478bd9Sstevel@tonic-gate size_t iov_len; 9727c478bd9Sstevel@tonic-gate 9737c478bd9Sstevel@tonic-gate iov_len = MIN(size, sfv_len); 9747c478bd9Sstevel@tonic-gate 9751574ae68Sjohansen if (vp->v_type == VSOCK) { 976c28749e9Skais dmp = allocb(iov_len + extra, BPRI_HI); 9771574ae68Sjohansen if (dmp == NULL) { 978b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(readvp, 979b3528faeSVasumathi Sundaram - Sun Microsystems V_WRITELOCK_FALSE, NULL); 9801574ae68Sjohansen releasef(sfv->sfv_fd); 9811574ae68Sjohansen return (ENOMEM); 9821574ae68Sjohansen } 983c28749e9Skais dmp->b_wptr = dmp->b_rptr = 984c28749e9Skais dmp->b_rptr + wroff; 9851574ae68Sjohansen ptr = (caddr_t)dmp->b_rptr; 9861574ae68Sjohansen } else { 9871574ae68Sjohansen ptr = buf; 9887c478bd9Sstevel@tonic-gate } 9897c478bd9Sstevel@tonic-gate 9907c478bd9Sstevel@tonic-gate aiov.iov_base = ptr; 9917c478bd9Sstevel@tonic-gate aiov.iov_len = iov_len; 9927c478bd9Sstevel@tonic-gate auio.uio_loffset = sfv_off; 9937c478bd9Sstevel@tonic-gate auio.uio_iov = &aiov; 9947c478bd9Sstevel@tonic-gate auio.uio_iovcnt = 1; 9957c478bd9Sstevel@tonic-gate auio.uio_resid = iov_len; 9967c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_SYSSPACE; 9977c478bd9Sstevel@tonic-gate auio.uio_llimit = MAXOFFSET_T; 9987c478bd9Sstevel@tonic-gate auio.uio_fmode = ffp->f_flag; 9997c478bd9Sstevel@tonic-gate ioflag = auio.uio_fmode & 10007c478bd9Sstevel@tonic-gate (FAPPEND|FSYNC|FDSYNC|FRSYNC); 10017c478bd9Sstevel@tonic-gate 10027c478bd9Sstevel@tonic-gate /* 10037c478bd9Sstevel@tonic-gate * If read sync is not asked for, 10047c478bd9Sstevel@tonic-gate * filter sync flags 10057c478bd9Sstevel@tonic-gate */ 10067c478bd9Sstevel@tonic-gate if ((ioflag & FRSYNC) == 0) 10077c478bd9Sstevel@tonic-gate ioflag &= ~(FSYNC|FDSYNC); 10087c478bd9Sstevel@tonic-gate error = VOP_READ(readvp, &auio, ioflag, 10097c478bd9Sstevel@tonic-gate fp->f_cred, NULL); 10107c478bd9Sstevel@tonic-gate if (error != 0) { 10117c478bd9Sstevel@tonic-gate /* 10127c478bd9Sstevel@tonic-gate * If we were reading a pipe (currently 10137c478bd9Sstevel@tonic-gate * not implemented), we may now lose 10147c478bd9Sstevel@tonic-gate * data. 10157c478bd9Sstevel@tonic-gate */ 10161574ae68Sjohansen if (vp->v_type == VSOCK) 10171574ae68Sjohansen freeb(dmp); 10181574ae68Sjohansen else 10191574ae68Sjohansen kmem_free(buf, size); 1020b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(readvp, V_WRITELOCK_FALSE, 1021b3528faeSVasumathi Sundaram - Sun Microsystems NULL); 10227c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 10237c478bd9Sstevel@tonic-gate return (error); 10247c478bd9Sstevel@tonic-gate } 10257c478bd9Sstevel@tonic-gate 10267c478bd9Sstevel@tonic-gate /* 10277c478bd9Sstevel@tonic-gate * Check how much data was really read. 10287c478bd9Sstevel@tonic-gate * Decrement the 'len' and increment the 10297c478bd9Sstevel@tonic-gate * 'off' appropriately. 10307c478bd9Sstevel@tonic-gate */ 10317c478bd9Sstevel@tonic-gate cnt = iov_len - auio.uio_resid; 10327c478bd9Sstevel@tonic-gate if (cnt == 0) { 10331574ae68Sjohansen if (vp->v_type == VSOCK) 10341574ae68Sjohansen freeb(dmp); 10351574ae68Sjohansen else 10361574ae68Sjohansen kmem_free(buf, size); 1037b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(readvp, V_WRITELOCK_FALSE, 1038b3528faeSVasumathi Sundaram - Sun Microsystems NULL); 10397c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 10407c478bd9Sstevel@tonic-gate return (EINVAL); 10417c478bd9Sstevel@tonic-gate } 10427c478bd9Sstevel@tonic-gate sfv_len -= cnt; 10437c478bd9Sstevel@tonic-gate sfv_off += cnt; 10447c478bd9Sstevel@tonic-gate 10457c478bd9Sstevel@tonic-gate if (vp->v_type == VSOCK) { 10467c478bd9Sstevel@tonic-gate dmp->b_wptr = dmp->b_rptr + cnt; 10477c478bd9Sstevel@tonic-gate 10480f1702c5SYu Xiangning error = socket_sendmblk(VTOSO(vp), 10490f1702c5SYu Xiangning &msg, fflag, CRED(), &dmp); 10500f1702c5SYu Xiangning 10517c478bd9Sstevel@tonic-gate if (error != 0) { 10520f1702c5SYu Xiangning if (dmp != NULL) 10530f1702c5SYu Xiangning freeb(dmp); 1054b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(readvp, 1055b3528faeSVasumathi Sundaram - Sun Microsystems V_WRITELOCK_FALSE, NULL); 10567c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 10577c478bd9Sstevel@tonic-gate return (error); 10587c478bd9Sstevel@tonic-gate } 10597c478bd9Sstevel@tonic-gate 10607c478bd9Sstevel@tonic-gate ttolwp(curthread)->lwp_ru.ioch += 10617c478bd9Sstevel@tonic-gate (ulong_t)cnt; 10627c478bd9Sstevel@tonic-gate *count += cnt; 10637c478bd9Sstevel@tonic-gate } else { 10647c478bd9Sstevel@tonic-gate 10657c478bd9Sstevel@tonic-gate aiov.iov_base = ptr; 10667c478bd9Sstevel@tonic-gate aiov.iov_len = cnt; 10677c478bd9Sstevel@tonic-gate auio.uio_loffset = *fileoff; 10687c478bd9Sstevel@tonic-gate auio.uio_resid = cnt; 1069a490cd42SPrakash Jalan auio.uio_iov = &aiov; 1070a490cd42SPrakash Jalan auio.uio_iovcnt = 1; 10717c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_SYSSPACE; 10727c478bd9Sstevel@tonic-gate auio.uio_llimit = curproc->p_fsz_ctl; 10737c478bd9Sstevel@tonic-gate auio.uio_fmode = fflag; 10747c478bd9Sstevel@tonic-gate ioflag = auio.uio_fmode & 10757c478bd9Sstevel@tonic-gate (FAPPEND|FSYNC|FDSYNC|FRSYNC); 10767c478bd9Sstevel@tonic-gate error = VOP_WRITE(vp, &auio, ioflag, 10777c478bd9Sstevel@tonic-gate fp->f_cred, NULL); 10787c478bd9Sstevel@tonic-gate 10797c478bd9Sstevel@tonic-gate /* 10807c478bd9Sstevel@tonic-gate * Check how much data was written. 10817c478bd9Sstevel@tonic-gate * Increment the 'len' and decrement the 10827c478bd9Sstevel@tonic-gate * 'off' if all the data was not 10837c478bd9Sstevel@tonic-gate * written. 10847c478bd9Sstevel@tonic-gate */ 10857c478bd9Sstevel@tonic-gate cnt -= auio.uio_resid; 10867c478bd9Sstevel@tonic-gate sfv_len += auio.uio_resid; 10877c478bd9Sstevel@tonic-gate sfv_off -= auio.uio_resid; 10887c478bd9Sstevel@tonic-gate ttolwp(curthread)->lwp_ru.ioch += 10897c478bd9Sstevel@tonic-gate (ulong_t)cnt; 10907c478bd9Sstevel@tonic-gate *fileoff += cnt; 10917c478bd9Sstevel@tonic-gate *count += cnt; 10927c478bd9Sstevel@tonic-gate if (error != 0) { 10932db6c79fSstevel kmem_free(buf, size); 1094b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(readvp, 1095b3528faeSVasumathi Sundaram - Sun Microsystems V_WRITELOCK_FALSE, NULL); 10967c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 10977c478bd9Sstevel@tonic-gate return (error); 10987c478bd9Sstevel@tonic-gate } 10997c478bd9Sstevel@tonic-gate } 11007c478bd9Sstevel@tonic-gate } 11011574ae68Sjohansen if (buf) { 11021574ae68Sjohansen kmem_free(buf, size); 11031574ae68Sjohansen buf = NULL; 11041574ae68Sjohansen } 1105b3528faeSVasumathi Sundaram - Sun Microsystems VOP_RWUNLOCK(readvp, V_WRITELOCK_FALSE, NULL); 11067c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 11077c478bd9Sstevel@tonic-gate } 11087c478bd9Sstevel@tonic-gate sfv++; 11097c478bd9Sstevel@tonic-gate } 11107c478bd9Sstevel@tonic-gate return (0); 11117c478bd9Sstevel@tonic-gate } 11127c478bd9Sstevel@tonic-gate 11137c478bd9Sstevel@tonic-gate ssize_t 11147c478bd9Sstevel@tonic-gate sendfilev(int opcode, int fildes, const struct sendfilevec *vec, int sfvcnt, 11157c478bd9Sstevel@tonic-gate size_t *xferred) 11167c478bd9Sstevel@tonic-gate { 1117311e3d4cSgeorges int error = 0; 1118311e3d4cSgeorges int first_vector_error = 0; 11197c478bd9Sstevel@tonic-gate file_t *fp; 11207c478bd9Sstevel@tonic-gate struct vnode *vp; 11217c478bd9Sstevel@tonic-gate struct sonode *so; 11227c478bd9Sstevel@tonic-gate u_offset_t fileoff; 11237c478bd9Sstevel@tonic-gate int copy_cnt; 11247c478bd9Sstevel@tonic-gate const struct sendfilevec *copy_vec; 11257c478bd9Sstevel@tonic-gate struct sendfilevec sfv[SEND_MAX_CHUNK]; 11267c478bd9Sstevel@tonic-gate ssize_t count = 0; 11277c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 11287c478bd9Sstevel@tonic-gate struct ksendfilevec32 sfv32[SEND_MAX_CHUNK]; 11297c478bd9Sstevel@tonic-gate #endif 11300a8433caSrshoaib ssize_t total_size; 11317c478bd9Sstevel@tonic-gate int i; 11327c478bd9Sstevel@tonic-gate boolean_t is_sock = B_FALSE; 11337c478bd9Sstevel@tonic-gate int maxblk = 0; 11347c478bd9Sstevel@tonic-gate 11357c478bd9Sstevel@tonic-gate if (sfvcnt <= 0) 11367c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 11377c478bd9Sstevel@tonic-gate 11387c478bd9Sstevel@tonic-gate if ((fp = getf(fildes)) == NULL) 11397c478bd9Sstevel@tonic-gate return (set_errno(EBADF)); 11407c478bd9Sstevel@tonic-gate 11417c478bd9Sstevel@tonic-gate if (((fp->f_flag) & FWRITE) == 0) { 11427c478bd9Sstevel@tonic-gate error = EBADF; 11437c478bd9Sstevel@tonic-gate goto err; 11447c478bd9Sstevel@tonic-gate } 11457c478bd9Sstevel@tonic-gate 11467c478bd9Sstevel@tonic-gate fileoff = fp->f_offset; 11477c478bd9Sstevel@tonic-gate vp = fp->f_vnode; 11487c478bd9Sstevel@tonic-gate 11497c478bd9Sstevel@tonic-gate switch (vp->v_type) { 11507c478bd9Sstevel@tonic-gate case VSOCK: 11517c478bd9Sstevel@tonic-gate so = VTOSO(vp); 11527c478bd9Sstevel@tonic-gate is_sock = B_TRUE; 11530f1702c5SYu Xiangning if (SOCK_IS_NONSTR(so)) { 11540f1702c5SYu Xiangning maxblk = so->so_proto_props.sopp_maxblk; 11550f1702c5SYu Xiangning } else { 11560f1702c5SYu Xiangning maxblk = (int)vp->v_stream->sd_maxblk; 11577c478bd9Sstevel@tonic-gate } 11587c478bd9Sstevel@tonic-gate break; 11597c478bd9Sstevel@tonic-gate case VREG: 11607c478bd9Sstevel@tonic-gate break; 11617c478bd9Sstevel@tonic-gate default: 11627c478bd9Sstevel@tonic-gate error = EINVAL; 11637c478bd9Sstevel@tonic-gate goto err; 11647c478bd9Sstevel@tonic-gate } 11657c478bd9Sstevel@tonic-gate 11667c478bd9Sstevel@tonic-gate switch (opcode) { 11677c478bd9Sstevel@tonic-gate case SENDFILEV : 11687c478bd9Sstevel@tonic-gate break; 11697c478bd9Sstevel@tonic-gate #if defined(_SYSCALL32_IMPL) || defined(_ILP32) 11707c478bd9Sstevel@tonic-gate case SENDFILEV64 : 11717c478bd9Sstevel@tonic-gate return (sendvec64(fp, (struct ksendfilevec64 *)vec, sfvcnt, 11727c478bd9Sstevel@tonic-gate (size32_t *)xferred, fildes)); 11737c478bd9Sstevel@tonic-gate #endif 11747c478bd9Sstevel@tonic-gate default : 11757c478bd9Sstevel@tonic-gate error = ENOSYS; 11767c478bd9Sstevel@tonic-gate break; 11777c478bd9Sstevel@tonic-gate } 11787c478bd9Sstevel@tonic-gate 11797c478bd9Sstevel@tonic-gate (void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, NULL); 11807c478bd9Sstevel@tonic-gate copy_vec = vec; 11817c478bd9Sstevel@tonic-gate 11827c478bd9Sstevel@tonic-gate do { 11830a8433caSrshoaib total_size = 0; 11847c478bd9Sstevel@tonic-gate copy_cnt = MIN(sfvcnt, SEND_MAX_CHUNK); 11857c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 11867c478bd9Sstevel@tonic-gate /* 32-bit callers need to have their iovec expanded. */ 11877c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_ILP32) { 11887c478bd9Sstevel@tonic-gate if (copyin(copy_vec, sfv32, 11897c478bd9Sstevel@tonic-gate copy_cnt * sizeof (ksendfilevec32_t))) { 11907c478bd9Sstevel@tonic-gate error = EFAULT; 11917c478bd9Sstevel@tonic-gate break; 11927c478bd9Sstevel@tonic-gate } 11937c478bd9Sstevel@tonic-gate 11947c478bd9Sstevel@tonic-gate for (i = 0; i < copy_cnt; i++) { 11957c478bd9Sstevel@tonic-gate sfv[i].sfv_fd = sfv32[i].sfv_fd; 11967c478bd9Sstevel@tonic-gate sfv[i].sfv_off = 1197311e3d4cSgeorges (off_t)(uint32_t)sfv32[i].sfv_off; 11987c478bd9Sstevel@tonic-gate sfv[i].sfv_len = (size_t)sfv32[i].sfv_len; 11997c478bd9Sstevel@tonic-gate total_size += sfv[i].sfv_len; 12007c478bd9Sstevel@tonic-gate sfv[i].sfv_flag = sfv32[i].sfv_flag; 1201311e3d4cSgeorges /* 1202311e3d4cSgeorges * Individual elements of the vector must not 1203311e3d4cSgeorges * wrap or overflow, as later math is signed. 1204311e3d4cSgeorges * Equally total_size needs to be checked after 1205311e3d4cSgeorges * each vector is added in, to be sure that 1206311e3d4cSgeorges * rogue values haven't overflowed the counter. 1207311e3d4cSgeorges */ 1208311e3d4cSgeorges if (((ssize32_t)sfv[i].sfv_len < 0) || 1209311e3d4cSgeorges ((ssize32_t)total_size < 0)) { 1210311e3d4cSgeorges /* 1211311e3d4cSgeorges * Truncate the vector to send data 1212311e3d4cSgeorges * described by elements before the 1213311e3d4cSgeorges * error. 1214311e3d4cSgeorges */ 1215311e3d4cSgeorges copy_cnt = i; 1216311e3d4cSgeorges first_vector_error = EINVAL; 1217311e3d4cSgeorges /* total_size can't be trusted */ 1218311e3d4cSgeorges if ((ssize32_t)total_size < 0) 1219311e3d4cSgeorges error = EINVAL; 1220311e3d4cSgeorges break; 1221311e3d4cSgeorges } 12227c478bd9Sstevel@tonic-gate } 1223311e3d4cSgeorges /* Nothing to do, process errors */ 1224311e3d4cSgeorges if (copy_cnt == 0) 1225311e3d4cSgeorges break; 1226311e3d4cSgeorges 12277c478bd9Sstevel@tonic-gate } else { 12287c478bd9Sstevel@tonic-gate #endif 12297c478bd9Sstevel@tonic-gate if (copyin(copy_vec, sfv, 12307c478bd9Sstevel@tonic-gate copy_cnt * sizeof (sendfilevec_t))) { 12317c478bd9Sstevel@tonic-gate error = EFAULT; 12327c478bd9Sstevel@tonic-gate break; 12337c478bd9Sstevel@tonic-gate } 12347c478bd9Sstevel@tonic-gate 12357c478bd9Sstevel@tonic-gate for (i = 0; i < copy_cnt; i++) { 12367c478bd9Sstevel@tonic-gate total_size += sfv[i].sfv_len; 1237311e3d4cSgeorges /* 1238311e3d4cSgeorges * Individual elements of the vector must not 1239311e3d4cSgeorges * wrap or overflow, as later math is signed. 1240311e3d4cSgeorges * Equally total_size needs to be checked after 1241311e3d4cSgeorges * each vector is added in, to be sure that 1242311e3d4cSgeorges * rogue values haven't overflowed the counter. 1243311e3d4cSgeorges */ 1244311e3d4cSgeorges if (((ssize_t)sfv[i].sfv_len < 0) || 1245311e3d4cSgeorges (total_size < 0)) { 1246311e3d4cSgeorges /* 1247311e3d4cSgeorges * Truncate the vector to send data 1248311e3d4cSgeorges * described by elements before the 1249311e3d4cSgeorges * error. 1250311e3d4cSgeorges */ 1251311e3d4cSgeorges copy_cnt = i; 1252311e3d4cSgeorges first_vector_error = EINVAL; 1253311e3d4cSgeorges /* total_size can't be trusted */ 1254311e3d4cSgeorges if (total_size < 0) 1255311e3d4cSgeorges error = EINVAL; 1256311e3d4cSgeorges break; 1257311e3d4cSgeorges } 12587c478bd9Sstevel@tonic-gate } 1259311e3d4cSgeorges /* Nothing to do, process errors */ 1260311e3d4cSgeorges if (copy_cnt == 0) 1261311e3d4cSgeorges break; 12627c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 12637c478bd9Sstevel@tonic-gate } 12647c478bd9Sstevel@tonic-gate #endif 12657c478bd9Sstevel@tonic-gate 12667c478bd9Sstevel@tonic-gate /* 12677c478bd9Sstevel@tonic-gate * The task between deciding to use sendvec_small_chunk 12687c478bd9Sstevel@tonic-gate * and sendvec_chunk is dependant on multiple things: 12697c478bd9Sstevel@tonic-gate * 12707c478bd9Sstevel@tonic-gate * i) latency is important for smaller files. So if the 12717c478bd9Sstevel@tonic-gate * data is smaller than 'tcp_slow_start_initial' times 12727c478bd9Sstevel@tonic-gate * maxblk, then use sendvec_small_chunk which creates 12733b3d24f3SJayakara Kini * maxblk size mblks and chains them together and sends 12747c478bd9Sstevel@tonic-gate * them to TCP in one shot. It also leaves 'wroff' size 12757c478bd9Sstevel@tonic-gate * space for the headers in each mblk. 12767c478bd9Sstevel@tonic-gate * 12777c478bd9Sstevel@tonic-gate * ii) for total size bigger than 'tcp_slow_start_initial' 12787c478bd9Sstevel@tonic-gate * time maxblk, its probably real file data which is 12797c478bd9Sstevel@tonic-gate * dominating. So its better to use sendvec_chunk because 12807c478bd9Sstevel@tonic-gate * performance goes to dog if we don't do pagesize reads. 12817c478bd9Sstevel@tonic-gate * sendvec_chunk will do pagesize reads and write them 12827c478bd9Sstevel@tonic-gate * in pagesize mblks to TCP. 12837c478bd9Sstevel@tonic-gate * 12847c478bd9Sstevel@tonic-gate * Side Notes: A write to file has not been optimized. 12857c478bd9Sstevel@tonic-gate * Future zero copy code will plugin into sendvec_chunk 12867c478bd9Sstevel@tonic-gate * only because doing zero copy for files smaller then 12877c478bd9Sstevel@tonic-gate * pagesize is useless. 12887c478bd9Sstevel@tonic-gate * 12897c478bd9Sstevel@tonic-gate * Note, if socket has NL7C enabled then call NL7C's 12902c9e429eSbrutus * senfilev() function to consume the sfv[]. 12917c478bd9Sstevel@tonic-gate */ 12927c478bd9Sstevel@tonic-gate if (is_sock) { 12930f1702c5SYu Xiangning if (!SOCK_IS_NONSTR(so) && 12940f1702c5SYu Xiangning _SOTOTPI(so)->sti_nl7c_flags != 0) { 12950f1702c5SYu Xiangning error = nl7c_sendfilev(so, &fileoff, 12960f1702c5SYu Xiangning sfv, copy_cnt, &count); 12970f1702c5SYu Xiangning } else if ((total_size <= (4 * maxblk)) && 12980f1702c5SYu Xiangning error == 0) { 12990f1702c5SYu Xiangning error = sendvec_small_chunk(fp, 13000f1702c5SYu Xiangning &fileoff, sfv, copy_cnt, 13010f1702c5SYu Xiangning total_size, maxblk, &count); 13020f1702c5SYu Xiangning } else { 13030f1702c5SYu Xiangning error = sendvec_chunk(fp, &fileoff, 13040f1702c5SYu Xiangning sfv, copy_cnt, &count); 13057c478bd9Sstevel@tonic-gate } 13067c478bd9Sstevel@tonic-gate } else { 13077c478bd9Sstevel@tonic-gate ASSERT(vp->v_type == VREG); 13087c478bd9Sstevel@tonic-gate error = sendvec_chunk(fp, &fileoff, sfv, copy_cnt, 13097c478bd9Sstevel@tonic-gate &count); 13107c478bd9Sstevel@tonic-gate } 13117c478bd9Sstevel@tonic-gate 13127c478bd9Sstevel@tonic-gate 13137c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 13147c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_ILP32) 13157c478bd9Sstevel@tonic-gate copy_vec = (const struct sendfilevec *)((char *)copy_vec + 13167c478bd9Sstevel@tonic-gate (copy_cnt * sizeof (ksendfilevec32_t))); 13177c478bd9Sstevel@tonic-gate else 13187c478bd9Sstevel@tonic-gate #endif 13197c478bd9Sstevel@tonic-gate copy_vec += copy_cnt; 13207c478bd9Sstevel@tonic-gate sfvcnt -= copy_cnt; 1321311e3d4cSgeorges 1322311e3d4cSgeorges /* Process all vector members up to first error */ 1323311e3d4cSgeorges } while ((sfvcnt > 0) && first_vector_error == 0 && error == 0); 13247c478bd9Sstevel@tonic-gate 13257c478bd9Sstevel@tonic-gate if (vp->v_type == VREG) 13267c478bd9Sstevel@tonic-gate fp->f_offset += count; 13277c478bd9Sstevel@tonic-gate 13287c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, NULL); 13297c478bd9Sstevel@tonic-gate 13307c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 13317c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_ILP32) { 13327c478bd9Sstevel@tonic-gate ssize32_t count32 = (ssize32_t)count; 13337c478bd9Sstevel@tonic-gate if (copyout(&count32, xferred, sizeof (count32))) 13347c478bd9Sstevel@tonic-gate error = EFAULT; 13357c478bd9Sstevel@tonic-gate releasef(fildes); 13367c478bd9Sstevel@tonic-gate if (error != 0) 13377c478bd9Sstevel@tonic-gate return (set_errno(error)); 1338311e3d4cSgeorges if (first_vector_error != 0) 1339311e3d4cSgeorges return (set_errno(first_vector_error)); 13407c478bd9Sstevel@tonic-gate return (count32); 13417c478bd9Sstevel@tonic-gate } 13427c478bd9Sstevel@tonic-gate #endif 13437c478bd9Sstevel@tonic-gate if (copyout(&count, xferred, sizeof (count))) 13447c478bd9Sstevel@tonic-gate error = EFAULT; 13457c478bd9Sstevel@tonic-gate releasef(fildes); 13467c478bd9Sstevel@tonic-gate if (error != 0) 13477c478bd9Sstevel@tonic-gate return (set_errno(error)); 1348311e3d4cSgeorges if (first_vector_error != 0) 1349311e3d4cSgeorges return (set_errno(first_vector_error)); 13507c478bd9Sstevel@tonic-gate return (count); 13517c478bd9Sstevel@tonic-gate err: 13527c478bd9Sstevel@tonic-gate ASSERT(error != 0); 13537c478bd9Sstevel@tonic-gate releasef(fildes); 13547c478bd9Sstevel@tonic-gate return (set_errno(error)); 13557c478bd9Sstevel@tonic-gate } 1356