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 /* 2374024373Spr * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 287c478bd9Sstevel@tonic-gate 297c478bd9Sstevel@tonic-gate #include <sys/types.h> 307c478bd9Sstevel@tonic-gate #include <sys/t_lock.h> 317c478bd9Sstevel@tonic-gate #include <sys/param.h> 327c478bd9Sstevel@tonic-gate #include <sys/systm.h> 337c478bd9Sstevel@tonic-gate #include <sys/buf.h> 347c478bd9Sstevel@tonic-gate #include <sys/conf.h> 357c478bd9Sstevel@tonic-gate #include <sys/cred.h> 367c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 377c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 387c478bd9Sstevel@tonic-gate #include <sys/vfs.h> 397c478bd9Sstevel@tonic-gate #include <sys/vnode.h> 407c478bd9Sstevel@tonic-gate #include <sys/debug.h> 417c478bd9Sstevel@tonic-gate #include <sys/errno.h> 427c478bd9Sstevel@tonic-gate #include <sys/time.h> 437c478bd9Sstevel@tonic-gate #include <sys/file.h> 447c478bd9Sstevel@tonic-gate #include <sys/open.h> 457c478bd9Sstevel@tonic-gate #include <sys/user.h> 467c478bd9Sstevel@tonic-gate #include <sys/termios.h> 477c478bd9Sstevel@tonic-gate #include <sys/stream.h> 487c478bd9Sstevel@tonic-gate #include <sys/strsubr.h> 4974024373Spr #include <sys/sunddi.h> 507c478bd9Sstevel@tonic-gate #include <sys/esunddi.h> 517c478bd9Sstevel@tonic-gate #include <sys/flock.h> 527c478bd9Sstevel@tonic-gate #include <sys/modctl.h> 537c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 547c478bd9Sstevel@tonic-gate #include <sys/vmsystm.h> 557c478bd9Sstevel@tonic-gate 567c478bd9Sstevel@tonic-gate #include <sys/socket.h> 577c478bd9Sstevel@tonic-gate #include <sys/socketvar.h> 5845916cd2Sjpk /* swilly code in sys/socketvar.h turns off DEBUG */ 5945916cd2Sjpk #ifdef __lint 6045916cd2Sjpk #define DEBUG 6145916cd2Sjpk #endif 6245916cd2Sjpk 637c478bd9Sstevel@tonic-gate #include <netinet/in.h> 647c478bd9Sstevel@tonic-gate #include <sys/sendfile.h> 657c478bd9Sstevel@tonic-gate #include <sys/un.h> 667c478bd9Sstevel@tonic-gate #include <sys/tihdr.h> 677c478bd9Sstevel@tonic-gate #include <sys/atomic.h> 687c478bd9Sstevel@tonic-gate 697c478bd9Sstevel@tonic-gate #include <inet/common.h> 707c478bd9Sstevel@tonic-gate #include <inet/ip.h> 717c478bd9Sstevel@tonic-gate #include <inet/ip6.h> 727c478bd9Sstevel@tonic-gate #include <inet/tcp.h> 737c478bd9Sstevel@tonic-gate 747c478bd9Sstevel@tonic-gate extern int sosendfile64(file_t *, file_t *, const struct ksendfilevec64 *, 757c478bd9Sstevel@tonic-gate ssize32_t *); 762c9e429eSbrutus extern int nl7c_sendfilev(struct sonode *, u_offset_t *, struct sendfilevec *, 772c9e429eSbrutus int, ssize_t *); 7874024373Spr extern int snf_segmap(file_t *, vnode_t *, u_offset_t, u_offset_t, uint_t, 7974024373Spr ssize_t *, boolean_t); 8074024373Spr 8174024373Spr #define readflg (V_WRITELOCK_FALSE) 8274024373Spr #define rwflag (V_WRITELOCK_TRUE) 837c478bd9Sstevel@tonic-gate 84ff550d0eSmasputra /* 85ff550d0eSmasputra * kstrwritemp() has very similar semantics as that of strwrite(). 86ff550d0eSmasputra * The main difference is it obtains mblks from the caller and also 87ff550d0eSmasputra * does not do any copy as done in strwrite() from user buffers to 88ff550d0eSmasputra * kernel buffers. 89ff550d0eSmasputra * 90ff550d0eSmasputra * Currently, this routine is used by sendfile to send data allocated 91ff550d0eSmasputra * within the kernel without any copying. This interface does not use the 92ff550d0eSmasputra * synchronous stream interface as synch. stream interface implies 93ff550d0eSmasputra * copying. 94ff550d0eSmasputra */ 95ff550d0eSmasputra int 96ff550d0eSmasputra kstrwritemp(struct vnode *vp, mblk_t *mp, ushort_t fmode) 97ff550d0eSmasputra { 98ff550d0eSmasputra struct stdata *stp; 99ff550d0eSmasputra struct queue *wqp; 100c28749e9Skais mblk_t *newmp; 101ff550d0eSmasputra char waitflag; 102ff550d0eSmasputra int tempmode; 103ff550d0eSmasputra int error = 0; 104ff550d0eSmasputra int done = 0; 105ff550d0eSmasputra struct sonode *so; 106ff550d0eSmasputra boolean_t direct; 107ff550d0eSmasputra 108ff550d0eSmasputra ASSERT(vp->v_stream); 109ff550d0eSmasputra stp = vp->v_stream; 110ff550d0eSmasputra 111ff550d0eSmasputra so = VTOSO(vp); 112ff550d0eSmasputra direct = (so->so_state & SS_DIRECT); 113ff550d0eSmasputra 114ff550d0eSmasputra /* 115ff550d0eSmasputra * This is the sockfs direct fast path. canputnext() need 116ff550d0eSmasputra * not be accurate so we don't grab the sd_lock here. If 117ff550d0eSmasputra * we get flow-controlled, we grab sd_lock just before the 118ff550d0eSmasputra * do..while loop below to emulate what strwrite() does. 119ff550d0eSmasputra */ 120ff550d0eSmasputra wqp = stp->sd_wrq; 121ff550d0eSmasputra if (canputnext(wqp) && direct && 122ff550d0eSmasputra !(stp->sd_flag & (STWRERR|STRHUP|STPLEX))) { 123ff550d0eSmasputra return (sostream_direct(so, NULL, mp, CRED())); 124ff550d0eSmasputra } else if (stp->sd_flag & (STWRERR|STRHUP|STPLEX)) { 125ff550d0eSmasputra /* Fast check of flags before acquiring the lock */ 126ff550d0eSmasputra mutex_enter(&stp->sd_lock); 127ff550d0eSmasputra error = strgeterr(stp, STWRERR|STRHUP|STPLEX, 0); 128ff550d0eSmasputra mutex_exit(&stp->sd_lock); 129ff550d0eSmasputra if (error != 0) { 130ff550d0eSmasputra if (!(stp->sd_flag & STPLEX) && 131ff550d0eSmasputra (stp->sd_wput_opt & SW_SIGPIPE)) { 132ff550d0eSmasputra tsignal(curthread, SIGPIPE); 133ff550d0eSmasputra error = EPIPE; 134ff550d0eSmasputra } 135ff550d0eSmasputra return (error); 136ff550d0eSmasputra } 137ff550d0eSmasputra } 138ff550d0eSmasputra 139ff550d0eSmasputra waitflag = WRITEWAIT; 140ff550d0eSmasputra if (stp->sd_flag & OLDNDELAY) 141ff550d0eSmasputra tempmode = fmode & ~FNDELAY; 142ff550d0eSmasputra else 143ff550d0eSmasputra tempmode = fmode; 144ff550d0eSmasputra 145ff550d0eSmasputra mutex_enter(&stp->sd_lock); 146ff550d0eSmasputra do { 147ff550d0eSmasputra if (canputnext(wqp)) { 148ff550d0eSmasputra mutex_exit(&stp->sd_lock); 149c28749e9Skais if (stp->sd_wputdatafunc != NULL) { 150c28749e9Skais newmp = (stp->sd_wputdatafunc)(vp, mp, NULL, 151c28749e9Skais NULL, NULL, NULL); 152c28749e9Skais if (newmp == NULL) { 153c28749e9Skais /* The caller will free mp */ 154c28749e9Skais return (ECOMM); 155c28749e9Skais } 156c28749e9Skais mp = newmp; 157c28749e9Skais } 158ff550d0eSmasputra putnext(wqp, mp); 159ff550d0eSmasputra return (0); 160ff550d0eSmasputra } 161ff550d0eSmasputra error = strwaitq(stp, waitflag, (ssize_t)0, tempmode, -1, 162ff550d0eSmasputra &done); 163ff550d0eSmasputra } while (error == 0 && !done); 164ff550d0eSmasputra 165ff550d0eSmasputra mutex_exit(&stp->sd_lock); 166ff550d0eSmasputra /* 167ff550d0eSmasputra * EAGAIN tells the application to try again. ENOMEM 168ff550d0eSmasputra * is returned only if the memory allocation size 169ff550d0eSmasputra * exceeds the physical limits of the system. ENOMEM 170ff550d0eSmasputra * can't be true here. 171ff550d0eSmasputra */ 172ff550d0eSmasputra if (error == ENOMEM) 173ff550d0eSmasputra error = EAGAIN; 174ff550d0eSmasputra return (error); 175ff550d0eSmasputra } 176ff550d0eSmasputra 1777c478bd9Sstevel@tonic-gate #define SEND_MAX_CHUNK 16 1787c478bd9Sstevel@tonic-gate 1797c478bd9Sstevel@tonic-gate #if defined(_SYSCALL32_IMPL) || defined(_ILP32) 1807c478bd9Sstevel@tonic-gate /* 1817c478bd9Sstevel@tonic-gate * 64 bit offsets for 32 bit applications only running either on 1827c478bd9Sstevel@tonic-gate * 64 bit kernel or 32 bit kernel. For 32 bit apps, we can't transfer 1837c478bd9Sstevel@tonic-gate * more than 2GB of data. 1847c478bd9Sstevel@tonic-gate */ 1857c478bd9Sstevel@tonic-gate int 1867c478bd9Sstevel@tonic-gate sendvec_chunk64(file_t *fp, u_offset_t *fileoff, struct ksendfilevec64 *sfv, 1877c478bd9Sstevel@tonic-gate int copy_cnt, ssize32_t *count) 1887c478bd9Sstevel@tonic-gate { 1897c478bd9Sstevel@tonic-gate struct vnode *vp; 1907c478bd9Sstevel@tonic-gate ushort_t fflag; 1917c478bd9Sstevel@tonic-gate int ioflag; 1927c478bd9Sstevel@tonic-gate size32_t cnt; 1937c478bd9Sstevel@tonic-gate ssize32_t sfv_len; 1947c478bd9Sstevel@tonic-gate ssize32_t tmpcount; 1957c478bd9Sstevel@tonic-gate u_offset_t sfv_off; 1967c478bd9Sstevel@tonic-gate struct uio auio; 1977c478bd9Sstevel@tonic-gate struct iovec aiov; 1987c478bd9Sstevel@tonic-gate int i, error; 1997c478bd9Sstevel@tonic-gate 2007c478bd9Sstevel@tonic-gate fflag = fp->f_flag; 2017c478bd9Sstevel@tonic-gate vp = fp->f_vnode; 2027c478bd9Sstevel@tonic-gate for (i = 0; i < copy_cnt; i++) { 2037c478bd9Sstevel@tonic-gate 2047c478bd9Sstevel@tonic-gate if (ISSIG(curthread, JUSTLOOKING)) 2057c478bd9Sstevel@tonic-gate return (EINTR); 2067c478bd9Sstevel@tonic-gate 2077c478bd9Sstevel@tonic-gate /* 2087c478bd9Sstevel@tonic-gate * Do similar checks as "write" as we are writing 2097c478bd9Sstevel@tonic-gate * sfv_len bytes into "vp". 2107c478bd9Sstevel@tonic-gate */ 2117c478bd9Sstevel@tonic-gate sfv_len = (ssize32_t)sfv->sfv_len; 2127c478bd9Sstevel@tonic-gate 2137c478bd9Sstevel@tonic-gate if (sfv_len == 0) 2147c478bd9Sstevel@tonic-gate continue; 2157c478bd9Sstevel@tonic-gate 2167c478bd9Sstevel@tonic-gate if (sfv_len < 0) 2177c478bd9Sstevel@tonic-gate return (EINVAL); 2187c478bd9Sstevel@tonic-gate 2197c478bd9Sstevel@tonic-gate if (vp->v_type == VREG) { 2207c478bd9Sstevel@tonic-gate if (*fileoff >= curproc->p_fsz_ctl) { 2217c478bd9Sstevel@tonic-gate mutex_enter(&curproc->p_lock); 2227c478bd9Sstevel@tonic-gate (void) rctl_action( 2237c478bd9Sstevel@tonic-gate rctlproc_legacy[RLIMIT_FSIZE], 2247c478bd9Sstevel@tonic-gate curproc->p_rctls, curproc, RCA_SAFE); 2257c478bd9Sstevel@tonic-gate mutex_exit(&curproc->p_lock); 2267c478bd9Sstevel@tonic-gate return (EFBIG); 2277c478bd9Sstevel@tonic-gate } 2287c478bd9Sstevel@tonic-gate 2297c478bd9Sstevel@tonic-gate if (*fileoff >= OFFSET_MAX(fp)) 2307c478bd9Sstevel@tonic-gate return (EFBIG); 2317c478bd9Sstevel@tonic-gate 2327c478bd9Sstevel@tonic-gate if (*fileoff + sfv_len > OFFSET_MAX(fp)) 2337c478bd9Sstevel@tonic-gate return (EINVAL); 2347c478bd9Sstevel@tonic-gate } 2357c478bd9Sstevel@tonic-gate 2367c478bd9Sstevel@tonic-gate tmpcount = *count + sfv_len; 2377c478bd9Sstevel@tonic-gate if (tmpcount < 0) 2387c478bd9Sstevel@tonic-gate return (EINVAL); 2397c478bd9Sstevel@tonic-gate 2407c478bd9Sstevel@tonic-gate sfv_off = sfv->sfv_off; 2417c478bd9Sstevel@tonic-gate 2427c478bd9Sstevel@tonic-gate auio.uio_extflg = UIO_COPY_DEFAULT; 2437c478bd9Sstevel@tonic-gate if (sfv->sfv_fd == SFV_FD_SELF) { 2447c478bd9Sstevel@tonic-gate aiov.iov_len = sfv_len; 2457c478bd9Sstevel@tonic-gate aiov.iov_base = (caddr_t)(uintptr_t)sfv_off; 2467c478bd9Sstevel@tonic-gate auio.uio_loffset = *fileoff; 2477c478bd9Sstevel@tonic-gate auio.uio_iovcnt = 1; 2487c478bd9Sstevel@tonic-gate auio.uio_resid = sfv_len; 2497c478bd9Sstevel@tonic-gate auio.uio_iov = &aiov; 2507c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_USERSPACE; 2517c478bd9Sstevel@tonic-gate auio.uio_llimit = curproc->p_fsz_ctl; 2527c478bd9Sstevel@tonic-gate auio.uio_fmode = fflag; 2537c478bd9Sstevel@tonic-gate ioflag = auio.uio_fmode & (FAPPEND|FSYNC|FDSYNC|FRSYNC); 2547c478bd9Sstevel@tonic-gate while (sfv_len > 0) { 2557c478bd9Sstevel@tonic-gate error = VOP_WRITE(vp, &auio, ioflag, 2567c478bd9Sstevel@tonic-gate fp->f_cred, NULL); 2577c478bd9Sstevel@tonic-gate cnt = sfv_len - auio.uio_resid; 2587c478bd9Sstevel@tonic-gate sfv_len -= cnt; 2597c478bd9Sstevel@tonic-gate ttolwp(curthread)->lwp_ru.ioch += (ulong_t)cnt; 2607c478bd9Sstevel@tonic-gate if (vp->v_type == VREG) 2617c478bd9Sstevel@tonic-gate *fileoff += cnt; 2627c478bd9Sstevel@tonic-gate *count += cnt; 2637c478bd9Sstevel@tonic-gate if (error != 0) 2647c478bd9Sstevel@tonic-gate return (error); 2657c478bd9Sstevel@tonic-gate } 2667c478bd9Sstevel@tonic-gate } else { 2677c478bd9Sstevel@tonic-gate file_t *ffp; 2687c478bd9Sstevel@tonic-gate vnode_t *readvp; 2697c478bd9Sstevel@tonic-gate size_t size; 2707c478bd9Sstevel@tonic-gate caddr_t ptr; 2717c478bd9Sstevel@tonic-gate 2727c478bd9Sstevel@tonic-gate if ((ffp = getf(sfv->sfv_fd)) == NULL) 2737c478bd9Sstevel@tonic-gate return (EBADF); 2747c478bd9Sstevel@tonic-gate 2757c478bd9Sstevel@tonic-gate if ((ffp->f_flag & FREAD) == 0) { 2767c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 2777c478bd9Sstevel@tonic-gate return (EBADF); 2787c478bd9Sstevel@tonic-gate } 2797c478bd9Sstevel@tonic-gate 2807c478bd9Sstevel@tonic-gate readvp = ffp->f_vnode; 2817c478bd9Sstevel@tonic-gate if (readvp->v_type != VREG) { 2827c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 2837c478bd9Sstevel@tonic-gate return (EINVAL); 2847c478bd9Sstevel@tonic-gate } 2857c478bd9Sstevel@tonic-gate 2867c478bd9Sstevel@tonic-gate /* 2877c478bd9Sstevel@tonic-gate * No point reading and writing to same vp, 2887c478bd9Sstevel@tonic-gate * as long as both are regular files. readvp is not 2897c478bd9Sstevel@tonic-gate * locked; but since we got it from an open file the 2907c478bd9Sstevel@tonic-gate * contents will be valid during the time of access. 2917c478bd9Sstevel@tonic-gate */ 292*bfb244baSpr if (vn_compare(vp, readvp)) { 2937c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 2947c478bd9Sstevel@tonic-gate return (EINVAL); 2957c478bd9Sstevel@tonic-gate } 2967c478bd9Sstevel@tonic-gate 2977c478bd9Sstevel@tonic-gate /* 2987c478bd9Sstevel@tonic-gate * Note: we assume readvp != vp. "vp" is already 2997c478bd9Sstevel@tonic-gate * locked, and "readvp" must not be. 3007c478bd9Sstevel@tonic-gate */ 3017c478bd9Sstevel@tonic-gate (void) VOP_RWLOCK(readvp, readflg, NULL); 3027c478bd9Sstevel@tonic-gate 3037c478bd9Sstevel@tonic-gate /* 3047c478bd9Sstevel@tonic-gate * Same checks as in pread64. 3057c478bd9Sstevel@tonic-gate */ 3067c478bd9Sstevel@tonic-gate if (sfv_off > MAXOFFSET_T) { 3077c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 3087c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 3097c478bd9Sstevel@tonic-gate return (EINVAL); 3107c478bd9Sstevel@tonic-gate } 3117c478bd9Sstevel@tonic-gate 3127c478bd9Sstevel@tonic-gate if (sfv_off + sfv_len > MAXOFFSET_T) 3137c478bd9Sstevel@tonic-gate sfv_len = (ssize32_t)(MAXOFFSET_T - sfv_off); 3147c478bd9Sstevel@tonic-gate 3157c478bd9Sstevel@tonic-gate /* Find the native blocksize to transfer data */ 3167c478bd9Sstevel@tonic-gate size = MIN(vp->v_vfsp->vfs_bsize, 3177c478bd9Sstevel@tonic-gate readvp->v_vfsp->vfs_bsize); 3187c478bd9Sstevel@tonic-gate size = sfv_len < size ? sfv_len : size; 3197c478bd9Sstevel@tonic-gate ptr = kmem_alloc(size, KM_SLEEP); 3207c478bd9Sstevel@tonic-gate 3217c478bd9Sstevel@tonic-gate while (sfv_len > 0) { 3227c478bd9Sstevel@tonic-gate size_t iov_len; 3237c478bd9Sstevel@tonic-gate 3247c478bd9Sstevel@tonic-gate iov_len = MIN(size, sfv_len); 3257c478bd9Sstevel@tonic-gate aiov.iov_base = ptr; 3267c478bd9Sstevel@tonic-gate aiov.iov_len = iov_len; 3277c478bd9Sstevel@tonic-gate auio.uio_loffset = sfv_off; 3287c478bd9Sstevel@tonic-gate auio.uio_iov = &aiov; 3297c478bd9Sstevel@tonic-gate auio.uio_iovcnt = 1; 3307c478bd9Sstevel@tonic-gate auio.uio_resid = iov_len; 3317c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_SYSSPACE; 3327c478bd9Sstevel@tonic-gate auio.uio_llimit = MAXOFFSET_T; 3337c478bd9Sstevel@tonic-gate auio.uio_fmode = ffp->f_flag; 3347c478bd9Sstevel@tonic-gate ioflag = auio.uio_fmode & 3357c478bd9Sstevel@tonic-gate (FAPPEND|FSYNC|FDSYNC|FRSYNC); 3367c478bd9Sstevel@tonic-gate 3377c478bd9Sstevel@tonic-gate /* 3387c478bd9Sstevel@tonic-gate * If read sync is not asked for, 3397c478bd9Sstevel@tonic-gate * filter sync flags 3407c478bd9Sstevel@tonic-gate */ 3417c478bd9Sstevel@tonic-gate if ((ioflag & FRSYNC) == 0) 3427c478bd9Sstevel@tonic-gate ioflag &= ~(FSYNC|FDSYNC); 3437c478bd9Sstevel@tonic-gate error = VOP_READ(readvp, &auio, ioflag, 3447c478bd9Sstevel@tonic-gate fp->f_cred, NULL); 3457c478bd9Sstevel@tonic-gate if (error) { 3467c478bd9Sstevel@tonic-gate kmem_free(ptr, size); 3477c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 3487c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 3497c478bd9Sstevel@tonic-gate return (error); 3507c478bd9Sstevel@tonic-gate } 3517c478bd9Sstevel@tonic-gate 3527c478bd9Sstevel@tonic-gate /* 3537c478bd9Sstevel@tonic-gate * Check how must data was really read. 3547c478bd9Sstevel@tonic-gate * Decrement the 'len' and increment the 3557c478bd9Sstevel@tonic-gate * 'off' appropriately. 3567c478bd9Sstevel@tonic-gate */ 3577c478bd9Sstevel@tonic-gate cnt = iov_len - auio.uio_resid; 3587c478bd9Sstevel@tonic-gate if (cnt == 0) { 3597c478bd9Sstevel@tonic-gate /* 3607c478bd9Sstevel@tonic-gate * If we were reading a pipe (currently 3617c478bd9Sstevel@tonic-gate * not implemented), we may now lose 3627c478bd9Sstevel@tonic-gate * data. 3637c478bd9Sstevel@tonic-gate */ 3647c478bd9Sstevel@tonic-gate kmem_free(ptr, size); 3657c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 3667c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 3677c478bd9Sstevel@tonic-gate return (EINVAL); 3687c478bd9Sstevel@tonic-gate } 3697c478bd9Sstevel@tonic-gate sfv_len -= cnt; 3707c478bd9Sstevel@tonic-gate sfv_off += cnt; 3717c478bd9Sstevel@tonic-gate 3727c478bd9Sstevel@tonic-gate aiov.iov_base = ptr; 3737c478bd9Sstevel@tonic-gate aiov.iov_len = cnt; 3747c478bd9Sstevel@tonic-gate auio.uio_loffset = *fileoff; 3757c478bd9Sstevel@tonic-gate auio.uio_resid = cnt; 3767c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_SYSSPACE; 3777c478bd9Sstevel@tonic-gate auio.uio_llimit = curproc->p_fsz_ctl; 3787c478bd9Sstevel@tonic-gate auio.uio_fmode = fflag; 3797c478bd9Sstevel@tonic-gate ioflag = auio.uio_fmode & 3807c478bd9Sstevel@tonic-gate (FAPPEND|FSYNC|FDSYNC|FRSYNC); 3817c478bd9Sstevel@tonic-gate error = VOP_WRITE(vp, &auio, ioflag, 3827c478bd9Sstevel@tonic-gate fp->f_cred, NULL); 3837c478bd9Sstevel@tonic-gate 3847c478bd9Sstevel@tonic-gate /* 3857c478bd9Sstevel@tonic-gate * Check how much data was written. Increment 3867c478bd9Sstevel@tonic-gate * the 'len' and decrement the 'off' if all 3877c478bd9Sstevel@tonic-gate * the data was not written. 3887c478bd9Sstevel@tonic-gate */ 3897c478bd9Sstevel@tonic-gate cnt -= auio.uio_resid; 3907c478bd9Sstevel@tonic-gate sfv_len += auio.uio_resid; 3917c478bd9Sstevel@tonic-gate sfv_off -= auio.uio_resid; 3927c478bd9Sstevel@tonic-gate ttolwp(curthread)->lwp_ru.ioch += (ulong_t)cnt; 3937c478bd9Sstevel@tonic-gate if (vp->v_type == VREG) 3947c478bd9Sstevel@tonic-gate *fileoff += cnt; 3957c478bd9Sstevel@tonic-gate *count += cnt; 3967c478bd9Sstevel@tonic-gate if (error != 0) { 3977c478bd9Sstevel@tonic-gate kmem_free(ptr, size); 3987c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 3997c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 4007c478bd9Sstevel@tonic-gate return (error); 4017c478bd9Sstevel@tonic-gate } 4027c478bd9Sstevel@tonic-gate } 4037c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 4047c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 4057c478bd9Sstevel@tonic-gate kmem_free(ptr, size); 4067c478bd9Sstevel@tonic-gate } 4077c478bd9Sstevel@tonic-gate sfv++; 4087c478bd9Sstevel@tonic-gate } 4097c478bd9Sstevel@tonic-gate return (0); 4107c478bd9Sstevel@tonic-gate } 4117c478bd9Sstevel@tonic-gate 4127c478bd9Sstevel@tonic-gate ssize32_t 4137c478bd9Sstevel@tonic-gate sendvec64(file_t *fp, const struct ksendfilevec64 *vec, int sfvcnt, 4147c478bd9Sstevel@tonic-gate size32_t *xferred, int fildes) 4157c478bd9Sstevel@tonic-gate { 4167c478bd9Sstevel@tonic-gate u_offset_t fileoff; 4177c478bd9Sstevel@tonic-gate int copy_cnt; 4187c478bd9Sstevel@tonic-gate const struct ksendfilevec64 *copy_vec; 4197c478bd9Sstevel@tonic-gate struct ksendfilevec64 sfv[SEND_MAX_CHUNK]; 4207c478bd9Sstevel@tonic-gate struct vnode *vp; 4217c478bd9Sstevel@tonic-gate int error; 4227c478bd9Sstevel@tonic-gate ssize32_t count = 0; 4237c478bd9Sstevel@tonic-gate 4247c478bd9Sstevel@tonic-gate vp = fp->f_vnode; 4257c478bd9Sstevel@tonic-gate (void) VOP_RWLOCK(vp, rwflag, NULL); 4267c478bd9Sstevel@tonic-gate 4277c478bd9Sstevel@tonic-gate copy_vec = vec; 4287c478bd9Sstevel@tonic-gate fileoff = fp->f_offset; 4297c478bd9Sstevel@tonic-gate 4307c478bd9Sstevel@tonic-gate do { 4317c478bd9Sstevel@tonic-gate copy_cnt = MIN(sfvcnt, SEND_MAX_CHUNK); 4327c478bd9Sstevel@tonic-gate if (copyin(copy_vec, sfv, copy_cnt * 4337c478bd9Sstevel@tonic-gate sizeof (struct ksendfilevec64))) { 4347c478bd9Sstevel@tonic-gate error = EFAULT; 4357c478bd9Sstevel@tonic-gate break; 4367c478bd9Sstevel@tonic-gate } 4377c478bd9Sstevel@tonic-gate 4387c478bd9Sstevel@tonic-gate /* 43974024373Spr * Optimize the regular file over 4407c478bd9Sstevel@tonic-gate * the socket case. 4417c478bd9Sstevel@tonic-gate */ 44274024373Spr if (vp->v_type == VSOCK && sfv->sfv_fd != SFV_FD_SELF) { 4437c478bd9Sstevel@tonic-gate file_t *rfp; 4447c478bd9Sstevel@tonic-gate vnode_t *rvp; 4457c478bd9Sstevel@tonic-gate 4467c478bd9Sstevel@tonic-gate if ((rfp = getf(sfv->sfv_fd)) == NULL) { 4477c478bd9Sstevel@tonic-gate error = EBADF; 4487c478bd9Sstevel@tonic-gate break; 4497c478bd9Sstevel@tonic-gate } 4507c478bd9Sstevel@tonic-gate if ((rfp->f_flag & FREAD) == 0) { 4517c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 4527c478bd9Sstevel@tonic-gate error = EBADF; 4537c478bd9Sstevel@tonic-gate break; 4547c478bd9Sstevel@tonic-gate } 4557c478bd9Sstevel@tonic-gate rvp = rfp->f_vnode; 4567c478bd9Sstevel@tonic-gate if (rvp->v_type == VREG) { 4577c478bd9Sstevel@tonic-gate error = sosendfile64(fp, rfp, sfv, &count); 45874024373Spr if (error) 45974024373Spr break; 46074024373Spr copy_vec++; 46174024373Spr sfvcnt--; 46274024373Spr continue; 4637c478bd9Sstevel@tonic-gate } 4647c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 4657c478bd9Sstevel@tonic-gate } 4667c478bd9Sstevel@tonic-gate error = sendvec_chunk64(fp, &fileoff, sfv, copy_cnt, &count); 4677c478bd9Sstevel@tonic-gate if (error != 0) 4687c478bd9Sstevel@tonic-gate break; 4697c478bd9Sstevel@tonic-gate 4707c478bd9Sstevel@tonic-gate copy_vec += copy_cnt; 4717c478bd9Sstevel@tonic-gate sfvcnt -= copy_cnt; 4727c478bd9Sstevel@tonic-gate } while (sfvcnt > 0); 4737c478bd9Sstevel@tonic-gate 4747c478bd9Sstevel@tonic-gate if (vp->v_type == VREG) 4757c478bd9Sstevel@tonic-gate fp->f_offset += count; 4767c478bd9Sstevel@tonic-gate 4777c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(vp, rwflag, NULL); 4787c478bd9Sstevel@tonic-gate if (copyout(&count, xferred, sizeof (count))) 4797c478bd9Sstevel@tonic-gate error = EFAULT; 4807c478bd9Sstevel@tonic-gate releasef(fildes); 4817c478bd9Sstevel@tonic-gate if (error != 0) 4827c478bd9Sstevel@tonic-gate return (set_errno(error)); 4837c478bd9Sstevel@tonic-gate return (count); 4847c478bd9Sstevel@tonic-gate } 4857c478bd9Sstevel@tonic-gate #endif 4867c478bd9Sstevel@tonic-gate 4877c478bd9Sstevel@tonic-gate int 4887c478bd9Sstevel@tonic-gate sendvec_small_chunk(file_t *fp, u_offset_t *fileoff, struct sendfilevec *sfv, 4897c478bd9Sstevel@tonic-gate int copy_cnt, ssize_t total_size, int maxblk, ssize_t *count) 4907c478bd9Sstevel@tonic-gate { 4917c478bd9Sstevel@tonic-gate struct vnode *vp; 4927c478bd9Sstevel@tonic-gate struct uio auio; 4937c478bd9Sstevel@tonic-gate struct iovec aiov; 4947c478bd9Sstevel@tonic-gate ushort_t fflag; 4957c478bd9Sstevel@tonic-gate int ioflag; 4967c478bd9Sstevel@tonic-gate int i, error; 4977c478bd9Sstevel@tonic-gate size_t cnt; 4987c478bd9Sstevel@tonic-gate ssize_t sfv_len; 4997c478bd9Sstevel@tonic-gate u_offset_t sfv_off; 5007c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 5017c478bd9Sstevel@tonic-gate model_t model = get_udatamodel(); 5027c478bd9Sstevel@tonic-gate u_offset_t maxoff = (model == DATAMODEL_ILP32) ? 5037c478bd9Sstevel@tonic-gate MAXOFF32_T : MAXOFFSET_T; 5047c478bd9Sstevel@tonic-gate #else 5057c478bd9Sstevel@tonic-gate const u_offset_t maxoff = MAXOFF32_T; 5067c478bd9Sstevel@tonic-gate #endif 5077c478bd9Sstevel@tonic-gate mblk_t *dmp = NULL; 5087c478bd9Sstevel@tonic-gate int wroff; 5097c478bd9Sstevel@tonic-gate int buf_left = 0; 5107c478bd9Sstevel@tonic-gate size_t iov_len; 5117c478bd9Sstevel@tonic-gate mblk_t *head, *tmp; 5127c478bd9Sstevel@tonic-gate size_t size = total_size; 513c28749e9Skais size_t extra; 514c28749e9Skais int tail_len; 5157c478bd9Sstevel@tonic-gate 5167c478bd9Sstevel@tonic-gate fflag = fp->f_flag; 5177c478bd9Sstevel@tonic-gate vp = fp->f_vnode; 5187c478bd9Sstevel@tonic-gate 5197c478bd9Sstevel@tonic-gate ASSERT(vp->v_type == VSOCK); 5207c478bd9Sstevel@tonic-gate ASSERT(maxblk > 0); 5217c478bd9Sstevel@tonic-gate 5227c478bd9Sstevel@tonic-gate wroff = (int)vp->v_stream->sd_wroff; 523c28749e9Skais tail_len = (int)vp->v_stream->sd_tail; 524c28749e9Skais extra = wroff + tail_len; 525c28749e9Skais 5267c478bd9Sstevel@tonic-gate buf_left = MIN(total_size, maxblk); 527c28749e9Skais head = dmp = allocb(buf_left + extra, BPRI_HI); 5287c478bd9Sstevel@tonic-gate if (head == NULL) 5297c478bd9Sstevel@tonic-gate return (ENOMEM); 5307c478bd9Sstevel@tonic-gate head->b_wptr = head->b_rptr = head->b_rptr + wroff; 5317c478bd9Sstevel@tonic-gate 5327c478bd9Sstevel@tonic-gate auio.uio_extflg = UIO_COPY_DEFAULT; 5337c478bd9Sstevel@tonic-gate for (i = 0; i < copy_cnt; i++) { 5347c478bd9Sstevel@tonic-gate if (ISSIG(curthread, JUSTLOOKING)) 5357c478bd9Sstevel@tonic-gate return (EINTR); 5367c478bd9Sstevel@tonic-gate 5377c478bd9Sstevel@tonic-gate /* 5387c478bd9Sstevel@tonic-gate * Do similar checks as "write" as we are writing 5397c478bd9Sstevel@tonic-gate * sfv_len bytes into "vp". 5407c478bd9Sstevel@tonic-gate */ 5417c478bd9Sstevel@tonic-gate sfv_len = (ssize_t)sfv->sfv_len; 5427c478bd9Sstevel@tonic-gate 5437c478bd9Sstevel@tonic-gate if (sfv_len == 0) { 5447c478bd9Sstevel@tonic-gate sfv++; 5457c478bd9Sstevel@tonic-gate continue; 5467c478bd9Sstevel@tonic-gate } 5477c478bd9Sstevel@tonic-gate 5487c478bd9Sstevel@tonic-gate /* Make sure sfv_len is not negative */ 5497c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 5507c478bd9Sstevel@tonic-gate if (model == DATAMODEL_ILP32) { 5517c478bd9Sstevel@tonic-gate if ((ssize32_t)sfv_len < 0) 5527c478bd9Sstevel@tonic-gate return (EINVAL); 5537c478bd9Sstevel@tonic-gate } else 5547c478bd9Sstevel@tonic-gate #endif 5557c478bd9Sstevel@tonic-gate if (sfv_len < 0) 5567c478bd9Sstevel@tonic-gate return (EINVAL); 5577c478bd9Sstevel@tonic-gate 5587c478bd9Sstevel@tonic-gate /* Check for overflow */ 5597c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 5607c478bd9Sstevel@tonic-gate if (model == DATAMODEL_ILP32) { 5617c478bd9Sstevel@tonic-gate if (((ssize32_t)(*count + sfv_len)) < 0) 5627c478bd9Sstevel@tonic-gate return (EINVAL); 5637c478bd9Sstevel@tonic-gate } else 5647c478bd9Sstevel@tonic-gate #endif 5657c478bd9Sstevel@tonic-gate if ((*count + sfv_len) < 0) 5667c478bd9Sstevel@tonic-gate return (EINVAL); 5677c478bd9Sstevel@tonic-gate 5687c478bd9Sstevel@tonic-gate sfv_off = (u_offset_t)(ulong_t)sfv->sfv_off; 5697c478bd9Sstevel@tonic-gate 5707c478bd9Sstevel@tonic-gate if (sfv->sfv_fd == SFV_FD_SELF) { 5717c478bd9Sstevel@tonic-gate while (sfv_len > 0) { 5727c478bd9Sstevel@tonic-gate if (buf_left == 0) { 5737c478bd9Sstevel@tonic-gate tmp = dmp; 5747c478bd9Sstevel@tonic-gate buf_left = MIN(total_size, maxblk); 5757c478bd9Sstevel@tonic-gate iov_len = MIN(buf_left, sfv_len); 576c28749e9Skais dmp = allocb(buf_left + extra, BPRI_HI); 5777c478bd9Sstevel@tonic-gate if (dmp == NULL) { 5787c478bd9Sstevel@tonic-gate freemsg(head); 5797c478bd9Sstevel@tonic-gate return (ENOMEM); 5807c478bd9Sstevel@tonic-gate } 5817c478bd9Sstevel@tonic-gate dmp->b_wptr = dmp->b_rptr = 5827c478bd9Sstevel@tonic-gate dmp->b_rptr + wroff; 5837c478bd9Sstevel@tonic-gate tmp->b_cont = dmp; 5847c478bd9Sstevel@tonic-gate } else { 5857c478bd9Sstevel@tonic-gate iov_len = MIN(buf_left, sfv_len); 5867c478bd9Sstevel@tonic-gate } 5877c478bd9Sstevel@tonic-gate 5887c478bd9Sstevel@tonic-gate aiov.iov_len = iov_len; 5897c478bd9Sstevel@tonic-gate aiov.iov_base = (caddr_t)(uintptr_t)sfv_off; 5907c478bd9Sstevel@tonic-gate auio.uio_loffset = *fileoff; 5917c478bd9Sstevel@tonic-gate auio.uio_iovcnt = 1; 5927c478bd9Sstevel@tonic-gate auio.uio_resid = iov_len; 5937c478bd9Sstevel@tonic-gate auio.uio_iov = &aiov; 5947c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_USERSPACE; 5957c478bd9Sstevel@tonic-gate auio.uio_llimit = curproc->p_fsz_ctl; 5967c478bd9Sstevel@tonic-gate auio.uio_fmode = fflag; 5977c478bd9Sstevel@tonic-gate 5987c478bd9Sstevel@tonic-gate buf_left -= iov_len; 5997c478bd9Sstevel@tonic-gate total_size -= iov_len; 6007c478bd9Sstevel@tonic-gate sfv_len -= iov_len; 6017c478bd9Sstevel@tonic-gate sfv_off += iov_len; 6027c478bd9Sstevel@tonic-gate 6037c478bd9Sstevel@tonic-gate error = uiomove((caddr_t)dmp->b_wptr, 6047c478bd9Sstevel@tonic-gate iov_len, UIO_WRITE, &auio); 6057c478bd9Sstevel@tonic-gate if (error != 0) { 6067c478bd9Sstevel@tonic-gate freemsg(head); 6077c478bd9Sstevel@tonic-gate return (error); 6087c478bd9Sstevel@tonic-gate } 6097c478bd9Sstevel@tonic-gate dmp->b_wptr += iov_len; 6107c478bd9Sstevel@tonic-gate } 6117c478bd9Sstevel@tonic-gate } else { 6127c478bd9Sstevel@tonic-gate file_t *ffp; 6137c478bd9Sstevel@tonic-gate vnode_t *readvp; 6147c478bd9Sstevel@tonic-gate 6157c478bd9Sstevel@tonic-gate if ((ffp = getf(sfv->sfv_fd)) == NULL) { 6167c478bd9Sstevel@tonic-gate freemsg(head); 6177c478bd9Sstevel@tonic-gate return (EBADF); 6187c478bd9Sstevel@tonic-gate } 6197c478bd9Sstevel@tonic-gate 6207c478bd9Sstevel@tonic-gate if ((ffp->f_flag & FREAD) == 0) { 6217c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 6227c478bd9Sstevel@tonic-gate freemsg(head); 6237c478bd9Sstevel@tonic-gate return (EACCES); 6247c478bd9Sstevel@tonic-gate } 6257c478bd9Sstevel@tonic-gate 6267c478bd9Sstevel@tonic-gate readvp = ffp->f_vnode; 6277c478bd9Sstevel@tonic-gate if (readvp->v_type != VREG) { 6287c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 6297c478bd9Sstevel@tonic-gate freemsg(head); 6307c478bd9Sstevel@tonic-gate return (EINVAL); 6317c478bd9Sstevel@tonic-gate } 6327c478bd9Sstevel@tonic-gate 6337c478bd9Sstevel@tonic-gate /* 6347c478bd9Sstevel@tonic-gate * No point reading and writing to same vp, 6357c478bd9Sstevel@tonic-gate * as long as both are regular files. readvp is not 6367c478bd9Sstevel@tonic-gate * locked; but since we got it from an open file the 6377c478bd9Sstevel@tonic-gate * contents will be valid during the time of access. 6387c478bd9Sstevel@tonic-gate */ 6397c478bd9Sstevel@tonic-gate 640*bfb244baSpr if (vn_compare(vp, readvp)) { 6417c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 6427c478bd9Sstevel@tonic-gate freemsg(head); 6437c478bd9Sstevel@tonic-gate return (EINVAL); 6447c478bd9Sstevel@tonic-gate } 6457c478bd9Sstevel@tonic-gate 6467c478bd9Sstevel@tonic-gate /* 6477c478bd9Sstevel@tonic-gate * Note: we assume readvp != vp. "vp" is already 6487c478bd9Sstevel@tonic-gate * locked, and "readvp" must not be. 6497c478bd9Sstevel@tonic-gate */ 6507c478bd9Sstevel@tonic-gate 6517c478bd9Sstevel@tonic-gate (void) VOP_RWLOCK(readvp, readflg, NULL); 6527c478bd9Sstevel@tonic-gate 6537c478bd9Sstevel@tonic-gate /* Same checks as in pread */ 6547c478bd9Sstevel@tonic-gate if (sfv_off > maxoff) { 6557c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 6567c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 6577c478bd9Sstevel@tonic-gate freemsg(head); 6587c478bd9Sstevel@tonic-gate return (EINVAL); 6597c478bd9Sstevel@tonic-gate } 6607c478bd9Sstevel@tonic-gate if (sfv_off + sfv_len > maxoff) { 6610a8433caSrshoaib total_size -= (sfv_off + sfv_len - maxoff); 6627c478bd9Sstevel@tonic-gate sfv_len = (ssize_t)((offset_t)maxoff - 6637c478bd9Sstevel@tonic-gate sfv_off); 6647c478bd9Sstevel@tonic-gate } 6657c478bd9Sstevel@tonic-gate 6667c478bd9Sstevel@tonic-gate while (sfv_len > 0) { 6677c478bd9Sstevel@tonic-gate if (buf_left == 0) { 6687c478bd9Sstevel@tonic-gate tmp = dmp; 6697c478bd9Sstevel@tonic-gate buf_left = MIN(total_size, maxblk); 6707c478bd9Sstevel@tonic-gate iov_len = MIN(buf_left, sfv_len); 671c28749e9Skais dmp = allocb(buf_left + extra, BPRI_HI); 6727c478bd9Sstevel@tonic-gate if (dmp == NULL) { 6737c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, 6747c478bd9Sstevel@tonic-gate NULL); 6757c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 6767c478bd9Sstevel@tonic-gate freemsg(head); 6777c478bd9Sstevel@tonic-gate return (ENOMEM); 6787c478bd9Sstevel@tonic-gate } 6797c478bd9Sstevel@tonic-gate dmp->b_wptr = dmp->b_rptr = 6807c478bd9Sstevel@tonic-gate dmp->b_rptr + wroff; 6817c478bd9Sstevel@tonic-gate tmp->b_cont = dmp; 6827c478bd9Sstevel@tonic-gate } else { 6837c478bd9Sstevel@tonic-gate iov_len = MIN(buf_left, sfv_len); 6847c478bd9Sstevel@tonic-gate } 6857c478bd9Sstevel@tonic-gate aiov.iov_base = (caddr_t)dmp->b_wptr; 6867c478bd9Sstevel@tonic-gate aiov.iov_len = iov_len; 6877c478bd9Sstevel@tonic-gate auio.uio_loffset = sfv_off; 6887c478bd9Sstevel@tonic-gate auio.uio_iov = &aiov; 6897c478bd9Sstevel@tonic-gate auio.uio_iovcnt = 1; 6907c478bd9Sstevel@tonic-gate auio.uio_resid = iov_len; 6917c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_SYSSPACE; 6927c478bd9Sstevel@tonic-gate auio.uio_llimit = MAXOFFSET_T; 6937c478bd9Sstevel@tonic-gate auio.uio_fmode = ffp->f_flag; 6947c478bd9Sstevel@tonic-gate ioflag = auio.uio_fmode & 6957c478bd9Sstevel@tonic-gate (FAPPEND|FSYNC|FDSYNC|FRSYNC); 6967c478bd9Sstevel@tonic-gate 6977c478bd9Sstevel@tonic-gate /* 6987c478bd9Sstevel@tonic-gate * If read sync is not asked for, 6997c478bd9Sstevel@tonic-gate * filter sync flags 7007c478bd9Sstevel@tonic-gate */ 7017c478bd9Sstevel@tonic-gate if ((ioflag & FRSYNC) == 0) 7027c478bd9Sstevel@tonic-gate ioflag &= ~(FSYNC|FDSYNC); 7037c478bd9Sstevel@tonic-gate error = VOP_READ(readvp, &auio, ioflag, 7047c478bd9Sstevel@tonic-gate fp->f_cred, NULL); 7057c478bd9Sstevel@tonic-gate if (error != 0) { 7067c478bd9Sstevel@tonic-gate /* 7077c478bd9Sstevel@tonic-gate * If we were reading a pipe (currently 7087c478bd9Sstevel@tonic-gate * not implemented), we may now loose 7097c478bd9Sstevel@tonic-gate * data. 7107c478bd9Sstevel@tonic-gate */ 7117c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 7127c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 7137c478bd9Sstevel@tonic-gate freemsg(head); 7147c478bd9Sstevel@tonic-gate return (error); 7157c478bd9Sstevel@tonic-gate } 7167c478bd9Sstevel@tonic-gate 7177c478bd9Sstevel@tonic-gate /* 7187c478bd9Sstevel@tonic-gate * Check how much data was really read. 7197c478bd9Sstevel@tonic-gate * Decrement the 'len' and increment the 7207c478bd9Sstevel@tonic-gate * 'off' appropriately. 7217c478bd9Sstevel@tonic-gate */ 7227c478bd9Sstevel@tonic-gate cnt = iov_len - auio.uio_resid; 7237c478bd9Sstevel@tonic-gate if (cnt == 0) { 7247c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 7257c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 7267c478bd9Sstevel@tonic-gate freemsg(head); 7277c478bd9Sstevel@tonic-gate return (EINVAL); 7287c478bd9Sstevel@tonic-gate } 7297c478bd9Sstevel@tonic-gate sfv_len -= cnt; 7307c478bd9Sstevel@tonic-gate sfv_off += cnt; 7317c478bd9Sstevel@tonic-gate total_size -= cnt; 7327c478bd9Sstevel@tonic-gate buf_left -= cnt; 7337c478bd9Sstevel@tonic-gate 7347c478bd9Sstevel@tonic-gate dmp->b_wptr += cnt; 7357c478bd9Sstevel@tonic-gate } 7367c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 7377c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 7387c478bd9Sstevel@tonic-gate } 7397c478bd9Sstevel@tonic-gate sfv++; 7407c478bd9Sstevel@tonic-gate } 7417c478bd9Sstevel@tonic-gate 7427c478bd9Sstevel@tonic-gate ASSERT(total_size == 0); 7437c478bd9Sstevel@tonic-gate error = kstrwritemp(vp, head, fflag); 7447c478bd9Sstevel@tonic-gate if (error != 0) { 7457c478bd9Sstevel@tonic-gate freemsg(head); 7467c478bd9Sstevel@tonic-gate return (error); 7477c478bd9Sstevel@tonic-gate } 7487c478bd9Sstevel@tonic-gate ttolwp(curthread)->lwp_ru.ioch += (ulong_t)size; 7497c478bd9Sstevel@tonic-gate *count += size; 7507c478bd9Sstevel@tonic-gate 7517c478bd9Sstevel@tonic-gate return (0); 7527c478bd9Sstevel@tonic-gate } 7537c478bd9Sstevel@tonic-gate 7547c478bd9Sstevel@tonic-gate 7557c478bd9Sstevel@tonic-gate int 7567c478bd9Sstevel@tonic-gate sendvec_chunk(file_t *fp, u_offset_t *fileoff, struct sendfilevec *sfv, 7577c478bd9Sstevel@tonic-gate int copy_cnt, ssize_t *count) 7587c478bd9Sstevel@tonic-gate { 7597c478bd9Sstevel@tonic-gate struct vnode *vp; 7607c478bd9Sstevel@tonic-gate struct uio auio; 7617c478bd9Sstevel@tonic-gate struct iovec aiov; 7627c478bd9Sstevel@tonic-gate ushort_t fflag; 7637c478bd9Sstevel@tonic-gate int ioflag; 7647c478bd9Sstevel@tonic-gate int i, error; 7657c478bd9Sstevel@tonic-gate size_t cnt; 7667c478bd9Sstevel@tonic-gate ssize_t sfv_len; 7677c478bd9Sstevel@tonic-gate u_offset_t sfv_off; 7687c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 7697c478bd9Sstevel@tonic-gate model_t model = get_udatamodel(); 7707c478bd9Sstevel@tonic-gate u_offset_t maxoff = (model == DATAMODEL_ILP32) ? 7717c478bd9Sstevel@tonic-gate MAXOFF32_T : MAXOFFSET_T; 7727c478bd9Sstevel@tonic-gate #else 7737c478bd9Sstevel@tonic-gate const u_offset_t maxoff = MAXOFF32_T; 7747c478bd9Sstevel@tonic-gate #endif 7751574ae68Sjohansen mblk_t *dmp = NULL; 7761574ae68Sjohansen char *buf = NULL; 777c28749e9Skais size_t extra; 778c28749e9Skais int maxblk, wroff, tail_len; 779c28749e9Skais struct sonode *so; 780c28749e9Skais stdata_t *stp; 7817c478bd9Sstevel@tonic-gate 7827c478bd9Sstevel@tonic-gate fflag = fp->f_flag; 7837c478bd9Sstevel@tonic-gate vp = fp->f_vnode; 7847c478bd9Sstevel@tonic-gate 785c28749e9Skais if (vp->v_type == VSOCK) { 786c28749e9Skais so = VTOSO(vp); 787c28749e9Skais stp = vp->v_stream; 788c28749e9Skais wroff = (int)stp->sd_wroff; 789c28749e9Skais tail_len = (int)stp->sd_tail; 790c28749e9Skais maxblk = (int)stp->sd_maxblk; 791c28749e9Skais extra = wroff + tail_len; 792c28749e9Skais } 793c28749e9Skais 7947c478bd9Sstevel@tonic-gate auio.uio_extflg = UIO_COPY_DEFAULT; 7957c478bd9Sstevel@tonic-gate for (i = 0; i < copy_cnt; i++) { 7967c478bd9Sstevel@tonic-gate if (ISSIG(curthread, JUSTLOOKING)) 7977c478bd9Sstevel@tonic-gate return (EINTR); 7987c478bd9Sstevel@tonic-gate 7997c478bd9Sstevel@tonic-gate /* 8007c478bd9Sstevel@tonic-gate * Do similar checks as "write" as we are writing 8017c478bd9Sstevel@tonic-gate * sfv_len bytes into "vp". 8027c478bd9Sstevel@tonic-gate */ 8037c478bd9Sstevel@tonic-gate sfv_len = (ssize_t)sfv->sfv_len; 8047c478bd9Sstevel@tonic-gate 8057c478bd9Sstevel@tonic-gate if (sfv_len == 0) { 8067c478bd9Sstevel@tonic-gate sfv++; 8077c478bd9Sstevel@tonic-gate continue; 8087c478bd9Sstevel@tonic-gate } 8097c478bd9Sstevel@tonic-gate 8107c478bd9Sstevel@tonic-gate /* Make sure sfv_len is not negative */ 8117c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 8127c478bd9Sstevel@tonic-gate if (model == DATAMODEL_ILP32) { 8137c478bd9Sstevel@tonic-gate if ((ssize32_t)sfv_len < 0) 8147c478bd9Sstevel@tonic-gate return (EINVAL); 8157c478bd9Sstevel@tonic-gate } else 8167c478bd9Sstevel@tonic-gate #endif 8177c478bd9Sstevel@tonic-gate if (sfv_len < 0) 8187c478bd9Sstevel@tonic-gate return (EINVAL); 8197c478bd9Sstevel@tonic-gate 8207c478bd9Sstevel@tonic-gate if (vp->v_type == VREG) { 8217c478bd9Sstevel@tonic-gate if (*fileoff >= curproc->p_fsz_ctl) { 8227c478bd9Sstevel@tonic-gate mutex_enter(&curproc->p_lock); 8237c478bd9Sstevel@tonic-gate (void) rctl_action( 8247c478bd9Sstevel@tonic-gate rctlproc_legacy[RLIMIT_FSIZE], 8257c478bd9Sstevel@tonic-gate curproc->p_rctls, curproc, RCA_SAFE); 8267c478bd9Sstevel@tonic-gate mutex_exit(&curproc->p_lock); 8277c478bd9Sstevel@tonic-gate 8287c478bd9Sstevel@tonic-gate return (EFBIG); 8297c478bd9Sstevel@tonic-gate } 8307c478bd9Sstevel@tonic-gate 8317c478bd9Sstevel@tonic-gate if (*fileoff >= maxoff) 8327c478bd9Sstevel@tonic-gate return (EFBIG); 8337c478bd9Sstevel@tonic-gate 8347c478bd9Sstevel@tonic-gate if (*fileoff + sfv_len > maxoff) 8357c478bd9Sstevel@tonic-gate return (EINVAL); 8367c478bd9Sstevel@tonic-gate } 8377c478bd9Sstevel@tonic-gate 8387c478bd9Sstevel@tonic-gate /* Check for overflow */ 8397c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 8407c478bd9Sstevel@tonic-gate if (model == DATAMODEL_ILP32) { 8417c478bd9Sstevel@tonic-gate if (((ssize32_t)(*count + sfv_len)) < 0) 8427c478bd9Sstevel@tonic-gate return (EINVAL); 8437c478bd9Sstevel@tonic-gate } else 8447c478bd9Sstevel@tonic-gate #endif 8457c478bd9Sstevel@tonic-gate if ((*count + sfv_len) < 0) 8467c478bd9Sstevel@tonic-gate return (EINVAL); 8477c478bd9Sstevel@tonic-gate 8487c478bd9Sstevel@tonic-gate sfv_off = (u_offset_t)(ulong_t)sfv->sfv_off; 8497c478bd9Sstevel@tonic-gate 8507c478bd9Sstevel@tonic-gate if (sfv->sfv_fd == SFV_FD_SELF) { 8517c478bd9Sstevel@tonic-gate aiov.iov_len = sfv_len; 8527c478bd9Sstevel@tonic-gate aiov.iov_base = (caddr_t)(uintptr_t)sfv_off; 8537c478bd9Sstevel@tonic-gate auio.uio_loffset = *fileoff; 8547c478bd9Sstevel@tonic-gate auio.uio_iovcnt = 1; 8557c478bd9Sstevel@tonic-gate auio.uio_resid = sfv_len; 8567c478bd9Sstevel@tonic-gate auio.uio_iov = &aiov; 8577c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_USERSPACE; 8587c478bd9Sstevel@tonic-gate auio.uio_llimit = curproc->p_fsz_ctl; 8597c478bd9Sstevel@tonic-gate auio.uio_fmode = fflag; 8607c478bd9Sstevel@tonic-gate 8617c478bd9Sstevel@tonic-gate if (vp->v_type == VSOCK) { 8627c478bd9Sstevel@tonic-gate 8637c478bd9Sstevel@tonic-gate /* 8647c478bd9Sstevel@tonic-gate * Optimize for the socket case 8657c478bd9Sstevel@tonic-gate */ 8667c478bd9Sstevel@tonic-gate 867c28749e9Skais dmp = allocb(sfv_len + extra, BPRI_HI); 8687c478bd9Sstevel@tonic-gate if (dmp == NULL) 8697c478bd9Sstevel@tonic-gate return (ENOMEM); 8707c478bd9Sstevel@tonic-gate dmp->b_wptr = dmp->b_rptr = dmp->b_rptr + wroff; 8717c478bd9Sstevel@tonic-gate error = uiomove((caddr_t)dmp->b_wptr, 8727c478bd9Sstevel@tonic-gate sfv_len, UIO_WRITE, &auio); 8737c478bd9Sstevel@tonic-gate if (error != 0) { 8747c478bd9Sstevel@tonic-gate freeb(dmp); 8757c478bd9Sstevel@tonic-gate return (error); 8767c478bd9Sstevel@tonic-gate } 8777c478bd9Sstevel@tonic-gate dmp->b_wptr += sfv_len; 8787c478bd9Sstevel@tonic-gate error = kstrwritemp(vp, dmp, fflag); 8797c478bd9Sstevel@tonic-gate if (error != 0) { 8807c478bd9Sstevel@tonic-gate freeb(dmp); 8817c478bd9Sstevel@tonic-gate return (error); 8827c478bd9Sstevel@tonic-gate } 8837c478bd9Sstevel@tonic-gate ttolwp(curthread)->lwp_ru.ioch += 8847c478bd9Sstevel@tonic-gate (ulong_t)sfv_len; 8857c478bd9Sstevel@tonic-gate *count += sfv_len; 8867c478bd9Sstevel@tonic-gate } else { 8877c478bd9Sstevel@tonic-gate ioflag = auio.uio_fmode & 8887c478bd9Sstevel@tonic-gate (FAPPEND|FSYNC|FDSYNC|FRSYNC); 8897c478bd9Sstevel@tonic-gate while (sfv_len > 0) { 8907c478bd9Sstevel@tonic-gate error = VOP_WRITE(vp, &auio, ioflag, 8917c478bd9Sstevel@tonic-gate fp->f_cred, NULL); 8927c478bd9Sstevel@tonic-gate cnt = sfv_len - auio.uio_resid; 8937c478bd9Sstevel@tonic-gate sfv_len -= cnt; 8947c478bd9Sstevel@tonic-gate ttolwp(curthread)->lwp_ru.ioch += 8957c478bd9Sstevel@tonic-gate (ulong_t)cnt; 8967c478bd9Sstevel@tonic-gate *fileoff += cnt; 8977c478bd9Sstevel@tonic-gate *count += cnt; 8987c478bd9Sstevel@tonic-gate if (error != 0) 8997c478bd9Sstevel@tonic-gate return (error); 9007c478bd9Sstevel@tonic-gate } 9017c478bd9Sstevel@tonic-gate } 9027c478bd9Sstevel@tonic-gate } else { 9037f9ee850Sblu int segmapit = 0; 9047c478bd9Sstevel@tonic-gate file_t *ffp; 9057c478bd9Sstevel@tonic-gate vnode_t *readvp; 906*bfb244baSpr struct vnode *realvp; 9077c478bd9Sstevel@tonic-gate size_t size; 9087c478bd9Sstevel@tonic-gate caddr_t ptr; 9097c478bd9Sstevel@tonic-gate 9107c478bd9Sstevel@tonic-gate if ((ffp = getf(sfv->sfv_fd)) == NULL) 9117c478bd9Sstevel@tonic-gate return (EBADF); 9127c478bd9Sstevel@tonic-gate 9137c478bd9Sstevel@tonic-gate if ((ffp->f_flag & FREAD) == 0) { 9147c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 9157c478bd9Sstevel@tonic-gate return (EBADF); 9167c478bd9Sstevel@tonic-gate } 9177c478bd9Sstevel@tonic-gate 9187c478bd9Sstevel@tonic-gate readvp = ffp->f_vnode; 919*bfb244baSpr if (VOP_REALVP(readvp, &realvp) == 0) 920*bfb244baSpr readvp = realvp; 9217c478bd9Sstevel@tonic-gate if (readvp->v_type != VREG) { 9227c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 9237c478bd9Sstevel@tonic-gate return (EINVAL); 9247c478bd9Sstevel@tonic-gate } 9257c478bd9Sstevel@tonic-gate 9267c478bd9Sstevel@tonic-gate /* 9277c478bd9Sstevel@tonic-gate * No point reading and writing to same vp, 9287c478bd9Sstevel@tonic-gate * as long as both are regular files. readvp is not 9297c478bd9Sstevel@tonic-gate * locked; but since we got it from an open file the 9307c478bd9Sstevel@tonic-gate * contents will be valid during the time of access. 9317c478bd9Sstevel@tonic-gate */ 932*bfb244baSpr if (vn_compare(vp, readvp)) { 9337c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 9347c478bd9Sstevel@tonic-gate return (EINVAL); 9357c478bd9Sstevel@tonic-gate } 9367c478bd9Sstevel@tonic-gate 9377c478bd9Sstevel@tonic-gate /* 9387c478bd9Sstevel@tonic-gate * Note: we assume readvp != vp. "vp" is already 9397c478bd9Sstevel@tonic-gate * locked, and "readvp" must not be. 9407c478bd9Sstevel@tonic-gate */ 9417c478bd9Sstevel@tonic-gate (void) VOP_RWLOCK(readvp, readflg, NULL); 9427c478bd9Sstevel@tonic-gate 9437c478bd9Sstevel@tonic-gate /* Same checks as in pread */ 9447c478bd9Sstevel@tonic-gate if (sfv_off > maxoff) { 9457c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 9467c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 9477c478bd9Sstevel@tonic-gate return (EINVAL); 9487c478bd9Sstevel@tonic-gate } 9497c478bd9Sstevel@tonic-gate if (sfv_off + sfv_len > maxoff) { 9507c478bd9Sstevel@tonic-gate sfv_len = (ssize_t)((offset_t)maxoff - 9517c478bd9Sstevel@tonic-gate sfv_off); 9527c478bd9Sstevel@tonic-gate } 9537c478bd9Sstevel@tonic-gate /* Find the native blocksize to transfer data */ 9547c478bd9Sstevel@tonic-gate size = MIN(vp->v_vfsp->vfs_bsize, 9557c478bd9Sstevel@tonic-gate readvp->v_vfsp->vfs_bsize); 9567c478bd9Sstevel@tonic-gate size = sfv_len < size ? sfv_len : size; 9577c478bd9Sstevel@tonic-gate 9581574ae68Sjohansen if (vp->v_type != VSOCK) { 95974024373Spr segmapit = 0; 9601574ae68Sjohansen buf = kmem_alloc(size, KM_NOSLEEP); 9611574ae68Sjohansen if (buf == NULL) { 9621574ae68Sjohansen VOP_RWUNLOCK(readvp, readflg, NULL); 9631574ae68Sjohansen releasef(sfv->sfv_fd); 9641574ae68Sjohansen return (ENOMEM); 9651574ae68Sjohansen } 966c28749e9Skais } else { 967c28749e9Skais /* 968c28749e9Skais * For sockets acting as an SSL proxy, we 969c28749e9Skais * need to adjust the size to the maximum 970c28749e9Skais * SSL record size set in the stream head. 971c28749e9Skais */ 972c28749e9Skais if (so->so_kssl_ctx != NULL) 973c28749e9Skais size = MIN(size, maxblk); 97474024373Spr 97574024373Spr if (vn_has_flocks(readvp) || 97674024373Spr readvp->v_flag & VNOMAP || 97774024373Spr stp->sd_copyflag & STZCVMUNSAFE) { 97874024373Spr segmapit = 0; 97974024373Spr } else if (stp->sd_copyflag & STZCVMSAFE) { 98074024373Spr segmapit = 1; 98174024373Spr } else { 98274024373Spr int on = 1; 98374024373Spr if (SOP_SETSOCKOPT(VTOSO(vp), 98474024373Spr SOL_SOCKET, SO_SND_COPYAVOID, 98574024373Spr &on, sizeof (on)) == 0) 98674024373Spr segmapit = 1; 98774024373Spr } 98874024373Spr } 98974024373Spr 99074024373Spr if (segmapit) { 99174024373Spr boolean_t nowait; 99274024373Spr uint_t maxpsz; 99374024373Spr 99474024373Spr nowait = (sfv->sfv_flag & SFV_NOWAIT) != 0; 99574024373Spr maxpsz = stp->sd_qn_maxpsz; 99674024373Spr if (maxpsz == INFPSZ) 99774024373Spr maxpsz = maxphys; 99874024373Spr maxpsz = roundup(maxpsz, MAXBSIZE); 99974024373Spr error = snf_segmap(fp, readvp, sfv_off, 100074024373Spr (u_offset_t)sfv_len, maxpsz, 100174024373Spr (ssize_t *)&cnt, nowait); 100274024373Spr releasef(sfv->sfv_fd); 100374024373Spr *count += cnt; 100474024373Spr if (error) 100574024373Spr return (error); 100674024373Spr sfv++; 100774024373Spr continue; 10081574ae68Sjohansen } 10091574ae68Sjohansen 10107c478bd9Sstevel@tonic-gate while (sfv_len > 0) { 10117c478bd9Sstevel@tonic-gate size_t iov_len; 10127c478bd9Sstevel@tonic-gate 10137c478bd9Sstevel@tonic-gate iov_len = MIN(size, sfv_len); 10147c478bd9Sstevel@tonic-gate 10151574ae68Sjohansen if (vp->v_type == VSOCK) { 1016c28749e9Skais dmp = allocb(iov_len + extra, BPRI_HI); 10171574ae68Sjohansen if (dmp == NULL) { 10181574ae68Sjohansen VOP_RWUNLOCK(readvp, readflg, 10191574ae68Sjohansen NULL); 10201574ae68Sjohansen releasef(sfv->sfv_fd); 10211574ae68Sjohansen return (ENOMEM); 10221574ae68Sjohansen } 1023c28749e9Skais dmp->b_wptr = dmp->b_rptr = 1024c28749e9Skais dmp->b_rptr + wroff; 10251574ae68Sjohansen ptr = (caddr_t)dmp->b_rptr; 10261574ae68Sjohansen } else { 10271574ae68Sjohansen ptr = buf; 10287c478bd9Sstevel@tonic-gate } 10297c478bd9Sstevel@tonic-gate 10307c478bd9Sstevel@tonic-gate aiov.iov_base = ptr; 10317c478bd9Sstevel@tonic-gate aiov.iov_len = iov_len; 10327c478bd9Sstevel@tonic-gate auio.uio_loffset = sfv_off; 10337c478bd9Sstevel@tonic-gate auio.uio_iov = &aiov; 10347c478bd9Sstevel@tonic-gate auio.uio_iovcnt = 1; 10357c478bd9Sstevel@tonic-gate auio.uio_resid = iov_len; 10367c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_SYSSPACE; 10377c478bd9Sstevel@tonic-gate auio.uio_llimit = MAXOFFSET_T; 10387c478bd9Sstevel@tonic-gate auio.uio_fmode = ffp->f_flag; 10397c478bd9Sstevel@tonic-gate ioflag = auio.uio_fmode & 10407c478bd9Sstevel@tonic-gate (FAPPEND|FSYNC|FDSYNC|FRSYNC); 10417c478bd9Sstevel@tonic-gate 10427c478bd9Sstevel@tonic-gate /* 10437c478bd9Sstevel@tonic-gate * If read sync is not asked for, 10447c478bd9Sstevel@tonic-gate * filter sync flags 10457c478bd9Sstevel@tonic-gate */ 10467c478bd9Sstevel@tonic-gate if ((ioflag & FRSYNC) == 0) 10477c478bd9Sstevel@tonic-gate ioflag &= ~(FSYNC|FDSYNC); 10487c478bd9Sstevel@tonic-gate error = VOP_READ(readvp, &auio, ioflag, 10497c478bd9Sstevel@tonic-gate fp->f_cred, NULL); 10507c478bd9Sstevel@tonic-gate if (error != 0) { 10517c478bd9Sstevel@tonic-gate /* 10527c478bd9Sstevel@tonic-gate * If we were reading a pipe (currently 10537c478bd9Sstevel@tonic-gate * not implemented), we may now lose 10547c478bd9Sstevel@tonic-gate * data. 10557c478bd9Sstevel@tonic-gate */ 10561574ae68Sjohansen if (vp->v_type == VSOCK) 10571574ae68Sjohansen freeb(dmp); 10581574ae68Sjohansen else 10591574ae68Sjohansen kmem_free(buf, size); 10607c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 10617c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 10627c478bd9Sstevel@tonic-gate return (error); 10637c478bd9Sstevel@tonic-gate } 10647c478bd9Sstevel@tonic-gate 10657c478bd9Sstevel@tonic-gate /* 10667c478bd9Sstevel@tonic-gate * Check how much data was really read. 10677c478bd9Sstevel@tonic-gate * Decrement the 'len' and increment the 10687c478bd9Sstevel@tonic-gate * 'off' appropriately. 10697c478bd9Sstevel@tonic-gate */ 10707c478bd9Sstevel@tonic-gate cnt = iov_len - auio.uio_resid; 10717c478bd9Sstevel@tonic-gate if (cnt == 0) { 10721574ae68Sjohansen if (vp->v_type == VSOCK) 10731574ae68Sjohansen freeb(dmp); 10741574ae68Sjohansen else 10751574ae68Sjohansen kmem_free(buf, size); 10767c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 10777c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 10787c478bd9Sstevel@tonic-gate return (EINVAL); 10797c478bd9Sstevel@tonic-gate } 10807c478bd9Sstevel@tonic-gate sfv_len -= cnt; 10817c478bd9Sstevel@tonic-gate sfv_off += cnt; 10827c478bd9Sstevel@tonic-gate 10837c478bd9Sstevel@tonic-gate if (vp->v_type == VSOCK) { 10847c478bd9Sstevel@tonic-gate dmp->b_wptr = dmp->b_rptr + cnt; 10857c478bd9Sstevel@tonic-gate 10867c478bd9Sstevel@tonic-gate error = kstrwritemp(vp, dmp, fflag); 10877c478bd9Sstevel@tonic-gate if (error != 0) { 10887c478bd9Sstevel@tonic-gate freeb(dmp); 10897c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, 10907c478bd9Sstevel@tonic-gate NULL); 10917c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 10927c478bd9Sstevel@tonic-gate return (error); 10937c478bd9Sstevel@tonic-gate } 10947c478bd9Sstevel@tonic-gate 10957c478bd9Sstevel@tonic-gate ttolwp(curthread)->lwp_ru.ioch += 10967c478bd9Sstevel@tonic-gate (ulong_t)cnt; 10977c478bd9Sstevel@tonic-gate *count += cnt; 10987c478bd9Sstevel@tonic-gate } else { 10997c478bd9Sstevel@tonic-gate 11007c478bd9Sstevel@tonic-gate aiov.iov_base = ptr; 11017c478bd9Sstevel@tonic-gate aiov.iov_len = cnt; 11027c478bd9Sstevel@tonic-gate auio.uio_loffset = *fileoff; 11037c478bd9Sstevel@tonic-gate auio.uio_resid = cnt; 11047c478bd9Sstevel@tonic-gate auio.uio_segflg = UIO_SYSSPACE; 11057c478bd9Sstevel@tonic-gate auio.uio_llimit = curproc->p_fsz_ctl; 11067c478bd9Sstevel@tonic-gate auio.uio_fmode = fflag; 11077c478bd9Sstevel@tonic-gate ioflag = auio.uio_fmode & 11087c478bd9Sstevel@tonic-gate (FAPPEND|FSYNC|FDSYNC|FRSYNC); 11097c478bd9Sstevel@tonic-gate error = VOP_WRITE(vp, &auio, ioflag, 11107c478bd9Sstevel@tonic-gate fp->f_cred, NULL); 11117c478bd9Sstevel@tonic-gate 11127c478bd9Sstevel@tonic-gate /* 11137c478bd9Sstevel@tonic-gate * Check how much data was written. 11147c478bd9Sstevel@tonic-gate * Increment the 'len' and decrement the 11157c478bd9Sstevel@tonic-gate * 'off' if all the data was not 11167c478bd9Sstevel@tonic-gate * written. 11177c478bd9Sstevel@tonic-gate */ 11187c478bd9Sstevel@tonic-gate cnt -= auio.uio_resid; 11197c478bd9Sstevel@tonic-gate sfv_len += auio.uio_resid; 11207c478bd9Sstevel@tonic-gate sfv_off -= auio.uio_resid; 11217c478bd9Sstevel@tonic-gate ttolwp(curthread)->lwp_ru.ioch += 11227c478bd9Sstevel@tonic-gate (ulong_t)cnt; 11237c478bd9Sstevel@tonic-gate *fileoff += cnt; 11247c478bd9Sstevel@tonic-gate *count += cnt; 11257c478bd9Sstevel@tonic-gate if (error != 0) { 11262db6c79fSstevel kmem_free(buf, size); 11277c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, 11287c478bd9Sstevel@tonic-gate NULL); 11297c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 11307c478bd9Sstevel@tonic-gate return (error); 11317c478bd9Sstevel@tonic-gate } 11327c478bd9Sstevel@tonic-gate } 11337c478bd9Sstevel@tonic-gate } 11341574ae68Sjohansen if (buf) { 11351574ae68Sjohansen kmem_free(buf, size); 11361574ae68Sjohansen buf = NULL; 11371574ae68Sjohansen } 11387c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(readvp, readflg, NULL); 11397c478bd9Sstevel@tonic-gate releasef(sfv->sfv_fd); 11407c478bd9Sstevel@tonic-gate } 11417c478bd9Sstevel@tonic-gate sfv++; 11427c478bd9Sstevel@tonic-gate } 11437c478bd9Sstevel@tonic-gate return (0); 11447c478bd9Sstevel@tonic-gate } 11457c478bd9Sstevel@tonic-gate 11467c478bd9Sstevel@tonic-gate ssize_t 11477c478bd9Sstevel@tonic-gate sendfilev(int opcode, int fildes, const struct sendfilevec *vec, int sfvcnt, 11487c478bd9Sstevel@tonic-gate size_t *xferred) 11497c478bd9Sstevel@tonic-gate { 11507c478bd9Sstevel@tonic-gate int error; 11517c478bd9Sstevel@tonic-gate file_t *fp; 11527c478bd9Sstevel@tonic-gate struct vnode *vp; 11537c478bd9Sstevel@tonic-gate struct sonode *so; 11547c478bd9Sstevel@tonic-gate u_offset_t fileoff; 11557c478bd9Sstevel@tonic-gate int copy_cnt; 11567c478bd9Sstevel@tonic-gate const struct sendfilevec *copy_vec; 11577c478bd9Sstevel@tonic-gate struct sendfilevec sfv[SEND_MAX_CHUNK]; 11587c478bd9Sstevel@tonic-gate ssize_t count = 0; 11597c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 11607c478bd9Sstevel@tonic-gate struct ksendfilevec32 sfv32[SEND_MAX_CHUNK]; 11617c478bd9Sstevel@tonic-gate #endif 11620a8433caSrshoaib ssize_t total_size; 11637c478bd9Sstevel@tonic-gate int i; 11647c478bd9Sstevel@tonic-gate boolean_t is_sock = B_FALSE; 11657c478bd9Sstevel@tonic-gate int maxblk = 0; 11667c478bd9Sstevel@tonic-gate 11677c478bd9Sstevel@tonic-gate if (sfvcnt <= 0) 11687c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 11697c478bd9Sstevel@tonic-gate 11707c478bd9Sstevel@tonic-gate if ((fp = getf(fildes)) == NULL) 11717c478bd9Sstevel@tonic-gate return (set_errno(EBADF)); 11727c478bd9Sstevel@tonic-gate 11737c478bd9Sstevel@tonic-gate if (((fp->f_flag) & FWRITE) == 0) { 11747c478bd9Sstevel@tonic-gate error = EBADF; 11757c478bd9Sstevel@tonic-gate goto err; 11767c478bd9Sstevel@tonic-gate } 11777c478bd9Sstevel@tonic-gate 11787c478bd9Sstevel@tonic-gate fileoff = fp->f_offset; 11797c478bd9Sstevel@tonic-gate vp = fp->f_vnode; 11807c478bd9Sstevel@tonic-gate 11817c478bd9Sstevel@tonic-gate switch (vp->v_type) { 11827c478bd9Sstevel@tonic-gate case VSOCK: 11837c478bd9Sstevel@tonic-gate so = VTOSO(vp); 11847c478bd9Sstevel@tonic-gate /* sendfile not supported for SCTP */ 11857c478bd9Sstevel@tonic-gate if (so->so_protocol == IPPROTO_SCTP) { 11867c478bd9Sstevel@tonic-gate error = EPROTONOSUPPORT; 11877c478bd9Sstevel@tonic-gate goto err; 11887c478bd9Sstevel@tonic-gate } 11897c478bd9Sstevel@tonic-gate is_sock = B_TRUE; 11907c478bd9Sstevel@tonic-gate switch (so->so_family) { 11917c478bd9Sstevel@tonic-gate case AF_INET: 11927c478bd9Sstevel@tonic-gate case AF_INET6: 11937c478bd9Sstevel@tonic-gate /* 11947c478bd9Sstevel@tonic-gate * Make similar checks done in SOP_WRITE(). 11957c478bd9Sstevel@tonic-gate */ 11967c478bd9Sstevel@tonic-gate if (so->so_state & SS_CANTSENDMORE) { 11977c478bd9Sstevel@tonic-gate tsignal(curthread, SIGPIPE); 11987c478bd9Sstevel@tonic-gate error = EPIPE; 11997c478bd9Sstevel@tonic-gate goto err; 12007c478bd9Sstevel@tonic-gate } 12017c478bd9Sstevel@tonic-gate if (so->so_type != SOCK_STREAM) { 12027c478bd9Sstevel@tonic-gate error = EOPNOTSUPP; 12037c478bd9Sstevel@tonic-gate goto err; 12047c478bd9Sstevel@tonic-gate } 12057c478bd9Sstevel@tonic-gate 12067c478bd9Sstevel@tonic-gate if ((so->so_state & (SS_ISCONNECTED|SS_ISBOUND)) != 12077c478bd9Sstevel@tonic-gate (SS_ISCONNECTED|SS_ISBOUND)) { 12087c478bd9Sstevel@tonic-gate error = ENOTCONN; 12097c478bd9Sstevel@tonic-gate goto err; 12107c478bd9Sstevel@tonic-gate } 12117c478bd9Sstevel@tonic-gate 1212ff550d0eSmasputra if ((so->so_state & SS_DIRECT) && 1213c28749e9Skais (so->so_priv != NULL) && 1214c28749e9Skais (so->so_kssl_ctx == NULL)) { 12157c478bd9Sstevel@tonic-gate maxblk = ((tcp_t *)so->so_priv)->tcp_mss; 12167c478bd9Sstevel@tonic-gate } else { 12177c478bd9Sstevel@tonic-gate maxblk = (int)vp->v_stream->sd_maxblk; 12187c478bd9Sstevel@tonic-gate } 12197c478bd9Sstevel@tonic-gate break; 12207c478bd9Sstevel@tonic-gate default: 12217c478bd9Sstevel@tonic-gate error = EAFNOSUPPORT; 12227c478bd9Sstevel@tonic-gate goto err; 12237c478bd9Sstevel@tonic-gate } 12247c478bd9Sstevel@tonic-gate break; 12257c478bd9Sstevel@tonic-gate case VREG: 12267c478bd9Sstevel@tonic-gate break; 12277c478bd9Sstevel@tonic-gate default: 12287c478bd9Sstevel@tonic-gate error = EINVAL; 12297c478bd9Sstevel@tonic-gate goto err; 12307c478bd9Sstevel@tonic-gate } 12317c478bd9Sstevel@tonic-gate 12327c478bd9Sstevel@tonic-gate switch (opcode) { 12337c478bd9Sstevel@tonic-gate case SENDFILEV : 12347c478bd9Sstevel@tonic-gate break; 12357c478bd9Sstevel@tonic-gate #if defined(_SYSCALL32_IMPL) || defined(_ILP32) 12367c478bd9Sstevel@tonic-gate case SENDFILEV64 : 12377c478bd9Sstevel@tonic-gate return (sendvec64(fp, (struct ksendfilevec64 *)vec, sfvcnt, 12387c478bd9Sstevel@tonic-gate (size32_t *)xferred, fildes)); 12397c478bd9Sstevel@tonic-gate #endif 12407c478bd9Sstevel@tonic-gate default : 12417c478bd9Sstevel@tonic-gate error = ENOSYS; 12427c478bd9Sstevel@tonic-gate break; 12437c478bd9Sstevel@tonic-gate } 12447c478bd9Sstevel@tonic-gate 12457c478bd9Sstevel@tonic-gate (void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, NULL); 12467c478bd9Sstevel@tonic-gate copy_vec = vec; 12477c478bd9Sstevel@tonic-gate 12487c478bd9Sstevel@tonic-gate do { 12490a8433caSrshoaib total_size = 0; 12507c478bd9Sstevel@tonic-gate copy_cnt = MIN(sfvcnt, SEND_MAX_CHUNK); 12517c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 12527c478bd9Sstevel@tonic-gate /* 32-bit callers need to have their iovec expanded. */ 12537c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_ILP32) { 12547c478bd9Sstevel@tonic-gate if (copyin(copy_vec, sfv32, 12557c478bd9Sstevel@tonic-gate copy_cnt * sizeof (ksendfilevec32_t))) { 12567c478bd9Sstevel@tonic-gate error = EFAULT; 12577c478bd9Sstevel@tonic-gate break; 12587c478bd9Sstevel@tonic-gate } 12597c478bd9Sstevel@tonic-gate 12607c478bd9Sstevel@tonic-gate for (i = 0; i < copy_cnt; i++) { 12617c478bd9Sstevel@tonic-gate sfv[i].sfv_fd = sfv32[i].sfv_fd; 12627c478bd9Sstevel@tonic-gate sfv[i].sfv_off = 12637c478bd9Sstevel@tonic-gate (off_t)(uint32_t)sfv32[i].sfv_off; 12647c478bd9Sstevel@tonic-gate sfv[i].sfv_len = (size_t)sfv32[i].sfv_len; 12657c478bd9Sstevel@tonic-gate total_size += sfv[i].sfv_len; 12667c478bd9Sstevel@tonic-gate sfv[i].sfv_flag = sfv32[i].sfv_flag; 12677c478bd9Sstevel@tonic-gate } 12687c478bd9Sstevel@tonic-gate } else { 12697c478bd9Sstevel@tonic-gate #endif 12707c478bd9Sstevel@tonic-gate if (copyin(copy_vec, sfv, 12717c478bd9Sstevel@tonic-gate copy_cnt * sizeof (sendfilevec_t))) { 12727c478bd9Sstevel@tonic-gate error = EFAULT; 12737c478bd9Sstevel@tonic-gate break; 12747c478bd9Sstevel@tonic-gate } 12757c478bd9Sstevel@tonic-gate 12767c478bd9Sstevel@tonic-gate for (i = 0; i < copy_cnt; i++) { 12777c478bd9Sstevel@tonic-gate total_size += sfv[i].sfv_len; 12787c478bd9Sstevel@tonic-gate } 12797c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 12807c478bd9Sstevel@tonic-gate } 12817c478bd9Sstevel@tonic-gate #endif 12827c478bd9Sstevel@tonic-gate 12837c478bd9Sstevel@tonic-gate /* 12847c478bd9Sstevel@tonic-gate * The task between deciding to use sendvec_small_chunk 12857c478bd9Sstevel@tonic-gate * and sendvec_chunk is dependant on multiple things: 12867c478bd9Sstevel@tonic-gate * 12877c478bd9Sstevel@tonic-gate * i) latency is important for smaller files. So if the 12887c478bd9Sstevel@tonic-gate * data is smaller than 'tcp_slow_start_initial' times 12897c478bd9Sstevel@tonic-gate * maxblk, then use sendvec_small_chunk which creates 12907c478bd9Sstevel@tonic-gate * maxblk size mblks and chains then together and sends 12917c478bd9Sstevel@tonic-gate * them to TCP in one shot. It also leaves 'wroff' size 12927c478bd9Sstevel@tonic-gate * space for the headers in each mblk. 12937c478bd9Sstevel@tonic-gate * 12947c478bd9Sstevel@tonic-gate * ii) for total size bigger than 'tcp_slow_start_initial' 12957c478bd9Sstevel@tonic-gate * time maxblk, its probably real file data which is 12967c478bd9Sstevel@tonic-gate * dominating. So its better to use sendvec_chunk because 12977c478bd9Sstevel@tonic-gate * performance goes to dog if we don't do pagesize reads. 12987c478bd9Sstevel@tonic-gate * sendvec_chunk will do pagesize reads and write them 12997c478bd9Sstevel@tonic-gate * in pagesize mblks to TCP. 13007c478bd9Sstevel@tonic-gate * 13017c478bd9Sstevel@tonic-gate * Side Notes: A write to file has not been optimized. 13027c478bd9Sstevel@tonic-gate * Future zero copy code will plugin into sendvec_chunk 13037c478bd9Sstevel@tonic-gate * only because doing zero copy for files smaller then 13047c478bd9Sstevel@tonic-gate * pagesize is useless. 13057c478bd9Sstevel@tonic-gate * 13067c478bd9Sstevel@tonic-gate * Note, if socket has NL7C enabled then call NL7C's 13072c9e429eSbrutus * senfilev() function to consume the sfv[]. 13087c478bd9Sstevel@tonic-gate */ 13097c478bd9Sstevel@tonic-gate if (is_sock) { 13107c478bd9Sstevel@tonic-gate switch (so->so_family) { 13117c478bd9Sstevel@tonic-gate case AF_INET: 13127c478bd9Sstevel@tonic-gate case AF_INET6: 13132c9e429eSbrutus if (so->so_nl7c_flags != 0) 13142c9e429eSbrutus error = nl7c_sendfilev(so, &fileoff, 13152c9e429eSbrutus sfv, copy_cnt, &count); 13162c9e429eSbrutus else if (total_size <= (4 * maxblk)) 13177c478bd9Sstevel@tonic-gate error = sendvec_small_chunk(fp, 13187c478bd9Sstevel@tonic-gate &fileoff, sfv, copy_cnt, 13197c478bd9Sstevel@tonic-gate total_size, maxblk, &count); 13207c478bd9Sstevel@tonic-gate else 13217c478bd9Sstevel@tonic-gate error = sendvec_chunk(fp, &fileoff, 13227c478bd9Sstevel@tonic-gate sfv, copy_cnt, &count); 13237c478bd9Sstevel@tonic-gate break; 13247c478bd9Sstevel@tonic-gate } 13257c478bd9Sstevel@tonic-gate } else { 13267c478bd9Sstevel@tonic-gate ASSERT(vp->v_type == VREG); 13277c478bd9Sstevel@tonic-gate error = sendvec_chunk(fp, &fileoff, sfv, copy_cnt, 13287c478bd9Sstevel@tonic-gate &count); 13297c478bd9Sstevel@tonic-gate } 13307c478bd9Sstevel@tonic-gate 13317c478bd9Sstevel@tonic-gate 13327c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 13337c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_ILP32) 13347c478bd9Sstevel@tonic-gate copy_vec = (const struct sendfilevec *)((char *)copy_vec + 13357c478bd9Sstevel@tonic-gate (copy_cnt * sizeof (ksendfilevec32_t))); 13367c478bd9Sstevel@tonic-gate else 13377c478bd9Sstevel@tonic-gate #endif 13387c478bd9Sstevel@tonic-gate copy_vec += copy_cnt; 13397c478bd9Sstevel@tonic-gate sfvcnt -= copy_cnt; 13407c478bd9Sstevel@tonic-gate } while (sfvcnt > 0); 13417c478bd9Sstevel@tonic-gate 13427c478bd9Sstevel@tonic-gate if (vp->v_type == VREG) 13437c478bd9Sstevel@tonic-gate fp->f_offset += count; 13447c478bd9Sstevel@tonic-gate 13457c478bd9Sstevel@tonic-gate 13467c478bd9Sstevel@tonic-gate VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, NULL); 13477c478bd9Sstevel@tonic-gate 13487c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 13497c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_ILP32) { 13507c478bd9Sstevel@tonic-gate ssize32_t count32 = (ssize32_t)count; 13517c478bd9Sstevel@tonic-gate if (copyout(&count32, xferred, sizeof (count32))) 13527c478bd9Sstevel@tonic-gate error = EFAULT; 13537c478bd9Sstevel@tonic-gate releasef(fildes); 13547c478bd9Sstevel@tonic-gate if (error != 0) 13557c478bd9Sstevel@tonic-gate return (set_errno(error)); 13567c478bd9Sstevel@tonic-gate return (count32); 13577c478bd9Sstevel@tonic-gate } 13587c478bd9Sstevel@tonic-gate #endif 13597c478bd9Sstevel@tonic-gate if (copyout(&count, xferred, sizeof (count))) 13607c478bd9Sstevel@tonic-gate error = EFAULT; 13617c478bd9Sstevel@tonic-gate releasef(fildes); 13627c478bd9Sstevel@tonic-gate if (error != 0) 13637c478bd9Sstevel@tonic-gate return (set_errno(error)); 13647c478bd9Sstevel@tonic-gate return (count); 13657c478bd9Sstevel@tonic-gate err: 13667c478bd9Sstevel@tonic-gate ASSERT(error != 0); 13677c478bd9Sstevel@tonic-gate releasef(fildes); 13687c478bd9Sstevel@tonic-gate return (set_errno(error)); 13697c478bd9Sstevel@tonic-gate } 1370